@contractspec/lib.schema 1.57.0 → 1.58.0

package/dist/node/EnumType.js

@@ -0,0 +1,40 @@
+// src/EnumType.ts
+import * as z from "zod";
+import { GraphQLEnumType } from "graphql";
+
+class EnumType {
+  name;
+  values;
+  gqlEnum;
+  constructor(name, values) {
+    this.name = name;
+    this.values = values;
+    this.gqlEnum = new GraphQLEnumType({
+      name: this.name,
+      values: Object.fromEntries(values.map((v) => [v, { value: v }]))
+    });
+  }
+  getName() {
+    return this.name;
+  }
+  getEnumValues() {
+    return this.values;
+  }
+  getPothos() {
+    return this.gqlEnum;
+  }
+  getZod() {
+    return z.enum(this.values);
+  }
+  getJson() {
+    return { type: "string", enum: this.values };
+  }
+  getJsonSchema() {
+    return this.getJson();
+  }
+}
+var defineEnum = (name, values) => new EnumType(name, values);
+export {
+  defineEnum,
+  EnumType
+};

package/dist/node/FieldType.js

@@ -0,0 +1,43 @@
+// src/FieldType.ts
+import { GraphQLScalarType } from "graphql";
+
+class FieldType extends GraphQLScalarType {
+  zodSchema;
+  jsonSchemaDef;
+  constructor(config) {
+    super(config);
+    this.zodSchema = config.zod;
+    this.jsonSchemaDef = config.jsonSchema;
+  }
+  getZod() {
+    return this.zodSchema;
+  }
+  getPothos() {
+    return this;
+  }
+  getJson() {
+    return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+  }
+  getJsonSchemaDef() {
+    return this.jsonSchemaDef;
+  }
+  getJsonSchema() {
+    const deepResolve = (v) => {
+      const value = typeof v === "function" ? v() : v;
+      if (Array.isArray(value))
+        return value.map((item) => deepResolve(item));
+      if (value && typeof value === "object") {
+        const obj = {};
+        for (const [k, val] of Object.entries(value)) {
+          obj[k] = deepResolve(val);
+        }
+        return obj;
+      }
+      return value;
+    };
+    return deepResolve(this.getJson());
+  }
+}
+export {
+  FieldType
+};

package/dist/node/GraphQLSchemaType.js

@@ -0,0 +1,18 @@
+// src/GraphQLSchemaType.ts
+import { z } from "zod";
+
+class GraphQLSchemaType {
+  typeDef;
+  name;
+  _isSchemaType = true;
+  constructor(typeDef, name) {
+    this.typeDef = typeDef;
+    this.name = name;
+  }
+  getZod() {
+    return z.unknown();
+  }
+}
+export {
+  GraphQLSchemaType
+};

package/dist/node/JsonSchemaType.js

@@ -0,0 +1,74 @@
+// src/JsonSchemaType.ts
+import * as z from "zod";
+
+class JsonSchemaType {
+  jsonSchema;
+  options;
+  constructor(jsonSchema, options = {}) {
+    this.jsonSchema = jsonSchema;
+    this.options = options;
+  }
+  getZod() {
+    if (this.jsonSchema.additionalProperties !== undefined) {
+      if (this.jsonSchema.additionalProperties === true) {
+        return z.record(z.string(), z.unknown());
+      }
+      if (typeof this.jsonSchema.additionalProperties === "object") {
+        return z.record(z.string(), z.unknown());
+      }
+      if (this.jsonSchema.additionalProperties === false) {
+        return z.object({}).strict();
+      }
+    }
+    if (this.jsonSchema.properties) {
+      const shape = {};
+      const required = new Set(this.jsonSchema.required ?? []);
+      for (const [key, propSchema] of Object.entries(this.jsonSchema.properties)) {
+        const fieldType = this.convertPropertyToZod(propSchema);
+        shape[key] = required.has(key) ? fieldType : fieldType.optional();
+      }
+      return z.object(shape).passthrough();
+    }
+    return z.object({}).passthrough();
+  }
+  getJsonSchema() {
+    return this.jsonSchema;
+  }
+  getPothos() {
+    return { type: "JSON", name: this.options.name };
+  }
+  getName() {
+    return this.options.name;
+  }
+  convertPropertyToZod(schema) {
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    switch (type) {
+      case "string":
+        return z.string();
+      case "number":
+      case "integer":
+        return z.number();
+      case "boolean":
+        return z.boolean();
+      case "array":
+        if (schema.items && !Array.isArray(schema.items)) {
+          return z.array(this.convertPropertyToZod(schema.items));
+        }
+        return z.array(z.unknown());
+      case "object":
+        if (schema.properties) {
+          return new JsonSchemaType(schema).getZod();
+        }
+        return z.record(z.string(), z.unknown());
+      case "null":
+        return z.null();
+      default:
+        return z.unknown();
+    }
+  }
+}
+var fromJsonSchema = (schema, options) => new JsonSchemaType(schema, options);
+export {
+  fromJsonSchema,
+  JsonSchemaType
+};

