@prisma-next/sql-lane 0.0.1

package/dist/chunk-5OSV5CZC.js

@@ -0,0 +1,1545 @@
+// src/raw.ts
+import { planInvalid } from "@prisma-next/plan";
+var POSTGRES_TARGET = "postgres";
+var RAW_OPTIONS_SENTINEL = Symbol("rawOptions");
+function createRawFactory(contract) {
+  if (contract.target !== POSTGRES_TARGET) {
+    throw planInvalid("Raw lane currently supports only postgres target", {
+      expectedTarget: POSTGRES_TARGET,
+      actualTarget: contract.target
+    });
+  }
+  const factory = ((first, ...rest) => {
+    if (isTemplateInvocation(first)) {
+      const { values, options: options2 } = splitTemplateValues(rest);
+      const compiled = compileTemplateToPositional(first, values);
+      return buildRawPlan({
+        contract,
+        sql: compiled.sql,
+        params: compiled.params,
+        paramDescriptors: compiled.paramDescriptors,
+        ...options2 ? { options: options2 } : {}
+      });
+    }
+    const text = first;
+    const [options] = rest;
+    if (!options) {
+      throw planInvalid("Function form requires params option");
+    }
+    if (!Array.isArray(options.params)) {
+      throw planInvalid("Function form params must be an array");
+    }
+    const paramDescriptors = buildSequentialDescriptors(options.params.length);
+    return buildRawPlan({
+      contract,
+      sql: text,
+      params: options.params,
+      paramDescriptors,
+      options
+    });
+  });
+  factory.with = (options) => {
+    return ((strings, ...values) => {
+      const compiled = compileTemplateToPositional(strings, values);
+      return buildRawPlan({
+        contract,
+        sql: compiled.sql,
+        params: compiled.params,
+        paramDescriptors: compiled.paramDescriptors,
+        options
+      });
+    });
+  };
+  return factory;
+}
+function compileTemplateToPositional(strings, values) {
+  let sql2 = "";
+  const params = [];
+  const paramDescriptors = [];
+  strings.forEach((part, index) => {
+    sql2 += part;
+    if (index < values.length) {
+      const value = values[index];
+      const placeholderIndex = params.push(value);
+      sql2 += `$${placeholderIndex}`;
+      paramDescriptors.push({
+        index: placeholderIndex,
+        name: `p${placeholderIndex}`,
+        source: "raw"
+      });
+    }
+  });
+  return {
+    sql: sql2,
+    params,
+    paramDescriptors
+  };
+}
+function buildRawPlan(args) {
+  const params = Array.from(args.params);
+  const descriptors = args.paramDescriptors.map(
+    (descriptor) => Object.freeze({ ...descriptor, source: "raw" })
+  );
+  const meta = buildRawMeta({
+    contract: args.contract,
+    paramDescriptors: descriptors,
+    ...args.options ? { options: args.options } : {}
+  });
+  return Object.freeze({
+    sql: args.sql,
+    params: Object.freeze(params),
+    meta
+  });
+}
+function buildRawMeta(args) {
+  const { contract, paramDescriptors, options } = args;
+  const meta = {
+    target: POSTGRES_TARGET,
+    ...contract.targetFamily ? { targetFamily: contract.targetFamily } : {},
+    coreHash: contract.coreHash,
+    ...contract.profileHash !== void 0 ? { profileHash: contract.profileHash } : {},
+    lane: "raw",
+    paramDescriptors: Object.freeze([...paramDescriptors]),
+    ...options?.annotations ? { annotations: Object.freeze({ ...options.annotations }) } : {},
+    ...options?.refs ? { refs: freezeRefs(options.refs) } : {},
+    ...options?.projection ? { projection: Object.freeze([...options.projection]) } : {}
+  };
+  return Object.freeze(meta);
+}
+function freezeRefs(refs) {
+  return Object.freeze({
+    ...refs.tables ? { tables: Object.freeze([...refs.tables]) } : {},
+    ...refs.columns ? {
+      columns: Object.freeze(
+        refs.columns.map((col) => Object.freeze({ ...col }))
+      )
+    } : {},
+    ...refs.indexes ? {
+      indexes: Object.freeze(
+        refs.indexes.map(
+          (index) => Object.freeze({
+            ...index,
+            columns: Object.freeze([...index.columns])
+          })
+        )
+      )
+    } : {}
+  });
+}
+function buildSequentialDescriptors(count) {
+  return Array.from(
+    { length: count },
+    (_, idx) => Object.freeze({
+      index: idx + 1,
+      name: `p${idx + 1}`,
+      source: "raw"
+    })
+  );
+}
+function isTemplateInvocation(value) {
+  return Array.isArray(value) && Object.hasOwn(value, "raw");
+}
+function rawOptions(options) {
+  return Object.freeze({
+    [RAW_OPTIONS_SENTINEL]: true,
+    value: options
+  });
+}
+function splitTemplateValues(values) {
+  if (values.length === 0) {
+    return { values };
+  }
+  const last = values[values.length - 1];
+  if (!isOptionsSentinel(last)) {
+    return { values };
+  }
+  return {
+    values: values.slice(0, values.length - 1),
+    options: last.value
+  };
+}
+function isOptionsSentinel(value) {
+  return typeof value === "object" && value !== null && RAW_OPTIONS_SENTINEL in value;
+}
+
+// src/sql/builder.ts
+import { createJoinOnBuilder as createJoinOnBuilder2 } from "@prisma-next/sql-relational-core/ast";
+
+// src/sql/mutation-builder.ts
+import {
+  createColumnRef as createColumnRef2,
+  createDeleteAst,
+  createInsertAst,
+  createParamRef as createParamRef2,
+  createTableRef,
+  createUpdateAst
+} from "@prisma-next/sql-relational-core/ast";
+
+// src/utils/errors.ts
+import { planInvalid as planInvalid2 } from "@prisma-next/plan";
+function errorAliasPathEmpty() {
+  throw planInvalid2("Alias path cannot be empty");
+}
+function errorAliasCollision(path, alias, existingPath) {
+  throw planInvalid2(
+    `Alias collision: path ${path.join(".")} would generate alias "${alias}" which conflicts with path ${existingPath?.join(".") ?? "unknown"}`
+  );
+}
+function errorLimitMustBeNonNegativeInteger() {
+  throw planInvalid2("Limit must be a non-negative integer");
+}
+function errorChildProjectionMustBeSpecified() {
+  throw planInvalid2("Child projection must be specified");
+}
+function errorIncludeRequiresCapabilities(target) {
+  throw planInvalid2(
+    "includeMany requires lateral and jsonAgg capabilities",
+    target ? { target } : void 0,
+    [
+      "Enable capabilities for your target in contract.capabilities[target]",
+      "For SQL includes, set both 'lateral' and 'jsonAgg' to true",
+      "If your database lacks lateral/json_agg, use explicit joins + group aggregates"
+    ],
+    [
+      "docs/Architecture Overview.md",
+      "docs/reference/extensions-glossary.md",
+      "packages/targets/postgres-adapter/README.md"
+    ]
+  );
+}
+function errorIncludeCapabilitiesNotTrue(target, values) {
+  throw planInvalid2(
+    "includeMany requires lateral and jsonAgg capabilities to be true",
+    target ? { target, values } : void 0,
+    [
+      "Set contract.capabilities[target].lateral = true and .jsonAgg = true",
+      "If the target does not support these, avoid includeMany and compose a two-step plan"
+    ],
+    [
+      "docs/Architecture Overview.md",
+      "docs/reference/extensions-glossary.md",
+      "packages/targets/postgres-adapter/README.md"
+    ]
+  );
+}
+function errorUnknownTable(tableName) {
+  throw planInvalid2(`Unknown table ${tableName}`);
+}
+function errorSelfJoinNotSupported() {
+  throw planInvalid2("Self-joins are not supported in MVP");
+}
+function errorChildProjectionEmpty() {
+  throw planInvalid2("Child projection must not be empty");
+}
+function errorIncludeAliasCollision(alias, type) {
+  throw planInvalid2(
+    `Alias collision: include alias "${alias}" conflicts with existing ${type} alias`
+  );
+}
+function errorMissingColumnForAlias(alias, index) {
+  throw planInvalid2(`Missing column for alias ${alias ?? "unknown"} at index ${index}`);
+}
+function errorMissingAlias(index) {
+  throw planInvalid2(`Missing alias at index ${index}`);
+}
+function errorInvalidColumnForAlias(alias, index) {
+  throw planInvalid2(`Invalid column for alias ${alias} at index ${index}`);
+}
+function errorFromMustBeCalled() {
+  throw planInvalid2("from() must be called before building a query");
+}
+function errorSelectMustBeCalled() {
+  throw planInvalid2("select() must be called before build()");
+}
+function errorMissingParameter(paramName) {
+  throw planInvalid2(`Missing value for parameter ${paramName}`);
+}
+function errorInvalidProjectionValue(path) {
+  throw planInvalid2(
+    `Invalid projection value at path ${path.join(".")}: expected ColumnBuilder or nested object`
+  );
+}
+function errorIncludeAliasNotFound(alias) {
+  throw planInvalid2(
+    `Include alias "${alias}" not found. Did you call includeMany() with alias "${alias}"?`
+  );
+}
+function errorInvalidProjectionKey(key) {
+  throw planInvalid2(
+    `Invalid projection value at key "${key}": expected ColumnBuilder, boolean true (for includes), or nested object`
+  );
+}
+function errorProjectionEmpty() {
+  throw planInvalid2("select() requires at least one column or include");
+}
+function errorReturningRequiresCapability(target) {
+  throw planInvalid2(
+    "returning() requires returning capability",
+    target ? { target } : void 0,
+    [
+      "Enable 'returning' for your target in contract.capabilities[target]",
+      "PostgreSQL supports RETURNING; MySQL does not",
+      "If unsupported, remove returning() and fetch with a follow-up select()"
+    ],
+    [
+      "docs/Architecture Overview.md",
+      "docs/reference/extensions-glossary.md",
+      "packages/targets/postgres-adapter/README.md"
+    ]
+  );
+}
+function errorReturningCapabilityNotTrue(target, value) {
+  throw planInvalid2(
+    "returning() requires returning capability to be true",
+    target ? { target, value } : void 0,
+    [
+      "Set contract.capabilities[target].returning = true",
+      "If your database/adapter cannot support RETURNING, remove returning() and select after"
+    ],
+    [
+      "docs/Architecture Overview.md",
+      "docs/reference/extensions-glossary.md",
+      "packages/targets/postgres-adapter/README.md"
+    ]
+  );
+}
+function errorUnknownColumn(columnName, tableName) {
+  throw planInvalid2(`Unknown column ${columnName} in table ${tableName}`);
+}
+function errorWhereMustBeCalledForUpdate() {
+  throw planInvalid2("where() must be called before building an UPDATE query");
+}
+function errorFailedToBuildWhereClause() {
+  throw planInvalid2("Failed to build WHERE clause");
+}
+function errorWhereMustBeCalledForDelete() {
+  throw planInvalid2("where() must be called before building a DELETE query");
+}
+
+// src/utils/capabilities.ts
+function checkIncludeCapabilities(contract) {
+  const target = contract.target;
+  const contractCapabilities = contract.capabilities;
+  const declaredTargetCapabilities = contractCapabilities?.[target];
+  if (!contractCapabilities || !declaredTargetCapabilities) {
+    errorIncludeRequiresCapabilities(target);
+  }
+  if (declaredTargetCapabilities["lateral"] !== true || declaredTargetCapabilities["jsonAgg"] !== true) {
+    errorIncludeCapabilitiesNotTrue(target, {
+      lateral: declaredTargetCapabilities["lateral"],
+      jsonAgg: declaredTargetCapabilities["jsonAgg"]
+    });
+  }
+}
+function checkReturningCapability(contract) {
+  const target = contract.target;
+  const capabilities = contract.capabilities;
+  if (!capabilities || !capabilities[target]) {
+    errorReturningRequiresCapability(target);
+  }
+  const targetCapabilities = capabilities[target];
+  if (targetCapabilities["returning"] !== true) {
+    errorReturningCapabilityNotTrue(target, targetCapabilities["returning"]);
+  }
+}
+
+// src/sql/plan.ts
+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/sql/plan.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.joins) {
+    for (const join of args.joins) {
+      refsTables.add(join.table.name);
+      const onLeft = join.on.left;
+      const onRight = join.on.right;
+      refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
+        table: onLeft.table,
+        column: onLeft.column
+      });
+      refsColumns.set(`${onRight.table}.${onRight.column}`, {
+        table: onRight.table,
+        column: onRight.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) {
+        errorMissingColumnForAlias(alias, 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 column = args.projection.columns[i];
+    if (!column) {
+      continue;
+    }
+    const operationExpr = column._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 col = column;
+      const columnMeta = col.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/sql/predicate-builder.ts
+import {
+  createBinaryExpr,
+  createColumnRef,
+  createParamRef
+} from "@prisma-next/sql-relational-core/ast";
+function buildWhereExpr(contract, where, 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);
+  }
+  const rightParam = createParamRef(index, paramName);
+  return {
+    expr: createBinaryExpr("eq", leftExpr, rightParam),
+    ...codecId ? { codecId } : {},
+    paramName
+  };
+}
+
+// src/sql/mutation-builder.ts
+var InsertBuilderImpl = class _InsertBuilderImpl {
+  contract;
+  context;
+  table;
+  values;
+  returningColumns = [];
+  constructor(options, table, values) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.table = table;
+    this.values = values;
+  }
+  returning(...columns) {
+    checkReturningCapability(this.contract);
+    const builder = new _InsertBuilderImpl(
+      {
+        context: this.context
+      },
+      this.table,
+      this.values
+    );
+    builder.returningColumns = [...this.returningColumns, ...columns];
+    return builder;
+  }
+  build(options) {
+    const paramsMap = options?.params ?? {};
+    const paramDescriptors = [];
+    const paramValues = [];
+    const paramCodecs = {};
+    const contractTable = this.contract.storage.tables[this.table.name];
+    if (!contractTable) {
+      errorUnknownTable(this.table.name);
+    }
+    const values = {};
+    for (const [columnName, placeholder] of Object.entries(this.values)) {
+      if (!contractTable.columns[columnName]) {
+        errorUnknownColumn(columnName, this.table.name);
+      }
+      const paramName = placeholder.name;
+      if (!Object.hasOwn(paramsMap, paramName)) {
+        errorMissingParameter(paramName);
+      }
+      const value = paramsMap[paramName];
+      const index = paramValues.push(value);
+      const columnMeta = contractTable.columns[columnName];
+      const codecId = columnMeta?.type;
+      if (codecId && paramName) {
+        paramCodecs[paramName] = codecId;
+      }
+      paramDescriptors.push({
+        name: paramName,
+        source: "dsl",
+        refs: { table: this.table.name, column: columnName },
+        ...codecId ? { type: codecId } : {},
+        ...columnMeta?.nullable !== void 0 ? { nullable: columnMeta.nullable } : {}
+      });
+      values[columnName] = createParamRef2(index, paramName);
+    }
+    const returning = this.returningColumns.map((col) => {
+      const c = col;
+      return createColumnRef2(c.table, c.column);
+    });
+    const ast = createInsertAst({
+      table: createTableRef(this.table.name),
+      values,
+      returning
+    });
+    const returningProjection = {
+      aliases: this.returningColumns.map((col) => {
+        const c = col;
+        return c.column;
+      }),
+      columns: this.returningColumns
+    };
+    const planMeta = buildMeta({
+      contract: this.contract,
+      table: this.table,
+      projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {}
+    });
+    const queryPlan = Object.freeze({
+      ast,
+      params: paramValues,
+      meta: {
+        ...planMeta,
+        lane: "dsl",
+        annotations: {
+          ...planMeta.annotations,
+          intent: "write",
+          isMutation: true
+        }
+      }
+    });
+    return queryPlan;
+  }
+};
+var UpdateBuilderImpl = class _UpdateBuilderImpl {
+  contract;
+  context;
+  table;
+  set;
+  wherePredicate;
+  returningColumns = [];
+  constructor(options, table, set) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.table = table;
+    this.set = set;
+  }
+  where(predicate) {
+    const builder = new _UpdateBuilderImpl(
+      {
+        context: this.context
+      },
+      this.table,
+      this.set
+    );
+    builder.wherePredicate = predicate;
+    builder.returningColumns = [...this.returningColumns];
+    return builder;
+  }
+  returning(...columns) {
+    checkReturningCapability(this.contract);
+    const builder = new _UpdateBuilderImpl(
+      {
+        context: this.context
+      },
+      this.table,
+      this.set
+    );
+    if (this.wherePredicate) {
+      builder.wherePredicate = this.wherePredicate;
+    }
+    builder.returningColumns = [...this.returningColumns, ...columns];
+    return builder;
+  }
+  build(options) {
+    if (!this.wherePredicate) {
+      errorWhereMustBeCalledForUpdate();
+    }
+    const paramsMap = options?.params ?? {};
+    const paramDescriptors = [];
+    const paramValues = [];
+    const paramCodecs = {};
+    const contractTable = this.contract.storage.tables[this.table.name];
+    if (!contractTable) {
+      errorUnknownTable(this.table.name);
+    }
+    const set = {};
+    for (const [columnName, placeholder] of Object.entries(this.set)) {
+      if (!contractTable.columns[columnName]) {
+        errorUnknownColumn(columnName, this.table.name);
+      }
+      const paramName = placeholder.name;
+      if (!Object.hasOwn(paramsMap, paramName)) {
+        errorMissingParameter(paramName);
+      }
+      const value = paramsMap[paramName];
+      const index = paramValues.push(value);
+      const columnMeta = contractTable.columns[columnName];
+      const codecId = columnMeta?.type;
+      if (codecId && paramName) {
+        paramCodecs[paramName] = codecId;
+      }
+      paramDescriptors.push({
+        name: paramName,
+        source: "dsl",
+        refs: { table: this.table.name, column: columnName },
+        ...codecId ? { type: codecId } : {},
+        ...columnMeta?.nullable !== void 0 ? { nullable: columnMeta.nullable } : {}
+      });
+      set[columnName] = createParamRef2(index, paramName);
+    }
+    const whereResult = buildWhereExpr(
+      this.contract,
+      this.wherePredicate,
+      paramsMap,
+      paramDescriptors,
+      paramValues
+    );
+    const whereExpr = whereResult.expr;
+    if (!whereExpr) {
+      errorFailedToBuildWhereClause();
+    }
+    if (whereResult.codecId && whereResult.paramName) {
+      paramCodecs[whereResult.paramName] = whereResult.codecId;
+    }
+    const returning = this.returningColumns.map((col) => {
+      const c = col;
+      return createColumnRef2(c.table, c.column);
+    });
+    const ast = createUpdateAst({
+      table: createTableRef(this.table.name),
+      set,
+      where: whereExpr,
+      returning
+    });
+    const returningProjection = {
+      aliases: this.returningColumns.map((col) => {
+        const c = col;
+        return c.column;
+      }),
+      columns: this.returningColumns
+    };
+    const planMeta = buildMeta({
+      contract: this.contract,
+      table: this.table,
+      projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {},
+      where: this.wherePredicate
+    });
+    const queryPlan = Object.freeze({
+      ast,
+      params: paramValues,
+      meta: {
+        ...planMeta,
+        lane: "dsl",
+        annotations: {
+          ...planMeta.annotations,
+          intent: "write",
+          isMutation: true,
+          hasWhere: true
+        }
+      }
+    });
+    return queryPlan;
+  }
+};
+var DeleteBuilderImpl = class _DeleteBuilderImpl {
+  contract;
+  context;
+  table;
+  wherePredicate;
+  returningColumns = [];
+  constructor(options, table) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.table = table;
+  }
+  where(predicate) {
+    const builder = new _DeleteBuilderImpl(
+      {
+        context: this.context
+      },
+      this.table
+    );
+    builder.wherePredicate = predicate;
+    builder.returningColumns = [...this.returningColumns];
+    return builder;
+  }
+  returning(...columns) {
+    checkReturningCapability(this.contract);
+    const builder = new _DeleteBuilderImpl(
+      {
+        context: this.context
+      },
+      this.table
+    );
+    if (this.wherePredicate) {
+      builder.wherePredicate = this.wherePredicate;
+    }
+    builder.returningColumns = [...this.returningColumns, ...columns];
+    return builder;
+  }
+  build(options) {
+    if (!this.wherePredicate) {
+      errorWhereMustBeCalledForDelete();
+    }
+    const paramsMap = options?.params ?? {};
+    const paramDescriptors = [];
+    const paramValues = [];
+    const paramCodecs = {};
+    const contractTable = this.contract.storage.tables[this.table.name];
+    if (!contractTable) {
+      errorUnknownTable(this.table.name);
+    }
+    const whereResult = buildWhereExpr(
+      this.contract,
+      this.wherePredicate,
+      paramsMap,
+      paramDescriptors,
+      paramValues
+    );
+    const whereExpr = whereResult.expr;
+    if (!whereExpr) {
+      errorFailedToBuildWhereClause();
+    }
+    if (whereResult.codecId && whereResult.paramName) {
+      paramCodecs[whereResult.paramName] = whereResult.codecId;
+    }
+    const returning = this.returningColumns.map((col) => {
+      const c = col;
+      return createColumnRef2(c.table, c.column);
+    });
+    const ast = createDeleteAst({
+      table: createTableRef(this.table.name),
+      where: whereExpr,
+      returning
+    });
+    const returningProjection = {
+      aliases: this.returningColumns.map((col) => {
+        const c = col;
+        return c.column;
+      }),
+      columns: this.returningColumns
+    };
+    const planMeta = buildMeta({
+      contract: this.contract,
+      table: this.table,
+      projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
+      paramDescriptors,
+      ...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {},
+      where: this.wherePredicate
+    });
+    const queryPlan = Object.freeze({
+      ast,
+      params: paramValues,
+      meta: {
+        ...planMeta,
+        lane: "dsl",
+        annotations: {
+          ...planMeta.annotations,
+          intent: "write",
+          isMutation: true,
+          hasWhere: true
+        }
+      }
+    });
+    return queryPlan;
+  }
+};
+
+// src/sql/select-builder.ts
+import {
+  createColumnRef as createColumnRef5,
+  createJoinOnBuilder,
+  createOrderByItem as createOrderByItem2,
+  createSelectAst,
+  createTableRef as createTableRef4
+} from "@prisma-next/sql-relational-core/ast";
+
+// src/sql/include-builder.ts
+import {
+  createColumnRef as createColumnRef3,
+  createJoinOnExpr,
+  createOrderByItem,
+  createTableRef as createTableRef2
+} from "@prisma-next/sql-relational-core/ast";
+
+// src/sql/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/sql/include-builder.ts
+var IncludeChildBuilderImpl = class _IncludeChildBuilderImpl {
+  contract;
+  codecTypes;
+  table;
+  childProjection;
+  childWhere;
+  childOrderBy;
+  childLimit;
+  constructor(contract, codecTypes, table) {
+    this.contract = contract;
+    this.codecTypes = codecTypes;
+    this.table = table;
+  }
+  select(projection) {
+    const projectionState = buildProjectionState(this.table, projection);
+    const builder = new _IncludeChildBuilderImpl(this.contract, this.codecTypes, this.table);
+    builder.childProjection = projectionState;
+    if (this.childWhere !== void 0) {
+      builder.childWhere = this.childWhere;
+    }
+    if (this.childOrderBy !== void 0) {
+      builder.childOrderBy = this.childOrderBy;
+    }
+    if (this.childLimit !== void 0) {
+      builder.childLimit = this.childLimit;
+    }
+    return builder;
+  }
+  where(expr) {
+    const builder = new _IncludeChildBuilderImpl(
+      this.contract,
+      this.codecTypes,
+      this.table
+    );
+    if (this.childProjection !== void 0) {
+      builder.childProjection = this.childProjection;
+    }
+    builder.childWhere = expr;
+    if (this.childOrderBy !== void 0) {
+      builder.childOrderBy = this.childOrderBy;
+    }
+    if (this.childLimit !== void 0) {
+      builder.childLimit = this.childLimit;
+    }
+    return builder;
+  }
+  orderBy(order) {
+    const builder = new _IncludeChildBuilderImpl(
+      this.contract,
+      this.codecTypes,
+      this.table
+    );
+    if (this.childProjection !== void 0) {
+      builder.childProjection = this.childProjection;
+    }
+    if (this.childWhere !== void 0) {
+      builder.childWhere = this.childWhere;
+    }
+    builder.childOrderBy = order;
+    if (this.childLimit !== void 0) {
+      builder.childLimit = this.childLimit;
+    }
+    return builder;
+  }
+  limit(count) {
+    if (!Number.isInteger(count) || count < 0) {
+      errorLimitMustBeNonNegativeInteger();
+    }
+    const builder = new _IncludeChildBuilderImpl(
+      this.contract,
+      this.codecTypes,
+      this.table
+    );
+    if (this.childProjection !== void 0) {
+      builder.childProjection = this.childProjection;
+    }
+    if (this.childWhere !== void 0) {
+      builder.childWhere = this.childWhere;
+    }
+    if (this.childOrderBy !== void 0) {
+      builder.childOrderBy = this.childOrderBy;
+    }
+    builder.childLimit = count;
+    return builder;
+  }
+  getState() {
+    if (!this.childProjection) {
+      errorChildProjectionMustBeSpecified();
+    }
+    const state = {
+      childProjection: this.childProjection
+    };
+    if (this.childWhere !== void 0) {
+      state.childWhere = this.childWhere;
+    }
+    if (this.childOrderBy !== void 0) {
+      state.childOrderBy = this.childOrderBy;
+    }
+    if (this.childLimit !== void 0) {
+      state.childLimit = this.childLimit;
+    }
+    return state;
+  }
+};
+function buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramValues) {
+  const childOrderBy = include.childOrderBy ? (() => {
+    const orderBy = include.childOrderBy;
+    const orderExpr = orderBy.expr;
+    const expr = (() => {
+      if (isOperationExpr(orderExpr)) {
+        const baseCol = extractBaseColumnRef(orderExpr);
+        return createColumnRef3(baseCol.table, baseCol.column);
+      }
+      const colBuilder = orderExpr;
+      return createColumnRef3(colBuilder.table, colBuilder.column);
+    })();
+    return [createOrderByItem(expr, orderBy.dir)];
+  })() : void 0;
+  let childWhere;
+  if (include.childWhere) {
+    const whereResult = buildWhereExpr(
+      contract,
+      include.childWhere,
+      paramsMap,
+      paramDescriptors,
+      paramValues
+    );
+    childWhere = whereResult.expr;
+  }
+  const onLeft = include.on.left;
+  const onRight = include.on.right;
+  const leftCol = createColumnRef3(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef3(onRight.table, onRight.column);
+  const onExpr = createJoinOnExpr(leftCol, rightCol);
+  return {
+    kind: "includeMany",
+    alias: include.alias,
+    child: {
+      table: createTableRef2(include.table.name),
+      on: onExpr,
+      ...childWhere ? { where: childWhere } : {},
+      ...childOrderBy ? { orderBy: childOrderBy } : {},
+      ...typeof include.childLimit === "number" ? { limit: include.childLimit } : {},
+      project: include.childProjection.aliases.map((alias, idx) => {
+        const column = include.childProjection.columns[idx];
+        if (!column || !alias) {
+          errorMissingColumnForAlias(alias ?? "unknown", idx);
+        }
+        const col = column;
+        return {
+          alias,
+          expr: createColumnRef3(col.table, col.column)
+        };
+      })
+    }
+  };
+}
+
+// src/sql/join-builder.ts
+import {
+  createColumnRef as createColumnRef4,
+  createJoin,
+  createJoinOnExpr as createJoinOnExpr2,
+  createTableRef as createTableRef3
+} from "@prisma-next/sql-relational-core/ast";
+function buildJoinAst(join) {
+  const onLeft = join.on.left;
+  const onRight = join.on.right;
+  const leftCol = createColumnRef4(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef4(onRight.table, onRight.column);
+  const onExpr = createJoinOnExpr2(leftCol, rightCol);
+  return createJoin(join.joinType, createTableRef3(join.table.name), onExpr);
+}
+
+// src/sql/select-builder.ts
+var SelectBuilderImpl = class _SelectBuilderImpl {
+  contract;
+  codecTypes;
+  context;
+  state = {};
+  constructor(options, state) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.codecTypes = options.context.contract.mappings.codecTypes;
+    if (state) {
+      this.state = state;
+    }
+  }
+  from(table) {
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, from: table }
+    );
+  }
+  innerJoin(table, on) {
+    return this._addJoin("inner", table, on);
+  }
+  leftJoin(table, on) {
+    return this._addJoin("left", table, on);
+  }
+  rightJoin(table, on) {
+    return this._addJoin("right", table, on);
+  }
+  fullJoin(table, on) {
+    return this._addJoin("full", table, on);
+  }
+  includeMany(childTable, on, childBuilder, options) {
+    checkIncludeCapabilities(this.contract);
+    if (!this.contract.storage.tables[childTable.name]) {
+      errorUnknownTable(childTable.name);
+    }
+    const joinOnBuilder = createJoinOnBuilder();
+    const onPredicate = on(joinOnBuilder);
+    const onLeft = onPredicate.left;
+    const onRight = onPredicate.right;
+    if (onLeft.table === onRight.table) {
+      errorSelfJoinNotSupported();
+    }
+    const childBuilderImpl = new IncludeChildBuilderImpl(
+      this.contract,
+      this.codecTypes,
+      childTable
+    );
+    const builtChild = childBuilder(
+      childBuilderImpl
+    );
+    const childState = builtChild.getState();
+    if (childState.childProjection.aliases.length === 0) {
+      errorChildProjectionEmpty();
+    }
+    const alias = options?.alias ?? childTable.name;
+    if (this.state.projection) {
+      if (this.state.projection.aliases.includes(alias)) {
+        errorIncludeAliasCollision(alias, "projection");
+      }
+    }
+    const existingIncludes = this.state.includes ?? [];
+    if (existingIncludes.some((inc) => inc.alias === alias)) {
+      errorIncludeAliasCollision(alias, "include");
+    }
+    const includeState = {
+      alias,
+      table: childTable,
+      on: onPredicate,
+      childProjection: childState.childProjection,
+      ...childState.childWhere !== void 0 ? { childWhere: childState.childWhere } : {},
+      ...childState.childOrderBy !== void 0 ? { childOrderBy: childState.childOrderBy } : {},
+      ...childState.childLimit !== void 0 ? { childLimit: childState.childLimit } : {}
+    };
+    const newIncludes = [...existingIncludes, includeState];
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, includes: newIncludes }
+    );
+  }
+  _addJoin(joinType, table, on) {
+    const fromTable = this.ensureFrom();
+    if (!this.contract.storage.tables[table.name]) {
+      errorUnknownTable(table.name);
+    }
+    if (table.name === fromTable.name) {
+      errorSelfJoinNotSupported();
+    }
+    const joinOnBuilder = createJoinOnBuilder();
+    const onPredicate = on(joinOnBuilder);
+    const joinState = {
+      joinType,
+      table,
+      on: onPredicate
+    };
+    const existingJoins = this.state.joins ?? [];
+    const newJoins = [...existingJoins, joinState];
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, joins: newJoins }
+    );
+  }
+  where(expr) {
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, where: expr }
+    );
+  }
+  select(projection) {
+    const table = this.ensureFrom();
+    const projectionState = buildProjectionState(table, projection, this.state.includes);
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, projection: projectionState }
+    );
+  }
+  orderBy(order) {
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, orderBy: order }
+    );
+  }
+  limit(count) {
+    if (!Number.isInteger(count) || count < 0) {
+      errorLimitMustBeNonNegativeInteger();
+    }
+    return new _SelectBuilderImpl(
+      {
+        context: this.context
+      },
+      { ...this.state, limit: count }
+    );
+  }
+  build(options) {
+    const table = this.ensureFrom();
+    const projection = this.ensureProjection();
+    const paramsMap = options?.params ?? {};
+    const contractTable = this.contract.storage.tables[table.name];
+    if (!contractTable) {
+      errorUnknownTable(table.name);
+    }
+    const paramDescriptors = [];
+    const paramValues = [];
+    const paramCodecs = {};
+    const whereResult = this.state.where ? buildWhereExpr(this.contract, this.state.where, paramsMap, paramDescriptors, paramValues) : void 0;
+    const whereExpr = whereResult?.expr;
+    if (whereResult?.codecId && whereResult.paramName) {
+      paramCodecs[whereResult.paramName] = whereResult.codecId;
+    }
+    const orderByClause = this.state.orderBy ? (() => {
+      const orderBy = this.state.orderBy;
+      const orderExpr = orderBy.expr;
+      const expr = isOperationExpr(orderExpr) ? orderExpr : (() => {
+        const colBuilder = orderExpr;
+        return createColumnRef5(colBuilder.table, colBuilder.column);
+      })();
+      return [createOrderByItem2(expr, orderBy.dir)];
+    })() : void 0;
+    const joins = this.state.joins?.map((join) => buildJoinAst(join));
+    const includes = this.state.includes?.map(
+      (include) => buildIncludeAst(include, this.contract, paramsMap, paramDescriptors, paramValues)
+    );
+    const projectEntries = [];
+    for (let i = 0; i < projection.aliases.length; i++) {
+      const alias = projection.aliases[i];
+      if (!alias) {
+        errorMissingAlias(i);
+      }
+      const column = projection.columns[i];
+      if (!column) {
+        errorMissingColumnForAlias(alias, i);
+      }
+      const matchingInclude = this.state.includes?.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) {
+            errorInvalidColumnForAlias(alias, i);
+          }
+          projectEntries.push({
+            alias,
+            expr: createColumnRef5(tableName, columnName)
+          });
+        }
+      }
+    }
+    const ast = createSelectAst({
+      from: createTableRef4(table.name),
+      joins,
+      includes,
+      project: projectEntries,
+      where: whereExpr,
+      orderBy: orderByClause,
+      limit: this.state.limit
+    });
+    const planMeta = buildMeta({
+      contract: this.contract,
+      table,
+      projection,
+      joins: this.state.joins,
+      includes: this.state.includes,
+      paramDescriptors,
+      paramCodecs,
+      where: this.state.where,
+      orderBy: this.state.orderBy
+    });
+    const queryPlan = Object.freeze({
+      ast,
+      params: paramValues,
+      meta: planMeta
+    });
+    return queryPlan;
+  }
+  ensureFrom() {
+    if (!this.state.from) {
+      errorFromMustBeCalled();
+    }
+    return this.state.from;
+  }
+  ensureProjection() {
+    if (!this.state.projection) {
+      errorSelectMustBeCalled();
+    }
+    return this.state.projection;
+  }
+};
+
+// src/sql/builder.ts
+function sql(options) {
+  const builder = new SelectBuilderImpl(
+    options
+  );
+  const rawFactory = createRawFactory(options.context.contract);
+  Object.defineProperty(builder, "raw", {
+    value: rawFactory,
+    enumerable: true,
+    configurable: false
+  });
+  Object.defineProperty(builder, "insert", {
+    value: (table, values) => {
+      return new InsertBuilderImpl(options, table, values);
+    },
+    enumerable: true,
+    configurable: false
+  });
+  Object.defineProperty(builder, "update", {
+    value: (table, set) => {
+      return new UpdateBuilderImpl(options, table, set);
+    },
+    enumerable: true,
+    configurable: false
+  });
+  Object.defineProperty(builder, "delete", {
+    value: (table) => {
+      return new DeleteBuilderImpl(options, table);
+    },
+    enumerable: true,
+    configurable: false
+  });
+  return builder;
+}
+
+export {
+  rawOptions,
+  createJoinOnBuilder2 as createJoinOnBuilder,
+  sql
+};
+//# sourceMappingURL=chunk-5OSV5CZC.js.map