@humwick/server 0.130.0 → 0.130.2

package/node_modules/@humwick/kernel/openapi-init.ts

@@ -1,14 +0,0 @@
-// K1-6 — zod↔OpenAPI initialization, load-order-safe.
-//
-// `@hono/zod-openapi` runs `extendZodWithOpenApi(z)` as a load-time side effect, which patches zod's
-// factory functions so every schema built AFTERWARD carries an own `.openapi()` method. The derived
-// HTTP transport (`createHttpApp` → `registry.register(schema)`) calls `schema.openapi(refId)` on each
-// op's input/output schema, so a module whose schemas are built BEFORE the extension runs cannot be
-// mounted — its schemas silently lack `.openapi` and registration throws.
-//
-// A module (e.g. `control.ts`) builds its schemas at module-load time. Because `index.ts` re-exports
-// modules in source order, a module exported before `http-transport` would build its schemas before
-// the extension ran. Importing THIS module for its side effect as the very first thing `index.ts` does
-// runs the extension before any module schema is constructed, so every module's derived OpenAPI surface
-// works regardless of export order. Keep this import first in `index.ts`.
-import "@hono/zod-openapi";

package/node_modules/@humwick/kernel/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "@humwick/kernel",
-  "license": "PolyForm-Shield-1.0.0",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "files": [
-    "*.ts",
-    "!*.test.ts",
-    "LICENSE"
-  ],
-  "exports": {
-    ".": "./index.ts",
-    "./contract": "./contract.ts",
-    "./http-transport": "./http-transport.ts",
-    "./effects": "./effects.ts",
-    "./event-log": "./event-log.ts",
-    "./manifest-validation": "./manifest-validation.ts",
-    "./message-authority": "./message-authority.ts",
-    "./identity": "./identity.ts",
-    "./kernel-persistence": "./kernel-persistence.ts",
-    "./sqlite-kernel-persistence": "./sqlite-kernel-persistence.ts",
-    "./persistence": "./persistence.ts",
-    "./persistence-schema": "./persistence-schema.ts",
-    "./registry": "./registry.ts",
-    "./landing": "./landing.ts",
-    "./landing-incident": "./landing-incident.ts",
-    "./timers.pilot": "./timers.pilot.ts",
-    "./workflow.pilot": "./workflow.pilot.ts",
-    "./workflow-activation": "./workflow-activation.ts",
-    "./workflow-composition": "./workflow-composition.ts",
-    "./workflow-definition": "./workflow-definition.ts",
-    "./workflow-journal": "./workflow-journal.ts",
-    "./workflow-journal-codec": "./workflow-journal-codec.ts",
-    "./workflow-runtime": "./workflow-runtime.ts",
-    "./workflow-step-commit": "./workflow-step-commit.ts",
-    "./workflow-values": "./workflow-values.ts"
-  },
-  "dependencies": {
-    "@humwick/sdk": "0.2.135",
-    "@hono/zod-openapi": "^1.4.0",
-    "hono": "^4.12.0",
-    "zod": "^4.4.3",
-    "ajv": "^8.20.0",
-    "jsep": "^1.4.0"
-  }
-}

package/node_modules/@humwick/kernel/persistence-schema.ts

