@prisma-next/sql-lane-query-builder 0.8.0 → 0.9.0-dev.2

package/dist/index.d.mts

@@ -234,94 +234,516 @@ type TableAsterisk<TTableName extends string = string, THash extends StorageHash
   readonly '~table': TTableName;
 } & Brand<'[info] referencing all columns that belong to the following table reference:', `${TTableName}@${THash}`>;
 //#endregion
-//#region ../../1-core/contract/dist/types-njsiV-Ck.d.mts
-//#region src/types.d.ts
+//#region ../../../1-framework/1-core/framework-components/dist/ir.d.mts
+//#region src/ir/ir-node.d.ts
+/**
+ * Framework-level IR alphabet.
+ *
+ * The framework's contribution to Contract IR / Schema IR is a common
+ * root for the IR class hierarchy and a freeze affordance. Family
+ * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet
+ * for their family shape; targets ship the concrete classes.
+ *
+ * `kind` is an optional discriminator on the base. Families and leaves
+ * that benefit from discriminated-union dispatch declare their own
+ * literal `kind` at the level that earns it — Mongo leaves carry
+ * per-class literals (`readonly kind = 'mongo-collection' as const`)
+ * because Mongo IR has polymorphic walkers; SQL declares a single
+ * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no
+ * polymorphic dispatch today. No framework consumer dispatches on
+ * `IRNode.kind` at the BASE type — every dispatch site narrows
+ * through a union of leaves where each leaf carries a literal kind, so
+ * requiring `kind` at the base would be unearned. Future leaves that
+ * earn polymorphic dispatch override with a required literal at that
+ * leaf (e.g. `override readonly kind = 'postgres-enum' as const`).
+ *
+ * `IRNodeBase` carries no methods: the freeze-and-assign affordance
+ * lives in the free `freezeNode` helper below. Keeping `freezeNode` out
+ * of the class type means an emitted contract literal type
+ * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal
+ * like `{ nativeType, codecId, nullable }`) is structurally assignable
+ * to its class type — a `protected freeze()` instance method would
+ * otherwise leak into the public type surface and require the literal
+ * to carry it too.
+ *
+ * Subclasses construct fields then call `freezeNode(this)` to seal the
+ * instance. Frozen instances + plain readonly fields keep IR nodes
+ * JSON-clean by construction, so `JSON.stringify(node)` produces canonical
+ * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles
+ * round-trip from canonical JSON back to typed class instances.
+ *
+ * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:
+ * this base is the common root for both Contract IR and Schema IR class
+ * hierarchies, not a Schema-IR-specific alphabet.
+ */
+interface IRNode {
+  readonly kind?: string;
+}
+declare abstract class IRNodeBase implements IRNode {
+  abstract readonly kind?: string;
+}
+/**
+ * Seal an IR class instance after its constructor has assigned all
+ * fields. The free-helper form (rather than a `protected freeze()`
+ * instance method) keeps the class type structurally narrow so emitted
+ * contract literal types remain assignable to their class types.
+ *
+ * The helper name stays `freezeNode` — it operates on IR nodes
+ * regardless of root naming.
+ */
+/**
+ * Framework-level building block for a "namespace" — the database-level
+ * grouping under which storage objects (tables, collections, enums, …)
+ * reside. Each target's namespace concretion maps the framework concept to
+ * a target-native binding:
+ *
+ * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `"<schema>"`.
+ * - SQLite: the singleton `UNSPECIFIED_NAMESPACE_ID`; emitted SQL has no qualifier.
+ * - Mongo: the connection's `db` field; addressed as a database name.
+ *
+ * See `UNSPECIFIED_NAMESPACE_ID` above for the sentinel id and the
+ * singleton-subclass pattern that materialises it.
+ */
+interface Namespace extends IRNode {
+  readonly id: string;
+}
+//#endregion
+//#region src/ir/storage.d.ts
+/**
+ * Framework-level promise that every Contract IR / Schema IR carries a
+ * collection of namespaces keyed by namespace id. Family storage
+ * concretions (`SqlStorage`, `MongoStorage`) refine the shape with
+ * family-specific fields (tables, collections, enums, …); target
+ * concretions add target fields where the family vocabulary doesn't
+ * reach.
+ *
+ * Keeping `namespaces` at the framework layer enforces that every storage
+ * object — across any target — is namespace-scoped. The framework can
+ * therefore walk the namespace map without knowing the family alphabet, and
+ * the `(namespace.id, name)` keying that the verifier and planner depend on
+ * is honest at every layer.
+ *
+ * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,
+ * serializers) can dispatch on `Storage`-typed slots through the same
+ * IR-node alphabet as every other node — the structural dual already
+ * holds in code (every concrete storage class extends an IR-node base);
+ * the interface promotion makes the typing honest.
+ *
+ * **Persisted envelope shape is target-owned, not framework-promised.**
+ * Whether the `namespaces` map appears in the on-disk JSON envelope is
+ * a per-target decision made by `ContractSerializer.serializeContract`.
+ * Some targets emit a JSON-clean namespace shape that round-trips
+ * through `JSON.stringify` cleanly (SQL today via the family-layer
+ * identity serializer); others ship runtime-only fields on their
+ * namespace concretions and override `serializeContract` to strip
+ * them (Mongo). Future open (F16): extend the per-target
+ * `ContractSerializer` integration-test surface with an explicit
+ * envelope-shape assertion for each target, so the strip-vs-pass-through
+ * choice is locked at test time rather than implied by the override
+ * presence/absence. Earned by PR2's per-target namespace lift, when
+ * `PostgresSchema` / `SqliteUnspecifiedDatabase` start carrying
+ * target-specific fields.
+ */
+interface Storage extends IRNode {
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+} //#endregion
+//#region src/ir/storage-type.d.ts
+/**
+ * Framework-level alphabet for entries in a storage `types` slot.
+ *
+ * The slot is polymorphic at the framework level: a family or target can
+ * persist either a JSON-clean codec-triple object literal (carrying
+ * `kind: 'codec-instance'`) or a class-instance IR node with a narrower
+ * kind discriminator (e.g. `'postgres-enum'`). Hydration walkers,
+ * verifiers, and planners dispatch on the `kind` literal to recover the
+ * precise variant.
+ *
+ * The `kind` field is required at this layer (in contrast with
+ * `IRNode.kind` which is optional) because the slot's downstream
+ * consumers dispatch on it — without a guaranteed discriminator the
+ * polymorphic walk cannot pick the right reader. Concrete variants
+ * narrow `kind` to their literal and add their own field set;
+ * downstream consumers use `kind`-discriminator helpers to recover
+ * the precise shape.
+ */
+interface StorageType extends IRNode {
+  readonly kind: string;
+} //#endregion
+//#endregion
+//#region ../../1-core/contract/dist/types-B0lbr9cb.d.mts
+//#region src/ir/sql-node.d.ts
+/**
+ * SQL family IR node base. Carries the family-level `kind` discriminator
+ * `'sql'` and inherits the framework's `freezeNode` affordance.
+ *
+ * Single family-level discriminator (not per-leaf) reflects the fact that
+ * SQL IR has no polymorphic dispatch today — verifiers and serializers
+ * walk by structural position (`storage.tables[name].columns[name]`),
+ * not by inspecting `kind`. The abstract bar for per-leaf discriminators
+ * isn't earned until a future polymorphic consumer arrives.
+ *
+ * `kind` is installed as a non-enumerable own property on every instance,
+ * which keeps three things clean simultaneously:
+ *
+ * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+ *   shape (no `kind` field), so emitted contract.json files and the
+ *   `validateSqlContractFully` arktype schemas stay unchanged.
+ * - Test assertions that use `toEqual({...})` against the pre-lift flat
+ *   shape continue to pass — only enumerable own properties are
+ *   compared.
+ * - Direct access (`node.kind`) and runtime narrowing
+ *   (`if (node.kind === 'sql')`) still work, so future polymorphic
+ *   dispatch can begin reading `kind` without a runtime change.
+ *
+ * Future per-leaf overrides land cleanly: a class that gains a
+ * polymorphic-dispatch consumer (e.g. an enum type instance walked
+ * alongside other types) overrides `kind` with its narrower literal
+ * at that leaf level. Per-leaf overrides will use enumerable kind
+ * (matching the Mongo per-class-discriminator precedent) because they
+ * encode dispatch-relevant information that callers need to see in
+ * JSON envelopes; the family-level `'sql'` is uniform across all SQL
+ * IR and carries no dispatch-relevant information.
+ */
+declare abstract class SqlNode extends IRNodeBase {
+  readonly kind?: string;
+  constructor();
+} //#endregion
+//#region src/ir/foreign-key-references.d.ts
+interface ForeignKeyReferencesInput {
+  readonly table: string;
+  readonly columns: readonly string[];
+}
+/**
+ * SQL Contract IR node for the referenced side of a foreign key.
+ *
+ * The class is shaped around single-namespace references today; a
+ * future milestone introduces a cross-namespace coordinate on top of
+ * `(table, columns)` when namespace-keyed storage lands.
+ */
+declare class ForeignKeyReferences extends SqlNode {
+  readonly table: string;
+  readonly columns: readonly string[];
+  constructor(input: ForeignKeyReferencesInput);
+} //#endregion
+//#region src/ir/foreign-key.d.ts
+type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+interface ForeignKeyInput {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences | ForeignKeyReferencesInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
+  readonly constraint: boolean;
+  /** Whether to emit a backing index for the FK columns. */
+  readonly index: boolean;
+}
 /**
- * A column definition in storage.
+ * SQL Contract IR node for a table-level foreign-key declaration.
  *
- * `typeParams` is optional because most columns use non-parameterized types.
- * Columns with parameterized types can either inline `typeParams` or reference
- * a named {@link StorageTypeInstance} via `typeRef`.
+ * The nested `references` field is normalised to a
+ * {@link ForeignKeyReferences} instance inside the constructor so
+ * downstream walks see a uniform AST regardless of whether the input
+ * was a JSON literal or an already-constructed class instance.
  */
