cliCommandWrapper.ts

import { randomUUIDv7 } from 'node:crypto'
import { type ParseArgsOptionsConfig, parseArgs } from 'node:util'
import type { RequestContext } from '@lokalise/fastify-extras'
import {
  globalLogger,
  isError,
  resolveGlobalErrorLogObject,
  stringValueSerializer,
} from '@lokalise/node-core'
import { ENABLE_ALL } from 'opinionated-machine'
import pino from 'pino'
import z from 'zod/v4'
import { getApp } from '../../src/app.ts'
import type { Dependencies } from '../../src/infrastructure/CommonModule.ts'

const unwrapSchemaIfNeeded = (schema: z.Schema) =>
  schema instanceof z.ZodOptional || schema instanceof z.ZodNullable ? schema.unwrap() : schema

const resolveInputObjectSchema = (schema: z.Schema): z.ZodObject | undefined => {
  if (schema instanceof z.ZodObject) return schema
  // schemas with transforms/pipes define their CLI flags on the input side of the pipe
  if (schema instanceof z.ZodPipe) return resolveInputObjectSchema(schema.in as z.Schema)
  return undefined
}

const deriveParseArgsOptions = (schema: z.Schema): ParseArgsOptionsConfig | undefined => {
  const objectSchema = resolveInputObjectSchema(schema)
  if (!objectSchema) return undefined

  const options: ParseArgsOptionsConfig = {}
  for (const [key, fieldSchema] of Object.entries(objectSchema.shape as Record<string, z.Schema>)) {
    const unwrappedFieldSchema = unwrapSchemaIfNeeded(fieldSchema)

    const isMultiple = unwrappedFieldSchema instanceof z.ZodArray
    const elementSchema = isMultiple
      ? unwrapSchemaIfNeeded(unwrappedFieldSchema.element as z.ZodSchema)
      : unwrappedFieldSchema

    options[key] = {
      type: elementSchema instanceof z.ZodBoolean ? 'boolean' : 'string',
      multiple: isMultiple,
    }
  }

  return options
}

const getArgs = (argsSchema: z.Schema) => {
  const { values } = parseArgs({
    args: process.argv,
    strict: false,
    options: deriveParseArgsOptions(argsSchema),
  })

  return values
}

export type CliCommandLifecycle = {
  signal: AbortSignal
}

export type CliCommand<
  ArgsSchema extends z.Schema | undefined,
  Args = ArgsSchema extends z.Schema ? z.infer<ArgsSchema> : undefined,
> = (
  dependencies: Dependencies,
  requestContext: RequestContext,
  args: Args,
  lifecycle: CliCommandLifecycle,
) => Promise<void> | void

export const cliCommandWrapper = async <ArgsSchema extends z.Schema | undefined>(
  cliCommandName: string,
  command: CliCommand<ArgsSchema>,
  argsSchema?: ArgsSchema,
): Promise<void> => {
  let app: Awaited<ReturnType<typeof getApp>>
  try {
    app = await getApp({
      healthchecksEnabled: false,
      monitoringEnabled: false,
      periodicJobsEnabled: false,
      messageQueueConsumersEnabled: false,
      enqueuedJobWorkersEnabled: false,
      jobQueuesEnabled: ENABLE_ALL,
    })
  } catch (err) {
    globalLogger.error(resolveGlobalErrorLogObject(err), `Failed to start ${cliCommandName}`)
    return process.exit(1)
  }

  const requestId = randomUUIDv7()
  const reqContext: RequestContext = {
    reqId: requestId,
    logger: app.diContainer.cradle.logger.child({
      origin: cliCommandName,
      'x-request-id': requestId,
    }),
  }

  // The app-scoped abort signal is aborted by app.ts's gracefulShutdown handler
  // (only registered in non-dev). Commands can observe `lifecycle.signal.aborted`
  // and/or pass `lifecycle.signal` to any AbortSignal-aware API.
  //
  // The handler below must still await `commandDone` — abort is a notification,
  // not synchronization, so without this the plugin would call `app.close()`
  // while the command is still unwinding.
  const lifecycle: CliCommandLifecycle = {
    signal: app.diContainer.cradle.appAbortController.signal,
  }
  let resolveCommandDone!: () => void
  const commandDone = new Promise<void>((resolve) => {
    resolveCommandDone = resolve
  })
  if (typeof app.gracefulShutdown === 'function') {
    app.gracefulShutdown(async (signal) => {
      reqContext.logger.warn({ signal }, 'Shutdown signal received, stopping after current step')
      await commandDone
    })
  }

  let args = undefined as ArgsSchema extends z.Schema ? z.infer<ArgsSchema> : undefined
  if (argsSchema) {
    const parseResult = argsSchema.safeParse(getArgs(argsSchema))
    if (!parseResult.success) {
      reqContext.logger.error(
        {
          errors: JSON.stringify(parseResult.error.issues),
        },
        'Invalid arguments',
      )
      await app.close()
      process.exit(1)
    }

    args = parseResult.data as ArgsSchema extends z.Schema ? z.infer<ArgsSchema> : undefined
  }

  let isSuccess = true
  try {
    await command(app.diContainer.cradle, reqContext, args, lifecycle)
  } catch (err) {
    isSuccess = false
    reqContext.logger.error(
      {
        error: isError(err) ? pino.stdSerializers.err(err) : stringValueSerializer(err),
      },
      'Error running command',
    )
  } finally {
    resolveCommandDone()
  }

  await app.close()
  process.exit(isSuccess ? 0 : 1)
}