@contractspec/lib.schema 1.57.0 → 1.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractspec/lib.schema",
-  "version": "1.57.0",
+  "version": "1.58.0",
   "description": "Schema utilities for Zod, JSON Schema, and GraphQL",
   "keywords": [
     "contractspec",
@@ -14,20 +14,21 @@
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "publish:pkg:canary": "bun publish:pkg --tag canary",
-    "build": "bun build:types && bun build:bundle",
-    "build:bundle": "tsdown",
-    "build:types": "tsc --noEmit",
-    "dev": "bun build:bundle --watch",
+    "build": "bun run prebuild && bun run build:bundle && bun run build:types",
+    "build:bundle": "contractspec-bun-build transpile",
+    "build:types": "contractspec-bun-build types",
+    "dev": "contractspec-bun-build dev",
     "clean": "rimraf dist .turbo",
     "lint": "bun lint:fix",
     "lint:fix": "eslint src --fix",
-    "lint:check": "eslint src"
+    "lint:check": "eslint src",
+    "prebuild": "contractspec-bun-build prebuild",
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@contractspec/tool.tsdown": "1.57.0",
-    "@contractspec/tool.typescript": "1.57.0",
-    "tsdown": "^0.20.3",
-    "typescript": "^5.9.3"
+    "@contractspec/tool.typescript": "1.58.0",
+    "typescript": "^5.9.3",
+    "@contractspec/tool.bun": "1.57.0"
   },
   "dependencies": {
     "zod": "^4.3.5",
@@ -40,25 +41,122 @@
   "type": "module",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./entity": "./dist/entity/index.js",
-    "./entity/defineEntity": "./dist/entity/defineEntity.js",
-    "./entity/generator": "./dist/entity/generator.js",
-    "./entity/types": "./dist/entity/types.js",
-    "./EnumType": "./dist/EnumType.js",
-    "./FieldType": "./dist/FieldType.js",
-    "./GraphQLSchemaType": "./dist/GraphQLSchemaType.js",
-    "./JsonSchemaType": "./dist/JsonSchemaType.js",
-    "./ScalarTypeEnum": "./dist/ScalarTypeEnum.js",
-    "./SchemaModel": "./dist/SchemaModel.js",
-    "./SchemaModelType": "./dist/SchemaModelType.js",
-    "./ZodSchemaType": "./dist/ZodSchemaType.js",
-    "./*": "./*"
+    ".": "./src/index.ts",
+    "./entity": "./src/entity/index.ts",
+    "./entity/defineEntity": "./src/entity/defineEntity.ts",
+    "./entity/generator": "./src/entity/generator.ts",
+    "./entity/index": "./src/entity/index.ts",
+    "./entity/types": "./src/entity/types.ts",
+    "./EnumType": "./src/EnumType.ts",
+    "./FieldType": "./src/FieldType.ts",
+    "./GraphQLSchemaType": "./src/GraphQLSchemaType.ts",
+    "./JsonSchemaType": "./src/JsonSchemaType.ts",
+    "./ScalarTypeEnum": "./src/ScalarTypeEnum.ts",
+    "./SchemaModel": "./src/SchemaModel.ts",
+    "./SchemaModelType": "./src/SchemaModelType.ts",
+    "./ZodSchemaType": "./src/ZodSchemaType.ts"
   },
   "publishConfig": {
     "access": "public",
     "exports": {
-      ".": "./dist/index.js"
+      ".": {
+        "types": "./dist/index.d.ts",
+        "bun": "./dist/index.js",
+        "node": "./dist/node/index.mjs",
+        "browser": "./dist/browser/index.js",
+        "default": "./dist/index.js"
+      },
+      "./entity": {
+        "types": "./dist/entity/index.d.ts",
+        "bun": "./dist/entity/index.js",
+        "node": "./dist/node/entity/index.mjs",
+        "browser": "./dist/browser/entity/index.js",
+        "default": "./dist/entity/index.js"
+      },
+      "./entity/defineEntity": {
+        "types": "./dist/entity/defineEntity.d.ts",
+        "bun": "./dist/entity/defineEntity.js",
+        "node": "./dist/node/entity/defineEntity.mjs",
+        "browser": "./dist/browser/entity/defineEntity.js",
+        "default": "./dist/entity/defineEntity.js"
+      },
+      "./entity/generator": {
+        "types": "./dist/entity/generator.d.ts",
+        "bun": "./dist/entity/generator.js",
+        "node": "./dist/node/entity/generator.mjs",
+        "browser": "./dist/browser/entity/generator.js",
+        "default": "./dist/entity/generator.js"
+      },
+      "./entity/index": {
+        "types": "./dist/entity/index.d.ts",
+        "bun": "./dist/entity/index.js",
+        "node": "./dist/node/entity/index.mjs",
+        "browser": "./dist/browser/entity/index.js",
+        "default": "./dist/entity/index.js"
+      },
+      "./entity/types": {
+        "types": "./dist/entity/types.d.ts",
+        "bun": "./dist/entity/types.js",
+        "node": "./dist/node/entity/types.mjs",
+        "browser": "./dist/browser/entity/types.js",
+        "default": "./dist/entity/types.js"
+      },
+      "./EnumType": {
+        "types": "./dist/EnumType.d.ts",
+        "bun": "./dist/EnumType.js",
+        "node": "./dist/node/EnumType.mjs",
+        "browser": "./dist/browser/EnumType.js",
+        "default": "./dist/EnumType.js"
+      },
+      "./FieldType": {
+        "types": "./dist/FieldType.d.ts",
+        "bun": "./dist/FieldType.js",
+        "node": "./dist/node/FieldType.mjs",
+        "browser": "./dist/browser/FieldType.js",
+        "default": "./dist/FieldType.js"
+      },
+      "./GraphQLSchemaType": {
+        "types": "./dist/GraphQLSchemaType.d.ts",
+        "bun": "./dist/GraphQLSchemaType.js",
+        "node": "./dist/node/GraphQLSchemaType.mjs",
+        "browser": "./dist/browser/GraphQLSchemaType.js",
+        "default": "./dist/GraphQLSchemaType.js"
+      },
+      "./JsonSchemaType": {
+        "types": "./dist/JsonSchemaType.d.ts",
+        "bun": "./dist/JsonSchemaType.js",
+        "node": "./dist/node/JsonSchemaType.mjs",
+        "browser": "./dist/browser/JsonSchemaType.js",
+        "default": "./dist/JsonSchemaType.js"
+      },
+      "./ScalarTypeEnum": {
+        "types": "./dist/ScalarTypeEnum.d.ts",
+        "bun": "./dist/ScalarTypeEnum.js",
+        "node": "./dist/node/ScalarTypeEnum.mjs",
+        "browser": "./dist/browser/ScalarTypeEnum.js",
+        "default": "./dist/ScalarTypeEnum.js"
+      },
+      "./SchemaModel": {
+        "types": "./dist/SchemaModel.d.ts",
+        "bun": "./dist/SchemaModel.js",
+        "node": "./dist/node/SchemaModel.mjs",
+        "browser": "./dist/browser/SchemaModel.js",
+        "default": "./dist/SchemaModel.js"
+      },
+      "./SchemaModelType": {
+        "types": "./dist/SchemaModelType.d.ts",
+        "bun": "./dist/SchemaModelType.js",
+        "node": "./dist/node/SchemaModelType.mjs",
+        "browser": "./dist/browser/SchemaModelType.js",
+        "default": "./dist/SchemaModelType.js"
+      },
+      "./ZodSchemaType": {
+        "types": "./dist/ZodSchemaType.d.ts",
+        "bun": "./dist/ZodSchemaType.js",
+        "node": "./dist/node/ZodSchemaType.mjs",
+        "browser": "./dist/browser/ZodSchemaType.js",
+        "default": "./dist/ZodSchemaType.js"
+      }
     },
     "registry": "https://registry.npmjs.org/"
   },

