@prisma-next/sql-contract 0.0.1

package/README.md

@@ -0,0 +1,154 @@
+# @prisma-next/sql-contract
+
+SQL contract types, validators, and IR factories for Prisma Next.
+
+## Overview
+
+This package provides TypeScript type definitions, Arktype validators, and factory functions for constructing SQL contract structures. It is located in the **shared plane**, making it available to both migration-plane (authoring, emitter) and runtime-plane (lanes, runtime) packages.
+
+## Responsibilities
+
+- **SQL Contract Types**: Defines SQL-specific contract types (`SqlContract`, `SqlStorage`, `StorageTable`, `ModelDefinition`, `SqlMappings`) that extend framework-level contract types
+- **Contract Validation**: Provides Arktype-based validators for structural validation of SQL contracts, storage, and models
+- **IR Factories**: Provides pure factory functions for constructing contract IR structures in tests and authoring
+- **Shared Plane Access**: Enables both migration-plane and runtime-plane packages to import SQL contract types without violating plane boundaries
+
+## Package Contents
+
+- **TypeScript Types**: Type definitions for `SqlContract`, `SqlStorage`, `StorageTable`, `ModelDefinition`, and related types
+- **Validators**: Arktype-based validators for structural validation of contracts, storage, and models
+- **Factories**: Pure factory functions for constructing contract IR structures in tests and authoring
+
+## Usage
+
+### TypeScript Types
+
+Import SQL contract types:
+
+```typescript
+import type {
+  SqlContract,
+  SqlStorage,
+  StorageTable,
+  ModelDefinition,
+} from '@prisma-next/sql-contract/exports/types';
+```
+
+### Validators
+
+Validate contract structures using Arktype validators:
+
+```typescript
+import { validateSqlContract, validateStorage, validateModel } from '@prisma-next/sql-contract/exports/validators';
+
+// Validate a complete contract
+const contract = validateSqlContract<Contract>(contractJson);
+
+// Validate storage structure
+const storage = validateStorage(storageJson);
+
+// Validate model structure
+const model = validateModel(modelJson);
+```
+
+### Factories
+
+Use factory functions to construct contract IR structures in tests:
+
+```typescript
+import { col, table, storage, model, contract, pk, unique, index, fk } from '@prisma-next/sql-contract/exports/factories';
+
+// Create a column
+const idColumn = col('pg/int4@1', false);
+
+// Create a table
+const userTable = table(
+  {
+    id: col('pg/int4@1'),
+    email: col('pg/text@1'),
+  },
+  {
+    pk: pk('id'),
+    uniques: [unique('email')],
+    indexes: [index('email')],
+  }
+);
+
+// Create storage
+const s = storage({ user: userTable });
+
+// Create a model
+const userModel = model('user', {
+  id: { column: 'id' },
+  email: { column: 'email' },
+});
+
+// Create a complete contract
+const c = contract({
+  target: 'postgres',
+  coreHash: 'sha256:abc123',
+  storage: s,
+  models: { User: userModel },
+});
+```
+
+## Exports
+
+- `./exports/types`: TypeScript type definitions
+- `./exports/validators`: Arktype validators for structural validation
+- `./exports/factories`: Factory functions for constructing contract IR
+
+## Architecture
+
+```mermaid
+flowchart TD
+    subgraph "SQL Contract Package (Shared Plane)"
+        TYPES[Type Definitions]
+        VALIDATORS[Validators]
+        FACTORIES[IR Factories]
+    end
+
+    subgraph "Migration Plane"
+        AUTHORING[Authoring]
+        EMITTER[Emitter]
+    end
+
+    subgraph "Runtime Plane"
+        LANES[Lanes]
+        RUNTIME[Runtime]
+    end
+
+    TYPES --> AUTHORING
+    TYPES --> EMITTER
+    TYPES --> LANES
+    TYPES --> RUNTIME
+    VALIDATORS --> AUTHORING
+    VALIDATORS --> EMITTER
+    VALIDATORS --> RUNTIME
+    FACTORIES --> AUTHORING
+    FACTORIES --> EMITTER
+```
+
+## Dependencies
+
+- **`@prisma-next/contract`**: Framework-level contract types (`ContractBase`)
+- **`arktype`**: Runtime validation library
+
+**Dependents:**
+- **`@prisma-next/sql-contract-ts`**: Uses SQL contract types and validators for authoring
+- **`@prisma-next/sql-contract-emitter`**: Uses SQL contract types for emission
+- **`@prisma-next/sql-query`**: Uses SQL contract types for query building
+- **`@prisma-next/sql-runtime`**: Uses SQL contract types for runtime execution
+- **`@prisma-next/sql-lane`**: Uses SQL contract types for lane operations
+
+## Related Packages
+
+- `@prisma-next/contract`: Framework-level contract types (`ContractBase`)
+- `@prisma-next/sql-contract-ts`: SQL contract authoring surface (uses this package)
+- `@prisma-next/emitter`: Contract emission engine (uses validators)
+
+## Related Subsystems
+
+- **[Data Contract](../../../docs/architecture%20docs/subsystems/1.%20Data%20Contract.md)**: Detailed subsystem specification
+- **[Contract Emitter & Types](../../../docs/architecture%20docs/subsystems/2.%20Contract%20Emitter%20&%20Types.md)**: Contract emission
+

