@vibeorm/sql 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1030 @@
+// @bun
+// packages/sql/src/ast.ts
+var SET_OPERATORS = ["increment", "decrement", "multiply", "divide"];
+function isSetOperation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes("__op") || !keys.includes("value"))
+    return false;
+  const candidate = value;
+  return typeof candidate.__op === "string" && SET_OPERATORS.includes(candidate.__op) && typeof candidate.value === "number" && Number.isFinite(candidate.value);
+}
+var LIST_SET_OPERATORS = ["append", "concat"];
+function isListSetOperation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes("__listOp") || !keys.includes("value"))
+    return false;
+  const candidate = value;
+  return typeof candidate.__listOp === "string" && LIST_SET_OPERATORS.includes(candidate.__listOp);
+}
+var SQL_DEFAULT_CELL = Object.freeze({ __sqlDefault: true });
+function isSqlDefaultCell(value) {
+  return value === SQL_DEFAULT_CELL;
+}
+function jsonParamCell(params) {
+  return { __jsonParam: true, text: params.text };
+}
+function isJsonParamCell(value) {
+  return typeof value === "object" && value !== null && value.__jsonParam === true;
+}
+// packages/sql/src/capabilities.ts
+var POSTGRES_CAPABILITIES = {
+  returning: true,
+  scalarArrays: true,
+  nativeEnums: true,
+  ilike: true,
+  lateralJoin: true,
+  distinctOn: true,
+  partialIndexes: true,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: true,
+  orderByNulls: true,
+  fullTextEngines: ["bm25", "tsvector"]
+};
+var SQLITE_CAPABILITIES = {
+  returning: true,
+  scalarArrays: false,
+  nativeEnums: false,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: true,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: false,
+  orderByNulls: true,
+  fullTextEngines: ["fts5"]
+};
+var MYSQL_CAPABILITIES = {
+  returning: false,
+  scalarArrays: false,
+  nativeEnums: true,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: false,
+  transactionalDdl: false,
+  createManyAndReturn: false,
+  jsonColumnType: true,
+  orderByNulls: false,
+  fullTextEngines: ["fulltext"]
+};
+var DIALECT_CAPABILITIES = {
+  postgres: POSTGRES_CAPABILITIES,
+  sqlite: SQLITE_CAPABILITIES,
+  mysql: MYSQL_CAPABILITIES
+};
+
+// packages/sql/src/dialects/postgres.ts
+var postgresDialect = {
+  name: "postgres",
+  capabilities: POSTGRES_CAPABILITIES,
+  inArrayStrategy: "any",
+  upsertForm: "onConflict",
+  doNothingForm: "onConflictDoNothing",
+  insensitiveLike: "ilike",
+  strictMatchStrategy: "native",
+  orderByNullsMode: "native",
+  offsetRequiresLimit: null,
+  likeEscapeClause: null,
+  jsonPathMode: "operators",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "::text::jsonb",
+  lastInsertIdSql: null,
+  selectForUpdate: " FOR UPDATE",
+  rowDefaultKeyword: true,
+  paramBudget: 30000,
+  quoteIdent({ name }) {
+    return `"${name.replaceAll('"', '""')}"`;
+  },
+  placeholder({ index }) {
+    return `$${index}`;
+  }
+};
+// packages/sql/src/dialects/sqlite.ts
+var sqliteDialect = {
+  name: "sqlite",
+  capabilities: SQLITE_CAPABILITIES,
+  inArrayStrategy: "expand",
+  upsertForm: "onConflict",
+  doNothingForm: "onConflictDoNothing",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "glob",
+  orderByNullsMode: "native",
+  offsetRequiresLimit: { limitText: "-1" },
+  likeEscapeClause: " ESCAPE '\\'",
+  jsonPathMode: "sqliteExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  lastInsertIdSql: null,
+  selectForUpdate: null,
+  rowDefaultKeyword: false,
+  paramBudget: 900,
+  quoteIdent({ name }) {
+    return `"${name.replaceAll('"', '""')}"`;
+  },
+  placeholder() {
+    return "?";
+  }
+};
+// packages/sql/src/dialects/mysql.ts
+var mysqlDialect = {
+  name: "mysql",
+  capabilities: MYSQL_CAPABILITIES,
+  inArrayStrategy: "expand",
+  upsertForm: "onDuplicateKey",
+  doNothingForm: "insertIgnore",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "binary",
+  orderByNullsMode: "emulate",
+  offsetRequiresLimit: { limitText: "18446744073709551615" },
+  likeEscapeClause: null,
+  jsonPathMode: "mysqlExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  lastInsertIdSql: "SELECT LAST_INSERT_ID() AS `id`",
+  selectForUpdate: " FOR UPDATE",
+  rowDefaultKeyword: true,
+  paramBudget: 1e4,
+  quoteIdent({ name }) {
+    return `\`${name.replaceAll("`", "``")}\``;
+  },
+  placeholder() {
+    return "?";
+  }
+};
+// packages/sql/src/dialects/registry.ts
+var SQL_DIALECTS = {
+  postgres: postgresDialect,
+  sqlite: sqliteDialect,
+  mysql: mysqlDialect
+};
+function getSqlDialect(params) {
+  return SQL_DIALECTS[params.dialect];
+}
+// packages/sql/src/codecs.ts
+import { VibeError } from "@vibeorm/schema";
+function decodeIsNoop(params) {
+  const { scalarType, wire } = params;
+  if (wire === undefined)
+    return false;
+  if (scalarType === "DateTime")
+    return wire.dateTime === "native";
+  if (scalarType === "Json")
+    return wire.json === "parsed";
+  if (scalarType === "Int" || scalarType === "Float")
+    return wire.numbers === "native";
+  return false;
+}
+var identity = (value) => value;
+var passthroughCodec = { encode: identity, decode: identity };
+var numberCodec = {
+  encode: identity,
+  decode: (value) => typeof value === "string" ? Number(value) : value
+};
+var bigIntCodec = {
+  encode: (value) => typeof value === "bigint" ? value.toString() : value,
+  decode: (value) => {
+    if (typeof value === "bigint")
+      return value;
+    if (typeof value === "string" || typeof value === "number")
+      return BigInt(value);
+    return value;
+  }
+};
+var decimalCodec = {
+  encode: (value) => typeof value === "number" || typeof value === "bigint" ? String(value) : value,
+  decode: identity
+};
+var mysqlDecimalCodec = {
+  encode: decimalCodec.encode,
+  decode: (value) => {
+    if (typeof value !== "string" || !value.includes("."))
+      return value;
+    const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
+    return trimmed === "" || trimmed === "-" ? "0" : trimmed;
+  }
+};
+var dateNativeCodec = {
+  encode: identity,
+  decode: (value) => {
+    if (value instanceof Date)
+      return value;
+    if (typeof value === "string" || typeof value === "number")
+      return new Date(value);
+    return value;
+  }
+};
+var dateTextCodec = {
+  encode: (value) => value instanceof Date ? value.toISOString() : value,
+  decode: dateNativeCodec.decode
+};
+var EXPLICIT_ZONE = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+var mysqlDateCodec = {
+  encode: (value) => {
+    if (value instanceof Date)
+      return value;
+    if (typeof value === "number") {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime()))
+        return parsed;
+      return value;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (!EXPLICIT_ZONE.test(trimmed) && !DATE_ONLY.test(trimmed)) {
+        const asUtc = new Date(`${trimmed.replace(" ", "T")}Z`);
+        if (!Number.isNaN(asUtc.getTime()))
+          return asUtc;
+      }
+      const parsed = new Date(trimmed);
+      if (!Number.isNaN(parsed.getTime()))
+        return parsed;
+    }
+    return value;
+  },
+  decode: dateNativeCodec.decode
+};
+var booleanIntCodec = {
+  encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
+  decode: (value) => typeof value === "number" ? value !== 0 : value
+};
+var booleanNativeInCodec = {
+  encode: identity,
+  decode: booleanIntCodec.decode
+};
+var jsonCodec = {
+  encode: (value) => JSON.stringify(value),
+  decode: (value) => {
+    if (typeof value !== "string")
+      return value;
+    try {
+      return JSON.parse(value);
+    } catch (cause) {
+      throw new VibeError({
+        code: "VIBE_INTERNAL",
+        message: "a Json column returned text that is not valid JSON",
+        meta: { value },
+        cause
+      });
+    }
+  }
+};
+var POSTGRES_CODECS = {
+  String: passthroughCodec,
+  Boolean: passthroughCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateNativeCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var SQLITE_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanIntCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateTextCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var MYSQL_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanNativeInCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: mysqlDecimalCodec,
+  DateTime: mysqlDateCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var DIALECT_CODECS = {
+  postgres: POSTGRES_CODECS,
+  sqlite: SQLITE_CODECS,
+  mysql: MYSQL_CODECS
+};
+// packages/sql/src/render.ts
+import { internalError, unsupportedCapability } from "@vibeorm/schema";
+
+// packages/sql/src/like.ts
+function escapeLikePattern(params) {
+  return params.raw.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function containsPattern(params) {
+  return `%${escapeLikePattern({ raw: params.raw })}%`;
+}
+function startsWithPattern(params) {
+  return `${escapeLikePattern({ raw: params.raw })}%`;
+}
+function endsWithPattern(params) {
+  return `%${escapeLikePattern({ raw: params.raw })}`;
+}
+function escapeGlobPattern(params) {
+  return params.raw.replace(/[*?[]/g, (char) => `[${char}]`);
+}
+function strictMatchPattern(params) {
+  const { strategy, op, value } = params;
+  if (strategy === "glob") {
+    const inner = escapeGlobPattern({ raw: value });
+    return op === "contains" ? `*${inner}*` : op === "startsWith" ? `${inner}*` : `*${inner}`;
+  }
+  return op === "contains" ? containsPattern({ raw: value }) : op === "startsWith" ? startsWithPattern({ raw: value }) : endsWithPattern({ raw: value });
+}
+
+// packages/sql/src/params.ts
+class ParamCollector {
+  dialect;
+  values;
+  constructor(dialect) {
+    this.dialect = dialect;
+    this.values = [];
+  }
+  add(value) {
+    this.values.push(value);
+    return this.dialect.placeholder({ index: this.values.length });
+  }
+  addMany(values) {
+    return values.map((value) => this.add(value));
+  }
+}
+
+// packages/sql/src/render.ts
+function renderStatement(params) {
+  const { dialect, statement } = params;
+  const collector = new ParamCollector(dialect);
+  switch (statement.kind) {
+    case "select":
+      return renderSelect({ dialect, statement, collector });
+    case "insert":
+      return renderInsert({ dialect, statement, collector });
+    case "update":
+      return renderUpdate({ dialect, statement, collector });
+    case "delete":
+      return renderDelete({ dialect, statement, collector });
+  }
+}
+function quoteCol(dialect, column) {
+  const name = dialect.quoteIdent({ name: column.name });
+  const ref = column.table === undefined ? name : `${dialect.quoteIdent({ name: column.table })}.${name}`;
+  if (column.castReal === true) {
+    if (dialect.name !== "sqlite") {
+      throw internalError({ message: "ColRef.castReal is a sqlite Decimal construct" });
+    }
+    return `CAST(${ref} AS REAL)`;
+  }
+  return ref;
+}
+function quoteProjection(dialect, column) {
+  if (column.transform === undefined) {
+    const base = quoteCol(dialect, column);
+    if (column.alias === undefined)
+      return base;
+    return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
+  }
+  if (dialect.name !== "postgres") {
+    throw internalError({ message: "ColRef.transform is a postgres lateral-join construct" });
+  }
+  const ref = quoteCol(dialect, column);
+  const alias = dialect.quoteIdent({ name: column.name });
+  if (column.transform === "castText")
+    return `${ref}::text AS ${alias}`;
+  return `encode(${ref}, 'base64') AS ${alias}`;
+}
+function renderTable(dialect, table) {
+  const name = dialect.quoteIdent({ name: table.name });
+  if (table.alias === undefined)
+    return name;
+  return `${name} AS ${dialect.quoteIdent({ name: table.alias })}`;
+}
+function assertCount(value, what) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw internalError({ message: `${what} must be a non-negative integer, got ${value}` });
+  }
+}
+var COMPARISON_SQL = {
+  eq: "=",
+  ne: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var SET_OPERATION_SQL = {
+  increment: "+",
+  decrement: "-",
+  multiply: "*",
+  divide: "/"
+};
+var AGG_FN_SQL = {
+  count: "COUNT",
+  avg: "AVG",
+  sum: "SUM",
+  min: "MIN",
+  max: "MAX"
+};
+function renderAggRef(dialect, agg) {
+  if (agg.fn === "countAll")
+    return "COUNT(*)";
+  return `${AGG_FN_SQL[agg.fn]}(${quoteCol(dialect, agg.column)})`;
+}
+function assertScalarArrays(dialect, feature) {
+  if (dialect.capabilities.scalarArrays)
+    return;
+  throw unsupportedCapability({
+    dialect: dialect.name,
+    feature,
+    hint: "only postgres has native array columns \u2014 model the list as a related table instead"
+  });
+}
+function renderExpr(params) {
+  const { dialect, expr, collector } = params;
+  switch (expr.kind) {
+    case "cmp": {
+      const op = COMPARISON_SQL[expr.op];
+      if (op === undefined) {
+        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+      }
+      return `${quoteCol(dialect, expr.column)} ${op} ${collector.add(expr.value)}`;
+    }
+    case "cmpCol": {
+      const op = COMPARISON_SQL[expr.op];
+      if (op === undefined) {
+        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+      }
+      return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
+    }
+    case "isNull":
+      return `${quoteCol(dialect, expr.column)} IS ${expr.negate === true ? "NOT NULL" : "NULL"}`;
+    case "inArray": {
+      if (expr.values.length === 0) {
+        return expr.negate === true ? "1 = 1" : "1 = 0";
+      }
+      const column = quoteCol(dialect, expr.column);
+      if (dialect.inArrayStrategy === "any") {
+        const base = `${column} = ANY(${collector.add([...expr.values])})`;
+        return expr.negate === true ? `NOT (${base})` : base;
+      }
+      const placeholders = collector.addMany(expr.values);
+      return `${column} ${expr.negate === true ? "NOT IN" : "IN"} (${placeholders.join(", ")})`;
+    }
+    case "like": {
+      const column = quoteCol(dialect, expr.column);
+      const placeholder = collector.add(expr.pattern);
+      let base;
+      if (expr.insensitive === true) {
+        base = dialect.insensitiveLike === "ilike" ? `${column} ILIKE ${placeholder}` : `LOWER(${column}) LIKE LOWER(${placeholder})`;
+      } else {
+        base = `${column} LIKE ${placeholder}`;
+      }
+      if (dialect.likeEscapeClause !== null) {
+        base = `${base}${dialect.likeEscapeClause}`;
+      }
+      return expr.negate === true ? `NOT (${base})` : base;
+    }
+    case "strictMatch": {
+      const column = quoteCol(dialect, expr.column);
+      let base;
+      if (expr.op === "equals") {
+        base = dialect.strictMatchStrategy === "binary" ? `${column} = CAST(${collector.add(expr.value)} AS BINARY)` : `${column} = ${collector.add(expr.value)}`;
+      } else {
+        const pattern = strictMatchPattern({
+          strategy: dialect.strictMatchStrategy,
+          op: expr.op,
+          value: expr.value
+        });
+        if (dialect.strictMatchStrategy === "glob") {
+          base = `${column} GLOB ${collector.add(pattern)}`;
+        } else {
+          const placeholder = collector.add(pattern);
+          base = dialect.strictMatchStrategy === "binary" ? `${column} LIKE CAST(${placeholder} AS BINARY)` : `${column} LIKE ${placeholder}`;
+          if (dialect.likeEscapeClause !== null)
+            base = `${base}${dialect.likeEscapeClause}`;
+        }
+      }
+      return expr.negate === true ? `NOT (${base})` : base;
+    }
+    case "and":
+    case "or": {
+      if (expr.operands.length === 0) {
+        return expr.kind === "and" ? "1 = 1" : "1 = 0";
+      }
+      if (expr.operands.length === 1) {
+        return renderExpr({ dialect, expr: expr.operands[0], collector });
+      }
+      const joiner = expr.kind === "and" ? " AND " : " OR ";
+      const rendered = expr.operands.map((operand) => renderExpr({ dialect, expr: operand, collector }));
+      return `(${rendered.join(joiner)})`;
+    }
+    case "not":
+      return `NOT (${renderExpr({ dialect, expr: expr.operand, collector })})`;
+    case "aggCmp": {
+      const op = COMPARISON_SQL[expr.op];
+      if (op === undefined) {
+        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+      }
+      return `${renderAggRef(dialect, expr.agg)} ${op} ${collector.add(expr.value)}`;
+    }
+    case "arrayHas": {
+      assertScalarArrays(dialect, 'the scalar-list filter "has"');
+      const base = `${collector.add(expr.value)} = ANY(${quoteCol(dialect, expr.column)})`;
+      return expr.negate === true ? `NOT (${base})` : base;
+    }
+    case "arrayContainsAll": {
+      assertScalarArrays(dialect, 'the scalar-list filter "hasEvery"');
+      return `${quoteCol(dialect, expr.column)} @> ${collector.add([...expr.values])}`;
+    }
+    case "arrayOverlaps": {
+      assertScalarArrays(dialect, 'the scalar-list filter "hasSome"');
+      return `${quoteCol(dialect, expr.column)} && ${collector.add([...expr.values])}`;
+    }
+    case "arrayIsEmpty": {
+      assertScalarArrays(dialect, 'the scalar-list filter "isEmpty"');
+      const column = quoteCol(dialect, expr.column);
+      return `array_length(${column}, 1) IS ${expr.empty ? "NULL" : "NOT NULL"}`;
+    }
+    case "jsonFilter":
+      return renderJsonFilter({ dialect, expr, collector });
+    case "exists": {
+      const sub = renderSelect({ dialect, statement: expr.select, collector });
+      return `${expr.negate === true ? "NOT " : ""}EXISTS (${sub.text})`;
+    }
+    case "fragment":
+      return renderFragment({ dialect, fragment: expr.fragment, collector });
+    case "raw":
+      return expr.text;
+  }
+}
+function renderFragment(params) {
+  const { dialect, fragment, collector } = params;
+  let text = "";
+  for (const part of fragment.parts) {
+    if (typeof part === "string") {
+      text += part;
+    } else if ("param" in part) {
+      text += collector.add(part.param);
+    } else {
+      text += part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
+    }
+  }
+  return text;
+}
+function jsonPathString(path) {
+  let out = "$";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+    } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)) {
+      out += `.${segment}`;
+    } else {
+      out += `."${segment.replaceAll('"', "\\\"")}"`;
+    }
+  }
+  return out;
+}
+function jsonStringPattern(params) {
+  const { expr } = params;
+  if (typeof expr.value !== "string") {
+    throw internalError({ message: `json ${expr.op} expects a string operand` });
+  }
+  if (expr.op === "string_contains")
+    return containsPattern({ raw: expr.value });
+  if (expr.op === "string_starts_with")
+    return startsWithPattern({ raw: expr.value });
+  return endsWithPattern({ raw: expr.value });
+}
+function renderJsonLike(params) {
+  const { dialect, target, expr, collector } = params;
+  const placeholder = collector.add(jsonStringPattern({ expr }));
+  let base;
+  if (expr.insensitive === true) {
+    base = dialect.insensitiveLike === "ilike" ? `${target} ILIKE ${placeholder}` : `LOWER(${target}) LIKE LOWER(${placeholder})`;
+  } else {
+    base = `${target} LIKE ${placeholder}`;
+  }
+  if (dialect.likeEscapeClause !== null)
+    base = `${base}${dialect.likeEscapeClause}`;
+  return expr.negate === true ? `NOT (${base})` : base;
+}
+function renderJsonFilter(params) {
+  const { dialect, expr, collector } = params;
+  if (!dialect.supportedJsonOps.includes(expr.op)) {
+    throw unsupportedCapability({
+      dialect: dialect.name,
+      feature: `the json filter "${expr.op}"`,
+      hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
+    });
+  }
+  const cmp = expr.negate === true ? "<>" : "=";
+  if (dialect.jsonPathMode === "operators") {
+    const column2 = quoteCol(dialect, expr.column);
+    const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
+    switch (expr.op) {
+      case "equals":
+        return `(${column2} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+      case "string_contains":
+      case "string_starts_with":
+      case "string_ends_with":
+        return renderJsonLike({ dialect, target: `(${column2} #>> ${pathParam})`, expr, collector });
+      case "array_contains":
+        return `(${column2} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+      case "array_starts_with":
+        return `(${column2} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+      case "array_ends_with":
+        return `(${column2} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+    }
+  }
+  if (dialect.jsonPathMode === "sqliteExtract") {
+    const column2 = quoteCol(dialect, expr.column);
+    const compareExtracted = (target, value) => {
+      if (typeof value === "boolean") {
+        return `${target} ${cmp} ${collector.add(value ? 1 : 0)}`;
+      }
+      if (typeof value === "object" && value !== null) {
+        return `${target} ${cmp} json(${collector.add(JSON.stringify(value))})`;
+      }
+      return `${target} ${cmp} ${collector.add(value)}`;
+    };
+    switch (expr.op) {
+      case "equals":
+        return compareExtracted(`json_extract(${column2}, ${collector.add(jsonPathString(expr.path))})`, expr.value);
+      case "string_contains":
+      case "string_starts_with":
+      case "string_ends_with": {
+        const target = `json_extract(${column2}, ${collector.add(jsonPathString(expr.path))})`;
+        return renderJsonLike({ dialect, target, expr, collector });
+      }
+      case "array_starts_with":
+      case "array_ends_with": {
+        const edge = expr.op === "array_starts_with" ? "[0]" : "[#-1]";
+        return compareExtracted(`json_extract(${column2}, ${collector.add(`${jsonPathString(expr.path)}${edge}`)})`, expr.value);
+      }
+      case "array_contains": {
+        const guard = `json_type(${column2}, ${collector.add(jsonPathString(expr.path))}) = 'array'`;
+        const elements = Array.isArray(expr.value) ? expr.value : [expr.value];
+        const tests = elements.map((element) => {
+          if (element === null || typeof element === "object" && element !== null) {
+            throw unsupportedCapability({
+              dialect: dialect.name,
+              feature: "json array_contains with object/array/null elements",
+              hint: "sqlite expresses scalar-element containment only \u2014 deep structural containment needs postgres or mysql"
+            });
+          }
+          const bound = typeof element === "boolean" ? element ? 1 : 0 : element;
+          return `EXISTS (SELECT 1 FROM json_each(${column2}, ${collector.add(jsonPathString(expr.path))}) WHERE ${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "value" })} = ${collector.add(bound)})`;
+        });
+        return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
+      }
+      default:
+        throw internalError({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+    }
+  }
+  const column = quoteCol(dialect, expr.column);
+  const pathString = jsonPathString(expr.path);
+  switch (expr.op) {
+    case "equals":
+      return `JSON_EXTRACT(${column}, ${collector.add(pathString)}) ${cmp} CAST(${collector.add(JSON.stringify(expr.value))} AS JSON)`;
+    case "string_contains":
+    case "string_starts_with":
+    case "string_ends_with": {
+      const target = `JSON_UNQUOTE(JSON_EXTRACT(${column}, ${collector.add(pathString)}))`;
+      return renderJsonLike({ dialect, target, expr, collector });
+    }
+    case "array_contains":
+      return `JSON_CONTAINS(JSON_EXTRACT(${column}, ${collector.add(pathString)}), CAST(${collector.add(JSON.stringify(expr.value))} AS JSON))`;
+    case "array_starts_with":
+      return `JSON_EXTRACT(${column}, ${collector.add(`${pathString}[0]`)}) ${cmp} CAST(${collector.add(JSON.stringify(expr.value))} AS JSON)`;
+    case "array_ends_with":
+      return `JSON_EXTRACT(${column}, ${collector.add(`${pathString}[last]`)}) ${cmp} CAST(${collector.add(JSON.stringify(expr.value))} AS JSON)`;
+  }
+}
+function renderOrderTerm(params) {
+  const { dialect, term, collector } = params;
+  if ("agg" in term) {
+    return `${renderAggRef(dialect, term.agg)} ${term.direction === "asc" ? "ASC" : "DESC"}`;
+  }
+  if ("select" in term) {
+    const sub = renderSelect({ dialect, statement: term.select, collector });
+    return `(${sub.text}) ${term.direction === "asc" ? "ASC" : "DESC"}`;
+  }
+  const column = quoteCol(dialect, term.column);
+  const direction = term.direction === "asc" ? "ASC" : "DESC";
+  if (term.nulls === undefined) {
+    return `${column} ${direction}`;
+  }
+  if (dialect.orderByNullsMode === "native") {
+    return `${column} ${direction} NULLS ${term.nulls === "first" ? "FIRST" : "LAST"}`;
+  }
+  if (term.nulls === "first" === (term.direction === "asc")) {
+    return `${column} ${direction}`;
+  }
+  const nullsTerm = term.nulls === "first" ? `${column} IS NULL DESC` : `${column} IS NULL`;
+  return `${nullsTerm}, ${column} ${direction}`;
+}
+function renderSelectExpr(params) {
+  const { dialect, expr } = params;
+  if (expr.kind === "one")
+    return "1";
+  const alias = expr.alias === undefined ? "" : ` AS ${dialect.quoteIdent({ name: expr.alias })}`;
+  return `COUNT(*)${alias}`;
+}
+function renderLateralJoin(params) {
+  const { dialect, join, collector } = params;
+  const inner = renderSelect({ dialect, statement: join.select, collector });
+  const columnAlias = dialect.quoteIdent({ name: join.columnAlias });
+  const subAlias = dialect.quoteIdent({ name: "__sub" });
+  let aggOrder = "";
+  if (join.agg === "jsonArray" && join.select.orderBy !== undefined && join.select.orderBy.length > 0) {
+    const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name));
+    const terms = join.select.orderBy;
+    const columnTerms = terms.filter((term) => !("agg" in term));
+    if (columnTerms.length === terms.length && columnTerms.every((term) => projected.has(term.column.name))) {
+      const rendered = columnTerms.map((term) => renderOrderTerm({ dialect, term: { ...term, column: { table: "__sub", name: term.column.name } }, collector }));
+      aggOrder = ` ORDER BY ${rendered.join(", ")}`;
+    }
+  }
+  const projection = join.agg === "jsonArray" ? `COALESCE(jsonb_agg(to_jsonb(${subAlias}.*)${aggOrder}), '[]'::jsonb) AS ${columnAlias}` : `to_jsonb(${subAlias}.*) AS ${columnAlias}`;
+  const alias = dialect.quoteIdent({ name: join.alias });
+  return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
+}
+function applyReturning(params) {
+  const { dialect, requested } = params;
+  if (requested === undefined || requested.length === 0) {
+    return { suffix: "", status: "none" };
+  }
+  if (!dialect.capabilities.returning) {
+    return { suffix: "", status: "omitted" };
+  }
+  const columns = requested.map((name) => dialect.quoteIdent({ name })).join(", ");
+  return { suffix: ` RETURNING ${columns}`, status: "native" };
+}
+function renderSelect(params) {
+  const { dialect, statement, collector } = params;
+  if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
+    throw internalError({ message: "only countAll can combine with a column list" });
+  }
+  if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
+    throw internalError({ message: "selectExpr and aggregates cannot combine" });
+  }
+  const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
+  if (statement.selectExpr !== undefined) {
+    columnList.push(renderSelectExpr({ dialect, expr: statement.selectExpr }));
+  }
+  if (statement.aggregates !== undefined) {
+    for (const selection of statement.aggregates) {
+      columnList.push(`${renderAggRef(dialect, selection.agg)} AS ${dialect.quoteIdent({ name: selection.alias })}`);
+    }
+  }
+  if (statement.rowNumber !== undefined) {
+    const rowNumber = statement.rowNumber;
+    if (rowNumber.partitionBy.length === 0) {
+      throw internalError({ message: "rowNumber needs at least one partition column" });
+    }
+    const partition = rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ");
+    const order = rowNumber.orderBy.length === 0 ? "" : ` ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
+    columnList.push(`ROW_NUMBER() OVER (PARTITION BY ${partition}${order}) AS ${dialect.quoteIdent({ name: rowNumber.alias })}`);
+  }
+  let distinctPrefix = "";
+  if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
+    if (!dialect.capabilities.distinctOn) {
+      throw unsupportedCapability({
+        dialect: dialect.name,
+        feature: "SELECT DISTINCT ON",
+        hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
+      });
+    }
+    distinctPrefix = `DISTINCT ON (${statement.distinctOn.map((column) => quoteCol(dialect, column)).join(", ")}) `;
+  }
+  const columns = columnList.length === 0 ? "*" : columnList.join(", ");
+  let from;
+  if (statement.fromSelect !== undefined) {
+    if (statement.table.alias !== undefined) {
+      throw internalError({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+    }
+    const inner = renderSelect({ dialect, statement: statement.fromSelect, collector });
+    from = `(${inner.text}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
+  } else {
+    from = renderTable(dialect, statement.table);
+  }
+  let text = `SELECT ${distinctPrefix}${columns} FROM ${from}`;
+  if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
+    for (const join of statement.innerJoins) {
+      if (join.on.length === 0) {
+        throw internalError({ message: "inner join needs at least one ON pair" });
+      }
+      const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
+      text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
+    }
+  }
+  if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
+    if (!dialect.capabilities.lateralJoin) {
+      throw unsupportedCapability({
+        dialect: dialect.name,
+        feature: "LATERAL JOIN relation loading",
+        hint: 'use the portable "query" relation strategy on this dialect'
+      });
+    }
+    for (const join of statement.lateralJoins) {
+      text += ` ${renderLateralJoin({ dialect, join, collector })}`;
+    }
+  }
+  if (statement.where !== undefined) {
+    text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
+  }
+  if (statement.groupBy !== undefined && statement.groupBy.length > 0) {
+    text += ` GROUP BY ${statement.groupBy.map((column) => quoteCol(dialect, column)).join(", ")}`;
+  }
+  if (statement.having !== undefined) {
+    text += ` HAVING ${renderExpr({ dialect, expr: statement.having, collector })}`;
+  }
+  if (statement.orderBy !== undefined && statement.orderBy.length > 0) {
+    const terms = statement.orderBy.map((term) => renderOrderTerm({ dialect, term, collector }));
+    text += ` ORDER BY ${terms.join(", ")}`;
+  }
+  if (statement.limit !== undefined) {
+    assertCount(statement.limit, "limit");
+    text += ` LIMIT ${statement.limit}`;
+  }
+  if (statement.offset !== undefined) {
+    assertCount(statement.offset, "offset");
+    if (statement.limit === undefined && dialect.offsetRequiresLimit !== null) {
+      text += ` LIMIT ${dialect.offsetRequiresLimit.limitText}`;
+    }
+    text += ` OFFSET ${statement.offset}`;
+  }
+  if (statement.lockForUpdate === true && dialect.selectForUpdate !== null) {
+    text += dialect.selectForUpdate;
+  }
+  return { text, values: collector.values, returning: "none" };
+}
+function renderInsert(params) {
+  const { dialect, statement, collector } = params;
+  if (statement.columns.length === 0) {
+    throw internalError({ message: "insert requires at least one column" });
+  }
+  if (statement.rows.length === 0) {
+    throw internalError({ message: "insert requires at least one row" });
+  }
+  for (const row of statement.rows) {
+    if (row.length !== statement.columns.length) {
+      throw internalError({
+        message: `insert row has ${row.length} values but ${statement.columns.length} columns`
+      });
+    }
+  }
+  const onConflict = statement.onConflict;
+  const skipConflicts = onConflict !== undefined && "doNothing" in onConflict;
+  const insertKeyword = skipConflicts && dialect.doNothingForm === "insertIgnore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+  const rowsSql = statement.rows.map((row) => `(${row.map((value) => {
+    if (isJsonParamCell(value))
+      return `${collector.add(value.text)}${dialect.jsonParamCast}`;
+    if (!isSqlDefaultCell(value))
+      return collector.add(value);
+    if (!dialect.rowDefaultKeyword) {
+      throw internalError({
+        message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
+      });
+    }
+    return "DEFAULT";
+  }).join(", ")})`).join(", ");
+  let text = `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) VALUES ${rowsSql}`;
+  if (onConflict !== undefined) {
+    if ("doNothing" in onConflict) {
+      if (dialect.doNothingForm === "onConflictDoNothing") {
+        const target = onConflict.columns === undefined || onConflict.columns.length === 0 ? "" : ` (${onConflict.columns.map((name) => dialect.quoteIdent({ name })).join(", ")})`;
+        text += ` ON CONFLICT${target} DO NOTHING`;
+      }
+    } else {
+      const updates = Object.entries(onConflict.update);
+      if (updates.length === 0) {
+        throw internalError({ message: "upsert update must set at least one column" });
+      }
+      const selfRef = dialect.quoteIdent({ name: statement.table.name });
+      const assignments = renderAssignments({ dialect, entries: updates, collector, selfRef });
+      if (dialect.upsertForm === "onConflict") {
+        if (onConflict.lastInsertIdColumn !== undefined) {
+          throw internalError({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+        }
+        const conflictColumns = onConflict.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
+        text += ` ON CONFLICT (${conflictColumns}) DO UPDATE SET ${assignments}`;
+      } else {
+        const trick = onConflict.lastInsertIdColumn === undefined ? "" : `, ${dialect.quoteIdent({ name: onConflict.lastInsertIdColumn })} = LAST_INSERT_ID(${dialect.quoteIdent({ name: onConflict.lastInsertIdColumn })})`;
+        text += ` ON DUPLICATE KEY UPDATE ${assignments}${trick}`;
+      }
+    }
+  }
+  const returning = applyReturning({ dialect, requested: statement.returning });
+  return { text: text + returning.suffix, values: collector.values, returning: returning.status };
+}
+function renderUpdate(params) {
+  const { dialect, statement, collector } = params;
+  const assignments = Object.entries(statement.set);
+  if (assignments.length === 0) {
+    throw internalError({ message: "update must set at least one column" });
+  }
+  const setSql = renderAssignments({ dialect, entries: assignments, collector });
+  let text = `UPDATE ${renderTable(dialect, statement.table)} SET ${setSql}`;
+  if (statement.where !== undefined) {
+    text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
+  }
+  const returning = applyReturning({ dialect, requested: statement.returning });
+  return { text: text + returning.suffix, values: collector.values, returning: returning.status };
+}
+function renderAssignments(params) {
+  const { dialect, entries, collector, selfRef } = params;
+  return entries.map(([name, value]) => {
+    const column = dialect.quoteIdent({ name });
+    const read = selfRef === undefined ? column : `${selfRef}.${column}`;
+    if (isJsonParamCell(value)) {
+      return `${column} = ${collector.add(value.text)}${dialect.jsonParamCast}`;
+    }
+    if (isSetOperation(value)) {
+      return `${column} = ${read} ${SET_OPERATION_SQL[value.__op]} ${collector.add(value.value)}`;
+    }
+    if (isListSetOperation(value)) {
+      assertScalarArrays(dialect, 'the scalar-list update operation "push"');
+      if (value.__listOp === "append") {
+        return `${column} = array_append(${read}, ${collector.add(value.value)})`;
+      }
+      return `${column} = ${read} || ${collector.add(value.value)}`;
+    }
+    return `${column} = ${collector.add(value)}`;
+  }).join(", ");
+}
+function renderDelete(params) {
+  const { dialect, statement, collector } = params;
+  let text = `DELETE FROM ${renderTable(dialect, statement.table)}`;
+  if (statement.where !== undefined) {
+    text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
+  }
+  const returning = applyReturning({ dialect, requested: statement.returning });
+  return { text: text + returning.suffix, values: collector.values, returning: returning.status };
+}
+export {
+  strictMatchPattern,
+  startsWithPattern,
+  sqliteDialect,
+  renderStatement,
+  renderFragment,
+  renderExpr,
+  postgresDialect,
+  mysqlDialect,
+  jsonParamCell,
+  isSqlDefaultCell,
+  isSetOperation,
+  isListSetOperation,
+  isJsonParamCell,
+  getSqlDialect,
+  escapeLikePattern,
+  escapeGlobPattern,
+  endsWithPattern,
+  decodeIsNoop,
+  containsPattern,
+  SQL_DIALECTS,
+  SQL_DEFAULT_CELL,
+  SQLITE_CODECS,
+  SQLITE_CAPABILITIES,
+  ParamCollector,
+  POSTGRES_CODECS,
+  POSTGRES_CAPABILITIES,
+  MYSQL_CODECS,
+  MYSQL_CAPABILITIES,
+  DIALECT_CODECS,
+  DIALECT_CAPABILITIES
+};
+
+//# debugId=2B8F0892BD46367D64756E2164756E21