@pikku/core 0.12.107 → 0.12.111

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

@@ -1,183 +0,0 @@
-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 { wireAddon } from '../wirings/addon/wire-addon.js'
-import { reloadGeneratedMeta, reconcileAddonRegistry } 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, [])
-  })
-})
-
-describe('reconcileAddonRegistry', { concurrency: false }, () => {
-  beforeEach(() => resetPikkuState())
-
-  test('drops addons the fresh generation no longer declares', () => {
-    wireAddon({ name: 'gmail', package: '@pikku/addon-gmail' })
-    wireAddon({ name: 'mandrill-e2e', package: '@pikku/addon-mandrill' })
-
-    // gmail is still wired in source; mandrill-e2e's *.addon.ts was deleted.
-    reconcileAddonRegistry(['gmail'])
-
-    const addons = pikkuState(null, 'addons', 'packages')
-    assert.ok(addons.has('gmail'), 'still-declared addon is kept')
-    assert.ok(!addons.has('mandrill-e2e'), 'deleted addon is pruned')
-  })
-
-  test('keeps every addon when all are still declared', () => {
-    wireAddon({ name: 'gmail', package: '@pikku/addon-gmail' })
-    wireAddon({ name: 'mailgun', package: '@pikku/addon-mailgun' })
-
-    reconcileAddonRegistry(['gmail', 'mailgun'])
-
-    const addons = pikkuState(null, 'addons', 'packages')
-    assert.equal(addons.size, 2)
-  })
-})

package/src/dev/reload-meta.ts

@@ -1,144 +0,0 @@
-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 codegen output (wiring meta + JSON schemas) into the running
- * process, so new and changed functions become callable without a restart.
- * 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.
- */
-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')
-  )
-  // knowledge: decisions/internals/core-hot-reload-merges-generated-meta-never-replaces-it.md
-  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')
-  )
-  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)
-  }
-
-  // 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)}`
-    )
-  }
-}
-
-/**
- * Prunes the live addon registry to the namespaces the current source still
- * declares. Hot reload only re-imports files that exist, so a deleted
- * `*.addon.ts` otherwise leaves its `wireAddon` entry stranded until a restart.
- *
- * `declaredNamespaces` is `inspectorState.rpc.wireAddonDeclarations.keys()`.
- */
-export function reconcileAddonRegistry(
-  declaredNamespaces: Iterable<string>,
-  logger?: Logger
-): void {
-  const declared = new Set(declaredNamespaces)
-  const addons = pikkuState(null, 'addons', 'packages')
-  for (const namespace of [...addons.keys()]) {
-    if (!declared.has(namespace)) {
-      addons.delete(namespace)
-      logger?.info(`• Removed unwired addon "${namespace}"`)
-    }
-  }
-}

package/src/ecosystem-tier-removed.test.ts

