@prisma-next/sql-contract 0.14.0-dev.31 → 0.14.0-dev.32

package/dist/contract-view.d.mts

@@ -0,0 +1,61 @@
+import { s as SqlStorage } from "./sql-storage-CUP3mD3c.mjs";
+import { DefaultNamespaceEntries, NamespacedEntities, SingleNamespaceView } from "@prisma-next/framework-components/ir";
+import { Contract } from "@prisma-next/contract/types";
+
+//#region src/contract-view.d.ts
+/**
+ * The SQL family's statically-named built-in entity kinds. `table` and
+ * `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+ * (e.g. `policy`) stay under `.entries`.
+ */
+declare const SQL_BUILTIN_KINDS: readonly ["table", "valueSet"];
+type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];
+type SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<TContract['storage']>;
+/**
+ * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds
+ * under `entries`. A target that never emits a built-in kind (SQLite has
+ * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty
+ * map.
+ */
+type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> = SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;
+/**
+ * Single-namespace SQL view: the deserialized contract intersected with the
+ * by-name accessors, so the value is substitutable for `Contract` while also
+ * exposing:
+ *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole
+ *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.
+ *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole
+ *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.
+ */
+type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract & SqlSingleNamespaceAccessors<TContract> & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+ * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+ * `namespace` map, and layers both over the deserialized contract. Targets with
+ * one default namespace (SQLite) call this directly; Postgres qualifies by
+ * schema.
+ */
+declare function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSingleNamespaceView<TContract>;
+/**
+ * Schema-qualified SQL view: the deserialized contract intersected with a single
+ * `view.namespace.<id>` member — every schema reached by raw id
+ * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`
+ * keying exactly (the default schema keeps its literal `__unbound__` id). There
+ * is NO root schema-name promotion, so there is no collision with contract
+ * envelope fields — `view.storage` is always the contract's `storage`. Postgres
+ * uses this; SQLite (single default namespace) uses
+ * {@link buildSqlSingleNamespaceView}.
+ */
+type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+ * map over the deserialized contract. Postgres uses this.
+ */
+declare function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSchemaQualifiedView<TContract>;
+//#endregion
+export { SQL_BUILTIN_KINDS, type SqlBuiltinKind, type SqlSchemaQualifiedView, type SqlSingleNamespaceAccessors, type SqlSingleNamespaceView, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+//# sourceMappingURL=contract-view.d.mts.map

package/dist/contract-view.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.d.mts","names":[],"sources":["../src/contract-view.ts"],"mappings":";;;;;;;AAeA;;;cAAa,iBAAA;AAAA,KACD,cAAA,WAAyB,iBAAiB;AAAA,KAEjD,UAAA,mBAA6B,QAAA,CAAS,UAAA,KAAe,uBAAA,CACxD,SAAA;;;;AAHoD;AAAU;;KAYpD,2BAAA,mBAA8C,QAAA,CAAS,UAAA,KACjE,mBAAA,CAAoB,UAAA,CAAW,SAAA,GAAY,cAAA;;;;;;;;;;KAWjC,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA,GAC3E,2BAAA,CAA4B,SAAA;EAAA,SACjB,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAvBtD;AASX;;;;;;AATW,iBAiCK,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA;;;;;;;;;;;KAyBd,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA;EAAA,SAClE,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAxC/D;;;;AAAA,iBA+CgB,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA"}

package/dist/contract-view.mjs

@@ -0,0 +1,39 @@
+import { buildNamespacedEntities, buildSingleNamespaceView } from "@prisma-next/framework-components/ir";
+//#region src/contract-view.ts
+/**
+* The SQL family's statically-named built-in entity kinds. `table` and
+* `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+* (e.g. `policy`) stay under `.entries`.
+*/
+const SQL_BUILTIN_KINDS = ["table", "valueSet"];
+/**
+* Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+* built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+* `namespace` map, and layers both over the deserialized contract. Targets with
+* one default namespace (SQLite) call this directly; Postgres qualifies by
+* schema.
+*/
+function buildSqlSingleNamespaceView(contract) {
+	const rootAccessors = buildSingleNamespaceView(contract.storage, SQL_BUILTIN_KINDS);
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		...rootAccessors,
+		namespace
+	};
+}
+/**
+* Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+* map over the deserialized contract. Postgres uses this.
+*/
+function buildSqlSchemaQualifiedView(contract) {
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		namespace
+	};
+}
+//#endregion
+export { SQL_BUILTIN_KINDS, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+
+//# sourceMappingURL=contract-view.mjs.map

package/dist/contract-view.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.mjs","names":[],"sources":["../src/contract-view.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildNamespacedEntities,\n  buildSingleNamespaceView,\n  type DefaultNamespaceEntries,\n  type NamespacedEntities,\n  type SingleNamespaceView,\n} from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from './ir/sql-storage';\n\n/**\n * The SQL family's statically-named built-in entity kinds. `table` and\n * `valueSet` are promoted to top-level view accessors; pack-contributed kinds\n * (e.g. `policy`) stay under `.entries`.\n */\nexport const SQL_BUILTIN_KINDS = ['table', 'valueSet'] as const;\nexport type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];\n\ntype SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<\n  TContract['storage']\n>;\n\n/**\n * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds\n * under `entries`. A target that never emits a built-in kind (SQLite has\n * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty\n * map.\n */\nexport type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> =\n  SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;\n\n/**\n * Single-namespace SQL view: the deserialized contract intersected with the\n * by-name accessors, so the value is substitutable for `Contract` while also\n * exposing:\n *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole\n *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.\n *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole\n *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.\n */\nexport type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract &\n  SqlSingleNamespaceAccessors<TContract> & {\n    readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n  };\n\n/**\n * Builds the single-namespace SQL view: unwraps the sole namespace's SQL\n * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed\n * `namespace` map, and layers both over the deserialized contract. Targets with\n * one default namespace (SQLite) call this directly; Postgres qualifies by\n * schema.\n */\nexport function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSingleNamespaceView<TContract> {\n  const rootAccessors = buildSingleNamespaceView<SqlSingleNamespaceAccessors<TContract>>(\n    contract.storage,\n    SQL_BUILTIN_KINDS,\n  );\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    ...rootAccessors,\n    namespace,\n  };\n}\n\n/**\n * Schema-qualified SQL view: the deserialized contract intersected with a single\n * `view.namespace.<id>` member — every schema reached by raw id\n * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`\n * keying exactly (the default schema keeps its literal `__unbound__` id). There\n * is NO root schema-name promotion, so there is no collision with contract\n * envelope fields — `view.storage` is always the contract's `storage`. Postgres\n * uses this; SQLite (single default namespace) uses\n * {@link buildSqlSingleNamespaceView}.\n */\nexport type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {\n  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n};\n\n/**\n * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`\n * map over the deserialized contract. Postgres uses this.\n */\nexport function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSchemaQualifiedView<TContract> {\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    namespace,\n  };\n}\n"],"mappings":";;;;;;;AAeA,MAAa,oBAAoB,CAAC,SAAS,UAAU;;;;;;;;AAqCrD,SAAgB,4BACd,UACmC;CACnC,MAAM,gBAAgB,yBACpB,SAAS,SACT,iBACF;CACA,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH,GAAG;EACH;CACF;AACF;;;;;AAoBA,SAAgB,4BACd,UACmC;CACnC,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH;CACF;AACF"}

