@prisma-next/sql-relational-core 0.0.1

package/README.md

@@ -0,0 +1,123 @@
+# @prisma-next/sql-relational-core
+
+Schema and column builders, operation attachment, and AST types for Prisma Next.
+
+## Package Classification
+
+- **Domain**: sql
+- **Layer**: lanes
+- **Plane**: runtime
+
+## Overview
+
+The relational core package provides the foundational primitives for building relational SQL queries. It includes table/column builders, parameter helpers, operation attachment logic, and type definitions that are shared across SQL query lanes (DSL, ORM, Raw).
+
+This package is part of the SQL lanes layer and provides the relational primitives that both the SQL DSL and ORM builder depend on.
+
+## Purpose
+
+Provide shared relational primitives (schema builders, column builders, parameter helpers, operations registry) that can be consumed by multiple SQL query lanes without code duplication.
+
+## Responsibilities
+
+- **Schema Builder**: Creates typed table and column builders from contracts
+- **Column Builders**: Provides column accessors with operation methods attached based on column typeId
+- **Parameter Helpers**: Creates parameter placeholders for query building
+- **Operations Registry**: Attaches registered operations as methods on column builders
+- **Type Definitions**: Defines TypeScript types for column builders, operations, and projections
+
+**Non-goals:**
+- Query DSL construction (sql-lane)
+- ORM lowering (orm-lane)
+- Raw SQL handling (sql-lane)
+- Execution or runtime behavior (runtime)
+
+## Architecture
+
+```mermaid
+flowchart TD
+    subgraph "Relational Core"
+        SCHEMA[Schema Builder]
+        COL[Column Builders]
+        PARAM[Parameter Helpers]
+        OPS[Operations Registry]
+        TYPES[Type Definitions]
+    end
+
+    subgraph "Consumers"
+        SQL[SQL Lane]
+        ORM[ORM Lane]
+    end
+
+    SCHEMA --> SQL
+    SCHEMA --> ORM
+    COL --> SQL
+    COL --> ORM
+    PARAM --> SQL
+    PARAM --> ORM
+    OPS --> SQL
+    OPS --> ORM
+    TYPES --> SQL
+    TYPES --> ORM
+```
+
+## Components
+
+### Schema Builder (`schema.ts`)
+- Creates a schema handle with typed table builders
+- Builds column builders with operation methods attached
+- Provides proxy access for convenience (e.g., `tables.user.id` in addition to `tables.user.columns.id`)
+
+### Column Builders (`types.ts`)
+- Defines `ColumnBuilder` type with operation methods based on column typeId
+- Provides type inference for JavaScript types from codec types
+- Supports operation chaining when operations return typeIds
+
+### Parameter Helpers (`param.ts`)
+- Creates parameter placeholders for query building
+- Validates parameter names
+
+### Operations Registry (`operations-registry.ts`)
+- Attaches registered operations as methods on `ColumnBuilder` instances
+- Dynamically exposes operations based on column `typeId` and contract capabilities
+- Handles operation chaining when operations return typeIds
+
+### Type Definitions (`types.ts`)
+- Defines TypeScript types for column builders, operations, projections
+- Provides type inference utilities for extracting JavaScript types from codec types (e.g., `ExtractJsTypeFromColumnBuilder`)
+- Defines projection row inference types
+- Defines `AnyColumnBuilder` helper type for accepting column builders with any operation types
+
+## Dependencies
+
+- **`@prisma-next/contract`**: Core contract types
+- **`@prisma-next/plan`**: Plan error helpers (`planInvalid`, `planUnsupported`) and `RuntimeError` type
+- **`@prisma-next/runtime`**: Runtime context types (TODO: Slice 6 will clean this up)
+- **`@prisma-next/sql-target`**: SQL contract types, adapter interfaces
+
+**Note**: This package does not depend on specific adapters (e.g., `@prisma-next/adapter-postgres`). Test fixtures define `CodecTypes` inline to remain adapter-agnostic and avoid cyclic dependencies.
+
+**Note**: Error helpers (`planInvalid`, `planUnsupported`) and the `RuntimeError` type are imported from `@prisma-next/plan` (core ring) rather than being defined locally. This ensures target-agnostic error handling.
+
+## Package Structure
+
+This package follows the standard `exports/` directory pattern:
+
+- `src/exports/schema.ts` - Re-exports schema builder
+- `src/exports/param.ts` - Re-exports parameter helpers
+- `src/exports/types.ts` - Re-exports type definitions
+- `src/exports/operations-registry.ts` - Re-exports operations registry
+- `src/exports/errors.ts` - Re-exports error helpers (from `@prisma-next/plan`)
+- `src/index.ts` - Main entry point that re-exports from `exports/`
+
+This enables subpath imports like `@prisma-next/sql-relational-core/schema`, `@prisma-next/sql-relational-core/param`, etc.
+
+## Related Subsystems
+
+- **[Query Lanes](../../../../docs/architecture%20docs/subsystems/3.%20Query%20Lanes.md)**: Detailed subsystem specification
+- **[Runtime & Plugin Framework](../../../../docs/architecture%20docs/subsystems/4.%20Runtime%20&%20Plugin%20Framework.md)**: Plan execution
+
+## Related ADRs
+
+- [ADR 140 - Package Layering & Target-Family Namespacing](../../../../docs/architecture%20docs/adrs/ADR%20140%20-%20Package%20Layering%20&%20Target-Family%20Namespacing.md)
+- [ADR 005 - Thin Core, Fat Targets](../../../../docs/architecture%20docs/adrs/ADR%20005%20-%20Thin%20Core,%20Fat%20Targets.md)

