@contractspec/lib.schema 1.44.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaman Ventures, SASU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# @contractspec/lib.schema
+
+[![npm version](https://img.shields.io/npm/v/@contractspec/lib.schema)](https://www.npmjs.com/package/@contractspec/lib.schema)
+[![npm downloads](https://img.shields.io/npm/dt/@contractspec/lib.schema)](https://www.npmjs.com/package/@contractspec/lib.schema)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lssm-tech/contractspec)
+
+
+Website: https://contractspec.io/
+
+
+**Multi-surface consistency starts here** — Define schemas once, export to Zod, GraphQL, and JSON Schema.
+
+A schema dictionary to describe operation I/O once and generate consistent types across all surfaces (API, database, UI). Part of ContractSpec's spec-first approach.
+
+## Exports to:
+
+- zod (runtime validation)
+- Pothos (GraphQL type refs)
+- JSON Schema (via `zod-to-json-schema` or custom `getJsonSchema()` on `FieldType`)
+
+## Installation
+
+```bash
+npm install @contractspec/lib.schema
+# or
+bun add @contractspec/lib.schema
+```
+
+The package ships only pre-built `dist/` artifacts and type declarations. Import helpers directly, e.g.:
+
+```ts
+import { SchemaModel, ScalarTypeEnum } from '@contractspec/lib.schema';
+```
+
+## Primitives
+
+- `FieldType<T>` wraps a GraphQLScalarType and carries a zod schema, plus optional JSON Schema definition.
+- `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:
+  - `getZod()` → `z.enum([...])`
+  - `getPothos()` → GraphQL `GraphQLEnumType`
+  - `getJsonSchema()` → `{ type: 'string', enum: [...] }`
+  - Create with `defineEnum('Name', ['A','B'] as const)`
+
+Example
+
+```ts
+import { defineEnum, SchemaModel, ScalarTypeEnum } from '@contractspec/lib.schema';
+
+const Weekday = defineEnum('Weekday', [
+  'MO',
+  'TU',
+  'WE',
+  'TH',
+  'FR',
+  'SA',
+  'SU',
+] as const);
+
+const Rule = new SchemaModel({
+  name: 'Rule',
+  fields: {
+    timezone: { type: ScalarTypeEnum.TimeZone(), isOptional: false },
+    frequency: {
+      type: defineEnum('RecurrenceFrequency', [
+        'DAILY',
+        'WEEKLY',
+        'MONTHLY',
+        'YEARLY',
+      ] as const),
+      isOptional: false,
+    },
+    byWeekday: { type: Weekday, isOptional: true, isArray: true },
+  },
+});
+```
+
+## Usage
+
+Define fields with `FieldType` and group them into a `SchemaModel`. Adapters (REST/MCP/GraphQL) can consume these to generate appropriate I/O types while preserving a single source of truth.
+
+## API Overview
+
+- **FieldType<TInternal, TExternal = TInternal>**
+  - `getZod()` → zod schema
+  - `getPothos()` → GraphQL scalar type
+  - `getJsonSchema()` → deeply-resolved JSON Schema
+- **EnumType<T>**
+  - Construct via `defineEnum('Name', ['A','B'] as const)`
+  - `getZod()`, `getPothos()`, `getJsonSchema()`
+- **SchemaModel<Fields>**
+  - `getZod()` → typed `z.ZodObject`
+  - `getPothosInput()` → input object name for GraphQL builders
+  - Each field supports `{ isOptional: boolean, isArray?: true }`
+
+## Patterns & Conventions
+
+- Name models with PascalCase and suffix with `Input`/`Result` when ambiguous.
+- Use `ScalarTypeEnum` for common scalars: `NonEmptyString`, `Date`, `DateTime`, `Locale`, `TimeZone`, `Latitude`, `Longitude`, `PhoneNumber`, etc.
+- Prefer enums for constrained strings. Reuse enums across input/output models to ensure consistency.
+- Top-level arrays: define a nested model and set `isArray: true` on the field that holds the list, or create a dedicated list model if needed by adapters.
+
+## Example: Nested models + arrays
+
+```ts
+import { ScalarTypeEnum, SchemaModel, defineEnum } from '@contractspec/lib.schema';
+
+const Weekday = defineEnum('Weekday', [
+  'MO',
+  'TU',
+  'WE',
+  'TH',
+  'FR',
+  'SA',
+  'SU',
+] as const);
+
+const Address = new SchemaModel({
+  name: 'Address',
+  fields: {
+    city: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    country: { type: ScalarTypeEnum.CountryCode(), isOptional: false },
+  },
+});
+
+export const CreateSpotInput = new SchemaModel({
+  name: 'CreateSpotInput',
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    latitude: { type: ScalarTypeEnum.Latitude(), isOptional: false },
+    longitude: { type: ScalarTypeEnum.Longitude(), isOptional: false },
+    availabilityWeekdays: { type: Weekday, isOptional: true, isArray: true },
+    address: { type: Address, isOptional: true },
+  },
+});
+```
+
+## JSON Schema export
+
+Prefer `getZod()` + `zod-to-json-schema` for consistency. For advanced cases, expose a custom `getJsonSchema()` from `FieldType` or a specialized wrapper.

package/dist/EnumType.d.ts

@@ -0,0 +1,42 @@
+import * as z$1 from "zod";
+import { GraphQLEnumType } from "graphql";
+
+//#region src/EnumType.d.ts
+
+/**
+ * Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.
+ */
+declare class EnumType<T extends [string, ...string[]]> {
+  private readonly name;
+  private readonly values;
+  private readonly gqlEnum;
+  constructor(name: string, values: T);
+  /** Enum type name (used by GraphQL and JSON Schema). */
+  getName(): string;
+  /** Returns the literal tuple of allowed values. */
+  getEnumValues(): T;
+  /** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */
+  getPothos(): GraphQLEnumType;
+  /** zod schema representing this enum. */
+  getZod(): z$1.ZodEnum<{ [K in T[number]]: K }>;
+  /** Minimal JSON representation (alias of getJsonSchema). */
+  getJson(): {
+    type: 'string';
+    enum: T;
+  };
+  /** JSON Schema for this enum. */
+  getJsonSchema(): {
+    type: 'string';
+    enum: T;
+  };
+}
+type AnyEnumType = EnumType<[string, ...string[]]>;
+/**
+ * Helper to define an EnumType.
+ * @param name Display/type name used across GraphQL and JSON Schema
+ * @param values Literal tuple of allowed string values (at least one)
+ */
+declare const defineEnum: <T extends [string, ...string[]]>(name: string, values: T) => EnumType<T>;
+//#endregion
+export { AnyEnumType, EnumType, defineEnum };
+//# sourceMappingURL=EnumType.d.ts.map

package/dist/EnumType.d.ts.map

@@ -0,0 +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;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

@@ -0,0 +1,57 @@
+import * as z$1 from "zod";
+import { GraphQLEnumType } from "graphql";
+
+//#region src/EnumType.ts
+/**
+* Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.
+*/
+var EnumType = class {
+	name;
+	values;
+	gqlEnum;
+	constructor(name, values) {
+		this.name = name;
+		this.values = values;
+		this.gqlEnum = new GraphQLEnumType({
+			name: this.name,
+			values: Object.fromEntries(values.map((v) => [v, { value: v }]))
+		});
+	}
+	/** Enum type name (used by GraphQL and JSON Schema). */
+	getName() {
+		return this.name;
+	}
+	/** Returns the literal tuple of allowed values. */
+	getEnumValues() {
+		return this.values;
+	}
+	/** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */
+	getPothos() {
+		return this.gqlEnum;
+	}
+	/** zod schema representing this enum. */
+	getZod() {
+		return z$1.enum(this.values);
+	}
+	/** Minimal JSON representation (alias of getJsonSchema). */
+	getJson() {
+		return {
+			type: "string",
+			enum: this.values
+		};
+	}
+	/** JSON Schema for this enum. */
+	getJsonSchema() {
+		return this.getJson();
+	}
+};
+/**
+* Helper to define an EnumType.
+* @param name Display/type name used across GraphQL and JSON Schema
+* @param values Literal tuple of allowed string values (at least one)
+*/
+const defineEnum = (name, values) => new EnumType(name, values);
+
+//#endregion
+export { EnumType, defineEnum };
+//# sourceMappingURL=EnumType.js.map

package/dist/EnumType.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,31 @@
+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$1.ZodType<TInternal>;
+  jsonSchema: unknown | (() => unknown);
+}
+type AnyFieldType = FieldType<any, any>;
+/**
+ * GraphQL scalar wrapper that carries zod and JSON Schema metadata.
+ *
+ * TInternal is the runtime representation; TExternal is the GraphQL output.
+ */
+declare class FieldType<TInternal, TExternal = TInternal> extends GraphQLScalarType<TInternal, TExternal> {
+  private zodSchema;
+  private readonly jsonSchemaDef?;
+  constructor(config: FieldTypeConfig<TInternal, TExternal>);
+  /** Return the attached zod schema for validation. */
+  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). */
+  getJson(): unknown;
+  getJsonSchemaDef(): unknown | (() => unknown);
+  getJsonSchema(): unknown;
+}
+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

@@ -0,0 +1 @@
+{"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/FieldType.js

@@ -0,0 +1,50 @@
+import "zod";
+import { GraphQLScalarType } from "graphql";
+
+//#region src/FieldType.ts
+/**
+* GraphQL scalar wrapper that carries zod and JSON Schema metadata.
+*
+* TInternal is the runtime representation; TExternal is the GraphQL output.
+*/
+var FieldType = class extends GraphQLScalarType {
+	zodSchema;
+	jsonSchemaDef;
+	constructor(config) {
+		super(config);
+		this.zodSchema = config.zod;
+		this.jsonSchemaDef = config.jsonSchema;
+	}
+	/** Return the attached zod schema for validation. */
+	getZod() {
+		return this.zodSchema;
+	}
+	/** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */
+	getPothos() {
+		return this;
+	}
+	/** Return the JSON Schema (evaluates factory if provided). */
+	getJson() {
+		return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+	}
+	getJsonSchemaDef() {
+		return this.jsonSchemaDef;
+	}
+	getJsonSchema() {
+		const deepResolve = (v) => {
+			const value = typeof v === "function" ? v() : v;
+			if (Array.isArray(value)) return value.map((item) => deepResolve(item));
+			if (value && typeof value === "object") {
+				const obj = {};
+				for (const [k, val] of Object.entries(value)) obj[k] = deepResolve(val);
+				return obj;
+			}
+			return value;
+		};
+		return deepResolve(this.getJson());
+	}
+};
+
+//#endregion
+export { FieldType };
+//# sourceMappingURL=FieldType.js.map

package/dist/FieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldType.js","names":["obj: Record<string, unknown>"],"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,MAAMA,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.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