@@ -1,248 +0,0 @@
-import type { Database } from "bun:sqlite";
-import type * as z from "zod";
-import type { EntityDecl, ModuleDefinition, ModuleManifest } from "./contract";
-import type { KernelEntityCatalog, KernelModuleCatalog } from "./kernel-persistence";
-
-export type StorageKind = "text" | "integer" | "real" | "boolean" | "bigint" | "date" | "json";
-
-export interface EntityField {
-  readonly name: string;
-  readonly quoted: string;
-  readonly schema: z.ZodType;
-  readonly kind: StorageKind;
-  readonly nullable: boolean;
-}
-
-export interface EntityTable {
-  readonly moduleId: string;
-  readonly entityName: string;
-  readonly name: string;
-  readonly quoted: string;
-  readonly decl: EntityDecl;
-  readonly fields: readonly EntityField[];
-  readonly fieldByName: ReadonlyMap<string, EntityField>;
-  readonly key: EntityField;
-}
-
-type ZodDef = {
-  type?: string;
-  innerType?: z.ZodType;
-  out?: z.ZodType;
-  values?: readonly unknown[];
-  entries?: Readonly<Record<string, unknown>>;
-};
-
-function zodDef(schema: z.ZodType): ZodDef {
-  return (schema as unknown as { _zod: { def: ZodDef } })._zod.def;
-}
-
-function outputSchema(schema: z.ZodType): z.ZodType {
-  const def = zodDef(schema);
-  if (def.type === "pipe" && def.out) return outputSchema(def.out);
-  if (["optional", "nullable", "default", "prefault", "catch", "readonly", "nonoptional"].includes(def.type ?? "") && def.innerType) {
-    return outputSchema(def.innerType);
-  }
-  return schema;
-}
-
-function allValuesOfType(values: readonly unknown[] | undefined, type: string): boolean {
-  return !!values?.length && values.every((value) => typeof value === type);
-}
-
-function storageKind(schema: z.ZodType): StorageKind {
-  const output = outputSchema(schema);
-  const def = zodDef(output);
-  if (def.type === "string") return "text";
-  if (def.type === "number") {
-    return (output as unknown as { isInt?: boolean }).isInt ? "integer" : "real";
-  }
-  if (def.type === "boolean") return "boolean";
-  if (def.type === "bigint") return "bigint";
-  if (def.type === "date") return "date";
-  if (def.type === "literal") {
-    if (allValuesOfType(def.values, "string")) return "text";
-    if (allValuesOfType(def.values, "number")) return "real";
-    if (allValuesOfType(def.values, "boolean")) return "boolean";
-  }
-  if (def.type === "enum") {
-    const values = [...new Set(Object.values(def.entries ?? {}))];
-    if (allValuesOfType(values, "string")) return "text";
-    if (allValuesOfType(values, "number")) return "real";
-  }
-  return "json";
-}
-
-function allowsSqlNull(schema: z.ZodType): boolean {
-  const undefinedResult = schema.safeParse(undefined);
-  if (undefinedResult.success && undefinedResult.data === undefined) return true;
-  const nullResult = schema.safeParse(null);
-  return nullResult.success && nullResult.data === null;
-}
-
-export function quoteIdentifier(value: string): string {
-  return `"${value.replaceAll('"', '""')}"`;
-}
-
-function sqlType(kind: StorageKind): string {
-  if (kind === "integer" || kind === "boolean" || kind === "date") return "INTEGER";
-  if (kind === "real") return "REAL";
-  return "TEXT";
-}
-
-export function encodeField(field: EntityField, value: unknown): string | number | bigint | null {
-  if (value === undefined || value === null) return null;
-  switch (field.kind) {
-    case "text": return value as string;
-    case "integer":
-    case "real": return value as number;
-    case "boolean": return value ? 1 : 0;
-    case "bigint": return (value as bigint).toString();
-    case "date": return (value as Date).getTime();
-    case "json": {
-      const encoded = JSON.stringify(value);
-      if (encoded === undefined) throw new TypeError(`entity field '${field.name}' is not JSON-serializable`);
-      return encoded;
-    }
-  }
-}
-
-export function decodeField(field: EntityField, value: unknown): unknown {
-  if (value === null || value === undefined) {
-    const nullResult = field.schema.safeParse(null);
-    return nullResult.success ? null : undefined;
-  }
-  switch (field.kind) {
-    case "text":
-    case "integer":
-    case "real": return value;
-    case "boolean": return value === 1 || value === true;
-    case "bigint": return BigInt(value as string);
-    case "date": return new Date(value as number);
-    case "json": return JSON.parse(value as string) as unknown;
-  }
-}
-
-export function buildTable(moduleId: string, entityName: string, decl: EntityDecl): EntityTable {
-  const keyName = String(decl.key ?? "id");
-  const fields = Object.entries(decl.schema.shape).map(([name, schema]) => ({
-    name,
-    quoted: quoteIdentifier(name),
-    schema: schema as z.ZodType,
-    kind: storageKind(schema as z.ZodType),
-    nullable: allowsSqlNull(schema as z.ZodType),
-  } satisfies EntityField));
-  const fieldByName = new Map(fields.map((field) => [field.name, field]));
-  const key = fieldByName.get(keyName);
-  if (!key) throw new Error(`entity '${moduleId}.${entityName}' has no key field '${keyName}'`);
-  if (key.nullable || key.kind === "json" || key.kind === "date") {
-    throw new Error(`entity '${moduleId}.${entityName}' key '${keyName}' must be a non-null scalar`);
-  }
-  const name = `kernel_entity__${moduleId}__${entityName}`;
-  return { moduleId, entityName, name, quoted: quoteIdentifier(name), decl, fields, fieldByName, key };
-}
-
-/** Strip runtime-only Zod schemas/Maps/quoted names from a table before it crosses the port. */
-export function entityCatalogOf(table: EntityTable): KernelEntityCatalog {
-  return Object.freeze({
-    moduleId: table.moduleId,
-    entityName: table.entityName,
-    tableName: table.name,
-    key: table.key.name,
-    fields: Object.freeze(table.fields.map((field) => Object.freeze({
-      name: field.name,
-      kind: field.kind,
-      nullable: field.nullable,
-      nullValue: field.schema.safeParse(null).success ? "null" : "undefined",
-    }))),
-    references: Object.freeze(Object.fromEntries(
-      Object.entries(table.decl.references ?? {}).map(([name, ref]) => [name, { module: ref!.module, entity: ref!.entity }]),
-    )),
-    indexes: Object.freeze((table.decl.indexes ?? []).map((entry) => Object.freeze(
-      (Array.isArray(entry) ? entry : [entry]).map(String),
-    ))),
-  });
-}
-
-/** Build the clone-safe catalog while retaining the runtime table map on the kernel side. */
-export function buildModuleEntityCatalog<M extends ModuleManifest>(module: ModuleDefinition<M>): {
-  readonly catalog: KernelModuleCatalog;
-  readonly tables: ReadonlyMap<string, EntityTable>;
-} {
-  const tables = new Map<string, EntityTable>();
-  for (const [entityName, decl] of Object.entries(module.entities ?? {}) as Array<[string, EntityDecl]>) {
-    tables.set(entityName, buildTable(module.id, entityName, decl));
-  }
-  return {
-    tables,
-    catalog: Object.freeze({ moduleId: module.id, entities: Object.freeze([...tables.values()].map(entityCatalogOf)) }),
-  };
-}
-
-function ensureTable(db: Database, table: EntityTable): void {
-  const columns = table.fields.map((field) => `${field.quoted} ${sqlType(field.kind)}${field.nullable ? "" : " NOT NULL"}`);
-  const references = Object.entries(table.decl.references ?? {}).map(([fieldName, reference]) => {
-    const field = table.fieldByName.get(fieldName);
-    if (!field) throw new Error(`unknown reference field '${fieldName}' on '${table.moduleId}.${table.entityName}'`);
-    const target = quoteIdentifier(`kernel_entity__${reference!.module}__${reference!.entity}`);
-    // The omitted target-column list means the target's composite primary key. Including scope in
-    // the child key keeps the reference same-scope; enforcement requires the connection to run
-    // with `PRAGMA foreign_keys = ON` (EntityPersistence enables this on the injected handle).
-    return `FOREIGN KEY (scope, ${field.quoted}) REFERENCES ${target}`;
-  });
-  db.run(`CREATE TABLE IF NOT EXISTS ${table.quoted} (
-    scope TEXT NOT NULL,
-    ${columns.join(",\n    ")},
-    version INTEGER NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL,
-    PRIMARY KEY (scope, ${table.key.quoted})${references.length ? `,\n    ${references.join(",\n    ")}` : ""}
-  )`);
-
-  const tableInfo = db.query(`PRAGMA table_info(${table.quoted})`).all() as Array<{
-    name: string;
-    type: string;
-    notnull: number;
-    pk: number;
-  }>;
-  const existing = new Map(tableInfo.map((row) => [row.name, row.type]));
-  for (const [name, type] of [["scope", "TEXT"], ["version", "INTEGER"], ["created_at", "INTEGER"], ["updated_at", "INTEGER"]] as const) {
-    const column = tableInfo.find((row) => row.name === name);
-    if (!column || column.type.toUpperCase() !== type || column.notnull !== 1) {
-      throw new Error(`entity table '${table.name}' has incompatible kernel column '${name}'`);
-    }
-  }
-  const primaryKey = tableInfo.filter((row) => row.pk > 0).sort((a, b) => a.pk - b.pk).map((row) => row.name);
-  if (primaryKey.length !== 2 || primaryKey[0] !== "scope" || primaryKey[1] !== table.key.name) {
-    throw new Error(`entity table '${table.name}' must have primary key (scope, ${table.key.name})`);
-  }
-  for (const field of table.fields) {
-    const type = existing.get(field.name);
-    if (!type) {
-      if (!field.nullable) throw new Error(`cannot add required field '${field.name}' to existing entity table '${table.name}'`);
-      db.run(`ALTER TABLE ${table.quoted} ADD COLUMN ${field.quoted} ${sqlType(field.kind)}`);
-    } else if (type.toUpperCase() !== sqlType(field.kind)) {
-      throw new Error(`entity field '${table.moduleId}.${table.entityName}.${field.name}' changed SQLite type from ${type} to ${sqlType(field.kind)}`);
-    }
-  }
-
-  for (const [position, fieldsOrField] of (table.decl.indexes ?? []).entries()) {
-    const names = (Array.isArray(fieldsOrField) ? fieldsOrField : [fieldsOrField]).map(String);
-    const quotedFields = names.map((name) => {
-      const field = table.fieldByName.get(name);
-      if (!field) throw new Error(`unknown index field '${name}' on '${table.moduleId}.${table.entityName}'`);
-      return field.quoted;
-    });
-    const index = quoteIdentifier(`${table.name}__idx_${position}`);
-    db.run(`CREATE INDEX IF NOT EXISTS ${index} ON ${table.quoted} (scope, ${quotedFields.join(", ")})`);
-  }
-}
-
-export function installModuleEntities<M extends ModuleManifest>(db: Database, module: ModuleDefinition<M>): ReadonlyMap<string, EntityTable> {
-  const result = new Map<string, EntityTable>();
-  for (const [entityName, decl] of Object.entries(module.entities ?? {}) as Array<[string, EntityDecl]>) {
-    const table = buildTable(module.id, entityName, decl);
-    ensureTable(db, table);
-    result.set(entityName, table);
-  }
-  return result;
-}