package/dist/chunk-2F7DSEOU.js

@@ -0,0 +1,8 @@
+// src/errors.ts
+import { planInvalid, planUnsupported } from "@prisma-next/plan";
+
+export {
+  planInvalid,
+  planUnsupported
+};
+//# sourceMappingURL=chunk-2F7DSEOU.js.map

package/dist/chunk-2F7DSEOU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["export { planInvalid, planUnsupported } from '@prisma-next/plan';\n"],"mappings":";AAAA,SAAS,aAAa,uBAAuB;","names":[]}

package/dist/chunk-7FMQVMSM.js

@@ -0,0 +1,128 @@
+import {
+  attachOperationsToColumnBuilder
+} from "./chunk-FMVAOBWJ.js";
+
+// src/schema.ts
+import { planInvalid } from "@prisma-next/plan";
+var ColumnBuilderImpl = class {
+  constructor(table, column, storageColumn) {
+    this.table = table;
+    this.column = column;
+    this.storageColumn = storageColumn;
+  }
+  kind = "column";
+  get columnMeta() {
+    return this.storageColumn;
+  }
+  // Type-level helper property (not used at runtime)
+  get __jsType() {
+    return void 0;
+  }
+  eq(value) {
+    if (value.kind !== "param-placeholder") {
+      throw planInvalid("Parameter placeholder required for column comparison");
+    }
+    return Object.freeze({
+      kind: "binary",
+      op: "eq",
+      left: this,
+      right: value
+    });
+  }
+  asc() {
+    return Object.freeze({
+      kind: "order",
+      expr: this,
+      dir: "asc"
+    });
+  }
+  desc() {
+    return Object.freeze({
+      kind: "order",
+      expr: this,
+      dir: "desc"
+    });
+  }
+};
+var TableBuilderImpl = class {
+  kind = "table";
+  columns;
+  _name;
+  constructor(name, columns) {
+    this._name = name;
+    this.columns = columns;
+  }
+  get name() {
+    return this._name;
+  }
+};
+function buildColumns(tableName, storage, _contract, operationRegistry, contractCapabilities) {
+  const table = storage.tables[tableName];
+  if (!table) {
+    throw planInvalid(`Unknown table ${tableName}`);
+  }
+  const tableColumns = table.columns;
+  const result = {};
+  const assignColumn = (columnName, columnDef) => {
+    const columnBuilder = new ColumnBuilderImpl(
+      tableName,
+      columnName,
+      columnDef
+    );
+    const builderWithOps = attachOperationsToColumnBuilder(
+      columnBuilder,
+      columnDef,
+      operationRegistry,
+      contractCapabilities
+    );
+    result[columnName] = builderWithOps;
+  };
+  for (const columnName of Object.keys(tableColumns)) {
+    const columnDef = tableColumns[columnName];
+    if (!columnDef) continue;
+    assignColumn(columnName, columnDef);
+  }
+  return result;
+}
+function createTableProxy(table) {
+  return new Proxy(table, {
+    get(target, prop) {
+      if (prop === "name" || prop === "kind" || prop === "columns") {
+        return Reflect.get(target, prop);
+      }
+      if (typeof prop === "string" && prop in target.columns) {
+        return target.columns[prop];
+      }
+      return void 0;
+    }
+  });
+}
+function schema(context) {
+  const contract = context.contract;
+  const storage = contract.storage;
+  const tables = {};
+  const contractCapabilities = contract.capabilities;
+  const operationRegistry = context.operations;
+  for (const tableName of Object.keys(storage.tables)) {
+    const columns = buildColumns(
+      tableName,
+      storage,
+      contract,
+      operationRegistry,
+      contractCapabilities
+    );
+    const table = new TableBuilderImpl(tableName, columns);
+    const proxiedTable = createTableProxy(table);
+    tables[tableName] = Object.freeze(
+      proxiedTable
+    );
+  }
+  return Object.freeze({ tables });
+}
+
+export {
+  ColumnBuilderImpl,
+  TableBuilderImpl,
+  schema
+};
+//# sourceMappingURL=chunk-7FMQVMSM.js.map

