@contractspec/lib.contracts-runtime-server-rest 2.0.0

package/dist/contracts-adapter-input.js

@@ -0,0 +1,100 @@
+// @bun
+// src/contracts-adapter-input.ts
+import { isSchemaModel } from "@contractspec/lib.schema";
+function isFieldType(x) {
+  return typeof x?.getPothos === "function";
+}
+function isEnumType(x) {
+  return typeof x?.getEnumValues === "function" && typeof x?.getPothos === "function";
+}
+function mapScalarName(name) {
+  if (name === "Boolean_unsecure")
+    return "Boolean";
+  if (name === "ID_unsecure")
+    return "ID";
+  if (name === "String_unsecure")
+    return "String";
+  if (name === "Int_unsecure")
+    return "Int";
+  if (name === "Float_unsecure")
+    return "Float";
+  return name;
+}
+function createInputTypeBuilder(builder) {
+  const inputTypeCache = new Map;
+  const enumTypeCache = new Set;
+  function registerEnumsForModel(model) {
+    const entries = Object.entries(model.config.fields);
+    for (const [, field] of entries) {
+      const fieldType = field.type;
+      if (isSchemaModel(fieldType)) {
+        registerEnumsForModel(fieldType);
+      } else if (isEnumType(field.type)) {
+        const enumObj = field.type;
+        const name = enumObj.getName?.() ?? enumObj.getPothos().name;
+        if (!enumTypeCache.has(name)) {
+          builder.enumType(name, {
+            values: enumObj.getEnumValues()
+          });
+          enumTypeCache.add(name);
+        }
+      }
+    }
+  }
+  function ensureInputTypeForModel(model) {
+    const typeName = String(model.config?.name ?? "Input");
+    const cached = inputTypeCache.get(typeName);
+    if (cached)
+      return cached;
+    registerEnumsForModel(model);
+    const created = builder.inputType(model.getPothosInput(), {
+      fields: (t) => {
+        const entries = Object.entries(model.config.fields);
+        const acc = {};
+        for (const [key, field] of entries) {
+          const fieldType = field.type;
+          if (isSchemaModel(fieldType)) {
+            const nested = ensureInputTypeForModel(fieldType);
+            const typeRef = field.isArray ? [nested] : nested;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else if (isFieldType(field.type)) {
+            const typeName2 = mapScalarName(String(field.type.getPothos().name));
+            const typeRef = field.isArray ? [typeName2] : typeName2;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else {
+            const typeRef = field.isArray ? ["JSON"] : "JSON";
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          }
+        }
+        return acc;
+      }
+    });
+    inputTypeCache.set(typeName, created);
+    return created;
+  }
+  function buildInputFieldArgs(model) {
+    if (!model)
+      return null;
+    if (!isSchemaModel(model)) {
+      return null;
+    }
+    if (!model.config?.fields || Object.keys(model.config.fields).length === 0) {
+      return null;
+    }
+    const ref = ensureInputTypeForModel(model);
+    return ref;
+  }
+  return { buildInputFieldArgs };
+}
+export {
+  createInputTypeBuilder
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './contracts-adapter-hydration';
+export * from './contracts-adapter-input';
+export * from './rest-elysia';
+export * from './rest-express';
+export * from './rest-generic';
+export * from './rest-next-app';
+export * from './rest-next-pages';

package/dist/index.js

@@ -0,0 +1,347 @@
+// @bun
+// src/contracts-adapter-hydration.ts
+function parseReturns(returnsLike) {
+  if (!returnsLike)
+    return { isList: false, inner: "JSON" };
+  const trimmed = String(returnsLike).trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return { isList: true, inner: trimmed.slice(1, -1).trim() };
+  }
+  return { isList: false, inner: trimmed };
+}
+async function hydrateResourceIfNeeded(resources, result, opts) {
+  if (!resources || !opts.template)
+    return result;
+  const varName = opts.varName ?? "id";
+  const hydrateOne = async (item) => {
+    if (item && typeof item === "object" && varName in item) {
+      const key = String(item[varName]);
+      const uri = (opts.template ?? "").replace("{id}", key);
+      const match = resources.match(uri);
+      if (match) {
+        const resolved = await match.tmpl.resolve(match.params, {});
+        try {
+          return JSON.parse(String(resolved.data || "null"));
+        } catch {
+          return resolved.data;
+        }
+      }
+    }
+    return item;
+  };
+  if (opts.returns.isList && Array.isArray(result)) {
+    const hydrated = await Promise.all(result.map((x) => hydrateOne(x)));
+    return hydrated;
+  }
+  return await hydrateOne(result);
+}
+
+// src/contracts-adapter-input.ts
+import { isSchemaModel } from "@contractspec/lib.schema";
+function isFieldType(x) {
+  return typeof x?.getPothos === "function";
+}
+function isEnumType(x) {
+  return typeof x?.getEnumValues === "function" && typeof x?.getPothos === "function";
+}
+function mapScalarName(name) {
+  if (name === "Boolean_unsecure")
+    return "Boolean";
+  if (name === "ID_unsecure")
+    return "ID";
+  if (name === "String_unsecure")
+    return "String";
+  if (name === "Int_unsecure")
+    return "Int";
+  if (name === "Float_unsecure")
+    return "Float";
+  return name;
+}
+function createInputTypeBuilder(builder) {
+  const inputTypeCache = new Map;
+  const enumTypeCache = new Set;
+  function registerEnumsForModel(model) {
+    const entries = Object.entries(model.config.fields);
+    for (const [, field] of entries) {
+      const fieldType = field.type;
+      if (isSchemaModel(fieldType)) {
+        registerEnumsForModel(fieldType);
+      } else if (isEnumType(field.type)) {
+        const enumObj = field.type;
+        const name = enumObj.getName?.() ?? enumObj.getPothos().name;
+        if (!enumTypeCache.has(name)) {
+          builder.enumType(name, {
+            values: enumObj.getEnumValues()
+          });
+          enumTypeCache.add(name);
+        }
+      }
+    }
+  }
+  function ensureInputTypeForModel(model) {
+    const typeName = String(model.config?.name ?? "Input");
+    const cached = inputTypeCache.get(typeName);
+    if (cached)
+      return cached;
+    registerEnumsForModel(model);
+    const created = builder.inputType(model.getPothosInput(), {
+      fields: (t) => {
+        const entries = Object.entries(model.config.fields);
+        const acc = {};
+        for (const [key, field] of entries) {
+          const fieldType = field.type;
+          if (isSchemaModel(fieldType)) {
+            const nested = ensureInputTypeForModel(fieldType);
+            const typeRef = field.isArray ? [nested] : nested;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else if (isFieldType(field.type)) {
+            const typeName2 = mapScalarName(String(field.type.getPothos().name));
+            const typeRef = field.isArray ? [typeName2] : typeName2;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else {
+            const typeRef = field.isArray ? ["JSON"] : "JSON";
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          }
+        }
+        return acc;
+      }
+    });
+    inputTypeCache.set(typeName, created);
+    return created;
+  }
+  function buildInputFieldArgs(model) {
+    if (!model)
+      return null;
+    if (!isSchemaModel(model)) {
+      return null;
+    }
+    if (!model.config?.fields || Object.keys(model.config.fields).length === 0) {
+      return null;
+    }
+    const ref = ensureInputTypeForModel(model);
+    return ref;
+  }
+  return { buildInputFieldArgs };
+}
+
+// src/rest-generic.ts
+import { defaultRestPath } from "@contractspec/lib.contracts-spec/jsonschema";
+function corsHeaders(opt) {
+  const h = {};
+  const origin = typeof opt === "object" ? opt.origin ?? "*" : "*";
+  h["access-control-allow-origin"] = origin;
+  h["vary"] = "Origin";
+  if (typeof opt === "object") {
+    if (opt.methods)
+      h["access-control-allow-methods"] = opt.methods.join(", ");
+    if (opt.headers)
+      h["access-control-allow-headers"] = opt.headers.join(", ");
+    if (opt.credentials)
+      h["access-control-allow-credentials"] = "true";
+    if (typeof opt.maxAge === "number") {
+      h["access-control-max-age"] = String(opt.maxAge);
+    }
+  } else {
+    h["access-control-allow-methods"] = "GET,POST,OPTIONS";
+    h["access-control-allow-headers"] = "content-type,x-idempotency-key,x-trace-id";
+  }
+  return h;
+}
+function joinPath(a, b) {
+  const left = (a ?? "").replace(/\/+$/g, "");
+  const right = b.replace(/^\/+/g, "");
+  return `${left}/${right}`.replace(/\/{2,}/g, "/");
+}
+function createFetchHandler(reg, ctxFactory, options) {
+  const opts = {
+    basePath: options?.basePath ?? "",
+    cors: options?.cors ?? false,
+    prettyJson: options?.prettyJson ?? false,
+    onError: options?.onError
+  };
+  const routes = reg.list().map((spec) => ({
+    method: spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST"),
+    path: joinPath(opts.basePath, spec.transport?.rest?.path ?? defaultRestPath(spec.meta.key, spec.meta.version)),
+    name: spec.meta.key,
+    version: spec.meta.version
+  }));
+  const routeTable = new Map;
+  for (const r of routes)
+    routeTable.set(`${r.method} ${r.path}`, r);
+  const makeJson = (status, data, extraHeaders) => {
+    const body = opts.prettyJson ? JSON.stringify(data, null, opts.prettyJson) : JSON.stringify(data);
+    const base = {
+      "content-type": "application/json; charset=utf-8"
+    };
+    return new Response(body, {
+      status,
+      headers: extraHeaders ? { ...base, ...extraHeaders } : base
+    });
+  };
+  return async function handle(req) {
+    const url = new URL(req.url);
+    const key = `${req.method.toUpperCase()} ${url.pathname}`;
+    if (opts.cors && req.method.toUpperCase() === "OPTIONS") {
+      const h = corsHeaders(opts.cors === true ? {} : opts.cors);
+      return new Response(null, {
+        status: 204,
+        headers: { ...h, "content-length": "0" }
+      });
+    }
+    const route = routeTable.get(key);
+    if (!route) {
+      const headers = {};
+      if (opts.cors)
+        Object.assign(headers, corsHeaders(opts.cors === true ? {} : opts.cors));
+      return makeJson(404, { error: "NotFound", path: url.pathname }, headers);
+    }
+    try {
+      let input = {};
+      if (route.method === "GET") {
+        if (url.searchParams.has("input")) {
+          const raw = url.searchParams.get("input");
+          input = raw ? JSON.parse(raw) : {};
+        } else {
+          const obj = {};
+          for (const [k, v] of url.searchParams.entries())
+            obj[k] = v;
+          input = obj;
+        }
+      } else {
+        const contentType = req.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          input = await req.json();
+        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          const form = await req.formData();
+          input = Object.fromEntries(form.entries());
+        } else if (!contentType) {
+          input = {};
+        } else {
+          return makeJson(415, { error: "UnsupportedMediaType", contentType });
+        }
+      }
+      const ctx = ctxFactory(req);
+      const result = await reg.execute(route.name, route.version, input, ctx);
+      const headers = {};
+      if (opts.cors)
+        Object.assign(headers, corsHeaders(opts.cors === true ? {} : opts.cors));
+      return makeJson(200, result, headers);
+    } catch (err) {
+      if (opts.onError) {
+        const mapped = opts.onError(err);
+        const headers2 = {};
+        if (opts.cors)
+          Object.assign(headers2, corsHeaders(opts.cors === true ? {} : opts.cors));
+        return makeJson(mapped.status, mapped.body, headers2);
+      }
+      const headers = {};
+      if (opts.cors)
+        Object.assign(headers, corsHeaders(opts.cors === true ? {} : opts.cors));
+      if (err?.issues) {
+        return makeJson(400, {
+          error: "ValidationError",
+          issues: err.issues
+        }, headers);
+      }
+      if (typeof err?.message === "string" && err.message.startsWith("PolicyDenied")) {
+        return makeJson(403, { error: "PolicyDenied" }, headers);
+      }
+      return makeJson(500, { error: "InternalError" }, headers);
+    }
+  };
+}
+
+// src/rest-elysia.ts
+function elysiaPlugin(app, reg, ctxFactory, options) {
+  const handler = createFetchHandler(reg, (req) => ctxFactory({
+    request: req,
+    store: app.store
+  }), options);
+  for (const spec of reg.list()) {
+    const method = spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST");
+    const path = (options?.basePath ?? "") + (spec.transport?.rest?.path ?? `/${spec.meta.key.replace(/\./g, "/")}/v${spec.meta.version}`);
+    app[method.toLowerCase()](path, ({ request }) => handler(request));
+  }
+  if (options?.cors) {
+    app.options("*", ({ request }) => handler(request));
+  }
+  return app;
+}
+
+// src/rest-express.ts
+function expressRouter(express, reg, ctxFactory, options) {
+  const router = express.Router();
+  for (const spec of reg.list()) {
+    const method = spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST");
+    const path = (options?.basePath ?? "") + (spec.transport?.rest?.path ?? `/${spec.meta.key.replace(/\./g, "/")}/v${spec.meta.version}`);
+    router[method.toLowerCase()](path, async (req, res) => {
+      const url = new URL(`${req.protocol}://${req.get("host")}${req.originalUrl}`);
+      const request = new Request(url.toString(), {
+        method,
+        headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, String(v)])),
+        body: method === "POST" ? JSON.stringify(req.body ?? {}) : undefined
+      });
+      const handler = createFetchHandler(reg, () => ctxFactory(req), options);
+      const response = await handler(request);
+      res.status(response.status);
+      response.headers.forEach((v, k) => res.setHeader(k, v));
+      const text = await response.text();
+      res.send(text);
+    });
+  }
+  if (options?.cors) {
+    router.options("*", (_req, res) => {
+      const h = new Headers;
+      const resp = new Response(null, { status: 204 });
+      resp.headers.forEach((v, k) => h.set(k, v));
+      res.status(204).send();
+    });
+  }
+  return router;
+}
+
+// src/rest-next-app.ts
+function makeNextAppHandler(reg, ctxFactory, options) {
+  const handler = createFetchHandler(reg, ctxFactory, options);
+  return async function requestHandler(req) {
+    return handler(req);
+  };
+}
+
+// src/rest-next-pages.ts
+function makeNextPagesHandler(reg, ctxFactory, options) {
+  return async function handler(req, res) {
+    const url = `${req.headers["x-forwarded-proto"] ?? "http"}://${req.headers.host}${req.url}`;
+    const method = req.method?.toUpperCase() || "GET";
+    const request = new Request(url, {
+      method,
+      headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, String(v)])),
+      body: method === "POST" ? JSON.stringify(req.body ?? {}) : undefined
+    });
+    const perReqHandler = createFetchHandler(reg, () => ctxFactory(req), options);
+    const response = await perReqHandler(request);
+    res.status(response.status);
+    response.headers.forEach((v, k) => res.setHeader(k, v));
+    const text = await response.text();
+    res.send(text);
+  };
+}
+export {
+  parseReturns,
+  makeNextPagesHandler,
+  makeNextAppHandler,
+  hydrateResourceIfNeeded,
+  expressRouter,
+  elysiaPlugin,
+  createInputTypeBuilder,
+  createFetchHandler
+};

