@prisma-next/sql-relational-core 0.0.1

package/dist/exports/schema.d.ts

@@ -0,0 +1,63 @@
+import { StorageColumn, SqlContract, SqlStorage, ExtractCodecTypes, ExtractOperationTypes } from '@prisma-next/sql-contract/types';
+import { T as TableRef } from '../plan-D6dOf1wQ.js';
+import { Q as QueryLaneContext } from '../query-lane-context-BhOMmb_K.js';
+import { ParamPlaceholder, BinaryBuilder, OrderBuilder, CodecTypes, OperationTypes, ColumnBuilder, ComputeColumnJsType, OperationTypeSignature } from './types.js';
+import '@prisma-next/contract/types';
+import '@prisma-next/operations';
+import '@prisma-next/sql-operations';
+import 'ts-toolbelt';
+import '@prisma-next/plan';
+
+type TableColumns<Table extends {
+    columns: Record<string, StorageColumn>;
+}> = Table['columns'];
+type ColumnBuilders<Contract extends SqlContract<SqlStorage>, TableName extends string, Columns extends Record<string, StorageColumn>, CodecTypes extends CodecTypes, Operations extends OperationTypes> = {
+    readonly [K in keyof Columns]: ColumnBuilder<K & string, Columns[K], ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>, Operations>;
+};
+declare class ColumnBuilderImpl<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown> {
+    readonly table: string;
+    readonly column: ColumnName;
+    private readonly storageColumn;
+    readonly kind: "column";
+    constructor(table: string, column: ColumnName, storageColumn: ColumnMeta);
+    get columnMeta(): ColumnMeta;
+    get __jsType(): JsType;
+    eq(this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>, value: ParamPlaceholder): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+    asc(this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>): OrderBuilder<ColumnName, ColumnMeta, JsType>;
+    desc(this: ColumnBuilderImpl<ColumnName, ColumnMeta, JsType>): OrderBuilder<ColumnName, ColumnMeta, JsType>;
+}
+declare class TableBuilderImpl<Contract extends SqlContract<SqlStorage>, TableName extends string, Columns extends Record<string, StorageColumn>, CodecTypes extends CodecTypes, Operations extends OperationTypes> implements TableRef {
+    readonly kind: "table";
+    readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;
+    private readonly _name;
+    constructor(name: TableName, columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>);
+    get name(): string;
+}
+type ExtractSchemaTables<Contract extends SqlContract<SqlStorage>, CodecTypes extends CodecTypes, Operations extends OperationTypes> = {
+    readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<Contract, TableName & string, TableColumns<Contract['storage']['tables'][TableName]>, CodecTypes, Operations> & TableRef;
+};
+type SchemaHandle<Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>, CodecTypes extends CodecTypes = CodecTypes, Operations extends OperationTypes = Record<string, never>> = {
+    readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;
+};
+type SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<Contract, ExtractCodecTypes<Contract>, ToOperationTypes<ExtractOperationTypes<Contract>>>;
+type NormalizeOperationTypes<T> = {
+    [TypeId in keyof T]: {
+        [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature ? T[TypeId][Method] : OperationTypeSignature;
+    };
+};
+type ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;
+/**
+ * Creates a schema handle for building SQL queries.
+ *
+ * @param context - Query lane context containing contract, codec and operation registries
+ * @returns A schema handle with typed table builders
+ *
+ * @example
+ * ```typescript
+ * const schemaHandle = schema<Contract>(context);
+ * const userTable = schemaHandle.tables.user;
+ * ```
+ */
+declare function schema<Contract extends SqlContract<SqlStorage>>(context: QueryLaneContext<Contract>): SchemaReturnType<Contract>;
+
+export { ColumnBuilderImpl as Column, ColumnBuilderImpl, type SchemaHandle, TableBuilderImpl as Table, TableBuilderImpl, schema };

package/dist/exports/schema.js

@@ -0,0 +1,12 @@
+import {
+  ColumnBuilderImpl,
+  TableBuilderImpl,
+  schema
+} from "../chunk-7FMQVMSM.js";
+import "../chunk-FMVAOBWJ.js";
+export {
+  ColumnBuilderImpl,
+  TableBuilderImpl,
+  schema
+};
+//# sourceMappingURL=schema.js.map

package/dist/exports/schema.js.map

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

package/dist/exports/types.d.ts

@@ -0,0 +1,306 @@
+import { ExecutionPlan, PlanRefs, ResultType as ResultType$1 } from '@prisma-next/contract/types';
+import { ArgSpec, ReturnSpec } from '@prisma-next/operations';
+import { StorageColumn, SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { SqlLoweringSpec } from '@prisma-next/sql-operations';
+import { O as OperationExpr, D as Direction, C as ColumnRef, P as ParamRef, Q as QueryAst, f as SqlQueryPlan } from '../plan-D6dOf1wQ.js';
+import { Q as QueryLaneContext } from '../query-lane-context-BhOMmb_K.js';
+export { RuntimeError } from '@prisma-next/plan';
+import 'ts-toolbelt';
+
+interface ParamPlaceholder {
+    readonly kind: 'param-placeholder';
+    readonly name: string;
+}
+interface OrderBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown> {
+    readonly kind: 'order';
+    readonly expr: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
+    readonly dir: Direction;
+}
+/**
+ * ColumnBuilder with optional operation methods based on the column's typeId.
+ * When Operations is provided and the column's typeId matches, operation methods are included.
+ */
+type ColumnBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>> = {
+    readonly kind: 'column';
+    readonly table: string;
+    readonly column: ColumnName;
+    readonly columnMeta: ColumnMeta;
+    eq(value: ParamPlaceholder): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
+    asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
+    desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
+    readonly __jsType: JsType;
+} & (ColumnMeta['type'] extends keyof Operations ? OperationMethods<OperationsForTypeId<ColumnMeta['type'], Operations>, ColumnName, StorageColumn, JsType> : Record<string, never>);
+interface BinaryBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown> {
+    readonly kind: 'binary';
+    readonly op: 'eq';
+    readonly left: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
+    readonly right: ParamPlaceholder;
+}
+type AnyColumnBuilder = ColumnBuilder<string, StorageColumn, unknown, any>;
+type AnyBinaryBuilder = BinaryBuilder<string, StorageColumn, unknown>;
+type AnyOrderBuilder = OrderBuilder<string, StorageColumn, unknown>;
+declare function isColumnBuilder(value: unknown): value is AnyColumnBuilder;
+interface JoinOnBuilder {
+    eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;
+}
+interface JoinOnPredicate {
+    readonly kind: 'join-on';
+    readonly left: AnyColumnBuilder;
+    readonly right: AnyColumnBuilder;
+}
+type Expr = ColumnRef | ParamRef;
+/**
+ * Helper type to extract codec output type from CodecTypes.
+ * Returns never if the codecId is not found in CodecTypes.
+ */
+type ExtractCodecOutputType<CodecId extends string, CodecTypes extends Record<string, {
+    readonly output: unknown;
+}>> = CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends {
+    readonly output: infer Output;
+} ? Output : never : never;
+/**
+ * Type-level operation signature.
+ * Represents an operation at the type level, similar to OperationSignature at runtime.
+ */
+type OperationTypeSignature = {
+    readonly args: ReadonlyArray<ArgSpec>;
+    readonly returns: ReturnSpec;
+    readonly lowering: SqlLoweringSpec;
+    readonly capabilities?: ReadonlyArray<string>;
+};
+/**
+ * Type-level operation registry.
+ * Maps typeId → operations, where operations is a record of method name → operation signature.
+ *
+ * Example:
+ * ```typescript
+ * type MyOperations: OperationTypes = {
+ *   'pgvector/vector@1': {
+ *     cosineDistance: {
+ *       args: [{ kind: 'typeId'; type: 'pgvector/vector@1' }];
+ *       returns: { kind: 'builtin'; type: 'number' };
+ *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };
+ *     };
+ *   };
+ * };
+ * ```
+ */
+type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;
+/**
+ * CodecTypes represents a map of typeId to codec definitions.
+ * Each codec definition must have an `output` property indicating the JavaScript type.
+ *
+ * Example:
+ * ```typescript
+ * type MyCodecTypes: CodecTypes = {
+ *   'pg/int4@1': { output: number };
+ *   'pg/text@1': { output: string };
+ * };
+ * ```
+ */
+type CodecTypes = Record<string, {
+    readonly output: unknown;
+}>;
+/**
+ * Extracts operations for a given typeId from the operation registry.
+ * Returns an empty record if the typeId is not found.
+ *
+ * @example
+ * ```typescript
+ * type Ops = OperationsForTypeId<'pgvector/vector@1', MyOperations>;
+ * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }
+ * ```
+ */
+type OperationsForTypeId<TypeId extends string, Operations extends OperationTypes> = Operations extends Record<string, never> ? Record<string, never> : TypeId extends keyof Operations ? Operations[TypeId] : Record<string, never>;
+/**
+ * Maps operation signatures to method signatures on ColumnBuilder.
+ * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder
+ * based on the return type.
+ */
+type OperationMethods<Ops extends Record<string, OperationTypeSignature>, ColumnName extends string, ColumnMeta extends StorageColumn, JsType> = {
+    [K in keyof Ops]: Ops[K] extends OperationTypeSignature ? (...args: OperationArgs<Ops[K]['args']>) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType> : never;
+};
+/**
+ * Maps operation argument specs to TypeScript argument types.
+ * - typeId args: ColumnBuilder (accepts base columns or operation results)
+ * - param args: ParamPlaceholder
+ * - literal args: unknown (could be more specific in future)
+ */
+type OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [
+    infer First,
+    ...infer Rest
+] ? First extends ArgSpec ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])] : [] : [];
+type ArgToType<Arg extends ArgSpec> = Arg extends {
+    kind: 'typeId';
+} ? AnyColumnBuilder : Arg extends {
+    kind: 'param';
+} ? ParamPlaceholder : Arg extends {
+    kind: 'literal';
+} ? unknown : never;
+/**
+ * Maps operation return spec to return type.
+ * - builtin types: ColumnBuilder with appropriate JsType (matches runtime behavior)
+ * - typeId types: ColumnBuilder (for now, could be more specific in future)
+ */
+type OperationReturn<Returns extends ReturnSpec, ColumnName extends string, ColumnMeta extends StorageColumn, _JsType> = Returns extends {
+    kind: 'builtin';
+    type: infer T;
+} ? T extends 'number' ? ColumnBuilder<ColumnName, ColumnMeta, number> : T extends 'boolean' ? ColumnBuilder<ColumnName, ColumnMeta, boolean> : T extends 'string' ? ColumnBuilder<ColumnName, ColumnMeta, string> : ColumnBuilder<ColumnName, ColumnMeta, unknown> : Returns extends {
+    kind: 'typeId';
+} ? AnyColumnBuilder : ColumnBuilder<ColumnName, ColumnMeta, unknown>;
+/**
+ * Computes JavaScript type for a column at column creation time.
+ *
+ * Type inference:
+ * - Read columnMeta.type as typeId string literal
+ * - Look up CodecTypes[typeId].output
+ * - Apply nullability: nullable ? Output | null : Output
+ */
+type ComputeColumnJsType<_Contract extends SqlContract<SqlStorage>, _TableName extends string, _ColumnName extends string, ColumnMeta extends StorageColumn, CodecTypes extends Record<string, {
+    readonly output: unknown;
+}>> = ColumnMeta extends {
+    type: infer T;
+    nullable: infer N;
+} ? T extends string ? ExtractCodecOutputType<T, CodecTypes> extends infer CodecOutput ? [CodecOutput] extends [never] ? unknown : N extends true ? CodecOutput | null : CodecOutput : unknown : unknown : unknown;
+/**
+ * Infers Row type from a projection object.
+ * Maps Record<string, ColumnBuilder> to Record<string, JSType>
+ *
+ * Extracts the pre-computed JsType from each ColumnBuilder in the projection.
+ */
+/**
+ * Extracts the inferred JsType carried by a ColumnBuilder.
+ */
+type ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> = CB extends ColumnBuilder<infer _ColumnName extends string, infer _ColumnMeta extends StorageColumn, infer JsType, infer _Ops> ? JsType : never;
+type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {
+    [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;
+};
+/**
+ * Nested projection type - allows recursive nesting of ColumnBuilder or nested objects.
+ */
+type NestedProjection = Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder>>>>>;
+/**
+ * Helper type to extract include type from Includes map.
+ * Returns the value type if K is a key of Includes, otherwise returns unknown.
+ */
+type ExtractIncludeType<K extends string, Includes extends Record<string, unknown>> = K extends keyof Includes ? Includes[K] : unknown;
+/**
+ * Infers Row type from a nested projection object.
+ * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.
+ *
+ * Extracts the pre-computed JsType from each ColumnBuilder at leaves.
+ * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`
+ * by looking up the include alias in the Includes type map.
+ */
+type InferNestedProjectionRow<P extends Record<string, AnyColumnBuilder | boolean | NestedProjection>, CodecTypes extends Record<string, {
+    readonly output: unknown;
+}> = Record<string, never>, Includes extends Record<string, unknown> = Record<string, never>> = {
+    [K in keyof P]: P[K] extends AnyColumnBuilder ? ExtractJsTypeFromColumnBuilder<P[K]> : P[K] extends true ? Array<ExtractIncludeType<K & string, Includes>> : P[K] extends NestedProjection ? InferNestedProjectionRow<P[K], CodecTypes, Includes> : never;
+};
+/**
+ * Infers Row type from a tuple of ColumnBuilders used in returning() clause.
+ * Extracts column name and JsType from each ColumnBuilder and creates a Record.
+ */
+type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> = Columns extends readonly [infer First, ...infer Rest] ? First extends ColumnBuilder<infer Name, infer _Meta, infer JsType, infer _Ops extends OperationTypes> ? Name extends string ? Rest extends readonly AnyColumnBuilder[] ? {
+    [K in Name]: JsType;
+} & InferReturningRow<Rest> : {
+    [K in Name]: JsType;
+} : never : never : Record<string, never>;
+/**
+ * Utility type to check if a contract has the required capabilities for includeMany.
+ * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.
+ * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`
+ */
+type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> = TContract extends {
+    capabilities: infer C;
+    target: infer T;
+} ? T extends string ? C extends Record<string, Record<string, boolean>> ? C extends {
+    [K in T]: infer TargetCaps;
+} ? TargetCaps extends {
+    lateral: true;
+    jsonAgg: true;
+} ? true : false : false : false : false : false;
+/**
+ * SQL-specific Plan type that refines the ast field to use QueryAst.
+ * This is the type used by SQL query builders.
+ */
+type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;
+/**
+ * Helper types for extracting contract structure.
+ */
+type TablesOf<TContract> = TContract extends {
+    storage: {
+        tables: infer U;
+    };
+} ? U : never;
+type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;
+/**
+ * Unique symbol for metadata property to avoid collisions with user-defined properties
+ */
+declare const META: unique symbol;
+/**
+ * Extracts metadata from a type that has a META property
+ */
+type Meta<T extends {
+    [META]: unknown;
+}> = T[typeof META];
+/**
+ * Metadata interface for table definitions
+ */
+interface TableMetadata<Name extends string> {
+    name: Name;
+}
+/**
+ * Metadata interface for model definitions
+ */
+interface ModelMetadata<Name extends string> {
+    name: Name;
+}
+/**
+ * Base interface for table definitions with metadata
+ * Used in contract.d.ts to define storage-level table types
+ */
+interface TableDef<Name extends string> {
+    readonly [META]: TableMetadata<Name>;
+}
+/**
+ * Base interface for model definitions with metadata
+ * Used in contract.d.ts to define application-level model types
+ */
+interface ModelDef<Name extends string> {
+    readonly [META]: ModelMetadata<Name>;
+}
+type ColumnsOf<TContract, K extends TableKey<TContract>> = K extends keyof TablesOf<TContract> ? TablesOf<TContract>[K] extends {
+    columns: infer C;
+} ? C : never : never;
+interface RawTemplateOptions {
+    readonly refs?: PlanRefs;
+    readonly annotations?: Record<string, unknown>;
+    readonly projection?: ReadonlyArray<string>;
+}
+interface RawFunctionOptions extends RawTemplateOptions {
+    readonly params: ReadonlyArray<unknown>;
+}
+type RawTemplateFactory = (strings: TemplateStringsArray, ...values: readonly unknown[]) => ExecutionPlan;
+interface RawFactory extends RawTemplateFactory {
+    (text: string, options: RawFunctionOptions): ExecutionPlan;
+    with(options: RawTemplateOptions): RawTemplateFactory;
+}
+
+interface BuildParamsMap {
+    readonly [name: string]: unknown;
+}
+interface BuildOptions {
+    readonly params?: BuildParamsMap;
+}
+interface SqlBuilderOptions<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>> {
+    readonly context: QueryLaneContext<TContract>;
+}
+/**
+ * SQL-specific ResultType that works with both Plan and SqlQueryPlan.
+ * This extends the core ResultType to also handle SqlQueryPlan.
+ * Example: `type Row = ResultType<typeof plan>`
+ */
+type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : ResultType$1<P>;
+
+export { type AnyBinaryBuilder, type AnyColumnBuilder, type AnyOrderBuilder, type BinaryBuilder, type BuildOptions, type BuildParamsMap, type CodecTypes, type ColumnBuilder, type ColumnsOf, type ComputeColumnJsType, type Expr, type HasIncludeManyCapabilities, type InferNestedProjectionRow, type InferProjectionRow, type InferReturningRow, type JoinOnBuilder, type JoinOnPredicate, META, type Meta, type ModelDef, type ModelMetadata, type NestedProjection, type OperationTypeSignature, type OperationTypes, type OperationsForTypeId, type OrderBuilder, type ParamPlaceholder, type RawFactory, type RawFunctionOptions, type RawTemplateFactory, type RawTemplateOptions, type ResultType, type SqlBuilderOptions, type SqlPlan, type TableDef, type TableKey, type TableMetadata, type TablesOf, isColumnBuilder };

package/dist/exports/types.js

@@ -0,0 +1,7 @@
+import {
+  isColumnBuilder
+} from "../chunk-ILC64YWE.js";
+export {
+  isColumnBuilder
+};
+//# sourceMappingURL=types.js.map

package/dist/exports/types.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { Adapter, AdapterProfile, AdapterTarget, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, LoweredPayload, Lowerer, LowererContext, SqlDriver, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, compact, createBinaryExpr, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst } from './exports/ast.js';
+export { a as Codec, h as CodecDefBuilder, d as CodecId, e as CodecInput, C as CodecMeta, f as CodecOutput, b as CodecRegistry, E as ExtractCodecTypes, g as ExtractDataTypes, Q as QueryLaneContext, c as codec, i as createCodecRegistry, j as defineCodecs } from './query-lane-context-BhOMmb_K.js';
+export { B as BinaryExpr, C as ColumnRef, d as DeleteAst, D as Direction, E as ExistsExpr, b as IncludeAst, I as IncludeRef, c as InsertAst, a as JoinAst, J as JoinOnExpr, L as LiteralExpr, e as LoweredStatement, O as OperationExpr, P as ParamRef, Q as QueryAst, S as SelectAst, f as SqlQueryPlan, T as TableRef, U as UpdateAst, i as isOperationExpr } from './plan-D6dOf1wQ.js';
+export { RuntimeError, planInvalid, planUnsupported } from '@prisma-next/plan';
+export { attachOperationsToColumnBuilder } from './exports/operations-registry.js';
+export { Parameter, param } from './exports/param.js';
+export { Column, Column as ColumnBuilderImpl, SchemaHandle, Table, Table as TableBuilderImpl, schema } from './exports/schema.js';
+export { AnyBinaryBuilder, AnyColumnBuilder, AnyOrderBuilder, BinaryBuilder, BuildOptions, BuildParamsMap, CodecTypes, ColumnBuilder, ColumnsOf, ComputeColumnJsType, Expr, HasIncludeManyCapabilities, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, JoinOnBuilder, JoinOnPredicate, META, Meta, ModelDef, ModelMetadata, NestedProjection, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrderBuilder, ParamPlaceholder, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, SqlBuilderOptions, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf, isColumnBuilder } from './exports/types.js';
+import '@prisma-next/operations';
+import '@prisma-next/sql-contract/types';
+import 'ts-toolbelt';
+import '@prisma-next/contract/types';
+import '@prisma-next/sql-operations';

package/dist/index.js

@@ -0,0 +1,74 @@
+import "./chunk-U7AXAUJA.js";
+import {
+  ColumnBuilderImpl,
+  TableBuilderImpl,
+  schema
+} from "./chunk-7FMQVMSM.js";
+import {
+  param
+} from "./chunk-7I3EMQID.js";
+import "./chunk-G52ENULI.js";
+import {
+  attachOperationsToColumnBuilder
+} from "./chunk-FMVAOBWJ.js";
+import {
+  planInvalid,
+  planUnsupported
+} from "./chunk-2F7DSEOU.js";
+import {
+  codec,
+  compact,
+  createBinaryExpr,
+  createCodecRegistry,
+  createColumnRef,
+  createDeleteAst,
+  createExistsExpr,
+  createInsertAst,
+  createJoin,
+  createJoinOnBuilder,
+  createJoinOnExpr,
+  createLiteralExpr,
+  createOperationExpr,
+  createOrderByItem,
+  createParamRef,
+  createSelectAst,
+  createTableRef,
+  createUpdateAst,
+  defineCodecs,
+  isOperationExpr
+} from "./chunk-ENOLRQZS.js";
+import {
+  isColumnBuilder
+} from "./chunk-ILC64YWE.js";
+import "./chunk-UVFWELV2.js";
+export {
+  ColumnBuilderImpl,
+  TableBuilderImpl,
+  attachOperationsToColumnBuilder,
+  codec,
+  compact,
+  createBinaryExpr,
+  createCodecRegistry,
+  createColumnRef,
+  createDeleteAst,
+  createExistsExpr,
+  createInsertAst,
+  createJoin,
+  createJoinOnBuilder,
+  createJoinOnExpr,
+  createLiteralExpr,
+  createOperationExpr,
+  createOrderByItem,
+  createParamRef,
+  createSelectAst,
+  createTableRef,
+  createUpdateAst,
+  defineCodecs,
+  isColumnBuilder,
+  isOperationExpr,
+  param,
+  planInvalid,
+  planUnsupported,
+  schema
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/plan-D6dOf1wQ.d.ts

@@ -0,0 +1,135 @@
+import { ExecutionPlan } from '@prisma-next/contract/types';
+import { ReturnSpec } from '@prisma-next/operations';
+import { SqlLoweringSpec } from '@prisma-next/sql-operations';
+
+type Direction = 'asc' | 'desc';
+interface TableRef {
+    readonly kind: 'table';
+    readonly name: string;
+}
+interface ColumnRef {
+    readonly kind: 'col';
+    readonly table: string;
+    readonly column: string;
+}
+interface ParamRef {
+    readonly kind: 'param';
+    readonly index: number;
+    readonly name?: string;
+}
+interface LiteralExpr {
+    readonly kind: 'literal';
+    readonly value: unknown;
+}
+interface OperationExpr {
+    readonly kind: 'operation';
+    readonly method: string;
+    readonly forTypeId: string;
+    readonly self: ColumnRef | OperationExpr;
+    readonly args: ReadonlyArray<ColumnRef | ParamRef | LiteralExpr | OperationExpr>;
+    readonly returns: ReturnSpec;
+    readonly lowering: SqlLoweringSpec;
+}
+declare function isOperationExpr(expr: ColumnRef | OperationExpr): expr is OperationExpr;
+interface BinaryExpr {
+    readonly kind: 'bin';
+    readonly op: 'eq';
+    readonly left: ColumnRef | OperationExpr;
+    readonly right: ParamRef;
+}
+interface ExistsExpr {
+    readonly kind: 'exists';
+    readonly not: boolean;
+    readonly subquery: SelectAst;
+}
+type JoinOnExpr = {
+    readonly kind: 'eqCol';
+    readonly left: ColumnRef;
+    readonly right: ColumnRef;
+};
+interface JoinAst {
+    readonly kind: 'join';
+    readonly joinType: 'inner' | 'left' | 'right' | 'full';
+    readonly table: TableRef;
+    readonly on: JoinOnExpr;
+}
+interface IncludeRef {
+    readonly kind: 'includeRef';
+    readonly alias: string;
+}
+interface IncludeAst {
+    readonly kind: 'includeMany';
+    readonly alias: string;
+    readonly child: {
+        readonly table: TableRef;
+        readonly on: JoinOnExpr;
+        readonly where?: BinaryExpr | ExistsExpr;
+        readonly orderBy?: ReadonlyArray<{
+            expr: ColumnRef | OperationExpr;
+            dir: Direction;
+        }>;
+        readonly limit?: number;
+        readonly project: ReadonlyArray<{
+            alias: string;
+            expr: ColumnRef | OperationExpr;
+        }>;
+    };
+}
+interface SelectAst {
+    readonly kind: 'select';
+    readonly from: TableRef;
+    readonly joins?: ReadonlyArray<JoinAst>;
+    readonly includes?: ReadonlyArray<IncludeAst>;
+    readonly project: ReadonlyArray<{
+        alias: string;
+        expr: ColumnRef | IncludeRef | OperationExpr | LiteralExpr;
+    }>;
+    readonly where?: BinaryExpr | ExistsExpr;
+    readonly orderBy?: ReadonlyArray<{
+        expr: ColumnRef | OperationExpr;
+        dir: Direction;
+    }>;
+    readonly limit?: number;
+}
+interface InsertAst {
+    readonly kind: 'insert';
+    readonly table: TableRef;
+    readonly values: Record<string, ColumnRef | ParamRef>;
+    readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface UpdateAst {
+    readonly kind: 'update';
+    readonly table: TableRef;
+    readonly set: Record<string, ColumnRef | ParamRef>;
+    readonly where: BinaryExpr;
+    readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface DeleteAst {
+    readonly kind: 'delete';
+    readonly table: TableRef;
+    readonly where: BinaryExpr;
+    readonly returning?: ReadonlyArray<ColumnRef>;
+}
+type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;
+interface LoweredStatement {
+    readonly sql: string;
+    readonly params: readonly unknown[];
+    readonly annotations?: Record<string, unknown>;
+}
+
+/**
+ * SQL query plan produced by lanes before lowering.
+ *
+ * Lanes build ASTs and metadata but do not perform SQL lowering.
+ * The `sql` field is absent - lowering happens in the runtime executor.
+ *
+ * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain
+ * compatibility with ExecutionPlan/Plan-based utilities.
+ * The generic parameter `_Row` is preserved for type extraction via ResultType.
+ */
+interface SqlQueryPlan<_Row = unknown> extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {
+    readonly ast: QueryAst;
+    readonly _Row?: _Row;
+}
+
+export { type BinaryExpr as B, type ColumnRef as C, type Direction as D, type ExistsExpr as E, type IncludeRef as I, type JoinOnExpr as J, type LiteralExpr as L, type OperationExpr as O, type ParamRef as P, type QueryAst as Q, type SelectAst as S, type TableRef as T, type UpdateAst as U, type JoinAst as a, type IncludeAst as b, type InsertAst as c, type DeleteAst as d, type LoweredStatement as e, type SqlQueryPlan as f, isOperationExpr as i };