-type StorageColumn = {
+declare class ForeignKey extends SqlNode {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences;
+  readonly constraint: boolean;
+  readonly index: boolean;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  constructor(input: ForeignKeyInput);
+} //#endregion
+//#region src/ir/postgres-enum-storage-entry.d.ts
+/**
+ * Discriminator literal for the Postgres-enum variant on the polymorphic
+ * `SqlStorage.types` slot.
+ *
+ * Enums are a target-level concept: Postgres ships native
+ * `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via
+ * constraints. The literal lives at the SQL family layer because every
+ * SQL-family consumer (verifier, planner, lowering, …) needs to
+ * discriminate enum-typed slot entries from codec-typed ones. The
+ * concrete IR class (`PostgresEnumType`) lives in the target-postgres
+ * package and implements this structural contract; cross-domain
+ * layering rules forbid the SQL family from importing the concrete
+ * target class directly, so the discriminator and structural interface
+ * carry the dispatch.
+ */
+declare const POSTGRES_ENUM_KIND: "postgres-enum";
+/**
+ * Structural contract every Postgres-enum slot entry honours — both
+ * the live `PostgresEnumType` IR-class instance and the raw JSON
+ * envelope shape that survives `JSON.stringify` round-trips. SQL
+ * family-layer dispatch narrows polymorphic `StorageType` slot
+ * entries to this shape via `isPostgresEnumStorageEntry`.
+ *
+ * The `codecBinding` field is accessor-shaped (live class instance) on
+ * the IR class and undefined on the raw JSON envelope; consumers that
+ * need it must guard for its presence (the JSON path synthesises an
+ * equivalent shape from `codecId` + `values`).
+ */
+interface PostgresEnumStorageEntry extends StorageType {
+  readonly kind: typeof POSTGRES_ENUM_KIND;
+  readonly name: string;
   readonly nativeType: string;
-  readonly codecId: string;
-  readonly nullable: boolean;
-  /**
-   * Opaque, codec-owned JS/type parameters.
-   * The codec that owns `codecId` defines the shape and semantics.
-   * Mutually exclusive with `typeRef`.
-   */
-  readonly typeParams?: Record<string, unknown>;
-  /**
-   * Reference to a named type instance in `storage.types`.
-   * Mutually exclusive with `typeParams`.
-   */
-  readonly typeRef?: string;
+  readonly values: readonly string[];
   /**
-   * Default value for the column.
-   * Can be a literal value or database function.
+   * Enumerable own property on the persisted JSON envelope; the live
+   * IR-class instance carries it too. Family-shared dispatch sites
+   * read `codecId` directly rather than going through the IR-class
+   * `codecBinding` accessor (which lives on the prototype and isn't
+   * present on raw JSON envelopes).
    */
-  readonly default?: ColumnDefault;
-};
-type PrimaryKey = {
+  readonly codecId: string;
+}
+/**
+ * Narrow a polymorphic `StorageType` entry to the Postgres-enum shape
+ * via its enumerable `kind` discriminator. Type guard returns true for
+ * both live `PostgresEnumType` instances and raw JSON envelopes.
+ */
+//#endregion
+//#region src/ir/primary-key.d.ts
+interface PrimaryKeyInput {
   readonly columns: readonly string[];
   readonly name?: string;
-};
-type UniqueConstraint = {
+}
+/**
+ * SQL Contract IR node for a table's primary-key constraint.
+ */
+declare class PrimaryKey extends SqlNode {
   readonly columns: readonly string[];
   readonly name?: string;
-};
-type Index = {
+  constructor(input: PrimaryKeyInput);
+} //#endregion
+//#region src/ir/sql-index.d.ts
+interface IndexInput {
   readonly columns: readonly string[];
   readonly name?: string;
   readonly type?: string;
   readonly options?: Record<string, unknown>;
-};
-type ForeignKeyReferences = {
-  readonly table: string;
+}
+/**
+ * SQL Contract IR node for a table-level secondary index.
+ *
+ * Note that this class shadows the global TypeScript `Index` lib type
+ * at the family-shared name; consumer files that need both should
+ * alias one (e.g.
+ * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
+ */
+declare class Index extends SqlNode {
   readonly columns: readonly string[];
-};
-type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
-type ForeignKey = {
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  constructor(input: IndexInput);
+} //#endregion
+//#region src/ir/storage-column.d.ts
+/**
+ * Hydration / construction input shape for {@link StorageColumn}. Mirrors
+ * the on-disk storage JSON envelope exactly so the family-base
+ * serializer's hydration walker can hand an arktype-validated literal
+ * straight to `new`.
+ *
+ * `typeParams` and `typeRef` remain mutually exclusive (one or the
+ * other, not both); the constructor preserves whichever caller-side
+ * choice the input encodes.
+ */
+interface StorageColumnInput {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+}
+/**
+ * SQL Contract IR node for a single column entry in `StorageTable.columns`.
+ *
+ * Single concrete family-shared class — every SQL target reads the
+ * same column shape today, so there is no per-target subclass. The
+ * class type accepts any caller that constructs via
+ * `new StorageColumn(input)`; literal construction sites must pass
+ * through the constructor or the family-base hydration walker.
+ *
+ * The column's `name` is not on the class — columns are keyed by name
+ * in the parent `StorageTable.columns: Record<string, StorageColumn>`
+ * map, so a `name` field would be redundant with the key.
+ */
+declare class StorageColumn extends SqlNode {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+  constructor(input: StorageColumnInput);
+} //#endregion
+//#region src/ir/unique-constraint.d.ts
+interface UniqueConstraintInput {
   readonly columns: readonly string[];
-  readonly references: ForeignKeyReferences;
   readonly name?: string;
-  readonly onDelete?: ReferentialAction;
-  readonly onUpdate?: ReferentialAction; /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
-  readonly constraint: boolean; /** Whether to emit a backing index for the FK columns. */
-  readonly index: boolean;
-};
-type StorageTable = {
-  readonly columns: Record<string, StorageColumn>;
-  readonly primaryKey?: PrimaryKey;
+}
+/**
+ * SQL Contract IR node for a table-level unique constraint.
+ */
+declare class UniqueConstraint extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: UniqueConstraintInput);
+} //#endregion
+//#region src/ir/storage-table.d.ts
+interface StorageTableInput {
+  readonly columns: Record<string, StorageColumn | StorageColumnInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;
+  readonly indexes: ReadonlyArray<Index | IndexInput>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;
+}
+/**
+ * SQL Contract IR node for a single table entry in `SqlStorage.tables`.
+ *
+ * The constructor normalises nested IR-class fields (columns, primary
+ * key, uniques, indexes, foreign keys) into the appropriate class
+ * instances so downstream walks see a uniform AST regardless of whether
+ * the input was a JSON literal or an already-constructed class.
+ *
+ * The table's `name` is not on the class — tables are keyed by name in
+ * the parent `SqlStorage.tables: Record<string, StorageTable>` map.
+ * A future namespace-aware milestone will add a `namespaceId` field
+ * when namespace-keyed storage lands; today's single-namespace shape
+ * needs neither field.
+ */
+declare class StorageTable extends SqlNode {
+  readonly columns: Readonly<Record<string, StorageColumn>>;
   readonly uniques: ReadonlyArray<UniqueConstraint>;
   readonly indexes: ReadonlyArray<Index>;
   readonly foreignKeys: ReadonlyArray<ForeignKey>;
-};
+  readonly primaryKey?: PrimaryKey;
+  constructor(input: StorageTableInput);
+} //#endregion
+//#region src/ir/storage-type-instance.d.ts
 /**
- * A named, parameterized type instance.
- * These are registered in `storage.types` for reuse across columns
- * and to enable ergonomic schema surfaces like `schema.types.MyType`.
- *
- * Unlike {@link StorageColumn}, `typeParams` is required here because
- * `StorageTypeInstance` exists specifically to define reusable parameterized types.
- * A type instance without parameters would be redundant—columns can reference
- * the codec directly via `codecId`.
+ * Sentinel kind for the legacy codec-triple shape persisted under
+ * `SqlStorage.types`. Plain JSON-clean object literals carry this
+ * discriminator so the polymorphic slot dispatch can route them down
+ * the codec path while target-specific IR class instances (e.g. the
+ * Postgres enum class) keep their own narrower `kind` literal.
+ */
+declare const CODEC_INSTANCE_KIND: "codec-instance";
+/**
+ * Structural sub-interface of {@link StorageType} for codec-typed entries
+ * in `SqlStorage.types`. These are plain object literals — there is no
+ * runtime IR class, the JSON envelope round-trips through the slot
+ * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
+ * key that distinguishes codec-typed entries from class-instance entries
+ * (e.g. `PostgresEnumType`) sharing the polymorphic slot.
  */