package/dist/chunk-7FMQVMSM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type {\n  ExtractCodecTypes,\n  ExtractOperationTypes,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n} from '@prisma-next/sql-contract/types';\nimport type { TableRef } from './ast/types';\nimport { attachOperationsToColumnBuilder } from './operations-registry';\nimport type { QueryLaneContext } from './query-lane-context';\nimport type {\n  BinaryBuilder,\n  CodecTypes as CodecTypesType,\n  ColumnBuilder,\n  ComputeColumnJsType,\n  OperationTypeSignature,\n  OperationTypes,\n  OrderBuilder,\n  ParamPlaceholder,\n} from './types';\n\ntype TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];\n\ntype ColumnBuilders<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [K in keyof Columns]: ColumnBuilder<\n    K & string,\n    Columns[K],\n    ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n    Operations\n  >;\n};\n\nexport class ColumnBuilderImpl<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n> {\n  readonly kind = 'column' as const;\n\n  constructor(\n    readonly table: string,\n    readonly column: ColumnName,\n    private readonly storageColumn: ColumnMeta,\n  ) {}\n\n  get columnMeta(): ColumnMeta {\n    return this.storageColumn;\n  }\n\n  // Type-level helper property (not used at runtime)\n  get __jsType(): JsType {\n    return undefined as unknown as JsType;\n  }\n\n  eq(\n    this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>,\n    value: ParamPlaceholder,\n  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    if (value.kind !== 'param-placeholder') {\n      throw planInvalid('Parameter placeholder required for column comparison');\n    }\n\n    return Object.freeze({\n      kind: 'binary' as const,\n      op: 'eq' as const,\n      left: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,\n      right: value,\n    }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n\n  asc(\n    this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>,\n  ): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,\n      dir: 'asc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n\n  desc(\n    this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>,\n  ): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,\n      dir: 'desc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n}\n\nexport class TableBuilderImpl<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> implements TableRef\n{\n  readonly kind = 'table' as const;\n  readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n  private readonly _name: TableName;\n\n  constructor(\n    name: TableName,\n    columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>,\n  ) {\n    this._name = name;\n    this.columns = columns;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n}\n\nfunction buildColumns<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends keyof Contract['storage']['tables'] & string,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  tableName: TableName,\n  storage: SqlStorage,\n  _contract: Contract,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilders<\n  Contract,\n  TableName,\n  Contract['storage']['tables'][TableName]['columns'],\n  CodecTypes,\n  Operations\n> {\n  const table = storage.tables[tableName];\n\n  if (!table) {\n    throw planInvalid(`Unknown table ${tableName}`);\n  }\n\n  type Columns = Contract['storage']['tables'][TableName]['columns'];\n  const tableColumns = table.columns as Columns;\n\n  const result = {} as {\n    [K in keyof Columns]: ColumnBuilder<\n      K & string,\n      Columns[K],\n      ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n      Operations\n    >;\n  };\n\n  const assignColumn = <ColumnKey extends keyof Columns & string>(\n    columnName: ColumnKey,\n    columnDef: Columns[ColumnKey],\n  ) => {\n    type JsType = ComputeColumnJsType<\n      Contract,\n      TableName,\n      ColumnKey,\n      Columns[ColumnKey],\n      CodecTypes\n    >;\n\n    const columnBuilder = new ColumnBuilderImpl<ColumnKey, Columns[ColumnKey], JsType>(\n      tableName,\n      columnName,\n      columnDef,\n    );\n\n    const builderWithOps = attachOperationsToColumnBuilder<\n      ColumnKey,\n      Columns[ColumnKey],\n      JsType,\n      Operations\n    >(\n      columnBuilder as unknown as ColumnBuilder<\n        ColumnKey,\n        Columns[ColumnKey],\n        JsType,\n        Record<string, never>\n      >,\n      columnDef,\n      operationRegistry,\n      contractCapabilities,\n    );\n\n    (result as Record<string, unknown>)[columnName] = builderWithOps;\n  };\n\n  for (const columnName of Object.keys(tableColumns) as Array<keyof Columns & string>) {\n    const columnDef = tableColumns[columnName];\n    if (!columnDef) continue;\n    assignColumn(columnName, columnDef);\n  }\n\n  return result as ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n}\n\n/**\n * Creates a Proxy that enables accessing table columns directly on the table object,\n * in addition to the standard `table.columns.columnName` syntax.\n *\n * This allows both access patterns:\n * - `tables.user.columns.id` (standard access)\n * - `tables.user.id` (convenience access via proxy)\n *\n * The proxy intercepts property access and routes column name lookups to\n * `table.columns[prop]`, while preserving direct access to table properties\n * like `name`, `kind`, and `columns`.\n */\nfunction createTableProxy<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  table: TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations>,\n): TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations> {\n  return new Proxy(table, {\n    get(target, prop) {\n      if (prop === 'name' || prop === 'kind' || prop === 'columns') {\n        return Reflect.get(target, prop);\n      }\n      if (typeof prop === 'string' && prop in target.columns) {\n        return target.columns[prop as keyof typeof target.columns];\n      }\n      return undefined;\n    },\n  });\n}\n\ntype ExtractSchemaTables<\n  Contract extends SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<\n    Contract,\n    TableName & string,\n    TableColumns<Contract['storage']['tables'][TableName]>,\n    CodecTypes,\n    Operations\n  > &\n    TableRef;\n};\n\nexport type SchemaHandle<\n  Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType = CodecTypesType,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;\n};\n\ntype SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<\n  Contract,\n  ExtractCodecTypes<Contract>,\n  ToOperationTypes<ExtractOperationTypes<Contract>>\n>;\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\n/**\n * Creates a schema handle for building SQL queries.\n *\n * @param context - Query lane context containing contract, codec and operation registries\n * @returns A schema handle with typed table builders\n *\n * @example\n * ```typescript\n * const schemaHandle = schema<Contract>(context);\n * const userTable = schemaHandle.tables.user;\n * ```\n */\nexport function schema<Contract extends SqlContract<SqlStorage>>(\n  context: QueryLaneContext<Contract>,\n): SchemaReturnType<Contract> {\n  const contract = context.contract;\n  const storage = contract.storage;\n  type CodecTypes = ExtractCodecTypes<Contract>;\n  type Operations = ToOperationTypes<ExtractOperationTypes<Contract>>;\n  const tables = {} as ExtractSchemaTables<Contract, CodecTypes, Operations>;\n  const contractCapabilities = contract.capabilities;\n\n  const operationRegistry = context.operations;\n\n  for (const tableName of Object.keys(storage.tables) as Array<\n    keyof Contract['storage']['tables'] & string\n  >) {\n    const columns = buildColumns<Contract, typeof tableName, CodecTypes, Operations>(\n      tableName,\n      storage,\n      contract,\n      operationRegistry,\n      contractCapabilities,\n    );\n    const table = new TableBuilderImpl<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(tableName, columns);\n    const proxiedTable = createTableProxy<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(table);\n    (tables as Record<string, unknown>)[tableName] = Object.freeze(\n      proxiedTable,\n    ) as ExtractSchemaTables<Contract, CodecTypes, Operations>[typeof tableName];\n  }\n\n  return Object.freeze({ tables }) as SchemaReturnType<Contract>;\n}\n\nexport type { ColumnBuilderImpl as Column, TableBuilderImpl as Table };\n"],"mappings":";;;;;AACA,SAAS,mBAAmB;AAuCrB,IAAM,oBAAN,MAIL;AAAA,EAGA,YACW,OACA,QACQ,eACjB;AAHS;AACA;AACQ;AAAA,EAChB;AAAA,EANM,OAAO;AAAA,EAQhB,IAAI,aAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,WAAmB;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,GAEE,OAC+C;AAC/C,QAAI,MAAM,SAAS,qBAAqB;AACtC,YAAM,YAAY,sDAAsD;AAAA,IAC1E;AAEA,WAAO,OAAO,OAAO;AAAA,MACnB,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,MAEgD;AAC9C,WAAO,OAAO,OAAO;AAAA,MACnB,MAAM;AAAA,MACN,MAAM;AAAA,MACN,KAAK;AAAA,IACP,CAAC;AAAA,EACH;AAAA,EAEA,OAEgD;AAC9C,WAAO,OAAO,OAAO;AAAA,MACnB,MAAM;AAAA,MACN,MAAM;AAAA,MACN,KAAK;AAAA,IACP,CAAC;AAAA,EACH;AACF;AAEO,IAAM,mBAAN,MAOP;AAAA,EACW,OAAO;AAAA,EACP;AAAA,EACQ;AAAA,EAEjB,YACE,MACA,SACA;AACA,SAAK,QAAQ;AACb,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AACF;AAEA,SAAS,aAMP,WACA,SACA,WACA,mBACA,sBAOA;AACA,QAAM,QAAQ,QAAQ,OAAO,SAAS;AAEtC,MAAI,CAAC,OAAO;AACV,UAAM,YAAY,iBAAiB,SAAS,EAAE;AAAA,EAChD;AAGA,QAAM,eAAe,MAAM;AAE3B,QAAM,SAAS,CAAC;AAShB,QAAM,eAAe,CACnB,YACA,cACG;AASH,UAAM,gBAAgB,IAAI;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,UAAM,iBAAiB;AAAA,MAMrB;AAAA,MAMA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,IAAC,OAAmC,UAAU,IAAI;AAAA,EACpD;AAEA,aAAW,cAAc,OAAO,KAAK,YAAY,GAAoC;AACnF,UAAM,YAAY,aAAa,UAAU;AACzC,QAAI,CAAC,UAAW;AAChB,iBAAa,YAAY,SAAS;AAAA,EACpC;AAEA,SAAO;AACT;AAcA,SAAS,iBAOP,OACwE;AACxE,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,MAAM;AAChB,UAAI,SAAS,UAAU,SAAS,UAAU,SAAS,WAAW;AAC5D,eAAO,QAAQ,IAAI,QAAQ,IAAI;AAAA,MACjC;AACA,UAAI,OAAO,SAAS,YAAY,QAAQ,OAAO,SAAS;AACtD,eAAO,OAAO,QAAQ,IAAmC;AAAA,MAC3D;AACA,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;AAqDO,SAAS,OACd,SAC4B;AAC5B,QAAM,WAAW,QAAQ;AACzB,QAAM,UAAU,SAAS;AAGzB,QAAM,SAAS,CAAC;AAChB,QAAM,uBAAuB,SAAS;AAEtC,QAAM,oBAAoB,QAAQ;AAElC,aAAW,aAAa,OAAO,KAAK,QAAQ,MAAM,GAE/C;AACD,UAAM,UAAU;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,UAAM,QAAQ,IAAI,iBAMhB,WAAW,OAAO;AACpB,UAAM,eAAe,iBAMnB,KAAK;AACP,IAAC,OAAmC,SAAS,IAAI,OAAO;AAAA,MACtD;AAAA,IACF;AAAA,EACF;AAEA,SAAO,OAAO,OAAO,EAAE,OAAO,CAAC;AACjC;","names":[]}

package/dist/chunk-7I3EMQID.js

@@ -0,0 +1,16 @@
+// src/param.ts
+import { planInvalid } from "@prisma-next/plan";
+function param(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw planInvalid("Parameter name must be a non-empty string");
+  }
+  return Object.freeze({
+    kind: "param-placeholder",
+    name
+  });
+}
+
+export {
+  param
+};
+//# sourceMappingURL=chunk-7I3EMQID.js.map