package/dist/exports/factories.d.ts

@@ -0,0 +1,33 @@
+import { StorageColumn, SqlStorage, ModelDefinition, SqlMappings, SqlContract, ForeignKey, Index, ModelField, PrimaryKey, StorageTable, UniqueConstraint } from './types.js';
+import '@prisma-next/contract/types';
+
+declare function col(typeId: string, nullable?: boolean): StorageColumn;
+declare function pk(...columns: readonly string[]): PrimaryKey;
+declare function unique(...columns: readonly string[]): UniqueConstraint;
+declare function index(...columns: readonly string[]): Index;
+declare function fk(columns: readonly string[], refTable: string, refColumns: readonly string[], name?: string): ForeignKey;
+declare function table(columns: Record<string, StorageColumn>, opts?: {
+    pk?: PrimaryKey;
+    uniques?: readonly UniqueConstraint[];
+    indexes?: readonly Index[];
+    fks?: readonly ForeignKey[];
+}): StorageTable;
+declare function model(table: string, fields: Record<string, ModelField>, relations?: Record<string, unknown>): ModelDefinition;
+declare function storage(tables: Record<string, StorageTable>): SqlStorage;
+declare function contract(opts: {
+    target: string;
+    coreHash: string;
+    storage: SqlStorage;
+    models?: Record<string, ModelDefinition>;
+    relations?: Record<string, unknown>;
+    mappings?: Partial<SqlMappings>;
+    schemaVersion?: '1';
+    targetFamily?: 'sql';
+    profileHash?: string;
+    capabilities?: Record<string, Record<string, boolean>>;
+    extensions?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+    sources?: Record<string, unknown>;
+}): SqlContract;
+
+export { col, contract, fk, index, model, pk, storage, table, unique };

package/dist/exports/factories.js

@@ -0,0 +1,82 @@
+// src/factories.ts
+function col(typeId, nullable = false) {
+  return {
+    type: typeId,
+    nullable
+  };
+}
+function pk(...columns) {
+  return {
+    columns
+  };
+}
+function unique(...columns) {
+  return {
+    columns
+  };
+}
+function index(...columns) {
+  return {
+    columns
+  };
+}
+function fk(columns, refTable, refColumns, name) {
+  const references = {
+    table: refTable,
+    columns: refColumns
+  };
+  return {
+    columns,
+    references,
+    ...name !== void 0 && { name }
+  };
+}
+function table(columns, opts) {
+  return {
+    columns,
+    ...opts?.pk !== void 0 && { primaryKey: opts.pk },
+    uniques: opts?.uniques ?? [],
+    indexes: opts?.indexes ?? [],
+    foreignKeys: opts?.fks ?? []
+  };
+}
+function model(table2, fields, relations = {}) {
+  const storage2 = { table: table2 };
+  return {
+    storage: storage2,
+    fields,
+    relations
+  };
+}
+function storage(tables) {
+  return { tables };
+}
+function contract(opts) {
+  return {
+    schemaVersion: opts.schemaVersion ?? "1",
+    target: opts.target,
+    targetFamily: opts.targetFamily ?? "sql",
+    coreHash: opts.coreHash,
+    storage: opts.storage,
+    models: opts.models ?? {},
+    relations: opts.relations ?? {},
+    mappings: opts.mappings ?? {},
+    ...opts.profileHash !== void 0 && { profileHash: opts.profileHash },
+    ...opts.capabilities !== void 0 && { capabilities: opts.capabilities },
+    ...opts.extensions !== void 0 && { extensions: opts.extensions },
+    ...opts.meta !== void 0 && { meta: opts.meta },
+    ...opts.sources !== void 0 && { sources: opts.sources }
+  };
+}
+export {
+  col,
+  contract,
+  fk,
+  index,
+  model,
+  pk,
+  storage,
+  table,
+  unique
+};
+//# sourceMappingURL=factories.js.map

