@prisma-next/sql-orm-lane 0.0.1

package/dist/chunk-JOTSRS66.js

@@ -0,0 +1,1707 @@
+// src/orm/builder.ts
+import { planInvalid as planInvalid5 } from "@prisma-next/plan";
+import { schema as schema4 } from "@prisma-next/sql-relational-core/schema";
+
+// src/utils/ast.ts
+import {
+  createBinaryExpr,
+  createColumnRef,
+  createDeleteAst,
+  createInsertAst,
+  createJoinOnExpr,
+  createOrderByItem,
+  createParamRef,
+  createSelectAst,
+  createTableRef,
+  createUpdateAst
+} from "@prisma-next/sql-relational-core/ast";
+
+// src/utils/errors.ts
+import { planInvalid } from "@prisma-next/plan";
+function errorModelNotFound(modelName) {
+  throw planInvalid(`Model ${modelName} not found in mappings`);
+}
+function errorTableNotFound(tableName) {
+  throw planInvalid(`Table ${tableName} not found in schema`);
+}
+function errorUnknownTable(tableName) {
+  throw planInvalid(`Unknown table ${tableName}`);
+}
+function errorUnknownColumn(columnName, tableName) {
+  throw planInvalid(`Unknown column ${columnName} in table ${tableName}`);
+}
+function errorMissingParameter(paramName) {
+  throw planInvalid(`Missing value for parameter ${paramName}`);
+}
+function errorAliasPathEmpty() {
+  throw planInvalid("Alias path cannot be empty");
+}
+function errorAliasCollision(path, alias, existingPath) {
+  throw planInvalid(
+    `Alias collision: path ${path.join(".")} would generate alias "${alias}" which conflicts with path ${existingPath?.join(".") ?? "unknown"}`
+  );
+}
+function errorInvalidProjectionValue(path) {
+  throw planInvalid(
+    `Invalid projection value at path ${path.join(".")}: expected ColumnBuilder or nested object`
+  );
+}
+function errorIncludeAliasNotFound(alias) {
+  throw planInvalid(
+    `Include alias "${alias}" not found. Did you call includeMany() with alias "${alias}"?`
+  );
+}
+function errorInvalidProjectionKey(key) {
+  throw planInvalid(
+    `Invalid projection value at key "${key}": expected ColumnBuilder, boolean true (for includes), or nested object`
+  );
+}
+function errorProjectionEmpty() {
+  throw planInvalid("select() requires at least one column or include");
+}
+function errorCreateRequiresFields() {
+  throw planInvalid("create() requires at least one field");
+}
+function errorUpdateRequiresFields() {
+  throw planInvalid("update() requires at least one field");
+}
+function errorIncludeRequiresCapabilities() {
+  throw planInvalid("includeMany requires lateral and jsonAgg capabilities");
+}
+function errorIncludeCapabilitiesNotTrue() {
+  throw planInvalid("includeMany requires lateral and jsonAgg capabilities to be true");
+}
+function errorMultiColumnJoinsNotSupported() {
+  throw planInvalid("Multi-column joins in includes are not yet supported");
+}
+function errorJoinColumnsMustBeDefined() {
+  throw planInvalid("Join columns must be defined");
+}
+function errorColumnNotFound(columnName, tableName) {
+  throw planInvalid(`Column ${columnName} not found in table ${tableName}`);
+}
+function errorChildProjectionMustBeSpecified() {
+  throw planInvalid("Child projection must be specified");
+}
+function errorChildProjectionEmpty() {
+  throw planInvalid("Child projection must not be empty after filtering boolean values");
+}
+function errorMissingAlias(index) {
+  throw planInvalid(`Missing alias at index ${index}`);
+}
+function errorMissingColumn(alias, index) {
+  throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
+}
+function errorInvalidColumn(alias, index) {
+  throw planInvalid(`Invalid column for alias ${alias} at index ${index}`);
+}
+function errorFailedToBuildWhereClause() {
+  throw planInvalid("Failed to build WHERE clause");
+}
+function assertColumnExists(columnMeta, columnName, tableName) {
+  if (!columnMeta) {
+    errorUnknownColumn(columnName, tableName);
+  }
+}
+function assertParameterExists(paramsMap, paramName) {
+  if (!Object.hasOwn(paramsMap, paramName)) {
+    errorMissingParameter(paramName);
+  }
+  return paramsMap[paramName];
+}
+
+// src/selection/predicates.ts
+function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
+  const placeholder = where.right;
+  const paramName = placeholder.name;
+  if (!Object.hasOwn(paramsMap, paramName)) {
+    errorMissingParameter(paramName);
+  }
+  const value = paramsMap[paramName];
+  const index = values.push(value);
+  let leftExpr;
+  let codecId;
+  const operationExpr = where.left._operationExpr;
+  if (operationExpr) {
+    leftExpr = operationExpr;
+  } else {
+    const colBuilder = where.left;
+    const meta = colBuilder.columnMeta ?? {};
+    descriptors.push({
+      name: paramName,
+      source: "dsl",
+      refs: { table: colBuilder.table, column: colBuilder.column },
+      ...typeof meta.type === "string" ? { type: meta.type } : {},
+      ...typeof meta.nullable === "boolean" ? { nullable: meta.nullable } : {}
+    });
+    const contractTable = contract.storage.tables[colBuilder.table];
+    const columnMeta = contractTable?.columns[colBuilder.column];
+    codecId = columnMeta?.type;
+    leftExpr = createColumnRef(colBuilder.table, colBuilder.column);
+  }
+  return {
+    expr: createBinaryExpr("eq", leftExpr, createParamRef(index, paramName)),
+    ...codecId ? { codecId } : {},
+    paramName
+  };
+}
+
+// src/mutations/delete-builder.ts
+function buildDeletePlan(context, modelName, where, getModelAccessor, options) {
+  const modelAccessor = getModelAccessor();
+  const wherePredicate = where(modelAccessor);
+  const tableName = context.contract.mappings.modelToTable?.[modelName];
+  if (!tableName) {
+    errorModelNotFound(modelName);
+  }
+  const table = createTableRef(tableName);
+  const paramsMap = options?.params ?? {};
+  const paramDescriptors = [];
+  const paramValues = [];
+  const paramCodecs = {};
+  const whereResult = buildWhereExpr(
+    wherePredicate,
+    context.contract,
+    paramsMap,
+    paramDescriptors,
+    paramValues
+  );
+  const whereExpr = whereResult.expr;
+  if (!whereExpr) {
+    errorFailedToBuildWhereClause();
+  }
+  if (whereResult?.codecId && whereResult.paramName) {
+    paramCodecs[whereResult.paramName] = whereResult.codecId;
+  }
+  const ast = createDeleteAst({
+    table,
+    where: whereExpr
+  });
+  return Object.freeze({
+    ast,
+    params: paramValues,
+    meta: {
+      target: context.contract.target,
+      targetFamily: context.contract.targetFamily,
+      coreHash: context.contract.coreHash,
+      lane: "orm",
+      refs: {
+        tables: [tableName],
+        columns: []
+      },
+      projection: {},
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? {
+        annotations: {
+          codecs: paramCodecs,
+          intent: "write",
+          isMutation: true
+        }
+      } : {
+        annotations: {
+          intent: "write",
+          isMutation: true
+        }
+      }
+    }
+  });
+}
+
+// src/mutations/insert-builder.ts
+import { param } from "@prisma-next/sql-relational-core/param";
+
+// src/utils/param-descriptor.ts
+function createParamDescriptor(args) {
+  return {
+    name: args.name,
+    source: "dsl",
+    refs: { table: args.table, column: args.column },
+    ...args.type ? { type: args.type } : {},
+    nullable: args.nullable
+  };
+}
+
+// src/mutations/insert-builder.ts
+function convertModelFieldsToColumns(contract, modelName, fields) {
+  const model = contract.models[modelName];
+  if (!model || typeof model !== "object" || !("fields" in model)) {
+    throw new Error(`Model ${modelName} does not have fields`);
+  }
+  const modelFields = model.fields;
+  const result = {};
+  for (const fieldName in fields) {
+    if (!Object.hasOwn(fields, fieldName)) {
+      continue;
+    }
+    if (!Object.hasOwn(modelFields, fieldName)) {
+      throw new Error(`Field ${fieldName} does not exist on model ${modelName}`);
+    }
+    const field = modelFields[fieldName];
+    if (!field) {
+      continue;
+    }
+    const columnName = contract.mappings.fieldToColumn?.[modelName]?.[fieldName] ?? field.column ?? fieldName;
+    result[columnName] = param(fieldName);
+  }
+  return result;
+}
+function buildInsertPlan(context, modelName, data, options) {
+  if (!data || Object.keys(data).length === 0) {
+    errorCreateRequiresFields();
+  }
+  const values = convertModelFieldsToColumns(context.contract, modelName, data);
+  const tableName = context.contract.mappings.modelToTable?.[modelName];
+  if (!tableName) {
+    errorModelNotFound(modelName);
+  }
+  const table = createTableRef(tableName);
+  const paramsMap = {
+    ...options?.params ?? {},
+    ...data
+  };
+  const paramDescriptors = [];
+  const paramValues = [];
+  const paramCodecs = {};
+  const contractTable = context.contract.storage.tables[tableName];
+  if (!contractTable) {
+    errorUnknownTable(tableName);
+  }
+  const insertValues = {};
+  for (const [columnName, placeholder] of Object.entries(values)) {
+    const columnMeta = contractTable.columns[columnName];
+    assertColumnExists(columnMeta, columnName, tableName);
+    const paramName = placeholder.name;
+    const value = assertParameterExists(paramsMap, paramName);
+    const index = paramValues.push(value);
+    const codecId = columnMeta.type;
+    if (codecId && paramName) {
+      paramCodecs[paramName] = codecId;
+    }
+    paramDescriptors.push(
+      createParamDescriptor({
+        name: paramName,
+        table: tableName,
+        column: columnName,
+        type: codecId,
+        nullable: columnMeta.nullable
+      })
+    );
+    insertValues[columnName] = createParamRef(index, paramName);
+  }
+  const ast = createInsertAst({
+    table,
+    values: insertValues
+  });
+  return Object.freeze({
+    ast,
+    params: paramValues,
+    meta: {
+      target: context.contract.target,
+      targetFamily: context.contract.targetFamily,
+      coreHash: context.contract.coreHash,
+      lane: "orm",
+      refs: {
+        tables: [tableName],
+        columns: []
+      },
+      projection: {},
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? {
+        annotations: {
+          codecs: paramCodecs,
+          intent: "write",
+          isMutation: true
+        }
+      } : {
+        annotations: {
+          intent: "write",
+          isMutation: true
+        }
+      }
+    }
+  });
+}
+
+// src/mutations/update-builder.ts
+function buildUpdatePlan(context, modelName, where, getModelAccessor, data, options) {
+  if (!data || Object.keys(data).length === 0) {
+    errorUpdateRequiresFields();
+  }
+  const set = convertModelFieldsToColumns(context.contract, modelName, data);
+  const modelAccessor = getModelAccessor();
+  const wherePredicate = where(modelAccessor);
+  const tableName = context.contract.mappings.modelToTable?.[modelName];
+  if (!tableName) {
+    errorModelNotFound(modelName);
+  }
+  const table = createTableRef(tableName);
+  const paramsMap = {
+    ...options?.params ?? {},
+    ...data
+  };
+  const paramDescriptors = [];
+  const paramValues = [];
+  const paramCodecs = {};
+  const contractTable = context.contract.storage.tables[tableName];
+  if (!contractTable) {
+    errorUnknownTable(tableName);
+  }
+  const updateSet = {};
+  for (const [columnName, placeholder] of Object.entries(set)) {
+    const columnMeta = contractTable.columns[columnName];
+    assertColumnExists(columnMeta, columnName, tableName);
+    const paramName = placeholder.name;
+    const value = assertParameterExists(paramsMap, paramName);
+    const index = paramValues.push(value);
+    const codecId = columnMeta.type;
+    if (codecId && paramName) {
+      paramCodecs[paramName] = codecId;
+    }
+    paramDescriptors.push(
+      createParamDescriptor({
+        name: paramName,
+        table: tableName,
+        column: columnName,
+        type: codecId,
+        nullable: columnMeta.nullable
+      })
+    );
+    updateSet[columnName] = createParamRef(index, paramName);
+  }
+  const whereResult = buildWhereExpr(
+    wherePredicate,
+    context.contract,
+    paramsMap,
+    paramDescriptors,
+    paramValues
+  );
+  const whereExpr = whereResult.expr;
+  if (!whereExpr) {
+    errorFailedToBuildWhereClause();
+  }
+  if (whereResult?.codecId && whereResult.paramName) {
+    paramCodecs[whereResult.paramName] = whereResult.codecId;
+  }
+  const ast = createUpdateAst({
+    table,
+    set: updateSet,
+    where: whereExpr
+  });
+  return Object.freeze({
+    ast,
+    params: paramValues,
+    meta: {
+      target: context.contract.target,
+      targetFamily: context.contract.targetFamily,
+      coreHash: context.contract.coreHash,
+      lane: "orm",
+      refs: {
+        tables: [tableName],
+        columns: []
+      },
+      projection: {},
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? {
+        annotations: {
+          codecs: paramCodecs,
+          intent: "write",
+          isMutation: true
+        }
+      } : {
+        annotations: {
+          intent: "write",
+          isMutation: true
+        }
+      }
+    }
+  });
+}
+
+// src/orm-include-child.ts
+import { planInvalid as planInvalid2 } from "@prisma-next/plan";
+import { schema } from "@prisma-next/sql-relational-core/schema";
+var OrmIncludeChildBuilderImpl = class _OrmIncludeChildBuilderImpl {
+  context;
+  contract;
+  childModelName;
+  childWhere;
+  childOrderBy;
+  childLimit;
+  childProjection = void 0;
+  constructor(options, childModelName) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.childModelName = childModelName;
+  }
+  where(fn) {
+    const builder = new _OrmIncludeChildBuilderImpl(
+      { context: this.context },
+      this.childModelName
+    );
+    builder.childWhere = fn(this._getModelAccessor());
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = this.childLimit;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+  orderBy(fn) {
+    const builder = new _OrmIncludeChildBuilderImpl(
+      { context: this.context },
+      this.childModelName
+    );
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = fn(this._getModelAccessor());
+    builder.childLimit = this.childLimit;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+  take(n) {
+    const builder = new _OrmIncludeChildBuilderImpl(
+      { context: this.context },
+      this.childModelName
+    );
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = n;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+  select(fn) {
+    const builder = new _OrmIncludeChildBuilderImpl({ context: this.context }, this.childModelName);
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = this.childLimit;
+    builder.childProjection = fn(this._getModelAccessor());
+    return builder;
+  }
+  getState() {
+    return {
+      ...this.childWhere !== void 0 ? { childWhere: this.childWhere } : {},
+      ...this.childOrderBy !== void 0 ? { childOrderBy: this.childOrderBy } : {},
+      ...this.childLimit !== void 0 ? { childLimit: this.childLimit } : {},
+      ...this.childProjection !== void 0 ? { childProjection: this.childProjection } : {}
+    };
+  }
+  _getModelAccessor() {
+    const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
+    if (!tableName) {
+      throw planInvalid2(`Model ${this.childModelName} not found in mappings`);
+    }
+    const schemaHandle = schema(this.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      throw planInvalid2(`Table ${tableName} not found in schema`);
+    }
+    const accessor = {};
+    const model = this.contract.models[this.childModelName];
+    if (!model || typeof model !== "object" || !("fields" in model)) {
+      throw planInvalid2(`Model ${this.childModelName} does not have fields`);
+    }
+    const modelFields = model.fields;
+    for (const fieldName in modelFields) {
+      const field = modelFields[fieldName];
+      if (!field) continue;
+      const columnName = this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ?? field.column ?? fieldName;
+      const column = table.columns[columnName];
+      if (column) {
+        accessor[fieldName] = column;
+      }
+    }
+    return accessor;
+  }
+};
+
+// src/orm-relation-filter.ts
+import { planInvalid as planInvalid3 } from "@prisma-next/plan";
+import { schema as schema2 } from "@prisma-next/sql-relational-core/schema";
+var OrmRelationFilterBuilderImpl = class _OrmRelationFilterBuilderImpl {
+  context;
+  contract;
+  childModelName;
+  wherePredicate = void 0;
+  modelAccessor = void 0;
+  constructor(options, childModelName) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.childModelName = childModelName;
+    this.modelAccessor = this._getModelAccessor();
+  }
+  where(fn) {
+    const builder = new _OrmRelationFilterBuilderImpl(
+      { context: this.context },
+      this.childModelName
+    );
+    builder.modelAccessor = this.modelAccessor;
+    if (this.modelAccessor) {
+      builder.wherePredicate = fn(this.modelAccessor);
+    }
+    return builder;
+  }
+  getWherePredicate() {
+    return this.wherePredicate;
+  }
+  getChildModelName() {
+    return this.childModelName;
+  }
+  getModelAccessor() {
+    if (!this.modelAccessor) {
+      this.modelAccessor = this._getModelAccessor();
+    }
+    if (!this.modelAccessor) {
+      throw planInvalid3(`Failed to get model accessor for ${this.childModelName}`);
+    }
+    return this.modelAccessor;
+  }
+  _getModelAccessor() {
+    const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
+    if (!tableName) {
+      throw planInvalid3(`Model ${this.childModelName} not found in mappings`);
+    }
+    const schemaHandle = schema2(this.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      throw planInvalid3(`Table ${tableName} not found in schema`);
+    }
+    const accessor = {};
+    const model = this.contract.models[this.childModelName];
+    if (!model || typeof model !== "object" || !("fields" in model)) {
+      throw planInvalid3(`Model ${this.childModelName} does not have fields`);
+    }
+    const modelFields = model.fields;
+    for (const fieldName in modelFields) {
+      const field = modelFields[fieldName];
+      if (!field) continue;
+      const columnName = this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ?? field.column ?? fieldName;
+      const column = table.columns[columnName];
+      if (column) {
+        accessor[fieldName] = column;
+      }
+    }
+    return accessor;
+  }
+};
+
+// src/plan/plan-assembly.ts
+import { planInvalid as planInvalid4 } from "@prisma-next/plan";
+import { compact } from "@prisma-next/sql-relational-core/ast";
+
+// src/utils/guards.ts
+function extractBaseColumnRef(expr) {
+  if (expr.kind === "col") {
+    return expr;
+  }
+  return extractBaseColumnRef(expr.self);
+}
+function collectColumnRefs(expr) {
+  if (expr.kind === "col") {
+    return [expr];
+  }
+  if (expr.kind === "operation") {
+    const refs = collectColumnRefs(expr.self);
+    for (const arg of expr.args) {
+      refs.push(...collectColumnRefs(arg));
+    }
+    return refs;
+  }
+  return [];
+}
+function isOperationExpr(expr) {
+  return typeof expr === "object" && expr !== null && "kind" in expr && expr.kind === "operation";
+}
+function getColumnInfo(expr) {
+  if (isOperationExpr(expr)) {
+    const baseCol = extractBaseColumnRef(expr);
+    return { table: baseCol.table, column: baseCol.column };
+  }
+  const colBuilder = expr;
+  return { table: colBuilder.table, column: colBuilder.column };
+}
+function isColumnBuilder(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "column";
+}
+
+// src/plan/plan-assembly.ts
+function buildMeta(args) {
+  const refsColumns = /* @__PURE__ */ new Map();
+  const refsTables = /* @__PURE__ */ new Set([args.table.name]);
+  for (const column of args.projection.columns) {
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column
+        });
+      }
+    } else {
+      const col = column;
+      if (col.table && col.column) {
+        refsColumns.set(`${col.table}.${col.column}`, {
+          table: col.table,
+          column: col.column
+        });
+      }
+    }
+  }
+  if (args.includes) {
+    for (const include of args.includes) {
+      refsTables.add(include.table.name);
+      const onLeft = include.on.left;
+      const onRight = include.on.right;
+      if (onLeft.table && onLeft.column && onRight.table && onRight.column) {
+        refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
+          table: onLeft.table,
+          column: onLeft.column
+        });
+        refsColumns.set(`${onRight.table}.${onRight.column}`, {
+          table: onRight.table,
+          column: onRight.column
+        });
+      }
+      for (const column of include.childProjection.columns) {
+        const col = column;
+        if (col.table && col.column) {
+          refsColumns.set(`${col.table}.${col.column}`, {
+            table: col.table,
+            column: col.column
+          });
+        }
+      }
+      if (include.childWhere) {
+        const colInfo = getColumnInfo(include.childWhere.left);
+        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+          table: colInfo.table,
+          column: colInfo.column
+        });
+      }
+      if (include.childOrderBy) {
+        const orderBy = include.childOrderBy;
+        if (orderBy.expr) {
+          const colInfo = getColumnInfo(orderBy.expr);
+          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+            table: colInfo.table,
+            column: colInfo.column
+          });
+        }
+      }
+    }
+  }
+  if (args.where) {
+    const whereLeft = args.where.left;
+    const operationExpr = whereLeft._operationExpr;
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column
+        });
+      }
+    } else {
+      const colBuilder = whereLeft;
+      if (colBuilder.table && colBuilder.column) {
+        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+          table: colBuilder.table,
+          column: colBuilder.column
+        });
+      }
+    }
+  }
+  if (args.orderBy) {
+    const orderBy = args.orderBy;
+    const orderByExpr = orderBy.expr;
+    if (orderByExpr) {
+      if (isOperationExpr(orderByExpr)) {
+        const allRefs = collectColumnRefs(orderByExpr);
+        for (const ref of allRefs) {
+          refsColumns.set(`${ref.table}.${ref.column}`, {
+            table: ref.table,
+            column: ref.column
+          });
+        }
+      } else {
+        const colBuilder = orderByExpr;
+        if (colBuilder.table && colBuilder.column) {
+          refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+            table: colBuilder.table,
+            column: colBuilder.column
+          });
+        }
+      }
+    }
+  }
+  const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
+  const projectionMap = Object.fromEntries(
+    args.projection.aliases.map((alias, index) => {
+      if (includeAliases.has(alias)) {
+        return [alias, `include:${alias}`];
+      }
+      const column = args.projection.columns[index];
+      if (!column) {
+        throw planInvalid4(`Missing column for alias ${alias} at index ${index}`);
+      }
+      const col = column;
+      if (!col.table || !col.column) {
+        return [alias, `include:${alias}`];
+      }
+      const operationExpr = col._operationExpr;
+      if (operationExpr) {
+        return [alias, `operation:${operationExpr.method}`];
+      }
+      return [alias, `${col.table}.${col.column}`];
+    })
+  );
+  const projectionTypes = {};
+  for (let i = 0; i < args.projection.aliases.length; i++) {
+    const alias = args.projection.aliases[i];
+    if (!alias || includeAliases.has(alias)) {
+      continue;
+    }
+    const col = args.projection.columns[i];
+    if (!col) {
+      continue;
+    }
+    const operationExpr = col._operationExpr;
+    if (operationExpr) {
+      if (operationExpr.returns.kind === "typeId") {
+        projectionTypes[alias] = operationExpr.returns.type;
+      } else if (operationExpr.returns.kind === "builtin") {
+        projectionTypes[alias] = operationExpr.returns.type;
+      }
+    } else {
+      const colMeta = col;
+      const columnMeta = colMeta.columnMeta;
+      if (columnMeta?.type) {
+        projectionTypes[alias] = columnMeta.type;
+      }
+    }
+  }
+  const projectionCodecs = {};
+  for (let i = 0; i < args.projection.aliases.length; i++) {
+    const alias = args.projection.aliases[i];
+    if (!alias || includeAliases.has(alias)) {
+      continue;
+    }
+    const column = args.projection.columns[i];
+    if (!column) {
+      continue;
+    }
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
+      if (operationExpr.returns.kind === "typeId") {
+        projectionCodecs[alias] = operationExpr.returns.type;
+      }
+    } else {
+      const col = column;
+      const columnMeta = col.columnMeta;
+      if (columnMeta?.type) {
+        projectionCodecs[alias] = columnMeta.type;
+      }
+    }
+  }
+  const allCodecs = {
+    ...projectionCodecs,
+    ...args.paramCodecs ? args.paramCodecs : {}
+  };
+  return Object.freeze(
+    compact({
+      target: args.contract.target,
+      targetFamily: args.contract.targetFamily,
+      coreHash: args.contract.coreHash,
+      lane: "dsl",
+      refs: {
+        tables: Array.from(refsTables),
+        columns: Array.from(refsColumns.values())
+      },
+      projection: projectionMap,
+      projectionTypes: Object.keys(projectionTypes).length > 0 ? projectionTypes : void 0,
+      annotations: Object.keys(allCodecs).length > 0 ? Object.freeze({ codecs: Object.freeze(allCodecs) }) : void 0,
+      paramDescriptors: args.paramDescriptors,
+      profileHash: args.contract.profileHash
+    })
+  );
+}
+
+// src/relations/include-plan.ts
+import { compact as compact2 } from "@prisma-next/sql-relational-core/ast";
+import { schema as schema3 } from "@prisma-next/sql-relational-core/schema";
+
+// src/orm/capabilities.ts
+function checkIncludeCapabilities(contract) {
+  const target = contract.target;
+  const capabilities = contract.capabilities;
+  if (!capabilities || !capabilities[target]) {
+    errorIncludeRequiresCapabilities();
+  }
+  const targetCapabilities = capabilities[target];
+  if (capabilities[target]["lateral"] !== true || targetCapabilities["jsonAgg"] !== true) {
+    errorIncludeCapabilitiesNotTrue();
+  }
+}
+
+// src/selection/join.ts
+function buildJoinOnExpr(parentTableName, parentColName, childTableName, childColName) {
+  const leftCol = createColumnRef(parentTableName, parentColName);
+  const rightCol = createColumnRef(childTableName, childColName);
+  return createJoinOnExpr(leftCol, rightCol);
+}
+
+// src/selection/ordering.ts
+function buildOrderByClause(orderBy) {
+  if (!orderBy) {
+    return void 0;
+  }
+  const orderByBuilder = orderBy;
+  const orderExpr = orderByBuilder.expr;
+  const expr = isOperationExpr(orderExpr) ? orderExpr : (() => {
+    const colBuilder = orderExpr;
+    return createColumnRef(colBuilder.table, colBuilder.column);
+  })();
+  return [createOrderByItem(expr, orderByBuilder.dir)];
+}
+function buildChildOrderByClause(orderBy) {
+  if (!orderBy) {
+    return void 0;
+  }
+  const orderByBuilder = orderBy;
+  const orderExpr = orderByBuilder.expr;
+  const expr = (() => {
+    if (isOperationExpr(orderExpr)) {
+      const baseCol = extractBaseColumnRef(orderExpr);
+      return createColumnRef(baseCol.table, baseCol.column);
+    }
+    const colBuilder = orderExpr;
+    return createColumnRef(colBuilder.table, colBuilder.column);
+  })();
+  return [createOrderByItem(expr, orderByBuilder.dir)];
+}
+
+// src/selection/projection.ts
+function generateAlias(path) {
+  if (path.length === 0) {
+    errorAliasPathEmpty();
+  }
+  return path.join("_");
+}
+var AliasTracker = class {
+  aliases = /* @__PURE__ */ new Set();
+  aliasToPath = /* @__PURE__ */ new Map();
+  register(path) {
+    const alias = generateAlias(path);
+    if (this.aliases.has(alias)) {
+      const existingPath = this.aliasToPath.get(alias);
+      errorAliasCollision(path, alias, existingPath);
+    }
+    this.aliases.add(alias);
+    this.aliasToPath.set(alias, path);
+    return alias;
+  }
+  getPath(alias) {
+    return this.aliasToPath.get(alias);
+  }
+  has(alias) {
+    return this.aliases.has(alias);
+  }
+};
+function flattenProjection(projection, tracker, currentPath = []) {
+  const aliases = [];
+  const columns = [];
+  for (const [key, value] of Object.entries(projection)) {
+    const path = [...currentPath, key];
+    if (isColumnBuilder(value)) {
+      const alias = tracker.register(path);
+      aliases.push(alias);
+      columns.push(value);
+    } else if (typeof value === "object" && value !== null) {
+      const nested = flattenProjection(value, tracker, path);
+      aliases.push(...nested.aliases);
+      columns.push(...nested.columns);
+    } else {
+      errorInvalidProjectionValue(path);
+    }
+  }
+  return { aliases, columns };
+}
+function buildProjectionState(_table, projection, includes) {
+  const tracker = new AliasTracker();
+  const aliases = [];
+  const columns = [];
+  for (const [key, value] of Object.entries(projection)) {
+    if (value === true) {
+      const matchingInclude = includes?.find((inc) => inc.alias === key);
+      if (!matchingInclude) {
+        errorIncludeAliasNotFound(key);
+      }
+      aliases.push(key);
+      columns.push({
+        kind: "column",
+        table: matchingInclude.table.name,
+        column: "",
+        columnMeta: { type: "core/json@1", nullable: true }
+      });
+    } else if (isColumnBuilder(value)) {
+      const alias = tracker.register([key]);
+      aliases.push(alias);
+      columns.push(value);
+    } else if (typeof value === "object" && value !== null) {
+      const nested = flattenProjection(value, tracker, [key]);
+      aliases.push(...nested.aliases);
+      columns.push(...nested.columns);
+    } else {
+      errorInvalidProjectionKey(key);
+    }
+  }
+  if (aliases.length === 0) {
+    errorProjectionEmpty();
+  }
+  return { aliases, columns };
+}
+
+// src/relations/include-plan.ts
+function buildIncludeAsts(includes, contract, context, modelName, paramsMap, paramDescriptors, paramValues, paramCodecs) {
+  const includesAst = [];
+  const includesForMeta = [];
+  for (const includeState of includes) {
+    checkIncludeCapabilities(contract);
+    const parentTableName = contract.mappings.modelToTable?.[modelName];
+    if (!parentTableName) {
+      errorModelNotFound(modelName);
+    }
+    const parentSchemaHandle = schema3(context);
+    const parentSchemaTable = parentSchemaHandle.tables[parentTableName];
+    if (!parentSchemaTable) {
+      errorTableNotFound(parentTableName);
+    }
+    const childSchemaHandle = schema3(context);
+    const childSchemaTable = childSchemaHandle.tables[includeState.childTable.name];
+    if (!childSchemaTable) {
+      errorTableNotFound(includeState.childTable.name);
+    }
+    if (includeState.relation.on.parentCols.length !== 1 || includeState.relation.on.childCols.length !== 1) {
+      errorMultiColumnJoinsNotSupported();
+    }
+    const parentColName = includeState.relation.on.parentCols[0];
+    const childColName = includeState.relation.on.childCols[0];
+    if (!parentColName || !childColName) {
+      errorJoinColumnsMustBeDefined();
+    }
+    const parentCol = parentSchemaTable.columns[parentColName];
+    const childCol = childSchemaTable.columns[childColName];
+    if (!parentCol) {
+      errorColumnNotFound(parentColName, parentTableName);
+    }
+    if (!childCol) {
+      errorColumnNotFound(childColName, includeState.childTable.name);
+    }
+    const onExpr = buildJoinOnExpr(
+      parentTableName,
+      parentColName,
+      includeState.childTable.name,
+      childColName
+    );
+    if (!includeState.childProjection) {
+      errorChildProjectionMustBeSpecified();
+    }
+    const filteredProjection = {};
+    for (const [key, value] of Object.entries(includeState.childProjection)) {
+      if (value !== true && value !== false) {
+        filteredProjection[key] = value;
+      }
+    }
+    if (Object.keys(filteredProjection).length === 0) {
+      errorChildProjectionEmpty();
+    }
+    const childProjectionState = buildProjectionState(
+      includeState.childTable,
+      filteredProjection
+    );
+    let childWhere;
+    if (includeState.childWhere) {
+      const whereResult = buildWhereExpr(
+        includeState.childWhere,
+        contract,
+        paramsMap,
+        paramDescriptors,
+        paramValues
+      );
+      childWhere = whereResult.expr;
+      if (whereResult.codecId && whereResult.paramName) {
+        paramCodecs[whereResult.paramName] = whereResult.codecId;
+      }
+    }
+    const childOrderBy = buildChildOrderByClause(includeState.childOrderBy);
+    const childProjectionItems = [];
+    for (let i = 0; i < childProjectionState.aliases.length; i++) {
+      const alias = childProjectionState.aliases[i];
+      if (!alias) {
+        errorMissingAlias(i);
+      }
+      const column = childProjectionState.columns[i];
+      if (!column) {
+        errorMissingColumn(alias, i);
+      }
+      const operationExpr = column._operationExpr;
+      if (operationExpr) {
+        childProjectionItems.push({ alias, expr: operationExpr });
+      } else {
+        const col = column;
+        childProjectionItems.push({ alias, expr: createColumnRef(col.table, col.column) });
+      }
+    }
+    const includeAst = compact2({
+      kind: "includeMany",
+      alias: includeState.alias,
+      child: compact2({
+        table: includeState.childTable,
+        on: onExpr,
+        project: childProjectionItems,
+        where: childWhere,
+        orderBy: childOrderBy,
+        limit: includeState.childLimit
+      })
+    });
+    includesAst.push(includeAst);
+    const includeForMeta = compact2({
+      alias: includeState.alias,
+      table: includeState.childTable,
+      on: {
+        kind: "join-on",
+        left: parentCol,
+        right: childCol
+      },
+      childProjection: childProjectionState,
+      childWhere: includeState.childWhere,
+      childOrderBy: includeState.childOrderBy,
+      childLimit: includeState.childLimit
+    });
+    includesForMeta.push(includeForMeta);
+  }
+  return { includesAst, includesForMeta };
+}
+function buildExistsSubqueries(relationFilters, contract, modelName, options) {
+  const existsExprs = [];
+  for (const filter of relationFilters) {
+    const childTableName = contract.mappings.modelToTable?.[filter.childModelName];
+    if (!childTableName) {
+      errorModelNotFound(filter.childModelName);
+    }
+    const childTable = { kind: "table", name: childTableName };
+    const parentTableName = contract.mappings.modelToTable?.[modelName];
+    if (!parentTableName) {
+      errorModelNotFound(modelName);
+    }
+    const joinConditions = [];
+    for (let i = 0; i < filter.relation.on.parentCols.length; i++) {
+      const parentCol = filter.relation.on.parentCols[i];
+      const childCol = filter.relation.on.childCols[i];
+      if (!parentCol || !childCol) {
+        continue;
+      }
+      joinConditions.push({
+        left: { kind: "col", table: parentTableName, column: parentCol },
+        right: { kind: "col", table: childTableName, column: childCol }
+      });
+    }
+    let childWhere;
+    if (filter.childWhere) {
+      const paramsMap = options?.params ?? {};
+      const paramDescriptors = [];
+      const paramValues = [];
+      const whereResult = buildWhereExpr(
+        filter.childWhere,
+        contract,
+        paramsMap,
+        paramDescriptors,
+        paramValues
+      );
+      childWhere = whereResult.expr;
+    }
+    let subqueryWhere = childWhere;
+    if (joinConditions.length > 0) {
+      const firstJoinCondition = joinConditions[0];
+      if (firstJoinCondition) {
+        const joinWhere = {
+          kind: "bin",
+          op: "eq",
+          left: firstJoinCondition.left,
+          right: firstJoinCondition.right
+        };
+        if (childWhere) {
+          subqueryWhere = joinWhere;
+        } else {
+          subqueryWhere = joinWhere;
+        }
+      }
+    }
+    const projectionColumn = joinConditions[0]?.right ?? createColumnRef(childTableName, "id");
+    const subquery = createSelectAst({
+      from: childTable,
+      project: [{ alias: "_exists", expr: projectionColumn }],
+      where: subqueryWhere
+    });
+    const notExists = filter.filterType === "none" || filter.filterType === "every";
+    const existsExpr = {
+      kind: "exists",
+      subquery,
+      not: notExists
+    };
+    existsExprs.push(existsExpr);
+  }
+  return existsExprs;
+}
+function combineWhereClauses(mainWhere, existsExprs) {
+  if (existsExprs.length === 1) {
+    return existsExprs[0];
+  }
+  if (mainWhere) {
+    return mainWhere;
+  }
+  if (existsExprs.length > 0) {
+    return existsExprs[0];
+  }
+  return void 0;
+}
+
+// src/selection/select-builder.ts
+function buildProjectionItems(projectionState, includesForMeta) {
+  const projectEntries = [];
+  for (let i = 0; i < projectionState.aliases.length; i++) {
+    const alias = projectionState.aliases[i];
+    if (!alias) {
+      errorMissingAlias(i);
+    }
+    const column = projectionState.columns[i];
+    if (!column) {
+      errorMissingColumn(alias, i);
+    }
+    const matchingInclude = includesForMeta.find((inc) => inc.alias === alias);
+    if (matchingInclude) {
+      projectEntries.push({
+        alias,
+        expr: { kind: "includeRef", alias }
+      });
+    } else {
+      const operationExpr = column._operationExpr;
+      if (operationExpr) {
+        projectEntries.push({
+          alias,
+          expr: operationExpr
+        });
+      } else {
+        const col = column;
+        const tableName = col.table;
+        const columnName = col.column;
+        if (!tableName || !columnName) {
+          errorInvalidColumn(alias, i);
+        }
+        projectEntries.push({
+          alias,
+          expr: createColumnRef(tableName, columnName)
+        });
+      }
+    }
+  }
+  return projectEntries;
+}
+function buildSelectAst(table, projectEntries, includesAst, whereExpr, orderByClause, limit) {
+  return createSelectAst({
+    from: createTableRef(table.name),
+    project: projectEntries,
+    includes: includesAst,
+    where: whereExpr,
+    orderBy: orderByClause,
+    limit
+  });
+}
+
+// src/orm/context.ts
+function createOrmContext(context) {
+  return context;
+}
+
+// src/orm/builder.ts
+var OrmModelBuilderImpl = class _OrmModelBuilderImpl {
+  context;
+  contract;
+  modelName;
+  table;
+  wherePredicate = void 0;
+  relationFilters = [];
+  includes = [];
+  orderByExpr = void 0;
+  limitValue = void 0;
+  offsetValue = void 0;
+  projection = void 0;
+  constructor(options, modelName) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.modelName = modelName;
+    const tableName = this.contract.mappings.modelToTable?.[modelName];
+    if (!tableName) {
+      errorModelNotFound(modelName);
+    }
+    const schemaHandle = schema4(options.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      errorTableNotFound(tableName);
+    }
+    this.table = table;
+  }
+  get where() {
+    const whereFn = (fn) => {
+      const builder = new _OrmModelBuilderImpl(
+        { context: this.context },
+        this.modelName
+      );
+      builder["table"] = this.table;
+      builder.wherePredicate = fn(this._getModelAccessor());
+      builder.relationFilters = this.relationFilters;
+      builder.includes = this.includes;
+      builder.orderByExpr = this.orderByExpr;
+      builder.limitValue = this.limitValue;
+      builder.offsetValue = this.offsetValue;
+      builder.projection = this.projection;
+      return builder;
+    };
+    const related = this._createRelatedProxy();
+    return Object.assign(whereFn, { related });
+  }
+  get include() {
+    return this._createIncludeProxy();
+  }
+  _createIncludeProxy() {
+    const self = this;
+    const tableName = this.contract.mappings.modelToTable?.[this.modelName];
+    if (!tableName) {
+      return {};
+    }
+    const modelRelations = this.contract.relations?.[tableName];
+    if (!modelRelations || typeof modelRelations !== "object") {
+      return {};
+    }
+    return new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string") {
+          return void 0;
+        }
+        const relation = modelRelations[prop];
+        if (!relation || typeof relation !== "object" || !("to" in relation)) {
+          throw planInvalid5(`Relation ${prop} not found on model ${self.modelName}`);
+        }
+        const childModelName = relation.to;
+        const relationDef = relation;
+        const relationName = prop;
+        const includeFn = ((child) => {
+          return self._applyInclude(
+            relationName,
+            childModelName,
+            child,
+            relationDef
+          );
+        });
+        return includeFn;
+      }
+    });
+  }
+  _applyInclude(relationName, childModelName, childBuilderFn, relationDef) {
+    const childTableName = this.contract.mappings.modelToTable?.[childModelName];
+    if (!childTableName) {
+      errorModelNotFound(childModelName);
+    }
+    const childTable = { kind: "table", name: childTableName };
+    const childBuilder = new OrmIncludeChildBuilderImpl(
+      { context: this.context },
+      childModelName
+    );
+    const builtChild = childBuilderFn(
+      childBuilder
+    );
+    const childState = builtChild.getState();
+    const includeState = {
+      relationName,
+      childModelName,
+      childTable,
+      childWhere: childState.childWhere,
+      childOrderBy: childState.childOrderBy,
+      childLimit: childState.childLimit,
+      childProjection: childState.childProjection,
+      alias: relationName,
+      relation: relationDef
+    };
+    const builder = new _OrmModelBuilderImpl({ context: this.context }, this.modelName);
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = this.relationFilters;
+    builder.includes = [...this.includes, includeState];
+    builder.orderByExpr = this.orderByExpr;
+    builder.limitValue = this.limitValue;
+    builder.offsetValue = this.offsetValue;
+    builder.projection = this.projection;
+    return builder;
+  }
+  _createRelatedProxy() {
+    const self = this;
+    const tableName = this.contract.mappings.modelToTable?.[this.modelName];
+    if (!tableName) {
+      return {};
+    }
+    const modelRelations = this.contract.relations?.[tableName];
+    if (!modelRelations || typeof modelRelations !== "object") {
+      return {};
+    }
+    return new Proxy(
+      {},
+      {
+        get(_target, prop) {
+          if (typeof prop !== "string") {
+            return void 0;
+          }
+          const relation = modelRelations[prop];
+          if (!relation || typeof relation !== "object" || !("to" in relation)) {
+            throw planInvalid5(`Relation ${prop} not found on model ${self.modelName}`);
+          }
+          const childModelName = relation.to;
+          const relationDef = relation;
+          const filterBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
+          const modelAccessor = filterBuilder.getModelAccessor();
+          const builderWithAccessor = Object.assign(
+            filterBuilder,
+            modelAccessor
+          );
+          return {
+            some: (fn) => {
+              const result = fn(builderWithAccessor);
+              if (result && "kind" in result && result.kind === "binary") {
+                const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
+                wrappedBuilder["wherePredicate"] = result;
+                return self._applyRelationFilter(
+                  prop,
+                  childModelName,
+                  "some",
+                  () => wrappedBuilder,
+                  relationDef
+                );
+              }
+              return self._applyRelationFilter(
+                prop,
+                childModelName,
+                "some",
+                () => result,
+                relationDef
+              );
+            },
+            none: (fn) => {
+              const result = fn(builderWithAccessor);
+              if (result && "kind" in result && result.kind === "binary") {
+                const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
+                wrappedBuilder["wherePredicate"] = result;
+                return self._applyRelationFilter(
+                  prop,
+                  childModelName,
+                  "none",
+                  () => wrappedBuilder,
+                  relationDef
+                );
+              }
+              return self._applyRelationFilter(
+                prop,
+                childModelName,
+                "none",
+                () => result,
+                relationDef
+              );
+            },
+            every: (fn) => {
+              const result = fn(builderWithAccessor);
+              if (result && "kind" in result && result.kind === "binary") {
+                const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
+                wrappedBuilder["wherePredicate"] = result;
+                return self._applyRelationFilter(
+                  prop,
+                  childModelName,
+                  "every",
+                  () => wrappedBuilder,
+                  relationDef
+                );
+              }
+              return self._applyRelationFilter(
+                prop,
+                childModelName,
+                "every",
+                () => result,
+                relationDef
+              );
+            }
+          };
+        }
+      }
+    );
+  }
+  _applyRelationFilter(relationName, childModelName, filterType, fn, relationDef) {
+    const filterBuilder = new OrmRelationFilterBuilderImpl(
+      { context: this.context },
+      childModelName
+    );
+    const appliedFilter = fn(
+      filterBuilder
+    );
+    const childWhere = appliedFilter.getWherePredicate();
+    const relationFilter = {
+      relationName,
+      childModelName,
+      filterType,
+      childWhere,
+      relation: relationDef
+    };
+    const builder = new _OrmModelBuilderImpl(
+      { context: this.context },
+      this.modelName
+    );
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = [...this.relationFilters, relationFilter];
+    builder.includes = this.includes;
+    builder.orderByExpr = this.orderByExpr;
+    builder.limitValue = this.limitValue;
+    builder.offsetValue = this.offsetValue;
+    builder.projection = this.projection;
+    return builder;
+  }
+  orderBy(fn) {
+    const builder = new _OrmModelBuilderImpl(
+      { context: this.context },
+      this.modelName
+    );
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = this.relationFilters;
+    builder.includes = this.includes;
+    builder.orderByExpr = fn(this._getModelAccessor());
+    builder.limitValue = this.limitValue;
+    builder.offsetValue = this.offsetValue;
+    builder.projection = this.projection;
+    return builder;
+  }
+  take(n) {
+    const builder = new _OrmModelBuilderImpl(
+      { context: this.context },
+      this.modelName
+    );
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = this.relationFilters;
+    builder.includes = this.includes;
+    builder.orderByExpr = this.orderByExpr;
+    builder.limitValue = n;
+    builder.offsetValue = this.offsetValue;
+    builder.projection = this.projection;
+    return builder;
+  }
+  skip(n) {
+    const builder = new _OrmModelBuilderImpl(
+      { context: this.context },
+      this.modelName
+    );
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = this.relationFilters;
+    builder.includes = this.includes;
+    builder.orderByExpr = this.orderByExpr;
+    builder.limitValue = this.limitValue;
+    builder.offsetValue = n;
+    builder.projection = this.projection;
+    return builder;
+  }
+  select(fn) {
+    const builder = new _OrmModelBuilderImpl({ context: this.context }, this.modelName);
+    builder["table"] = this.table;
+    builder.wherePredicate = this.wherePredicate;
+    builder.relationFilters = this.relationFilters;
+    builder.includes = this.includes;
+    builder.orderByExpr = this.orderByExpr;
+    builder.limitValue = this.limitValue;
+    builder.offsetValue = this.offsetValue;
+    builder.projection = fn(this._getModelAccessor());
+    return builder;
+  }
+  findMany(options) {
+    const paramsMap = options?.params ?? {};
+    const contractTable = this.contract.storage.tables[this.table.name];
+    if (!contractTable) {
+      errorUnknownTable(this.table.name);
+    }
+    const paramDescriptors = [];
+    const paramValues = [];
+    const paramCodecs = {};
+    const projectionInput = this.projection ?? (() => {
+      const modelAccessor = this._getModelAccessor();
+      const defaultProjection = {};
+      for (const fieldName in modelAccessor) {
+        defaultProjection[fieldName] = modelAccessor[fieldName];
+      }
+      return defaultProjection;
+    })();
+    const { includesAst, includesForMeta } = buildIncludeAsts(
+      this.includes,
+      this.contract,
+      this.context,
+      this.modelName,
+      paramsMap,
+      paramDescriptors,
+      paramValues,
+      paramCodecs
+    );
+    const projectionState = buildProjectionState(
+      this.table,
+      projectionInput,
+      includesForMeta.length > 0 ? includesForMeta : void 0
+    );
+    const whereResult = this.wherePredicate ? buildWhereExpr(this.wherePredicate, this.contract, paramsMap, paramDescriptors, paramValues) : void 0;
+    const whereExpr = whereResult?.expr;
+    if (whereResult?.codecId && whereResult.paramName) {
+      paramCodecs[whereResult.paramName] = whereResult.codecId;
+    }
+    const orderByClause = buildOrderByClause(this.orderByExpr);
+    const projectEntries = buildProjectionItems(projectionState, includesForMeta);
+    const ast = buildSelectAst(
+      this.table,
+      projectEntries,
+      includesAst.length > 0 ? includesAst : void 0,
+      whereExpr,
+      orderByClause,
+      this.limitValue
+    );
+    const planMeta = buildMeta({
+      contract: this.contract,
+      table: createTableRef(this.table.name),
+      projection: projectionState,
+      includes: includesForMeta.length > 0 ? includesForMeta : void 0,
+      paramDescriptors,
+      paramCodecs: Object.keys(paramCodecs).length > 0 ? paramCodecs : void 0,
+      where: this.wherePredicate,
+      orderBy: this.orderByExpr
+    });
+    if (this.relationFilters.length > 0) {
+      const existsExprs = buildExistsSubqueries(
+        this.relationFilters,
+        this.contract,
+        this.modelName,
+        options
+      );
+      if (existsExprs.length > 0) {
+        const combinedWhere = combineWhereClauses(ast.where, existsExprs);
+        const modifiedAst = {
+          ...ast,
+          ...combinedWhere !== void 0 ? { where: combinedWhere } : {}
+        };
+        return Object.freeze({
+          ast: modifiedAst,
+          params: paramValues,
+          meta: {
+            ...planMeta,
+            lane: "orm"
+          }
+        });
+      }
+    }
+    return Object.freeze({
+      ast,
+      params: paramValues,
+      meta: {
+        ...planMeta,
+        lane: "orm"
+      }
+    });
+  }
+  findFirst(options) {
+    const queryPlan = this.take(1).findMany(options);
+    return queryPlan;
+  }
+  findUnique(where, options) {
+    return this.where(where).take(1).findMany(options);
+  }
+  create(data, options) {
+    const context = createOrmContext(this.context);
+    return buildInsertPlan(context, this.modelName, data, options);
+  }
+  update(where, data, options) {
+    const context = createOrmContext(this.context);
+    return buildUpdatePlan(
+      context,
+      this.modelName,
+      where,
+      () => this._getModelAccessor(),
+      data,
+      options
+    );
+  }
+  delete(where, options) {
+    const context = createOrmContext(this.context);
+    return buildDeletePlan(
+      context,
+      this.modelName,
+      where,
+      () => this._getModelAccessor(),
+      options
+    );
+  }
+  _getModelAccessor() {
+    const tableName = this.contract.mappings.modelToTable?.[this.modelName];
+    if (!tableName) {
+      errorModelNotFound(this.modelName);
+    }
+    const schemaHandle = schema4(this.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      errorTableNotFound(tableName);
+    }
+    const accessor = {};
+    const model = this.contract.models[this.modelName];
+    if (!model || typeof model !== "object" || !("fields" in model)) {
+      throw planInvalid5(`Model ${this.modelName} does not have fields`);
+    }
+    const modelFields = model.fields;
+    for (const fieldName in modelFields) {
+      const field = modelFields[fieldName];
+      if (!field) continue;
+      const columnName = this.contract.mappings.fieldToColumn?.[this.modelName]?.[fieldName] ?? field.column ?? fieldName;
+      const column = table.columns[columnName];
+      if (column) {
+        accessor[fieldName] = column;
+      }
+    }
+    return accessor;
+  }
+};
+
+// src/orm.ts
+import { planInvalid as planInvalid6 } from "@prisma-next/plan";
+function orm(options) {
+  const contract = options.context.contract;
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") {
+        return void 0;
+      }
+      const modelName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      if (!contract.models || typeof contract.models !== "object" || !(modelName in contract.models)) {
+        throw planInvalid6(`Model ${prop} (resolved to ${modelName}) not found in contract`);
+      }
+      return () => new OrmModelBuilderImpl(options, modelName);
+    },
+    has(_target, prop) {
+      if (typeof prop !== "string") {
+        return false;
+      }
+      const modelName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      return contract.models && typeof contract.models === "object" && modelName in contract.models;
+    }
+  });
+}
+
+export {
+  OrmModelBuilderImpl,
+  orm
+};
+//# sourceMappingURL=chunk-JOTSRS66.js.map