@contractspec/lib.schema 1.57.0 → 1.58.0

package/dist/node/index.js

@@ -0,0 +1,840 @@
+// 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);
+
+// 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/GraphQLSchemaType.ts
+import { z as z2 } from "zod";
+
+class GraphQLSchemaType {
+  typeDef;
+  name;
+  _isSchemaType = true;
+  constructor(typeDef, name) {
+    this.typeDef = typeDef;
+    this.name = name;
+  }
+  getZod() {
+    return z2.unknown();
+  }
+}
+
+// src/JsonSchemaType.ts
+import * as z3 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 z3.record(z3.string(), z3.unknown());
+      }
+      if (typeof this.jsonSchema.additionalProperties === "object") {
+        return z3.record(z3.string(), z3.unknown());
+      }
+      if (this.jsonSchema.additionalProperties === false) {
+        return z3.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 z3.object(shape).passthrough();
+    }
+    return z3.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 z3.string();
+      case "number":
+      case "integer":
+        return z3.number();
+      case "boolean":
+        return z3.boolean();
+      case "array":
+        if (schema.items && !Array.isArray(schema.items)) {
+          return z3.array(this.convertPropertyToZod(schema.items));
+        }
+        return z3.array(z3.unknown());
+      case "object":
+        if (schema.properties) {
+          return new JsonSchemaType(schema).getZod();
+        }
+        return z3.record(z3.string(), z3.unknown());
+      case "null":
+        return z3.null();
+      default:
+        return z3.unknown();
+    }
+  }
+}
+var fromJsonSchema = (schema, options) => new JsonSchemaType(schema, options);
+
+// src/ScalarTypeEnum.ts
+import * as z4 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: z4.string(),
+    parseValue: (v) => z4.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: z4.number().int(),
+    parseValue: (v) => {
+      const num = typeof v === "number" ? v : Number(v);
+      return z4.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: z4.number(),
+    parseValue: (v) => {
+      const num = typeof v === "number" ? v : Number(v);
+      return z4.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: z4.boolean(),
+    parseValue: (v) => z4.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: z4.string(),
+    parseValue: (v) => z4.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: z4.any(),
+    parseValue: (v) => v,
+    serialize: (v) => v,
+    jsonSchema: {}
+  }),
+  JSONObject: () => new FieldType({
+    name: "JSONObject",
+    zod: z4.record(z4.string(), z4.any()),
+    parseValue: (v) => z4.record(z4.string(), z4.any()).parse(v),
+    serialize: (v) => v ?? {},
+    jsonSchema: { type: "object" }
+  }),
+  Date: () => new FieldType({
+    name: "Date",
+    zod: z4.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: z4.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: z4.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),
+    parseValue: (v) => z4.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: z4.string().email(),
+    parseValue: (v) => z4.string().email().parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", format: "email" }
+  }),
+  URL: () => new FieldType({
+    name: "URL",
+    zod: z4.string().url(),
+    parseValue: (v) => z4.string().url().parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", format: "uri" }
+  }),
+  PhoneNumber: () => new FieldType({
+    name: "PhoneNumber",
+    zod: z4.string().regex(phoneRegex),
+    parseValue: (v) => z4.string().regex(phoneRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: phoneRegex.source }
+  }),
+  NonEmptyString: () => new FieldType({
+    name: "NonEmptyString",
+    zod: z4.string().min(1),
+    parseValue: (v) => z4.string().min(1).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", minLength: 1 }
+  }),
+  Locale: () => new FieldType({
+    name: "Locale",
+    zod: z4.string().regex(localeRegex),
+    parseValue: (v) => z4.string().regex(localeRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: localeRegex.source }
+  }),
+  TimeZone: () => new FieldType({
+    name: "TimeZone",
+    zod: z4.string().regex(timezoneRegex),
+    parseValue: (v) => z4.string().regex(timezoneRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: timezoneRegex.source }
+  }),
+  Latitude: () => new FieldType({
+    name: "Latitude",
+    zod: z4.number().min(latMin).max(latMax),
+    parseValue: (v) => z4.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: z4.number().min(lonMin).max(lonMax),
+    parseValue: (v) => z4.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: z4.string().regex(currencyRegex),
+    parseValue: (v) => z4.string().regex(currencyRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: currencyRegex.source }
+  }),
+  CountryCode: () => new FieldType({
+    name: "CountryCode",
+    zod: z4.string().regex(countryRegex),
+    parseValue: (v) => z4.string().regex(countryRegex).parse(v),
+    serialize: (v) => String(v),
+    jsonSchema: { type: "string", pattern: countryRegex.source }
+  })
+};
+
+// src/SchemaModel.ts
+import * as z5 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 ? z5.array(base) : base;
+      acc[key] = def.isOptional ? withArray.optional() : withArray;
+      return acc;
+    }, {});
+    return z5.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);
+
+// src/SchemaModelType.ts
+function isSchemaType(value) {
+  return value !== null && typeof value === "object" && "getZod" in value && typeof value.getZod === "function";
+}
+
+// src/ZodSchemaType.ts
+import * as z6 from "zod";
+
+class ZodSchemaType {
+  schema;
+  options;
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.options = options;
+  }
+  getZod() {
+    return this.schema;
+  }
+  getJsonSchema() {
+    return z6.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);
+
+// src/entity/defineEntity.ts
+import * as z7 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: z7.email(),
+      ...opts
+    };
+  },
+  url(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      zod: z7.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 };
+  }
+};
+
+// src/entity/generator.ts
+function generatePrismaSchema(entities, options = {}) {
+  const {
+    provider = "postgresql",
+    clientOutput = "../../src/generated/prisma",
+    includePothos = true,
+    pothosOutput = "../../src/generated/pothos-types.ts"
+  } = options;
+  const lines = [];
+  const schemas = new Set;
+  entities.forEach((entity) => {
+    if (entity.schema) {
+      schemas.add(entity.schema);
+    }
+  });
+  const schemaList = schemas.size > 0 ? Array.from(schemas) : ["public"];
+  lines.push("datasource db {");
+  lines.push(`  provider = "${provider}"`);
+  if (schemas.size > 0) {
+    lines.push(`  schemas  = [${schemaList.map((s) => `"${s}"`).join(", ")}]`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("generator client {");
+  lines.push('  provider = "prisma-client"');
+  lines.push(`  output   = "${clientOutput}"`);
+  lines.push("");
+  lines.push('  engineType             = "client"');
+  lines.push('  runtime                = "bun"');
+  lines.push('  moduleFormat           = "esm"');
+  lines.push('  generatedFileExtension = "ts"');
+  lines.push('  importFileExtension    = "ts"');
+  lines.push("}");
+  lines.push("");
+  if (includePothos) {
+    lines.push("generator pothos {");
+    lines.push('  provider          = "prisma-pothos-types"');
+    lines.push('  clientOutput      = "./prisma"');
+    lines.push(`  output            = "${pothosOutput}"`);
+    lines.push("  generateDatamodel = true");
+    lines.push("  documentation     = false");
+    lines.push("}");
+    lines.push("");
+  }
+  const enumMap = new Map;
+  entities.forEach((entity) => {
+    entity.enums?.forEach((enumDef) => {
+      if (!enumMap.has(enumDef.name)) {
+        enumMap.set(enumDef.name, enumDef);
+      }
+    });
+    Object.values(entity.fields).forEach((field2) => {
+      if (field2.kind === "enum" && field2.values && !enumMap.has(field2.enumName)) {
+        enumMap.set(field2.enumName, {
+          name: field2.enumName,
+          values: field2.values,
+          schema: entity.schema
+        });
+      }
+    });
+  });
+  enumMap.forEach((enumDef) => {
+    lines.push(...generateEnumBlock(enumDef));
+    lines.push("");
+  });
+  entities.forEach((entity) => {
+    lines.push(...generateModelBlock(entity));
+    lines.push("");
+  });
+  return lines.join(`
+`);
+}
+function generateEnumBlock(enumDef) {
+  const lines = [];
+  if (enumDef.description) {
+    lines.push(`/// ${enumDef.description}`);
+  }
+  lines.push(`enum ${enumDef.name} {`);
+  enumDef.values.forEach((value) => {
+    lines.push(`  ${value}`);
+  });
+  lines.push("");
+  if (enumDef.schema) {
+    lines.push(`  @@schema("${enumDef.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateModelBlock(entity) {
+  const lines = [];
+  if (entity.description) {
+    lines.push(`/// ${entity.description}`);
+  }
+  lines.push(`model ${entity.name} {`);
+  Object.entries(entity.fields).forEach(([fieldName, field2]) => {
+    const fieldLine = generateFieldLine(fieldName, field2);
+    if (field2.description) {
+      lines.push(`  /// ${field2.description}`);
+    }
+    lines.push(`  ${fieldLine}`);
+  });
+  if (entity.indexes && entity.indexes.length > 0) {
+    lines.push("");
+    entity.indexes.forEach((idx) => {
+      lines.push(`  ${generateIndexLine(idx)}`);
+    });
+  }
+  if (entity.map) {
+    lines.push(`  @@map("${entity.map}")`);
+  }
+  if (entity.schema) {
+    lines.push(`  @@schema("${entity.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateFieldLine(fieldName, field2) {
+  if (field2.kind === "scalar") {
+    return generateScalarFieldLine(fieldName, field2);
+  } else if (field2.kind === "enum") {
+    return generateEnumFieldLine(fieldName, field2);
+  } else if (field2.kind === "relation") {
+    return generateRelationFieldLine(fieldName, field2);
+  }
+  throw new Error(`Unknown field kind: ${field2.kind}`);
+}
+function generateScalarFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.type;
+  if (field2.isArray) {
+    typeStr += "[]";
+  }
+  if (field2.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field2.isId) {
+    attrs.push("@id");
+  }
+  if (field2.default !== undefined) {
+    if (typeof field2.default === "string" && field2.default.includes("(")) {
+      attrs.push(`@default(${field2.default})`);
+    } else if (typeof field2.default === "boolean") {
+      attrs.push(`@default(${field2.default})`);
+    } else if (typeof field2.default === "number") {
+      attrs.push(`@default(${field2.default})`);
+    } else {
+      attrs.push(`@default("${field2.default}")`);
+    }
+  }
+  if (field2.updatedAt) {
+    attrs.push("@updatedAt");
+  }
+  if (field2.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field2.map) {
+    attrs.push(`@map("${field2.map}")`);
+  }
+  if (field2.dbType) {
+    attrs.push(`@db.${field2.dbType}`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateEnumFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.enumName;
+  if (field2.isArray) {
+    typeStr += "[]";
+  }
+  if (field2.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field2.default !== undefined) {
+    attrs.push(`@default(${field2.default})`);
+  }
+  if (field2.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field2.map) {
+    attrs.push(`@map("${field2.map}")`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateRelationFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.target;
+  if (field2.type === "hasMany") {
+    typeStr += "[]";
+  }
+  if (field2.type === "hasOne") {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const relationParts = [];
+  if (field2.name) {
+    relationParts.push(`name: "${field2.name}"`);
+  }
+  if (field2.fields && field2.fields.length > 0) {
+    relationParts.push(`fields: [${field2.fields.join(", ")}]`);
+  }
+  if (field2.references && field2.references.length > 0) {
+    relationParts.push(`references: [${field2.references.join(", ")}]`);
+  }
+  if (field2.onDelete) {
+    relationParts.push(`onDelete: ${field2.onDelete}`);
+  }
+  if (field2.onUpdate) {
+    relationParts.push(`onUpdate: ${field2.onUpdate}`);
+  }
+  if (relationParts.length > 0) {
+    parts.push(`@relation(${relationParts.join(", ")})`);
+  }
+  return parts.join(" ");
+}
+function generateIndexLine(idx) {
+  const fieldList = idx.fields.join(", ");
+  const parts = [];
+  if (idx.unique) {
+    parts.push(`@@unique([${fieldList}]`);
+  } else {
+    parts.push(`@@index([${fieldList}]`);
+  }
+  const options = [];
+  if (idx.name) {
+    options.push(`name: "${idx.name}"`);
+  }
+  if (idx.type) {
+    options.push(`type: ${idx.type}`);
+  }
+  if (options.length > 0) {
+    parts[0] += `, ${options.join(", ")}`;
+  }
+  parts[0] += ")";
+  return parts.join("");
+}
+function composeModuleSchemas(contributions, options = {}) {
+  const allEntities = [];
+  const allEnums = new Map;
+  contributions.forEach((contrib) => {
+    contrib.entities.forEach((entity) => {
+      allEntities.push({
+        ...entity,
+        module: contrib.moduleId
+      });
+    });
+    contrib.enums?.forEach((enumDef) => {
+      if (!allEnums.has(enumDef.name)) {
+        allEnums.set(enumDef.name, enumDef);
+      }
+    });
+  });
+  if (allEntities[0] && allEnums.size > 0) {
+    allEntities[0] = {
+      ...allEntities[0],
+      enums: [...allEntities[0].enums ?? [], ...allEnums.values()]
+    };
+  }
+  return generatePrismaSchema(allEntities, options);
+}
+function generateEntityFragment(entity) {
+  return generateModelBlock(entity).join(`
+`);
+}
+function generateEnumFragment(enumDef) {
+  return generateEnumBlock(enumDef).join(`
+`);
+}
+export {
+  isSchemaType,
+  isSchemaModel,
+  index,
+  generatePrismaSchema,
+  generateEnumFragment,
+  generateEntityFragment,
+  fromZod,
+  fromJsonSchema,
+  field,
+  defineSchemaModel,
+  defineEnum,
+  defineEntityEnum,
+  defineEntity,
+  composeModuleSchemas,
+  ZodSchemaType,
+  SchemaModel,
+  ScalarTypeEnum,
+  JsonSchemaType,
+  GraphQLSchemaType,
+  FieldType,
+  EnumType
+};