package/dist/exports/factories.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/factories.ts"],"sourcesContent":["import type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlMappings,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nexport function col(typeId: string, nullable = false): StorageColumn {\n  return {\n    type: typeId,\n    nullable,\n  };\n}\n\nexport function pk(...columns: readonly string[]): PrimaryKey {\n  return {\n    columns,\n  };\n}\n\nexport function unique(...columns: readonly string[]): UniqueConstraint {\n  return {\n    columns,\n  };\n}\n\nexport function index(...columns: readonly string[]): Index {\n  return {\n    columns,\n  };\n}\n\nexport function fk(\n  columns: readonly string[],\n  refTable: string,\n  refColumns: readonly string[],\n  name?: string,\n): ForeignKey {\n  const references: ForeignKeyReferences = {\n    table: refTable,\n    columns: refColumns,\n  };\n  return {\n    columns,\n    references,\n    ...(name !== undefined && { name }),\n  };\n}\n\nexport function table(\n  columns: Record<string, StorageColumn>,\n  opts?: {\n    pk?: PrimaryKey;\n    uniques?: readonly UniqueConstraint[];\n    indexes?: readonly Index[];\n    fks?: readonly ForeignKey[];\n  },\n): StorageTable {\n  return {\n    columns,\n    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),\n    uniques: opts?.uniques ?? [],\n    indexes: opts?.indexes ?? [],\n    foreignKeys: opts?.fks ?? [],\n  };\n}\n\nexport function model(\n  table: string,\n  fields: Record<string, ModelField>,\n  relations: Record<string, unknown> = {},\n): ModelDefinition {\n  const storage: ModelStorage = { table };\n  return {\n    storage,\n    fields,\n    relations,\n  };\n}\n\nexport function storage(tables: Record<string, StorageTable>): SqlStorage {\n  return { tables };\n}\n\nexport function contract(opts: {\n  target: string;\n  coreHash: string;\n  storage: SqlStorage;\n  models?: Record<string, ModelDefinition>;\n  relations?: Record<string, unknown>;\n  mappings?: Partial<SqlMappings>;\n  schemaVersion?: '1';\n  targetFamily?: 'sql';\n  profileHash?: string;\n  capabilities?: Record<string, Record<string, boolean>>;\n  extensions?: Record<string, unknown>;\n  meta?: Record<string, unknown>;\n  sources?: Record<string, unknown>;\n}): SqlContract {\n  return {\n    schemaVersion: opts.schemaVersion ?? '1',\n    target: opts.target,\n    targetFamily: opts.targetFamily ?? 'sql',\n    coreHash: opts.coreHash,\n    storage: opts.storage,\n    models: opts.models ?? {},\n    relations: opts.relations ?? {},\n    mappings: (opts.mappings ?? {}) as SqlMappings,\n    ...(opts.profileHash !== undefined && { profileHash: opts.profileHash }),\n    ...(opts.capabilities !== undefined && { capabilities: opts.capabilities }),\n    ...(opts.extensions !== undefined && { extensions: opts.extensions }),\n    ...(opts.meta !== undefined && { meta: opts.meta }),\n    ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),\n  } as SqlContract;\n}\n"],"mappings":";AAgBO,SAAS,IAAI,QAAgB,WAAW,OAAsB;AACnE,SAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,EACF;AACF;AAEO,SAAS,MAAM,SAAwC;AAC5D,SAAO;AAAA,IACL;AAAA,EACF;AACF;AAEO,SAAS,UAAU,SAA8C;AACtE,SAAO;AAAA,IACL;AAAA,EACF;AACF;AAEO,SAAS,SAAS,SAAmC;AAC1D,SAAO;AAAA,IACL;AAAA,EACF;AACF;AAEO,SAAS,GACd,SACA,UACA,YACA,MACY;AACZ,QAAM,aAAmC;AAAA,IACvC,OAAO;AAAA,IACP,SAAS;AAAA,EACX;AACA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAI,SAAS,UAAa,EAAE,KAAK;AAAA,EACnC;AACF;AAEO,SAAS,MACd,SACA,MAMc;AACd,SAAO;AAAA,IACL;AAAA,IACA,GAAI,MAAM,OAAO,UAAa,EAAE,YAAY,KAAK,GAAG;AAAA,IACpD,SAAS,MAAM,WAAW,CAAC;AAAA,IAC3B,SAAS,MAAM,WAAW,CAAC;AAAA,IAC3B,aAAa,MAAM,OAAO,CAAC;AAAA,EAC7B;AACF;AAEO,SAAS,MACdA,QACA,QACA,YAAqC,CAAC,GACrB;AACjB,QAAMC,WAAwB,EAAE,OAAAD,OAAM;AACtC,SAAO;AAAA,IACL,SAAAC;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,SAAS,QAAQ,QAAkD;AACxE,SAAO,EAAE,OAAO;AAClB;AAEO,SAAS,SAAS,MAcT;AACd,SAAO;AAAA,IACL,eAAe,KAAK,iBAAiB;AAAA,IACrC,QAAQ,KAAK;AAAA,IACb,cAAc,KAAK,gBAAgB;AAAA,IACnC,UAAU,KAAK;AAAA,IACf,SAAS,KAAK;AAAA,IACd,QAAQ,KAAK,UAAU,CAAC;AAAA,IACxB,WAAW,KAAK,aAAa,CAAC;AAAA,IAC9B,UAAW,KAAK,YAAY,CAAC;AAAA,IAC7B,GAAI,KAAK,gBAAgB,UAAa,EAAE,aAAa,KAAK,YAAY;AAAA,IACtE,GAAI,KAAK,iBAAiB,UAAa,EAAE,cAAc,KAAK,aAAa;AAAA,IACzE,GAAI,KAAK,eAAe,UAAa,EAAE,YAAY,KAAK,WAAW;AAAA,IACnE,GAAI,KAAK,SAAS,UAAa,EAAE,MAAM,KAAK,KAAK;AAAA,IACjD,GAAI,KAAK,YAAY,UAAa,EAAE,SAAS,KAAK,QAAmC;AAAA,EACvF;AACF;","names":["table","storage"]}