package/dist/node/ScalarTypeEnum.js

@@ -0,0 +1,236 @@
+// src/FieldType.ts
+import { GraphQLScalarType } from "graphql";
+
+class FieldType extends GraphQLScalarType {
+  zodSchema;
+  jsonSchemaDef;
+  constructor(config) {
+    super(config);
+    this.zodSchema = config.zod;
+    this.jsonSchemaDef = config.jsonSchema;
+  }
+  getZod() {
+    return this.zodSchema;
+  }
+  getPothos() {
+    return this;
+  }
+  getJson() {
+    return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+  }
+  getJsonSchemaDef() {
+    return this.jsonSchemaDef;
+  }
+  getJsonSchema() {
+    const deepResolve = (v) => {
+      const value = typeof v === "function" ? v() : v;
+      if (Array.isArray(value))
+        return value.map((item) => deepResolve(item));
+      if (value && typeof value === "object") {
+        const obj = {};
+        for (const [k, val] of Object.entries(value)) {
+          obj[k] = deepResolve(val);
+        }
+        return obj;
+      }
+      return value;
+    };
+    return deepResolve(this.getJson());
+  }
+}
+
+// src/ScalarTypeEnum.ts
+import * as z from "zod";
+import { Kind } from "graphql";
+var localeRegex = /^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/;
+var timezoneRegex = /^(?:UTC|[A-Za-z_]+\/[A-Za-z_]+)$/;
+var phoneRegex = /^[+]?\d[\d\s().-]{3,}$/;
+var currencyRegex = /^[A-Z]{3}$/;
+var countryRegex = /^[A-Z]{2}$/;
+var latMin = -90;
+var latMax = 90;
+var lonMin = -180;
+var lonMax = 180;
+var ScalarTypeEnum = {
+  String_unsecure: () => new FieldType({
+    name: "String_unsecure",
+    description: "Unvalidated string scalar",
+    zod: z.string(),
+    parseValue: (v) => z.string().parse(v),
+    serialize: (v) => String(v),
+    parseLiteral: (ast) => {
+      if (ast.kind !== Kind.STRING)
+        throw new TypeError("Invalid literal");
+      return ast.value;
+    },
+    jsonSchema: { type: "string" }
+  }),
+  Int_unsecure: () => new FieldType({
+    name: "Int_unsecure",
+    description: "Unvalidated integer scalar",
+    zod: z.number().int(),
+    parseValue: (v) => {
+      const num = typeof v === "number" ? v : Number(v);
+      return z.number().int().parse(num);
+    },
+    serialize: (v) => Math.trunc(typeof v === "number" ? v : Number(v)),
+    parseLiteral: (ast) => {
+      if (ast.kind !== Kind.INT)
+        throw new TypeError("Invalid literal");
+      return Number(ast.value);
+    },
+    jsonSchema: { type: "integer" }
+  }),
+  Float_unsecure: () => new FieldType({
+    name: "Float_unsecure",
+    description: "Unvalidated float scalar",
+    zod: z.number(),
+    parseValue: (v) => {
+      const num = typeof v === "number" ? v : Number(v);
+      return z.number().parse(num);
+    },
+    serialize: (v) => Number(v),
+    parseLiteral: (ast) => {
+      if (ast.kind !== Kind.FLOAT && ast.kind !== Kind.INT)
+        throw new TypeError("Invalid literal");
+      return Number(ast.value);
+    },
+    jsonSchema: { type: "number" }
+  }),
+  Boolean: () => new FieldType({
+    name: "Boolean",
+    description: "Unvalidated boolean scalar",
+    zod: z.boolean(),
+    parseValue: (v) => z.coerce.boolean().parse(v),
+    serialize: (v) => Boolean(v),
+    parseLiteral: (ast) => {
+      if (ast.kind !== Kind.BOOLEAN)
+        throw new TypeError("Invalid literal");
+      return ast.value;
+    },
+    jsonSchema: { type: "boolean" }
+  }),
+  ID: () => new FieldType({
+    name: "ID",
+    description: "Unvalidated id scalar",
+    zod: z.string(),
+    parseValue: (v) => z.string().parse(v),
+    serialize: (v) => String(v),
+    parseLiteral: (ast) => {
+      if (ast.kind !== Kind.STRING)
+        throw new TypeError("Invalid literal");
+      return ast.value;
+    },
+    jsonSchema: { type: "string" }
+  }),
+  JSON: () => new FieldType({
+    name: "JSON",
+    zod: z.any(),
+    parseValue: (v) => v,
+    serialize: (v) => v,
+    jsonSchema: {}
+  }),
+  JSONObject: () => new FieldType({
+    name: "JSONObject",
+    zod: z.record(z.string(), z.any()),
+    parseValue: (v) => z.record(z.string(), z.any()).parse(v),
+    serialize: (v) => v ?? {},
+    jsonSchema: { type: "object" }
+  }),
+  Date: () => new FieldType({
+    name: "Date",
+    zod: z.date(),
+    parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+    serialize: (v) => v instanceof Date ? v.toISOString().split("T")[0] : String(v),
+    jsonSchema: { type: "string", format: "date" }
+  }),
+  DateTime: () => new FieldType({
+    name: "DateTime",
+    zod: z.date(),
+    parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+    serialize: (v) => {
+      return v instanceof Date ? v.toISOString() : String(v);
+    },
+    jsonSchema: { type: "string", format: "date-time" }
+  }),
+  Time: () => new FieldType({
+    name: "Time",
+    zod: z.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),
+    parseValue: (v) => z.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: "^\\d{2}:\\d{2}(:\\d{2})?$" }
+  }),
+  EmailAddress: () => new FieldType({
+    name: "EmailAddress",
+    zod: z.string().email(),
+    parseValue: (v) => z.string().email().parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", format: "email" }
+  }),
+  URL: () => new FieldType({
+    name: "URL",
+    zod: z.string().url(),
+    parseValue: (v) => z.string().url().parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", format: "uri" }
+  }),
+  PhoneNumber: () => new FieldType({
+    name: "PhoneNumber",
+    zod: z.string().regex(phoneRegex),
+    parseValue: (v) => z.string().regex(phoneRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: phoneRegex.source }
+  }),
+  NonEmptyString: () => new FieldType({
+    name: "NonEmptyString",
+    zod: z.string().min(1),
+    parseValue: (v) => z.string().min(1).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", minLength: 1 }
+  }),
+  Locale: () => new FieldType({
+    name: "Locale",
+    zod: z.string().regex(localeRegex),
+    parseValue: (v) => z.string().regex(localeRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: localeRegex.source }
+  }),
+  TimeZone: () => new FieldType({
+    name: "TimeZone",
+    zod: z.string().regex(timezoneRegex),
+    parseValue: (v) => z.string().regex(timezoneRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: timezoneRegex.source }
+  }),
+  Latitude: () => new FieldType({
+    name: "Latitude",
+    zod: z.number().min(latMin).max(latMax),
+    parseValue: (v) => z.coerce.number().min(latMin).max(latMax).parse(v),
+    serialize: (v) => Number(v),
+    jsonSchema: { type: "number", minimum: latMin, maximum: latMax }
+  }),
+  Longitude: () => new FieldType({
+    name: "Longitude",
+    zod: z.number().min(lonMin).max(lonMax),
+    parseValue: (v) => z.coerce.number().min(lonMin).max(lonMax).parse(v),
+    serialize: (v) => Number(v),
+    jsonSchema: { type: "number", minimum: lonMin, maximum: lonMax }
+  }),
+  Currency: () => new FieldType({
+    name: "Currency",
+    zod: z.string().regex(currencyRegex),
+    parseValue: (v) => z.string().regex(currencyRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: currencyRegex.source }
+  }),
+  CountryCode: () => new FieldType({
+    name: "CountryCode",
+    zod: z.string().regex(countryRegex),
+    parseValue: (v) => z.string().regex(countryRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: countryRegex.source }
+  })
+};
+export {
+  ScalarTypeEnum
+};

