@yrest/cli 0.13.0 → 0.14.0

package/dist/index.js

@@ -153,6 +153,62 @@ var init_parseRelations = __esm({
   }
 });
 
+// src/storage/parseRoutes.ts
+function parseRoutes(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(normaliseRoute).filter((r) => r !== null);
+}
+function normaliseRoute(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const v = raw;
+  const method = v["_method"];
+  if (typeof method === "string" && method.toUpperCase() === "SSE") return null;
+  if ("_sse" in v) return null;
+  const path = v["_path"];
+  if (typeof method !== "string" || typeof path !== "string") return null;
+  const route = { method, path };
+  if (typeof v["_handler"] === "string") route.handler = v["_handler"];
+  if (typeof v["_delay"] === "number") route.delay = v["_delay"];
+  if (typeof v["_error"] === "number") route.error = v["_error"];
+  if (v["_errorBody"] !== void 0) route.errorBody = v["_errorBody"];
+  const response = normaliseResponse(v["_response"]);
+  if (response) route.response = response;
+  const otherwise = normaliseResponse(v["_otherwise"]);
+  if (otherwise) route.otherwise = otherwise;
+  const scenarios = normaliseScenarios(v["_scenarios"]);
+  if (scenarios.length > 0) route.scenarios = scenarios;
+  return route;
+}
+function normaliseResponse(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const v = raw;
+  const response = {};
+  if (typeof v["_status"] === "number") response.status = v["_status"];
+  if (v["_body"] !== void 0) response.body = v["_body"];
+  if (v["_headers"] && typeof v["_headers"] === "object" && !Array.isArray(v["_headers"]))
+    response.headers = v["_headers"];
+  return Object.keys(response).length > 0 ? response : void 0;
+}
+function normaliseScenarios(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(normaliseScenario).filter((s) => s !== null);
+}
+function normaliseScenario(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const v = raw;
+  const when = v["_when"];
+  if (!when || typeof when !== "object") return null;
+  const response = normaliseResponse(v["_response"]);
+  if (!response) return null;
+  return { when, response };
+}
+var init_parseRoutes = __esm({
+  "src/storage/parseRoutes.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // src/storage/parseSseRoutes.ts
 function parseSseRoutes(raw) {
   if (!Array.isArray(raw)) return [];
@@ -169,11 +225,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,
@@ -275,62 +332,6 @@ var init_deepCopy = __esm({
   }
 });
 
-// src/storage/parseRoutes.ts
-function parseRoutes(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw.map(normaliseRoute).filter((r) => r !== null);
-}
-function normaliseRoute(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const v = raw;
-  const method = v["_method"];
-  if (typeof method === "string" && method.toUpperCase() === "SSE") return null;
-  if ("_sse" in v) return null;
-  const path = v["_path"];
-  if (typeof method !== "string" || typeof path !== "string") return null;
-  const route = { method, path };
-  if (typeof v["_handler"] === "string") route.handler = v["_handler"];
-  if (typeof v["_delay"] === "number") route.delay = v["_delay"];
-  if (typeof v["_error"] === "number") route.error = v["_error"];
-  if (v["_errorBody"] !== void 0) route.errorBody = v["_errorBody"];
-  const response = normaliseResponse(v["_response"]);
-  if (response) route.response = response;
-  const otherwise = normaliseResponse(v["_otherwise"]);
-  if (otherwise) route.otherwise = otherwise;
-  const scenarios = normaliseScenarios(v["_scenarios"]);
-  if (scenarios.length > 0) route.scenarios = scenarios;
-  return route;
-}
-function normaliseResponse(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const v = raw;
-  const response = {};
-  if (typeof v["_status"] === "number") response.status = v["_status"];
-  if (v["_body"] !== void 0) response.body = v["_body"];
-  if (v["_headers"] && typeof v["_headers"] === "object" && !Array.isArray(v["_headers"]))
-    response.headers = v["_headers"];
-  return Object.keys(response).length > 0 ? response : void 0;
-}
-function normaliseScenarios(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw.map(normaliseScenario).filter((s) => s !== null);
-}
-function normaliseScenario(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const v = raw;
-  const when = v["_when"];
-  if (!when || typeof when !== "object") return null;
-  const response = normaliseResponse(v["_response"]);
-  if (!response) return null;
-  return { when, response };
-}
-var init_parseRoutes = __esm({
-  "src/storage/parseRoutes.ts"() {
-    "use strict";
-    init_cjs_shims();
-  }
-});
-
 // src/storage/parseData.ts
 function parseData(raw) {
   const block = raw["_data"];
@@ -574,6 +575,9 @@ __export(src_exports, {
   createYrestServer: () => createYrestServer,
   createYrestServerFromStorage: () => createYrestServerFromStorage,
   createYrestStorage: () => createYrestStorage,
+  defineHandler: () => defineHandler,
+  defineSseHandler: () => defineSseHandler,
+  generateTypes: () => generateTypes,
   yrest: () => yrest,
   yrestOptionsSchema: () => yrestOptionsSchema
 });
@@ -626,18 +630,25 @@ function dedent(str) {
 init_cjs_shims();
 var import_node_path3 = require("path");
 init_parseRelations();
+init_parseRoutes();
 init_parseSseRoutes();
 init_parseSchema();
 
 // src/utils/handlers.ts
 init_cjs_shims();
 var import_node_fs = require("fs");
-var ALLOWED_EXTENSIONS = [".js", ".mjs", ".cjs"];
+function defineHandler(fn) {
+  return fn;
+}
+function defineSseHandler(fn) {
+  return fn;
+}
+var ALLOWED_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts"];
 async function loadHandlers(filePath) {
   if (!(0, import_node_fs.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();
   }
@@ -934,6 +945,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>`
@@ -2244,6 +2259,33 @@ var CollectionRouteCommand = class {
 // src/router/routes/custom.routes.ts
 init_cjs_shims();
 
+// src/api/collection.ts
+init_cjs_shims();
+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
 init_cjs_shims();
 function resolveRequestPath(dotPath, req) {
@@ -2307,15 +2349,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;
@@ -2352,7 +2399,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);
@@ -2967,26 +3014,64 @@ var SnapshotRouteCommand = class {
 // src/router/routes/sse.routes.ts
 init_cjs_shims();
 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;
@@ -3037,6 +3122,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) {
@@ -3079,8 +3171,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) {
@@ -3114,6 +3206,9 @@ function createYrestServerFromStorage(storage, options, handlers = /* @__PURE__
     },
     get url() {
       return `http://${options.host}:${_port}${options.base}`;
+    },
+    collection(name) {
+      return createCollectionHandle(storage, name, options.idStrategy);
     }
   };
 }
@@ -3137,6 +3232,10 @@ function createYrestServer(options) {
     },
     get url() {
       return _inner?.url ?? "";
+    },
+    collection(name) {
+      if (!_inner) throw new Error("collection() is only available after start()");
+      return _inner.collection(name);
     }
   };
 }
@@ -3160,7 +3259,7 @@ function createInMemoryStorage(data) {
   const raw = data;
   const RESERVED2 = /* @__PURE__ */ new Set(["_rel", "_routes", "_schema"]);
   const relations = parseRelations(raw["_rel"]);
-  const routes = Array.isArray(raw["_routes"]) ? raw["_routes"] : [];
+  const routes = parseRoutes(raw["_routes"]);
   const sseRoutes = parseSseRoutes(raw["_routes"]);
   const schema = parseSchema(raw["_schema"]);
   const collections = Object.fromEntries(
@@ -3251,12 +3350,240 @@ var yrestOptionsSchema = import_zod.z.object({
    */
   idStrategy: import_zod.z.enum(["increment", "uuid"]).default("increment")
 });
+
+// src/codegen/generateTypes.ts
+init_cjs_shims();
+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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createServer,
   createYrestServer,
   createYrestServerFromStorage,
   createYrestStorage,
+  defineHandler,
+  defineSseHandler,
+  generateTypes,
   yrest,
   yrestOptionsSchema
 });