package/dist/exports/types.d.ts

@@ -0,0 +1,69 @@
+import { ContractBase } from '@prisma-next/contract/types';
+
+type StorageColumn = {
+    readonly type: string;
+    readonly nullable: boolean;
+};
+type PrimaryKey = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type UniqueConstraint = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type Index = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type ForeignKeyReferences = {
+    readonly table: string;
+    readonly columns: readonly string[];
+};
+type ForeignKey = {
+    readonly columns: readonly string[];
+    readonly references: ForeignKeyReferences;
+    readonly name?: string;
+};
+type StorageTable = {
+    readonly columns: Record<string, StorageColumn>;
+    readonly primaryKey?: PrimaryKey;
+    readonly uniques: ReadonlyArray<UniqueConstraint>;
+    readonly indexes: ReadonlyArray<Index>;
+    readonly foreignKeys: ReadonlyArray<ForeignKey>;
+};
+type SqlStorage = {
+    readonly tables: Record<string, StorageTable>;
+};
+type ModelField = {
+    readonly column: string;
+};
+type ModelStorage = {
+    readonly table: string;
+};
+type ModelDefinition = {
+    readonly storage: ModelStorage;
+    readonly fields: Record<string, ModelField>;
+    readonly relations: Record<string, unknown>;
+};
+type SqlMappings = {
+    readonly modelToTable?: Record<string, string>;
+    readonly tableToModel?: Record<string, string>;
+    readonly fieldToColumn?: Record<string, Record<string, string>>;
+    readonly columnToField?: Record<string, Record<string, string>>;
+    readonly codecTypes: Record<string, {
+        readonly output: unknown;
+    }>;
+    readonly operationTypes: Record<string, Record<string, unknown>>;
+};
+type SqlContract<S extends SqlStorage = SqlStorage, M extends Record<string, unknown> = Record<string, unknown>, R extends Record<string, unknown> = Record<string, unknown>, Map extends SqlMappings = SqlMappings> = ContractBase & {
+    readonly targetFamily: string;
+    readonly storage: S;
+    readonly models: M;
+    readonly relations: R;
+    readonly mappings: Map;
+};
+type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['codecTypes'];
+type ExtractOperationTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['operationTypes'];
+
+export type { ExtractCodecTypes, ExtractOperationTypes, ForeignKey, ForeignKeyReferences, Index, ModelDefinition, ModelField, ModelStorage, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, UniqueConstraint };

