@prisma-next/sql-contract 0.3.0-dev.13 → 0.3.0-dev.131

package/src/validators.ts

@@ -2,22 +2,84 @@ import { type } from 'arktype';
 import type {
   ForeignKey,
   ForeignKeyReferences,
-  Index,
   ModelDefinition,
-  ModelField,
-  ModelStorage,
   PrimaryKey,
+  ReferentialAction,
   SqlContract,
   SqlStorage,
-  StorageColumn,
-  StorageTable,
+  StorageTypeInstance,
   UniqueConstraint,
 } from './types';
 
-const StorageColumnSchema = type.declare<StorageColumn>().type({
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;
+};
+type ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const generatorKindSchema = type("'generator'");
+const generatorIdSchema = type('string').narrow((value, ctx) => {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value) ? true : ctx.mustBe('a flat generator id');
+});
+
+export const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({
+  kind: literalKindSchema,
+  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',
+});
+
+export const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({
+  kind: functionKindSchema,
+  expression: 'string',
+});
+
+export const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+
+const ExecutionMutationDefaultValueSchema = type({
+  '+': 'reject',
+  kind: generatorKindSchema,
+  id: generatorIdSchema,
+  'params?': 'Record<string, unknown>',
+});
+
+const ExecutionMutationDefaultSchema = type({
+  '+': 'reject',
+  ref: {
+    '+': 'reject',
+    table: 'string',
+    column: 'string',
+  },
+  'onCreate?': ExecutionMutationDefaultValueSchema,
+  'onUpdate?': ExecutionMutationDefaultValueSchema,
+});
+
+const ExecutionSchema = type({
+  '+': 'reject',
+  mutations: {
+    '+': 'reject',
+    defaults: ExecutionMutationDefaultSchema.array().readonly(),
+  },
+});
+
+const StorageColumnSchema = type({
+  '+': 'reject',
   nativeType: 'string',
   codecId: 'string',
   nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
+}).narrow((col, ctx) => {
+  if (col.typeParams !== undefined && col.typeRef !== undefined) {
+    return ctx.mustBe('a column with either typeParams or typeRef, not both');
+  }
+  return true;
+});
+
+const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
+  codecId: 'string',
+  nativeType: 'string',
+  typeParams: 'Record<string, unknown>',
 });
 
 const PrimaryKeySchema = type.declare<PrimaryKey>().type({
@@ -30,23 +92,34 @@ const UniqueConstraintSchema = type.declare<UniqueConstraint>().type({
   'name?': 'string',
 });
 
-const IndexSchema = type.declare<Index>().type({
+export const IndexSchema = type({
   columns: type.string.array().readonly(),
   'name?': 'string',
+  'using?': 'string',
+  'config?': 'Record<string, unknown>',
 });
 
-const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
+export const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
   table: 'string',
   columns: type.string.array().readonly(),
 });
 
-const ForeignKeySchema = type.declare<ForeignKey>().type({
+export const ReferentialActionSchema = type
+  .declare<ReferentialAction>()
+  .type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+
+export const ForeignKeySchema = type.declare<ForeignKey>().type({
   columns: type.string.array().readonly(),
   references: ForeignKeyReferencesSchema,
   'name?': 'string',
+  'onDelete?': ReferentialActionSchema,
+  'onUpdate?': ReferentialActionSchema,
+  constraint: 'boolean',
+  index: 'boolean',
 });
 
-const StorageTableSchema = type.declare<StorageTable>().type({
+const StorageTableSchema = type({
+  '+': 'reject',
   columns: type({ '[string]': StorageColumnSchema }),
   'primaryKey?': PrimaryKeySchema,
   uniques: UniqueConstraintSchema.array().readonly(),
@@ -54,38 +127,82 @@ const StorageTableSchema = type.declare<StorageTable>().type({
   foreignKeys: ForeignKeySchema.array().readonly(),
 });
 
-const StorageSchema = type.declare<SqlStorage>().type({
+const StorageSchema = type({
+  '+': 'reject',
   tables: type({ '[string]': StorageTableSchema }),
+  'types?': type({ '[string]': StorageTypeInstanceSchema }),
 });
 
-const ModelFieldSchema = type.declare<ModelField>().type({
+const ModelFieldSchema = type({
+  'column?': 'string',
+  'nullable?': 'boolean',
+  'codecId?': 'string',
+});
+
+const ModelStorageFieldSchema = type({
   column: 'string',
+  'codecId?': 'string',
+  'nullable?': 'boolean',
 });
 
-const ModelStorageSchema = type.declare<ModelStorage>().type({
+const ModelStorageSchema = type({
   table: 'string',
+  'fields?': type({ '[string]': ModelStorageFieldSchema }),
 });
 
-const ModelSchema = type.declare<ModelDefinition>().type({
+const ModelSchema = type({
   storage: ModelStorageSchema,
   fields: type({ '[string]': ModelFieldSchema }),
   relations: type({ '[string]': 'unknown' }),
+  'discriminator?': 'unknown',
+  'variants?': 'unknown',
+  'base?': 'string',
+  'owner?': 'string',
+});
+
+const MappingsSchema = type({
+  '+': 'reject',
+  'modelToTable?': 'null | Record<string, string>',
+  'tableToModel?': 'null | Record<string, string>',
+  'fieldToColumn?': 'null | Record<string, Record<string, string>>',
+  'columnToField?': 'null | Record<string, Record<string, string>>',
+  'codecTypes?': 'null | Record<string, unknown>',
+  'operationTypes?': 'null | Record<string, Record<string, unknown>>',
+});
+
+const ContractMetaSchema = type({
+  '[string]': 'unknown',
 });
 
 const SqlContractSchema = type({
+  '+': 'reject',
   'schemaVersion?': "'1'",
   target: 'string',
   targetFamily: "'sql'",
-  coreHash: 'string',
+  'coreHash?': 'string',
+  storageHash: 'string',
+  'executionHash?': 'string',
   'profileHash?': 'string',
+  '_generated?': 'Record<string, unknown>',
   'capabilities?': 'Record<string, Record<string, boolean>>',
   'extensionPacks?': 'Record<string, unknown>',
-  'meta?': 'Record<string, unknown>',
+  'meta?': ContractMetaSchema,
   'sources?': 'Record<string, unknown>',
+  'relations?': type({ '[string]': 'unknown' }),
+  'roots?': 'Record<string, string>',
+  'mappings?': MappingsSchema,
   models: type({ '[string]': ModelSchema }),
   storage: StorageSchema,
+  'execution?': ExecutionSchema,
 });
 
+// NOTE: StorageColumnSchema, StorageTableSchema, and StorageSchema use bare type()
+// instead of type.declare<T>().type() because the ColumnDefault union's value field
+// includes bigint | Date (runtime-only types after decoding) which cannot be expressed
+// in Arktype's JSON validation DSL. The `as SqlStorage` cast in validateStorage() bridges
+// the gap between the JSON-safe Arktype output and the runtime TypeScript type.
+// See decodeContractDefaults() in validate.ts for the decoding step.
+
 /**
  * Validates the structural shape of SqlStorage using Arktype.
  *
@@ -99,7 +216,7 @@ export function validateStorage(value: unknown): SqlStorage {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Storage validation failed: ${messages}`);
   }
-  return result;
+  return result as SqlStorage;
 }
 
 /**
@@ -115,7 +232,7 @@ export function validateModel(value: unknown): ModelDefinition {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Model validation failed: ${messages}`);
   }
-  return result;
+  return result as ModelDefinition;
 }
 
 /**
@@ -135,6 +252,10 @@ export function validateModel(value: unknown): ModelDefinition {
  * @throws Error if the contract structure is invalid
  */
 export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {
+  if (typeof value !== 'object' || value === null) {
+    throw new Error('Contract structural validation failed: value must be an object');
+  }
+
   // Check targetFamily first to provide a clear error message for unsupported target families
   const rawValue = value as { targetFamily?: string };
   if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {
@@ -153,3 +274,48 @@ export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: un
   // between Arktype's inferred type and the generic T, but runtime-wise they're compatible
   return contractResult as T;
 }
+
+/**
+ * Validates semantic constraints on SqlStorage that cannot be expressed in Arktype schemas.
+ *
+ * Returns an array of human-readable error strings. Empty array = valid.
+ *
+ * Currently checks:
+ * - `setNull` referential action on a non-nullable FK column (would fail at runtime)
+ * - `setDefault` referential action on a non-nullable FK column without a DEFAULT (would fail at runtime)
+ */
+export function validateStorageSemantics(storage: SqlStorage): string[] {
+  const errors: string[] = [];
+
+  for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const fk of table.foreignKeys) {
+      for (const colName of fk.columns) {
+        const column = table.columns[colName];
+        if (!column) continue;
+
+        if (fk.onDelete === 'setNull' && !column.nullable) {
+          errors.push(
+            `Table "${tableName}": onDelete setNull on foreign key column "${colName}" which is NOT NULL`,
+          );
+        }
+        if (fk.onUpdate === 'setNull' && !column.nullable) {
+          errors.push(
+            `Table "${tableName}": onUpdate setNull on foreign key column "${colName}" which is NOT NULL`,
+          );
+        }
+        if (fk.onDelete === 'setDefault' && !column.nullable && column.default === undefined) {
+          errors.push(
+            `Table "${tableName}": onDelete setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`,
+          );
+        }
+        if (fk.onUpdate === 'setDefault' && !column.nullable && column.default === undefined) {
+          errors.push(
+            `Table "${tableName}": onUpdate setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`,
+          );
+        }
+      }
+    }
+  }
+
+  return errors;
+}

package/dist/exports/factories.d.ts

@@ -1,2 +0,0 @@
-export { col, contract, fk, index, model, pk, storage, table, unique, } from '../factories';
-//# sourceMappingURL=factories.d.ts.map

package/dist/exports/factories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../src/exports/factories.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,EAAE,EACF,KAAK,EACL,KAAK,EACL,EAAE,EACF,OAAO,EACP,KAAK,EACL,MAAM,GACP,MAAM,cAAc,CAAC"}

package/dist/exports/factories.js

@@ -1,83 +0,0 @@
-// src/factories.ts
-function col(nativeType, codecId, nullable = false) {
-  return {
-    nativeType,
-    codecId,
-    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.extensionPacks !== void 0 && { extensionPacks: opts.extensionPacks },
-    ...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

@@ -1 +0,0 @@
-{"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\n/**\n * Creates a StorageColumn with nativeType and codecId.\n *\n * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')\n * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')\n * @param nullable - Whether the column is nullable (default: false)\n * @returns StorageColumn with nativeType and codecId\n */\nexport function col(nativeType: string, codecId: string, nullable = false): StorageColumn {\n  return {\n    nativeType,\n    codecId,\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  extensionPacks?: 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.extensionPacks !== undefined && { extensionPacks: opts.extensionPacks }),\n    ...(opts.meta !== undefined && { meta: opts.meta }),\n    ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),\n  } as SqlContract;\n}\n"],"mappings":";AAwBO,SAAS,IAAI,YAAoB,SAAiB,WAAW,OAAsB;AACxF,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;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,mBAAmB,UAAa,EAAE,gBAAgB,KAAK,eAAe;AAAA,IAC/E,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/pack-types.d.ts

@@ -1,2 +0,0 @@
-export type { StorageTypeMetadata } from '../pack-types';
-//# sourceMappingURL=pack-types.d.ts.map

package/dist/exports/pack-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pack-types.d.ts","sourceRoot":"","sources":["../../src/exports/pack-types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/exports/pack-types.js

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

package/dist/exports/pack-types.js.map

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

package/dist/exports/types.d.ts

@@ -1,2 +0,0 @@
-export type { ExtractCodecTypes, ExtractOperationTypes, ForeignKey, ForeignKeyReferences, Index, ModelDefinition, ModelField, ModelStorage, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, UniqueConstraint, } from '../types';
-//# sourceMappingURL=types.d.ts.map

package/dist/exports/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/exports/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,UAAU,EACV,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,GACjB,MAAM,UAAU,CAAC"}

package/dist/exports/types.js

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

package/dist/exports/types.js.map

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

package/dist/exports/validators.d.ts

@@ -1,2 +0,0 @@
-export { validateModel, validateSqlContract, validateStorage } from '../validators';
-//# sourceMappingURL=validators.d.ts.map

package/dist/exports/validators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/exports/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/exports/validators.js

@@ -1,96 +0,0 @@
-// src/validators.ts
-import { type } from "arktype";
-var StorageColumnSchema = type.declare().type({
-  nativeType: "string",
-  codecId: "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>>",
-  "extensionPacks?": "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

@@ -1 +0,0 @@
-{"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  nativeType: 'string',\n  codecId: '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  'extensionPacks?': '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/dist/factories.d.ts

@@ -1,38 +0,0 @@
-import type { ForeignKey, Index, ModelDefinition, ModelField, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, UniqueConstraint } from './types';
-/**
- * Creates a StorageColumn with nativeType and codecId.
- *
- * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')
- * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')
- * @param nullable - Whether the column is nullable (default: false)
- * @returns StorageColumn with nativeType and codecId
- */
-export declare function col(nativeType: string, codecId: string, nullable?: boolean): StorageColumn;
-export declare function pk(...columns: readonly string[]): PrimaryKey;
-export declare function unique(...columns: readonly string[]): UniqueConstraint;
-export declare function index(...columns: readonly string[]): Index;
-export declare function fk(columns: readonly string[], refTable: string, refColumns: readonly string[], name?: string): ForeignKey;
-export declare function table(columns: Record<string, StorageColumn>, opts?: {
-    pk?: PrimaryKey;
-    uniques?: readonly UniqueConstraint[];
-    indexes?: readonly Index[];
-    fks?: readonly ForeignKey[];
-}): StorageTable;
-export declare function model(table: string, fields: Record<string, ModelField>, relations?: Record<string, unknown>): ModelDefinition;
-export declare function storage(tables: Record<string, StorageTable>): SqlStorage;
-export 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>>;
-    extensionPacks?: Record<string, unknown>;
-    meta?: Record<string, unknown>;
-    sources?: Record<string, unknown>;
-}): SqlContract;
-//# sourceMappingURL=factories.d.ts.map

package/dist/factories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../src/factories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAEV,KAAK,EACL,eAAe,EACf,UAAU,EAEV,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,aAAa,CAMxF;AAED,wBAAgB,EAAE,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CAI5D;AAED,wBAAgB,MAAM,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,CAItE;AAED,wBAAgB,KAAK,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAI1D;AAED,wBAAgB,EAAE,CAChB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,IAAI,CAAC,EAAE,MAAM,GACZ,UAAU,CAUZ;AAED,wBAAgB,KAAK,CACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACtC,IAAI,CAAC,EAAE;IACL,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,OAAO,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,OAAO,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC3B,GAAG,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7B,GACA,YAAY,CAQd;AAED,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAClC,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACtC,eAAe,CAOjB;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,UAAU,CAExE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAChC,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,GAAG,WAAW,CAgBd"}

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from './exports/factories';
-export * from './exports/types';
-export * from './exports/validators';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}

package/dist/pack-types.d.ts

@@ -1,10 +0,0 @@
-/**
- * Storage type metadata for pack refs.
- */
-export interface StorageTypeMetadata {
-    readonly typeId: string;
-    readonly familyId: string;
-    readonly targetId: string;
-    readonly nativeType?: string;
-}
-//# sourceMappingURL=pack-types.d.ts.map

package/dist/pack-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pack-types.d.ts","sourceRoot":"","sources":["../src/pack-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B"}