@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/node/server/graphql-pothos.js

@@ -0,0 +1,338 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/jsonschema.ts
+import z from "zod";
+function jsonSchemaForSpec(spec) {
+  return {
+    input: spec.io.input ? z.toJSONSchema(spec.io.input.getZod()) : null,
+    output: spec.io.output ? z.toJSONSchema(spec.io.output.getZod()) : null,
+    meta: {
+      name: spec.meta.key,
+      version: spec.meta.version,
+      kind: spec.meta.kind,
+      description: spec.meta.description,
+      tags: spec.meta.tags ?? [],
+      stability: spec.meta.stability ?? "stable"
+    }
+  };
+}
+function defaultRestPath(name, version) {
+  return `/${name.replace(/\./g, "/")}/v${version}`;
+}
+function sanitizeMcpName(name) {
+  const sanitized = name.replace(/\./g, "_");
+  return sanitized.slice(0, 64);
+}
+function defaultMcpTool(name, version) {
+  const safeName = name.replace(/\./g, "_");
+  const safeVersion = version.replace(/\./g, "_");
+  return `${safeName}-v${safeVersion}`;
+}
+function defaultMcpPrompt(key) {
+  return sanitizeMcpName(key);
+}
+function defaultGqlField(name, version) {
+  return `${name.replace(/\./g, "_")}_v${version}`;
+}
+
+// src/server/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/server/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/server/graphql-pothos.ts
+import"@pothos/plugin-prisma";
+import"@pothos/plugin-complexity";
+import"@pothos/plugin-relay";
+import"@pothos/plugin-dataloader";
+import"@pothos/plugin-tracing";
+import { isSchemaModel as isSchemaModel2 } from "@contractspec/lib.schema";
+function registerContractsOnBuilder(builder, reg, resources) {
+  const { buildInputFieldArgs } = createInputTypeBuilder(builder);
+  const outputTypeCache = new Map;
+  for (const spec of reg.list()) {
+    const out = spec.io.output;
+    if (out && "getZod" in out && typeof out.getZod === "function") {
+      const model = out;
+      const typeName = isSchemaModel2(model) ? model.config?.name : "UnknownOutput";
+      if (typeName && !outputTypeCache.has(typeName)) {
+        outputTypeCache.set(typeName, model);
+      }
+    }
+  }
+  for (const [typeName, model] of outputTypeCache.entries()) {
+    if (!isSchemaModel2(model))
+      continue;
+    builder.objectType(typeName, {
+      fields: (t) => {
+        const entries = Object.entries(model.config.fields);
+        const acc = {};
+        for (const [key, field] of entries) {
+          const fieldType = field.type;
+          let gqlType = "JSON";
+          if (fieldType && typeof fieldType.getPothos === "function") {
+            const pothosInfo = fieldType.getPothos();
+            gqlType = pothosInfo.name || "JSON";
+            if (gqlType === "String_unsecure")
+              gqlType = "String";
+            if (gqlType === "Int_unsecure")
+              gqlType = "Int";
+            if (gqlType === "Float_unsecure")
+              gqlType = "Float";
+            if (gqlType === "Boolean_unsecure")
+              gqlType = "Boolean";
+            if (gqlType === "ID_unsecure")
+              gqlType = "ID";
+          }
+          const typeRef = field.isArray ? [gqlType] : gqlType;
+          acc[key] = t.field({
+            type: typeRef,
+            nullable: field.isOptional,
+            resolve: (parent) => parent[key]
+          });
+        }
+        return acc;
+      }
+    });
+  }
+  function resolveGraphQLTypeName(contractSpec) {
+    const returnsName = contractSpec.transport?.gql?.returns;
+    if (returnsName)
+      return returnsName;
+    const out = contractSpec.io.output ?? {};
+    if (out && "kind" in out && out.kind === "resource_ref" && "graphQLType" in out && out.graphQLType)
+      return String(out.graphQLType);
+    if (out && "getZod" in out && typeof out.getZod === "function") {
+      const model = out;
+      if (isSchemaModel2(model)) {
+        const typeName = model.config?.name;
+        if (typeName && outputTypeCache.has(typeName)) {
+          return typeName;
+        }
+      }
+    }
+    return "JSON";
+  }
+  for (const spec of reg.list()) {
+    const fieldName = spec.transport?.gql?.field ?? defaultGqlField(spec.meta.key, spec.meta.version);
+    const byIdField = spec.transport?.gql?.byIdField ?? "id";
+    const returnsResource = spec.transport?.gql?.resource;
+    const isQuery = spec.meta.kind === "query";
+    const graphQLTypeName = resolveGraphQLTypeName(spec);
+    const returnsDecl = spec.transport?.gql?.returns;
+    const parsed = parseReturns(returnsDecl ?? graphQLTypeName);
+    const resolveFieldFn = async (_root, args, ctx) => {
+      if (spec.policy.auth !== "anonymous" && !ctx.user)
+        throw new Error("Unauthorized");
+      const handlerCtx = {
+        traceId: ctx.logger?.getTraceId?.() ?? undefined,
+        userId: ctx.user?.id ?? null,
+        organizationId: ctx.session?.activeOrganizationId ?? null,
+        actor: ctx.user ? "user" : "anonymous",
+        channel: "web",
+        eventPublisher: ctx.eventPublisher
+      };
+      const parsedInput = spec.io.input?.getZod().parse(args.input ?? {});
+      const result = await reg.execute(spec.meta.key, spec.meta.version, parsedInput, handlerCtx);
+      const out = spec.io.output;
+      if (resources && (returnsResource || out?.kind === "resource_ref")) {
+        const varName = byIdField ?? out?.varName ?? "id";
+        const template = returnsResource ?? out?.uriTemplate;
+        const hydrated = await hydrateResourceIfNeeded(resources, result, {
+          template,
+          varName,
+          returns: parsed
+        });
+        if (hydrated !== result)
+          return hydrated;
+      }
+      if (graphQLTypeName) {
+        if (parsed.inner === "Boolean" && !parsed.isList)
+          return Boolean(result?.ok ?? result);
+        return result;
+      }
+      const parsedOut = spec.io.output.getZod().parse(result);
+      return parsedOut;
+    };
+    const fieldSettingsFn = (t) => {
+      const inputType = buildInputFieldArgs(spec.io.input);
+      return t.field({
+        type: parsed.isList ? [parsed.inner] : parsed.inner,
+        complexity: () => 10,
+        resolve: resolveFieldFn,
+        args: inputType ? {
+          input: t.arg({
+            type: inputType,
+            required: true
+          })
+        } : undefined
+      });
+    };
+    if (isQuery) {
+      builder.queryField(fieldName, fieldSettingsFn);
+    } else {
+      builder.mutationField(fieldName, fieldSettingsFn);
+    }
+  }
+}
+export {
+  registerContractsOnBuilder
+};