@farming-labs/orm-firestore 0.0.31

package/dist/index.js

@@ -0,0 +1,843 @@
+// src/index.ts
+import { randomUUID } from "crypto";
+import {
+  createDriverHandle,
+  createManifest,
+  equalValues,
+  isOperatorFilterObject,
+  mergeUniqueLookupCreateData,
+  requireUniqueLookup,
+  validateUniqueLookupUpdateData
+} from "@farming-labs/orm";
+var manifestCache = /* @__PURE__ */ new WeakMap();
+function getManifest(schema) {
+  const cached = manifestCache.get(schema);
+  if (cached) return cached;
+  const next = createManifest(schema);
+  manifestCache.set(schema, next);
+  return next;
+}
+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 isTimestampLike(value) {
+  return !!value && typeof value === "object" && "toDate" in value && typeof value.toDate === "function";
+}
+function applyDefault(value, field) {
+  if (value !== void 0) return value;
+  if (field.generated === "id") return randomUUID();
+  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 (!isOperatorFilterObject(filter)) {
+    return equalValues(value, filter);
+  }
+  if ("eq" in filter && !equalValues(value, filter.eq)) return false;
+  if ("not" in filter && equalValues(value, filter.not)) return false;
+  if ("in" in filter) {
+    const values = Array.isArray(filter.in) ? filter.in : [];
+    if (!values.some((candidate) => 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 matchesWhere(record, where) {
+  if (!where) return true;
+  if (where.AND && !where.AND.every((clause) => matchesWhere(record, clause))) {
+    return false;
+  }
+  if (where.OR && !where.OR.some((clause) => matchesWhere(record, clause))) {
+    return false;
+  }
+  if (where.NOT && matchesWhere(record, where.NOT)) {
+    return false;
+  }
+  for (const [key, filter] of Object.entries(where)) {
+    if (key === "AND" || key === "OR" || key === "NOT") continue;
+    if (!evaluateFilter(record[key], filter)) 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 (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 applyQuery(rows, args = {}) {
+  const filtered = rows.filter((row) => matchesWhere(row.data, args.where));
+  const sorted = sortRows(filtered, args.orderBy);
+  return pageRows(sorted, args.skip, args.take);
+}
+function firestoreConstraintError(target) {
+  const fields = Array.isArray(target) ? target.join(", ") : target;
+  const error = new Error(`Firestore unique constraint violation on ${fields}.`);
+  Object.assign(error, {
+    code: 6,
+    details: error.message,
+    target
+  });
+  return error;
+}
+function hasTransactionSupport(db) {
+  return typeof db.runTransaction === "function";
+}
+function createFirestoreDriverInternal(config, state = {}) {
+  function getSupportedManifest(schema) {
+    const manifest = getManifest(schema);
+    for (const model of Object.values(manifest.models)) {
+      if (model.schema) {
+        throw new Error(
+          `The Firestore runtime does not support schema-qualified tables for model "${model.name}". Use flat collection names instead.`
+        );
+      }
+      const idField = model.fields.id;
+      if (idField?.kind === "id" && idField.idType === "integer" && idField.generated === "increment") {
+        throw new Error(
+          `The Firestore runtime does not support generated integer ids for model "${model.name}". Use manual numeric ids or a string id instead.`
+        );
+      }
+    }
+    return manifest;
+  }
+  function getCollection(schema, modelName) {
+    const manifest = getSupportedManifest(schema);
+    return config.collections?.[modelName] ?? config.db.collection(manifest.models[modelName].table);
+  }
+  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;
+      if (isTimestampLike(value)) return value;
+      return new Date(value);
+    }
+    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") {
+      if (value instanceof Date) return value;
+      if (isTimestampLike(value)) return value.toDate();
+      return 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: randomUUID(),
+        stored,
+        decoded
+      };
+    }
+    let idValue = decoded[idField.name];
+    if (idValue === void 0 || idValue === null) {
+      idValue = randomUUID();
+      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}".`);
+      }
+      const encoded = encodeValue(model.name, field, value);
+      stored[field.column] = encoded;
+      decoded[field.name] = decodeValue(model.name, field, encoded);
+    }
+    const idField = model.fields.id;
+    const docId = idField && decoded[idField.name] !== void 0 && decoded[idField.name] !== null ? String(decoded[idField.name]) : current.docId;
+    return {
+      docId,
+      stored,
+      decoded
+    };
+  }
+  async function getQuerySnapshot(query) {
+    if (state.transaction) {
+      const result = await state.transaction.get(query);
+      if ("docs" in result) {
+        return result;
+      }
+      return {
+        docs: result.exists ? [result] : []
+      };
+    }
+    return query.get();
+  }
+  async function getDocumentSnapshot(reference) {
+    if (state.transaction) {
+      const result = await state.transaction.get(reference);
+      if ("exists" in result) {
+        return result;
+      }
+      return result.docs[0] ?? {
+        id: reference.id,
+        exists: false,
+        data: () => void 0,
+        ref: reference
+      };
+    }
+    return reference.get();
+  }
+  async function loadRows(schema, modelName) {
+    const model = getSupportedManifest(schema).models[modelName];
+    const collection = getCollection(schema, modelName);
+    const snapshot = await getQuerySnapshot(collection);
+    return snapshot.docs.filter((doc) => doc.exists).map((doc) => {
+      const stored = doc.data() ?? {};
+      const decoded = {};
+      for (const field of Object.values(model.fields)) {
+        decoded[field.name] = decodeValue(model.name, field, stored[field.column], doc.id);
+      }
+      return {
+        docId: doc.id,
+        ref: doc.ref ?? collection.doc(doc.id),
+        data: decoded,
+        stored
+      };
+    });
+  }
+  async function loadUniqueRow(schema, modelName, where) {
+    const manifest = getSupportedManifest(schema);
+    const model = manifest.models[modelName];
+    const lookup = requireUniqueLookup(model, where, "FindUnique");
+    if (lookup.kind === "id") {
+      const reference = getCollection(schema, modelName).doc(
+        String(lookup.values[lookup.fields[0].name])
+      );
+      const doc = await getDocumentSnapshot(reference);
+      if (!doc.exists) return null;
+      const stored = doc.data() ?? {};
+      const decoded = {};
+      for (const field of Object.values(model.fields)) {
+        decoded[field.name] = decodeValue(model.name, field, stored[field.column], doc.id);
+      }
+      return {
+        docId: doc.id,
+        ref: doc.ref ?? reference,
+        data: decoded,
+        stored
+      };
+    }
+    const rows = await loadRows(schema, modelName);
+    return rows.find((row) => matchesModelWhere(model, row.data, where)) ?? null;
+  }
+  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 && 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 (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) => equalValues(candidate[fieldName], row.data[fieldName])
+        )) {
+          return [...constraint.fields];
+        }
+      }
+    }
+    return null;
+  }
+  async function writeDocument(schema, modelName, next, previousDocId) {
+    const collection = getCollection(schema, modelName);
+    const reference = collection.doc(next.docId);
+    if (state.transaction) {
+      state.transaction.set(reference, next.stored);
+      if (previousDocId && previousDocId !== next.docId) {
+        state.transaction.delete(collection.doc(previousDocId));
+      }
+      return;
+    }
+    await reference.set(next.stored);
+    if (previousDocId && previousDocId !== next.docId) {
+      await collection.doc(previousDocId).delete();
+    }
+  }
+  async function deleteDocument(schema, modelName, docId) {
+    const reference = getCollection(schema, modelName).doc(docId);
+    if (state.transaction) {
+      state.transaction.delete(reference);
+      return;
+    }
+    await reference.delete();
+  }
+  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 !== true && value === void 0) 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) => equalValues(item.data.id, foreignValue)
+      );
+      const target = applyQuery(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) => equalValues(item.data[relation.foreignKey], row.id)
+      );
+      const target = applyQuery(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) => equalValues(item.data[relation.foreignKey], row.id)
+      );
+      const matchedRows2 = applyQuery(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) => 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) => equalValues(targetId, item.data.id))
+    );
+    const matchedRows = applyQuery(targetRows, relationArgs);
+    return Promise.all(
+      matchedRows.map(
+        (item) => projectRow(schema, relation.target, item.data, relationArgs.select)
+      )
+    );
+  }
+  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 (!isOperatorFilterObject(filter)) {
+      return 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);
+  }
+  async function runWrite(run) {
+    if (state.transaction || !hasTransactionSupport(config.db)) {
+      return run();
+    }
+    return config.db.runTransaction(async (transaction) => {
+      const txDriver = createFirestoreDriverInternal(config, {
+        transaction
+      });
+      return run.call({
+        driver: txDriver
+      });
+    });
+  }
+  let driver;
+  driver = {
+    handle: createDriverHandle({
+      kind: "firestore",
+      client: {
+        db: config.db,
+        collections: config.collections
+      },
+      capabilities: {
+        supportsNumericIds: true,
+        numericIds: "manual",
+        supportsJSON: true,
+        supportsDates: true,
+        supportsBooleans: true,
+        supportsTransactions: hasTransactionSupport(config.db),
+        supportsSchemaNamespaces: false,
+        supportsTransactionalDDL: false,
+        supportsJoin: false,
+        nativeRelationLoading: "none",
+        textComparison: "case-sensitive",
+        textMatching: {
+          equality: "case-sensitive",
+          contains: "case-sensitive",
+          ordering: "case-sensitive"
+        },
+        upsert: "native",
+        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) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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 firestoreConstraintError(conflict);
+      }
+      await writeDocument(schema, modelName, built);
+      return projectRow(schema, modelName, built.decoded, args.select);
+    },
+    async createMany(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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,
+            ref: getCollection(schema, modelName).doc(row.docId),
+            data: row.decoded,
+            stored: row.stored
+          }))
+        ]);
+        if (conflict) {
+          throw firestoreConstraintError(conflict);
+        }
+        created.push(built);
+      }
+      for (const row of created) {
+        await writeDocument(schema, modelName, row);
+      }
+      return Promise.all(
+        created.map((row) => projectRow(schema, modelName, row.decoded, args.select))
+      );
+    },
+    async update(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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 firestoreConstraintError(conflict);
+      }
+      await writeDocument(schema, modelName, next, current.docId);
+      return projectRow(schema, modelName, next.decoded, args.select);
+    },
+    async updateMany(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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 firestoreConstraintError(conflict);
+        }
+        pending.push({
+          docId: next.docId,
+          ref: getCollection(schema, modelName).doc(next.docId),
+          data: next.decoded,
+          stored: next.stored
+        });
+      }
+      for (let index = 0; index < matched.length; index += 1) {
+        await writeDocument(schema, modelName, nextRows[index], matched[index].docId);
+      }
+      return nextRows.length;
+    },
+    async upsert(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.upsert(schema, modelName, args);
+        });
+      }
+      const model = getSupportedManifest(schema).models[modelName];
+      const lookup = requireUniqueLookup(model, args.where, "Upsert");
+      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 firestoreConstraintError(conflict2);
+        }
+        await writeDocument(schema, modelName, next, current.docId);
+        return projectRow(schema, modelName, next.decoded, args.select);
+      }
+      const created = buildStoredRow(
+        model,
+        mergeUniqueLookupCreateData(
+          model,
+          args.create,
+          lookup,
+          "Upsert"
+        )
+      );
+      const rows = await loadRows(schema, modelName);
+      const conflict = findUniqueConflict(model, created.decoded, rows);
+      if (conflict) {
+        throw firestoreConstraintError(conflict);
+      }
+      await writeDocument(schema, modelName, created);
+      return projectRow(schema, modelName, created.decoded, args.select);
+    },
+    async delete(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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 deleteDocument(schema, modelName, row.docId);
+      return 1;
+    },
+    async deleteMany(schema, modelName, args) {
+      if (!state.transaction && hasTransactionSupport(config.db)) {
+        return config.db.runTransaction(async (transaction) => {
+          const txDriver = createFirestoreDriverInternal(config, {
+            transaction
+          });
+          return txDriver.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 deleteDocument(schema, modelName, row.docId);
+      }
+      return rows.length;
+    },
+    async transaction(schema, run) {
+      getSupportedManifest(schema);
+      if (state.transaction || !hasTransactionSupport(config.db)) {
+        return run(driver);
+      }
+      return config.db.runTransaction(async (transaction) => {
+        const txDriver = createFirestoreDriverInternal(config, {
+          transaction
+        });
+        return run(txDriver);
+      });
+    }
+  };
+  return driver;
+}
+function createFirestoreDriver(config) {
+  return createFirestoreDriverInternal(config);
+}
+export {
+  createFirestoreDriver
+};
+//# sourceMappingURL=index.js.map