@vsrepo/drizzle-adapter 0.1.0

package/dist/index.js

@@ -0,0 +1,1525 @@
+// src/drizzle.adapter.ts
+import { avg, count as countFn, eq as eq3, max as maxFn, min as minFn, sql as sql2, sum as sumFn } from "drizzle-orm";
+import {
+  AdapterErrorCode as AdapterErrorCode10,
+  VSRepoAdapter,
+  VSRepoAdapterError as VSRepoAdapterError10
+} from "vsrepo";
+
+// src/resolvers/fields-config.resolver.ts
+import { AdapterErrorCode, VSRepoAdapterError } from "vsrepo";
+import { getColumns, getTableName } from "drizzle-orm";
+function resolveFieldsConfig(table) {
+  let pk;
+  for (const column of Object.values(getColumns(table))) {
+    if (column.primary) {
+      pk = column.name;
+      break;
+    }
+  }
+  if (!pk) {
+    throw new VSRepoAdapterError(
+      `Table '${getTableName(table)}' has no primary key defined. VSRepoDrizzleAdapter requires every table to declare a primary key.`,
+      AdapterErrorCode.INVALID_ADAPTER_CONFIG,
+      null
+    );
+  }
+  return { pk };
+}
+
+// src/resolvers/isolation-level.resolver.ts
+var isolationRecord = {
+  ReadCommitted: "read committed",
+  ReadUncommitted: "read uncommitted",
+  RepeatableRead: "repeatable read",
+  Serializable: "serializable"
+};
+function resolveIsolationLevel(vsrepoIsolation) {
+  return isolationRecord[vsrepoIsolation];
+}
+
+// src/resolvers/raw-sql.resolver.ts
+import { SQL, StringChunk, Param } from "drizzle-orm";
+var PLACEHOLDER_PATTERNS = {
+  postgresql: /\$(\d+)/g,
+  cockroach: /\$(\d+)/g,
+  sqlite: /\?/g
+};
+var NUMBERED_DIALECTS = /* @__PURE__ */ new Set(["postgresql", "cockroach"]);
+function resolveRawSql(dialect, query, args = []) {
+  const pattern = PLACEHOLDER_PATTERNS[dialect];
+  const isNumbered = NUMBERED_DIALECTS.has(dialect);
+  const chunks = [];
+  let lastIndex = 0;
+  let positionalIndex = 0;
+  for (const match of query.matchAll(pattern)) {
+    chunks.push(new StringChunk(query.slice(lastIndex, match.index)));
+    const argIndex = isNumbered ? Number(match[1]) - 1 : positionalIndex++;
+    chunks.push(new Param(args[argIndex]));
+    lastIndex = match.index + match[0].length;
+  }
+  chunks.push(new StringChunk(query.slice(lastIndex)));
+  return new SQL(chunks);
+}
+
+// src/resolvers/raw-result.resolver.ts
+function resolveRawResult(dialect, result, modifying) {
+  switch (dialect) {
+    case "postgresql":
+    case "cockroach":
+      return modifying ? result.rowCount ?? 0 : result.rows;
+    // assume node-postgres
+    case "sqlite":
+      return modifying ? result.changes ?? 0 : result;
+  }
+}
+
+// src/resolvers/map-drizzle-error.resolver.ts
+import { AdapterErrorCode as AdapterErrorCode2, VSRepoAdapterError as VSRepoAdapterError2 } from "vsrepo";
+import { DrizzleQueryError, TransactionRollbackError } from "drizzle-orm";
+var POSTGRES_SQLSTATE_MAP = {
+  "23505": AdapterErrorCode2.UNIQUE_CONSTRAINT_VIOLATION,
+  "23503": AdapterErrorCode2.FOREIGN_KEY_VIOLATION,
+  "23502": AdapterErrorCode2.NOT_NULL_VIOLATION,
+  "23514": AdapterErrorCode2.CHECK_VIOLATION,
+  "23000": AdapterErrorCode2.CONSTRAINT_VIOLATION,
+  "22001": AdapterErrorCode2.VALUE_TOO_LONG,
+  "22P02": AdapterErrorCode2.CONVERSION_ERROR,
+  "42601": AdapterErrorCode2.INVALID_QUERY,
+  "42703": AdapterErrorCode2.TABLE_OR_COLUMN_NOT_FOUND,
+  "42P01": AdapterErrorCode2.TABLE_OR_COLUMN_NOT_FOUND,
+  "40P01": AdapterErrorCode2.DEADLOCK,
+  "40001": AdapterErrorCode2.TRANSACTION_CONFLICT,
+  "55P03": AdapterErrorCode2.LOCK_TIMEOUT,
+  "57014": AdapterErrorCode2.TIMEOUT,
+  "28000": AdapterErrorCode2.INVALID_CREDENTIALS,
+  "28P01": AdapterErrorCode2.INVALID_CREDENTIALS,
+  "3D000": AdapterErrorCode2.CONNECTION_FAILED
+};
+var SQLITE_CODE_MAP = {
+  SQLITE_CONSTRAINT_UNIQUE: AdapterErrorCode2.UNIQUE_CONSTRAINT_VIOLATION,
+  SQLITE_CONSTRAINT_PRIMARYKEY: AdapterErrorCode2.UNIQUE_CONSTRAINT_VIOLATION,
+  SQLITE_CONSTRAINT_FOREIGNKEY: AdapterErrorCode2.FOREIGN_KEY_VIOLATION,
+  SQLITE_CONSTRAINT_NOTNULL: AdapterErrorCode2.NOT_NULL_VIOLATION,
+  SQLITE_CONSTRAINT_CHECK: AdapterErrorCode2.CHECK_VIOLATION,
+  SQLITE_CONSTRAINT: AdapterErrorCode2.CONSTRAINT_VIOLATION,
+  SQLITE_BUSY: AdapterErrorCode2.LOCK_TIMEOUT,
+  SQLITE_LOCKED: AdapterErrorCode2.LOCKED,
+  SQLITE_MISUSE: AdapterErrorCode2.INVALID_QUERY,
+  SQLITE_CANTOPEN: AdapterErrorCode2.CONNECTION_FAILED
+};
+function resolveCodeFromDriverError(dialect, error) {
+  switch (dialect) {
+    case "postgresql":
+    case "cockroach":
+      return typeof error.code === "string" ? POSTGRES_SQLSTATE_MAP[error.code] : void 0;
+    case "sqlite":
+      return typeof error.code === "string" ? SQLITE_CODE_MAP[error.code] : void 0;
+  }
+}
+function mapDrizzleError(error, operation, dialect) {
+  if (error instanceof VSRepoAdapterError2) return error;
+  if (error instanceof TransactionRollbackError) {
+    return new VSRepoAdapterError2(
+      `'${operation}' was rolled back intentionally via 'tx.rollback()'`,
+      AdapterErrorCode2.UNKNOWN,
+      error
+    );
+  }
+  const driverError = error instanceof DrizzleQueryError && error.cause ? error.cause : error;
+  const code = resolveCodeFromDriverError(dialect, driverError);
+  return new VSRepoAdapterError2(
+    `'${operation}' failed: ${driverError?.message ?? "unknown error"}`,
+    code ?? AdapterErrorCode2.UNKNOWN,
+    error
+  );
+}
+
+// src/validators/validate-adapter-config.validator.ts
+import { is, Table as Table2 } from "drizzle-orm";
+import { AdapterErrorCode as AdapterErrorCode3, VSRepoAdapterError as VSRepoAdapterError3 } from "vsrepo";
+var SUPPORTED_DIALECTS = /* @__PURE__ */ new Set(["postgresql", "sqlite", "cockroach"]);
+function validateDrizzleAdapterConfig(db, config) {
+  if (db === null || db === void 0) {
+    throw new VSRepoAdapterError3(
+      "Missing Drizzle client: the first constructor argument (db) is null/undefined.",
+      AdapterErrorCode3.MISSING_DB_CLIENT,
+      null
+    );
+  }
+  const dbLike = db;
+  if (typeof dbLike.query !== "object" || dbLike.query === null) {
+    throw new VSRepoAdapterError3(
+      "Invalid Drizzle client: 'db.query' is undefined \u2014 the client must be created with the 'relations' config (e.g. 'drizzle(connection, { relations })') for DrizzleAdapter to run relational queries.",
+      AdapterErrorCode3.MISSING_DB_CLIENT,
+      null
+    );
+  }
+  if (config === null || config === void 0) {
+    throw new VSRepoAdapterError3(
+      "Invalid constructor config: the second constructor argument (config) is null/undefined.",
+      AdapterErrorCode3.INVALID_ADAPTER_CONFIG,
+      null
+    );
+  }
+  const { table, dialect, queryKey } = config;
+  if (!is(table, Table2)) {
+    throw new VSRepoAdapterError3(
+      "Invalid constructor config (table): expected a Drizzle 'Table' instance (the object exported by your schema, e.g. 'userTable').",
+      AdapterErrorCode3.INVALID_ADAPTER_CONFIG,
+      null
+    );
+  }
+  if (dialect !== void 0 && !SUPPORTED_DIALECTS.has(dialect)) {
+    throw new VSRepoAdapterError3(
+      `Invalid constructor config (dialect): '${String(dialect)}' is not supported. Expected one of: ${[...SUPPORTED_DIALECTS].join(", ")}.`,
+      AdapterErrorCode3.INVALID_ADAPTER_CONFIG,
+      null
+    );
+  }
+  if (typeof queryKey !== "string" || queryKey.length === 0) {
+    throw new VSRepoAdapterError3(
+      "Invalid constructor config (queryKey): expected a non-empty string matching a key of 'db.query' (the name your schema exports the table under, e.g. 'userTable').",
+      AdapterErrorCode3.INVALID_ADAPTER_CONFIG,
+      null
+    );
+  }
+  const queryEntry = dbLike.query[queryKey];
+  if (typeof queryEntry !== "object" || queryEntry === null || typeof queryEntry.findFirst !== "function" || typeof queryEntry.findMany !== "function") {
+    throw new VSRepoAdapterError3(
+      `Invalid constructor config (queryKey): no relational query builder found for '${queryKey}' on 'db.query' (expected 'db.query.${queryKey}' to exist \u2014 check that '${queryKey}' matches the name your schema exports the table under, and that the table is included in the 'relations' config).`,
+      AdapterErrorCode3.MODEL_NOT_FOUND,
+      null
+    );
+  }
+  return { db, config };
+}
+
+// src/validators/validate-relations.validator.ts
+import { getColumns as getColumns2, getTableName as getTableName2, is as is2, Table as Table3 } from "drizzle-orm";
+import { AdapterErrorCode as AdapterErrorCode4, VSRepoAdapterError as VSRepoAdapterError4 } from "vsrepo";
+
+// src/validators/is-plain-object.validator.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+
+// src/validators/validate-relations.validator.ts
+var MODES = /* @__PURE__ */ new Set(["otm", "mto", "oto"]);
+var RESTRICTIONS = /* @__PURE__ */ new Set(["set", "add"]);
+function fail(message) {
+  throw new VSRepoAdapterError4(message, AdapterErrorCode4.INVALID_ADAPTER_CONFIG, null);
+}
+function validateRelations(table, dialect, relations) {
+  if (relations === void 0) return void 0;
+  if (!isPlainObject(relations)) {
+    fail(
+      "Invalid constructor config (relations): expected an object mapping relation field names to their config."
+    );
+  }
+  const hereColumns = new Set(Object.keys(getColumns2(table)));
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [key, rawRelation] of Object.entries(relations)) {
+    if (rawRelation === void 0) continue;
+    if (!isPlainObject(rawRelation)) {
+      fail(`Invalid constructor config (relations.${key}): expected an object (an 'AdapterRelation').`);
+    }
+    const { mode, restriction, table: relatedTable, fkHere, fkThere, nullable } = rawRelation;
+    if (!is2(relatedTable, Table3)) {
+      fail(
+        `Invalid constructor config (relations.${key}.table): expected a Drizzle 'Table' instance (the object exported by your schema).`
+      );
+    }
+    if (!MODES.has(mode)) {
+      fail(
+        `Invalid constructor config (relations.${key}.mode): expected one of 'otm' | 'mto' | 'oto', got '${String(mode)}'.`
+      );
+    }
+    if (!RESTRICTIONS.has(restriction)) {
+      fail(
+        `Invalid constructor config (relations.${key}.restriction): expected one of 'set' | 'add', got '${String(restriction)}'.`
+      );
+    }
+    const thereColumns = new Set(Object.keys(getColumns2(relatedTable)));
+    if (mode === "otm") {
+      if (fkHere !== void 0) {
+        fail(`Invalid constructor config (relations.${key}): mode 'otm' doesn't accept 'fkHere'.`);
+      }
+      if (typeof fkThere !== "string" || fkThere.length === 0) {
+        fail(
+          `Invalid constructor config (relations.${key}): mode 'otm' requires 'fkThere' (a column of the related table).`
+        );
+      }
+      if (!thereColumns.has(fkThere)) {
+        fail(
+          `Invalid constructor config (relations.${key}.fkThere): '${fkThere}' is not a column of table '${getTableName2(relatedTable)}'.`
+        );
+      }
+    } else if (mode === "mto") {
+      if (fkThere !== void 0) {
+        fail(`Invalid constructor config (relations.${key}): mode 'mto' doesn't accept 'fkThere'.`);
+      }
+      if (typeof fkHere !== "string" || fkHere.length === 0) {
+        fail(
+          `Invalid constructor config (relations.${key}): mode 'mto' requires 'fkHere' (a column of this adapter's table).`
+        );
+      }
+      if (!hereColumns.has(fkHere)) {
+        fail(
+          `Invalid constructor config (relations.${key}.fkHere): '${fkHere}' is not a column of table '${getTableName2(table)}'.`
+        );
+      }
+      if (nullable !== void 0 && typeof nullable !== "boolean") {
+        fail(`Invalid constructor config (relations.${key}.nullable): expected a boolean.`);
+      }
+    } else {
+      const hasHere = fkHere !== void 0;
+      const hasThere = fkThere !== void 0;
+      if (hasHere === hasThere) {
+        fail(
+          `Invalid constructor config (relations.${key}): mode 'oto' requires exactly one of 'fkHere' / 'fkThere'.`
+        );
+      }
+      if (hasHere) {
+        if (typeof fkHere !== "string" || !hereColumns.has(fkHere)) {
+          fail(
+            `Invalid constructor config (relations.${key}.fkHere): '${String(fkHere)}' is not a column of table '${getTableName2(table)}'.`
+          );
+        }
+      } else {
+        if (typeof fkThere !== "string" || !thereColumns.has(fkThere)) {
+          fail(
+            `Invalid constructor config (relations.${key}.fkThere): '${String(fkThere)}' is not a column of table '${getTableName2(relatedTable)}'.`
+          );
+        }
+      }
+    }
+    const relatedFieldsConfig = resolveFieldsConfig(relatedTable);
+    resolved.set(key, {
+      mode,
+      restriction,
+      table: relatedTable,
+      fkHere,
+      fkThere,
+      nullable,
+      relatedPk: relatedFieldsConfig.pk
+    });
+  }
+  return resolved;
+}
+
+// src/parsers/columns.parser.ts
+function parseColumns(select) {
+  const columns = {};
+  let withResult;
+  for (const [key, value] of Object.entries(select)) {
+    if (value === void 0) continue;
+    if (isPlainObject(value)) {
+      withResult ??= {};
+      const nested = parseColumns(value);
+      withResult[key] = nested.with ? { columns: nested.columns, with: nested.with } : { columns: nested.columns };
+    } else {
+      columns[key] = value;
+    }
+  }
+  return { columns, with: withResult };
+}
+
+// src/parsers/with.parser.ts
+function parseWith(relations) {
+  const result = {};
+  for (const [key, value] of Object.entries(relations)) {
+    if (value === void 0) continue;
+    result[key] = isPlainObject(value) ? { with: parseWith(value) } : value;
+  }
+  return result;
+}
+
+// src/parsers/where.parser.ts
+import { AdapterErrorCode as AdapterErrorCode5, VSRepoAdapterError as VSRepoAdapterError5 } from "vsrepo";
+var FIELD_OPERATOR_KEYS = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "ignoreCase"
+]);
+function isFieldOperatorObject(value) {
+  return Object.keys(value).some((key) => FIELD_OPERATOR_KEYS.has(key));
+}
+function isArrayRelationFilter(value) {
+  return "_some" in value || "_every" in value || "_none" in value;
+}
+function isObjectRelationFilter(value) {
+  return "_with" in value || "_without" in value;
+}
+function parseFieldOperators(value, dialect) {
+  const result = {};
+  const likeKey = value.ignoreCase === true && dialect !== "sqlite" ? "ilike" : "like";
+  for (const [key, val] of Object.entries(value)) {
+    if (val === void 0) continue;
+    switch (key) {
+      case "ignoreCase":
+        break;
+      case "equals":
+        result.eq = val;
+        break;
+      case "between": {
+        const [min, max] = val;
+        if (min !== void 0) result.gte = min;
+        if (max !== void 0) result.lte = max;
+        break;
+      }
+      case "contains":
+        result[likeKey] = `%${val}%`;
+        break;
+      case "startsWith":
+        result[likeKey] = `${val}%`;
+        break;
+      case "endsWith":
+        result[likeKey] = `%${val}`;
+        break;
+      case "not":
+        result.NOT = isPlainObject(val) && isFieldOperatorObject(val) ? parseFieldOperators(val, dialect) : val;
+        break;
+      default:
+        result[key] = val;
+    }
+  }
+  return result;
+}
+function parseArrayRelationFilter(value, dialect) {
+  if (value._every !== void 0 || value._none !== void 0) {
+    throw new VSRepoAdapterError5(
+      "Drizzle's relational query API has no native 'every'/'none' filter for to-many relations (only an implicit 'some'/exists filter, via '_some') \u2014 rewrite the filter using '_some', or fall back to 'query()' with raw SQL.",
+      AdapterErrorCode5.NOT_SUPPORTED,
+      null
+    );
+  }
+  return parsePlainWhere(value._some, dialect) ?? {};
+}
+function parseObjectRelationFilter(value, dialect) {
+  if (value._with !== void 0) {
+    return parsePlainWhere(value._with, dialect) ?? {};
+  }
+  if (value._without !== void 0) {
+    return { NOT: parsePlainWhere(value._without, dialect) };
+  }
+  return {};
+}
+function parseFieldValue(value, dialect) {
+  if (value === null || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return { in: value };
+  }
+  const obj = value;
+  if (isArrayRelationFilter(obj)) return parseArrayRelationFilter(obj, dialect);
+  if (isObjectRelationFilter(obj)) return parseObjectRelationFilter(obj, dialect);
+  if (isFieldOperatorObject(obj)) return parseFieldOperators(obj, dialect);
+  return parsePlainWhere(obj, dialect);
+}
+function parsePlainWhere(where, dialect) {
+  if (where === void 0 || where === null) return void 0;
+  const result = {};
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    result[key] = parseFieldValue(value, dialect);
+  }
+  return result;
+}
+function parseWhere(where, dialect) {
+  if (where === void 0 || where === null) return void 0;
+  const result = {};
+  let andList;
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "AND") {
+      const list = Array.isArray(value) ? value : [value];
+      andList = [...andList ?? [], ...list.map((v) => parseWhere(v, dialect))];
+      continue;
+    }
+    if (key === "OR") {
+      const list = Array.isArray(value) ? value : [value];
+      result.OR = list.map((v) => parseWhere(v, dialect));
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(value)) {
+        andList = [...andList ?? [], ...value.map((v) => ({ NOT: parseWhere(v, dialect) }))];
+      } else {
+        result.NOT = parseWhere(value, dialect);
+      }
+      continue;
+    }
+    result[key] = parseFieldValue(value, dialect);
+  }
+  if (andList) result.AND = andList;
+  return result;
+}
+function parseDrizzleWhere(where, dialect) {
+  return parseWhere(where, dialect);
+}
+function hasQuantifierFilter(where) {
+  if (where === null || where === void 0) return false;
+  if (Array.isArray(where)) {
+    return where.some(hasQuantifierFilter);
+  }
+  if (typeof where !== "object" || where instanceof Date) {
+    return false;
+  }
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "_every" || key === "_none") return true;
+    if (hasQuantifierFilter(value)) return true;
+  }
+  return false;
+}
+
+// src/parsers/sql-where.parser.ts
+import {
+  and,
+  eq,
+  exists,
+  getTableName as getTableName3,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  not,
+  notInArray,
+  or,
+  sql
+} from "drizzle-orm";
+import { AdapterErrorCode as AdapterErrorCode6, VSRepoAdapterError as VSRepoAdapterError6 } from "vsrepo";
+var FIELD_OPERATOR_KEYS2 = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "ignoreCase"
+]);
+function isFieldOperatorObject2(value) {
+  return Object.keys(value).some((key) => FIELD_OPERATOR_KEYS2.has(key));
+}
+function isArrayRelationFilter2(value) {
+  return "_some" in value || "_every" in value || "_none" in value;
+}
+function isObjectRelationFilter2(value) {
+  return "_with" in value || "_without" in value;
+}
+function buildFieldOperators(column, ops) {
+  const parts = [];
+  const likeFn = ops.ignoreCase === true ? (column2, pattern) => sql`lower(${column2}) like lower(${pattern})` : like;
+  for (const [key, val] of Object.entries(ops)) {
+    if (val === void 0) continue;
+    switch (key) {
+      case "ignoreCase":
+        break;
+      case "equals":
+        parts.push(val === null ? isNull(column) : eq(column, val));
+        break;
+      case "not": {
+        if (val === null) {
+          parts.push(isNotNull(column));
+          break;
+        }
+        const inner = isPlainObject(val) && isFieldOperatorObject2(val) ? buildFieldOperators(column, val) : eq(column, val);
+        if (inner) parts.push(not(inner));
+        break;
+      }
+      case "in":
+        parts.push(inArray(column, val));
+        break;
+      case "notIn":
+        parts.push(notInArray(column, val));
+        break;
+      case "gt":
+        parts.push(gt(column, val));
+        break;
+      case "gte":
+        parts.push(gte(column, val));
+        break;
+      case "lt":
+        parts.push(lt(column, val));
+        break;
+      case "lte":
+        parts.push(lte(column, val));
+        break;
+      case "between": {
+        const [min, max] = val;
+        if (min !== void 0) parts.push(gte(column, min));
+        if (max !== void 0) parts.push(lte(column, max));
+        break;
+      }
+      case "contains":
+        parts.push(likeFn(column, `%${val}%`));
+        break;
+      case "startsWith":
+        parts.push(likeFn(column, `${val}%`));
+        break;
+      case "endsWith":
+        parts.push(likeFn(column, `%${val}`));
+        break;
+    }
+  }
+  if (parts.length === 0) return void 0;
+  return parts.length === 1 ? parts[0] : and(...parts);
+}
+function buildJoinCondition(relation, ctx) {
+  const relatedColumns = relation.table;
+  const hereColumns = ctx.table;
+  if (relation.fkHere) {
+    return eq(relatedColumns[relation.relatedPk], hereColumns[relation.fkHere]);
+  }
+  return eq(relatedColumns[relation.fkThere], hereColumns[ctx.pk]);
+}
+function buildExists(relation, condition, ctx) {
+  const subquery = ctx.db.select({ one: sql`1` }).from(relation.table).where(condition);
+  return exists(subquery);
+}
+function buildRelationCondition(key, value, relation, ctx) {
+  const nestedCtx = { ...ctx, table: relation.table, relations: void 0 };
+  if (isArrayRelationFilter2(value)) {
+    if (relation.mode !== "otm") {
+      throw new VSRepoAdapterError6(
+        `Field '${key}': '_some'/'_every'/'_none' can only be used on a to-many ('otm') relation.`,
+        AdapterErrorCode6.INVALID_DATA,
+        null
+      );
+    }
+    const join2 = buildJoinCondition(relation, ctx);
+    if (value._some !== void 0) {
+      const nested3 = parsePlainWhere2(value._some, nestedCtx);
+      return buildExists(relation, nested3 ? and(join2, nested3) : join2, ctx);
+    }
+    if (value._none !== void 0) {
+      const nested3 = parsePlainWhere2(value._none, nestedCtx);
+      return not(buildExists(relation, nested3 ? and(join2, nested3) : join2, ctx));
+    }
+    const nested2 = parsePlainWhere2(value._every, nestedCtx);
+    if (!nested2) return sql`(1 = 1)`;
+    return not(buildExists(relation, and(join2, not(nested2)), ctx));
+  }
+  if (isObjectRelationFilter2(value)) {
+    const isWithout = "_without" in value;
+    const filter = isWithout ? value._without : value._with;
+    const join2 = buildJoinCondition(relation, ctx);
+    const nested2 = parsePlainWhere2(filter, nestedCtx);
+    const condition = nested2 ? and(join2, isWithout ? not(nested2) : nested2) : join2;
+    return buildExists(relation, condition, ctx);
+  }
+  if (relation.mode === "otm") {
+    throw new VSRepoAdapterError6(
+      `Field '${key}': to-many relation filters require '_some' (or the unsupported '_every'/'_none').`,
+      AdapterErrorCode6.INVALID_DATA,
+      null
+    );
+  }
+  const join = buildJoinCondition(relation, ctx);
+  const nested = parsePlainWhere2(value, nestedCtx);
+  return buildExists(relation, nested ? and(join, nested) : join, ctx);
+}
+function buildFieldCondition(column, value) {
+  if (value === null) return isNull(column);
+  if (value instanceof Date || typeof value !== "object") {
+    return eq(column, value);
+  }
+  if (Array.isArray(value)) {
+    return inArray(column, value);
+  }
+  return buildFieldOperators(column, value);
+}
+function parsePlainWhere2(where, ctx) {
+  if (where === void 0 || where === null) return void 0;
+  const tableColumns = ctx.table;
+  const parts = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    const relation = ctx.relations?.get(key);
+    if (relation) {
+      parts.push(buildRelationCondition(key, value, relation, ctx));
+      continue;
+    }
+    const column = tableColumns[key];
+    if (column === void 0) {
+      throw new VSRepoAdapterError6(
+        `Unknown field '${key}' in 'where': no column or configured relation with that name on table '${getTableName3(ctx.table)}'.`,
+        AdapterErrorCode6.FIELD_NOT_FOUND,
+        null
+      );
+    }
+    const condition = buildFieldCondition(column, value);
+    if (condition) parts.push(condition);
+  }
+  if (parts.length === 0) return void 0;
+  return parts.length === 1 ? parts[0] : and(...parts);
+}
+function parseWhere2(where, ctx) {
+  if (where === void 0 || where === null) return void 0;
+  const parts = [];
+  let orPart;
+  const plainEntries = {};
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "AND") {
+      const list = Array.isArray(value) ? value : [value];
+      for (const v of list) {
+        const c = parseWhere2(v, ctx);
+        if (c) parts.push(c);
+      }
+      continue;
+    }
+    if (key === "OR") {
+      const list = Array.isArray(value) ? value : [value];
+      const ors = list.map((v) => parseWhere2(v, ctx)).filter((c) => c !== void 0);
+      if (ors.length > 0) orPart = ors.length === 1 ? ors[0] : or(...ors);
+      continue;
+    }
+    if (key === "NOT") {
+      const list = Array.isArray(value) ? value : [value];
+      for (const v of list) {
+        const c = parseWhere2(v, ctx);
+        if (c) parts.push(not(c));
+      }
+      continue;
+    }
+    plainEntries[key] = value;
+  }
+  const plainCondition = parsePlainWhere2(plainEntries, ctx);
+  if (plainCondition) parts.push(plainCondition);
+  if (orPart) parts.push(orPart);
+  if (parts.length === 0) return void 0;
+  return parts.length === 1 ? parts[0] : and(...parts);
+}
+function parseSqlWhere(where, ctx) {
+  return parseWhere2(where, ctx);
+}
+
+// src/parsers/order-by.parser.ts
+import { AdapterErrorCode as AdapterErrorCode7, VSRepoAdapterError as VSRepoAdapterError7 } from "vsrepo";
+function isSortDirection(value) {
+  return value === "asc" || value === "desc" || value === "ASC" || value === "DESC";
+}
+function parseOrderByField(order) {
+  const result = {};
+  for (const [key, value] of Object.entries(order)) {
+    if (value === void 0) continue;
+    if (isSortDirection(value)) {
+      result[key] = value.toLowerCase();
+      continue;
+    }
+    if (isPlainObject(value)) {
+      throw new VSRepoAdapterError7(
+        `Ordering by a nested relation field ('${key}') isn't supported at the top level of a Drizzle relational query \u2014 nest the ordering inside that relation's own 'with' config instead.`,
+        AdapterErrorCode7.NOT_SUPPORTED,
+        null
+      );
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function parseOrderBy(order) {
+  if (order === void 0 || order === null) return void 0;
+  if (!Array.isArray(order)) return parseOrderByField(order);
+  return order.reduce((acc, field) => ({ ...acc, ...parseOrderByField(field) }), {});
+}
+
+// src/parsers/sql-order-by.parser.ts
+import { asc, desc } from "drizzle-orm";
+import { AdapterErrorCode as AdapterErrorCode8, VSRepoAdapterError as VSRepoAdapterError8 } from "vsrepo";
+function isSortDirection2(value) {
+  return value === "asc" || value === "desc" || value === "ASC" || value === "DESC";
+}
+function pushOrderByField(table, order, acc) {
+  const tableColumns = table;
+  for (const [key, value] of Object.entries(order)) {
+    if (value === void 0) continue;
+    if (!isSortDirection2(value)) {
+      if (isPlainObject(value)) {
+        throw new VSRepoAdapterError8(
+          `Ordering by a nested relation field ('${key}') isn't supported by this adapter.`,
+          AdapterErrorCode8.NOT_SUPPORTED,
+          null
+        );
+      }
+      continue;
+    }
+    const column = tableColumns[key];
+    if (!column) continue;
+    acc.push(value.toString().toLowerCase() === "desc" ? desc(column) : asc(column));
+  }
+}
+function parseSqlOrderBy(table, order) {
+  if (order === void 0 || order === null) return void 0;
+  const acc = [];
+  const list = Array.isArray(order) ? order : [order];
+  for (const field of list) pushOrderByField(table, field, acc);
+  return acc.length > 0 ? acc : void 0;
+}
+
+// src/resolvers/merge-entities.resolver.ts
+function deepMergeValue(target, source) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    return [...target, ...source];
+  }
+  if (isPlainObject(target) && isPlainObject(source)) {
+    return deepMergePlain(target, source);
+  }
+  return source;
+}
+function deepMergePlain(target, source) {
+  const merged = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0) continue;
+    merged[key] = key in target ? deepMergeValue(target[key], value) : value;
+  }
+  return merged;
+}
+function mergeToManyRelation(target, source, relatedPk) {
+  const targetByPk = /* @__PURE__ */ new Map();
+  const targetWithoutPk = [];
+  for (const item of target) {
+    if (item[relatedPk] !== void 0) {
+      targetByPk.set(item[relatedPk], item);
+    } else {
+      targetWithoutPk.push(item);
+    }
+  }
+  const sourceWithoutPk = [];
+  for (const item of source) {
+    if (item[relatedPk] === void 0) {
+      sourceWithoutPk.push(item);
+      continue;
+    }
+    const existing = targetByPk.get(item[relatedPk]);
+    targetByPk.set(item[relatedPk], existing ? deepMergePlain(existing, item) : item);
+  }
+  return [...targetByPk.values(), ...targetWithoutPk, ...sourceWithoutPk];
+}
+function mergeEntities(result, obj, relations) {
+  if (!relations) {
+    return deepMergePlain(result, obj);
+  }
+  const merged = { ...result };
+  for (const [key, field] of Object.entries(obj)) {
+    if (field === void 0) continue;
+    const relation = relations.get(key);
+    if (!relation) {
+      merged[key] = field;
+      continue;
+    }
+    if (relation.mode !== "otm" && isPlainObject(merged[key])) {
+      merged[key] = field === null ? null : deepMergePlain(merged[key], field);
+      continue;
+    }
+    if (relation.mode === "otm" && Array.isArray(merged[key])) {
+      merged[key] = mergeToManyRelation(merged[key], field, relation.relatedPk);
+      continue;
+    }
+    merged[key] = field;
+  }
+  return merged;
+}
+
+// src/resolvers/relation-writes.resolver.ts
+import { and as and2, eq as eq2, ne, notInArray as notInArray2 } from "drizzle-orm";
+import { AdapterErrorCode as AdapterErrorCode9, VSRepoAdapterError as VSRepoAdapterError9 } from "vsrepo";
+var SKIP = /* @__PURE__ */ Symbol("skip");
+function omitKey(item, key) {
+  const clone = { ...item };
+  delete clone[key];
+  return clone;
+}
+function splitWritePayload(obj, relations, pkName, excludePk) {
+  const scalarFields = {};
+  const fkHereEntries = [];
+  const fkThereEntries = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    const relation = relations?.get(key);
+    if (!relation) {
+      if (excludePk && key === pkName) continue;
+      scalarFields[key] = value;
+      continue;
+    }
+    if (relation.fkHere) {
+      fkHereEntries.push([key, relation, value]);
+    } else {
+      fkThereEntries.push([key, relation, value]);
+    }
+  }
+  return { scalarFields, fkHereEntries, fkThereEntries };
+}
+async function resolveFkHereField(tx, relation, field, currentFkValue) {
+  const relatedTable = relation.table;
+  const pkColumn = relatedTable[relation.relatedPk];
+  if (field === null) {
+    if (relation.mode === "mto" && relation.nullable) return null;
+    if (relation.mode === "oto" && relation.restriction === "set") {
+      if (currentFkValue !== void 0 && currentFkValue !== null) {
+        await tx.delete(relation.table).where(eq2(pkColumn, currentFkValue));
+      }
+      return null;
+    }
+    return SKIP;
+  }
+  const pkValue = field[relation.relatedPk];
+  if (pkValue === void 0) {
+    const [created] = await tx.insert(relation.table).values(field).returning();
+    return created[relation.relatedPk];
+  }
+  const existing = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(pkColumn, pkValue)).limit(1);
+  if (existing.length === 0) {
+    await tx.insert(relation.table).values(field);
+  } else if (relation.restriction === "set") {
+    const dataWithoutPk = omitKey(field, relation.relatedPk);
+    if (Object.keys(dataWithoutPk).length > 0) {
+      await tx.update(relation.table).set(dataWithoutPk).where(eq2(pkColumn, pkValue));
+    }
+  }
+  return pkValue;
+}
+async function resolveFkHereFields(tx, entries, scalarFields, currentRow) {
+  for (const [key, relation, value] of entries) {
+    if (value !== null && typeof value !== "object") {
+      throw new VSRepoAdapterError9(
+        `Field '${key}': expected an object or 'null' for a to-one relation, got '${typeof value}'.`,
+        AdapterErrorCode9.INVALID_DATA,
+        null
+      );
+    }
+    const currentFkValue = currentRow?.[relation.fkHere];
+    const resolved = await resolveFkHereField(tx, relation, value, currentFkValue);
+    if (resolved !== SKIP) {
+      scalarFields[relation.fkHere] = resolved;
+    }
+  }
+}
+async function resolveOtmField(tx, relation, items, ownPkValue) {
+  const relatedTable = relation.table;
+  const fkColumn = relatedTable[relation.fkThere];
+  const pkColumn = relatedTable[relation.relatedPk];
+  const withoutPk = items.filter((item) => item[relation.relatedPk] === void 0);
+  const withPk = items.filter((item) => item[relation.relatedPk] !== void 0);
+  const connectedIds = [];
+  for (const item of withoutPk) {
+    const [insertedRow] = await tx.insert(relation.table).values({ ...item, [relation.fkThere]: ownPkValue }).returning();
+    if (insertedRow?.[relation.relatedPk] !== void 0) {
+      connectedIds.push(insertedRow[relation.relatedPk]);
+    }
+  }
+  for (const item of withPk) {
+    const pkValue = item[relation.relatedPk];
+    connectedIds.push(pkValue);
+    const existing = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(pkColumn, pkValue)).limit(1);
+    if (existing.length === 0) {
+      await tx.insert(relation.table).values({ ...item, [relation.fkThere]: ownPkValue });
+      continue;
+    }
+    const setData = relation.restriction === "set" ? { ...omitKey(item, relation.relatedPk), [relation.fkThere]: ownPkValue } : { [relation.fkThere]: ownPkValue };
+    await tx.update(relation.table).set(setData).where(eq2(pkColumn, pkValue));
+  }
+  if (relation.restriction === "set") {
+    const condition = connectedIds.length > 0 ? and2(eq2(fkColumn, ownPkValue), notInArray2(pkColumn, connectedIds)) : eq2(fkColumn, ownPkValue);
+    await tx.delete(relation.table).where(condition);
+  }
+}
+async function resolveOtoFkThereField(tx, relation, field, ownPkValue) {
+  const relatedTable = relation.table;
+  const fkColumn = relatedTable[relation.fkThere];
+  const pkColumn = relatedTable[relation.relatedPk];
+  if (field === null) {
+    if (relation.restriction === "set") {
+      await tx.delete(relation.table).where(eq2(fkColumn, ownPkValue));
+    }
+    return;
+  }
+  const pkValue = field[relation.relatedPk];
+  let keepPk = pkValue;
+  if (pkValue === void 0) {
+    const [insertedRow] = await tx.insert(relation.table).values({ ...field, [relation.fkThere]: ownPkValue }).returning();
+    keepPk = insertedRow?.[relation.relatedPk];
+  } else {
+    const existing = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(pkColumn, pkValue)).limit(1);
+    if (existing.length === 0) {
+      await tx.insert(relation.table).values({ ...field, [relation.fkThere]: ownPkValue });
+    } else {
+      const setData = relation.restriction === "set" ? { ...omitKey(field, relation.relatedPk), [relation.fkThere]: ownPkValue } : { [relation.fkThere]: ownPkValue };
+      await tx.update(relation.table).set(setData).where(eq2(pkColumn, pkValue));
+    }
+  }
+  if (relation.restriction === "set" && keepPk !== void 0) {
+    await tx.delete(relation.table).where(and2(eq2(fkColumn, ownPkValue), ne(pkColumn, keepPk)));
+  }
+}
+async function resolveFkThereFields(tx, entries, ownPkValue) {
+  for (const [key, relation, value] of entries) {
+    if (relation.mode === "otm") {
+      if (!Array.isArray(value)) {
+        throw new VSRepoAdapterError9(
+          `Field '${key}': expected an array for a to-many relation, got '${typeof value}'.`,
+          AdapterErrorCode9.INVALID_DATA,
+          null
+        );
+      }
+      await resolveOtmField(tx, relation, value, ownPkValue);
+      continue;
+    }
+    if (value !== null && typeof value !== "object") {
+      throw new VSRepoAdapterError9(
+        `Field '${key}': expected an object or 'null' for a to-one relation, got '${typeof value}'.`,
+        AdapterErrorCode9.INVALID_DATA,
+        null
+      );
+    }
+    await resolveOtoFkThereField(tx, relation, value, ownPkValue);
+  }
+}
+
+// src/drizzle.adapter.ts
+var DrizzleAdapter = class extends VSRepoAdapter {
+  table;
+  db;
+  dialect;
+  pk;
+  queryKey;
+  relations;
+  constructor(db, config) {
+    super();
+    const validated = validateDrizzleAdapterConfig(db, config);
+    this.db = validated.db;
+    this.table = validated.config.table;
+    this.dialect = validated.config.dialect ?? "postgresql";
+    this.queryKey = validated.config.queryKey;
+    const fieldsConfig = resolveFieldsConfig(this.table);
+    this.pk = fieldsConfig.pk;
+    this.relations = validateRelations(this.table, this.dialect, validated.config.relations);
+  }
+  /**
+   * Returns `db.query[queryKey]` (the relational query builder entry for
+   * this adapter's table), reading from `db` when a transaction/executor
+   * override is passed via `options.db`, otherwise from the root client.
+   */
+  getQueryBuilder(db) {
+    const executor = db ?? this.db;
+    return executor.query[this.queryKey];
+  }
+  /**
+   * Resolves the "read" part of a query arg: `columns`/`with`/`where`/
+   * `orderBy`/pagination.
+   *
+   * Per the adapter contract: when both `select` and `relations` are
+   * given, `select` wins and `relations` is ignored entirely.
+   */
+  async resolveReadArgs(where, options, single = false) {
+    options ??= {};
+    let columns;
+    let withArg;
+    if (options.select) {
+      const parsedSelect = parseColumns(options.select);
+      columns = parsedSelect.columns;
+      withArg = parsedSelect.with;
+    } else if (options.relations) {
+      withArg = parseWith(options.relations);
+    }
+    const found = await this.resolveFindWhere(where, {
+      db: options.db,
+      order: options.order,
+      limit: single ? 1 : options.pagination?.limit,
+      offset: single ? void 0 : options.pagination?.offset
+    });
+    return {
+      where: found.where,
+      columns,
+      with: withArg,
+      // When the prefetch already applied limit/offset, `IN (pks)` no longer preserves that
+      // order on its own, so the same ordering has to be re-applied at this level too — but
+      // limit/offset themselves must NOT be re-applied, since the pk set is already the exact page.
+      orderBy: found.paginationApplied ? found.orderBy : parseOrderBy(options.order),
+      limit: found.paginationApplied ? void 0 : options.pagination?.limit,
+      offset: found.paginationApplied ? void 0 : options.pagination?.offset
+    };
+  }
+  /** Builds the context `parseSqlWhere` needs to resolve `_with`/`_without`/`_some`/`_every`/`_none` relation filters. */
+  getSqlWhereContext(db) {
+    return {
+      table: this.table,
+      pk: this.pk,
+      relations: this.relations,
+      db: db ?? this.db
+    };
+  }
+  /**
+   * Resolves a user-supplied `VSRepoWhere<T>` into the `where` shape the
+   * relational query API (`db.query[queryKey].findFirst/findMany`) accepts.
+   *
+   * The relational API's own object-shaped `where` (`where.parser.ts`) has
+   * no native `_every`/`_none` semantics for to-many relations — so when
+   * `where` contains one (`hasQuantifierFilter`), this instead:
+   *  1. Resolves `where` into a `SQL` condition via `sql-where.parser.ts`
+   *     (which DOES support `_every`/`_none`, via `NOT EXISTS`);
+   *  2. Runs `db.select({pk}).from(table).where(condition)`, applying the
+   *     SAME `order`/`limit`/`offset` the final query would've used
+   *     (`sql-order-by.parser.ts`), so the prefetch only ever pulls the
+   *     rows the caller actually needs, instead of every matching row;
+   *  3. Returns `parseDrizzleWhere({ [pk]: { in: pks } })` instead — the
+   *     relational API then only has to filter by pk (trivial for it),
+   *     while still handling `columns`/`with` on the correct result set.
+   *
+   * Since SQL `IN (...)` doesn't preserve the given list's order, `resolveReadArgs`
+   * re-applies `orderBy` (but NOT `limit`/`offset`, already baked into the pk set)
+   * on the final relational query when `paginationApplied` comes back `true`.
+   *
+   * This keeps `_every`/`_none` support consistent between this adapter's
+   * two `where` parsers — from the outside, `findOne`/`findMany`/etc. never
+   * throw `NOT_SUPPORTED` for them, at the cost of an extra round-trip only
+   * when they're actually used.
+   */
+  async resolveFindWhere(where, opts) {
+    if (!hasQuantifierFilter(where)) {
+      return { where: parseDrizzleWhere(where, this.dialect), paginationApplied: false };
+    }
+    const executor = opts?.db ?? this.db;
+    const pkColumn = this.table[this.pk];
+    const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+    const sqlOrderBy = parseSqlOrderBy(this.table, opts?.order);
+    let qb = executor.select({ pk: pkColumn }).from(this.table).where(condition);
+    if (sqlOrderBy) qb = qb.orderBy(...sqlOrderBy);
+    if (opts?.limit !== void 0) qb = qb.limit(opts.limit);
+    if (opts?.offset !== void 0) qb = qb.offset(opts.offset);
+    const rows = await qb;
+    const pks = rows.map((row) => row.pk);
+    return {
+      where: parseDrizzleWhere({ [this.pk]: { in: pks } }, this.dialect),
+      orderBy: parseOrderBy(opts?.order),
+      paginationApplied: opts?.limit !== void 0 || opts?.offset !== void 0
+    };
+  }
+  /**
+   * Strips relation fields from a payload — used by `createMany`/`updateMany`/
+   * `updateManyReturning`, since batch statements only accept flat column
+   * data (no nested writes). Throws `VSRepoAdapterError` (code
+   * `NOT_SUPPORTED`) instead of silently dropping the field, when a
+   * configured relation field is present in the payload.
+   */
+  stripRelationFields(obj) {
+    if (!this.relations) return obj;
+    const data = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === void 0) continue;
+      if (this.relations.has(key)) {
+        throw new VSRepoAdapterError10(
+          `Field '${key}' is a configured relation, but this adapter's *Many operations don't support nested relation writes.`,
+          AdapterErrorCode10.NOT_SUPPORTED,
+          null
+        );
+      }
+      data[key] = value;
+    }
+    return data;
+  }
+  isRootClient(db) {
+    return typeof db?.rollback !== "function";
+  }
+  async runTransactional(db, fn) {
+    if (db && !this.isRootClient(db)) {
+      return fn(db);
+    }
+    return (db ?? this.db).transaction(fn);
+  }
+  async runInTransaction(fn, options) {
+    if (options?.timeoutMs !== void 0) {
+      throw new VSRepoAdapterError10(
+        "This adapter doesn't support 'timeoutMs' in transactions.",
+        AdapterErrorCode10.NOT_SUPPORTED,
+        null
+      );
+    }
+    try {
+      return await this.db.transaction(fn, {
+        isolationLevel: options?.isolationLevel && resolveIsolationLevel(options.isolationLevel)
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "runInTransaction", this.dialect);
+    }
+  }
+  getDbClient() {
+    return this.db;
+  }
+  async query(rawQuery, options) {
+    const executor = options?.db ?? this.db;
+    try {
+      const sqlQuery = resolveRawSql(this.dialect, rawQuery, options?.args);
+      const result = await executor.execute(sqlQuery);
+      return resolveRawResult(this.dialect, result, options?.modifying ?? false);
+    } catch (error) {
+      throw mapDrizzleError(error, "query", this.dialect);
+    }
+  }
+  async findOne(where, options) {
+    try {
+      const arg = await this.resolveReadArgs(where, options, true);
+      const result = await this.getQueryBuilder(options?.db).findFirst(arg);
+      return result ?? null;
+    } catch (error) {
+      throw mapDrizzleError(error, "findOne", this.dialect);
+    }
+  }
+  async findOneOrThrow(where, options) {
+    try {
+      const arg = await this.resolveReadArgs(where, options, true);
+      const result = await this.getQueryBuilder(options?.db).findFirst(arg);
+      if (!result) {
+        throw new VSRepoAdapterError10(
+          "'findOneOrThrow' found no record matching the given 'where'.",
+          AdapterErrorCode10.NOT_FOUND,
+          null
+        );
+      }
+      return result;
+    } catch (error) {
+      throw mapDrizzleError(error, "findOneOrThrow", this.dialect);
+    }
+  }
+  async findMany(where, options) {
+    if (options?.distinct !== void 0) {
+      throw new VSRepoAdapterError10(
+        "This adapter doesn't support 'distinct' in 'findMany': Drizzle's relational query API (db.query[queryKey].findMany) has no 'distinct' option.",
+        AdapterErrorCode10.NOT_SUPPORTED,
+        null
+      );
+    }
+    try {
+      const arg = await this.resolveReadArgs(where, options);
+      return await this.getQueryBuilder(options?.db).findMany(arg);
+    } catch (error) {
+      throw mapDrizzleError(error, "findMany", this.dialect);
+    }
+  }
+  async save(obj, options) {
+    try {
+      const objAny = obj;
+      const pkValue = objAny[this.pk];
+      if (pkValue === void 0) {
+        return await this.create(obj, options);
+      }
+      return await this.runTransactional(options?.db, async (tx) => {
+        const pkColumn = this.table[this.pk];
+        const existing = await tx.select({ pk: pkColumn }).from(this.table).where(eq3(pkColumn, pkValue)).limit(1);
+        if (existing.length === 0) {
+          return this.create(obj, { ...options, db: tx });
+        }
+        return this.update({ [this.pk]: pkValue }, obj, { ...options, db: tx });
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "save", this.dialect);
+    }
+  }
+  async saveMany(objs, options) {
+    try {
+      return await this.runTransactional(
+        options?.db,
+        (tx) => Promise.all(objs.map((obj) => this.save(obj, { ...options, db: tx })))
+      );
+    } catch (error) {
+      throw mapDrizzleError(error, "saveMany", this.dialect);
+    }
+  }
+  async create(obj, options) {
+    try {
+      return await this.runTransactional(options?.db, async (tx) => {
+        const objAny = obj;
+        const { scalarFields, fkHereEntries, fkThereEntries } = splitWritePayload(
+          objAny,
+          this.relations,
+          this.pk,
+          false
+        );
+        await resolveFkHereFields(tx, fkHereEntries, scalarFields, void 0);
+        const [created] = await tx.insert(this.table).values(scalarFields).returning();
+        const ownPkValue = created[this.pk];
+        await resolveFkThereFields(tx, fkThereEntries, ownPkValue);
+        const readArg = await this.resolveReadArgs(
+          { [this.pk]: ownPkValue },
+          options
+        );
+        const result = await this.getQueryBuilder(tx).findFirst(readArg);
+        return result ?? created;
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "create", this.dialect);
+    }
+  }
+  async createMany(objs, options) {
+    try {
+      const data = objs.map((obj) => this.stripRelationFields(obj));
+      const executor = options?.db ?? this.db;
+      let qb = executor.insert(this.table).values(data);
+      if (options?.ignoreConflicts) qb = qb.onConflictDoNothing();
+      const result = await qb;
+      const affected = resolveRawResult(this.dialect, result, true);
+      return { count: affected ?? data.length };
+    } catch (error) {
+      throw mapDrizzleError(error, "createMany", this.dialect);
+    }
+  }
+  async createManyReturning(objs, options) {
+    try {
+      const data = objs.map((obj) => this.stripRelationFields(obj));
+      const executor = options?.db ?? this.db;
+      let qb = executor.insert(this.table).values(data);
+      if (options?.ignoreConflicts) qb = qb.onConflictDoNothing();
+      return await qb.returning();
+    } catch (error) {
+      throw mapDrizzleError(error, "createManyReturning", this.dialect);
+    }
+  }
+  async delete(where, options) {
+    try {
+      return await this.runTransactional(options?.db, async (tx) => {
+        const readArg = await this.resolveReadArgs(where, options, true);
+        const current = await this.getQueryBuilder(tx).findFirst(readArg);
+        if (!current) {
+          throw new VSRepoAdapterError10(
+            "'delete' found no record matching the given 'where'.",
+            AdapterErrorCode10.NOT_FOUND,
+            null
+          );
+        }
+        const pkColumn = this.table[this.pk];
+        await tx.delete(this.table).where(eq3(pkColumn, current[this.pk]));
+        return current;
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "delete", this.dialect);
+    }
+  }
+  async deleteMany(where, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      const result = await executor.delete(this.table).where(condition);
+      const affected = resolveRawResult(this.dialect, result, true);
+      return { count: affected ?? 0 };
+    } catch (error) {
+      throw mapDrizzleError(error, "deleteMany", this.dialect);
+    }
+  }
+  async deleteManyReturning(where, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      return await executor.delete(this.table).where(condition).returning();
+    } catch (error) {
+      throw mapDrizzleError(error, "deleteManyReturning", this.dialect);
+    }
+  }
+  async update(where, obj, options) {
+    try {
+      return await this.runTransactional(options?.db, async (tx) => {
+        const current = await this.getQueryBuilder(tx).findFirst({
+          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
+        });
+        if (!current) {
+          throw new VSRepoAdapterError10(
+            "'update' found no record matching the given 'where'.",
+            AdapterErrorCode10.NOT_FOUND,
+            null
+          );
+        }
+        const ownPkValue = current[this.pk];
+        const objAny = obj;
+        const { scalarFields, fkHereEntries, fkThereEntries } = splitWritePayload(
+          objAny,
+          this.relations,
+          this.pk,
+          true
+        );
+        await resolveFkHereFields(tx, fkHereEntries, scalarFields, current);
+        if (Object.keys(scalarFields).length > 0) {
+          const pkColumn = this.table[this.pk];
+          await tx.update(this.table).set(scalarFields).where(eq3(pkColumn, ownPkValue));
+        }
+        await resolveFkThereFields(tx, fkThereEntries, ownPkValue);
+        const readArg = await this.resolveReadArgs(
+          { [this.pk]: ownPkValue },
+          options
+        );
+        const result = await this.getQueryBuilder(tx).findFirst(readArg);
+        return result ?? current;
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "update", this.dialect);
+    }
+  }
+  async updateMany(where, obj, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const data = this.stripRelationFields(obj);
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      const result = await executor.update(this.table).set(data).where(condition);
+      const affected = resolveRawResult(this.dialect, result, true);
+      return { count: affected ?? 0 };
+    } catch (error) {
+      throw mapDrizzleError(error, "updateMany", this.dialect);
+    }
+  }
+  async updateManyReturning(where, obj, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const data = this.stripRelationFields(obj);
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      return await executor.update(this.table).set(data).where(condition).returning();
+    } catch (error) {
+      throw mapDrizzleError(error, "updateManyReturning", this.dialect);
+    }
+  }
+  async count(where, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      const [row] = await executor.select({ value: countFn() }).from(this.table).where(condition);
+      return Number(row?.value ?? 0);
+    } catch (error) {
+      throw mapDrizzleError(error, "count", this.dialect);
+    }
+  }
+  async exists(where, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      const rows = await executor.select({ one: sql2`1` }).from(this.table).where(condition).limit(1);
+      return rows.length > 0;
+    } catch (error) {
+      throw mapDrizzleError(error, "exists", this.dialect);
+    }
+  }
+  async merge(where, obj, options) {
+    try {
+      const readArg = await this.resolveReadArgs(where, options);
+      const result = await this.getQueryBuilder(options?.db).findFirst(readArg);
+      if (!result) {
+        throw new VSRepoAdapterError10(
+          "'merge' found no record matching the given 'where'.",
+          AdapterErrorCode10.NOT_FOUND,
+          null
+        );
+      }
+      return mergeEntities(result, obj, this.relations);
+    } catch (error) {
+      throw mapDrizzleError(error, "merge", this.dialect);
+    }
+  }
+  async upsert(where, create, update, options) {
+    try {
+      return await this.runTransactional(options?.db, async (tx) => {
+        const current = await this.getQueryBuilder(tx).findFirst({
+          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
+        });
+        if (current) {
+          const ownPkValue = current[this.pk];
+          return this.update({ [this.pk]: ownPkValue }, update, {
+            ...options,
+            db: tx
+          });
+        }
+        return this.create(create, { ...options, db: tx });
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, "upsert", this.dialect);
+    }
+  }
+  /** Shared implementation behind `incrementOne`/`decrementOne`/`multiplyOne`/`divideOne`. */
+  async atomicUpdate(operation, field, toExpression, value, where, options) {
+    try {
+      return await this.runTransactional(options?.db, async (tx) => {
+        const current = await this.getQueryBuilder(tx).findFirst({
+          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
+        });
+        if (!current) {
+          throw new VSRepoAdapterError10(
+            `'${operation}' found no record matching the given 'where'.`,
+            AdapterErrorCode10.NOT_FOUND,
+            null
+          );
+        }
+        const ownPkValue = current[this.pk];
+        const pkColumn = this.table[this.pk];
+        const column = this.table[field];
+        await tx.update(this.table).set({ [field]: toExpression(column, value) }).where(eq3(pkColumn, ownPkValue));
+        const readArg = await this.resolveReadArgs(
+          { [this.pk]: ownPkValue },
+          options
+        );
+        return await this.getQueryBuilder(tx).findFirst(readArg);
+      });
+    } catch (error) {
+      throw mapDrizzleError(error, operation, this.dialect);
+    }
+  }
+  incrementOne(field, value, where, options) {
+    return this.atomicUpdate("incrementOne", field, (column, v) => sql2`${column} + ${v}`, value, where, options);
+  }
+  decrementOne(field, value, where, options) {
+    return this.atomicUpdate("decrementOne", field, (column, v) => sql2`${column} - ${v}`, value, where, options);
+  }
+  multiplyOne(field, value, where, options) {
+    return this.atomicUpdate("multiplyOne", field, (column, v) => sql2`${column} * ${v}`, value, where, options);
+  }
+  divideOne(field, value, where, options) {
+    return this.atomicUpdate("divideOne", field, (column, v) => sql2`${column} / ${v}`, value, where, options);
+  }
+  /** Shared implementation behind `sum`/`average`/`min`/`max`. */
+  async aggregate(operation, fn, field, where, options) {
+    try {
+      const executor = options?.db ?? this.db;
+      const condition = parseSqlWhere(where, this.getSqlWhereContext(executor));
+      const column = this.table[field];
+      const [row] = await executor.select({ value: fn(column) }).from(this.table).where(condition);
+      const raw = row?.value;
+      if (raw === null || raw === void 0) return null;
+      return typeof raw === "number" ? raw : Number(raw);
+    } catch (error) {
+      throw mapDrizzleError(error, operation, this.dialect);
+    }
+  }
+  sum(field, where, options) {
+    return this.aggregate("sum", sumFn, field, where, options);
+  }
+  average(field, where, options) {
+    return this.aggregate("average", avg, field, where, options);
+  }
+  min(field, where, options) {
+    return this.aggregate("min", minFn, field, where, options);
+  }
+  max(field, where, options) {
+    return this.aggregate("max", maxFn, field, where, options);
+  }
+};
+export {
+  DrizzleAdapter
+};
+//# sourceMappingURL=index.js.map