package/dist/exports/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/exports/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exports/validators.d.ts

@@ -0,0 +1,38 @@
+import { ModelDefinition, SqlContract, SqlStorage } from './types.js';
+import '@prisma-next/contract/types';
+
+/**
+ * Validates the structural shape of SqlStorage using Arktype.
+ *
+ * @param value - The storage value to validate
+ * @returns The validated storage if structure is valid
+ * @throws Error if the storage structure is invalid
+ */
+declare function validateStorage(value: unknown): SqlStorage;
+/**
+ * Validates the structural shape of ModelDefinition using Arktype.
+ *
+ * @param value - The model value to validate
+ * @returns The validated model if structure is valid
+ * @throws Error if the model structure is invalid
+ */
+declare function validateModel(value: unknown): ModelDefinition;
+/**
+ * Validates the structural shape of a SqlContract using Arktype.
+ *
+ * **Responsibility: Validation Only**
+ * This function validates that the contract has the correct structure and types.
+ * It does NOT normalize the contract - normalization must happen in the contract builder.
+ *
+ * The contract passed to this function must already be normalized (all required fields present).
+ * If normalization is needed, it should be done by the contract builder before calling this function.
+ *
+ * This ensures all required fields are present and have the correct types.
+ *
+ * @param value - The contract value to validate (typically from a JSON import)
+ * @returns The validated contract if structure is valid
+ * @throws Error if the contract structure is invalid
+ */
+declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
+
+export { validateModel, validateSqlContract, validateStorage };

package/dist/exports/validators.js

