@pikku/core 0.12.56 → 0.12.57

package/src/dev/reload-meta.test.ts

@@ -0,0 +1,154 @@
+import { describe, test, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import { pikkuState, resetPikkuState } from '../pikku-state.js'
+import { getSchema } from '../schema.js'
+import { reloadGeneratedMeta } from './reload-meta.js'
+
+const createMockLogger = () => {
+  const logs: Array<{ level: string; message: string }> = []
+  return {
+    info: (msg: string) => logs.push({ level: 'info', message: String(msg) }),
+    warn: (msg: string) => logs.push({ level: 'warn', message: String(msg) }),
+    error: (msg: string | Error) =>
+      logs.push({
+        level: 'error',
+        message: msg instanceof Error ? msg.message : String(msg),
+      }),
+    debug: (msg: string) => logs.push({ level: 'debug', message: String(msg) }),
+    getLogs: () => logs,
+    setLevel: () => {},
+  }
+}
+
+const compiled: string[] = []
+const mockSchemaService = {
+  compileSchema: (name: string, _value: any) => {
+    compiled.push(name)
+  },
+  validateSchema: () => {},
+  getSchemaNames: () => new Set(compiled),
+  getSchemaKeys: () => [],
+} as any
+
+describe('reloadGeneratedMeta', { concurrency: false }, () => {
+  let tmpDir: string
+  let mockLogger: ReturnType<typeof createMockLogger>
+
+  beforeEach(async () => {
+    resetPikkuState()
+    compiled.length = 0
+    tmpDir = await mkdtemp(join(tmpdir(), 'pikku-reload-meta-test-'))
+    mockLogger = createMockLogger()
+  })
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('reads generated meta json into pikku state', async () => {
+    await mkdir(join(tmpDir, 'function'), { recursive: true })
+    await mkdir(join(tmpDir, 'rpc'), { recursive: true })
+    await writeFile(
+      join(tmpDir, 'function/pikku-functions-meta.gen.json'),
+      JSON.stringify({
+        newFunc: { pikkuFuncId: 'newFunc', inputSchemaName: 'NewFuncInput' },
+      })
+    )
+    await writeFile(
+      join(tmpDir, 'rpc/pikku-rpc-wirings-meta.internal.gen.json'),
+      JSON.stringify({ newFunc: 'newFunc' })
+    )
+
+    await reloadGeneratedMeta({
+      pikkuDir: tmpDir,
+      logger: mockLogger,
+      schemaService: mockSchemaService,
+    })
+
+    const functionsMeta = pikkuState(null, 'function', 'meta') as any
+    assert.equal(functionsMeta.newFunc.pikkuFuncId, 'newFunc')
+    const rpcMeta = pikkuState(null, 'rpc', 'meta') as any
+    assert.equal(rpcMeta.newFunc, 'newFunc')
+  })
+
+  test('preserves runtime-registered internals (workflow orchestrator) across reload', async () => {
+    // The workflow service registers these at init; they are never in the
+    // generated JSON, so the reload must merge — not replace — the meta maps.
+    pikkuState(null, 'function', 'meta', {
+      pikkuWorkflowOrchestrator: { pikkuFuncId: 'pikkuWorkflowOrchestrator' },
+    })
+    pikkuState(null, 'queue', 'meta', {
+      'pikku-workflow-orchestrator': {
+        pikkuFuncId: 'pikkuWorkflowOrchestrator',
+        name: 'pikku-workflow-orchestrator',
+      },
+    })
+
+    await mkdir(join(tmpDir, 'function'), { recursive: true })
+    await mkdir(join(tmpDir, 'queue'), { recursive: true })
+    await writeFile(
+      join(tmpDir, 'function/pikku-functions-meta.gen.json'),
+      JSON.stringify({ userFunc: { pikkuFuncId: 'userFunc' } })
+    )
+    await writeFile(
+      join(tmpDir, 'queue/pikku-queue-workers-wirings-meta.gen.json'),
+      JSON.stringify({ userQueue: { pikkuFuncId: 'userFunc', name: 'userQueue' } })
+    )
+
+    await reloadGeneratedMeta({
+      pikkuDir: tmpDir,
+      logger: mockLogger,
+      schemaService: mockSchemaService,
+    })
+
+    const functionsMeta = pikkuState(null, 'function', 'meta') as any
+    assert.equal(
+      functionsMeta.pikkuWorkflowOrchestrator?.pikkuFuncId,
+      'pikkuWorkflowOrchestrator',
+      'runtime-registered internal must survive the reload'
+    )
+    assert.equal(functionsMeta.userFunc?.pikkuFuncId, 'userFunc')
+    const queueMeta = pikkuState(null, 'queue', 'meta') as any
+    assert.equal(
+      queueMeta['pikku-workflow-orchestrator']?.pikkuFuncId,
+      'pikkuWorkflowOrchestrator'
+    )
+    assert.equal(queueMeta.userQueue?.name, 'userQueue')
+  })
+
+  test('re-adds generated json schemas and recompiles them', async () => {
+    const schemasDir = join(tmpDir, 'schemas', 'schemas')
+    await mkdir(schemasDir, { recursive: true })
+    await writeFile(
+      join(schemasDir, 'NewFuncInput.schema.json'),
+      JSON.stringify({ type: 'object', properties: { id: { type: 'string' } } })
+    )
+
+    await reloadGeneratedMeta({
+      pikkuDir: tmpDir,
+      logger: mockLogger,
+      schemaService: mockSchemaService,
+    })
+
+    const schema = getSchema('NewFuncInput') as any
+    assert.equal(schema.type, 'object')
+    assert.ok(
+      compiled.includes('NewFuncInput'),
+      'Schema should be recompiled after reload'
+    )
+  })
+
+  test('missing meta files and schemas dir are not an error', async () => {
+    await reloadGeneratedMeta({
+      pikkuDir: tmpDir,
+      logger: mockLogger,
+      schemaService: mockSchemaService,
+    })
+    const errors = mockLogger.getLogs().filter((l) => l.level === 'error')
+    assert.deepEqual(errors, [])
+  })
+})

package/src/dev/reload-meta.ts

@@ -0,0 +1,138 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+
+import { pikkuState } from '../pikku-state.js'
+import { addSchema, compileAllSchemas } from '../schema.js'
+import { clearMiddlewareCache } from '../middleware-runner.js'
+import { clearPermissionsCache } from '../permissions.js'
+import { clearChannelMiddlewareCache } from '../wirings/channel/channel-middleware-runner.js'
+import { httpRouter } from '../wirings/http/routers/http-router.js'
+import type { Logger } from '../services/logger.js'
+import type { SchemaService } from '../services/schema-service.js'
+
+export interface ReloadGeneratedMetaOptions {
+  /** The project's generated output directory (the CLI's resolved outDir). */
+  pikkuDir: string
+  logger: Logger
+  /** Used to recompile validators for changed schemas; falls back to the
+   *  schema service on the registered singleton services. */
+  schemaService?: SchemaService
+}
+
+const readJson = async (
+  logger: Logger,
+  file: string
+): Promise<any | undefined> => {
+  let raw: string
+  try {
+    raw = await readFile(file, 'utf-8')
+  } catch {
+    // The project doesn't use this wiring type — nothing generated.
+    return undefined
+  }
+  try {
+    return JSON.parse(raw)
+  } catch (err) {
+    logger.error(
+      `Hot-reload could not parse ${file}: ${err instanceof Error ? err.message : String(err)}`
+    )
+    return undefined
+  }
+}
+
+/**
+ * Re-reads the codegen output (wiring meta + JSON schemas) into the running
+ * process so new and changed functions become callable without a server
+ * restart. The generated `*-meta.gen.ts` files are plain
+ * `pikkuState(area, key, <json>)` side effects, but they cannot be
+ * re-imported after a dev-time codegen — the ESM cache pins both the wrapper
+ * and its JSON import — so this reads the JSON sources directly and applies
+ * the same state.
+ *
+ * Meant to be called by a dev-server watcher after each codegen pass. Routes
+ * registered by NEW `wireHTTP` files are not picked up (their modules were
+ * never imported); those still need a restart.
+ */
+export async function reloadGeneratedMeta(
+  options: ReloadGeneratedMetaOptions
+): Promise<void> {
+  const { pikkuDir, logger, schemaService } = options
+  const dir = resolve(pikkuDir)
+
+  const functionsMeta = await readJson(
+    logger,
+    join(dir, 'function/pikku-functions-meta.gen.json')
+  )
+  // Merge over the existing map, don't replace it: framework internals like
+  // pikkuWorkflowOrchestrator / the per-workflow queue workers are registered
+  // at service-init (pikku-workflow-service.ts), never in the generated JSON —
+  // a wholesale replace drops them and workflow jobs then fail with
+  // "Function meta not found: pikkuWorkflowOrchestrator".
+  if (functionsMeta) {
+    const existing = pikkuState(null, 'function', 'meta') ?? {}
+    pikkuState(null, 'function', 'meta', { ...existing, ...functionsMeta })
+  }
+
+  const httpMeta = await readJson(
+    logger,
+    join(dir, 'http/pikku-http-wirings-meta.gen.json')
+  )
+  if (httpMeta) pikkuState(null, 'http', 'meta', httpMeta)
+
+  const rpcMeta = await readJson(
+    logger,
+    join(dir, 'rpc/pikku-rpc-wirings-meta.internal.gen.json')
+  )
+  if (rpcMeta) pikkuState(null, 'rpc', 'meta', rpcMeta)
+
+  const queueMeta = await readJson(
+    logger,
+    join(dir, 'queue/pikku-queue-workers-wirings-meta.gen.json')
+  )
+  // Same reason as function meta: the workflow service adds its orchestrator /
+  // step queues (and wf-orchestrator-* / wf-step-* per-workflow queues) here at
+  // init, absent from the generated JSON — merge so they survive the reload.
+  if (queueMeta) {
+    const existing = pikkuState(null, 'queue', 'meta') ?? {}
+    pikkuState(null, 'queue', 'meta', { ...existing, ...queueMeta })
+  }
+
+  const agentMeta = await readJson(
+    logger,
+    join(dir, 'agent/pikku-agent-wirings-meta.gen.json')
+  )
+  if (agentMeta?.agentsMeta) {
+    pikkuState(null, 'agent', 'agentsMeta', agentMeta.agentsMeta)
+  }
+
+  // Generated JSON schemas: <outDir>/schemas/schemas/<Name>.schema.json.
+  // Re-adding replaces the map entry; the schema service recompiles any
+  // validator whose stored schema value no longer matches.
+  const schemasDir = join(dir, 'schemas', 'schemas')
+  let schemaFiles: string[] = []
+  try {
+    schemaFiles = await readdir(schemasDir)
+  } catch {
+    // No generated schemas — a schema-less project.
+  }
+  for (const file of schemaFiles) {
+    if (!file.endsWith('.schema.json')) continue
+    const schema = await readJson(logger, join(schemasDir, file))
+    if (schema) {
+      addSchema(file.slice(0, -'.schema.json'.length), schema)
+    }
+  }
+
+  clearMiddlewareCache()
+  clearPermissionsCache()
+  clearChannelMiddlewareCache()
+  httpRouter.reset()
+
+  try {
+    compileAllSchemas(logger, schemaService)
+  } catch (err) {
+    logger.error(
+      `Hot-reload schema recompilation failed: ${err instanceof Error ? err.message : String(err)}`
+    )
+  }
+}