@lssm/lib.schema 1.42.10 → 1.43.0

package/README.md

@@ -33,8 +33,16 @@ import { SchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
 - `SchemaModel` composes fields into named object models with helpers:
   - `getZod()` → typed `z.ZodObject` preserving each field's schema and optionality
   - `getPothosInput()` → builder name for input object
+  - `getPothosInput()` → builder name for input object
   - `getJsonSchema()` → resolved JSON Schema
 
+### Multi-Format Wrappers
+
+Use existing schema definitions from other libraries:
+- `ZodSchemaType`: Wraps a raw Zod schema (`z.infer` becomes the TS type).
+- `JsonSchemaType`: Wraps a JSON Schema object.
+- `GraphQLSchemaType`: Wraps a GraphQL SDL string.
+
 ### Enums
 
 - `EnumType<T>` represents string enums with a single source of truth:

package/dist/EnumType.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as z$1 from "zod";
 import { GraphQLEnumType } from "graphql";
 
 //#region src/EnumType.d.ts
@@ -18,7 +18,7 @@ declare class EnumType<T extends [string, ...string[]]> {
   /** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */
   getPothos(): GraphQLEnumType;
   /** zod schema representing this enum. */
-  getZod(): z.ZodEnum<{ [K in T[number]]: K }>;
+  getZod(): z$1.ZodEnum<{ [K in T[number]]: K }>;
   /** Minimal JSON representation (alias of getJsonSchema). */
   getJson(): {
     type: 'string';

package/dist/EnumType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnumType.d.ts","names":[],"sources":["../src/EnumType.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMA;AAKoC,cALvB,QAKuB,CAAA,UAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,CAAA,CAAA;EAejB,iBAAA,IAAA;EAMJ,iBAAA,MAAA;EAKe,iBAAA,OAAA;EAAY,WAAA,CAAA,IAAA,EAAA,MAAA,EAAA,MAAA,EA1BN,CA0BM;EAA5B;EAKuB,OAAA,CAAA,CAAA,EAAA,MAAA;EAKM;EAAC,aAAA,CAAA,CAAA,EArBzB,CAqByB;EAKhC;EAOC,SAAA,CAAA,CAAA,EA3BE,eA8BgB;EADrB;EAAC,MAAA,CAAA,CAAA,EAxBC,CAAA,CAAE,OAwBH,CAAA,QAxBmB,CAwBnB,CAAA,MAAA,CAAA,GAxB+B,CAwB/B,EAAA,CAAA;;;;UAnB0B;;;;;UAKM;;;KAK/B,WAAA,GAAc;;;;;;cAOb,oEAEH,MAAC,SAAA"}
+{"version":3,"file":"EnumType.d.ts","names":[],"sources":["../src/EnumType.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMA;AAKoC,cALvB,QAKuB,CAAA,UAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,CAAA,CAAA;EAejB,iBAAA,IAAA;EAMJ,iBAAA,MAAA;EAKe,iBAAA,OAAA;EAAY,WAAA,CAAA,IAAA,EAAA,MAAA,EAAA,MAAA,EA1BN,CA0BM;EAA9B;EAKyB,OAAA,CAAA,CAAA,EAAA,MAAA;EAKM;EAAC,aAAA,CAAA,CAAA,EArBzB,CAqByB;EAKhC;EAOC,SAAA,CAAA,CAAA,EA3BE,eA8BgB;EADrB;EAAC,MAAA,CAAA,CAAA,EAxBC,GAAA,CAAE,OAwBH,CAAA,QAxBmB,CAwBnB,CAAA,MAAA,CAAA,GAxB+B,CAwB/B,EAAA,CAAA;;;;UAnB0B;;;;;UAKM;;;KAK/B,WAAA,GAAc;;;;;;cAOb,oEAEH,MAAC,SAAA"}

package/dist/EnumType.js

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as z$1 from "zod";
 import { GraphQLEnumType } from "graphql";
 
 //#region src/EnumType.ts
@@ -31,7 +31,7 @@ var EnumType = class {
 	}
 	/** zod schema representing this enum. */
 	getZod() {
-		return z.enum(this.values);
+		return z$1.enum(this.values);
 	}
 	/** Minimal JSON representation (alias of getJsonSchema). */
 	getJson() {

package/dist/EnumType.js.map

@@ -1 +1 @@
-{"version":3,"file":"EnumType.js","names":[],"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,SAAO,EAAE,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"}
+{"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.d.ts

@@ -1,9 +1,9 @@
-import * as z from "zod";
+import * as z$1 from "zod";
 import { GraphQLScalarType, GraphQLScalarTypeConfig } from "graphql";
 
 //#region src/FieldType.d.ts
 interface FieldTypeConfig<TInternal, TExternal = TInternal> extends GraphQLScalarTypeConfig<TInternal, TExternal> {
-  zod: z.ZodType<TInternal>;
+  zod: z$1.ZodType<TInternal>;
   jsonSchema: unknown | (() => unknown);
 }
 type AnyFieldType = FieldType<any, any>;
@@ -17,7 +17,7 @@ declare class FieldType<TInternal, TExternal = TInternal> extends GraphQLScalarT
   private readonly jsonSchemaDef?;
   constructor(config: FieldTypeConfig<TInternal, TExternal>);
   /** Return the attached zod schema for validation. */
-  getZod(): z.ZodType<TInternal>;
+  getZod(): z$1.ZodType<TInternal>;
   /** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */
   getPothos(): GraphQLScalarType<TInternal, TExternal>;
   /** Return the JSON Schema (evaluates factory if provided). */
@@ -25,7 +25,7 @@ declare class FieldType<TInternal, TExternal = TInternal> extends GraphQLScalarT
   getJsonSchemaDef(): unknown | (() => unknown);
   getJsonSchema(): unknown;
 }
-type ZodFieldType<Field extends AnyFieldType> = z.infer<ReturnType<Field['getZod']>>;
+type ZodFieldType<Field extends AnyFieldType> = z$1.infer<ReturnType<Field['getZod']>>;
 //#endregion
 export { AnyFieldType, FieldType, FieldTypeConfig, ZodFieldType };
 //# sourceMappingURL=FieldType.d.ts.map

package/dist/FieldType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldType.d.ts","names":[],"sources":["../src/FieldType.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,uCAEH,mBACJ,wBAAwB,WAAW;OACtC,CAAA,CAAE,QAAQ;EAJA,UAAA,EAAA,OAAe,GAAA,CAAA,GAAA,GAAA,OAAA,CAAA;;AAGE,KAMtB,YAAA,GAAe,SANO,CAAA,GAAA,EAAA,GAAA,CAAA;;;;;;AAMtB,cAOC,SAPc,CAAA,SAAS,EAAA,YAStB,SATsB,CAAA,SAU1B,iBAV0B,CAUR,SAVQ,EAUG,SAVH,CAAA,CAAA;EAOvB,QAAA,SAAS;EAER,iBAAA,aAAA;EACc,WAAA,CAAA,MAAA,EAIN,eAJM,CAIU,SAJV,EAIqB,SAJrB,CAAA;EAAW;EAID,MAAA,CAAA,CAAA,EAO1B,CAAA,CAAE,OAPwB,CAOhB,SAPgB,CAAA;EAAW;EAA3B,SAAA,CAAA,CAAA,EAYP,iBAZO,CAYW,SAZX,EAYsB,SAZtB,CAAA;EAOA;EAAR,OAAA,CAAA,CAAA,EAAA,OAAA;EAKmB,gBAAA,CAAA,CAAA,EAAA,OAAA,GAAA,CAAA,GAAA,GAAA,OAAA,CAAA;EAAW,aAAA,CAAA,CAAA,EAAA,OAAA;;AAhBlC,KAoDE,YApDF,CAAA,cAoD6B,YApD7B,CAAA,GAoD6C,CAAA,CAAE,KApD/C,CAqDR,UArDQ,CAqDG,KArDH,CAAA,QAAA,CAAA,CAAA,CAAA"}
+{"version":3,"file":"FieldType.d.ts","names":[],"sources":["../src/FieldType.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,uCAEH,mBACJ,wBAAwB,WAAW;OACtC,GAAA,CAAE,QAAQ;EAJA,UAAA,EAAA,OAAe,GAAA,CAAA,GAAA,GAAA,OAAA,CAAA;;AAGE,KAMtB,YAAA,GAAe,SANO,CAAA,GAAA,EAAA,GAAA,CAAA;;;;;;AAMtB,cAOC,SAPW,CAAG,SAAA,EAAS,YAStB,SATsB,CAAA,SAU1B,iBAV0B,CAUR,SAVQ,EAUG,SAVH,CAAA,CAAA;EAOvB,QAAA,SAAS;EAER,iBAAA,aAAA;EACc,WAAA,CAAA,MAAA,EAIN,eAJM,CAIU,SAJV,EAIqB,SAJrB,CAAA;EAAW;EAID,MAAA,CAAA,CAAA,EAO1B,GAAA,CAAE,OAPwB,CAOhB,SAPgB,CAAA;EAAW;EAA3B,SAAA,CAAA,CAAA,EAYP,iBAZO,CAYW,SAZX,EAYsB,SAZtB,CAAA;EAOA;EAAV,OAAE,CAAA,CAAA,EAAA,OAAA;EAKmB,gBAAA,CAAA,CAAA,EAAA,OAAA,GAAA,CAAA,GAAA,GAAA,OAAA,CAAA;EAAW,aAAA,CAAA,CAAA,EAAA,OAAA;;AAhBlC,KAoDE,YApDF,CAAA,cAoD6B,YApD7B,CAAA,GAoD6C,GAAA,CAAE,KApD/C,CAqDR,UArDQ,CAqDG,KArDH,CAAA,QAAA,CAAA,CAAA,CAAA"}

package/dist/GraphQLSchemaType.d.ts

@@ -0,0 +1,19 @@
+import { SchemaModelType } from "./SchemaModelType.js";
+import { z } from "zod";
+
+//#region src/GraphQLSchemaType.d.ts
+
+/**
+ * Wrapper for GraphQL Type Definitions to be used in ContractSpec Schemas.
+ * Note: Runtime validation is limited to 'unknown' (pass-through) as SDL is not parsed at runtime.
+ */
+declare class GraphQLSchemaType implements SchemaModelType {
+  readonly typeDef: string;
+  readonly name: string;
+  readonly _isSchemaType = true;
+  constructor(typeDef: string, name: string);
+  getZod(): z.ZodType;
+}
+//#endregion
+export { GraphQLSchemaType };
+//# sourceMappingURL=GraphQLSchemaType.d.ts.map

package/dist/GraphQLSchemaType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphQLSchemaType.d.ts","names":[],"sources":["../src/GraphQLSchemaType.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;cAAa,iBAAA,YAA6B;;;;;YAQ9B,CAAA,CAAE"}

package/dist/GraphQLSchemaType.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+//#region src/GraphQLSchemaType.ts
+/**
+* Wrapper for GraphQL Type Definitions to be used in ContractSpec Schemas.
+* Note: Runtime validation is limited to 'unknown' (pass-through) as SDL is not parsed at runtime.
+*/
+var GraphQLSchemaType = class {
+	_isSchemaType = true;
+	constructor(typeDef, name) {
+		this.typeDef = typeDef;
+		this.name = name;
+	}
+	getZod() {
+		return z.unknown();
+	}
+};
+
+//#endregion
+export { GraphQLSchemaType };
+//# sourceMappingURL=GraphQLSchemaType.js.map

package/dist/GraphQLSchemaType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphQLSchemaType.js","names":["typeDef: string","name: string"],"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,AAAgBA,SAChB,AAAgBC,MAChB;EAFgB;EACA;;CAGlB,SAAoB;AAClB,SAAO,EAAE,SAAS"}

package/dist/JsonSchemaType.d.ts

@@ -0,0 +1,112 @@
+import { SchemaModelType } from "./SchemaModelType.js";
+import * as z$1 from "zod";
+
+//#region src/JsonSchemaType.d.ts
+
+/**
+ * JSON Schema definition structure.
+ * Supports standard JSON Schema draft-07/2020-12 properties.
+ */
+interface JsonSchemaDefinition {
+  type?: string | string[];
+  properties?: Record<string, JsonSchemaDefinition>;
+  required?: string[];
+  additionalProperties?: boolean | JsonSchemaDefinition;
+  items?: JsonSchemaDefinition | JsonSchemaDefinition[];
+  enum?: unknown[];
+  const?: unknown;
+  oneOf?: JsonSchemaDefinition[];
+  anyOf?: JsonSchemaDefinition[];
+  allOf?: JsonSchemaDefinition[];
+  $ref?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  format?: string;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  [key: string]: unknown;
+}
+/**
+ * Options for JsonSchemaType wrapper.
+ */
+interface JsonSchemaTypeOptions {
+  /** Name for identification */
+  name?: string;
+}
+/**
+ * Wrapper to use JSON Schema as a SchemaType.
+ * Converts to Zod at runtime for validation.
+ *
+ * @example
+ * ```typescript
+ * const CustomFieldsSchema = fromJsonSchema({
+ *   type: 'object',
+ *   additionalProperties: {
+ *     oneOf: [
+ *       { type: 'string' },
+ *       { type: 'number' },
+ *       { type: 'boolean' },
+ *     ],
+ *   },
+ * }, { name: 'CustomFields' });
+ * ```
+ */
+declare class JsonSchemaType implements SchemaModelType<Record<string, unknown>> {
+  private readonly jsonSchema;
+  private readonly options;
+  constructor(jsonSchema: JsonSchemaDefinition, options?: JsonSchemaTypeOptions);
+  /**
+   * Convert JSON Schema to Zod schema for runtime validation.
+   *
+   * Note: This is a simplified conversion. For complex schemas,
+   * consider using a dedicated json-schema-to-zod library.
+   */
+  getZod(): z$1.ZodType<Record<string, unknown>>;
+  /**
+   * Return the original JSON Schema.
+   */
+  getJsonSchema(): JsonSchemaDefinition;
+  /**
+   * Return GraphQL type info.
+   * JSON Schema types map to JSON scalar in GraphQL.
+   */
+  getPothos(): {
+    type: string;
+    name?: string;
+  };
+  /**
+   * Get the configured name for this schema.
+   */
+  getName(): string | undefined;
+  /**
+   * Convert a single JSON Schema property to Zod.
+   */
+  private convertPropertyToZod;
+}
+/**
+ * Helper to create a SchemaType from JSON Schema.
+ *
+ * @param schema - The JSON Schema definition
+ * @param options - Optional configuration
+ * @returns A SchemaType-compatible wrapper
+ *
+ * @example
+ * ```typescript
+ * const MetadataSchema = fromJsonSchema({
+ *   type: 'object',
+ *   properties: {
+ *     createdAt: { type: 'string', format: 'date-time' },
+ *     updatedAt: { type: 'string', format: 'date-time' },
+ *   },
+ *   required: ['createdAt'],
+ * });
+ * ```
+ */
+declare const fromJsonSchema: (schema: JsonSchemaDefinition, options?: JsonSchemaTypeOptions) => JsonSchemaType;
+//#endregion
+export { JsonSchemaDefinition, JsonSchemaType, JsonSchemaTypeOptions, fromJsonSchema };
+//# sourceMappingURL=JsonSchemaType.d.ts.map

package/dist/JsonSchemaType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSchemaType.d.ts","names":[],"sources":["../src/JsonSchemaType.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA2CiB,UA3BA,oBAAA,CA2BqB;EAuBzB,IAAA,CAAA,EAAA,MAAA,GAAA,MAAe,EAAA;EAC1B,UAAA,CAAA,EAjDa,MAiDb,CAAA,MAAA,EAjD4B,oBAiD5B,CAAA;EAMc,QAAA,CAAA,EAAA,MAAA,EAAA;EACH,oBAAA,CAAA,EAAA,OAAA,GAtDsB,oBAsDtB;EAYS,KAAA,CAAA,EAjEZ,oBAiEY,GAjEW,oBAiEX,EAAA;EAAV,IAAE,CAAA,EAAA,OAAA,EAAA;EAqCK,KAAA,CAAA,EAAA,OAAA;EAzDoB,KAAA,CAAA,EA1C7B,oBA0C6B,EAAA;EAAe,KAAA,CAAA,EAzC5C,oBAyC4C,EAAA;EA+HzC,KAAA,CAAA,EAvKH,oBA0K8C,EAAA;EAF9C,IAAA,CAAA,EAAA,MAAA;EACE,KAAA,CAAA,EAAA,MAAA;EACT,WAAA,CAAA,EAAA,MAAA;EAAqD,OAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;UAzJvC,qBAAA;;;;;;;;;;;;;;;;;;;;;;cAuBJ,cAAA,YAA0B,gBACrC;;;0BAMc,gCACH;;;;;;;YAYD,GAAA,CAAE,QAAQ;;;;mBAqCH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsEN,yBACH,gCACE,0BACT"}

package/dist/JsonSchemaType.js

@@ -0,0 +1,125 @@
+import * as z$1 from "zod";
+
+//#region src/JsonSchemaType.ts
+/**
+* JSON Schema wrapper for ContractSpec compatibility.
+*
+* Wraps JSON Schema definitions to implement the SchemaType interface,
+* enabling direct JSON Schema usage in ContractSpec definitions.
+*
+* @module JsonSchemaType
+*/
+/**
+* Wrapper to use JSON Schema as a SchemaType.
+* Converts to Zod at runtime for validation.
+*
+* @example
+* ```typescript
+* const CustomFieldsSchema = fromJsonSchema({
+*   type: 'object',
+*   additionalProperties: {
+*     oneOf: [
+*       { type: 'string' },
+*       { type: 'number' },
+*       { type: 'boolean' },
+*     ],
+*   },
+* }, { name: 'CustomFields' });
+* ```
+*/
+var JsonSchemaType = class JsonSchemaType {
+	jsonSchema;
+	options;
+	constructor(jsonSchema, options = {}) {
+		this.jsonSchema = jsonSchema;
+		this.options = options;
+	}
+	/**
+	* Convert JSON Schema to Zod schema for runtime validation.
+	*
+	* Note: This is a simplified conversion. For complex schemas,
+	* consider using a dedicated json-schema-to-zod library.
+	*/
+	getZod() {
+		if (this.jsonSchema.additionalProperties !== void 0) {
+			if (this.jsonSchema.additionalProperties === true) return z$1.record(z$1.string(), z$1.unknown());
+			if (typeof this.jsonSchema.additionalProperties === "object") return z$1.record(z$1.string(), z$1.unknown());
+			if (this.jsonSchema.additionalProperties === false) return z$1.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$1.object(shape).passthrough();
+		}
+		return z$1.object({}).passthrough();
+	}
+	/**
+	* Return the original JSON Schema.
+	*/
+	getJsonSchema() {
+		return this.jsonSchema;
+	}
+	/**
+	* Return GraphQL type info.
+	* JSON Schema types map to JSON scalar in GraphQL.
+	*/
+	getPothos() {
+		return {
+			type: "JSON",
+			name: this.options.name
+		};
+	}
+	/**
+	* Get the configured name for this schema.
+	*/
+	getName() {
+		return this.options.name;
+	}
+	/**
+	* Convert a single JSON Schema property to Zod.
+	*/
+	convertPropertyToZod(schema) {
+		switch (Array.isArray(schema.type) ? schema.type[0] : schema.type) {
+			case "string": return z$1.string();
+			case "number":
+			case "integer": return z$1.number();
+			case "boolean": return z$1.boolean();
+			case "array":
+				if (schema.items && !Array.isArray(schema.items)) return z$1.array(this.convertPropertyToZod(schema.items));
+				return z$1.array(z$1.unknown());
+			case "object":
+				if (schema.properties) return new JsonSchemaType(schema).getZod();
+				return z$1.record(z$1.string(), z$1.unknown());
+			case "null": return z$1.null();
+			default: return z$1.unknown();
+		}
+	}
+};
+/**
+* Helper to create a SchemaType from JSON Schema.
+*
+* @param schema - The JSON Schema definition
+* @param options - Optional configuration
+* @returns A SchemaType-compatible wrapper
+*
+* @example
+* ```typescript
+* const MetadataSchema = fromJsonSchema({
+*   type: 'object',
+*   properties: {
+*     createdAt: { type: 'string', format: 'date-time' },
+*     updatedAt: { type: 'string', format: 'date-time' },
+*   },
+*   required: ['createdAt'],
+* });
+* ```
+*/
+const fromJsonSchema = (schema, options) => new JsonSchemaType(schema, options);
+
+//#endregion
+export { JsonSchemaType, fromJsonSchema };
+//# sourceMappingURL=JsonSchemaType.js.map

package/dist/JsonSchemaType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSchemaType.js","names":["z","shape: Record<string, z.ZodType>"],"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,MAAMC,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,UAAOD,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

@@ -1,5 +1,5 @@
 import { FieldType } from "./FieldType.js";
-import * as z from "zod";
+import * as z$1 from "zod";
 import { Kind } from "graphql";
 
 //#region src/ScalarTypeEnum.ts
@@ -19,8 +19,8 @@ const ScalarTypeEnum = {
 	String_unsecure: () => new FieldType({
 		name: "String_unsecure",
 		description: "Unvalidated string scalar",
-		zod: z.string(),
-		parseValue: (v) => z.string().parse(v),
+		zod: z$1.string(),
+		parseValue: (v) => z$1.string().parse(v),
 		serialize: (v) => String(v),
 		parseLiteral: (ast) => {
 			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
@@ -31,10 +31,10 @@ const ScalarTypeEnum = {
 	Int_unsecure: () => new FieldType({
 		name: "Int_unsecure",
 		description: "Unvalidated integer scalar",
-		zod: z.number().int(),
+		zod: z$1.number().int(),
 		parseValue: (v) => {
 			const num = typeof v === "number" ? v : Number(v);
-			return z.number().int().parse(num);
+			return z$1.number().int().parse(num);
 		},
 		serialize: (v) => Math.trunc(typeof v === "number" ? v : Number(v)),
 		parseLiteral: (ast) => {
@@ -46,10 +46,10 @@ const ScalarTypeEnum = {
 	Float_unsecure: () => new FieldType({
 		name: "Float_unsecure",
 		description: "Unvalidated float scalar",
-		zod: z.number(),
+		zod: z$1.number(),
 		parseValue: (v) => {
 			const num = typeof v === "number" ? v : Number(v);
-			return z.number().parse(num);
+			return z$1.number().parse(num);
 		},
 		serialize: (v) => Number(v),
 		parseLiteral: (ast) => {
@@ -61,8 +61,8 @@ const ScalarTypeEnum = {
 	Boolean: () => new FieldType({
 		name: "Boolean",
 		description: "Unvalidated boolean scalar",
-		zod: z.boolean(),
-		parseValue: (v) => z.coerce.boolean().parse(v),
+		zod: z$1.boolean(),
+		parseValue: (v) => z$1.coerce.boolean().parse(v),
 		serialize: (v) => Boolean(v),
 		parseLiteral: (ast) => {
 			if (ast.kind !== Kind.BOOLEAN) throw new TypeError("Invalid literal");
@@ -73,8 +73,8 @@ const ScalarTypeEnum = {
 	ID: () => new FieldType({
 		name: "ID",
 		description: "Unvalidated id scalar",
-		zod: z.string(),
-		parseValue: (v) => z.string().parse(v),
+		zod: z$1.string(),
+		parseValue: (v) => z$1.string().parse(v),
 		serialize: (v) => String(v),
 		parseLiteral: (ast) => {
 			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
@@ -84,21 +84,21 @@ const ScalarTypeEnum = {
 	}),
 	JSON: () => new FieldType({
 		name: "JSON",
-		zod: z.any(),
+		zod: z$1.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),
+		zod: z$1.record(z$1.string(), z$1.any()),
+		parseValue: (v) => z$1.record(z$1.string(), z$1.any()).parse(v),
 		serialize: (v) => v ?? {},
 		jsonSchema: { type: "object" }
 	}),
 	Date: () => new FieldType({
 		name: "Date",
-		zod: z.date(),
+		zod: z$1.date(),
 		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
 		serialize: (v) => v instanceof Date ? v.toISOString().split("T")[0] : String(v),
 		jsonSchema: {
@@ -108,7 +108,7 @@ const ScalarTypeEnum = {
 	}),
 	DateTime: () => new FieldType({
 		name: "DateTime",
-		zod: z.date(),
+		zod: z$1.date(),
 		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
 		serialize: (v) => {
 			return v instanceof Date ? v.toISOString() : String(v);
@@ -120,8 +120,8 @@ const ScalarTypeEnum = {
 	}),
 	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),
+		zod: z$1.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),
+		parseValue: (v) => z$1.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -130,8 +130,8 @@ const ScalarTypeEnum = {
 	}),
 	EmailAddress: () => new FieldType({
 		name: "EmailAddress",
-		zod: z.string().email(),
-		parseValue: (v) => z.string().email().parse(v),
+		zod: z$1.string().email(),
+		parseValue: (v) => z$1.string().email().parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -140,8 +140,8 @@ const ScalarTypeEnum = {
 	}),
 	URL: () => new FieldType({
 		name: "URL",
-		zod: z.string().url(),
-		parseValue: (v) => z.string().url().parse(v),
+		zod: z$1.string().url(),
+		parseValue: (v) => z$1.string().url().parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -150,8 +150,8 @@ const ScalarTypeEnum = {
 	}),
 	PhoneNumber: () => new FieldType({
 		name: "PhoneNumber",
-		zod: z.string().regex(phoneRegex),
-		parseValue: (v) => z.string().regex(phoneRegex).parse(v),
+		zod: z$1.string().regex(phoneRegex),
+		parseValue: (v) => z$1.string().regex(phoneRegex).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -160,8 +160,8 @@ const ScalarTypeEnum = {
 	}),
 	NonEmptyString: () => new FieldType({
 		name: "NonEmptyString",
-		zod: z.string().min(1),
-		parseValue: (v) => z.string().min(1).parse(v),
+		zod: z$1.string().min(1),
+		parseValue: (v) => z$1.string().min(1).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -170,8 +170,8 @@ const ScalarTypeEnum = {
 	}),
 	Locale: () => new FieldType({
 		name: "Locale",
-		zod: z.string().regex(localeRegex),
-		parseValue: (v) => z.string().regex(localeRegex).parse(v),
+		zod: z$1.string().regex(localeRegex),
+		parseValue: (v) => z$1.string().regex(localeRegex).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -180,8 +180,8 @@ const ScalarTypeEnum = {
 	}),
 	TimeZone: () => new FieldType({
 		name: "TimeZone",
-		zod: z.string().regex(timezoneRegex),
-		parseValue: (v) => z.string().regex(timezoneRegex).parse(v),
+		zod: z$1.string().regex(timezoneRegex),
+		parseValue: (v) => z$1.string().regex(timezoneRegex).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -190,8 +190,8 @@ const ScalarTypeEnum = {
 	}),
 	Latitude: () => new FieldType({
 		name: "Latitude",
-		zod: z.number().min(latMin).max(latMax),
-		parseValue: (v) => z.coerce.number().min(latMin).max(latMax).parse(v),
+		zod: z$1.number().min(latMin).max(latMax),
+		parseValue: (v) => z$1.coerce.number().min(latMin).max(latMax).parse(v),
 		serialize: (v) => Number(v),
 		jsonSchema: {
 			type: "number",
@@ -201,8 +201,8 @@ const ScalarTypeEnum = {
 	}),
 	Longitude: () => new FieldType({
 		name: "Longitude",
-		zod: z.number().min(lonMin).max(lonMax),
-		parseValue: (v) => z.coerce.number().min(lonMin).max(lonMax).parse(v),
+		zod: z$1.number().min(lonMin).max(lonMax),
+		parseValue: (v) => z$1.coerce.number().min(lonMin).max(lonMax).parse(v),
 		serialize: (v) => Number(v),
 		jsonSchema: {
 			type: "number",
@@ -212,8 +212,8 @@ const ScalarTypeEnum = {
 	}),
 	Currency: () => new FieldType({
 		name: "Currency",
-		zod: z.string().regex(currencyRegex),
-		parseValue: (v) => z.string().regex(currencyRegex).parse(v),
+		zod: z$1.string().regex(currencyRegex),
+		parseValue: (v) => z$1.string().regex(currencyRegex).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",
@@ -222,8 +222,8 @@ const ScalarTypeEnum = {
 	}),
 	CountryCode: () => new FieldType({
 		name: "CountryCode",
-		zod: z.string().regex(countryRegex),
-		parseValue: (v) => z.string().regex(countryRegex).parse(v),
+		zod: z$1.string().regex(countryRegex),
+		parseValue: (v) => z$1.string().regex(countryRegex).parse(v),
 		serialize: (v) => String(v),
 		jsonSchema: {
 			type: "string",