infra-kit 0.1.128 → 0.1.130

package/src/dev/serverless-local-run.ts

@@ -1,329 +0,0 @@
-import { Logger } from '@aws-lambda-powertools/logger'
-import type { APIGatewayProxyEvent, APIGatewayProxyEventQueryStringParameters, Context } from 'aws-lambda'
-import fastify from 'fastify'
-import * as fs from 'node:fs'
-import type { Server } from 'node:http'
-import * as path from 'node:path'
-import process from 'node:process'
-import { pathToFileURL } from 'node:url'
-import { parse as parseYaml } from 'yaml'
-
-import type { ILogger } from './interfaces.js'
-
-export interface IServerConfig {
-  controllersPath: string
-  prefixUrl?: string
-  port: number
-  /** App folder name, surfaced by the `/__health` endpoint. Optional. */
-  appName?: string
-}
-
-type HandlerResult = Promise<{ body: string; headers: Record<string, string>; statusCode: number }>
-
-/** Default simulated Lambda timeout; overridable via `DEV_SERVER_TIMEOUT_MS`. */
-const DEFAULT_LAMBDA_TIMEOUT_MS = 30_000
-
-/** Resolve the simulated Lambda timeout (ms), honoring `DEV_SERVER_TIMEOUT_MS` when it parses. */
-const resolveLambdaTimeoutMs = (): number => {
-  const raw = Number.parseInt(process.env.DEV_SERVER_TIMEOUT_MS ?? '', 10)
-
-  return Number.isNaN(raw) ? DEFAULT_LAMBDA_TIMEOUT_MS : raw
-}
-
-/**
- * Whether to emit a one-line `<method> <url> → <status> <ms>ms` log per request.
- * Off by default; opt in with `DEV_SERVER_REQUEST_LOG=1` (kept out of the Powertools
- * JSON logger so the line stays terminal-readable). Mirrors the env-reader precedent
- * of {@link resolveLambdaTimeoutMs}.
- */
-const isRequestLogEnabled = (): boolean => {
-  return process.env.DEV_SERVER_REQUEST_LOG === '1'
-}
-
-export class ServerlessLocalRun {
-  /** Busts Node ESM `import()` cache on each new server instance (watch restart). */
-  private readonly importCacheBust: string
-  private readonly logger: Logger
-  private readonly server: ReturnType<typeof fastify>
-  private readonly controllers: Record<
-    string,
-    {
-      action: Record<string, (event: APIGatewayProxyEvent, ctx: Context, log: ILogger) => HandlerResult>
-      handler: string
-    }
-  > = {}
-
-  /** `method urlAction` keys reserved synchronously, so duplicates are caught before any async import. */
-  private readonly registeredRouteKeys = new Set<string>()
-
-  constructor(private readonly serverConfig: IServerConfig) {
-    this.importCacheBust = `${Date.now()}`
-    this.logger = new Logger({ serviceName: 'LocalServer', logLevel: 'DEBUG' })
-    this.serverConfig.prefixUrl = this.serverConfig.prefixUrl ?? ''
-    this.server = fastify({ logger: false })
-
-    // Add CORS support for local development
-    this.server.addHook(
-      'onRequest',
-      async (
-        request: { method: string },
-        reply: { header: (k: string, v: string) => unknown; status: (n: number) => { send: () => void } },
-      ) => {
-        reply.header('Access-Control-Allow-Origin', '*')
-        reply.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS')
-        reply.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With')
-
-        // Handle preflight OPTIONS requests
-        if (request.method === 'OPTIONS') {
-          reply.status(204).send()
-        }
-      },
-    )
-
-    // Opt-in per-request log line (raw stdout, not the Powertools JSON logger) so live
-    // traffic is visible in the dev terminal. Off unless DEV_SERVER_REQUEST_LOG=1.
-    if (isRequestLogEnabled()) {
-      this.server.addHook(
-        'onResponse',
-        async (request: { method: string; url: string }, reply: { statusCode: number; elapsedTime: number }) => {
-          const ms = Math.round(reply.elapsedTime)
-
-          process.stdout.write(`${request.method} ${request.url} → ${reply.statusCode} ${ms}ms\n`)
-        },
-      )
-    }
-  }
-
-  /**
-   * The registered `METHOD /path` route keys (sorted). Excludes the internal
-   * `/__health` liveness route, which is registered outside {@link defineRoute} and
-   * never added to {@link registeredRouteKeys}. Used by the runner's startup route dump.
-   */
-  public getRegisteredRoutes(): string[] {
-    return [...this.registeredRouteKeys].sort()
-  }
-
-  public async start(): Promise<void> {
-    this.registerHealthRoute()
-
-    await Promise.all(this.loadRoutes())
-
-    await this.server.listen({ port: this.serverConfig.port, host: '127.0.0.1' })
-
-    this.logger.info(`Server listening on http://127.0.0.1:${this.serverConfig.port}`, {
-      address: `http://127.0.0.1:${this.serverConfig.port}`,
-    })
-  }
-
-  /** Close the server (for watch/restart). */
-  public async close(): Promise<void> {
-    const raw = this.server.server as Server
-
-    if (typeof raw.closeAllConnections === 'function') {
-      raw.closeAllConnections()
-    }
-    await this.server.close()
-  }
-
-  /**
-   * Register a fixed `GET /__health` liveness route returning 200. The path is
-   * unprefixed (serverless.yml routes carry the `prefixUrl`, e.g. `/api/v1/...`),
-   * so it never collides with a handler route.
-   */
-  private registerHealthRoute(): void {
-    this.server.route({
-      method: 'GET',
-      url: '/__health',
-      handler: (_request: unknown, reply: { code: (n: number) => { send: (body: unknown) => void } }) => {
-        return reply.code(200).send({
-          status: 'ok',
-          app: this.serverConfig.appName ?? null,
-          port: this.serverConfig.port,
-        })
-      },
-    })
-  }
-
-  private loadRoutes(): Promise<void>[] {
-    const serverlessYmlPath = path.join(this.serverConfig.controllersPath, 'serverless.yml')
-    const fileContents = fs.readFileSync(serverlessYmlPath, 'utf8')
-    const data = parseYaml(fileContents) as {
-      functions: Record<string, { events?: Array<{ http?: { method: string; path: string } }>; handler?: string }>
-    }
-    const p: Promise<void>[] = []
-
-    if (!data?.functions) return p
-
-    for (const [funcName, funcDef] of Object.entries(data.functions)) {
-      if (!funcDef?.events?.length) continue
-      for (const element of funcDef.events) {
-        const http = element?.http
-
-        if (!http) continue
-        this.logger.debug(`Registering route: ${http.method} /${http.path} -> ${funcName}`)
-        p.push(this.defineRoute(http, funcDef))
-      }
-    }
-
-    return p
-  }
-
-  private async defineRoute(http: { method: string; path: string }, funcDef: { handler?: string }): Promise<void> {
-    let url = http.path.toString()
-
-    url = url.replaceAll('{', ':').replaceAll('}', '')
-
-    let urlAction = path.posix.join(this.serverConfig.prefixUrl ?? '', url)
-
-    urlAction = urlAction[0] === '/' ? urlAction : `/${urlAction}`
-
-    const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']
-    const method = String(http.method).toUpperCase()
-
-    if (!validMethods.includes(method)) {
-      throw new Error(`Invalid HTTP method: "${http.method}" for URL: ${urlAction}`)
-    }
-
-    // Key on method + path: two events can share a path but differ by method (e.g. GET/POST /users),
-    // so keying on the path alone would let one handler overwrite the other. Reserve the key
-    // synchronously (before the first `await`) so concurrent route loads detect a true duplicate.
-    const routeKey = `${method} ${urlAction}`
-
-    if (this.registeredRouteKeys.has(routeKey)) {
-      throw new Error(`Duplicate route: ${routeKey}`)
-    }
-    this.registeredRouteKeys.add(routeKey)
-
-    const handlerStr = funcDef.handler ?? ''
-    const parts = handlerStr.split('.')
-    const filepath = parts[0] ?? ''
-    const handler = parts[1] ?? ''
-
-    const controllerPath = path.join(this.serverConfig.controllersPath, `${filepath}.js`)
-    const fileUrl = pathToFileURL(controllerPath)
-
-    // Search params bust Node's ESM import cache so watch rebuilds load new `dist` output.
-    fileUrl.searchParams.set('v', this.importCacheBust)
-    const action = (await import(fileUrl.href)) as Record<
-      string,
-      (event: APIGatewayProxyEvent, ctx: Context, log: ILogger) => HandlerResult
-    >
-
-    this.controllers[routeKey] = { action, handler }
-
-    const traceLogger = this.logger.createChild({ serviceName: 'RequestLogger' })
-
-    this.logger.debug(`Adding fastify route: ${method} ${urlAction}`)
-
-    this.server.route({
-      method: method as 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS',
-      url: urlAction,
-      handler: async (
-        request: { body?: unknown; query?: unknown; params?: unknown; headers?: unknown },
-        reply: {
-          headers: (h: Record<string, string>) => unknown
-          code: (n: number) => { send: (body: unknown) => void }
-        },
-      ) => {
-        const controller = this.controllers[routeKey]
-
-        if (!controller) throw new Error(`No controller for ${routeKey}`)
-        const handlerFn = controller.action[controller.handler]
-
-        if (!handlerFn) throw new Error(`No handler ${controller.handler} for ${urlAction}`)
-        const retVal = await handlerFn(
-          this.getEventObj(request.body, request.query, request.params, request.headers, method, urlAction),
-          this.getContext(),
-          traceLogger,
-        )
-        const responseBody = JSON.parse(retVal.body)
-
-        reply.headers(retVal.headers ?? {})
-
-        return reply.code(retVal?.statusCode ?? 500).send(responseBody)
-      },
-    })
-
-    this.logger.debug(`Route added successfully: ${method} ${urlAction}`)
-  }
-
-  private getEventObj(
-    requestBody?: unknown,
-    queryParams?: unknown,
-    pathParameters?: unknown,
-    headers?: unknown,
-    httpMethod = '',
-    path = '',
-  ): APIGatewayProxyEvent {
-    const retVal = {
-      body: requestBody ? JSON.stringify(requestBody) : null,
-      headers: (headers ?? {}) as APIGatewayProxyEvent['headers'],
-      multiValueHeaders: {},
-      httpMethod,
-      isBase64Encoded: false,
-      path,
-      pathParameters: pathParameters ?? null,
-      queryStringParameters: (queryParams as APIGatewayProxyEventQueryStringParameters) ?? null,
-      multiValueQueryStringParameters: null,
-      stageVariables: null,
-      requestContext: {
-        accountId: '',
-        apiId: '',
-        authorizer: undefined,
-        protocol: '',
-        httpMethod,
-        identity: {
-          accessKey: null,
-          accountId: null,
-          apiKey: null,
-          apiKeyId: null,
-          caller: null,
-          clientCert: null,
-          cognitoAuthenticationProvider: null,
-          cognitoAuthenticationType: null,
-          cognitoIdentityId: null,
-          cognitoIdentityPoolId: null,
-          principalOrgId: null,
-          sourceIp: 'devIp',
-          user: null,
-          userAgent: null,
-          userArn: null,
-        },
-        path,
-        stage: '',
-        requestId: '',
-        requestTimeEpoch: 0,
-        resourceId: '',
-        resourcePath: path,
-      },
-      resource: path,
-    }
-
-    ;(retVal as APIGatewayProxyEvent & { source: string }).source = 'aws.events'
-
-    return retVal as APIGatewayProxyEvent
-  }
-
-  private getContext(): Context {
-    const startTime = Date.now()
-    const timeoutMs = resolveLambdaTimeoutMs()
-    const datePart = new Date().toISOString().split('T')[0] ?? ''
-
-    return {
-      callbackWaitsForEmptyEventLoop: false,
-      functionName: 'local-dev',
-      functionVersion: '1.0.0',
-      invokedFunctionArn: 'arn:aws:lambda:local:000000000000:function:local-dev',
-      memoryLimitInMB: '1024',
-      awsRequestId: `local-${Date.now()}`,
-      logGroupName: '/aws/lambda/local-dev',
-      logStreamName: `${datePart}/local`,
-      getRemainingTimeInMillis: (): number => {
-        return Math.max(0, timeoutMs - (Date.now() - startTime))
-      },
-      done: (_error?: Error, _result?: unknown): void => {},
-      fail: (_error: string | Error): void => {},
-      succeed: (_messageOrObject: unknown): void => {},
-    }
-  }
-}