package/dist/node/contracts-adapter-hydration.js

@@ -0,0 +1,40 @@
+// src/contracts-adapter-hydration.ts
+function parseReturns(returnsLike) {
+  if (!returnsLike)
+    return { isList: false, inner: "JSON" };
+  const trimmed = String(returnsLike).trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return { isList: true, inner: trimmed.slice(1, -1).trim() };
+  }
+  return { isList: false, inner: trimmed };
+}
+async function hydrateResourceIfNeeded(resources, result, opts) {
+  if (!resources || !opts.template)
+    return result;
+  const varName = opts.varName ?? "id";
+  const hydrateOne = async (item) => {
+    if (item && typeof item === "object" && varName in item) {
+      const key = String(item[varName]);
+      const uri = (opts.template ?? "").replace("{id}", key);
+      const match = resources.match(uri);
+      if (match) {
+        const resolved = await match.tmpl.resolve(match.params, {});
+        try {
+          return JSON.parse(String(resolved.data || "null"));
+        } catch {
+          return resolved.data;
+        }
+      }
+    }
+    return item;
+  };
+  if (opts.returns.isList && Array.isArray(result)) {
+    const hydrated = await Promise.all(result.map((x) => hydrateOne(x)));
+    return hydrated;
+  }
+  return await hydrateOne(result);
+}
+export {
+  parseReturns,
+  hydrateResourceIfNeeded
+};

