@yrest/cli 0.5.3 → 0.7.0

package/dist/index.mjs

@@ -1,8 +1,21 @@
-// src/storage/yamlStorage.ts
-import { readFileSync, writeFileSync, renameSync } from "fs";
-import { resolve, dirname } from "path";
-import { randomUUID } from "crypto";
-import { parse, stringify } from "yaml";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
 
 // src/utils/deepCopy.ts
 function deepCopyData(source) {
@@ -10,11 +23,25 @@ function deepCopyData(source) {
     Object.entries(source).map(([k, v]) => [k, v.map((item) => ({ ...item }))])
   );
 }
+var init_deepCopy = __esm({
+  "src/utils/deepCopy.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
-// src/storage/yamlStorage.ts
-function createYamlStorage(filePath) {
+// src/storage/yrestStorage.ts
+var yrestStorage_exports = {};
+__export(yrestStorage_exports, {
+  createYrestStorage: () => createYrestStorage
+});
+import { readFileSync, writeFileSync, renameSync } from "fs";
+import { resolve, dirname } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { parse as parse2, stringify } from "yaml";
+function createYrestStorage(filePath) {
   const absPath = resolve(filePath);
-  const raw = parse(readFileSync(absPath, "utf8")) ?? {};
+  const raw = parse2(readFileSync(absPath, "utf8")) ?? {};
   const relations = raw["_rel"] ?? {};
   const routes = Array.isArray(raw["_routes"]) ? raw["_routes"] : [];
   const data = Object.fromEntries(
@@ -46,12 +73,12 @@ function createYamlStorage(filePath) {
       if (Object.keys(relations).length > 0) payload._rel = relations;
       if (routes.length > 0) payload._routes = routes;
       Object.assign(payload, data);
-      const tmp = resolve(dirname(absPath), `.yrest-${randomUUID()}.tmp`);
+      const tmp = resolve(dirname(absPath), `.yrest-${randomUUID2()}.tmp`);
       writeFileSync(tmp, stringify(payload), "utf8");
       renameSync(tmp, absPath);
     },
     reload() {
-      const fresh = parse(readFileSync(absPath, "utf8")) ?? {};
+      const fresh = parse2(readFileSync(absPath, "utf8")) ?? {};
       const freshRelations = fresh["_rel"] ?? {};
       const freshData = Object.fromEntries(
         Object.entries(fresh).filter(([key]) => key !== "_rel" && key !== "_routes")
@@ -81,31 +108,126 @@ function createYamlStorage(filePath) {
     }
   };
 }
+var init_yrestStorage = __esm({
+  "src/storage/yrestStorage.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_deepCopy();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/api/yrest.ts
+init_esm_shims();
+import { parse } from "yaml";
+function yrest(strings, ...values) {
+  const raw = strings.reduce(
+    (acc, str, i) => acc + str + (values[i] !== void 0 ? stringifyInterpolation(values[i]) : ""),
+    ""
+  );
+  const dedented = dedent(raw);
+  let parsed;
+  try {
+    parsed = parse(dedented);
+  } catch (e) {
+    throw new Error(`[yrest] Invalid YAML: ${e instanceof Error ? e.message : String(e)}`, {
+      cause: e
+    });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("[yrest] Template must resolve to a YAML object with collection keys.");
+  }
+  return parsed;
+}
+function stringifyInterpolation(value) {
+  if (value === null || value === void 0) return String(value);
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  const type = Array.isArray(value) ? "array" : typeof value;
+  throw new Error(
+    `[yrest] Cannot interpolate a value of type "${type}". Only string, number, and boolean are supported.`
+  );
+}
+function dedent(str) {
+  const lines = str.split("\n");
+  const minIndent = lines.filter((line) => line.trim().length > 0).reduce((min, line) => {
+    const match = line.match(/^(\s*)/);
+    return Math.min(min, match ? match[1].length : 0);
+  }, Infinity);
+  const indent = minIndent === Infinity ? 0 : minIndent;
+  return lines.map((line) => line.slice(indent)).join("\n").trim();
+}
+
+// src/api/yrestServer.ts
+init_esm_shims();
+import { resolve as resolve2 } from "path";
+
+// src/utils/handlers.ts
+init_esm_shims();
+import { existsSync } from "fs";
+async function loadHandlers(filePath) {
+  if (!existsSync(filePath)) return /* @__PURE__ */ new Map();
+  try {
+    const mod = await import(filePath);
+    const map = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(mod)) {
+      if (typeof value === "function") map.set(name, value);
+    }
+    return map;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`  \x1B[31m[handlers] failed to load ${filePath} \u2014 ${msg}\x1B[0m`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+
+// src/api/yrestServer.ts
+init_deepCopy();
+
+// src/server/index.ts
+init_esm_shims();
 
 // src/server/createServer.ts
+init_esm_shims();
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 
+// src/router/resource.router.ts
+init_esm_shims();
+
+// src/router/routes/index.ts
+init_esm_shims();
+
+// src/router/routes/about.routes.ts
+init_esm_shims();
+
+// src/router/templates/about.template.ts
+init_esm_shims();
+
 // src/utils/interpolate.ts
-import { randomUUID as randomUUID2 } from "crypto";
-function getPath(obj, path) {
-  return path.split(".").reduce((acc, key) => {
+init_esm_shims();
+import { randomUUID } from "crypto";
+function getPath(obj, path2) {
+  return path2.split(".").reduce((acc, key) => {
     if (acc != null && typeof acc === "object") return acc[key];
     return void 0;
   }, obj);
 }
-function resolveVar(path, ctx) {
-  if (path === "now") return (/* @__PURE__ */ new Date()).toISOString();
-  if (path === "uuid") return randomUUID2();
-  if (path === "body") return ctx.body;
-  if (path.startsWith("body.")) return getPath(ctx.body, path.slice(5));
-  if (path.startsWith("params.")) return ctx.params[path.slice(7)] ?? "";
-  if (path.startsWith("query.")) {
-    const val = ctx.query[path.slice(6)];
+function resolveVar(path2, ctx) {
+  if (path2 === "now") return (/* @__PURE__ */ new Date()).toISOString();
+  if (path2 === "uuid") return randomUUID();
+  if (path2 === "body") return ctx.body;
+  if (path2.startsWith("body.")) return getPath(ctx.body, path2.slice(5));
+  if (path2.startsWith("params.")) return ctx.params[path2.slice(7)] ?? "";
+  if (path2.startsWith("query.")) {
+    const val = ctx.query[path2.slice(6)];
     return Array.isArray(val) ? val[0] : val ?? "";
   }
-  if (path.startsWith("headers.")) {
-    const val = ctx.headers[path.slice(8)];
+  if (path2.startsWith("headers.")) {
+    const val = ctx.headers[path2.slice(8)];
     return Array.isArray(val) ? val[0] : val ?? "";
   }
   return "";
@@ -113,8 +235,8 @@ function resolveVar(path, ctx) {
 function interpolateString(str, ctx) {
   const exact = str.match(/^\{\{([^}]+)\}\}$/);
   if (exact) return resolveVar(exact[1].trim(), ctx);
-  return str.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
-    const val = resolveVar(path.trim(), ctx);
+  return str.replace(/\{\{([^}]+)\}\}/g, (_, path2) => {
+    const val = resolveVar(path2.trim(), ctx);
     return val == null ? "" : String(val);
   });
 }
@@ -148,11 +270,11 @@ function methodBadge(method) {
   const color = METHOD_COLOR[method] ?? "#7d8590";
   return badge(method, color, `${color}18`);
 }
-function endpointRow(method, path, desc) {
+function endpointRow(method, path2, desc) {
   return `
     <tr>
       <td class="method-cell">${methodBadge(method)}</td>
-      <td class="path-cell"><code>${path}</code></td>
+      <td class="path-cell"><code>${path2}</code></td>
       <td class="desc-cell">${desc}</td>
     </tr>`;
 }
@@ -332,16 +454,33 @@ function generateAboutHtml(storage, options, handlers = /* @__PURE__ */ new Map(
     <table><tbody>
       ${customRoutes.map((r) => {
     const fullPath = `${base}${r.path}`;
+    const tags = [];
+    if (r.delay && r.delay > 0) {
+      tags.push(`<span style="color:#fb923c;font-size:11px">delay\xB7${r.delay}ms</span>`);
+    }
+    if (r.scenarios?.length) {
+      const hasOr = r.scenarios.some((s) => Array.isArray(s.when));
+      tags.push(
+        `<span style="color:#a371f7;font-size:11px">scenarios\xB7${r.scenarios.length}${hasOr ? " (OR)" : ""}</span>`
+      );
+    }
+    if (r.otherwise) {
+      tags.push(`<span style="color:var(--text-muted);font-size:11px">otherwise</span>`);
+    }
     let desc;
     if (r.handler) {
       const found = handlers.has(r.handler);
       desc = found ? `Handler \u2014 <code>${r.handler}()</code>` : `Handler \u2014 <code>${r.handler}()</code> <span style="color:#f85149">(not loaded)</span>`;
+    } else if (r.scenarios?.length) {
+      const hasTemplateInScenarios = r.scenarios.some((s) => s.response.body != null && hasTemplates(s.response.body)) || r.otherwise?.body != null && hasTemplates(r.otherwise.body);
+      desc = hasTemplateInScenarios ? `Scenarios \u2014 <code>{{\u2026}}</code>` : `Scenarios`;
     } else if (r.response?.body != null && hasTemplates(r.response.body)) {
-      desc = `Dynamic body \u2014 <code>{{\u2026}}</code>`;
+      desc = `Dynamic \u2014 <code>{{\u2026}}</code>`;
     } else {
       const status = r.response?.status ?? 200;
-      desc = `Static \u2014 <code>${status}</code>${r.response?.headers ? ` + custom headers` : ""}`;
+      desc = `Static \u2014 <code>${status}</code>${r.response?.headers ? ` + headers` : ""}`;
     }
+    if (tags.length) desc += `&ensp;${tags.join("&ensp;")}`;
     return endpointRow(r.method?.toUpperCase() ?? "GET", fullPath, desc);
   }).join("")}
     </tbody></table>
@@ -493,7 +632,7 @@ function generateAboutHtml(storage, options, handlers = /* @__PURE__ */ new Map(
 
   <div class="banner">
     <div class="banner-inner">
-      <h1><span class="y">y</span><span class="rest">rest</span></h1>
+      <h1><span class="y">y</span><span class="rest">Rest</span></h1>
       <p>Zero-config REST API mock server</p>
       <div class="banner-meta">
         <span>URL <strong>${host}</strong></span>
@@ -545,7 +684,7 @@ function generateAboutHtml(storage, options, handlers = /* @__PURE__ */ new Map(
     ${collections.length ? `<h2>Examples</h2><div class="card">${examplesBlock(collections, relations, base, host, options, customRoutes[0])}</div>` : ""}
 
     <footer>
-      Powered by <a href="https://github.com/aggiovato/yaml-rest" target="_blank">@aggiovato/yrest</a> &nbsp;\xB7&nbsp; <a href="/_about">/_about</a>
+      Powered by <a href="https://github.com/aggiovato/yRest" target="_blank">@yrest/cli</a> &nbsp;\xB7&nbsp; <a href="/_about">/_about</a>
     </footer>
 
   </div>
@@ -571,7 +710,11 @@ var AboutRouteCommand = class {
   }
 };
 
+// src/router/routes/collection.routes.ts
+init_esm_shims();
+
 // src/utils/params.ts
+init_esm_shims();
 function nextId(items) {
   const ids = items.map((i) => i["id"]).filter((id) => typeof id === "number");
   return ids.length > 0 ? Math.max(...ids) + 1 : 1;
@@ -582,6 +725,7 @@ function firstParam(value) {
 }
 
 // src/services/query.service.ts
+init_esm_shims();
 var OPERATORS = ["_gte", "_lte", "_ne", "_like", "_start", "_regex"];
 function applyOperator(itemValue, op, filterValue) {
   const strItem = String(itemValue);
@@ -657,6 +801,7 @@ function paginate(items, page, limit) {
 }
 
 // src/services/resource.service.ts
+init_esm_shims();
 function findById(items, id) {
   return items.find((i) => String(i["id"]) === id);
 }
@@ -704,6 +849,7 @@ function deleteItem(storage, resource, id) {
 }
 
 // src/services/expand.service.ts
+init_esm_shims();
 function expandItems(input, query, resource, storage) {
   const isArray = Array.isArray(input);
   const items = isArray ? input : [input];
@@ -851,6 +997,66 @@ var CollectionRouteCommand = class {
 };
 
 // src/router/routes/custom.routes.ts
+init_esm_shims();
+
+// src/utils/conditions.ts
+init_esm_shims();
+function resolveRequestPath(dotPath, req) {
+  const [root, ...rest] = dotPath.split(".");
+  let value;
+  switch (root) {
+    case "body":
+      value = req.body;
+      break;
+    case "params":
+      value = req.params;
+      break;
+    case "query":
+      value = req.query;
+      break;
+    case "headers":
+      value = req.headers;
+      break;
+    default:
+      return void 0;
+  }
+  for (const key of rest) {
+    if (value != null && typeof value === "object") {
+      value = value[key];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
+function matchConditionGroup(group, req) {
+  return Object.entries(group).every(([key, expected]) => {
+    const op = OPERATORS.find((o) => key.endsWith(o));
+    if (op) {
+      const path2 = key.slice(0, -op.length);
+      const value2 = resolveRequestPath(path2, req);
+      if (value2 === void 0) return false;
+      return applyOperator(value2, op, String(expected));
+    }
+    const value = resolveRequestPath(key, req);
+    return String(value) === String(expected);
+  });
+}
+function matchWhen(when, req) {
+  if (Array.isArray(when)) {
+    return when.some((group) => matchConditionGroup(group, req));
+  }
+  return matchConditionGroup(when, req);
+}
+function findMatchingScenario(scenarios, req) {
+  return scenarios.find((s) => matchWhen(s.when, req));
+}
+
+// src/router/routes/custom.routes.ts
+function resolveBody(body, ctx) {
+  if (body != null && hasTemplates(body)) return interpolate(body, ctx);
+  return body ?? null;
+}
 var CustomRouteCommand = class {
   constructor(storage, base, handlers = /* @__PURE__ */ new Map()) {
     this.storage = storage;
@@ -863,9 +1069,9 @@ var CustomRouteCommand = class {
   register(server) {
     for (const route of this.storage.getRoutes()) {
       const method = route.method?.toUpperCase();
-      const path = route.path;
-      if (!method || !path) continue;
-      const url = `${this.base}${path}`;
+      const path2 = route.path;
+      if (!method || !path2) continue;
+      const url = `${this.base}${path2}`;
       const status = route.response?.status ?? 200;
       const rawBody = route.response?.body ?? null;
       const headers = route.response?.headers ?? {};
@@ -875,6 +1081,9 @@ var CustomRouteCommand = class {
         method,
         url,
         handler: async (req, reply) => {
+          if (route.delay && route.delay > 0) {
+            await new Promise((resolve3) => setTimeout(resolve3, route.delay));
+          }
           for (const [key, value] of Object.entries(headers)) {
             reply.header(key, value);
           }
@@ -884,13 +1093,13 @@ var CustomRouteCommand = class {
               return reply.status(501).send({ error: `Handler "${handlerName}" is not defined in the handlers file` });
             }
             try {
-              const ctx = {
+              const ctx2 = {
                 params: req.params,
                 query: req.query,
                 body: req.body,
                 headers: req.headers
               };
-              const result = await fn(ctx);
+              const result = await fn(ctx2);
               const resStatus = result.status ?? 200;
               for (const [k, v] of Object.entries(result.headers ?? {})) {
                 reply.header(k, v);
@@ -902,12 +1111,24 @@ var CustomRouteCommand = class {
               return reply.status(500).send({ error: `Handler "${handlerName}" threw an error: ${msg}` });
             }
           }
-          const body = dynamic ? interpolate(rawBody, {
+          const ctx = {
             params: req.params,
             query: req.query,
             body: req.body,
             headers: req.headers
-          }) : rawBody;
+          };
+          if (route.scenarios?.length) {
+            const matched = findMatchingScenario(route.scenarios, ctx);
+            const active = matched?.response ?? route.otherwise;
+            if (active) {
+              const aStatus = active.status ?? 200;
+              const aBody = resolveBody(active.body, ctx);
+              for (const [k, v] of Object.entries(active.headers ?? {})) reply.header(k, v);
+              if (!active.body && aStatus === 204) return reply.status(aStatus).send();
+              return reply.status(aStatus).send(aBody);
+            }
+          }
+          const body = dynamic ? interpolate(rawBody, ctx) : rawBody;
           if (body === null && status === 204) return reply.status(status).send();
           return reply.status(status).send(body);
         }
@@ -917,6 +1138,7 @@ var CustomRouteCommand = class {
 };
 
 // src/router/routes/item.routes.ts
+init_esm_shims();
 var ItemRouteCommand = class {
   constructor(storage, resource, base) {
     this.storage = storage;
@@ -966,6 +1188,7 @@ var ItemRouteCommand = class {
 };
 
 // src/router/routes/nested.routes.ts
+init_esm_shims();
 var NestedRouteCommand = class {
   constructor(storage, relations, base) {
     this.storage = storage;
@@ -1005,6 +1228,7 @@ var NestedRouteCommand = class {
 };
 
 // src/router/routes/snapshot.routes.ts
+init_esm_shims();
 var SnapshotRouteCommand = class {
   constructor(storage) {
     this.storage = storage;
@@ -1094,9 +1318,119 @@ async function createServer(storage, options, handlers = /* @__PURE__ */ new Map
   return server;
 }
 
+// src/server/yrestServer.ts
+init_esm_shims();
+function createYrestServerFromStorage(storage, options, handlers = /* @__PURE__ */ new Map()) {
+  let _port = 0;
+  let _started = false;
+  let _fastify = null;
+  return {
+    async start() {
+      if (_started) return;
+      _fastify = await createServer(storage, options, handlers);
+      await _fastify.listen({ port: options.port, host: options.host });
+      const address = _fastify.addresses()[0];
+      _port = typeof address === "object" && "port" in address ? address.port : options.port;
+      _started = true;
+    },
+    async stop() {
+      if (!_started || !_fastify) return;
+      await _fastify.close();
+      _started = false;
+    },
+    get port() {
+      return _port;
+    },
+    get url() {
+      return `http://${options.host}:${_port}${options.base}`;
+    }
+  };
+}
+
+// src/api/yrestServer.ts
+function createYrestServer(options) {
+  const resolvedOptions = buildOptions(options);
+  let _inner = null;
+  return {
+    async start() {
+      const storage = "data" in options && options.data !== void 0 ? createInMemoryStorage(options.data) : (await Promise.resolve().then(() => (init_yrestStorage(), yrestStorage_exports))).createYrestStorage(resolvedOptions.file);
+      const handlers = resolvedOptions.handlers ? await loadHandlers(resolve2(resolvedOptions.handlers)) : /* @__PURE__ */ new Map();
+      _inner = createYrestServerFromStorage(storage, resolvedOptions, handlers);
+      await _inner.start();
+    },
+    async stop() {
+      await _inner?.stop();
+    },
+    get port() {
+      return _inner?.port ?? 0;
+    },
+    get url() {
+      return _inner?.url ?? "";
+    }
+  };
+}
+function buildOptions(opts) {
+  const pageable = opts.pageable;
+  return {
+    file: "file" in opts && opts.file ? opts.file : "",
+    port: opts.port ?? 3070,
+    host: opts.host ?? "localhost",
+    base: opts.base ? opts.base.startsWith("/") ? opts.base : `/${opts.base}` : "",
+    watch: false,
+    snapshot: opts.snapshot ?? false,
+    readonly: opts.readonly ?? false,
+    delay: opts.delay ?? 0,
+    handlers: opts.handlers,
+    pageable: typeof pageable === "number" ? { enabled: true, limit: pageable } : pageable ? { enabled: true, limit: 10 } : { enabled: false, limit: 10 }
+  };
+}
+function createInMemoryStorage(data) {
+  const raw = data;
+  const relations = raw["_rel"] ?? {};
+  const routes = Array.isArray(raw["_routes"]) ? raw["_routes"] : [];
+  const collections = Object.fromEntries(
+    Object.entries(raw).filter(([k]) => k !== "_rel" && k !== "_routes")
+  );
+  let snapshot = {
+    data: deepCopyData(collections),
+    relations: { ...relations },
+    savedAt: /* @__PURE__ */ new Date()
+  };
+  return {
+    getData: () => collections,
+    getRelations: () => relations,
+    getRoutes: () => routes,
+    getCollection: (name) => collections[name],
+    setCollection: (name, items) => {
+      collections[name] = items;
+    },
+    persist: () => {
+    },
+    reload: () => {
+    },
+    getSnapshot: () => snapshot,
+    saveSnapshot: () => {
+      snapshot = {
+        data: deepCopyData(collections),
+        relations: { ...relations },
+        savedAt: /* @__PURE__ */ new Date()
+      };
+    },
+    resetToSnapshot: () => {
+      const snap = deepCopyData(snapshot.data);
+      for (const key of Object.keys(collections)) delete collections[key];
+      Object.assign(collections, snap);
+    }
+  };
+}
+
+// src/index.ts
+init_yrestStorage();
+
 // src/config/loadOptions.ts
+init_esm_shims();
 import { z } from "zod";
-var serverOptionsSchema = z.object({
+var yrestOptionsSchema = z.object({
   /** Path to the YAML database file. Must be a non-empty string. */
   file: z.string().min(1),
   /** TCP port the server listens on. Accepts string input and coerces to number. */
@@ -1135,6 +1469,9 @@ var serverOptionsSchema = z.object({
 });
 export {
   createServer,
-  createYamlStorage,
-  serverOptionsSchema
+  createYrestServer,
+  createYrestServerFromStorage,
+  createYrestStorage,
+  yrest,
+  yrestOptionsSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrest/cli",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "YAML-powered json-server alternative. Zero-config REST API mock server with full CRUD, relations, filters and snapshots from a db.yml file.",
   "keywords": [
     "yrest",