package/dist/node/SchemaModel.js

@@ -0,0 +1,30 @@
+// src/SchemaModel.ts
+import * as z from "zod";
+
+class SchemaModel {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getZod() {
+    const shape = Object.entries(this.config.fields).reduce((acc, [key, def]) => {
+      const base = def.type.getZod();
+      const withArray = def.isArray ? z.array(base) : base;
+      acc[key] = def.isOptional ? withArray.optional() : withArray;
+      return acc;
+    }, {});
+    return z.object(shape);
+  }
+  getPothosInput() {
+    return this.config.name;
+  }
+}
+function isSchemaModel(model) {
+  return model !== null && model !== undefined && "config" in model && typeof model.config === "object" && "name" in model.config;
+}
+var defineSchemaModel = (config) => new SchemaModel(config);
+export {
+  isSchemaModel,
+  defineSchemaModel,
+  SchemaModel
+};

package/dist/node/SchemaModelType.js

@@ -0,0 +1,7 @@
+// src/SchemaModelType.ts
+function isSchemaType(value) {
+  return value !== null && typeof value === "object" && "getZod" in value && typeof value.getZod === "function";
+}
+export {
+  isSchemaType
+};

package/dist/node/ZodSchemaType.js

@@ -0,0 +1,31 @@
+// src/ZodSchemaType.ts
+import * as z from "zod";
+
+class ZodSchemaType {
+  schema;
+  options;
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.options = options;
+  }
+  getZod() {
+    return this.schema;
+  }
+  getJsonSchema() {
+    return z.toJSONSchema(this.schema);
+  }
+  getPothos() {
+    return { type: "JSON", name: this.options.name };
+  }
+  getName() {
+    return this.options.name;
+  }
+  getDescription() {
+    return this.options.description;
+  }
+}
+var fromZod = (schema, options) => new ZodSchemaType(schema, options);
+export {
+  fromZod,
+  ZodSchemaType
+};