package/dist/chunk-7I3EMQID.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/param.ts"],"sourcesContent":["import { planInvalid } from '@prisma-next/plan';\nimport type { ParamPlaceholder } from './types';\n\nexport type Parameter = ParamPlaceholder;\n\nexport function param(name: string): Parameter {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw planInvalid('Parameter name must be a non-empty string');\n  }\n\n  return Object.freeze({\n    kind: 'param-placeholder' as const,\n    name,\n  }) satisfies Parameter;\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;AAKrB,SAAS,MAAM,MAAyB;AAC7C,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG;AACjD,UAAM,YAAY,2CAA2C;AAAA,EAC/D;AAEA,SAAO,OAAO,OAAO;AAAA,IACnB,MAAM;AAAA,IACN;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-ENOLRQZS.js

@@ -0,0 +1,320 @@
+import {
+  isColumnBuilder
+} from "./chunk-ILC64YWE.js";
+
+// src/ast/codec-types.ts
+var CodecRegistryImpl = class {
+  _byId = /* @__PURE__ */ new Map();
+  _byScalar = /* @__PURE__ */ new Map();
+  /**
+   * Map-like interface for codec lookup by ID.
+   * Example: registry.get('pg/text@1')
+   */
+  get(id) {
+    return this._byId.get(id);
+  }
+  /**
+   * Check if a codec with the given ID is registered.
+   */
+  has(id) {
+    return this._byId.has(id);
+  }
+  /**
+   * Get all codecs that handle a given scalar type.
+   * Returns an empty frozen array if no codecs are found.
+   * Example: registry.getByScalar('text') → [codec1, codec2, ...]
+   */
+  getByScalar(scalar) {
+    return this._byScalar.get(scalar) ?? Object.freeze([]);
+  }
+  /**
+   * Get the default codec for a scalar type (first registered codec).
+   * Returns undefined if no codec handles this scalar type.
+   */
+  getDefaultCodec(scalar) {
+    const _codecs = this._byScalar.get(scalar);
+    return _codecs?.[0];
+  }
+  /**
+   * Register a codec in the registry.
+   * Throws an error if a codec with the same ID is already registered.
+   *
+   * @param codec - The codec to register
+   * @throws Error if a codec with the same ID already exists
+   */
+  register(codec2) {
+    if (this._byId.has(codec2.id)) {
+      throw new Error(`Codec with ID '${codec2.id}' is already registered`);
+    }
+    this._byId.set(codec2.id, codec2);
+    for (const scalarType of codec2.targetTypes) {
+      const existing = this._byScalar.get(scalarType);
+      if (existing) {
+        existing.push(codec2);
+      } else {
+        this._byScalar.set(scalarType, [codec2]);
+      }
+    }
+  }
+  /**
+   * Returns an iterator over all registered codecs.
+   * Useful for iterating through codecs from another registry.
+   */
+  *[Symbol.iterator]() {
+    for (const codec2 of this._byId.values()) {
+      yield codec2;
+    }
+  }
+  /**
+   * Returns an iterable of all registered codecs.
+   */
+  values() {
+    return this._byId.values();
+  }
+};
+function codec(config) {
+  return {
+    id: config.typeId,
+    targetTypes: config.targetTypes,
+    ...config.meta ? { meta: config.meta } : {},
+    encode: config.encode,
+    decode: config.decode
+  };
+}
+var CodecDefBuilderImpl = class _CodecDefBuilderImpl {
+  _codecs;
+  CodecTypes;
+  dataTypes;
+  constructor(codecs) {
+    this._codecs = codecs;
+    const codecTypes = {};
+    for (const [, codecImpl] of Object.entries(this._codecs)) {
+      const codecImplTyped = codecImpl;
+      codecTypes[codecImplTyped.id] = {
+        input: void 0,
+        output: void 0
+      };
+    }
+    this.CodecTypes = codecTypes;
+    const dataTypes = {};
+    for (const key in this._codecs) {
+      if (Object.hasOwn(this._codecs, key)) {
+        const codec2 = this._codecs[key];
+        dataTypes[key] = codec2.id;
+      }
+    }
+    this.dataTypes = dataTypes;
+  }
+  add(scalarName, codecImpl) {
+    return new _CodecDefBuilderImpl({
+      ...this._codecs,
+      [scalarName]: codecImpl
+    });
+  }
+  /**
+   * Derive codecDefinitions structure.
+   */
+  get codecDefinitions() {
+    const result = {};
+    for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {
+      const codec2 = codecImpl;
+      result[scalarName] = {
+        typeId: codec2.id,
+        scalar: scalarName,
+        codec: codec2,
+        input: void 0,
+        output: void 0,
+        jsType: void 0
+      };
+    }
+    return result;
+  }
+};
+function createCodecRegistry() {
+  return new CodecRegistryImpl();
+}
+function defineCodecs() {
+  return new CodecDefBuilderImpl({});
+}
+
+// src/ast/util.ts
+function compact(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
+// src/ast/common.ts
+function createTableRef(name) {
+  return {
+    kind: "table",
+    name
+  };
+}
+function createColumnRef(table, column) {
+  return {
+    kind: "col",
+    table,
+    column
+  };
+}
+function createParamRef(index, name) {
+  return compact({
+    kind: "param",
+    index,
+    name
+  });
+}
+function createOperationExpr(operation) {
+  return operation;
+}
+function createLiteralExpr(value) {
+  return {
+    kind: "literal",
+    value
+  };
+}
+
+// src/ast/delete.ts
+function createDeleteAst(options) {
+  return compact({
+    kind: "delete",
+    table: options.table,
+    where: options.where,
+    returning: options.returning
+  });
+}
+
+// src/ast/insert.ts
+function createInsertAst(options) {
+  return compact({
+    kind: "insert",
+    table: options.table,
+    values: options.values,
+    returning: options.returning
+  });
+}
+
+// src/ast/join.ts
+import { planInvalid } from "@prisma-next/plan";
+function createJoin(joinType, table, on) {
+  return {
+    kind: "join",
+    joinType,
+    table,
+    on
+  };
+}
+function createJoinOnExpr(left, right) {
+  return {
+    kind: "eqCol",
+    left,
+    right
+  };
+}
+var JoinOnBuilderImpl = class {
+  eqCol(left, right) {
+    if (!left || !isColumnBuilder(left)) {
+      throw planInvalid("Join ON left operand must be a column");
+    }
+    if (!right || !isColumnBuilder(right)) {
+      throw planInvalid("Join ON right operand must be a column");
+    }
+    const leftCol = left;
+    const rightCol = right;
+    if (leftCol.table === rightCol.table) {
+      throw planInvalid("Self-joins are not supported in MVP");
+    }
+    return {
+      kind: "join-on",
+      left,
+      right
+    };
+  }
+};
+function createJoinOnBuilder() {
+  return new JoinOnBuilderImpl();
+}
+
+// src/ast/order.ts
+function createOrderByItem(expr, dir) {
+  return {
+    expr,
+    dir
+  };
+}
+
+// src/ast/predicate.ts
+function createBinaryExpr(op, left, right) {
+  return {
+    kind: "bin",
+    op,
+    left,
+    right
+  };
+}
+function createExistsExpr(not, subquery) {
+  return {
+    kind: "exists",
+    not,
+    subquery
+  };
+}
+
+// src/ast/select.ts
+function createSelectAst(options) {
+  return compact({
+    kind: "select",
+    from: options.from,
+    joins: options.joins,
+    includes: options.includes,
+    project: options.project,
+    where: options.where,
+    orderBy: options.orderBy,
+    limit: options.limit
+  });
+}
+
+// src/ast/types.ts
+function isOperationExpr(expr) {
+  return expr.kind === "operation";
+}
+
+// src/ast/update.ts
+function createUpdateAst(options) {
+  return compact({
+    kind: "update",
+    table: options.table,
+    set: options.set,
+    where: options.where,
+    returning: options.returning
+  });
+}
+
+export {
+  codec,
+  createCodecRegistry,
+  defineCodecs,
+  compact,
+  createTableRef,
+  createColumnRef,
+  createParamRef,
+  createOperationExpr,
+  createLiteralExpr,
+  createDeleteAst,
+  createInsertAst,
+  createJoin,
+  createJoinOnExpr,
+  createJoinOnBuilder,
+  createOrderByItem,
+  createBinaryExpr,
+  createExistsExpr,
+  createSelectAst,
+  isOperationExpr,
+  createUpdateAst
+};
+//# sourceMappingURL=chunk-ENOLRQZS.js.map