package/dist/EnumType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EnumType.js","names":["z"],"sources":["../src/EnumType.ts"],"sourcesContent":["import * as z from 'zod';\nimport { GraphQLEnumType } from 'graphql';\n\n/**\n * Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.\n */\nexport class EnumType<T extends [string, ...string[]]> {\n  private readonly name: string;\n  private readonly values: T;\n  private readonly gqlEnum: GraphQLEnumType;\n\n  constructor(name: string, values: T) {\n    this.name = name;\n    this.values = values;\n    this.gqlEnum = new GraphQLEnumType({\n      name: this.name,\n      values: Object.fromEntries(values.map((v) => [v, { value: v }] as const)),\n    });\n  }\n\n  /** Enum type name (used by GraphQL and JSON Schema). */\n  getName(): string {\n    return this.name;\n  }\n\n  /** Returns the literal tuple of allowed values. */\n  getEnumValues(): T {\n    return this.values;\n  }\n\n  // For SchemaModel and adapters expecting a Pothos/GraphQL type-like object\n  /** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */\n  getPothos(): GraphQLEnumType {\n    return this.gqlEnum;\n  }\n\n  /** zod schema representing this enum. */\n  getZod(): z.ZodEnum<{ [K in T[number]]: K }> {\n    return z.enum(this.values);\n  }\n\n  /** Minimal JSON representation (alias of getJsonSchema). */\n  getJson(): { type: 'string'; enum: T } {\n    return { type: 'string', enum: this.values } as const;\n  }\n\n  /** JSON Schema for this enum. */\n  getJsonSchema(): { type: 'string'; enum: T } {\n    return this.getJson();\n  }\n}\n\nexport type AnyEnumType = EnumType<[string, ...string[]]>;\n\n/**\n * Helper to define an EnumType.\n * @param name Display/type name used across GraphQL and JSON Schema\n * @param values Literal tuple of allowed string values (at least one)\n */\nexport const defineEnum = <T extends [string, ...string[]]>(\n  name: string,\n  values: T\n) => new EnumType(name, values);\n"],"mappings":";;;;;;;AAMA,IAAa,WAAb,MAAuD;CACrD,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,YAAY,MAAc,QAAW;AACnC,OAAK,OAAO;AACZ,OAAK,SAAS;AACd,OAAK,UAAU,IAAI,gBAAgB;GACjC,MAAM,KAAK;GACX,QAAQ,OAAO,YAAY,OAAO,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,CAAC,CAAU,CAAC;GAC1E,CAAC;;;CAIJ,UAAkB;AAChB,SAAO,KAAK;;;CAId,gBAAmB;AACjB,SAAO,KAAK;;;CAKd,YAA6B;AAC3B,SAAO,KAAK;;;CAId,SAA6C;AAC3C,SAAOA,IAAE,KAAK,KAAK,OAAO;;;CAI5B,UAAuC;AACrC,SAAO;GAAE,MAAM;GAAU,MAAM,KAAK;GAAQ;;;CAI9C,gBAA6C;AAC3C,SAAO,KAAK,SAAS;;;;;;;;AAWzB,MAAa,cACX,MACA,WACG,IAAI,SAAS,MAAM,OAAO"}

package/dist/FieldType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FieldType.js","names":[],"sources":["../src/FieldType.ts"],"sourcesContent":["import * as z from 'zod';\nimport { GraphQLScalarType, type GraphQLScalarTypeConfig } from 'graphql';\n\nexport interface FieldTypeConfig<\n  TInternal,\n  TExternal = TInternal,\n> extends GraphQLScalarTypeConfig<TInternal, TExternal> {\n  zod: z.ZodType<TInternal>;\n  jsonSchema: unknown | (() => unknown);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFieldType = FieldType<any, any>;\n\n/**\n * GraphQL scalar wrapper that carries zod and JSON Schema metadata.\n *\n * TInternal is the runtime representation; TExternal is the GraphQL output.\n */\nexport class FieldType<\n  TInternal,\n  TExternal = TInternal,\n> extends GraphQLScalarType<TInternal, TExternal> {\n  private zodSchema: z.ZodType<TInternal>;\n  private readonly jsonSchemaDef?: unknown | (() => unknown);\n\n  constructor(config: FieldTypeConfig<TInternal, TExternal>) {\n    super(config);\n    this.zodSchema = config.zod;\n    this.jsonSchemaDef = config.jsonSchema;\n  }\n\n  /** Return the attached zod schema for validation. */\n  getZod(): z.ZodType<TInternal> {\n    return this.zodSchema;\n  }\n\n  /** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */\n  getPothos(): GraphQLScalarType<TInternal, TExternal> {\n    return this;\n  }\n\n  /** Return the JSON Schema (evaluates factory if provided). */\n  getJson(): unknown {\n    return typeof this.jsonSchemaDef === 'function'\n      ? (this.jsonSchemaDef as () => unknown)()\n      : this.jsonSchemaDef;\n  }\n\n  // Return the raw jsonSchema config (value or factory)\n  getJsonSchemaDef(): unknown | (() => unknown) {\n    return this.jsonSchemaDef;\n  }\n\n  // Return a deep-resolved JSON Schema (evaluates factory and nested factories)\n  getJsonSchema(): unknown {\n    const deepResolve = (v: unknown): unknown => {\n      const value = typeof v === 'function' ? (v as () => unknown)() : v;\n      if (Array.isArray(value)) return value.map((item) => deepResolve(item));\n      if (value && typeof value === 'object') {\n        const obj: Record<string, unknown> = {};\n        for (const [k, val] of Object.entries(\n          value as Record<string, unknown>\n        )) {\n          obj[k] = deepResolve(val);\n        }\n        return obj;\n      }\n      return value;\n    };\n    return deepResolve(this.getJson());\n  }\n}\n\nexport type ZodFieldType<Field extends AnyFieldType> = z.infer<\n  ReturnType<Field['getZod']>\n>;\n"],"mappings":";;;;;;;;;AAmBA,IAAa,YAAb,cAGU,kBAAwC;CAChD,AAAQ;CACR,AAAiB;CAEjB,YAAY,QAA+C;AACzD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO;AACxB,OAAK,gBAAgB,OAAO;;;CAI9B,SAA+B;AAC7B,SAAO,KAAK;;;CAId,YAAqD;AACnD,SAAO;;;CAIT,UAAmB;AACjB,SAAO,OAAO,KAAK,kBAAkB,aAChC,KAAK,eAAiC,GACvC,KAAK;;CAIX,mBAA8C;AAC5C,SAAO,KAAK;;CAId,gBAAyB;EACvB,MAAM,eAAe,MAAwB;GAC3C,MAAM,QAAQ,OAAO,MAAM,aAAc,GAAqB,GAAG;AACjE,OAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,MAAM,KAAK,SAAS,YAAY,KAAK,CAAC;AACvE,OAAI,SAAS,OAAO,UAAU,UAAU;IACtC,MAAM,MAA+B,EAAE;AACvC,SAAK,MAAM,CAAC,GAAG,QAAQ,OAAO,QAC5B,MACD,CACC,KAAI,KAAK,YAAY,IAAI;AAE3B,WAAO;;AAET,UAAO;;AAET,SAAO,YAAY,KAAK,SAAS,CAAC"}

package/dist/GraphQLSchemaType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GraphQLSchemaType.js","names":[],"sources":["../src/GraphQLSchemaType.ts"],"sourcesContent":["import { z } from 'zod';\nimport type { SchemaModelType } from './SchemaModelType';\n\n/**\n * Wrapper for GraphQL Type Definitions to be used in ContractSpec Schemas.\n * Note: Runtime validation is limited to 'unknown' (pass-through) as SDL is not parsed at runtime.\n */\nexport class GraphQLSchemaType implements SchemaModelType {\n  readonly _isSchemaType = true;\n\n  constructor(\n    public readonly typeDef: string,\n    public readonly name: string\n  ) {}\n\n  getZod(): z.ZodType {\n    return z.unknown();\n  }\n}\n"],"mappings":";;;;;;;AAOA,IAAa,oBAAb,MAA0D;CACxD,AAAS,gBAAgB;CAEzB,YACE,AAAgB,SAChB,AAAgB,MAChB;EAFgB;EACA;;CAGlB,SAAoB;AAClB,SAAO,EAAE,SAAS"}

package/dist/JsonSchemaType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonSchemaType.js","names":["z"],"sources":["../src/JsonSchemaType.ts"],"sourcesContent":["/**\n * JSON Schema wrapper for ContractSpec compatibility.\n *\n * Wraps JSON Schema definitions to implement the SchemaType interface,\n * enabling direct JSON Schema usage in ContractSpec definitions.\n *\n * @module JsonSchemaType\n */\n\nimport * as z from 'zod';\nimport type { SchemaModelType } from './SchemaModelType';\n\n/**\n * JSON Schema definition structure.\n * Supports standard JSON Schema draft-07/2020-12 properties.\n */\nexport interface JsonSchemaDefinition {\n  type?: string | string[];\n  properties?: Record<string, JsonSchemaDefinition>;\n  required?: string[];\n  additionalProperties?: boolean | JsonSchemaDefinition;\n  items?: JsonSchemaDefinition | JsonSchemaDefinition[];\n  enum?: unknown[];\n  const?: unknown;\n  oneOf?: JsonSchemaDefinition[];\n  anyOf?: JsonSchemaDefinition[];\n  allOf?: JsonSchemaDefinition[];\n  $ref?: string;\n  title?: string;\n  description?: string;\n  default?: unknown;\n  format?: string;\n  minimum?: number;\n  maximum?: number;\n  minLength?: number;\n  maxLength?: number;\n  pattern?: string;\n  [key: string]: unknown;\n}\n\n/**\n * Options for JsonSchemaType wrapper.\n */\nexport interface JsonSchemaTypeOptions {\n  /** Name for identification */\n  name?: string;\n}\n\n/**\n * Wrapper to use JSON Schema as a SchemaType.\n * Converts to Zod at runtime for validation.\n *\n * @example\n * ```typescript\n * const CustomFieldsSchema = fromJsonSchema({\n *   type: 'object',\n *   additionalProperties: {\n *     oneOf: [\n *       { type: 'string' },\n *       { type: 'number' },\n *       { type: 'boolean' },\n *     ],\n *   },\n * }, { name: 'CustomFields' });\n * ```\n */\nexport class JsonSchemaType implements SchemaModelType<\n  Record<string, unknown>\n> {\n  private readonly jsonSchema: JsonSchemaDefinition;\n  private readonly options: JsonSchemaTypeOptions;\n\n  constructor(\n    jsonSchema: JsonSchemaDefinition,\n    options: JsonSchemaTypeOptions = {}\n  ) {\n    this.jsonSchema = jsonSchema;\n    this.options = options;\n  }\n\n  /**\n   * Convert JSON Schema to Zod schema for runtime validation.\n   *\n   * Note: This is a simplified conversion. For complex schemas,\n   * consider using a dedicated json-schema-to-zod library.\n   */\n  getZod(): z.ZodType<Record<string, unknown>> {\n    // Handle additionalProperties (dictionary/record types)\n    if (this.jsonSchema.additionalProperties !== undefined) {\n      if (this.jsonSchema.additionalProperties === true) {\n        return z.record(z.string(), z.unknown());\n      }\n      if (typeof this.jsonSchema.additionalProperties === 'object') {\n        // For typed additionalProperties, use union or unknown\n        return z.record(z.string(), z.unknown());\n      }\n      if (this.jsonSchema.additionalProperties === false) {\n        return z.object({}).strict();\n      }\n    }\n\n    // Handle explicit properties\n    if (this.jsonSchema.properties) {\n      const shape: Record<string, z.ZodType> = {};\n      const required = new Set(this.jsonSchema.required ?? []);\n\n      for (const [key, propSchema] of Object.entries(\n        this.jsonSchema.properties\n      )) {\n        const fieldType = this.convertPropertyToZod(propSchema);\n        shape[key] = required.has(key) ? fieldType : fieldType.optional();\n      }\n\n      return z.object(shape).passthrough();\n    }\n\n    // Default: passthrough object\n    return z.object({}).passthrough();\n  }\n\n  /**\n   * Return the original JSON Schema.\n   */\n  getJsonSchema(): JsonSchemaDefinition {\n    return this.jsonSchema;\n  }\n\n  /**\n   * Return GraphQL type info.\n   * JSON Schema types map to JSON scalar in GraphQL.\n   */\n  getPothos(): { type: string; name?: string } {\n    return { type: 'JSON', name: this.options.name };\n  }\n\n  /**\n   * Get the configured name for this schema.\n   */\n  getName(): string | undefined {\n    return this.options.name;\n  }\n\n  /**\n   * Convert a single JSON Schema property to Zod.\n   */\n  private convertPropertyToZod(schema: JsonSchemaDefinition): z.ZodType {\n    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;\n\n    switch (type) {\n      case 'string':\n        return z.string();\n      case 'number':\n      case 'integer':\n        return z.number();\n      case 'boolean':\n        return z.boolean();\n      case 'array':\n        if (schema.items && !Array.isArray(schema.items)) {\n          return z.array(this.convertPropertyToZod(schema.items));\n        }\n        return z.array(z.unknown());\n      case 'object':\n        if (schema.properties) {\n          return new JsonSchemaType(schema).getZod();\n        }\n        return z.record(z.string(), z.unknown());\n      case 'null':\n        return z.null();\n      default:\n        return z.unknown();\n    }\n  }\n}\n\n/**\n * Helper to create a SchemaType from JSON Schema.\n *\n * @param schema - The JSON Schema definition\n * @param options - Optional configuration\n * @returns A SchemaType-compatible wrapper\n *\n * @example\n * ```typescript\n * const MetadataSchema = fromJsonSchema({\n *   type: 'object',\n *   properties: {\n *     createdAt: { type: 'string', format: 'date-time' },\n *     updatedAt: { type: 'string', format: 'date-time' },\n *   },\n *   required: ['createdAt'],\n * });\n * ```\n */\nexport const fromJsonSchema = (\n  schema: JsonSchemaDefinition,\n  options?: JsonSchemaTypeOptions\n): JsonSchemaType => new JsonSchemaType(schema, options);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,iBAAb,MAAa,eAEX;CACA,AAAiB;CACjB,AAAiB;CAEjB,YACE,YACA,UAAiC,EAAE,EACnC;AACA,OAAK,aAAa;AAClB,OAAK,UAAU;;;;;;;;CASjB,SAA6C;AAE3C,MAAI,KAAK,WAAW,yBAAyB,QAAW;AACtD,OAAI,KAAK,WAAW,yBAAyB,KAC3C,QAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;AAE1C,OAAI,OAAO,KAAK,WAAW,yBAAyB,SAElD,QAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;AAE1C,OAAI,KAAK,WAAW,yBAAyB,MAC3C,QAAOA,IAAE,OAAO,EAAE,CAAC,CAAC,QAAQ;;AAKhC,MAAI,KAAK,WAAW,YAAY;GAC9B,MAAM,QAAmC,EAAE;GAC3C,MAAM,WAAW,IAAI,IAAI,KAAK,WAAW,YAAY,EAAE,CAAC;AAExD,QAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QACrC,KAAK,WAAW,WACjB,EAAE;IACD,MAAM,YAAY,KAAK,qBAAqB,WAAW;AACvD,UAAM,OAAO,SAAS,IAAI,IAAI,GAAG,YAAY,UAAU,UAAU;;AAGnE,UAAOA,IAAE,OAAO,MAAM,CAAC,aAAa;;AAItC,SAAOA,IAAE,OAAO,EAAE,CAAC,CAAC,aAAa;;;;;CAMnC,gBAAsC;AACpC,SAAO,KAAK;;;;;;CAOd,YAA6C;AAC3C,SAAO;GAAE,MAAM;GAAQ,MAAM,KAAK,QAAQ;GAAM;;;;;CAMlD,UAA8B;AAC5B,SAAO,KAAK,QAAQ;;;;;CAMtB,AAAQ,qBAAqB,QAAyC;AAGpE,UAFa,MAAM,QAAQ,OAAO,KAAK,GAAG,OAAO,KAAK,KAAK,OAAO,MAElE;GACE,KAAK,SACH,QAAOA,IAAE,QAAQ;GACnB,KAAK;GACL,KAAK,UACH,QAAOA,IAAE,QAAQ;GACnB,KAAK,UACH,QAAOA,IAAE,SAAS;GACpB,KAAK;AACH,QAAI,OAAO,SAAS,CAAC,MAAM,QAAQ,OAAO,MAAM,CAC9C,QAAOA,IAAE,MAAM,KAAK,qBAAqB,OAAO,MAAM,CAAC;AAEzD,WAAOA,IAAE,MAAMA,IAAE,SAAS,CAAC;GAC7B,KAAK;AACH,QAAI,OAAO,WACT,QAAO,IAAI,eAAe,OAAO,CAAC,QAAQ;AAE5C,WAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;GAC1C,KAAK,OACH,QAAOA,IAAE,MAAM;GACjB,QACE,QAAOA,IAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;AAwB1B,MAAa,kBACX,QACA,YACmB,IAAI,eAAe,QAAQ,QAAQ"}

package/dist/ScalarTypeEnum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScalarTypeEnum.js","names":["z"],"sources":["../src/ScalarTypeEnum.ts"],"sourcesContent":["import * as z from 'zod';\nimport { Kind, type ValueNode } from 'graphql';\nimport { FieldType } from './FieldType';\n\n// Helpers to build standard scalars\nconst localeRegex = /^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/;\nconst timezoneRegex = /^(?:UTC|[A-Za-z_]+\\/[A-Za-z_]+)$/;\nconst phoneRegex = /^[+]?\\d[\\d\\s().-]{3,}$/;\nconst currencyRegex = /^[A-Z]{3}$/;\nconst countryRegex = /^[A-Z]{2}$/;\nconst latMin = -90;\nconst latMax = 90;\nconst lonMin = -180;\nconst lonMax = 180;\n\n/**\n * Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.\n */\nexport const ScalarTypeEnum = {\n  // primitives (_unsecure)\n  String_unsecure: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'String_unsecure',\n      description: 'Unvalidated string scalar',\n      zod: z.string(),\n      parseValue: (v) => z.string().parse(v),\n      serialize: (v) => String(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.STRING) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'string' },\n    }),\n  Int_unsecure: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Int_unsecure',\n      description: 'Unvalidated integer scalar',\n      zod: z.number().int(),\n      parseValue: (v) => {\n        const num = typeof v === 'number' ? v : Number(v as unknown);\n        return z.number().int().parse(num);\n      },\n      serialize: (v) => Math.trunc(typeof v === 'number' ? v : Number(v)),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.INT) throw new TypeError('Invalid literal');\n        return Number(ast.value);\n      },\n      jsonSchema: { type: 'integer' },\n    }),\n  Float_unsecure: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Float_unsecure',\n      description: 'Unvalidated float scalar',\n      zod: z.number(),\n      parseValue: (v) => {\n        const num = typeof v === 'number' ? v : Number(v as unknown);\n        return z.number().parse(num);\n      },\n      serialize: (v) => Number(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.FLOAT && ast.kind !== Kind.INT)\n          throw new TypeError('Invalid literal');\n        return Number(ast.value);\n      },\n      jsonSchema: { type: 'number' },\n    }),\n  Boolean: (): FieldType<boolean> =>\n    new FieldType<boolean>({\n      name: 'Boolean',\n      description: 'Unvalidated boolean scalar',\n      zod: z.boolean(),\n      parseValue: (v) => z.coerce.boolean().parse(v),\n      serialize: (v) => Boolean(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.BOOLEAN) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'boolean' },\n    }),\n  ID: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'ID',\n      description: 'Unvalidated id scalar',\n      zod: z.string(),\n      parseValue: (v) => z.string().parse(v),\n      serialize: (v) => String(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.STRING) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'string' },\n    }),\n\n  // Validated custom scalars\n  JSON: (): FieldType<unknown> =>\n    new FieldType<unknown>({\n      name: 'JSON',\n      zod: z.any(),\n      parseValue: (v) => v,\n      serialize: (v) => v,\n      jsonSchema: {},\n    }),\n  JSONObject: (): FieldType<Record<string, unknown>> =>\n    new FieldType<Record<string, unknown>>({\n      name: 'JSONObject',\n      zod: z.record(z.string(), z.any()),\n      parseValue: (v) => z.record(z.string(), z.any()).parse(v),\n      serialize: (v) => (v ?? {}) as Record<string, unknown>,\n      jsonSchema: { type: 'object' },\n    }),\n  Date: (): FieldType<Date, string> =>\n    new FieldType<Date, string>({\n      name: 'Date',\n      zod: z.date(),\n      parseValue: (v) => (v instanceof Date ? v : new Date(String(v))),\n      serialize: (v) =>\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        v instanceof Date ? v.toISOString().split('T')[0]! : String(v),\n      jsonSchema: { type: 'string', format: 'date' },\n    }),\n  DateTime: (): FieldType<Date, string> =>\n    new FieldType<Date, string>({\n      name: 'DateTime',\n      zod: z.date(),\n      parseValue: (v) => (v instanceof Date ? v : new Date(String(v))),\n      serialize: (v) => {\n        return v instanceof Date ? v.toISOString() : String(v);\n      },\n      jsonSchema: { type: 'string', format: 'date-time' },\n    }),\n  Time: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Time',\n      zod: z.string().regex(/^\\d{2}:\\d{2}(:\\d{2})?$/),\n      parseValue: (v) =>\n        z\n          .string()\n          .regex(/^\\d{2}:\\d{2}(:\\d{2})?$/)\n          .parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: '^\\\\d{2}:\\\\d{2}(:\\\\d{2})?$' },\n    }),\n  EmailAddress: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'EmailAddress',\n      zod: z.string().email(),\n      parseValue: (v) => z.string().email().parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', format: 'email' },\n    }),\n  URL: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'URL',\n      zod: z.string().url(),\n      parseValue: (v) => z.string().url().parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', format: 'uri' },\n    }),\n  PhoneNumber: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'PhoneNumber',\n      zod: z.string().regex(phoneRegex),\n      parseValue: (v) => z.string().regex(phoneRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: phoneRegex.source },\n    }),\n  NonEmptyString: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'NonEmptyString',\n      zod: z.string().min(1),\n      parseValue: (v) => z.string().min(1).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', minLength: 1 },\n    }),\n  Locale: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Locale',\n      zod: z.string().regex(localeRegex),\n      parseValue: (v) => z.string().regex(localeRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: localeRegex.source },\n    }),\n  TimeZone: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'TimeZone',\n      zod: z.string().regex(timezoneRegex),\n      parseValue: (v) => z.string().regex(timezoneRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: timezoneRegex.source },\n    }),\n  Latitude: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Latitude',\n      zod: z.number().min(latMin).max(latMax),\n      parseValue: (v) => z.coerce.number().min(latMin).max(latMax).parse(v),\n      serialize: (v) => Number(v),\n      jsonSchema: { type: 'number', minimum: latMin, maximum: latMax },\n    }),\n  Longitude: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Longitude',\n      zod: z.number().min(lonMin).max(lonMax),\n      parseValue: (v) => z.coerce.number().min(lonMin).max(lonMax).parse(v),\n      serialize: (v) => Number(v),\n      jsonSchema: { type: 'number', minimum: lonMin, maximum: lonMax },\n    }),\n  Currency: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Currency',\n      zod: z.string().regex(currencyRegex),\n      parseValue: (v) => z.string().regex(currencyRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: currencyRegex.source },\n    }),\n  CountryCode: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'CountryCode',\n      zod: z.string().regex(countryRegex),\n      parseValue: (v) => z.string().regex(countryRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: countryRegex.source },\n    }),\n  //   GeoJSON: (): FieldType<Record<string, unknown>, Record<string, unknown>> =>\n  //     new FieldType<Record<string, unknown>, Record<string, unknown>>({\n  //       name: 'GeoJSON',\n  //       zod: z.object({ type: z.string(), coordinates: z.any() }).passthrough(),\n  //       parseValue: (v) =>\n  //         z\n  //           .object({ type: z.string(), coordinates: z.any() })\n  //           .passthrough()\n  //           .parse(v),\n  //       serialize: (v) => v,\n  //       jsonSchema: { type: 'object' },\n  //     }),\n} as const;\nexport type ScalarTypeEnum = [keyof typeof ScalarTypeEnum];\n"],"mappings":"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"}

package/dist/SchemaModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaModel.js","names":["z"],"sources":["../src/SchemaModel.ts"],"sourcesContent":["import { type AnyFieldType } from './FieldType';\nimport { type AnyEnumType } from './EnumType';\nimport { type SchemaModelType } from './SchemaModelType';\nimport * as z from 'zod';\nimport type { Maybe } from 'graphql/jsutils/Maybe';\n\n/**\n * All types that can be used as field types in a SchemaModel.\n * Supports FieldType, EnumType, nested SchemaModel, or any SchemaType implementation.\n */\ntype FieldLike = AnyFieldType | AnyEnumType | AnySchemaModel | SchemaModelType;\n\n/** Field configuration for a SchemaModel property. */\nexport interface SchemaFieldConfig<Type extends FieldLike = FieldLike> {\n  type: Type;\n  isOptional: boolean;\n  /** When present and true, the field is an array */\n  isArray?: true;\n}\n\nexport type SchemaModelFieldsAnyConfig<Type extends FieldLike = FieldLike> =\n  Record<string, SchemaFieldConfig<Type>>;\n\n/** Model definition: name and fields. */\nexport interface SchemaModelConfig<Fields extends SchemaModelFieldsAnyConfig> {\n  name: string;\n  description?: Maybe<string>;\n  fields: Fields;\n}\n\n/**\n * Named object model built from FieldType/EnumType/SchemaModel fields.\n * Provides zod and GraphQL input helpers, and supports arrays/optional fields.\n */\nexport class SchemaModel<\n  Fields extends SchemaModelFieldsAnyConfig,\n> implements SchemaModelType {\n  constructor(public readonly config: SchemaModelConfig<Fields>) {}\n\n  /**\n   * Build a typed ZodObject from the model fields, preserving each field's\n   * Zod schema and optionality at the type level when possible.\n   */\n  getZod(): TopLevelZodFromModel<Fields> {\n    const shape = Object.entries(this.config.fields).reduce(\n      (acc, [key, def]) => {\n        const base: z.ZodType = def.type.getZod();\n        const withArray = def.isArray ? z.array(base) : base;\n        (acc as Record<string, z.ZodType>)[key] = def.isOptional\n          ? withArray.optional()\n          : withArray;\n        return acc;\n      },\n      {} as Record<string, z.ZodType>\n    ) as unknown as ZodShapeFromFields<Fields>;\n\n    return z.object(shape) as z.ZodObject<ZodShapeFromFields<Fields>>;\n  }\n\n  /** Input object name for GraphQL builder adapters. */\n  getPothosInput() {\n    return this.config.name;\n  }\n}\n\n/**\n * Union of all types that can serve as a schema model.\n * This is the main type expected by OperationSpec, EventSpec, FormSpec, etc.\n *\n * Supports:\n * - SchemaModel instances (native ContractSpec types)\n * - Any SchemaType implementation (ZodSchemaType, JsonSchemaType, etc.)\n */\nexport type AnySchemaModel =\n  | SchemaModel<SchemaModelFieldsAnyConfig>\n  | SchemaModelType;\n\n/**\n * Type guard to check if a value is a SchemaModel (not just any SchemaType).\n * Use this when you need to access SchemaModel-specific properties like `config`.\n *\n * @param model - The model to check\n * @returns True if the model is a SchemaModel instance\n *\n * @example\n * ```typescript\n * if (isSchemaModel(model)) {\n *   // TypeScript knows model.config is available\n *   console.log(model.config.name);\n * }\n * ```\n */\nexport function isSchemaModel(\n  model: AnySchemaModel | null | undefined\n): model is SchemaModel<SchemaModelFieldsAnyConfig> {\n  return (\n    model !== null &&\n    model !== undefined &&\n    'config' in model &&\n    typeof (model as SchemaModel<SchemaModelFieldsAnyConfig>).config ===\n      'object' &&\n    'name' in (model as SchemaModel<SchemaModelFieldsAnyConfig>).config\n  );\n}\n\nexport type ZodSchemaModel<Field extends AnySchemaModel> = z.infer<\n  ReturnType<Field['getZod']>\n>;\n\ntype InferZodFromType<T> =\n  T extends SchemaModel<SchemaModelFieldsAnyConfig>\n    ? z.ZodObject<z.ZodRawShape>\n    : T extends AnyFieldType\n      ? ReturnType<T['getZod']>\n      : T extends AnyEnumType\n        ? ReturnType<T['getZod']>\n        : T extends SchemaModelType\n          ? ReturnType<T['getZod']>\n          : z.ZodUnknown;\n\ntype MaybeArray<Z extends z.ZodType, A> = A extends true ? z.ZodArray<Z> : Z;\ntype MaybeOptional<Z extends z.ZodType, O> = O extends true\n  ? z.ZodOptional<Z>\n  : Z;\n\n/**\n * Helper type: derive the Zod shape from the field config.\n * Supports nested SchemaModel and arrays, preserving optionality and list-ness.\n */\ntype FieldIsArray<FC> = FC extends { isArray: true } ? true : false;\n\nexport type ZodShapeFromFields<F extends SchemaModelFieldsAnyConfig> = {\n  [K in keyof F]: MaybeOptional<\n    MaybeArray<InferZodFromType<F[K]['type']>, FieldIsArray<F[K]>>,\n    F[K]['isOptional']\n  >;\n};\n\n/**\n * The top-level Zod schema returned by getZod():\n * either ZodObject<...> or ZodArray<ZodObject<...>> when config.isArray.\n */\nexport type TopLevelZodFromModel<F extends SchemaModelFieldsAnyConfig> =\n  z.ZodObject<ZodShapeFromFields<F>>;\n\n/**\n * Helper to define a SchemaModel with type inference.\n * Equivalent to `new SchemaModel(config)` but with better ergonomics.\n */\nexport const defineSchemaModel = <Fields extends SchemaModelFieldsAnyConfig>(\n  config: SchemaModelConfig<Fields>\n): SchemaModel<Fields> => new SchemaModel(config);\n"],"mappings":";;;;;;;;;AAkCA,IAAa,cAAb,MAE6B;CAC3B,YAAY,AAAgB,QAAmC;EAAnC;;;;;;CAM5B,SAAuC;EACrC,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO,OAAO,CAAC,QAC9C,KAAK,CAAC,KAAK,SAAS;GACnB,MAAM,OAAkB,IAAI,KAAK,QAAQ;GACzC,MAAM,YAAY,IAAI,UAAUA,IAAE,MAAM,KAAK,GAAG;AAChD,GAAC,IAAkC,OAAO,IAAI,aAC1C,UAAU,UAAU,GACpB;AACJ,UAAO;KAET,EAAE,CACH;AAED,SAAOA,IAAE,OAAO,MAAM;;;CAIxB,iBAAiB;AACf,SAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;AA+BvB,SAAgB,cACd,OACkD;AAClD,QACE,UAAU,QACV,UAAU,UACV,YAAY,SACZ,OAAQ,MAAkD,WACxD,YACF,UAAW,MAAkD;;;;;;AAgDjE,MAAa,qBACX,WACwB,IAAI,YAAY,OAAO"}

package/dist/SchemaModelType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaModelType.js","names":[],"sources":["../src/SchemaModelType.ts"],"sourcesContent":["/**\n * Unified schema type interface for ContractSpec.\n *\n * This module provides a vendor-agnostic abstraction over different schema\n * definition approaches (SchemaModel, Zod, JSON Schema, GraphQL scalars).\n *\n * @module SchemaType\n */\n\nimport type * as z from 'zod';\n\n/**\n * Supported schema output formats for code generation.\n */\nexport type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';\n\n/**\n * Unified interface for all schema-compatible types.\n * Any type used in ContractSpec schemas must implement this interface.\n *\n * @template T - The TypeScript type this schema represents\n *\n * @example\n * ```typescript\n * // All of these implement SchemaType:\n * const fieldType = ScalarTypeEnum.String_unsecure();\n * const schemaModel = new SchemaModel({ name: 'User', fields: {...} });\n * const zodWrapper = fromZod(z.object({ name: z.string() }));\n * ```\n */\nexport interface SchemaModelType<T = unknown> {\n  /**\n   * Return the Zod schema for runtime validation.\n   * This is the primary method - all schema types must provide Zod conversion.\n   */\n  getZod(): z.ZodType<T>;\n\n  /**\n   * Return GraphQL type info for Pothos/GraphQL integration.\n   * Optional - types without GraphQL representation return undefined.\n   */\n  getPothos?(): unknown;\n\n  /**\n   * Return JSON Schema representation.\n   * Optional - types without JSON Schema representation return undefined.\n   */\n  getJsonSchema?(): unknown;\n}\n\n/**\n * Type guard to check if a value implements the SchemaType interface.\n *\n * @param value - Value to check\n * @returns True if value has a getZod method\n *\n * @example\n * ```typescript\n * if (isSchemaType(field.type)) {\n *   const zodSchema = field.type.getZod();\n * }\n * ```\n */\nexport function isSchemaType(value: unknown): value is SchemaModelType {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    'getZod' in value &&\n    typeof (value as SchemaModelType).getZod === 'function'\n  );\n}\n\n/**\n * Type alias for any SchemaType implementation.\n */\nexport type AnySchemaType = SchemaModelType<unknown>;\n"],"mappings":";;;;;;;;;;;;;;AA+DA,SAAgB,aAAa,OAA0C;AACrE,QACE,UAAU,QACV,OAAO,UAAU,YACjB,YAAY,SACZ,OAAQ,MAA0B,WAAW"}

package/dist/ZodSchemaType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ZodSchemaType.js","names":["z"],"sources":["../src/ZodSchemaType.ts"],"sourcesContent":["/**\n * Zod schema wrapper for ContractSpec compatibility.\n *\n * Wraps raw Zod schemas to implement the SchemaType interface,\n * enabling direct Zod usage in ContractSpec definitions.\n *\n * @module ZodSchemaType\n */\n\nimport * as z from 'zod';\nimport type { SchemaModelType } from './SchemaModelType';\n\n/**\n * Options for ZodSchemaType wrapper.\n */\nexport interface ZodSchemaTypeOptions {\n  /** Name for GraphQL/JSON Schema representation */\n  name?: string;\n  /** Description for documentation */\n  description?: string;\n}\n\n/**\n * Wrapper to use a raw Zod schema as a SchemaType.\n * Enables schema definition directly with Zod for maximum flexibility.\n *\n * @template T - The Zod schema type being wrapped\n *\n * @example\n * ```typescript\n * const UserSchema = fromZod(\n *   z.object({\n *     id: z.string().uuid(),\n *     name: z.string().min(1),\n *     email: z.string().email(),\n *   }),\n *   { name: 'User' }\n * );\n *\n * // Use in SchemaModel\n * const CreateUserInput = new SchemaModel({\n *   name: 'CreateUserInput',\n *   fields: {\n *     user: { type: UserSchema, isOptional: false },\n *   },\n * });\n * ```\n */\nexport class ZodSchemaType<T extends z.ZodType> implements SchemaModelType<\n  z.infer<T>\n> {\n  private readonly schema: T;\n  private readonly options: ZodSchemaTypeOptions;\n\n  constructor(schema: T, options: ZodSchemaTypeOptions = {}) {\n    this.schema = schema;\n    this.options = options;\n  }\n\n  /**\n   * Return the wrapped Zod schema.\n   */\n  getZod(): z.ZodType<z.infer<T>> {\n    return this.schema as z.ZodType<z.infer<T>>;\n  }\n\n  /**\n   * Return JSON Schema representation using Zod's toJSONSchema.\n   */\n  getJsonSchema(): unknown {\n    return z.toJSONSchema(this.schema);\n  }\n\n  /**\n   * Return GraphQL type info.\n   * For complex Zod types, defaults to JSON scalar.\n   */\n  getPothos(): { type: string; name?: string } {\n    return { type: 'JSON', name: this.options.name };\n  }\n\n  /**\n   * Get the configured name for this schema.\n   */\n  getName(): string | undefined {\n    return this.options.name;\n  }\n\n  /**\n   * Get the configured description for this schema.\n   */\n  getDescription(): string | undefined {\n    return this.options.description;\n  }\n}\n\n/**\n * Helper to wrap a raw Zod schema as a SchemaType.\n *\n * @param schema - The Zod schema to wrap\n * @param options - Optional configuration\n * @returns A SchemaType-compatible wrapper\n *\n * @example\n * ```typescript\n * const AddressSchema = fromZod(\n *   z.object({\n *     street: z.string(),\n *     city: z.string(),\n *     country: z.string(),\n *   }),\n *   { name: 'Address', description: 'Physical address' }\n * );\n * ```\n */\nexport const fromZod = <T extends z.ZodType>(\n  schema: T,\n  options?: ZodSchemaTypeOptions\n): ZodSchemaType<T> => new ZodSchemaType(schema, options);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,IAAa,gBAAb,MAEE;CACA,AAAiB;CACjB,AAAiB;CAEjB,YAAY,QAAW,UAAgC,EAAE,EAAE;AACzD,OAAK,SAAS;AACd,OAAK,UAAU;;;;;CAMjB,SAAgC;AAC9B,SAAO,KAAK;;;;;CAMd,gBAAyB;AACvB,SAAOA,IAAE,aAAa,KAAK,OAAO;;;;;;CAOpC,YAA6C;AAC3C,SAAO;GAAE,MAAM;GAAQ,MAAM,KAAK,QAAQ;GAAM;;;;;CAMlD,UAA8B;AAC5B,SAAO,KAAK,QAAQ;;;;;CAMtB,iBAAqC;AACnC,SAAO,KAAK,QAAQ;;;;;;;;;;;;;;;;;;;;;;AAuBxB,MAAa,WACX,QACA,YACqB,IAAI,cAAc,QAAQ,QAAQ"}

package/dist/entity/defineEntity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineEntity.js","names":["z"],"sources":["../../src/entity/defineEntity.ts"],"sourcesContent":["import * as z from 'zod';\nimport type {\n  EntityEnumDef,\n  EntityEnumField,\n  EntityField,\n  EntityIndex,\n  EntityRelationField,\n  EntityScalarField,\n  EntitySpec,\n} from './types';\n\n/**\n * Helper to define a database entity with full type safety.\n *\n * @example\n * ```typescript\n * const UserEntity = defineEntity({\n *   name: 'User',\n *   schema: 'lssm_sigil',\n *   description: 'A user of the platform.',\n *   fields: {\n *     id: field.id(),\n *     email: field.string({ isUnique: true, zod: z.string().email() }),\n *     name: field.string({ isOptional: true }),\n *     createdAt: field.createdAt(),\n *     updatedAt: field.updatedAt(),\n *     memberships: field.hasMany('Member'),\n *   },\n *   indexes: [{ fields: ['email'], unique: true }],\n * });\n * ```\n */\nexport function defineEntity<TFields extends Record<string, EntityField>>(\n  spec: EntitySpec<TFields>\n): EntitySpec<TFields> {\n  return spec;\n}\n\n/**\n * Helper to define an enum that can be shared across entities.\n */\nexport function defineEntityEnum(def: EntityEnumDef): EntityEnumDef {\n  return def;\n}\n\n/**\n * Field builder helpers for common field patterns.\n */\nexport const field = {\n  // ============ Scalar fields ============\n\n  /** String field */\n  string(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'String', ...opts };\n  },\n\n  /** Integer field */\n  int(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Int', ...opts };\n  },\n\n  /** Float field */\n  float(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Float', ...opts };\n  },\n\n  /** Boolean field */\n  boolean(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Boolean', ...opts };\n  },\n\n  /** DateTime field */\n  dateTime(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'DateTime', ...opts };\n  },\n\n  /** JSON field */\n  json(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Json', ...opts };\n  },\n\n  /** BigInt field */\n  bigInt(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'BigInt', ...opts };\n  },\n\n  /** Decimal field */\n  decimal(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Decimal', ...opts };\n  },\n\n  /** Bytes field */\n  bytes(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'Bytes', ...opts };\n  },\n\n  // ============ Common patterns ============\n\n  /** Primary key field with cuid() default */\n  id(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type' | 'isId'>>\n  ): EntityScalarField {\n    return {\n      kind: 'scalar',\n      type: 'String',\n      isId: true,\n      default: 'cuid()',\n      ...opts,\n    };\n  },\n\n  /** Primary key field with uuid() default */\n  uuid(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type' | 'isId'>>\n  ): EntityScalarField {\n    return {\n      kind: 'scalar',\n      type: 'String',\n      isId: true,\n      default: 'uuid()',\n      ...opts,\n    };\n  },\n\n  /** Auto-increment integer primary key */\n  autoIncrement(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type' | 'isId'>>\n  ): EntityScalarField {\n    return {\n      kind: 'scalar',\n      type: 'Int',\n      isId: true,\n      default: 'autoincrement()',\n      ...opts,\n    };\n  },\n\n  /** createdAt timestamp with now() default */\n  createdAt(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type' | 'default'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'DateTime', default: 'now()', ...opts };\n  },\n\n  /** updatedAt timestamp with @updatedAt */\n  updatedAt(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type' | 'updatedAt'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'DateTime', updatedAt: true, ...opts };\n  },\n\n  /** Email field with validation */\n  email(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return {\n      kind: 'scalar',\n      type: 'String',\n      zod: z.email(),\n      ...opts,\n    };\n  },\n\n  /** URL field with validation */\n  url(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return {\n      kind: 'scalar',\n      type: 'String',\n      zod: z.url(),\n      ...opts,\n    };\n  },\n\n  // ============ Enum fields ============\n\n  /** Enum field */\n  enum(\n    enumName: string,\n    opts?: Partial<Omit<EntityEnumField, 'kind' | 'enumName'>>\n  ): EntityEnumField {\n    return { kind: 'enum', enumName, ...opts };\n  },\n\n  /** Inline enum field with values */\n  inlineEnum(\n    enumName: string,\n    values: readonly string[],\n    opts?: Partial<Omit<EntityEnumField, 'kind' | 'enumName' | 'values'>>\n  ): EntityEnumField {\n    return { kind: 'enum', enumName, values, ...opts };\n  },\n\n  // ============ Relation fields ============\n\n  /** Has one relation (1:1 inverse side) */\n  hasOne(\n    target: string,\n    opts?: Partial<Omit<EntityRelationField, 'kind' | 'type' | 'target'>>\n  ): EntityRelationField {\n    return { kind: 'relation', type: 'hasOne', target, ...opts };\n  },\n\n  /** Has many relation (1:N inverse side) */\n  hasMany(\n    target: string,\n    opts?: Partial<Omit<EntityRelationField, 'kind' | 'type' | 'target'>>\n  ): EntityRelationField {\n    return { kind: 'relation', type: 'hasMany', target, ...opts };\n  },\n\n  /** Belongs to relation (N:1 owning side with foreign key) */\n  belongsTo(\n    target: string,\n    fields: string[],\n    references: string[],\n    opts?: Partial<\n      Omit<\n        EntityRelationField,\n        'kind' | 'type' | 'target' | 'fields' | 'references'\n      >\n    >\n  ): EntityRelationField {\n    return {\n      kind: 'relation',\n      type: 'belongsTo',\n      target,\n      fields,\n      references,\n      ...opts,\n    };\n  },\n\n  /** Foreign key field (string) - use with belongsTo */\n  foreignKey(\n    opts?: Partial<Omit<EntityScalarField, 'kind' | 'type'>>\n  ): EntityScalarField {\n    return { kind: 'scalar', type: 'String', ...opts };\n  },\n};\n\n/**\n * Index builder helpers.\n */\nexport const index = {\n  /** Create a regular index */\n  on(\n    fields: string[],\n    opts?: Partial<Omit<EntityIndex, 'fields'>>\n  ): EntityIndex {\n    return { fields, ...opts };\n  },\n\n  /** Create a unique constraint index */\n  unique(\n    fields: string[],\n    opts?: Partial<Omit<EntityIndex, 'fields' | 'unique'>>\n  ): EntityIndex {\n    return { fields, unique: true, ...opts };\n  },\n\n  /** Create a compound index with sort orders */\n  compound(\n    fields: string[],\n    sort: Record<string, 'Asc' | 'Desc'>,\n    opts?: Partial<Omit<EntityIndex, 'fields' | 'sort'>>\n  ): EntityIndex {\n    return { fields, sort, ...opts };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,aACd,MACqB;AACrB,QAAO;;;;;AAMT,SAAgB,iBAAiB,KAAmC;AAClE,QAAO;;;;;AAMT,MAAa,QAAQ;CAInB,OACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAU,GAAG;GAAM;;CAIpD,IACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAO,GAAG;GAAM;;CAIjD,MACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAS,GAAG;GAAM;;CAInD,QACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAW,GAAG;GAAM;;CAIrD,SACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAY,GAAG;GAAM;;CAItD,KACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAQ,GAAG;GAAM;;CAIlD,OACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAU,GAAG;GAAM;;CAIpD,QACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAW,GAAG;GAAM;;CAIrD,MACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAS,GAAG;GAAM;;CAMnD,GACE,MACmB;AACnB,SAAO;GACL,MAAM;GACN,MAAM;GACN,MAAM;GACN,SAAS;GACT,GAAG;GACJ;;CAIH,KACE,MACmB;AACnB,SAAO;GACL,MAAM;GACN,MAAM;GACN,MAAM;GACN,SAAS;GACT,GAAG;GACJ;;CAIH,cACE,MACmB;AACnB,SAAO;GACL,MAAM;GACN,MAAM;GACN,MAAM;GACN,SAAS;GACT,GAAG;GACJ;;CAIH,UACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAY,SAAS;GAAS,GAAG;GAAM;;CAIxE,UACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAY,WAAW;GAAM,GAAG;GAAM;;CAIvE,MACE,MACmB;AACnB,SAAO;GACL,MAAM;GACN,MAAM;GACN,KAAKA,IAAE,OAAO;GACd,GAAG;GACJ;;CAIH,IACE,MACmB;AACnB,SAAO;GACL,MAAM;GACN,MAAM;GACN,KAAKA,IAAE,KAAK;GACZ,GAAG;GACJ;;CAMH,KACE,UACA,MACiB;AACjB,SAAO;GAAE,MAAM;GAAQ;GAAU,GAAG;GAAM;;CAI5C,WACE,UACA,QACA,MACiB;AACjB,SAAO;GAAE,MAAM;GAAQ;GAAU;GAAQ,GAAG;GAAM;;CAMpD,OACE,QACA,MACqB;AACrB,SAAO;GAAE,MAAM;GAAY,MAAM;GAAU;GAAQ,GAAG;GAAM;;CAI9D,QACE,QACA,MACqB;AACrB,SAAO;GAAE,MAAM;GAAY,MAAM;GAAW;GAAQ,GAAG;GAAM;;CAI/D,UACE,QACA,QACA,YACA,MAMqB;AACrB,SAAO;GACL,MAAM;GACN,MAAM;GACN;GACA;GACA;GACA,GAAG;GACJ;;CAIH,WACE,MACmB;AACnB,SAAO;GAAE,MAAM;GAAU,MAAM;GAAU,GAAG;GAAM;;CAErD;;;;AAKD,MAAa,QAAQ;CAEnB,GACE,QACA,MACa;AACb,SAAO;GAAE;GAAQ,GAAG;GAAM;;CAI5B,OACE,QACA,MACa;AACb,SAAO;GAAE;GAAQ,QAAQ;GAAM,GAAG;GAAM;;CAI1C,SACE,QACA,MACA,MACa;AACb,SAAO;GAAE;GAAQ;GAAM,GAAG;GAAM;;CAEnC"}

package/dist/entity/generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.js","names":[],"sources":["../../src/entity/generator.ts"],"sourcesContent":["import type {\n  EntityEnumDef,\n  EntityEnumField,\n  EntityField,\n  EntityIndex,\n  EntityRelationField,\n  EntityScalarField,\n  EntitySpec,\n  ModuleSchemaContribution,\n} from './types';\n\n/**\n * Options for Prisma schema generation.\n */\nexport interface PrismaGeneratorOptions {\n  /** Output file path for the generated schema */\n  outputPath?: string;\n  /** Prisma datasource provider (default: 'postgresql') */\n  provider?: 'postgresql' | 'mysql' | 'sqlite' | 'mongodb' | 'sqlserver';\n  /** Prisma generator output path */\n  clientOutput?: string;\n  /** Include Pothos generator */\n  includePothos?: boolean;\n  /** Pothos output path */\n  pothosOutput?: string;\n}\n\n/**\n * Generate Prisma schema content from entity specifications.\n */\nexport function generatePrismaSchema(\n  entities: EntitySpec[],\n  options: PrismaGeneratorOptions = {}\n): string {\n  const {\n    provider = 'postgresql',\n    clientOutput = '../../src/generated/prisma',\n    includePothos = true,\n    pothosOutput = '../../src/generated/pothos-types.ts',\n  } = options;\n\n  const lines: string[] = [];\n\n  // Collect all schemas used\n  const schemas = new Set<string>();\n  entities.forEach((entity) => {\n    if (entity.schema) {\n      schemas.add(entity.schema);\n    }\n  });\n  const schemaList = schemas.size > 0 ? Array.from(schemas) : ['public'];\n\n  // Datasource block\n  lines.push('datasource db {');\n  lines.push(`  provider = \"${provider}\"`);\n  if (schemas.size > 0) {\n    lines.push(`  schemas  = [${schemaList.map((s) => `\"${s}\"`).join(', ')}]`);\n  }\n  lines.push('}');\n  lines.push('');\n\n  // Generator block\n  lines.push('generator client {');\n  lines.push('  provider = \"prisma-client\"');\n  lines.push(`  output   = \"${clientOutput}\"`);\n  lines.push('');\n  lines.push('  engineType             = \"client\"');\n  lines.push('  runtime                = \"bun\"');\n  lines.push('  moduleFormat           = \"esm\"');\n  lines.push('  generatedFileExtension = \"ts\"');\n  lines.push('  importFileExtension    = \"ts\"');\n  lines.push('}');\n  lines.push('');\n\n  // Pothos generator (optional)\n  if (includePothos) {\n    lines.push('generator pothos {');\n    lines.push('  provider          = \"prisma-pothos-types\"');\n    lines.push('  clientOutput      = \"./prisma\"');\n    lines.push(`  output            = \"${pothosOutput}\"`);\n    lines.push('  generateDatamodel = true');\n    lines.push('  documentation     = false');\n    lines.push('}');\n    lines.push('');\n  }\n\n  // Collect all enums across entities\n  const enumMap = new Map<string, EntityEnumDef>();\n  entities.forEach((entity) => {\n    entity.enums?.forEach((enumDef) => {\n      if (!enumMap.has(enumDef.name)) {\n        enumMap.set(enumDef.name, enumDef);\n      }\n    });\n    // Also collect inline enums from fields\n    Object.values(entity.fields).forEach((field) => {\n      if (\n        field.kind === 'enum' &&\n        field.values &&\n        !enumMap.has(field.enumName)\n      ) {\n        enumMap.set(field.enumName, {\n          name: field.enumName,\n          values: field.values,\n          schema: entity.schema,\n        });\n      }\n    });\n  });\n\n  // Generate enums\n  enumMap.forEach((enumDef) => {\n    lines.push(...generateEnumBlock(enumDef));\n    lines.push('');\n  });\n\n  // Generate models\n  entities.forEach((entity) => {\n    lines.push(...generateModelBlock(entity));\n    lines.push('');\n  });\n\n  return lines.join('\\n');\n}\n\n/**\n * Generate Prisma enum block.\n */\nfunction generateEnumBlock(enumDef: EntityEnumDef): string[] {\n  const lines: string[] = [];\n\n  if (enumDef.description) {\n    lines.push(`/// ${enumDef.description}`);\n  }\n\n  lines.push(`enum ${enumDef.name} {`);\n  enumDef.values.forEach((value) => {\n    lines.push(`  ${value}`);\n  });\n  lines.push('');\n  if (enumDef.schema) {\n    lines.push(`  @@schema(\"${enumDef.schema}\")`);\n  }\n  lines.push('}');\n\n  return lines;\n}\n\n/**\n * Generate Prisma model block from entity spec.\n */\nfunction generateModelBlock(entity: EntitySpec): string[] {\n  const lines: string[] = [];\n\n  // Model description\n  if (entity.description) {\n    lines.push(`/// ${entity.description}`);\n  }\n\n  lines.push(`model ${entity.name} {`);\n\n  // Generate fields\n  Object.entries(entity.fields).forEach(([fieldName, field]) => {\n    const fieldLine = generateFieldLine(fieldName, field);\n    if (field.description) {\n      lines.push(`  /// ${field.description}`);\n    }\n    lines.push(`  ${fieldLine}`);\n  });\n\n  // Generate indexes\n  if (entity.indexes && entity.indexes.length > 0) {\n    lines.push('');\n    entity.indexes.forEach((idx) => {\n      lines.push(`  ${generateIndexLine(idx)}`);\n    });\n  }\n\n  // Table mapping\n  if (entity.map) {\n    lines.push(`  @@map(\"${entity.map}\")`);\n  }\n\n  // Schema\n  if (entity.schema) {\n    lines.push(`  @@schema(\"${entity.schema}\")`);\n  }\n\n  lines.push('}');\n\n  return lines;\n}\n\n/**\n * Generate a single field line.\n */\nfunction generateFieldLine(fieldName: string, field: EntityField): string {\n  if (field.kind === 'scalar') {\n    return generateScalarFieldLine(fieldName, field);\n  } else if (field.kind === 'enum') {\n    return generateEnumFieldLine(fieldName, field);\n  } else if (field.kind === 'relation') {\n    return generateRelationFieldLine(fieldName, field);\n  }\n  throw new Error(`Unknown field kind: ${(field as EntityField).kind}`);\n}\n\n/**\n * Generate scalar field line.\n */\nfunction generateScalarFieldLine(\n  fieldName: string,\n  field: EntityScalarField\n): string {\n  const parts: string[] = [fieldName];\n\n  // Type with optional/array modifiers\n  let typeStr = field.type;\n  if (field.isArray) {\n    typeStr += '[]';\n  }\n  if (field.isOptional) {\n    typeStr += '?';\n  }\n  parts.push(typeStr);\n\n  // Attributes\n  const attrs: string[] = [];\n\n  if (field.isId) {\n    attrs.push('@id');\n  }\n\n  if (field.default !== undefined) {\n    if (typeof field.default === 'string' && field.default.includes('(')) {\n      // Function default like cuid(), now(), autoincrement()\n      attrs.push(`@default(${field.default})`);\n    } else if (typeof field.default === 'boolean') {\n      attrs.push(`@default(${field.default})`);\n    } else if (typeof field.default === 'number') {\n      attrs.push(`@default(${field.default})`);\n    } else {\n      attrs.push(`@default(\"${field.default}\")`);\n    }\n  }\n\n  if (field.updatedAt) {\n    attrs.push('@updatedAt');\n  }\n\n  if (field.isUnique) {\n    attrs.push('@unique');\n  }\n\n  if (field.map) {\n    attrs.push(`@map(\"${field.map}\")`);\n  }\n\n  if (field.dbType) {\n    attrs.push(`@db.${field.dbType}`);\n  }\n\n  if (attrs.length > 0) {\n    parts.push(attrs.join(' '));\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Generate enum field line.\n */\nfunction generateEnumFieldLine(\n  fieldName: string,\n  field: EntityEnumField\n): string {\n  const parts: string[] = [fieldName];\n\n  // Type with optional/array modifiers\n  let typeStr = field.enumName;\n  if (field.isArray) {\n    typeStr += '[]';\n  }\n  if (field.isOptional) {\n    typeStr += '?';\n  }\n  parts.push(typeStr);\n\n  // Attributes\n  const attrs: string[] = [];\n\n  if (field.default !== undefined) {\n    attrs.push(`@default(${field.default})`);\n  }\n\n  if (field.isUnique) {\n    attrs.push('@unique');\n  }\n\n  if (field.map) {\n    attrs.push(`@map(\"${field.map}\")`);\n  }\n\n  if (attrs.length > 0) {\n    parts.push(attrs.join(' '));\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Generate relation field line.\n */\nfunction generateRelationFieldLine(\n  fieldName: string,\n  field: EntityRelationField\n): string {\n  const parts: string[] = [fieldName];\n\n  // Type with array modifier for hasMany\n  let typeStr = field.target;\n  if (field.type === 'hasMany') {\n    typeStr += '[]';\n  }\n  if (field.type === 'hasOne') {\n    typeStr += '?';\n  }\n  parts.push(typeStr);\n\n  // @relation attribute\n  const relationParts: string[] = [];\n\n  if (field.name) {\n    relationParts.push(`name: \"${field.name}\"`);\n  }\n\n  if (field.fields && field.fields.length > 0) {\n    relationParts.push(`fields: [${field.fields.join(', ')}]`);\n  }\n\n  if (field.references && field.references.length > 0) {\n    relationParts.push(`references: [${field.references.join(', ')}]`);\n  }\n\n  if (field.onDelete) {\n    relationParts.push(`onDelete: ${field.onDelete}`);\n  }\n\n  if (field.onUpdate) {\n    relationParts.push(`onUpdate: ${field.onUpdate}`);\n  }\n\n  if (relationParts.length > 0) {\n    parts.push(`@relation(${relationParts.join(', ')})`);\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Generate index line.\n */\nfunction generateIndexLine(idx: EntityIndex): string {\n  const fieldList = idx.fields.join(', ');\n  const parts: string[] = [];\n\n  if (idx.unique) {\n    parts.push(`@@unique([${fieldList}]`);\n  } else {\n    parts.push(`@@index([${fieldList}]`);\n  }\n\n  const options: string[] = [];\n\n  if (idx.name) {\n    options.push(`name: \"${idx.name}\"`);\n  }\n\n  if (idx.type) {\n    options.push(`type: ${idx.type}`);\n  }\n\n  if (options.length > 0) {\n    parts[0] += `, ${options.join(', ')}`;\n  }\n\n  parts[0] += ')';\n\n  return parts.join('');\n}\n\n/**\n * Compose multiple module schema contributions into a single schema.\n */\nexport function composeModuleSchemas(\n  contributions: ModuleSchemaContribution[],\n  options: PrismaGeneratorOptions = {}\n): string {\n  // Merge all entities\n  const allEntities: EntitySpec[] = [];\n  const allEnums = new Map<string, EntityEnumDef>();\n\n  contributions.forEach((contrib) => {\n    // Add entities\n    contrib.entities.forEach((entity) => {\n      allEntities.push({\n        ...entity,\n        module: contrib.moduleId,\n      });\n    });\n\n    // Merge enums\n    contrib.enums?.forEach((enumDef) => {\n      if (!allEnums.has(enumDef.name)) {\n        allEnums.set(enumDef.name, enumDef);\n      }\n    });\n  });\n\n  // Add collected enums to first entity or create a holder\n  if (allEntities[0] && allEnums.size > 0) {\n    allEntities[0] = {\n      ...allEntities[0],\n      enums: [...(allEntities[0].enums ?? []), ...allEnums.values()],\n    };\n  }\n\n  return generatePrismaSchema(allEntities, options);\n}\n\n/**\n * Generate a single entity's Prisma schema fragment (for modular output).\n */\nexport function generateEntityFragment(entity: EntitySpec): string {\n  return generateModelBlock(entity).join('\\n');\n}\n\n/**\n * Generate a single enum's Prisma schema fragment (for modular output).\n */\nexport function generateEnumFragment(enumDef: EntityEnumDef): string {\n  return generateEnumBlock(enumDef).join('\\n');\n}\n"],"mappings":"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"}