-type StorageTypeInstance = {
+interface StorageTypeInstance extends StorageType {
+  readonly kind: typeof CODEC_INSTANCE_KIND;
   readonly codecId: string;
   readonly nativeType: string;
   readonly typeParams: Record<string, unknown>;
-};
-type SqlStorage<THash extends string = string> = StorageBase<THash> & {
-  readonly tables: Record<string, StorageTable>;
-  /**
-   * Named type instances for parameterized/custom types.
-   * Columns can reference these via `typeRef`.
-   */
-  readonly types?: Record<string, StorageTypeInstance>;
-};
+}
+/**
+ * Construction-time input for a codec-triple entry. Symmetric with the
+ * structural runtime shape minus the `kind` discriminator — callers may
+ * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.
+ */
+interface StorageTypeInstanceInput {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+/**
+ * Stamp the codec-instance `kind` discriminator on a caller-supplied
+ * codec triple. Idempotent: input that already carries the discriminator
+ * passes through unchanged.
+ */
+//#endregion
+//#region src/ir/sql-storage.d.ts
+/**
+ * Polymorphic value type for `SqlStorage.types` entries (Decision 18,
+ * Option B). The slot's framework alphabet is `StorageType` — codec
+ * triples (`StorageTypeInstance` with `kind: 'codec-instance'`) and
+ * target-specific IR class instances structurally satisfying
+ * `PostgresEnumStorageEntry` (with `kind: 'postgres-enum'`) are the
+ * two variants the SQL family ships today. The construction side also
+ * accepts {@link StorageTypeInstanceInput} so callers can pass raw
+ * codec triples; the constructor stamps the discriminator.
+ */
+type SqlStorageTypeEntry = StorageTypeInstance | PostgresEnumStorageEntry | StorageTypeInstanceInput;
+interface SqlStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Record<string, StorageTable | StorageTableInput>;
+  readonly types?: Record<string, SqlStorageTypeEntry>;
+  readonly namespaces?: Readonly<Record<string, Namespace>>;
+}
+/**
+ * SQL Contract IR root node for the `storage` field.
+ *
+ * Single concrete family-shared class — both Postgres and SQLite
+ * consume this same class today. Per-target storage subclasses are
+ * introduced when each target's namespace shape earns its
+ * target-specific concretion (target-specific derived fields,
+ * target-specific storage extensions).
+ *
+ * Honours the framework `Storage` interface: every SQL IR carries a
+ * `namespaces` map keyed by namespace id. The default singleton
+ * (`{ [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance }`)
+ * binds every contract authored before per-target namespace concretions
+ * land; per-target namespace classes (`PostgresSchema.unspecified`,
+ * `SqliteUnspecifiedDatabase.instance`) earn their slots when each
+ * target's namespace shape lands.
+ *
+ * The constructor normalises nested IR-class fields (`tables`, optional
+ * `types`) into class instances so downstream walks see a uniform AST.
+ * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
+ * are stamped with `kind: 'codec-instance'`; class-instance kinds
+ * (e.g. Postgres-enum entries satisfying `PostgresEnumStorageEntry`)
+ * pass through; hydration of raw JSON class-instance entries (carrying
+ * their narrower `kind` literal) is the per-target serializer's
+ * responsibility (so the family base does not import target-specific
+ * subclasses).
+ */
+declare class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Readonly<Record<string, StorageTable>>;
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+  readonly types?: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  constructor(input: SqlStorageInput<THash>);
+} //#endregion
+//#region src/ir/sql-unspecified-namespace.d.ts
+/**
+ * Family-layer placeholder for the SQL unspecified-namespace singleton.
+ *
+ * SQL contracts honour the framework `Storage.namespaces` invariant from
+ * the moment they appear in the IR. Today `SqlStorage` is family-shared
+ * (Postgres + SQLite consume the same class); a per-target namespace
+ * concretion (`PostgresSchema.unspecified`, `SqliteUnspecifiedDatabase.instance`)
+ * earns its existence when each target's namespace shape lands. Until
+ * then the family ships a single placeholder singleton so the JSON
+ * envelope and runtime walk are honest at every layer.
+ *
+ * The `kind` discriminator is installed as a non-enumerable own property
+ * so the JSON envelope reads `{ "id": "__unspecified__" }` — symmetric
+ * with the family-level non-enumerable `kind` on `SqlNode` and bounded
+ * to the minimum data the framework `Namespace` interface promises.
+ *
+ * **Freeze-trap warning.** The leaf constructor calls
+ * `freezeNode(this)` after installing `kind`. The leaf-class shape
+ * works today only because `NamespaceBase` does NOT freeze in its
+ * constructor — the `Object.defineProperty(this, 'kind', …)` call after
+ * `super()` succeeds because the instance is still mutable at that
+ * point. Subclasses that add instance fields will still hit the freeze
+ * trap once leaf-class `freezeNode(this)` runs; and if a future
+ * framework change lifts the freeze to `NamespaceBase`, even the
+ * `defineProperty` here would silently fail. To add subclass instance
+ * fields safely, lift `freezeNode` to a leaf-class `seal()` hook each
+ * leaf calls explicitly at the end of its own constructor.
+ */
 type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
   readonly codecTypes: infer C;
 } ? C extends Record<string, {

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["ScalarFieldType","Record","kind","codecId","typeParams","ValueObjectFieldType","name","UnionFieldType","ReadonlyArray","members","ContractFieldType","ContractField","nullable","type","many","dict","ContractRelationOn","localFields","targetFields","ContractReferenceRelation","to","cardinality","on","ContractEmbedRelation","ContractRelation","ContractDiscriminator","field","ContractVariantEntry","value","ContractValueObject","fields","ModelStorageBase","Readonly","ContractModelBase","TModelStorage","relations","storage","discriminator","variants","base","owner","ContractModel","HasModelsWithRelations","models","ReferenceRelationKeys","TContract","ModelName","K","EmbedRelationKeys","$","Brand","TKey","TValue","StorageHashBase","THash","ExecutionHashBase","executionHash","T","coreHash","ProfileHashBase","profileHash","StorageBase","storageHash","FieldType","items","properties","GeneratedValueSpec","id","params","JsonPrimitive","JsonValue","key","ColumnDefaultLiteralValue","ColumnDefaultLiteralInputValue","Date","isColumnDefaultLiteralInputValue","ColumnDefault","expression","isColumnDefault","ExecutionMutationDefaultValue","isExecutionMutationDefaultValue","ExecutionMutationDefault","ref","table","column","onCreate","onUpdate","ExecutionMutationDefaultPhases","Omit","ExecutionSection","mutations","defaults","Source","readOnly","projection","origin","capabilities","DocIndex","Expr","keys","unique","where","path","DocCollection","strategy","indexes","PlanMeta","target","targetFamily","lane","annotations","ContractMarkerRecord","contractJson","canonicalVersion","updatedAt","appTag","meta","invariants","ContractExecutionSection","Contract","TStorage","TModels","roots","valueObjects","extensionPacks","execution","A","B","C","D","E","F","G","H","I","J","L","M","N","O","P","R","S","U","V","W","_","a","b","c","d","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","ColumnDefault","StorageBase","CodecTrait","StorageColumn","Record","nativeType","codecId","nullable","typeParams","typeRef","default","PrimaryKey","columns","name","UniqueConstraint","Index","type","options","ForeignKeyReferences","table","ReferentialAction","ForeignKeyOptions","onDelete","onUpdate","ForeignKey","references","constraint","index","StorageTable","ReadonlyArray","primaryKey","uniques","indexes","foreignKeys","StorageTypeInstance","SqlStorage","THash","tables","types","SqlModelFieldStorage","column","SqlModelStorage","fields","DEFAULT_FK_CONSTRAINT","DEFAULT_FK_INDEX","applyFkDefaults","fk","overrideDefaults","TypeMaps","TCodecTypes","TQueryOperationTypes","TFieldOutputTypes","TFieldInputTypes","output","codecTypes","queryOperationTypes","fieldOutputTypes","fieldInputTypes","CodecTypesOf","T","C","QueryOperationSelfSpec","traits","QueryOperationReturn","returnType","QueryOperationTypeEntry","self","impl","args","SqlQueryOperationTypes","_CT","input","QueryOperationTypesBase","QueryOperationTypesOf","Q","TypeMapsPhantomKey","ContractWithTypeMaps","TContract","TTypeMaps","K","ExtractTypeMapsFromContract","NonNullable","FieldOutputTypesOf","F","FieldInputTypesOf","ExtractCodecTypes","ExtractQueryOperationTypes","ExtractFieldOutputTypes","ExtractFieldInputTypes","ResolveCodecTypes","A","D","E","M","N","O","P","S","_","a","b","c","d","f","g","h","i","j","k","l","m","n","o","p","r","s","t","u","v","w","x","y"],"sources":["../../../../1-framework/0-foundation/contract/dist/contract-types-Kl86EaEa.d.mts","../src/type-errors.ts","../src/column-reference.ts","../../../1-core/contract/dist/types-njsiV-Ck.d.mts","../src/table-reference.ts","../src/ref.ts","../src/type-atoms.ts","../src/selection.ts","../src/select-builder.ts","../src/root.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":["ScalarFieldType","Record","kind","codecId","typeParams","ValueObjectFieldType","name","UnionFieldType","ReadonlyArray","members","ContractFieldType","ContractField","nullable","type","many","dict","ContractRelationOn","localFields","targetFields","ContractReferenceRelation","to","cardinality","on","ContractEmbedRelation","ContractRelation","ContractDiscriminator","field","ContractVariantEntry","value","ContractValueObject","fields","ModelStorageBase","Readonly","ContractModelBase","TModelStorage","relations","storage","discriminator","variants","base","owner","ContractModel","HasModelsWithRelations","models","ReferenceRelationKeys","TContract","ModelName","K","EmbedRelationKeys","$","Brand","TKey","TValue","StorageHashBase","THash","ExecutionHashBase","executionHash","T","coreHash","ProfileHashBase","profileHash","StorageBase","storageHash","FieldType","items","properties","GeneratedValueSpec","id","params","JsonPrimitive","JsonValue","key","ColumnDefaultLiteralValue","ColumnDefaultLiteralInputValue","Date","isColumnDefaultLiteralInputValue","ColumnDefault","expression","isColumnDefault","ExecutionMutationDefaultValue","isExecutionMutationDefaultValue","ExecutionMutationDefault","ref","table","column","onCreate","onUpdate","ExecutionMutationDefaultPhases","Omit","ExecutionSection","mutations","defaults","Source","readOnly","projection","origin","capabilities","DocIndex","Expr","keys","unique","where","path","DocCollection","strategy","indexes","PlanMeta","target","targetFamily","lane","annotations","ContractMarkerRecord","contractJson","canonicalVersion","updatedAt","appTag","meta","invariants","ContractExecutionSection","Contract","TStorage","TModels","roots","valueObjects","extensionPacks","execution","A","B","C","D","E","F","G","H","I","J","L","M","N","O","P","R","S","U","V","W","_","a","b","c","d","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","IRNode","kind","IRNodeBase","freezeNode","T","node","UNSPECIFIED_NAMESPACE_ID","Namespace","id","NamespaceBase","Storage","Record","Readonly","namespaces","StorageType","IRNodeBase","Namespace","NamespaceBase","Storage","StorageType","ColumnDefault","StorageHashBase","CodecTrait","SqlNode","kind","constructor","ForeignKeyReferencesInput","table","columns","ForeignKeyReferences","input","ReferentialAction","ForeignKeyInput","references","name","onDelete","onUpdate","constraint","index","ForeignKey","POSTGRES_ENUM_KIND","PostgresEnumStorageEntry","nativeType","values","codecId","isPostgresEnumStorageEntry","value","PrimaryKeyInput","PrimaryKey","IndexInput","Record","type","options","Index","StorageColumnInput","nullable","typeParams","typeRef","default","StorageColumn","UniqueConstraintInput","UniqueConstraint","StorageTableInput","ReadonlyArray","primaryKey","uniques","indexes","foreignKeys","StorageTable","Readonly","CODEC_INSTANCE_KIND","StorageTypeInstance","StorageTypeInstanceInput","toStorageTypeInstance","isStorageTypeInstance","SqlStorageTypeEntry","SqlStorageInput","THash","storageHash","tables","types","namespaces","SqlStorage","SqlUnspecifiedNamespace","instance","id","ForeignKeyOptions","SqlModelFieldStorage","column","SqlModelStorage","fields","DEFAULT_FK_CONSTRAINT","DEFAULT_FK_INDEX","applyFkDefaults","fk","overrideDefaults","TypeMaps","TCodecTypes","TQueryOperationTypes","TFieldOutputTypes","TFieldInputTypes","output","codecTypes","queryOperationTypes","fieldOutputTypes","fieldInputTypes","CodecTypesOf","T","C","QueryOperationSelfSpec","traits","QueryOperationReturn","returnType","QueryOperationTypeEntry","self","impl","args","SqlQueryOperationTypes","_CT","QueryOperationTypesBase","QueryOperationTypesOf","Q","TypeMapsPhantomKey","ContractWithTypeMaps","TContract","TTypeMaps","K","ExtractTypeMapsFromContract","NonNullable","FieldOutputTypesOf","F","FieldInputTypesOf","ExtractCodecTypes","ExtractQueryOperationTypes","ExtractFieldOutputTypes","ExtractFieldInputTypes","ResolveCodecTypes","A","B","D","E","G","H","I","J","L","M","N","O","P","R","S","U","V","W","X","Y","Z","_","a","b","c","d","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"],"sources":["../../../../1-framework/0-foundation/contract/dist/contract-types-Kl86EaEa.d.mts","../src/type-errors.ts","../src/column-reference.ts","../../../../1-framework/1-core/framework-components/dist/ir.d.mts","../../../1-core/contract/dist/types-B0lbr9cb.d.mts","../src/table-reference.ts","../src/ref.ts","../src/type-atoms.ts","../src/selection.ts","../src/select-builder.ts","../src/root.ts"],"mappings":"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"}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["#contract","#contract"],"sources":["../src/ref.ts","../src/select-builder.ts","../src/root.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type {\n  Asterisk,\n  ColumnReference,\n  ColumnReferenceOutOfContractError,\n  TableAsterisk,\n} from './column-reference';\nimport type { TableReference, TableReferenceOutOfContractError } from './table-reference';\n\n/**\n * A fluent API representing references to tables and columns in a SQL contract.\n *\n * @template TContract The contract that describes the database.\n */\nexport type Ref<TContract extends Contract<SqlStorage>> = {\n  readonly [TableName in keyof TContract['storage']['tables'] & string]: TableReference<\n    TableName,\n    TContract['storage']['storageHash']\n  > & {\n    readonly [ColumnName in Exclude<\n      keyof TContract['storage']['tables'][TableName]['columns'],\n      keyof TableReference\n    > &\n      string]: ColumnReference<ColumnName, TableName, TContract['storage']['storageHash']>;\n  } & {\n    readonly ['*']: TableAsterisk<TableName, TContract['storage']['storageHash']>;\n  } & Record<\n      PropertyKey,\n      ColumnReferenceOutOfContractError<`[error] reference to a non-existing column in the '${TableName}' table`>\n    >;\n} & {\n  readonly ['*']: Asterisk;\n} & Record<\n    PropertyKey,\n    TableReferenceOutOfContractError<`[error] reference to a non-existing table in the contract`>\n  >;\n\n/**\n * Creates a reference object for the given SQL contract.\n *\n * @template TContract The contract that describes the database.\n */\nexport function createRef<TContract extends Contract<SqlStorage>>(\n  _contract: TContract,\n): Ref<TContract> {\n  return new Proxy({} as Ref<TContract>, {\n    get(_target, tableName) {\n      if (tableName === '*') {\n        return Object.freeze({\n          '~name': tableName,\n          '~table': null,\n        });\n      }\n\n      return new Proxy(\n        {},\n        {\n          get(_target, columnName) {\n            if (columnName === '~name') {\n              return tableName;\n            }\n\n            return Object.freeze({\n              '~name': columnName,\n              '~table': tableName,\n            });\n          },\n        },\n      );\n    },\n  });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Asterisk, TableAsterisk } from './column-reference';\nimport type { Selection, TableToSelection } from './selection';\nimport type { ExactlyOneProperty, IsNever, MergeObjects, Simplify } from './type-atoms';\nimport type { PreviousFunctionReceivedBadInputError } from './type-errors';\n\n/**\n * A builder for SQL `select` queries.\n *\n * @template TContract The contract that describes the database.\n * @template TTables The tables involved in the current `select` query.\n * @template TSelection The current selection of the `select` query.\n */\nexport class SelectBuilder<\n  TContract extends Contract<SqlStorage>,\n  TTables extends Contract<SqlStorage>['storage']['tables'],\n  TSelection extends Selection = never,\n> {\n  // @ts-expect-error\n  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: will be used soon.\n  readonly #contract: TContract;\n\n  constructor(contract: TContract) {\n    this.#contract = contract;\n  }\n\n  select(\n    asterisk: Asterisk,\n  ): ExactlyOneProperty<TTables> extends true\n    ? SelectBuilder<\n        TContract,\n        TTables,\n        MergeObjects<TSelection, TableToSelection<TContract, keyof TTables & string>>\n      >\n    : PreviousFunctionReceivedBadInputError<'[error] selecting all columns via `*` results in ambiguity when multiple tables are involved in the query'>;\n  select<TTableName extends keyof TTables & string>(\n    asterisk: TableAsterisk<TTableName, TContract['storage']['storageHash']>,\n  ): SelectBuilder<\n    TContract,\n    TTables,\n    MergeObjects<TSelection, TableToSelection<TContract, TTableName>>\n  >;\n  select(\n    arg: never,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid input in previous `select()` call'>;\n  select(..._args: unknown[]): unknown {\n    // TODO: do runtime stuff.\n    return this;\n  }\n\n  // TODO: the return type here is not the real one we'll use eventually.\n  // I'm using something to test the selection stuff.\n  build(): IsNever<TSelection> extends true\n    ? // TODO: either split to two builders or provide a type-level error here.\n      never\n    : Simplify<TSelection> {\n    // TODO: do runtime stuff.\n    return {} as never;\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SelectBuilder } from './select-builder';\nimport type { TableReference, TableReferenceTooWideError } from './table-reference';\nimport type { PreviousFunctionReceivedBadInputError } from './type-errors';\n\n/**\n * The root of all builder.\n *\n * @template TContract The contract that describes the database.\n */\nexport class Root<TContract extends Contract<SqlStorage>> {\n  readonly #contract: TContract;\n\n  constructor(contract: TContract) {\n    this.#contract = contract;\n  }\n\n  /**\n   * SQL's `from` clause, where all `select` queries actually start from.\n   *\n   * @param table The table to select from.\n   */\n  from(\n    table: TableReference<never>,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  /**\n   * @template TName The name of the table to select from.\n   */\n  from<TName extends string>(\n    table: string extends TName\n      ? TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>\n      : TableReference<TName, TContract['storage']['storageHash']>,\n  ): TName extends string\n    ? SelectBuilder<TContract, Pick<TContract['storage']['tables'], TName>>\n    : PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  from(\n    table: TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  /**\n   * @internal\n   */\n  from(_table: unknown): unknown {\n    // TODO: use runtime table reference value to do something \"AST\"-related.\n    return new SelectBuilder(this.#contract);\n  }\n}\n\n/**\n * Creates a new `Root` instance.\n */\nexport function createRoot(\n  contract: never,\n): PreviousFunctionReceivedBadInputError<'[error] root creation will likely fail at runtime given the passed contract is not valid or verified'>;\n/**\n * @template TContract The contract that describes the database.\n */\nexport function createRoot<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): Root<TContract>;\n/**\n * @internal\n */\nexport function createRoot(contract: unknown): unknown {\n  return new Root(contract as Contract<SqlStorage>);\n}\n"],"mappings":";;;;;;AA2CA,SAAgB,UACd,WACgB;CAChB,OAAO,IAAI,MAAM,EAAE,EAAoB,EACrC,IAAI,SAAS,WAAW;EACtB,IAAI,cAAc,KAChB,OAAO,OAAO,OAAO;GACnB,SAAS;GACT,UAAU;GACX,CAAC;EAGJ,OAAO,IAAI,MACT,EAAE,EACF,EACE,IAAI,SAAS,YAAY;GACvB,IAAI,eAAe,SACjB,OAAO;GAGT,OAAO,OAAO,OAAO;IACnB,SAAS;IACT,UAAU;IACX,CAAC;KAEL,CACF;IAEJ,CAAC;;;;;;;;;;;ACzDJ,IAAa,gBAAb,MAIE;CAGA;CAEA,YAAY,UAAqB;EAC/B,KAAKA,YAAY;;CAsBnB,OAAO,GAAG,OAA2B;EAEnC,OAAO;;CAKT,QAGyB;EAEvB,OAAO,EAAE;;;;;;;;;;AC/Cb,IAAa,OAAb,MAA0D;CACxD;CAEA,YAAY,UAAqB;EAC/B,KAAKC,YAAY;;;;;CA2BnB,KAAK,QAA0B;EAE7B,OAAO,IAAI,cAAc,KAAKA,UAAU;;;;;;AAmB5C,SAAgB,WAAW,UAA4B;CACrD,OAAO,IAAI,KAAK,SAAiC"}
+{"version":3,"file":"index.mjs","names":["#contract","#contract"],"sources":["../src/ref.ts","../src/select-builder.ts","../src/root.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type {\n  Asterisk,\n  ColumnReference,\n  ColumnReferenceOutOfContractError,\n  TableAsterisk,\n} from './column-reference';\nimport type { TableReference, TableReferenceOutOfContractError } from './table-reference';\n\n/**\n * A fluent API representing references to tables and columns in a SQL contract.\n *\n * @template TContract The contract that describes the database.\n */\nexport type Ref<TContract extends Contract<SqlStorage>> = {\n  readonly [TableName in keyof TContract['storage']['tables'] & string]: TableReference<\n    TableName,\n    TContract['storage']['storageHash']\n  > & {\n    readonly [ColumnName in Exclude<\n      keyof TContract['storage']['tables'][TableName]['columns'],\n      keyof TableReference\n    > &\n      string]: ColumnReference<ColumnName, TableName, TContract['storage']['storageHash']>;\n  } & {\n    readonly ['*']: TableAsterisk<TableName, TContract['storage']['storageHash']>;\n  } & Record<\n      PropertyKey,\n      ColumnReferenceOutOfContractError<`[error] reference to a non-existing column in the '${TableName}' table`>\n    >;\n} & {\n  readonly ['*']: Asterisk;\n} & Record<\n    PropertyKey,\n    TableReferenceOutOfContractError<`[error] reference to a non-existing table in the contract`>\n  >;\n\n/**\n * Creates a reference object for the given SQL contract.\n *\n * @template TContract The contract that describes the database.\n */\nexport function createRef<TContract extends Contract<SqlStorage>>(\n  _contract: TContract,\n): Ref<TContract> {\n  return new Proxy({} as Ref<TContract>, {\n    get(_target, tableName) {\n      if (tableName === '*') {\n        return Object.freeze({\n          '~name': tableName,\n          '~table': null,\n        });\n      }\n\n      return new Proxy(\n        {},\n        {\n          get(_target, columnName) {\n            if (columnName === '~name') {\n              return tableName;\n            }\n\n            return Object.freeze({\n              '~name': columnName,\n              '~table': tableName,\n            });\n          },\n        },\n      );\n    },\n  });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Asterisk, TableAsterisk } from './column-reference';\nimport type { Selection, TableToSelection } from './selection';\nimport type { ExactlyOneProperty, IsNever, MergeObjects, Simplify } from './type-atoms';\nimport type { PreviousFunctionReceivedBadInputError } from './type-errors';\n\n/**\n * A builder for SQL `select` queries.\n *\n * @template TContract The contract that describes the database.\n * @template TTables The tables involved in the current `select` query.\n * @template TSelection The current selection of the `select` query.\n */\nexport class SelectBuilder<\n  TContract extends Contract<SqlStorage>,\n  TTables extends Contract<SqlStorage>['storage']['tables'],\n  TSelection extends Selection = never,\n> {\n  // @ts-expect-error\n  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: will be used soon.\n  readonly #contract: TContract;\n\n  constructor(contract: TContract) {\n    this.#contract = contract;\n  }\n\n  select(\n    asterisk: Asterisk,\n  ): ExactlyOneProperty<TTables> extends true\n    ? SelectBuilder<\n        TContract,\n        TTables,\n        MergeObjects<TSelection, TableToSelection<TContract, keyof TTables & string>>\n      >\n    : PreviousFunctionReceivedBadInputError<'[error] selecting all columns via `*` results in ambiguity when multiple tables are involved in the query'>;\n  select<TTableName extends keyof TTables & string>(\n    asterisk: TableAsterisk<TTableName, TContract['storage']['storageHash']>,\n  ): SelectBuilder<\n    TContract,\n    TTables,\n    MergeObjects<TSelection, TableToSelection<TContract, TTableName>>\n  >;\n  select(\n    arg: never,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid input in previous `select()` call'>;\n  select(..._args: unknown[]): unknown {\n    // TODO: do runtime stuff.\n    return this;\n  }\n\n  // TODO: the return type here is not the real one we'll use eventually.\n  // I'm using something to test the selection stuff.\n  build(): IsNever<TSelection> extends true\n    ? // TODO: either split to two builders or provide a type-level error here.\n      never\n    : Simplify<TSelection> {\n    // TODO: do runtime stuff.\n    return {} as never;\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SelectBuilder } from './select-builder';\nimport type { TableReference, TableReferenceTooWideError } from './table-reference';\nimport type { PreviousFunctionReceivedBadInputError } from './type-errors';\n\n/**\n * The root of all builder.\n *\n * @template TContract The contract that describes the database.\n */\nexport class Root<TContract extends Contract<SqlStorage>> {\n  readonly #contract: TContract;\n\n  constructor(contract: TContract) {\n    this.#contract = contract;\n  }\n\n  /**\n   * SQL's `from` clause, where all `select` queries actually start from.\n   *\n   * @param table The table to select from.\n   */\n  from(\n    table: TableReference<never>,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  /**\n   * @template TName The name of the table to select from.\n   */\n  from<TName extends string>(\n    table: string extends TName\n      ? TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>\n      : TableReference<TName, TContract['storage']['storageHash']>,\n  ): TName extends string\n    ? SelectBuilder<TContract, Pick<TContract['storage']['tables'], TName>>\n    : PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  from(\n    table: TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>,\n  ): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;\n  /**\n   * @internal\n   */\n  from(_table: unknown): unknown {\n    // TODO: use runtime table reference value to do something \"AST\"-related.\n    return new SelectBuilder(this.#contract);\n  }\n}\n\n/**\n * Creates a new `Root` instance.\n */\nexport function createRoot(\n  contract: never,\n): PreviousFunctionReceivedBadInputError<'[error] root creation will likely fail at runtime given the passed contract is not valid or verified'>;\n/**\n * @template TContract The contract that describes the database.\n */\nexport function createRoot<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): Root<TContract>;\n/**\n * @internal\n */\nexport function createRoot(contract: unknown): unknown {\n  // Blind cast: the public overloads above (`createRoot(TContract)`)\n  // statically constrain `contract` to `Contract<SqlStorage>` —\n  // this internal `unknown` overload exists only to give the\n  // implementation a single body. Any caller that reaches the\n  // `unknown` form has already been narrowed by the matching\n  // overload at compile time.\n  return new Root(contract as unknown as Contract<SqlStorage>);\n}\n"],"mappings":";;;;;;AA2CA,SAAgB,UACd,WACgB;CAChB,OAAO,IAAI,MAAM,EAAE,EAAoB,EACrC,IAAI,SAAS,WAAW;EACtB,IAAI,cAAc,KAChB,OAAO,OAAO,OAAO;GACnB,SAAS;GACT,UAAU;GACX,CAAC;EAGJ,OAAO,IAAI,MACT,EAAE,EACF,EACE,IAAI,SAAS,YAAY;GACvB,IAAI,eAAe,SACjB,OAAO;GAGT,OAAO,OAAO,OAAO;IACnB,SAAS;IACT,UAAU;IACX,CAAC;KAEL,CACF;IAEJ,CAAC;;;;;;;;;;;ACzDJ,IAAa,gBAAb,MAIE;CAGA;CAEA,YAAY,UAAqB;EAC/B,KAAKA,YAAY;;CAsBnB,OAAO,GAAG,OAA2B;EAEnC,OAAO;;CAKT,QAGyB;EAEvB,OAAO,EAAE;;;;;;;;;;AC/Cb,IAAa,OAAb,MAA0D;CACxD;CAEA,YAAY,UAAqB;EAC/B,KAAKC,YAAY;;;;;CA2BnB,KAAK,QAA0B;EAE7B,OAAO,IAAI,cAAc,KAAKA,UAAU;;;;;;AAmB5C,SAAgB,WAAW,UAA4B;CAOrD,OAAO,IAAI,KAAK,SAA4C"}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@prisma-next/sql-lane-query-builder",
-  "version": "0.8.0",
+  "version": "0.9.0-dev.2",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL query builder lane for Prisma Next",
   "devDependencies": {
-    "@prisma-next/contract": "0.8.0",
-    "@prisma-next/sql-contract": "0.8.0",
-    "@prisma-next/tsconfig": "0.8.0",
-    "@prisma-next/tsdown": "0.8.0",
+    "@prisma-next/contract": "0.9.0-dev.2",
+    "@prisma-next/sql-contract": "0.9.0-dev.2",
+    "@prisma-next/tsconfig": "0.9.0-dev.2",
+    "@prisma-next/tsdown": "0.9.0-dev.2",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5"
@@ -25,8 +25,6 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "repository": {
     "type": "git",

package/src/root.ts

@@ -62,5 +62,11 @@ export function createRoot<TContract extends Contract<SqlStorage>>(
  * @internal
  */
 export function createRoot(contract: unknown): unknown {
-  return new Root(contract as Contract<SqlStorage>);
+  // Blind cast: the public overloads above (`createRoot(TContract)`)
+  // statically constrain `contract` to `Contract<SqlStorage>` —
+  // this internal `unknown` overload exists only to give the
+  // implementation a single body. Any caller that reaches the
+  // `unknown` form has already been narrowed by the matching
+  // overload at compile time.
+  return new Root(contract as unknown as Contract<SqlStorage>);
 }