@@ -0,0 +1,95 @@
+// src/validators.ts
+import { type } from "arktype";
+var StorageColumnSchema = type.declare().type({
+  type: "string",
+  nullable: "boolean"
+});
+var PrimaryKeySchema = type.declare().type({
+  columns: type.string.array().readonly(),
+  "name?": "string"
+});
+var UniqueConstraintSchema = type.declare().type({
+  columns: type.string.array().readonly(),
+  "name?": "string"
+});
+var IndexSchema = type.declare().type({
+  columns: type.string.array().readonly(),
+  "name?": "string"
+});
+var ForeignKeyReferencesSchema = type.declare().type({
+  table: "string",
+  columns: type.string.array().readonly()
+});
+var ForeignKeySchema = type.declare().type({
+  columns: type.string.array().readonly(),
+  references: ForeignKeyReferencesSchema,
+  "name?": "string"
+});
+var StorageTableSchema = type.declare().type({
+  columns: type({ "[string]": StorageColumnSchema }),
+  "primaryKey?": PrimaryKeySchema,
+  uniques: UniqueConstraintSchema.array().readonly(),
+  indexes: IndexSchema.array().readonly(),
+  foreignKeys: ForeignKeySchema.array().readonly()
+});
+var StorageSchema = type.declare().type({
+  tables: type({ "[string]": StorageTableSchema })
+});
+var ModelFieldSchema = type.declare().type({
+  column: "string"
+});
+var ModelStorageSchema = type.declare().type({
+  table: "string"
+});
+var ModelSchema = type.declare().type({
+  storage: ModelStorageSchema,
+  fields: type({ "[string]": ModelFieldSchema }),
+  relations: type({ "[string]": "unknown" })
+});
+var SqlContractSchema = type({
+  "schemaVersion?": "'1'",
+  target: "string",
+  targetFamily: "'sql'",
+  coreHash: "string",
+  "profileHash?": "string",
+  "capabilities?": "Record<string, Record<string, boolean>>",
+  "extensions?": "Record<string, unknown>",
+  "meta?": "Record<string, unknown>",
+  "sources?": "Record<string, unknown>",
+  models: type({ "[string]": ModelSchema }),
+  storage: StorageSchema
+});
+function validateStorage(value) {
+  const result = StorageSchema(value);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Storage validation failed: ${messages}`);
+  }
+  return result;
+}
+function validateModel(value) {
+  const result = ModelSchema(value);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Model validation failed: ${messages}`);
+  }
+  return result;
+}
+function validateSqlContract(value) {
+  const rawValue = value;
+  if (rawValue.targetFamily !== void 0 && rawValue.targetFamily !== "sql") {
+    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
+  }
+  const contractResult = SqlContractSchema(value);
+  if (contractResult instanceof type.errors) {
+    const messages = contractResult.map((p) => p.message).join("; ");
+    throw new Error(`Contract structural validation failed: ${messages}`);
+  }
+  return contractResult;
+}
+export {
+  validateModel,
+  validateSqlContract,
+  validateStorage
+};
+//# sourceMappingURL=validators.js.map

package/dist/exports/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nconst StorageColumnSchema = type.declare<StorageColumn>().type({\n  type: 'string',\n  nullable: 'boolean',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst IndexSchema = type.declare<Index>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nconst ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n});\n\nconst StorageTableSchema = type.declare<StorageTable>().type({\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n});\n\nconst StorageSchema = type.declare<SqlStorage>().type({\n  tables: type({ '[string]': StorageTableSchema }),\n});\n\nconst ModelFieldSchema = type.declare<ModelField>().type({\n  column: 'string',\n});\n\nconst ModelStorageSchema = type.declare<ModelStorage>().type({\n  table: 'string',\n});\n\nconst ModelSchema = type.declare<ModelDefinition>().type({\n  storage: ModelStorageSchema,\n  fields: type({ '[string]': ModelFieldSchema }),\n  relations: type({ '[string]': 'unknown' }),\n});\n\nconst SqlContractSchema = type({\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  coreHash: 'string',\n  'profileHash?': 'string',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensions?': 'Record<string, unknown>',\n  'meta?': 'Record<string, unknown>',\n  'sources?': 'Record<string, unknown>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n});\n\n/**\n * Validates the structural shape of SqlStorage using Arktype.\n *\n * @param value - The storage value to validate\n * @returns The validated storage if structure is valid\n * @throws Error if the storage structure is invalid\n */\nexport function validateStorage(value: unknown): SqlStorage {\n  const result = StorageSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Storage validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of ModelDefinition using Arktype.\n *\n * @param value - The model value to validate\n * @returns The validated model if structure is valid\n * @throws Error if the model structure is invalid\n */\nexport function validateModel(value: unknown): ModelDefinition {\n  const result = ModelSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Model validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nexport function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as T;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@prisma-next/sql-contract",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "SQL contract types, validators, and IR factories for Prisma Next",
+  "dependencies": {
+    "arktype": "^2.1.25",
+    "@prisma-next/contract": "0.0.1"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.1",
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.1",
+    "@prisma-next/test-utils": "0.0.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./types": {
+      "types": "./dist/exports/types.d.ts",
+      "import": "./dist/exports/types.js"
+    },
+    "./validators": {
+      "types": "./dist/exports/validators.d.ts",
+      "import": "./dist/exports/validators.js"
+    },
+    "./factories": {
+      "types": "./dist/exports/factories.d.ts",
+      "import": "./dist/exports/factories.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
+    "clean": "node ../../../../scripts/clean.mjs"
+  }
+}