@lucern/contracts 0.1.2-alpha.5 → 0.3.0-alpha.1

package/dist/dsl.js

@@ -0,0 +1,678 @@
+import { z, ZodFirstPartyTypeKind } from 'zod';
+
+// src/dsl/defineFunction.ts
+function defineFunction(spec) {
+  return spec;
+}
+
+// src/dsl/defineTable.ts
+function defineTable(spec) {
+  return spec;
+}
+
+// src/dsl/errors.ts
+function formatPath(path) {
+  if (!path || path.length === 0) {
+    return "";
+  }
+  return path.join(".");
+}
+function formatLocation(context) {
+  const segments = [context.adapter];
+  if (context.purpose) {
+    segments.push(context.purpose);
+  }
+  if (context.location) {
+    segments.push(context.location);
+  }
+  const formattedPath = formatPath(context.path);
+  if (formattedPath) {
+    segments.push(formattedPath);
+  }
+  return segments.join(" :: ");
+}
+var SchemaAdapterError = class extends Error {
+  context;
+  constructor(message, context) {
+    super(`${message} [${formatLocation(context)}]`);
+    this.name = "SchemaAdapterError";
+    this.context = context;
+  }
+};
+function schemaAdapterError(message, context) {
+  return new SchemaAdapterError(message, context);
+}
+var CONVEX_ID_TABLE = /* @__PURE__ */ Symbol.for("lucern.contracts.convexIdTable");
+function idOf(table) {
+  const schema = z.string().brand();
+  Object.defineProperty(schema, CONVEX_ID_TABLE, {
+    configurable: false,
+    enumerable: false,
+    value: table,
+    writable: false
+  });
+  return schema;
+}
+function getConvexIdTable(schema) {
+  return schema[CONVEX_ID_TABLE];
+}
+function unsupported(message, state, path) {
+  throw schemaAdapterError(message, {
+    adapter: "cli",
+    location: state.location,
+    path
+  });
+}
+function getObjectShape(schema) {
+  const shape = typeof schema._def.shape === "function" ? schema._def.shape() : schema._def.shape;
+  return shape;
+}
+function unwrapField(schema, path) {
+  let current = schema;
+  let required = true;
+  let nullable = false;
+  let defaultValue;
+  while (true) {
+    switch (current._def.typeName) {
+      case ZodFirstPartyTypeKind.ZodOptional:
+        required = false;
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodDefault:
+        required = false;
+        defaultValue = current._def.defaultValue();
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodNullable:
+        nullable = true;
+        current = current._def.innerType;
+        continue;
+      default:
+        return {
+          schema: current,
+          required,
+          nullable,
+          defaultValue
+        };
+    }
+  }
+}
+function primitiveOption(name, kind, field, choices) {
+  return {
+    name,
+    kind,
+    required: field.required,
+    nullable: field.nullable || void 0,
+    defaultValue: field.defaultValue,
+    choices,
+    description: field.schema.description
+  };
+}
+function optionFromSchema(name, schema, state, path) {
+  const field = unwrapField(schema);
+  switch (field.schema._def.typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return primitiveOption(name, "string", field);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return primitiveOption(name, "number", field);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return primitiveOption(name, "bigint", field);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return primitiveOption(name, "boolean", field);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return primitiveOption(name, "string", field, field.schema._def.values);
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
+      const values = [...new Set(Object.values(field.schema._def.values))].filter(
+        (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+      );
+      return primitiveOption(
+        name,
+        values.every((value) => typeof value === "number") ? "number" : "string",
+        field,
+        values
+      );
+    }
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return primitiveOption(name, "string", field, [field.schema._def.value]);
+    case ZodFirstPartyTypeKind.ZodArray: {
+      const item = unwrapField(field.schema._def.type, [...path, "[]"]);
+      switch (item.schema._def.typeName) {
+        case ZodFirstPartyTypeKind.ZodString:
+          return { ...primitiveOption(name, "string", field), variadic: true };
+        case ZodFirstPartyTypeKind.ZodNumber:
+          return { ...primitiveOption(name, "number", field), variadic: true };
+        case ZodFirstPartyTypeKind.ZodBigInt:
+          return { ...primitiveOption(name, "bigint", field), variadic: true };
+        case ZodFirstPartyTypeKind.ZodBoolean:
+          return { ...primitiveOption(name, "boolean", field), variadic: true };
+        default:
+          return {
+            ...primitiveOption(name, "json", field),
+            variadic: false
+          };
+      }
+    }
+    case ZodFirstPartyTypeKind.ZodLazy: {
+      const lazySchema = field.schema;
+      if (state.seenLazySchemas.has(lazySchema)) {
+        unsupported(
+          "Recursive z.lazy schemas are not supported by the CLI adapter",
+          state,
+          path
+        );
+      }
+      state.seenLazySchemas.add(lazySchema);
+      try {
+        return optionFromSchema(name, lazySchema._def.getter(), state, path);
+      } finally {
+        state.seenLazySchemas.delete(lazySchema);
+      }
+    }
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return primitiveOption(name, "string", field);
+    case ZodFirstPartyTypeKind.ZodObject:
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case ZodFirstPartyTypeKind.ZodRecord:
+    case ZodFirstPartyTypeKind.ZodAny:
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return primitiveOption(name, "json", field);
+    default:
+      unsupported(
+        `Unsupported Zod schema kind ${field.schema._def.typeName}`,
+        state,
+        path
+      );
+  }
+}
+function zodToCli(schema, options = {}) {
+  if (schema._def.typeName !== ZodFirstPartyTypeKind.ZodObject) {
+    throw schemaAdapterError("CLI generation requires a Zod object schema", {
+      adapter: "cli",
+      location: options.location,
+      path: []
+    });
+  }
+  const state = {
+    location: options.location,
+    seenLazySchemas: /* @__PURE__ */ new WeakSet()
+  };
+  const optionsList = Object.entries(getObjectShape(schema)).sort(([left], [right]) => left.localeCompare(right)).map(([name, value]) => optionFromSchema(name, value, state, [name]));
+  return {
+    options: optionsList
+  };
+}
+function encodeLiteral(value) {
+  if (typeof value === "bigint") {
+    return `${value}n`;
+  }
+  return JSON.stringify(value);
+}
+function quoteKey(value) {
+  return JSON.stringify(value);
+}
+function sortEntries(entries) {
+  return [...entries].sort(([left], [right]) => left.localeCompare(right));
+}
+function getObjectShape2(schema) {
+  const shape = typeof schema._def.shape === "function" ? schema._def.shape() : schema._def.shape;
+  return shape;
+}
+function unwrapOptionalLike(schema, state, path) {
+  const defaults = [];
+  let current = schema;
+  let isOptional = false;
+  while (true) {
+    switch (current._def.typeName) {
+      case ZodFirstPartyTypeKind.ZodOptional:
+        isOptional = true;
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodDefault: {
+        if (state.purpose === "table") {
+          throw schemaAdapterError(
+            "Zod defaults are not allowed in table contracts",
+            {
+              adapter: "convex",
+              purpose: state.purpose,
+              location: state.location,
+              path
+            }
+          );
+        }
+        isOptional = true;
+        defaults.push({
+          path,
+          value: current._def.defaultValue()
+        });
+        current = current._def.innerType;
+        continue;
+      }
+      default:
+        return {
+          schema: current,
+          isOptional,
+          defaults
+        };
+    }
+  }
+}
+function convertSchema(schema, state, path) {
+  const { schema: unwrapped, isOptional, defaults } = unwrapOptionalLike(
+    schema,
+    state,
+    path
+  );
+  const converted = convertSchemaInner(unwrapped, state, path);
+  return {
+    source: isOptional ? `v.optional(${converted.source})` : converted.source,
+    defaults: [...defaults, ...converted.defaults]
+  };
+}
+function enumToUnion(values) {
+  if (values.length === 0) {
+    return "v.never()";
+  }
+  if (values.length === 1) {
+    return `v.literal(${encodeLiteral(values[0])})`;
+  }
+  return `v.union(${values.map((value) => `v.literal(${encodeLiteral(value)})`).join(", ")})`;
+}
+function unsupported2(message, state, path) {
+  throw schemaAdapterError(message, {
+    adapter: "convex",
+    purpose: state.purpose,
+    location: state.location,
+    path
+  });
+}
+function convertLazy(schema, state, path) {
+  const lazySchema = schema;
+  if (state.seenLazySchemas.has(lazySchema)) {
+    unsupported2(
+      "Recursive z.lazy schemas are not supported by the Convex adapter",
+      state,
+      path
+    );
+  }
+  state.seenLazySchemas.add(lazySchema);
+  try {
+    return convertSchema(lazySchema._def.getter(), state, path);
+  } finally {
+    state.seenLazySchemas.delete(lazySchema);
+  }
+}
+function convertSchemaInner(schema, state, path) {
+  const idTable = getConvexIdTable(schema);
+  if (idTable) {
+    return {
+      source: `v.id(${JSON.stringify(idTable)})`,
+      defaults: []
+    };
+  }
+  switch (schema._def.typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return { source: "v.string()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return { source: "v.number()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return { source: "v.int64()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return { source: "v.boolean()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodNull:
+      return { source: "v.null()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodAny:
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return { source: "v.any()", defaults: [] };
+    case ZodFirstPartyTypeKind.ZodLiteral: {
+      return {
+        source: `v.literal(${encodeLiteral(schema._def.value)})`,
+        defaults: []
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return {
+        source: enumToUnion(schema._def.values),
+        defaults: []
+      };
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
+      const values = Object.values(schema._def.values).filter(
+        (value) => typeof value === "string" || typeof value === "number"
+      );
+      return {
+        source: enumToUnion([...new Set(values)]),
+        defaults: []
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodNullable: {
+      const inner = convertSchema(schema._def.innerType, state, path);
+      return {
+        source: `v.nullable(${inner.source})`,
+        defaults: inner.defaults
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodArray: {
+      const inner = convertSchema(schema._def.type, state, [...path, "[]"]);
+      return {
+        source: `v.array(${inner.source})`,
+        defaults: inner.defaults
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodObject: {
+      const objectSchema = schema;
+      if (objectSchema._def.catchall && objectSchema._def.catchall._def.typeName !== ZodFirstPartyTypeKind.ZodNever) {
+        unsupported2(
+          "Zod objects with catchall/passthrough fields cannot be lowered to Convex validators",
+          state,
+          path
+        );
+      }
+      const fields = sortEntries(Object.entries(getObjectShape2(objectSchema)));
+      const convertedFields = fields.map(([key, value]) => [
+        key,
+        convertSchema(value, state, [...path, key])
+      ]);
+      return {
+        source: `v.object({ ${convertedFields.map(([key, converted]) => `${quoteKey(key)}: ${converted.source}`).join(", ")} })`,
+        defaults: convertedFields.flatMap(([, converted]) => converted.defaults)
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodUnion: {
+      const members = schema._def.options.map(
+        (option, index) => convertSchema(option, state, [...path, String(index)])
+      );
+      return {
+        source: `v.union(${members.map((member) => member.source).join(", ")})`,
+        defaults: members.flatMap((member) => member.defaults)
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+      const discriminatedUnion = schema;
+      const options = discriminatedUnion.options instanceof Map ? [...discriminatedUnion.options.values()] : [...discriminatedUnion.options];
+      const members = options.map(
+        (option, index) => convertSchema(option, state, [...path, String(index)])
+      );
+      return {
+        source: `v.union(${members.map((member) => member.source).join(", ")})`,
+        defaults: members.flatMap((member) => member.defaults)
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodRecord: {
+      const keyType = schema._def.keyType;
+      if (keyType && keyType._def.typeName !== ZodFirstPartyTypeKind.ZodString) {
+        unsupported2(
+          "Only string-keyed z.record schemas can be lowered to Convex validators",
+          state,
+          path
+        );
+      }
+      const value = convertSchema(schema._def.valueType, state, [...path, "{}"]);
+      return {
+        source: `v.record(v.string(), ${value.source})`,
+        defaults: value.defaults
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return convertLazy(schema, state, path);
+    case ZodFirstPartyTypeKind.ZodBranded: {
+      return convertSchema(schema._def.type, state, path);
+    }
+    case ZodFirstPartyTypeKind.ZodEffects: {
+      return convertSchema(schema._def.schema, state, path);
+    }
+    default:
+      unsupported2(`Unsupported Zod schema kind ${schema._def.typeName}`, state, path);
+  }
+}
+function zodToConvex(schema, options = {}) {
+  const state = {
+    location: options.location,
+    purpose: options.purpose ?? "function_returns",
+    seenLazySchemas: /* @__PURE__ */ new WeakSet()
+  };
+  const converted = convertSchema(schema, state, []);
+  return {
+    source: converted.source,
+    defaults: converted.defaults
+  };
+}
+function tableIndexToConvexSource(index) {
+  switch (index.kind) {
+    case "index":
+      return `.index(${JSON.stringify(index.name)}, [${index.columns.map((column) => JSON.stringify(column)).join(", ")}])`;
+    case "search":
+      return `.searchIndex(${JSON.stringify(index.name)}, { searchField: ${JSON.stringify(
+        index.searchField
+      )}${index.filterFields?.length ? `, filterFields: [${index.filterFields.map((field) => JSON.stringify(field)).join(", ")}]` : ""} })`;
+    case "vector":
+      return `.vectorIndex(${JSON.stringify(index.name)}, { vectorField: ${JSON.stringify(
+        index.vectorField
+      )}, dimensions: ${index.dimensions}${index.filterFields?.length ? `, filterFields: [${index.filterFields.map((field) => JSON.stringify(field)).join(", ")}]` : ""} })`;
+    default: {
+      const exhaustive = index;
+      throw new SchemaAdapterError(
+        `Unsupported table index kind ${exhaustive.kind ?? "unknown"}`,
+        { adapter: "convex" }
+      );
+    }
+  }
+}
+function unsupported3(message, state, path) {
+  throw schemaAdapterError(message, {
+    adapter: "jsonschema",
+    location: state.location,
+    path
+  });
+}
+function getObjectShape3(schema) {
+  const shape = typeof schema._def.shape === "function" ? schema._def.shape() : schema._def.shape;
+  return shape;
+}
+function unwrapOptionalLike2(schema, state, path) {
+  let current = schema;
+  let required = true;
+  let defaultValue;
+  while (true) {
+    switch (current._def.typeName) {
+      case ZodFirstPartyTypeKind.ZodOptional:
+        required = false;
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodDefault:
+        required = false;
+        defaultValue = current._def.defaultValue();
+        current = current._def.innerType;
+        continue;
+      default:
+        return {
+          schema: current,
+          required,
+          defaultValue
+        };
+    }
+  }
+}
+function convertLazy2(schema, state, path) {
+  if (state.seenLazySchemas.has(schema)) {
+    unsupported3(
+      "Recursive z.lazy schemas are not supported by the JSON Schema adapter",
+      state,
+      path
+    );
+  }
+  state.seenLazySchemas.add(schema);
+  try {
+    return convertSchema2(schema._def.getter(), state, path);
+  } finally {
+    state.seenLazySchemas.delete(schema);
+  }
+}
+function literalType(value) {
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return Number.isInteger(value) ? "integer" : "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "integer";
+    default:
+      return value === null ? "null" : void 0;
+  }
+}
+function convertField(schema, state, path) {
+  const { schema: unwrapped, required, defaultValue } = unwrapOptionalLike2(
+    schema);
+  const field = convertSchema2(unwrapped, state, path);
+  if (typeof field === "boolean") {
+    return {
+      schema: field,
+      required
+    };
+  }
+  return {
+    schema: defaultValue === void 0 ? field : { ...field, default: defaultValue },
+    required
+  };
+}
+function convertSchema2(schema, state, path) {
+  const idTable = getConvexIdTable(schema);
+  if (idTable) {
+    return {
+      type: "string",
+      "x-convex-id-table": idTable
+    };
+  }
+  switch (schema._def.typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return { type: "string" };
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return { type: "number" };
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return { type: "integer", format: "int64" };
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return { type: "boolean" };
+    case ZodFirstPartyTypeKind.ZodNull:
+      return { type: "null" };
+    case ZodFirstPartyTypeKind.ZodAny:
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return {};
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return {
+        const: schema._def.value,
+        type: literalType(schema._def.value)
+      };
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return {
+        type: "string",
+        enum: schema._def.values
+      };
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
+      const values = [...new Set(Object.values(schema._def.values))].filter(
+        (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+      );
+      return {
+        type: values.every((value) => typeof value === "number") ? "number" : "string",
+        enum: values
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodNullable: {
+      const inner = convertSchema2(schema._def.innerType, state, path);
+      return {
+        anyOf: [inner, { type: "null" }]
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodArray:
+      return {
+        type: "array",
+        items: convertSchema2(schema._def.type, state, [...path, "[]"])
+      };
+    case ZodFirstPartyTypeKind.ZodObject: {
+      const objectSchema = schema;
+      if (objectSchema._def.catchall && objectSchema._def.catchall._def.typeName !== ZodFirstPartyTypeKind.ZodNever) {
+        unsupported3(
+          "Zod objects with catchall/passthrough fields cannot be lowered to JSON Schema",
+          state,
+          path
+        );
+      }
+      const entries = Object.entries(getObjectShape3(objectSchema)).sort(
+        ([a], [b]) => a.localeCompare(b)
+      );
+      const converted = entries.map(([key, value]) => [
+        key,
+        convertField(value, state, [...path, key])
+      ]);
+      const required = converted.filter(([, field]) => field.required).map(([key]) => key);
+      return {
+        type: "object",
+        properties: Object.fromEntries(
+          converted.map(([key, field]) => [key, field.schema])
+        ),
+        additionalProperties: false,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodUnion:
+      return {
+        anyOf: schema._def.options.map(
+          (option, index) => convertSchema2(option, state, [...path, String(index)])
+        )
+      };
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+      const discriminatedUnion = schema;
+      const options = discriminatedUnion.options instanceof Map ? [...discriminatedUnion.options.values()] : [...discriminatedUnion.options];
+      return {
+        oneOf: options.map(
+          (option, index) => convertSchema2(option, state, [...path, String(index)])
+        )
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodRecord: {
+      const keyType = schema._def.keyType;
+      if (keyType && keyType._def.typeName !== ZodFirstPartyTypeKind.ZodString) {
+        unsupported3(
+          "Only string-keyed z.record schemas can be lowered to JSON Schema",
+          state,
+          path
+        );
+      }
+      return {
+        type: "object",
+        additionalProperties: convertSchema2(
+          schema._def.valueType,
+          state,
+          [...path, "{}"]
+        )
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return convertLazy2(schema, state, path);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return convertSchema2(schema._def.type, state, path);
+    default:
+      unsupported3(
+        `Unsupported Zod schema kind ${schema._def.typeName}`,
+        state,
+        path
+      );
+  }
+}
+function zodToJsonSchema(schema, options = {}) {
+  const converted = convertSchema2(schema, {
+    location: options.location,
+    seenLazySchemas: /* @__PURE__ */ new WeakSet()
+  }, []);
+  if (typeof converted === "boolean") {
+    return converted;
+  }
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    ...converted
+  };
+}
+
+export { CONVEX_ID_TABLE, SchemaAdapterError, defineFunction, defineTable, getConvexIdTable, idOf, schemaAdapterError, tableIndexToConvexSource, zodToCli, zodToConvex, zodToJsonSchema };
+//# sourceMappingURL=dsl.js.map
+//# sourceMappingURL=dsl.js.map