package/dist/node/contracts-adapter-input.js

@@ -0,0 +1,99 @@
+// src/contracts-adapter-input.ts
+import { isSchemaModel } from "@contractspec/lib.schema";
+function isFieldType(x) {
+  return typeof x?.getPothos === "function";
+}
+function isEnumType(x) {
+  return typeof x?.getEnumValues === "function" && typeof x?.getPothos === "function";
+}
+function mapScalarName(name) {
+  if (name === "Boolean_unsecure")
+    return "Boolean";
+  if (name === "ID_unsecure")
+    return "ID";
+  if (name === "String_unsecure")
+    return "String";
+  if (name === "Int_unsecure")
+    return "Int";
+  if (name === "Float_unsecure")
+    return "Float";
+  return name;
+}
+function createInputTypeBuilder(builder) {
+  const inputTypeCache = new Map;
+  const enumTypeCache = new Set;
+  function registerEnumsForModel(model) {
+    const entries = Object.entries(model.config.fields);
+    for (const [, field] of entries) {
+      const fieldType = field.type;
+      if (isSchemaModel(fieldType)) {
+        registerEnumsForModel(fieldType);
+      } else if (isEnumType(field.type)) {
+        const enumObj = field.type;
+        const name = enumObj.getName?.() ?? enumObj.getPothos().name;
+        if (!enumTypeCache.has(name)) {
+          builder.enumType(name, {
+            values: enumObj.getEnumValues()
+          });
+          enumTypeCache.add(name);
+        }
+      }
+    }
+  }
+  function ensureInputTypeForModel(model) {
+    const typeName = String(model.config?.name ?? "Input");
+    const cached = inputTypeCache.get(typeName);
+    if (cached)
+      return cached;
+    registerEnumsForModel(model);
+    const created = builder.inputType(model.getPothosInput(), {
+      fields: (t) => {
+        const entries = Object.entries(model.config.fields);
+        const acc = {};
+        for (const [key, field] of entries) {
+          const fieldType = field.type;
+          if (isSchemaModel(fieldType)) {
+            const nested = ensureInputTypeForModel(fieldType);
+            const typeRef = field.isArray ? [nested] : nested;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else if (isFieldType(field.type)) {
+            const typeName2 = mapScalarName(String(field.type.getPothos().name));
+            const typeRef = field.isArray ? [typeName2] : typeName2;
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          } else {
+            const typeRef = field.isArray ? ["JSON"] : "JSON";
+            acc[key] = t.field({
+              type: typeRef,
+              required: !field.isOptional
+            });
+          }
+        }
+        return acc;
+      }
+    });
+    inputTypeCache.set(typeName, created);
+    return created;
+  }
+  function buildInputFieldArgs(model) {
+    if (!model)
+      return null;
+    if (!isSchemaModel(model)) {
+      return null;
+    }
+    if (!model.config?.fields || Object.keys(model.config.fields).length === 0) {
+      return null;
+    }
+    const ref = ensureInputTypeForModel(model);
+    return ref;
+  }
+  return { buildInputFieldArgs };
+}
+export {
+  createInputTypeBuilder
+};