package/dist/validators.d.mts

@@ -1,8 +1,8 @@
 import { n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
 import { c as UniqueConstraintInput, m as PrimaryKeyInput } from "./storage-value-set-B1Xmb6D2.mjs";
 import { s as SqlStorage } from "./sql-storage-CUP3mD3c.mjs";
-import { Type } from "arktype";
 import { AnyEntityKindDescriptor } from "@prisma-next/framework-components/ir";
+import { Type } from "arktype";
 import { Contract } from "@prisma-next/contract/types";
 
 //#region src/ir/storage-entry-schemas.d.ts

package/dist/validators.mjs

@@ -1,6 +1,6 @@
 import { a as ColumnDefaultFunctionSchema, c as ForeignKeyReferenceSchema, d as IndexSchema, f as ReferentialActionSchema, i as CheckConstraintSchema, l as ForeignKeySchema, m as StorageValueSetSchema, o as ColumnDefaultLiteralSchema, p as StorageTableSchema, s as ColumnDefaultSchema, t as composeSqlEntityKinds, u as ForeignKeySourceSchema } from "./entity-kinds-BSGvSPI8.mjs";
-import { type } from "arktype";
 import { isPlainRecord } from "@prisma-next/framework-components/ir";
+import { type } from "arktype";
 import { CrossReferenceSchema } from "@prisma-next/contract/types";
 import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 import { validateContractDomain } from "@prisma-next/contract/validate-domain";

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.14.0-dev.31",
+  "version": "0.14.0-dev.32",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL contract types, validators, and IR factories for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.14.0-dev.31",
-    "@prisma-next/framework-components": "0.14.0-dev.31",
-    "@prisma-next/utils": "0.14.0-dev.31",
+    "@prisma-next/contract": "0.14.0-dev.32",
+    "@prisma-next/framework-components": "0.14.0-dev.32",
+    "@prisma-next/utils": "0.14.0-dev.32",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.14.0-dev.31",
-    "@prisma-next/tsconfig": "0.14.0-dev.31",
-    "@prisma-next/tsdown": "0.14.0-dev.31",
+    "@prisma-next/test-utils": "0.14.0-dev.32",
+    "@prisma-next/tsconfig": "0.14.0-dev.32",
+    "@prisma-next/tsdown": "0.14.0-dev.32",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -33,6 +33,7 @@
   ],
   "exports": {
     "./canonicalization-hooks": "./dist/canonicalization-hooks.mjs",
+    "./contract-view": "./dist/contract-view.mjs",
     "./entity-kinds": "./dist/entity-kinds.mjs",
     "./factories": "./dist/factories.mjs",
     "./index-type-validation": "./dist/index-type-validation.mjs",

package/src/contract-view.ts

@@ -0,0 +1,98 @@
+import type { Contract } from '@prisma-next/contract/types';
+import {
+  buildNamespacedEntities,
+  buildSingleNamespaceView,
+  type DefaultNamespaceEntries,
+  type NamespacedEntities,
+  type SingleNamespaceView,
+} from '@prisma-next/framework-components/ir';
+import type { SqlStorage } from './ir/sql-storage';
+
+/**
+ * The SQL family's statically-named built-in entity kinds. `table` and
+ * `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+ * (e.g. `policy`) stay under `.entries`.
+ */
+export const SQL_BUILTIN_KINDS = ['table', 'valueSet'] as const;
+export type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];
+
+type SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<
+  TContract['storage']
+>;
+
+/**
+ * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds
+ * under `entries`. A target that never emits a built-in kind (SQLite has
+ * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty
+ * map.
+ */
+export type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> =
+  SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;
+
+/**
+ * Single-namespace SQL view: the deserialized contract intersected with the
+ * by-name accessors, so the value is substitutable for `Contract` while also
+ * exposing:
+ *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole
+ *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.
+ *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole
+ *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.
+ */
+export type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract &
+  SqlSingleNamespaceAccessors<TContract> & {
+    readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+  };
+
+/**
+ * Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+ * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+ * `namespace` map, and layers both over the deserialized contract. Targets with
+ * one default namespace (SQLite) call this directly; Postgres qualifies by
+ * schema.
+ */
+export function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(
+  contract: TContract,
+): SqlSingleNamespaceView<TContract> {
+  const rootAccessors = buildSingleNamespaceView<SqlSingleNamespaceAccessors<TContract>>(
+    contract.storage,
+    SQL_BUILTIN_KINDS,
+  );
+  const namespace = buildNamespacedEntities<
+    NamespacedEntities<TContract['storage'], SqlBuiltinKind>
+  >(contract.storage, SQL_BUILTIN_KINDS);
+  return {
+    ...contract,
+    ...rootAccessors,
+    namespace,
+  };
+}
+
+/**
+ * Schema-qualified SQL view: the deserialized contract intersected with a single
+ * `view.namespace.<id>` member — every schema reached by raw id
+ * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`
+ * keying exactly (the default schema keeps its literal `__unbound__` id). There
+ * is NO root schema-name promotion, so there is no collision with contract
+ * envelope fields — `view.storage` is always the contract's `storage`. Postgres
+ * uses this; SQLite (single default namespace) uses
+ * {@link buildSqlSingleNamespaceView}.
+ */
+export type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+
+/**
+ * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+ * map over the deserialized contract. Postgres uses this.
+ */
+export function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(
+  contract: TContract,
+): SqlSchemaQualifiedView<TContract> {
+  const namespace = buildNamespacedEntities<
+    NamespacedEntities<TContract['storage'], SqlBuiltinKind>
+  >(contract.storage, SQL_BUILTIN_KINDS);
+  return {
+    ...contract,
+    namespace,
+  };
+}

package/src/exports/contract-view.ts

@@ -0,0 +1,11 @@
+export type {
+  SqlBuiltinKind,
+  SqlSchemaQualifiedView,
+  SqlSingleNamespaceAccessors,
+  SqlSingleNamespaceView,
+} from '../contract-view';
+export {
+  buildSqlSchemaQualifiedView,
+  buildSqlSingleNamespaceView,
+  SQL_BUILTIN_KINDS,
+} from '../contract-view';