package/src/dev/turbo-watch.ts

@@ -1,62 +0,0 @@
-/*
- * `pnpm` is resolved from PATH — the same trust posture as the rest of the dev-server, which
- * already shells out to `pnpm exec turbo …`; the args are fixed literals plus discovered package
- * names, never shell-interpolated. Matches the file-level disable in `scripts/build.js`.
- */
-/* eslint-disable sonarjs/no-os-command-from-path */
-/**
- * `turbo watch build` engine for `infra-kit dev --watch`.
- *
- * Spawns ONE long-lived `turbo watch build` child that owns incremental rebuilds and
- * dependency-graph fan-out. Its stdout is teed to the runner log but NEVER parsed for
- * control flow: piped `turbo watch` block-buffers stdout and emits no per-task completion
- * marker for `tsc -b` tasks, so the dev-server derives "a build finished" from watching
- * `dist/` output instead (see {@link file://./dev-server.ts} `setupWatch`).
- *
- * The child is a 5-deep tree (`sh → pnpm → node → turbo → native binary`); killing the
- * wrapper PID orphans the rest. So it is spawned `detached` (its own process group) and
- * torn down with a process-GROUP signal — verified to fully reap the tree.
- */
-import { spawn } from 'node:child_process'
-import * as fs from 'node:fs'
-
-import { superviseChild } from './managed-child.js'
-import type { ManagedChild } from './managed-child.js'
-
-/** Handle to the running `turbo watch` child; `kill()` reaps the whole process group. */
-export type TurboWatchHandle = ManagedChild
-
-/** Injectable spawn seam so tests run the orchestrator without a real turbo child. */
-export type TurboWatchFactory = (opts: TurboWatchOptions) => TurboWatchHandle
-
-export interface TurboWatchOptions {
-  /** App package names; each becomes a `--filter=...<pkg>` (dependency-inclusive) arg. */
-  packageNames: string[]
-  /** Consumer repo cwd the child runs in (turbo resolves the consumer's own pin here). */
-  cwd: string
-  /** Runner log file; the child's stdout+stderr are appended to it. */
-  logFile: string
-}
-
-/**
- * Default factory: spawn `pnpm exec turbo watch build --filter=...<pkg> ... --continue=dependencies-successful
- * --env-mode=loose` detached, tee output to `logFile`, and reap the process group on `kill()`.
- *
- * `--filter=...<pkg>` (the leading `...`) includes each app's dependencies, so editing a
- * shared lib triggers a rebuild. `--continue=dependencies-successful` keeps the watcher
- * alive when one package fails to compile, so a shared-lib type error never tears down the
- * whole engine and the last-good `dist/` keeps serving.
- */
-export const defaultTurboWatchFactory: TurboWatchFactory = ({ packageNames, cwd, logFile }) => {
-  const filters = packageNames.map((name) => {
-    return `--filter=...${name}`
-  })
-  const out = fs.openSync(logFile, 'a')
-  const child = spawn(
-    'pnpm',
-    ['exec', 'turbo', 'watch', 'build', ...filters, '--continue=dependencies-successful', '--env-mode=loose'],
-    { cwd, detached: true, stdio: ['ignore', out, out] },
-  )
-
-  return superviseChild(child)
-}

