@prisma-next/sql-orm-lane 0.3.0-pr.93.5 → 0.3.0-pr.94.2

package/dist/chunk-3DNKIXXB.js

@@ -1,1736 +0,0 @@
-// src/orm/builder.ts
-import { planInvalid as planInvalid5 } from "@prisma-next/plan";
-import { schema as schema4 } from "@prisma-next/sql-relational-core/schema";
-
-// src/selection/predicates.ts
-import { augmentDescriptorWithColumnMeta } from "@prisma-next/sql-relational-core/plan";
-import {
-  getColumnInfo,
-  getColumnMeta,
-  getOperationExpr,
-  isColumnBuilder,
-  isParamPlaceholder
-} from "@prisma-next/sql-relational-core/utils/guards";
-
-// 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) {
-  let leftExpr;
-  let codecId;
-  let rightExpr;
-  let paramName;
-  const operationExpr = getOperationExpr(where.left);
-  if (operationExpr) {
-    leftExpr = operationExpr;
-  } else if (isColumnBuilder(where.left)) {
-    const { table, column } = getColumnInfo(where.left);
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-    const columnMeta = contractTable.columns[column];
-    if (columnMeta) {
-      codecId = columnMeta.codecId;
-    }
-    leftExpr = createColumnRef(table, column);
-  } else {
-    errorFailedToBuildWhereClause();
-  }
-  if (isParamPlaceholder(where.right)) {
-    const placeholder = where.right;
-    paramName = placeholder.name;
-    if (!Object.hasOwn(paramsMap, paramName)) {
-      errorMissingParameter(paramName);
-    }
-    const value = paramsMap[paramName];
-    const index = values.push(value);
-    if (isColumnBuilder(where.left)) {
-      const { table, column } = getColumnInfo(where.left);
-      const contractTable = contract.storage.tables[table];
-      const columnMeta = contractTable?.columns[column];
-      const builderColumnMeta = getColumnMeta(where.left);
-      descriptors.push({
-        name: paramName,
-        source: "dsl",
-        refs: { table, column },
-        ...typeof builderColumnMeta?.nullable === "boolean" ? { nullable: builderColumnMeta.nullable } : {}
-      });
-      augmentDescriptorWithColumnMeta(descriptors, columnMeta);
-    }
-    rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right)) {
-    const { table, column } = getColumnInfo(where.right);
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-    rightExpr = createColumnRef(table, column);
-    paramName = "";
-  } else {
-    errorFailedToBuildWhereClause();
-  }
-  return {
-    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
-    ...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.codecId ? { codecId: args.codecId } : {},
-    ...args.nativeType ? { nativeType: args.nativeType } : {},
-    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.codecId;
-    if (paramName) {
-      paramCodecs[paramName] = codecId;
-    }
-    paramDescriptors.push(
-      createParamDescriptor({
-        name: paramName,
-        table: tableName,
-        column: columnName,
-        codecId,
-        nativeType: columnMeta.nativeType,
-        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.codecId;
-    if (paramName) {
-      paramCodecs[paramName] = codecId;
-    }
-    paramDescriptors.push(
-      createParamDescriptor({
-        name: paramName,
-        table: tableName,
-        column: columnName,
-        codecId,
-        nativeType: columnMeta.nativeType,
-        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";
-import {
-  collectColumnRefs,
-  getColumnInfo as getColumnInfo2,
-  getColumnMeta as getColumnMeta2,
-  isOperationExpr
-} from "@prisma-next/sql-relational-core/utils/guards";
-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 = getColumnInfo2(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 = getColumnInfo2(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 columnMeta = getColumnMeta2(col);
-      const codecId = columnMeta?.codecId;
-      if (codecId) {
-        projectionTypes[alias] = codecId;
-      }
-    }
-  }
-  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 columnMeta = getColumnMeta2(column);
-      const codecId = columnMeta?.codecId;
-      if (codecId) {
-        projectionCodecs[alias] = codecId;
-      }
-    }
-  }
-  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
-import {
-  extractBaseColumnRef,
-  isOperationExpr as isOperationExpr2
-} from "@prisma-next/sql-relational-core/utils/guards";
-function buildOrderByClause(orderBy) {
-  if (!orderBy) {
-    return void 0;
-  }
-  const orderByBuilder = orderBy;
-  const orderExpr = orderByBuilder.expr;
-  const expr = isOperationExpr2(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 (isOperationExpr2(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
-import { isColumnBuilder as isColumnBuilder2 } from "@prisma-next/sql-relational-core/utils/guards";
-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 (isColumnBuilder2(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: {
-          nativeType: "jsonb",
-          codecId: "core/json@1",
-          nullable: true
-        }
-      });
-    } else if (isColumnBuilder2(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(input) {
-  const {
-    includes,
-    contract,
-    context,
-    modelName,
-    paramsMap,
-    paramDescriptors,
-    paramValues,
-    paramCodecs
-  } = input;
-  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(params) {
-  const { table, projectEntries, includesAst, whereExpr, orderByClause, limit } = params;
-  return createSelectAst({
-    from: createTableRef(table.name),
-    project: projectEntries,
-    ...includesAst ? { includes: includesAst } : {},
-    ...whereExpr ? { where: whereExpr } : {},
-    ...orderByClause ? { orderBy: orderByClause } : {},
-    ...limit !== void 0 ? { 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({
-      includes: this.includes,
-      contract: this.contract,
-      context: this.context,
-      modelName: 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({
-      table: this.table,
-      projectEntries,
-      ...includesAst.length > 0 ? { includesAst } : {},
-      ...whereExpr ? { whereExpr } : {},
-      ...orderByClause ? { orderByClause } : {},
-      ...this.limitValue !== void 0 ? { limit: 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-3DNKIXXB.js.map