#Node.js and containers

import { z } from 'zod'

// Every setting of the app, from the environment, checked at startup: a
// missing or invalid variable stops the process with an explicit message,
// instead of failing later on a request.
const Env = z.object({
  NODE_ENV: z
    .enum(['development', 'test', 'production'])
    .default('development'),
  PORT: z.coerce.number().int().min(0).max(65_535).default(3000),
  /** SQLite database file, created when missing. */
  DATABASE_PATH: z.string().min(1).default('data/tasks.db'),
  /** Public URL of the API, written in the tokens (`iss`). */
  PUBLIC_URL: z.url().optional(),
  /** RSA key pair (PEM); generated in `data/` in development. */
  JWT_PRIVATE_KEY: z.string().min(1).optional(),
  JWT_PUBLIC_KEY: z.string().min(1).optional(),
  /**
   * Redis: the queue of the events (BullMQ) and a shared cache. Without
   * it, the listeners run in the API process, and the cache lives in
   * memory.
   */
  REDIS_URL: z.url().optional(),
  /** Name of the BullMQ queue, shared by the API and the worker. */
  EVENTS_QUEUE: z.string().min(1).default('tasks-api-events'),
  /** SMTP server of the emails. Without it, they are printed. */
  SMTP_URL: z.url().optional(),
  MAIL_FROM: z.string().min(1).default('Tasks <noreply@example.com>'),
})

export type Config = ReturnType<typeof loadConfig>

/** Reads the configuration, or throws an error listing the problems. */
export const loadConfig = (
  env: Record<string, string | undefined> = process.env
) => {
  const result = Env.safeParse(env)
  if (!result.success) {
    throw new Error(`Invalid configuration:\n${z.prettifyError(result.error)}`)
  }
  const config = result.data
  return {
    ...config,
    production: config.NODE_ENV === 'production',
    publicUrl: config.PUBLIC_URL ?? `http://localhost:${config.PORT}`,
  }
}

/**
 * Checks the variables a process needs in production: the API and the
 * worker do not need the same ones.
 */
export const requireInProduction = (
  config: Config,
  names: readonly (keyof Config & Uppercase<string>)[]
) => {
  const missing = names.filter((name) => !config[name])
  if (config.production && missing.length > 0) {
    throw new Error(`Required in production: ${missing.join(', ')}.`)
  }
}

const config = loadConfig()
requireInProduction(config, ['PUBLIC_URL', 'JWT_PRIVATE_KEY', 'JWT_PUBLIC_KEY'])

// Entry point of the API: config → services → app → listen.
import { fastifyAdapter } from '@dotpress/adapter-fastify'
import { createConsoleLogger } from '@dotpress/core'
import { loadConfig, requireInProduction } from '../config.ts'
import { openDatabase } from '../db/database.ts'
import { loadKeys } from '../features/auth/keys.ts'
import { createNotifications } from '../features/notifications/listeners.ts'
import { createBus, createTransport } from '../services/bus.ts'
import { createCacheStore } from '../services/cache-store.ts'
import { createRepositories } from '../services/index.ts'
import { createAppMailer, createMailProvider } from '../services/mailer.ts'
import { createTasksApp } from './app.ts'

const config = loadConfig()
requireInProduction(config, [
  'PUBLIC_URL',
  'JWT_PRIVATE_KEY',
  'JWT_PUBLIC_KEY',
  // Without Redis, the API sends the emails itself.
  ...(config.REDIS_URL ? [] : (['SMTP_URL'] as const)),
])
const logger = createConsoleLogger()

// The services of this process, created once, closed on shutdown.
const repositories = createRepositories(openDatabase(config.DATABASE_PATH))
const cacheStore = await createCacheStore(config.REDIS_URL)
const mailProvider = createMailProvider(config)
const transport = createTransport(config)
if (transport.kind === 'memory') {
  logger.info('REDIS_URL is not set: the listeners run in this process')
} else if (mailProvider.name === 'console') {
  logger.info('SMTP_URL is not set: the worker prints the emails')
}

const app = await createTasksApp({
  adapter: fastifyAdapter(),
  repositories,
  keys: loadKeys(config),
  publicUrl: config.publicUrl,
  cacheStore: cacheStore.store,
  // The bus routes each event to its listeners, by name: with BullMQ, the
  // worker runs them; without, the in-memory queue of this process.
  events: createBus(
    transport,
    createNotifications({
      repositories,
      mailer: createAppMailer(mailProvider, config.MAIL_FROM),
    }),
    { logger }
  ),
  logger,
})
await app.listen(config.PORT)
logger.info(`Tasks API: ${config.publicUrl}`)
logger.info(`API reference: ${config.publicUrl}/docs`)

// Waits for pending requests, then closes the connections.
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
  process.once(signal, () => {
    void app
      .close()
      .then(() => transport.close())
      .then(() => cacheStore.close())
      .then(() => {
        mailProvider.close?.()
        repositories.db.close()
      })
  })
}

const healthRouter = createRouter()

healthRouter.defineRoute({
  path: '/health',
  meta: { summary: 'Health check', tags: ['health'] },
  handler: ({ services }) => {
    services.db.prepare('SELECT 1').get()
    return { status: 'ok' }
  },
})

import pino from 'pino'

const app = await createApp({ adapter, logger: pino() })