package/dist/node/entity/defineEntity.js

@@ -0,0 +1,128 @@
+// src/entity/defineEntity.ts
+import * as z from "zod";
+function defineEntity(spec) {
+  return spec;
+}
+function defineEntityEnum(def) {
+  return def;
+}
+var field = {
+  string(opts) {
+    return { kind: "scalar", type: "String", ...opts };
+  },
+  int(opts) {
+    return { kind: "scalar", type: "Int", ...opts };
+  },
+  float(opts) {
+    return { kind: "scalar", type: "Float", ...opts };
+  },
+  boolean(opts) {
+    return { kind: "scalar", type: "Boolean", ...opts };
+  },
+  dateTime(opts) {
+    return { kind: "scalar", type: "DateTime", ...opts };
+  },
+  json(opts) {
+    return { kind: "scalar", type: "Json", ...opts };
+  },
+  bigInt(opts) {
+    return { kind: "scalar", type: "BigInt", ...opts };
+  },
+  decimal(opts) {
+    return { kind: "scalar", type: "Decimal", ...opts };
+  },
+  bytes(opts) {
+    return { kind: "scalar", type: "Bytes", ...opts };
+  },
+  id(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      isId: true,
+      default: "cuid()",
+      ...opts
+    };
+  },
+  uuid(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      isId: true,
+      default: "uuid()",
+      ...opts
+    };
+  },
+  autoIncrement(opts) {
+    return {
+      kind: "scalar",
+      type: "Int",
+      isId: true,
+      default: "autoincrement()",
+      ...opts
+    };
+  },
+  createdAt(opts) {
+    return { kind: "scalar", type: "DateTime", default: "now()", ...opts };
+  },
+  updatedAt(opts) {
+    return { kind: "scalar", type: "DateTime", updatedAt: true, ...opts };
+  },
+  email(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      zod: z.email(),
+      ...opts
+    };
+  },
+  url(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      zod: z.url(),
+      ...opts
+    };
+  },
+  enum(enumName, opts) {
+    return { kind: "enum", enumName, ...opts };
+  },
+  inlineEnum(enumName, values, opts) {
+    return { kind: "enum", enumName, values, ...opts };
+  },
+  hasOne(target, opts) {
+    return { kind: "relation", type: "hasOne", target, ...opts };
+  },
+  hasMany(target, opts) {
+    return { kind: "relation", type: "hasMany", target, ...opts };
+  },
+  belongsTo(target, fields, references, opts) {
+    return {
+      kind: "relation",
+      type: "belongsTo",
+      target,
+      fields,
+      references,
+      ...opts
+    };
+  },
+  foreignKey(opts) {
+    return { kind: "scalar", type: "String", ...opts };
+  }
+};
+var index = {
+  on(fields, opts) {
+    return { fields, ...opts };
+  },
+  unique(fields, opts) {
+    return { fields, unique: true, ...opts };
+  },
+  compound(fields, sort, opts) {
+    return { fields, sort, ...opts };
+  }
+};
+export {
+  index,
+  field,
+  defineEntityEnum,
+  defineEntity
+};