package/src/dev/ui-dev.ts

@@ -1,62 +0,0 @@
-/*
- * `pnpm` is resolved from PATH — same trust posture as the rest of the dev-server (which already
- * shells out to `pnpm exec turbo …`); args are fixed literals plus discovered package names, never
- * shell-interpolated. Matches the file-level disable in `scripts/build.js`.
- */
-/* eslint-disable sonarjs/no-os-command-from-path */
-/**
- * Frontend dev engine for `infra-kit dev --ui`.
- *
- * Delegates FE to ONE `turbo run dev` child (turbo owns the `dev` fan-out, `^build` ordering
- * and concurrency) rather than infra-kit spawning each framework itself — the same delegation
- * choice already made for builds via `turbo watch`. infra-kit treats UIs opaquely: it runs their
- * `dev` script (vite/vike/astro/…) and never encodes per-framework knowledge.
- *
- * Unlike the `turbo watch` child, this one's stdio is INHERITED — the framework dev servers own
- * their own TTY output (HMR overlays, URLs, spinners), so it streams raw to the terminal below the
- * BE server table rather than being teed into the runner log (which would corrupt it with ANSI).
- *
- * Detached → its own process group; reaped as a group (SIGTERM→SIGKILL) via {@link superviseChild}.
- */
-import { spawn } from 'node:child_process'
-
-import { superviseChild } from './managed-child.js'
-import type { ManagedChild } from './managed-child.js'
-
-/** Handle to the running `turbo run dev` child; `kill()` reaps the whole process group. */
-export type UiDevHandle = ManagedChild
-
-/** Injectable spawn seam so tests run the orchestrator without a real turbo child. */
-export type UiDevFactory = (opts: UiDevOptions) => UiDevHandle
-
-export interface UiDevOptions {
-  /** UI app package names; each becomes an exact `--filter=<pkg>` (turbo runs its `dev` task). */
-  packageNames: string[]
-  /** Consumer repo cwd the child runs in. */
-  cwd: string
-  /**
-   * Concurrency cap. Must be ≥ the number of selected UI `dev` tasks (they're persistent) —
-   * turbo hard-errors when persistent tasks exceed concurrency (default 10).
-   */
-  concurrency: number
-}
-
-/**
- * Default factory: spawn `pnpm exec turbo run dev --filter=<pkg> … --concurrency=N --env-mode=loose`
- * detached, streaming to the parent terminal, and reap the process group on `kill()`.
- *
- * Exact `--filter=<pkg>` (no `...`) selects only the UI packages, so an API app that also defines a
- * `dev` task is never picked up.
- */
-export const defaultUiDevFactory: UiDevFactory = ({ packageNames, cwd, concurrency }) => {
-  const filters = packageNames.map((name) => {
-    return `--filter=${name}`
-  })
-  const child = spawn(
-    'pnpm',
-    ['exec', 'turbo', 'run', 'dev', ...filters, `--concurrency=${concurrency}`, '--env-mode=loose'],
-    { cwd, detached: true, stdio: ['ignore', 'inherit', 'inherit'] },
-  )
-
-  return superviseChild(child)
-}