@farming-labs/orm-redis 0.0.43

package/dist/index.cjs

@@ -0,0 +1,1093 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRedisDriver: () => createRedisDriver
+});
+module.exports = __toCommonJS(index_exports);
+var import_orm = require("@farming-labs/orm");
+var ormKindKey = "__orm_kind";
+var ormTargetKey = "__orm_target";
+var ormDocIdKey = "__orm_docId";
+var ormRecordKind = "record";
+var ormUniqueKind = "unique";
+var defaultBase = "orm";
+var manifestCache = /* @__PURE__ */ new WeakMap();
+function generateUuid() {
+  const randomUuid = globalThis.crypto?.randomUUID;
+  if (typeof randomUuid === "function") {
+    return randomUuid.call(globalThis.crypto);
+  }
+  throw new Error("The current runtime does not provide crypto.randomUUID().");
+}
+function getManifest(schema) {
+  const cached = manifestCache.get(schema);
+  if (cached) return cached;
+  const next = (0, import_orm.createManifest)(schema);
+  manifestCache.set(schema, next);
+  return next;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object";
+}
+function hasFunction(value, name) {
+  return isRecord(value) && typeof value[name] === "function";
+}
+function joinRedisKey(...parts) {
+  return parts.filter((part) => part && part.length > 0).join(":");
+}
+function isRedisRecordItem(value) {
+  return isRecord(value) && value[ormKindKey] === ormRecordKind && typeof value[ormDocIdKey] === "string" && isRecord(value.data);
+}
+function isRedisUniqueItem(value) {
+  return isRecord(value) && value[ormKindKey] === ormUniqueKind && typeof value[ormTargetKey] === "string";
+}
+function normalizeDecimalString(value) {
+  const trimmed = value.trim();
+  const match = /^(-?\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (!match) {
+    return trimmed;
+  }
+  const [, integerPart, fractionalPart] = match;
+  if (!fractionalPart) {
+    return integerPart;
+  }
+  const normalizedFraction = fractionalPart.replace(/0+$/g, "");
+  return normalizedFraction.length ? `${integerPart}.${normalizedFraction}` : integerPart;
+}
+function applyDefault(value, field) {
+  if (value !== void 0) return value;
+  if (field.generated === "id") return generateUuid();
+  if (field.generated === "now") return /* @__PURE__ */ new Date();
+  if (typeof field.defaultValue === "function") {
+    return field.defaultValue();
+  }
+  return field.defaultValue;
+}
+function isComparable(value) {
+  return value instanceof Date || typeof value === "number" || typeof value === "string" || typeof value === "bigint";
+}
+function evaluateFilter(value, filter) {
+  if (!(0, import_orm.isOperatorFilterObject)(filter)) {
+    return (0, import_orm.equalValues)(value, filter);
+  }
+  if ("eq" in filter && !(0, import_orm.equalValues)(value, filter.eq)) return false;
+  if ("not" in filter && (0, import_orm.equalValues)(value, filter.not)) return false;
+  if ("in" in filter) {
+    const values = Array.isArray(filter.in) ? filter.in : [];
+    if (!values.some((candidate) => (0, import_orm.equalValues)(candidate, value))) return false;
+  }
+  if ("contains" in filter) {
+    if (typeof value !== "string" || typeof filter.contains !== "string") return false;
+    if (!value.includes(filter.contains)) return false;
+  }
+  if ("gt" in filter) {
+    if (!isComparable(value) || value <= filter.gt) return false;
+  }
+  if ("gte" in filter) {
+    if (!isComparable(value) || value < filter.gte) return false;
+  }
+  if ("lt" in filter) {
+    if (!isComparable(value) || value >= filter.lt) return false;
+  }
+  if ("lte" in filter) {
+    if (!isComparable(value) || value > filter.lte) return false;
+  }
+  return true;
+}
+function sortRows(rows, orderBy) {
+  if (!orderBy) return rows;
+  const entries = Object.entries(orderBy);
+  if (!entries.length) return rows;
+  return [...rows].sort((left, right) => {
+    for (const [field, direction] of entries) {
+      const a = left.data[field];
+      const b = right.data[field];
+      if ((0, import_orm.equalValues)(a, b)) continue;
+      if (a === void 0) return direction === "asc" ? -1 : 1;
+      if (b === void 0) return direction === "asc" ? 1 : -1;
+      if (a == null) return direction === "asc" ? -1 : 1;
+      if (b == null) return direction === "asc" ? 1 : -1;
+      if (a < b) return direction === "asc" ? -1 : 1;
+      if (a > b) return direction === "asc" ? 1 : -1;
+    }
+    return 0;
+  });
+}
+function pageRows(rows, skip, take) {
+  const start = skip ?? 0;
+  const end = take === void 0 ? void 0 : start + take;
+  return rows.slice(start, end);
+}
+function redisConstraintError(target) {
+  const fields = Array.isArray(target) ? target.join(", ") : target ?? "unique fields";
+  const error = new Error(`Redis unique constraint violation on ${fields}.`);
+  Object.assign(error, {
+    name: "RedisUniqueConstraintError",
+    code: "REDIS_UNIQUE_CONSTRAINT",
+    target
+  });
+  return error;
+}
+function normalizeNxResult(result) {
+  if (typeof result === "boolean") return result;
+  if (typeof result === "number") return result === 1;
+  if (typeof result === "string") {
+    const normalized = result.trim().toUpperCase();
+    return normalized === "OK" || normalized === "1" || normalized === "TRUE";
+  }
+  return false;
+}
+async function callRedisCommand(client, names, ...args) {
+  const record = client;
+  for (const name of names) {
+    if (hasFunction(client, name)) {
+      return await record[name](...args);
+    }
+  }
+  throw new Error(`The Redis runtime client is missing required command support: ${names[0]}.`);
+}
+function normalizeStoredString(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string") return value;
+  if (value instanceof Uint8Array) {
+    return new TextDecoder().decode(value);
+  }
+  return JSON.stringify(value);
+}
+function parseStoredJson(raw) {
+  if (raw === void 0 || raw === null) return null;
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  if (isRecord(raw)) {
+    return raw;
+  }
+  return null;
+}
+function normalizeKeyList(value) {
+  if (Array.isArray(value)) {
+    if (value.length >= 2 && Array.isArray(value[1])) {
+      return value[1].map((entry) => String(entry));
+    }
+    return value.map((entry) => String(entry));
+  }
+  if (isRecord(value) && Array.isArray(value.keys)) {
+    return value.keys.map((entry) => String(entry));
+  }
+  return [];
+}
+function escapePatternCharacter(character) {
+  return /[\\^$+?.()|[\]{}]/.test(character) ? `\\${character}` : character;
+}
+function matchesRedisPattern(key, pattern) {
+  const source = Array.from(pattern).map((character) => {
+    if (character === "*") return ".*";
+    if (character === "?") return ".";
+    return escapePatternCharacter(character);
+  }).join("");
+  return new RegExp(`^${source}$`).test(key);
+}
+function extractScanCursor(value) {
+  if (Array.isArray(value) && value.length >= 2) {
+    return String(value[0] ?? "0");
+  }
+  if (isRecord(value) && "cursor" in value) {
+    return String(value.cursor ?? "0");
+  }
+  return "0";
+}
+async function getString(client, key) {
+  const value = await callRedisCommand(client, ["get"], key);
+  return normalizeStoredString(value);
+}
+async function setString(client, key, value) {
+  await callRedisCommand(client, ["set"], key, value);
+}
+async function setStringNx(client, key, value) {
+  if (hasFunction(client, "setNX")) {
+    return normalizeNxResult(await client.setNX(key, value));
+  }
+  if (hasFunction(client, "setnx")) {
+    return normalizeNxResult(await client.setnx(key, value));
+  }
+  if (hasFunction(client, "set")) {
+    const attempts = [
+      [key, value, { NX: true }],
+      [key, value, { nx: true }],
+      [key, value, "NX"]
+    ];
+    for (const args of attempts) {
+      try {
+        const result = await client.set(...args);
+        if (result === null || result === void 0) {
+          return false;
+        }
+        return normalizeNxResult(result);
+      } catch {
+      }
+    }
+  }
+  if (hasFunction(client, "sendCommand")) {
+    return normalizeNxResult(await client.sendCommand(["SET", key, value, "NX"]));
+  }
+  if (await getString(client, key) !== null) {
+    return false;
+  }
+  await setString(client, key, value);
+  return true;
+}
+async function deleteKey(client, key) {
+  if (hasFunction(client, "unlink")) {
+    await client.unlink(key);
+    return;
+  }
+  await callRedisCommand(client, ["del"], key);
+}
+async function listKeys(client, pattern) {
+  if (hasFunction(client, "keys")) {
+    return normalizeKeyList(await client.keys(pattern));
+  }
+  if (hasFunction(client, "scanIterator")) {
+    const keys = [];
+    for await (const item of client.scanIterator({ MATCH: pattern, COUNT: 100 })) {
+      keys.push(String(item));
+    }
+    return keys;
+  }
+  if (hasFunction(client, "scan")) {
+    let cursor = "0";
+    const keys = [];
+    const scanAttempts = hasFunction(client, "request") ? [
+      { match: pattern, count: 100 },
+      { MATCH: pattern, COUNT: 100 }
+    ] : [
+      { MATCH: pattern, COUNT: 100 },
+      { match: pattern, count: 100 }
+    ];
+    do {
+      let result;
+      for (const options of scanAttempts) {
+        try {
+          result = await client.scan(cursor, options);
+          break;
+        } catch {
+        }
+      }
+      if (result === void 0) {
+        throw new Error("The Redis runtime client scan() command could not be called.");
+      }
+      keys.push(...normalizeKeyList(result).filter((key) => matchesRedisPattern(key, pattern)));
+      cursor = extractScanCursor(result);
+    } while (cursor !== "0");
+    return keys;
+  }
+  throw new Error("The Redis runtime client must provide keys(), scanIterator(), or scan().");
+}
+function createRedisDriverInternal(config) {
+  function getSupportedManifest(schema) {
+    const manifest = getManifest(schema);
+    for (const model of Object.values(manifest.models)) {
+      if (model.schema) {
+        throw new Error(
+          `The Redis runtime does not support schema-qualified tables for model "${model.name}". Use flat table names instead.`
+        );
+      }
+      const idField = model.fields.id;
+      if (idField?.kind === "id" && idField.idType === "integer" && idField.generated === "increment") {
+        throw new Error(
+          `The Redis runtime does not support generated integer ids for model "${model.name}". Use manual numeric ids or a string id instead.`
+        );
+      }
+    }
+    return manifest;
+  }
+  function getModelBase(schema, modelName) {
+    const manifest = getSupportedManifest(schema);
+    return config.prefixes?.[modelName] ?? joinRedisKey(config.base ?? defaultBase, manifest.models[modelName].table);
+  }
+  function recordBase(schema, modelName) {
+    return joinRedisKey(getModelBase(schema, modelName), "record");
+  }
+  function recordKey(schema, modelName, docId) {
+    return joinRedisKey(recordBase(schema, modelName), encodeURIComponent(docId));
+  }
+  function fieldTransform(modelName, fieldName) {
+    return config.transforms?.[modelName]?.[fieldName];
+  }
+  function encodeValue(modelName, field, value) {
+    if (value === void 0) return value;
+    if (value === null) return null;
+    const transform = fieldTransform(modelName, field.name);
+    if (transform?.encode) {
+      return transform.encode(value);
+    }
+    if (field.kind === "id" && field.idType === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "enum") {
+      return String(value);
+    }
+    if (field.kind === "boolean") {
+      return Boolean(value);
+    }
+    if (field.kind === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "bigint") {
+      return typeof value === "bigint" ? value.toString() : BigInt(value).toString();
+    }
+    if (field.kind === "decimal") {
+      return typeof value === "string" ? normalizeDecimalString(value) : String(value);
+    }
+    if (field.kind === "datetime") {
+      if (value instanceof Date) return value.toISOString();
+      return new Date(value).toISOString();
+    }
+    return value;
+  }
+  function decodeValue(modelName, field, value, docId) {
+    const transform = fieldTransform(modelName, field.name);
+    if (transform?.decode) {
+      return transform.decode(value);
+    }
+    if (value === void 0 && field.kind === "id" && docId !== void 0) {
+      if (field.idType === "integer") {
+        const numeric = Number(docId);
+        return Number.isFinite(numeric) ? numeric : void 0;
+      }
+      return docId;
+    }
+    if (value === void 0 || value === null) return value ?? null;
+    if (field.kind === "id" && field.idType === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "enum") {
+      return String(value);
+    }
+    if (field.kind === "boolean") {
+      return Boolean(value);
+    }
+    if (field.kind === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "bigint") {
+      return typeof value === "bigint" ? value : BigInt(value);
+    }
+    if (field.kind === "decimal") {
+      return normalizeDecimalString(String(value));
+    }
+    if (field.kind === "datetime") {
+      return value instanceof Date ? value : new Date(value);
+    }
+    return value;
+  }
+  function buildStoredRow(model, data) {
+    const stored = {};
+    const decoded = {};
+    for (const field of Object.values(model.fields)) {
+      const value = applyDefault(data[field.name], field);
+      if (value === void 0) continue;
+      const encoded = encodeValue(model.name, field, value);
+      stored[field.column] = encoded;
+      decoded[field.name] = decodeValue(model.name, field, encoded);
+    }
+    const idField = model.fields.id;
+    if (!idField) {
+      return {
+        docId: generateUuid(),
+        stored,
+        decoded
+      };
+    }
+    let idValue = decoded[idField.name];
+    if (idValue === void 0 || idValue === null) {
+      if (idField.idType === "integer") {
+        throw new Error(
+          `The Redis runtime requires an explicit numeric id for model "${model.name}" when using manual integer ids.`
+        );
+      }
+      idValue = generateUuid();
+      const encodedId = encodeValue(model.name, idField, idValue);
+      stored[idField.column] = encodedId;
+      decoded[idField.name] = decodeValue(model.name, idField, encodedId);
+      idValue = decoded[idField.name];
+    }
+    return {
+      docId: String(idValue),
+      stored,
+      decoded
+    };
+  }
+  function buildUpdatedRow(model, current, data) {
+    const stored = {
+      ...current.stored
+    };
+    const decoded = {
+      ...current.data
+    };
+    for (const [fieldName, value] of Object.entries(data)) {
+      if (value === void 0) continue;
+      const field = model.fields[fieldName];
+      if (!field) {
+        throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+      }
+      if (field.name === "id" && !(0, import_orm.equalValues)(current.data.id, value)) {
+        throw new Error(
+          `The Redis runtime does not support updating the id field for model "${model.name}".`
+        );
+      }
+      const encoded = encodeValue(model.name, field, value);
+      stored[field.column] = encoded;
+      decoded[field.name] = decodeValue(model.name, field, encoded);
+    }
+    return {
+      docId: current.docId,
+      stored,
+      decoded
+    };
+  }
+  async function loadRowByKey(model, key) {
+    const item = parseStoredJson(await getString(config.client, key));
+    if (!isRedisRecordItem(item)) {
+      return null;
+    }
+    const decoded = {};
+    for (const field of Object.values(model.fields)) {
+      decoded[field.name] = decodeValue(
+        model.name,
+        field,
+        item.data[field.column],
+        item.__orm_docId
+      );
+    }
+    return {
+      docId: item.__orm_docId,
+      key,
+      data: decoded,
+      stored: item.data
+    };
+  }
+  async function loadRows(schema, modelName) {
+    const model = getSupportedManifest(schema).models[modelName];
+    const keys = await listKeys(config.client, `${recordBase(schema, modelName)}:*`);
+    const rows = await Promise.all(keys.map((key) => loadRowByKey(model, key)));
+    return rows.filter((row) => !!row);
+  }
+  function normalizeFilterValue(model, fieldName, value) {
+    const field = model.fields[fieldName];
+    if (!field || value === void 0 || value === null) {
+      return value;
+    }
+    return decodeValue(model.name, field, encodeValue(model.name, field, value));
+  }
+  function evaluateModelFilter(model, fieldName, value, filter) {
+    if (!(0, import_orm.isOperatorFilterObject)(filter)) {
+      return (0, import_orm.equalValues)(value, normalizeFilterValue(model, fieldName, filter));
+    }
+    const normalized = {
+      ...filter.eq !== void 0 ? { eq: normalizeFilterValue(model, fieldName, filter.eq) } : {},
+      ...filter.not !== void 0 ? { not: normalizeFilterValue(model, fieldName, filter.not) } : {},
+      ...filter.in !== void 0 ? {
+        in: (Array.isArray(filter.in) ? filter.in : []).map(
+          (entry) => normalizeFilterValue(model, fieldName, entry)
+        )
+      } : {},
+      ...filter.contains !== void 0 ? { contains: String(filter.contains) } : {},
+      ...filter.gt !== void 0 ? { gt: normalizeFilterValue(model, fieldName, filter.gt) } : {},
+      ...filter.gte !== void 0 ? { gte: normalizeFilterValue(model, fieldName, filter.gte) } : {},
+      ...filter.lt !== void 0 ? { lt: normalizeFilterValue(model, fieldName, filter.lt) } : {},
+      ...filter.lte !== void 0 ? { lte: normalizeFilterValue(model, fieldName, filter.lte) } : {}
+    };
+    return evaluateFilter(value, normalized);
+  }
+  function matchesModelWhere(model, record, where) {
+    if (!where) return true;
+    if (where.AND && !where.AND.every((clause) => matchesModelWhere(model, record, clause))) {
+      return false;
+    }
+    if (where.OR && !where.OR.some((clause) => matchesModelWhere(model, record, clause))) {
+      return false;
+    }
+    if (where.NOT && matchesModelWhere(model, record, where.NOT)) {
+      return false;
+    }
+    for (const [key, filter] of Object.entries(where)) {
+      if (key === "AND" || key === "OR" || key === "NOT") continue;
+      if (!evaluateModelFilter(model, key, record[key], filter)) return false;
+    }
+    return true;
+  }
+  function applyModelQuery(model, rows, args = {}) {
+    const filtered = rows.filter((row) => matchesModelWhere(model, row.data, args.where));
+    const sorted = sortRows(filtered, args.orderBy);
+    return pageRows(sorted, args.skip, args.take);
+  }
+  function serializeUniqueValue(model, fieldName, value) {
+    const field = model.fields[fieldName];
+    const normalized = decodeValue(model.name, field, encodeValue(model.name, field, value));
+    if (normalized instanceof Date) {
+      return normalized.toISOString();
+    }
+    if (typeof normalized === "bigint") {
+      return normalized.toString();
+    }
+    return JSON.stringify(normalized);
+  }
+  function uniqueLockKey(schema, model, fields, row) {
+    const values = fields.map((fieldName) => row[fieldName]);
+    if (values.some((value) => value === void 0 || value === null)) {
+      return null;
+    }
+    return joinRedisKey(
+      getModelBase(schema, model.name),
+      "unique",
+      fields.join("+"),
+      ...fields.map(
+        (fieldName) => encodeURIComponent(serializeUniqueValue(model, fieldName, row[fieldName]))
+      )
+    );
+  }
+  function uniqueLocksForRow(schema, model, row, docId) {
+    const target = recordKey(schema, model.name, docId);
+    const locks = [];
+    for (const field of Object.values(model.fields)) {
+      if (!field.unique) continue;
+      const key = uniqueLockKey(schema, model, [field.name], row);
+      if (!key) continue;
+      locks.push({
+        key,
+        target,
+        fields: [field.name]
+      });
+    }
+    for (const constraint of model.constraints.unique) {
+      const key = uniqueLockKey(schema, model, [...constraint.fields], row);
+      if (!key) continue;
+      locks.push({
+        key,
+        target,
+        fields: [...constraint.fields]
+      });
+    }
+    return locks;
+  }
+  async function loadUniqueRow(schema, modelName, where) {
+    const manifest = getSupportedManifest(schema);
+    const model = manifest.models[modelName];
+    const lookup = (0, import_orm.requireUniqueLookup)(model, where, "FindUnique");
+    if (lookup.kind === "id") {
+      return loadRowByKey(
+        model,
+        recordKey(schema, modelName, String(lookup.values[lookup.fields[0].name]))
+      );
+    }
+    const normalizedLookupRow = Object.fromEntries(
+      lookup.fields.map((field) => [
+        field.name,
+        decodeValue(model.name, field, encodeValue(model.name, field, lookup.values[field.name]))
+      ])
+    );
+    const key = uniqueLockKey(
+      schema,
+      model,
+      lookup.fields.map((field) => field.name),
+      normalizedLookupRow
+    );
+    if (!key) {
+      return null;
+    }
+    const lock = parseStoredJson(await getString(config.client, key));
+    if (!isRedisUniqueItem(lock)) {
+      return null;
+    }
+    return loadRowByKey(model, lock.__orm_target);
+  }
+  function findUniqueConflict(model, candidate, existingRows, ignoreDocIds = /* @__PURE__ */ new Set()) {
+    const idField = model.fields.id;
+    for (const row of existingRows) {
+      if (ignoreDocIds.has(row.docId)) continue;
+      if (idField && candidate[idField.name] !== void 0 && candidate[idField.name] !== null && row.data[idField.name] !== void 0 && row.data[idField.name] !== null && (0, import_orm.equalValues)(candidate[idField.name], row.data[idField.name])) {
+        return [idField.name];
+      }
+      for (const field of Object.values(model.fields)) {
+        if (!field.unique) continue;
+        if (candidate[field.name] === void 0 || candidate[field.name] === null) continue;
+        if (row.data[field.name] === void 0 || row.data[field.name] === null) continue;
+        if ((0, import_orm.equalValues)(candidate[field.name], row.data[field.name])) {
+          return [field.name];
+        }
+      }
+      for (const constraint of model.constraints.unique) {
+        if (!constraint.fields.every(
+          (fieldName) => candidate[fieldName] !== void 0 && candidate[fieldName] !== null && row.data[fieldName] !== void 0 && row.data[fieldName] !== null
+        )) {
+          continue;
+        }
+        if (constraint.fields.every(
+          (fieldName) => (0, import_orm.equalValues)(candidate[fieldName], row.data[fieldName])
+        )) {
+          return [...constraint.fields];
+        }
+      }
+    }
+    return null;
+  }
+  function serializeItem(value) {
+    return JSON.stringify(value);
+  }
+  function buildRecordItem(row) {
+    return {
+      __orm_kind: ormRecordKind,
+      __orm_docId: row.docId,
+      data: row.stored
+    };
+  }
+  async function putRecordSequential(schema, modelName, row, conditionallyCreate) {
+    const key = recordKey(schema, modelName, row.docId);
+    const payload = serializeItem(buildRecordItem(row));
+    if (conditionallyCreate) {
+      if (!await setStringNx(config.client, key, payload)) {
+        throw redisConstraintError(["id"]);
+      }
+      return;
+    }
+    await setString(config.client, key, payload);
+  }
+  async function putUniqueSequential(lock) {
+    const existing = parseStoredJson(await getString(config.client, lock.key));
+    if (isRedisUniqueItem(existing)) {
+      if (existing.__orm_target !== lock.target) {
+        throw redisConstraintError(lock.fields);
+      }
+      return;
+    }
+    const written = await setStringNx(
+      config.client,
+      lock.key,
+      serializeItem({
+        __orm_kind: ormUniqueKind,
+        __orm_target: lock.target
+      })
+    );
+    if (written) {
+      return;
+    }
+    const current = parseStoredJson(await getString(config.client, lock.key));
+    if (isRedisUniqueItem(current) && current.__orm_target === lock.target) {
+      return;
+    }
+    throw redisConstraintError(lock.fields);
+  }
+  async function deleteSequential(key) {
+    await deleteKey(config.client, key);
+  }
+  async function acquireUniqueLocksSequential(locks) {
+    const acquired = [];
+    try {
+      for (const lock of locks) {
+        await putUniqueSequential(lock);
+        acquired.push(lock);
+      }
+    } catch (error) {
+      await releaseUniqueLocksSequential(acquired);
+      throw error;
+    }
+    return acquired;
+  }
+  async function releaseUniqueLocksSequential(locks) {
+    for (const lock of [...locks].reverse()) {
+      try {
+        await deleteSequential(lock.key);
+      } catch {
+      }
+    }
+  }
+  async function createRecordWithLocks(schema, modelName, row, model) {
+    const locks = uniqueLocksForRow(schema, model, row.decoded, row.docId);
+    const acquired = await acquireUniqueLocksSequential(locks);
+    try {
+      await putRecordSequential(schema, modelName, row, true);
+    } catch (error) {
+      await releaseUniqueLocksSequential(acquired);
+      throw error;
+    }
+  }
+  async function updateRecordWithLocks(schema, modelName, model, current, next) {
+    const currentLocks = new Map(
+      uniqueLocksForRow(schema, model, current.data, current.docId).map((lock) => [lock.key, lock])
+    );
+    const nextLocks = new Map(
+      uniqueLocksForRow(schema, model, next.decoded, next.docId).map((lock) => [lock.key, lock])
+    );
+    const addedLocks = [...nextLocks.values()].filter((lock) => !currentLocks.has(lock.key));
+    const removedLocks = [...currentLocks.values()].filter((lock) => !nextLocks.has(lock.key));
+    const acquired = await acquireUniqueLocksSequential(addedLocks);
+    try {
+      await putRecordSequential(schema, modelName, next, false);
+    } catch (error) {
+      await releaseUniqueLocksSequential(acquired);
+      throw error;
+    }
+    for (const lock of removedLocks) {
+      await deleteSequential(lock.key);
+    }
+  }
+  async function deleteRecordWithLocks(schema, modelName, model, current) {
+    await deleteSequential(recordKey(schema, modelName, current.docId));
+    const locks = uniqueLocksForRow(schema, model, current.data, current.docId);
+    for (const lock of locks) {
+      await deleteSequential(lock.key);
+    }
+  }
+  async function projectRow(schema, modelName, row, select) {
+    const modelDefinition = schema.models[modelName];
+    const output = {};
+    if (!select) {
+      for (const fieldName of Object.keys(modelDefinition.fields)) {
+        output[fieldName] = row[fieldName];
+      }
+      return output;
+    }
+    for (const [key, value] of Object.entries(select)) {
+      if (!value) continue;
+      if (key in modelDefinition.fields && value === true) {
+        output[key] = row[key];
+        continue;
+      }
+      if (key in modelDefinition.relations) {
+        output[key] = await resolveRelation(
+          schema,
+          modelName,
+          key,
+          row,
+          value
+        );
+      }
+    }
+    return output;
+  }
+  async function resolveRelation(schema, modelName, relationName, row, value) {
+    const relation = schema.models[modelName].relations[relationName];
+    const relationArgs = value === true ? {} : value;
+    if (relation.kind === "belongsTo") {
+      const foreignValue = row[relation.foreignKey];
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data.id, foreignValue)
+      );
+      const target = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      )[0];
+      return target ? projectRow(
+        schema,
+        relation.target,
+        target.data,
+        relationArgs.select
+      ) : null;
+    }
+    if (relation.kind === "hasOne") {
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data[relation.foreignKey], row.id)
+      );
+      const target = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      )[0];
+      return target ? projectRow(
+        schema,
+        relation.target,
+        target.data,
+        relationArgs.select
+      ) : null;
+    }
+    if (relation.kind === "hasMany") {
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data[relation.foreignKey], row.id)
+      );
+      const matchedRows2 = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      );
+      return Promise.all(
+        matchedRows2.map(
+          (item) => projectRow(schema, relation.target, item.data, relationArgs.select)
+        )
+      );
+    }
+    const throughRows = (await loadRows(schema, relation.through)).filter(
+      (item) => (0, import_orm.equalValues)(item.data[relation.from], row.id)
+    );
+    const targetIds = throughRows.map((item) => item.data[relation.to]);
+    const targetRows = (await loadRows(schema, relation.target)).filter(
+      (item) => targetIds.some((targetId) => (0, import_orm.equalValues)(targetId, item.data.id))
+    );
+    const matchedRows = applyModelQuery(
+      relationTargetManifest(schema, relation.target),
+      targetRows,
+      relationArgs
+    );
+    return Promise.all(
+      matchedRows.map(
+        (item) => projectRow(schema, relation.target, item.data, relationArgs.select)
+      )
+    );
+  }
+  function relationTargetManifest(schema, modelName) {
+    return getSupportedManifest(schema).models[modelName];
+  }
+  let driver;
+  driver = {
+    handle: (0, import_orm.createDriverHandle)({
+      kind: "redis",
+      client: {
+        client: config.client,
+        base: config.base,
+        prefixes: config.prefixes
+      },
+      capabilities: {
+        supportsNumericIds: true,
+        numericIds: "manual",
+        supportsJSON: true,
+        supportsDates: true,
+        supportsBooleans: true,
+        supportsTransactions: false,
+        supportsSchemaNamespaces: false,
+        supportsTransactionalDDL: false,
+        supportsJoin: false,
+        nativeRelationLoading: "none",
+        textComparison: "case-sensitive",
+        textMatching: {
+          equality: "case-sensitive",
+          contains: "case-sensitive",
+          ordering: "case-sensitive"
+        },
+        upsert: "emulated",
+        returning: {
+          create: true,
+          update: true,
+          delete: false
+        },
+        returningMode: {
+          create: "record",
+          update: "record",
+          delete: "none"
+        },
+        nativeRelations: {
+          singularChains: false,
+          hasMany: false,
+          manyToMany: false,
+          filtered: false,
+          ordered: false,
+          paginated: false
+        }
+      }
+    }),
+    async findMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = applyModelQuery(model, await loadRows(schema, modelName), args);
+      return Promise.all(rows.map((row) => projectRow(schema, modelName, row.data, args.select)));
+    },
+    async findFirst(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = applyModelQuery(model, await loadRows(schema, modelName), args)[0];
+      if (!row) return null;
+      return projectRow(schema, modelName, row.data, args.select);
+    },
+    async findUnique(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = await loadUniqueRow(schema, modelName, args.where);
+      if (!row || !matchesModelWhere(model, row.data, args.where)) {
+        return null;
+      }
+      return projectRow(schema, modelName, row.data, args.select);
+    },
+    async count(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      return applyModelQuery(model, await loadRows(schema, modelName), args).length;
+    },
+    async create(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const existingRows = await loadRows(schema, modelName);
+      const built = buildStoredRow(model, args.data);
+      const conflict = findUniqueConflict(model, built.decoded, existingRows);
+      if (conflict) {
+        throw redisConstraintError(conflict);
+      }
+      await createRecordWithLocks(schema, modelName, built, model);
+      return projectRow(schema, modelName, built.decoded, args.select);
+    },
+    async createMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const existingRows = await loadRows(schema, modelName);
+      const created = [];
+      for (const entry of args.data) {
+        const built = buildStoredRow(model, entry);
+        const conflict = findUniqueConflict(model, built.decoded, [
+          ...existingRows,
+          ...created.map((row) => ({
+            docId: row.docId,
+            key: recordKey(schema, modelName, row.docId),
+            data: row.decoded,
+            stored: row.stored
+          }))
+        ]);
+        if (conflict) {
+          throw redisConstraintError(conflict);
+        }
+        created.push(built);
+      }
+      for (const row of created) {
+        await createRecordWithLocks(schema, modelName, row, model);
+      }
+      return Promise.all(
+        created.map((row) => projectRow(schema, modelName, row.decoded, args.select))
+      );
+    },
+    async update(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = await loadRows(schema, modelName);
+      const current = applyModelQuery(model, rows, {
+        where: args.where,
+        take: 1
+      })[0];
+      if (!current) return null;
+      const next = buildUpdatedRow(model, current, args.data);
+      const conflict = findUniqueConflict(model, next.decoded, rows, /* @__PURE__ */ new Set([current.docId]));
+      if (conflict) {
+        throw redisConstraintError(conflict);
+      }
+      await updateRecordWithLocks(schema, modelName, model, current, next);
+      return projectRow(schema, modelName, next.decoded, args.select);
+    },
+    async updateMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = await loadRows(schema, modelName);
+      const matched = applyModelQuery(model, rows, {
+        where: args.where
+      });
+      if (!matched.length) return 0;
+      const nextRows = matched.map(
+        (row) => buildUpdatedRow(model, row, args.data)
+      );
+      const keepIds = new Set(matched.map((row) => row.docId));
+      const remaining = rows.filter((row) => !keepIds.has(row.docId));
+      const pending = [];
+      for (const next of nextRows) {
+        const conflict = findUniqueConflict(model, next.decoded, [...remaining, ...pending]);
+        if (conflict) {
+          throw redisConstraintError(conflict);
+        }
+        pending.push({
+          docId: next.docId,
+          key: recordKey(schema, modelName, next.docId),
+          data: next.decoded,
+          stored: next.stored
+        });
+      }
+      for (let index = 0; index < matched.length; index += 1) {
+        await updateRecordWithLocks(schema, modelName, model, matched[index], nextRows[index]);
+      }
+      return nextRows.length;
+    },
+    async upsert(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const lookup = (0, import_orm.requireUniqueLookup)(model, args.where, "Upsert");
+      (0, import_orm.validateUniqueLookupUpdateData)(
+        model,
+        args.update,
+        lookup,
+        "Upsert"
+      );
+      const current = await loadUniqueRow(schema, modelName, args.where);
+      if (current && matchesModelWhere(model, current.data, args.where)) {
+        const rows2 = await loadRows(schema, modelName);
+        const next = buildUpdatedRow(
+          model,
+          current,
+          args.update
+        );
+        const conflict2 = findUniqueConflict(model, next.decoded, rows2, /* @__PURE__ */ new Set([current.docId]));
+        if (conflict2) {
+          throw redisConstraintError(conflict2);
+        }
+        await updateRecordWithLocks(schema, modelName, model, current, next);
+        return projectRow(schema, modelName, next.decoded, args.select);
+      }
+      const created = buildStoredRow(
+        model,
+        (0, import_orm.mergeUniqueLookupCreateData)(
+          model,
+          args.create,
+          lookup,
+          "Upsert"
+        )
+      );
+      const rows = await loadRows(schema, modelName);
+      const conflict = findUniqueConflict(model, created.decoded, rows);
+      if (conflict) {
+        throw redisConstraintError(conflict);
+      }
+      await createRecordWithLocks(schema, modelName, created, model);
+      return projectRow(schema, modelName, created.decoded, args.select);
+    },
+    async delete(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = applyModelQuery(model, await loadRows(schema, modelName), {
+        where: args.where,
+        take: 1
+      })[0];
+      if (!row) return 0;
+      await deleteRecordWithLocks(schema, modelName, model, row);
+      return 1;
+    },
+    async deleteMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = applyModelQuery(model, await loadRows(schema, modelName), {
+        where: args.where
+      });
+      for (const row of rows) {
+        await deleteRecordWithLocks(schema, modelName, model, row);
+      }
+      return rows.length;
+    },
+    async transaction(schema, run) {
+      getSupportedManifest(schema);
+      return run(driver);
+    }
+  };
+  return driver;
+}
+function createRedisDriver(config) {
+  return createRedisDriverInternal(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRedisDriver
+});
+//# sourceMappingURL=index.cjs.map