@yrest/cli 0.13.1 → 0.14.0

package/dist/cli/index.js

@@ -725,11 +725,12 @@ function normaliseSseRoute(raw) {
     return null;
   }
   const s = sse;
+  const handler = typeof s["_handler"] === "string" && s["_handler"].trim() ? s["_handler"].trim() : void 0;
   const rawEvents = s["_events"];
-  if (!Array.isArray(rawEvents)) return null;
-  const events = rawEvents.map(normaliseEvent).filter((e) => e !== null);
-  if (!events.length) return null;
+  const events = Array.isArray(rawEvents) ? rawEvents.map(normaliseEvent).filter((e) => e !== null) : [];
+  if (!handler && !events.length) return null;
   return {
+    ...handler ? { handler } : {},
     path,
     interval: typeof s["_interval"] === "number" ? s["_interval"] : 1e3,
     loop: s["_loop"] !== false,
@@ -1270,6 +1271,10 @@ function handlersAccordion(handlers, routes, base) {
 function sseRoutesAccordion(routes, base) {
   if (!routes.length) return "";
   const rows = routes.map((r) => {
+    if (r.handler) {
+      const desc2 = `SSE stream&ensp;<span style="color:#0ea5e9;font-size:11px">\u2192 ${escapeHtml(r.handler)}()</span>`;
+      return endpointRow("SSE", `${base}${r.path}`, desc2);
+    }
     const tags = [
       `<span style="color:#0ea5e9;font-size:11px">interval\xB7${r.interval}ms</span>`,
       `<span style="color:var(--text-muted);font-size:11px">${r.events.length} event${r.events.length !== 1 ? "s" : ""}</span>`
@@ -2568,6 +2573,32 @@ var CollectionRouteCommand = class {
   }
 };
 
+// src/api/collection.ts
+function createCollectionHandle(storage, name, idStrategy = "increment") {
+  if (!storage.getCollection(name)) {
+    const known = Object.keys(storage.getData()).join(", ") || "none";
+    throw new Error(`Collection "${name}" does not exist (known collections: ${known})`);
+  }
+  const items = () => storage.getCollection(name) ?? [];
+  const copy = (item) => item === void 0 ? void 0 : structuredClone(item);
+  return {
+    findAll: () => items().map((i) => copy(i)),
+    findById: (id) => copy(findById(items(), String(id))),
+    findWhere: (predicate) => items().map((i) => copy(i)).filter(predicate),
+    count: () => items().length,
+    create: (data) => copy(createItem(storage, name, { ...data }, idStrategy)),
+    update: (id, patch) => {
+      const rest = { ...patch };
+      delete rest["id"];
+      return copy(patchItem(storage, name, String(id), rest));
+    },
+    delete: (id) => copy(deleteItem(storage, name, String(id)))
+  };
+}
+function collectionAccessor(storage, idStrategy = "increment") {
+  return (name) => createCollectionHandle(storage, name, idStrategy);
+}
+
 // src/utils/conditions.ts
 function resolveRequestPath(dotPath, req) {
   const [root, ...rest] = dotPath.split(".");
@@ -2630,15 +2661,20 @@ function resolveBody(body, ctx) {
   return body ?? null;
 }
 var CustomRouteCommand = class {
-  constructor(storage, base, handlers = /* @__PURE__ */ new Map()) {
+  constructor(storage, base, handlers = /* @__PURE__ */ new Map(), idStrategy = "increment") {
     this.storage = storage;
     this.base = base;
     this.handlers = handlers;
+    this.idStrategy = idStrategy;
   }
   storage;
   base;
   handlers;
+  idStrategy;
   register(server) {
+    const handlerCtx = {
+      collection: collectionAccessor(this.storage, this.idStrategy)
+    };
     for (const route of this.storage.getRoutes()) {
       const method = route.method?.toUpperCase();
       const path = route.path;
@@ -2654,7 +2690,7 @@ var CustomRouteCommand = class {
         url,
         handler: async (req, reply) => {
           if (route.delay && route.delay > 0) {
-            await new Promise((resolve6) => setTimeout(resolve6, route.delay));
+            await new Promise((resolve7) => setTimeout(resolve7, route.delay));
           }
           if (route.error) {
             const body2 = route.errorBody ?? { error: `Forced error ${route.error}` };
@@ -2675,7 +2711,7 @@ var CustomRouteCommand = class {
                 body: req.body,
                 headers: req.headers
               };
-              const result = await fn(ctx2);
+              const result = await fn(ctx2, handlerCtx);
               const resStatus = result.status ?? 200;
               for (const [k, v] of Object.entries(result.headers ?? {})) {
                 reply.header(k, v);
@@ -3278,26 +3314,64 @@ var SnapshotRouteCommand = class {
 
 // src/router/routes/sse.routes.ts
 var SSERouteCommand = class {
-  constructor(storage, base) {
+  constructor(storage, base, handlers = /* @__PURE__ */ new Map(), idStrategy = "increment") {
     this.storage = storage;
     this.base = base;
+    this.handlers = handlers;
+    this.idStrategy = idStrategy;
   }
   storage;
   base;
+  handlers;
+  idStrategy;
   register(server) {
+    const handlerCtx = {
+      collection: collectionAccessor(this.storage, this.idStrategy)
+    };
     for (const route of this.storage.getSseRoutes()) {
       const url = `${this.base}${route.path}`;
       server.route({
         method: "GET",
         url,
         handler: async (req, reply) => {
+          if (route.handler) {
+            const fn = this.handlers.get(route.handler);
+            if (!fn) {
+              return reply.status(501).send({ error: `Handler "${route.handler}" is not defined in the handlers file` });
+            }
+            reply.hijack();
+            const raw2 = reply.raw;
+            openStream(raw2);
+            const keepAlive2 = setInterval(() => {
+              if (!raw2.writableEnded) raw2.write(": ping\n\n");
+            }, 15e3);
+            raw2.on("close", () => clearInterval(keepAlive2));
+            const ctx = {
+              params: req.params,
+              query: req.query,
+              body: null,
+              headers: req.headers
+            };
+            try {
+              await fn(ctx, raw2, handlerCtx);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              clearInterval(keepAlive2);
+              if (!raw2.writableEnded) {
+                raw2.write(
+                  `event: error
+data: ${JSON.stringify({ error: `Handler "${route.handler}" threw an error: ${msg}` })}
+
+`
+                );
+                raw2.end();
+              }
+            }
+            return;
+          }
           reply.hijack();
           const raw = reply.raw;
-          raw.setHeader("Content-Type", "text/event-stream");
-          raw.setHeader("Cache-Control", "no-cache");
-          raw.setHeader("Connection", "keep-alive");
-          raw.setHeader("Access-Control-Allow-Origin", "*");
-          raw.flushHeaders();
+          openStream(raw);
           let alive = true;
           req.raw.on("close", () => {
             alive = false;
@@ -3348,6 +3422,13 @@ var SSERouteCommand = class {
     }
   }
 };
+function openStream(raw) {
+  raw.setHeader("Content-Type", "text/event-stream");
+  raw.setHeader("Cache-Control", "no-cache");
+  raw.setHeader("Connection", "keep-alive");
+  raw.setHeader("Access-Control-Allow-Origin", "*");
+  raw.flushHeaders();
+}
 
 // src/router/resource.router.ts
 function buildResourceRouteCommands(storage, options) {
@@ -3390,8 +3471,8 @@ async function createServer(storage, options, handlers = /* @__PURE__ */ new Map
     new AboutRouteCommand(storage, options, handlers),
     new OpenApiRouteCommand(storage, options),
     ...options.snapshot ? [new SnapshotRouteCommand(storage)] : [],
-    new SSERouteCommand(storage, options.base),
-    new CustomRouteCommand(storage, options.base, handlers),
+    new SSERouteCommand(storage, options.base, handlers, options.idStrategy),
+    new CustomRouteCommand(storage, options.base, handlers, options.idStrategy),
     ...buildResourceRouteCommands(storage, options)
   ];
   for (const command of commands) {
@@ -3424,6 +3505,9 @@ function createYrestServerFromStorage(storage, options, handlers = /* @__PURE__
     },
     get url() {
       return `http://${options.host}:${_port}${options.base}`;
+    },
+    collection(name) {
+      return createCollectionHandle(storage, name, options.idStrategy);
     }
   };
 }
@@ -3486,12 +3570,12 @@ function loadConfigFile(configPath) {
 
 // src/utils/handlers.ts
 var import_node_fs5 = require("fs");
-var ALLOWED_EXTENSIONS = [".js", ".mjs", ".cjs"];
+var ALLOWED_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts"];
 async function loadHandlers(filePath) {
   if (!(0, import_node_fs5.existsSync)(filePath)) return /* @__PURE__ */ new Map();
   if (!ALLOWED_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
     console.error(
-      `  \x1B[31m[handlers] ${filePath} \u2014 only .js, .mjs and .cjs files are allowed\x1B[0m`
+      `  \x1B[31m[handlers] ${filePath} \u2014 only .js, .mjs, .cjs, .ts and .mts files are allowed\x1B[0m`
     );
     return /* @__PURE__ */ new Map();
   }
@@ -3531,7 +3615,7 @@ function registerServe(program2) {
     "Save a snapshot of the initial database state and expose /_snapshot endpoints"
   ).option(
     "--handlers <file>",
-    "Path to a JavaScript file exporting custom route handler functions"
+    "Path to a JS or TS file (.js, .mjs, .cjs, .ts, .mts) exporting handler functions"
   ).option(
     "--id-strategy <strategy>",
     "Id generation strategy for new items: increment (default) or uuid",
@@ -3644,26 +3728,59 @@ function registerServe(program2) {
 var import_node_fs7 = require("fs");
 var import_node_path5 = require("path");
 var import_yaml4 = require("yaml");
-var HANDLERS_FILE_HEADER = `// yrest handlers \u2014 loaded via "handlers:" in yrest.config.yml
-// Handler signature: (req: HandlerRequest) => HandlerResponse | Promise<HandlerResponse>
-// See https://github.com/aggiovato/yaml-rest for full documentation
+var JS_HEADER = `// yrest handlers \u2014 loaded via "handlers:" in yrest.config.yml
+// Handler signature: (req: HandlerRequest, ctx: HandlerContext) => HandlerResponse | Promise<HandlerResponse>
+// See https://github.com/aggiovato/yRest for full documentation
+`;
+var TS_HEADER = `// yrest handlers \u2014 loaded via "handlers:" in yrest.config.yml
+// TypeScript handlers need Node >= 22.18 (built-in type stripping) or running yrest through tsx.
+// See https://github.com/aggiovato/yRest for full documentation
+import { defineHandler } from "@yrest/cli";
 `;
-function buildStub(name, method, path) {
+function isTypeScriptFile(filePath) {
+  return filePath.endsWith(".ts") || filePath.endsWith(".mts");
+}
+function handlersFileHeader(typescript) {
+  return typescript ? TS_HEADER : JS_HEADER;
+}
+function hasHandler(content, name) {
+  return content.includes(`function ${name}(`) || new RegExp(`\\bconst ${name}\\s*=`).test(content);
+}
+function buildStub(name, method, path, typescript = false) {
   const tag = method && path ? `Handler for ${method.toUpperCase()} ${path}` : `yrest handler function`;
+  if (typescript) {
+    return [
+      "",
+      `/** ${tag} */`,
+      `export const ${name} = defineHandler(async (req, ctx) => {`,
+      `  // TODO: implement handler logic \u2014 ctx.collection("name") gives typed access to the data`,
+      `  return { status: 200, body: null };`,
+      `});`,
+      ""
+    ].join("\n");
+  }
   return [
     "",
     `/**`,
     ` * ${tag}`,
     ` * @param {import('@yrest/cli').HandlerRequest} req`,
+    ` * @param {import('@yrest/cli').HandlerContext} ctx`,
     ` * @returns {Promise<import('@yrest/cli').HandlerResponse>}`,
     ` */`,
-    `export async function ${name}(req) {`,
-    `  // TODO: implement handler logic`,
+    `export async function ${name}(req, ctx) {`,
+    `  // TODO: implement handler logic \u2014 ctx.collection("name") gives access to the data`,
     `  return { status: 200, body: null };`,
     `}`,
     ""
   ].join("\n");
 }
+function addRouteEntry(raw, name, method, path) {
+  if (!Array.isArray(raw["_routes"])) raw["_routes"] = [];
+  const routes = raw["_routes"];
+  if (routes.some((r) => r["_handler"] === name || r["handler"] === name)) return false;
+  routes.push({ _method: method.toUpperCase(), _path: path, _handler: name });
+  return true;
+}
 function registerHandler(program2) {
   program2.command("handler").description("Scaffold a handler function stub in the handlers file").argument("<name>", "Name of the handler function to create").option("-m, --method <method>", "HTTP method hint for the stub JSDoc (e.g. POST)").option("-p, --path <path>", "Route path hint for the stub JSDoc (e.g. /login)").option(
     "--register",
@@ -3674,20 +3791,18 @@ function registerHandler(program2) {
       fileConfig.handlers ?? "yrest.handlers.js"
     );
     const dbPath = (0, import_node_path5.resolve)(fileConfig.file ?? "db.yml");
+    const typescript = isTypeScriptFile(handlersPath);
+    const stub = buildStub(name, flags.method, flags.path, typescript);
     if (!(0, import_node_fs7.existsSync)(handlersPath)) {
-      (0, import_node_fs7.writeFileSync)(
-        handlersPath,
-        HANDLERS_FILE_HEADER + buildStub(name, flags.method, flags.path),
-        "utf8"
-      );
+      (0, import_node_fs7.writeFileSync)(handlersPath, handlersFileHeader(typescript) + stub, "utf8");
       console.log(`  Created ${(0, import_node_path5.basename)(handlersPath)}`);
     } else {
       const existing = (0, import_node_fs7.readFileSync)(handlersPath, "utf8");
-      if (existing.includes(`function ${name}(`)) {
+      if (hasHandler(existing, name)) {
         console.error(`  Error: handler "${name}" already exists in ${(0, import_node_path5.basename)(handlersPath)}`);
         process.exit(1);
       }
-      (0, import_node_fs7.appendFileSync)(handlersPath, buildStub(name, flags.method, flags.path), "utf8");
+      (0, import_node_fs7.appendFileSync)(handlersPath, stub, "utf8");
       console.log(`  Added handler "${name}" to ${(0, import_node_path5.basename)(handlersPath)}`);
     }
     if (flags.register) {
@@ -3700,11 +3815,7 @@ function registerHandler(program2) {
         process.exit(1);
       }
       const raw = (0, import_yaml4.parse)((0, import_node_fs7.readFileSync)(dbPath, "utf8")) ?? {};
-      if (!Array.isArray(raw["_routes"])) raw["_routes"] = [];
-      const routes = raw["_routes"];
-      const alreadyRegistered = routes.some((r) => r["handler"] === name);
-      if (!alreadyRegistered) {
-        routes.push({ method: flags.method.toUpperCase(), path: flags.path, handler: name });
+      if (addRouteEntry(raw, name, flags.method, flags.path)) {
         (0, import_node_fs7.writeFileSync)(dbPath, (0, import_yaml4.stringify)(raw), "utf8");
         console.log(`  Added _routes entry to ${(0, import_node_path5.basename)(dbPath)}`);
       } else {
@@ -3755,6 +3866,283 @@ function registerOpenApi(program2) {
   });
 }
 
+// src/cli/commands/types.ts
+var import_node_fs9 = require("fs");
+var import_node_path7 = require("path");
+var import_yaml6 = require("yaml");
+
+// src/codegen/generateTypes.ts
+var HEADER = "// Auto-generated by yrest types \u2014 do not edit manually.";
+var IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var MAX_DEPTH = 4;
+function generateTypes(input, options = {}) {
+  const { data, schema = {}, relations = {} } = input;
+  const collections = unique([...Object.keys(data), ...Object.keys(schema)]);
+  const names = resolveInterfaceNames(collections);
+  const out = [HEADER];
+  if (options.source) out.push(`// Source: ${options.source}`);
+  out.push("");
+  for (const collection of collections) {
+    out.push(
+      renderInterface(
+        names.get(collection),
+        collection,
+        data[collection] ?? [],
+        schema[collection] ?? {},
+        relations[collection] ?? {}
+      )
+    );
+    out.push("");
+  }
+  out.push(`/** Union of all collection names in the source file. */`);
+  out.push(
+    collections.length > 0 ? `export type CollectionName = ${collections.map((c) => quote(c)).join(" | ")};` : "export type CollectionName = never;"
+  );
+  out.push("");
+  out.push(`/** Maps each collection name to its item array type. */`);
+  out.push("export interface Collections {");
+  for (const collection of collections) {
+    out.push(`  ${propKey(collection)}: ${names.get(collection)}[];`);
+  }
+  out.push("}");
+  return out.join("\n") + "\n";
+}
+function renderInterface(name, collection, items, fieldDefs, rels) {
+  const records = items.filter(isPlainObject);
+  const fields = collectFields(records);
+  const fieldNames = unique([...fields.keys(), ...Object.keys(fieldDefs)]);
+  const lines = [`/** Item of the \`${collection}\` collection. */`];
+  lines.push(`export interface ${name} {`);
+  for (const field of fieldNames) {
+    const info = fields.get(field);
+    const def = fieldDefs[field];
+    const inferredRequired = info !== void 0 && info.count === records.length && records.length > 0;
+    const required = def?.required ?? inferredRequired;
+    let type = def ? typeFromDef(def, info) : typeOfValues(info.values, 0);
+    if (def?.nullable === true && !type.split(" | ").includes("null")) type = `${type} | null`;
+    for (const doc of fieldDoc(field, def, rels)) lines.push(`  ${doc}`);
+    lines.push(`  ${propKey(field)}${required ? "" : "?"}: ${type};`);
+  }
+  if (fieldNames.length === 0) lines.push("  [key: string]: unknown;");
+  lines.push("}");
+  return lines.join("\n");
+}
+function fieldDoc(field, def, rels) {
+  const text = [];
+  const tags = [];
+  if (def?.description) text.push(def.description.replace(/\*\//g, "*\\/"));
+  const rel = Object.entries(rels).find(
+    ([key, r]) => r.type !== "many2many" && (r.foreignKey ?? key) === field
+  )?.[1];
+  if (rel) text.push(`FK \u2192 ${rel.target}.id`);
+  if (def?.format) tags.push(`@format ${def.format}`);
+  if (def?.deprecated) tags.push("@deprecated");
+  if (text.length === 0 && tags.length === 0) return [];
+  if (tags.length === 0) return [`/** ${text.join(" \u2014 ")} */`];
+  return ["/**", ...[...text, ...tags].map((l) => ` * ${l}`), " */"];
+}
+function collectFields(records) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    for (const [key, value] of Object.entries(record)) {
+      let info = fields.get(key);
+      if (!info) {
+        info = { values: [], count: 0 };
+        fields.set(key, info);
+      }
+      info.count++;
+      info.values.push(value);
+    }
+  }
+  return fields;
+}
+function typeOfValues(values, depth) {
+  return unionOf(typeSetOf(values, depth));
+}
+function typeSetOf(values, depth) {
+  const types = /* @__PURE__ */ new Set();
+  const objects = [];
+  const elements = [];
+  let sawArray = false;
+  for (const value of values) {
+    if (value === null || value === void 0) types.add("null");
+    else if (typeof value === "string") types.add("string");
+    else if (typeof value === "number") types.add("number");
+    else if (typeof value === "boolean") types.add("boolean");
+    else if (Array.isArray(value)) {
+      sawArray = true;
+      elements.push(...value);
+    } else if (isPlainObject(value)) objects.push(value);
+    else types.add("unknown");
+  }
+  if (objects.length > 0) {
+    types.add(depth >= MAX_DEPTH ? "Record<string, unknown>" : inlineObject(objects, depth + 1));
+  }
+  if (sawArray) {
+    types.add(
+      elements.length === 0 ? "unknown[]" : depth >= MAX_DEPTH ? "unknown[]" : arrayOf(typeSetOf(elements, depth + 1))
+    );
+  }
+  return types;
+}
+function inlineObject(records, depth) {
+  const fields = collectFields(records);
+  if (fields.size === 0) return "Record<string, unknown>";
+  const props = [...fields].map(([key, info]) => {
+    const optional = info.count < records.length ? "?" : "";
+    return `${propKey(key)}${optional}: ${typeOfValues(info.values, depth)}`;
+  });
+  return `{ ${props.join("; ")} }`;
+}
+function unionOf(types) {
+  const list = [...types];
+  if (list.length === 0) return "unknown";
+  if (list.length === 1 && list[0] === "null") return "unknown";
+  const hasConcreteArray = list.some((t) => t.endsWith("[]") && t !== "unknown[]");
+  const filtered = hasConcreteArray ? list.filter((t) => t !== "unknown[]") : list;
+  filtered.sort((a, b) => a === "null" ? 1 : b === "null" ? -1 : 0);
+  return filtered.join(" | ");
+}
+function arrayOf(elements) {
+  const element = unionOf(elements);
+  return element.includes(" | ") && elements.size > 1 ? `(${element})[]` : `${element}[]`;
+}
+function typeFromDef(def, info) {
+  if (def.enum && def.enum.length > 0) {
+    return unique(def.enum.map((v) => literal(v))).join(" | ");
+  }
+  if (def.type) {
+    if (def.type === "array") {
+      const items = def.items;
+      if (items?.enum && items.enum.length > 0)
+        return arrayOf(new Set(items.enum.map((v) => literal(v))));
+      if (items?.type) return arrayOf(/* @__PURE__ */ new Set([primitiveFor(items.type)]));
+      const inferred = info ? typeOfValues(info.values, 0) : "";
+      return inferred.endsWith("[]") && !inferred.includes(" | ") ? inferred : "unknown[]";
+    }
+    return primitiveFor(def.type);
+  }
+  return info ? typeOfValues(info.values, 0) : "unknown";
+}
+function primitiveFor(type) {
+  switch (type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "unknown[]";
+    case "object":
+      return "Record<string, unknown>";
+  }
+}
+function literal(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return "unknown";
+}
+function resolveInterfaceNames(collections) {
+  const names = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    const words = splitWords(collection);
+    const candidates = [
+      toPascal([...words.slice(0, -1), singularize(words.at(-1) ?? "")]),
+      toPascal(words)
+    ];
+    let name = candidates.find((c) => c && !used.has(c));
+    if (!name) {
+      const base = candidates[1] || "Collection";
+      let i = 2;
+      while (used.has(`${base}${i}`)) i++;
+      name = `${base}${i}`;
+    }
+    if (/^[0-9]/.test(name)) name = `_${name}`;
+    used.add(name);
+    names.set(collection, name);
+  }
+  return names;
+}
+function splitWords(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+}
+function toPascal(words) {
+  return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function singularize(word) {
+  const lower = word.toLowerCase();
+  if (lower.length <= 2) return word;
+  if (/(ss|us|is)$/.test(lower)) return word;
+  if (/[^aeiou]ies$/.test(lower)) return word.slice(0, -3) + "y";
+  if (/(s|x|z|ch|sh)es$/.test(lower)) return word.slice(0, -2);
+  if (lower.endsWith("s")) return word.slice(0, -1);
+  return word;
+}
+function propKey(key) {
+  return IDENT_RE.test(key) ? key : JSON.stringify(key);
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+function unique(list) {
+  return [...new Set(list)];
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/cli/commands/types.ts
+function generateTypesFromFile(filePath) {
+  const absPath = (0, import_node_path7.resolve)(filePath);
+  const raw = (0, import_yaml6.parse)((0, import_node_fs9.readFileSync)(absPath, "utf8")) ?? {};
+  return generateTypes(
+    {
+      data: parseData(raw),
+      schema: parseSchema(raw["_schema"]),
+      relations: parseRelations(raw["_rel"])
+    },
+    { source: (0, import_node_path7.basename)(absPath) }
+  );
+}
+function registerTypes(program2) {
+  program2.command("types <file>").description("Generate TypeScript interfaces from a db.yml file").option("-o, --output <file>", "Write to a file instead of stdout (e.g. db.types.ts)").option("-w, --watch", "Regenerate on every change of <file> (requires --output)").action((file, opts) => {
+    if (opts.watch && !opts.output) {
+      console.error("\u2717  --watch requires --output");
+      process.exitCode = 1;
+      return;
+    }
+    const run = () => {
+      try {
+        const output = generateTypesFromFile(file);
+        if (!opts.output) {
+          process.stdout.write(output);
+        } else {
+          const outFile = (0, import_node_path7.resolve)(opts.output);
+          (0, import_node_fs9.writeFileSync)(outFile, output, "utf8");
+          console.log(`\u2713  Types written to ${outFile}`);
+        }
+        return true;
+      } catch (err) {
+        console.error(`\u2717  Could not generate types: ${err.message}`);
+        return false;
+      }
+    };
+    const ok2 = run();
+    if (!opts.watch) {
+      if (!ok2) process.exitCode = 1;
+      return;
+    }
+    console.log(`\u{1F440} Watching ${(0, import_node_path7.resolve)(file)} \u2014 Ctrl+C to stop`);
+    (0, import_node_fs9.watchFile)((0, import_node_path7.resolve)(file), { interval: 300 }, (curr, prev) => {
+      if (curr.mtimeMs !== prev.mtimeMs) run();
+    });
+  });
+}
+
 // src/cli/index.ts
 var require2 = (0, import_module.createRequire)(importMetaUrl);
 var { version } = require2("../../package.json");
@@ -3763,4 +4151,5 @@ registerInit(import_commander.program);
 registerServe(import_commander.program);
 registerHandler(import_commander.program);
 registerOpenApi(import_commander.program);
+registerTypes(import_commander.program);
 import_commander.program.parse();