@prisma-next/sql-lane 0.3.0-pr.93.4 → 0.3.0-pr.94.1

package/dist/chunk-AWSKRSFP.js

@@ -1,1569 +0,0 @@
-// src/raw.ts
-import { planInvalid } from "@prisma-next/plan";
-var RAW_OPTIONS_SENTINEL = /* @__PURE__ */ Symbol("rawOptions");
-function createRawFactory(contract) {
-  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: contract.target,
-    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/3-targets/6-adapters/postgres/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/3-targets/6-adapters/postgres/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 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/3-targets/6-adapters/postgres/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/3-targets/6-adapters/postgres/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";
-import {
-  collectColumnRefs,
-  getColumnInfo,
-  getOperationExpr,
-  isColumnBuilder,
-  isOperationExpr
-} from "@prisma-next/sql-relational-core/utils/guards";
-
-// src/utils/assertions.ts
-import { planInvalid as planInvalid3 } from "@prisma-next/plan";
-function assertColumnBuilder(col, context) {
-  if (typeof col === "object" && col !== null && "table" in col && "column" in col && typeof col.table === "string" && typeof col.column === "string") {
-    return col;
-  }
-  throw planInvalid3(`ColumnBuilder missing table/column in ${context}`);
-}
-
-// 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) {
-    if (!column) {
-      continue;
-    }
-    const operationExpr = getOperationExpr(column);
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
-      for (const ref of allRefs) {
-        refsColumns.set(`${ref.table}.${ref.column}`, {
-          table: ref.table,
-          column: ref.column
-        });
-      }
-    } else {
-      refsColumns.set(`${column.table}.${column.column}`, {
-        table: column.table,
-        column: column.column
-      });
-    }
-  }
-  if (args.joins) {
-    for (const join of args.joins) {
-      refsTables.add(join.table.name);
-      const onLeft = assertColumnBuilder(join.on.left, "join ON left");
-      const onRight = assertColumnBuilder(join.on.right, "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 leftCol = assertColumnBuilder(include.on.left, "include ON left");
-      const rightCol = assertColumnBuilder(include.on.right, "include ON right");
-      refsColumns.set(`${leftCol.table}.${leftCol.column}`, {
-        table: leftCol.table,
-        column: leftCol.column
-      });
-      refsColumns.set(`${rightCol.table}.${rightCol.column}`, {
-        table: rightCol.table,
-        column: rightCol.column
-      });
-      for (const column of include.childProjection.columns) {
-        const col = assertColumnBuilder(column, "include child projection 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
-        });
-        const childWhereRight = include.childWhere.right;
-        if (isColumnBuilder(childWhereRight)) {
-          const rightColInfo = getColumnInfo(childWhereRight);
-          refsColumns.set(`${rightColInfo.table}.${rightColInfo.column}`, {
-            table: rightColInfo.table,
-            column: rightColInfo.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;
-    if (isOperationExpr(whereLeft)) {
-      const allRefs = collectColumnRefs(whereLeft);
-      for (const ref of allRefs) {
-        refsColumns.set(`${ref.table}.${ref.column}`, {
-          table: ref.table,
-          column: ref.column
-        });
-      }
-    } else {
-      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 = assertColumnBuilder(whereLeft, "where clause must be a ColumnBuilder");
-        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-          table: colBuilder.table,
-          column: colBuilder.column
-        });
-      }
-    }
-    const whereRight = args.where.right;
-    if (isColumnBuilder(whereRight)) {
-      const colInfo = getColumnInfo(whereRight);
-      refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-        table: colInfo.table,
-        column: colInfo.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 {
-        refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-          table: orderByExpr.table,
-          column: orderByExpr.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 operationExpr = getOperationExpr(column);
-      if (operationExpr) {
-        return [alias, `operation:${operationExpr.method}`];
-      }
-      return [alias, `${column.table}.${column.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;
-      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 col = column;
-      const columnMeta = col.columnMeta;
-      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/sql/predicate-builder.ts
-import {
-  createBinaryExpr,
-  createColumnRef,
-  createParamRef
-} from "@prisma-next/sql-relational-core/ast";
-import {
-  getColumnInfo as getColumnInfo2,
-  getOperationExpr as getOperationExpr2,
-  isColumnBuilder as isColumnBuilder2,
-  isParamPlaceholder
-} from "@prisma-next/sql-relational-core/utils/guards";
-function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
-  let leftExpr;
-  let codecId;
-  let rightExpr;
-  let paramName;
-  const operationExpr = getOperationExpr2(where.left);
-  if (operationExpr) {
-    leftExpr = operationExpr;
-  } else if (isColumnBuilder2(where.left)) {
-    const { table, column } = getColumnInfo2(where.left);
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-    const columnMeta = contractTable.columns[column];
-    if (!columnMeta) {
-      errorUnknownColumn(column, table);
-    }
-    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 (isColumnBuilder2(where.left)) {
-      const { table, column } = getColumnInfo2(where.left);
-      const contractTable = contract.storage.tables[table];
-      const columnMeta = contractTable?.columns[column];
-      if (columnMeta) {
-        descriptors.push({
-          name: paramName,
-          source: "dsl",
-          refs: { table, column },
-          nullable: columnMeta.nullable,
-          codecId: columnMeta.codecId,
-          nativeType: columnMeta.nativeType
-        });
-      }
-    }
-    rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder2(where.right)) {
-    const { table, column } = getColumnInfo2(where.right);
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-    const columnMeta = contractTable.columns[column];
-    if (!columnMeta) {
-      errorUnknownColumn(column, table);
-    }
-    rightExpr = createColumnRef(table, column);
-    paramName = "";
-  } else {
-    errorFailedToBuildWhereClause();
-  }
-  return {
-    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
-    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?.codecId;
-      if (paramName && codecId) {
-        paramCodecs[paramName] = codecId;
-      }
-      paramDescriptors.push({
-        name: paramName,
-        source: "dsl",
-        refs: { table: this.table.name, column: columnName },
-        ...codecId ? { codecId } : {},
-        ...columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {},
-        ...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?.codecId;
-      if (paramName && codecId) {
-        paramCodecs[paramName] = codecId;
-      }
-      paramDescriptors.push({
-        name: paramName,
-        source: "dsl",
-        refs: { table: this.table.name, column: columnName },
-        ...codecId ? { codecId } : {},
-        ...columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {},
-        ...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";
-import { getOperationExpr as getOperationExpr3 } from "@prisma-next/sql-relational-core/utils/guards";
-
-// src/sql/include-builder.ts
-import {
-  createColumnRef as createColumnRef3,
-  createJoinOnExpr,
-  createOrderByItem,
-  createTableRef as createTableRef2
-} from "@prisma-next/sql-relational-core/ast";
-import {
-  extractBaseColumnRef,
-  isOperationExpr as isOperationExpr2
-} from "@prisma-next/sql-relational-core/utils/guards";
-
-// src/sql/projection.ts
-import { isColumnBuilder as isColumnBuilder3 } 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 (isColumnBuilder3(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(null);
-    } else if (isColumnBuilder3(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 (isOperationExpr2(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);
-        }
-        return {
-          alias,
-          expr: createColumnRef3(column.table, column.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 operationExpr = getOperationExpr3(orderExpr);
-      const expr = operationExpr ? operationExpr : (() => {
-        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];
-      const matchingInclude = this.state.includes?.find((inc) => inc.alias === alias);
-      if (matchingInclude) {
-        projectEntries.push({
-          alias,
-          expr: { kind: "includeRef", alias }
-        });
-      } else {
-        if (!column) {
-          errorMissingColumnForAlias(alias, i);
-        }
-        const operationExpr = column._operationExpr;
-        if (operationExpr) {
-          projectEntries.push({
-            alias,
-            expr: operationExpr
-          });
-        } else {
-          const col = column;
-          assertColumnBuilder(col, "projection column");
-          projectEntries.push({
-            alias,
-            expr: createColumnRef5(col.table, col.column)
-          });
-        }
-      }
-    }
-    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-AWSKRSFP.js.map