@prisma-next/sql-lane 0.3.0-pr.94.3 → 0.3.0-pr.95.2

package/dist/chunk-72PNERR5.js

@@ -0,0 +1,1541 @@
+// 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,
+  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 ExpressionSource (ColumnBuilder or ExpressionBuilder) 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,
+  isColumnBuilder,
+  isExpressionBuilder,
+  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 collectRefsFromExpressionSource(source, refsColumns) {
+  if (isExpressionBuilder(source)) {
+    const allRefs = collectColumnRefs(source.expr);
+    for (const ref of allRefs) {
+      refsColumns.set(`${ref.table}.${ref.column}`, {
+        table: ref.table,
+        column: ref.column
+      });
+    }
+  } else if (isColumnBuilder(source)) {
+    const col = source;
+    refsColumns.set(`${col.table}.${col.column}`, {
+      table: col.table,
+      column: col.column
+    });
+  }
+}
+function collectRefsFromExpression(expr, refsColumns) {
+  if (isOperationExpr(expr)) {
+    const allRefs = collectColumnRefs(expr);
+    for (const ref of allRefs) {
+      refsColumns.set(`${ref.table}.${ref.column}`, {
+        table: ref.table,
+        column: ref.column
+      });
+    }
+  } else if (expr.kind === "col") {
+    refsColumns.set(`${expr.table}.${expr.column}`, {
+      table: expr.table,
+      column: expr.column
+    });
+  }
+}
+function buildMeta(args) {
+  const refsColumns = /* @__PURE__ */ new Map();
+  const refsTables = /* @__PURE__ */ new Set([args.table.name]);
+  for (const column of args.projection.columns) {
+    collectRefsFromExpressionSource(column, refsColumns);
+  }
+  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) {
+        collectRefsFromExpression(include.childWhere.left, refsColumns);
+        const childWhereRight = include.childWhere.right;
+        if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
+          collectRefsFromExpressionSource(childWhereRight, refsColumns);
+        }
+      }
+      if (include.childOrderBy) {
+        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+      }
+    }
+  }
+  if (args.where) {
+    const leftExpr = args.where.left;
+    if (isOperationExpr(leftExpr)) {
+      const allRefs = collectColumnRefs(leftExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column
+        });
+      }
+    } else {
+      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
+        table: leftExpr.table,
+        column: leftExpr.column
+      });
+    }
+    const whereRight = args.where.right;
+    if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
+      collectRefsFromExpressionSource(whereRight, refsColumns);
+    }
+  }
+  if (args.orderBy) {
+    const orderByExpr = args.orderBy.expr;
+    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);
+      }
+      if (isExpressionBuilder(column)) {
+        return [alias, `operation:${column.expr.method}`];
+      }
+      const col = column;
+      if (!col.table || !col.column) {
+        return [alias, `include:${alias}`];
+      }
+      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;
+    }
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
+      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;
+    }
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
+      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, createParamRef } from "@prisma-next/sql-relational-core/ast";
+import {
+  isColumnBuilder as isColumnBuilder2,
+  isExpressionBuilder as isExpressionBuilder2,
+  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 validExpressionKinds = ["col", "operation"];
+  if (!where.left || typeof where.left !== "object" || !validExpressionKinds.includes(where.left.kind ?? "")) {
+    errorFailedToBuildWhereClause();
+  }
+  leftExpr = where.left;
+  if (leftExpr.kind === "col") {
+    const { table, column } = leftExpr;
+    const contractTable = contract.storage.tables[table];
+    if (!contractTable) {
+      errorUnknownTable(table);
+    }
+    const columnMeta = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
+    }
+    codecId = columnMeta.codecId;
+  }
+  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 (leftExpr.kind === "col") {
+      const { table, column } = leftExpr;
+      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) || isExpressionBuilder2(where.right)) {
+    rightExpr = where.right.toExpr();
+    if (rightExpr.kind === "col") {
+      const { table, column } = rightExpr;
+      const contractTable = contract.storage.tables[table];
+      if (!contractTable) {
+        errorUnknownTable(table);
+      }
+      const columnMeta = contractTable.columns[column];
+      if (!columnMeta) {
+        errorUnknownColumn(column, table);
+      }
+    }
+    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 createColumnRef(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 createColumnRef(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 createColumnRef(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 {
+  createJoinOnBuilder,
+  createOrderByItem as createOrderByItem2,
+  createSelectAst,
+  createTableRef as createTableRef4
+} from "@prisma-next/sql-relational-core/ast";
+import { isExpressionBuilder as isExpressionBuilder3 } from "@prisma-next/sql-relational-core/utils/guards";
+
+// src/sql/include-builder.ts
+import {
+  createColumnRef as createColumnRef2,
+  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 { isExpressionSource } 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 (isExpressionSource(value)) {
+      const alias = tracker.register(path);
+      aliases.push(alias);
+      columns.push(value);
+    } else if (typeof value === "object" && value !== null) {
+      const nested = flattenProjection(value, tracker, path);
+      aliases.push(...nested.aliases);
+      columns.push(...nested.columns);
+    } else {
+      errorInvalidProjectionValue(path);
+    }
+  }
+  return { aliases, columns };
+}
+function buildProjectionState(_table, projection, includes) {
+  const tracker = new AliasTracker();
+  const aliases = [];
+  const columns = [];
+  for (const [key, value] of Object.entries(projection)) {
+    if (value === true) {
+      const matchingInclude = includes?.find((inc) => inc.alias === key);
+      if (!matchingInclude) {
+        errorIncludeAliasNotFound(key);
+      }
+      aliases.push(key);
+      columns.push({
+        kind: "column",
+        table: matchingInclude.table.name,
+        column: "",
+        columnMeta: { nativeType: "jsonb", codecId: "core/json@1", nullable: true },
+        toExpr: () => ({ kind: "col", table: matchingInclude.table.name, column: "" })
+      });
+    } else if (isExpressionSource(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 createColumnRef2(baseCol.table, baseCol.column);
+      }
+      const colBuilder = orderExpr;
+      return createColumnRef2(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 = createColumnRef2(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef2(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: column.toExpr()
+        };
+      })
+    }
+  };
+}
+
+// src/sql/join-builder.ts
+import {
+  createColumnRef as createColumnRef3,
+  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 = createColumnRef3(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef3(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;
+      return [createOrderByItem2(orderBy.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 && isExpressionBuilder3(column)) {
+        projectEntries.push({
+          alias,
+          expr: column.expr
+        });
+      } else if (column) {
+        const columnRef = column.toExpr();
+        projectEntries.push({
+          alias,
+          expr: columnRef
+        });
+      }
+    }
+    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-72PNERR5.js.map