@@ -1,72 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { join, dirname, relative } from 'node:path'
-
-const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '../../..')
-
-const skipped = new Set([
-  'node_modules',
-  'dist',
-  '.pikku',
-  '.next',
-  'build',
-  '.git',
-  '.deploy',
-  'coverage',
-  // A worktree here carries its own copy of this file, which necessarily
-  // contains the specifier being scanned for — the guard would report itself.
-  '.claude',
-])
-
-const collectSourceFiles = (
-  directory: string,
-  out: string[] = []
-): string[] => {
-  for (const entry of readdirSync(directory, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      if (!skipped.has(entry.name)) {
-        collectSourceFiles(join(directory, entry.name), out)
-      }
-    } else if (/\.(ts|tsx|js|mjs|mts|cts)$/.test(entry.name)) {
-      out.push(join(directory, entry.name))
-    }
-  }
-  return out
-}
-
-/**
- * A stale compiled `.test.js` next to this file would otherwise read as an
- * offender of its own scan, which is how a sibling removal guard in this
- * directory reports a phantom failure on a dirty tree. Comparing paths with
- * the extension dropped excludes this file and its build artifacts without
- * excluding a neighbour that merely shares the prefix.
- */
-const withoutExtension = (file: string): string =>
-  file.replace(/\.(ts|tsx|js|mjs|mts|cts)$/, '')
-
-/**
- * The `@pikku/core/ecosystem/*` tier was deleted in favour of one door per
- * name. Nothing resolves those specifiers any more, but a dead one is easy to
- * miss: a type-only import is erased before it can fail at runtime, and the
- * service packages exclude `**\/*.test.ts` from their tsconfig, so neither the
- * test run nor `yarn tsc` reports it.
- */
-describe('the ecosystem entry-point tier is gone', () => {
-  test('no source file imports from @pikku/core/ecosystem', () => {
-    const self = withoutExtension(fileURLToPath(import.meta.url))
-    const offenders = collectSourceFiles(repoRoot)
-      .filter(
-        (file) =>
-          withoutExtension(file) !== self &&
-          /@pikku\/core\/ecosystem/.test(readFileSync(file, 'utf-8'))
-      )
-      .map((file) => relative(repoRoot, file))
-    assert.deepEqual(
-      offenders,
-      [],
-      `@pikku/core/ecosystem imports found in:\n${offenders.join('\n')}`
-    )
-  })
-})

package/src/env.ts

@@ -1 +0,0 @@
-export const isProduction = () => process.env.NODE_ENV === 'production'

package/src/errors/error-handler.ts

@@ -1,77 +0,0 @@
-import { pikkuState } from '../pikku-state.js'
-
-export class PikkuError extends Error {
-  constructor(message: string = 'An error occurred') {
-    super(message)
-    Object.setPrototypeOf(this, new.target.prototype)
-    this.name = new.target.name
-  }
-}
-
-/**
- * A `PikkuError`, or any error carrying `expected: true` — the marker that
- * survives serialization across a workflow step boundary and rehydration as a
- * plain `Error`. Callers log the message alone for these, the full stack for
- * everything else.
- *
- * @example snippet: isExpectedError
- */
-export const isExpectedError = (error: unknown): boolean =>
-  error instanceof PikkuError ||
-  (error as { expected?: unknown } | null)?.expected === true
-
-export interface ErrorDetails {
-  /** The HTTP status this error answers with, instead of a 500. */
-  status: number
-  /** What the caller is told. It leaves the process, so it must not name anything internal. */
-  message: string
-  /** The JSON-RPC code an MCP client is given, where the HTTP status has no equivalent. */
-  mcpCode?: number
-}
-
-export type PikkuErrorConstructor = new (...args: any[]) => Error
-
-/**
- * Registers one of your own error classes with the HTTP status and message it
- * should produce, so throwing it maps to a real response instead of a 500.
- *
- * @example snippet: addError
- */
-export const addError = (
-  error: any,
-  { status, message, mcpCode }: ErrorDetails
-) => {
-  pikkuState(null, 'misc', 'errors').set(
-    error,
-    mcpCode === undefined ? { status, message } : { status, message, mcpCode }
-  )
-}
-
-export const addErrors = (
-  errors: Array<[error: any, details: ErrorDetails]>
-) => {
-  errors.forEach((error) => {
-    addError(error[0], error[1])
-  })
-}
-
-export const getErrorResponse = (
-  error: Error
-): { status: number; message: string; mcpCode?: number } | undefined => {
-  const errors = pikkuState(null, 'misc', 'errors')
-
-  let ctor: unknown = (error as { constructor?: unknown } | null)?.constructor
-  while (typeof ctor === 'function' && ctor !== Object) {
-    const details = errors.get(ctor as PikkuErrorConstructor)
-    if (details) {
-      return details
-    }
-    ctor = Object.getPrototypeOf(ctor)
-  }
-
-  const name = (error as { constructor?: { name?: string } } | null)
-    ?.constructor?.name
-  return name
-    ? Array.from(errors.entries()).find(([e]) => e.name === name)?.[1]
-    : undefined
-}