@lpdjs/firestore-repo-service 1.0.0

package/dist/index.js

@@ -0,0 +1,746 @@
+// src/query-builder.ts
+function chunkArray(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function applyBasicQueryOptions(q, options) {
+  if (options.orderBy) {
+    options.orderBy.forEach((o) => {
+      q = q.orderBy(String(o.field), o.direction || "asc");
+    });
+  }
+  if (options.limit) {
+    q = q.limit(options.limit);
+  }
+  if (options.offset) {
+    q = q.offset(options.offset);
+  }
+  if (options.startAt) {
+    q = Array.isArray(options.startAt) ? q.startAt(...options.startAt) : q.startAt(options.startAt);
+  }
+  if (options.startAfter) {
+    q = Array.isArray(options.startAfter) ? q.startAfter(...options.startAfter) : q.startAfter(options.startAfter);
+  }
+  if (options.endAt) {
+    q = Array.isArray(options.endAt) ? q.endAt(...options.endAt) : q.endAt(options.endAt);
+  }
+  if (options.endBefore) {
+    q = Array.isArray(options.endBefore) ? q.endBefore(...options.endBefore) : q.endBefore(options.endBefore);
+  }
+  return q;
+}
+function needsSplitting(clause) {
+  const { operator, value } = clause;
+  return (operator === "in" || operator === "array-contains-any") && Array.isArray(value) && value.length > 30;
+}
+function splitWhereClause(clause) {
+  const { field, operator, value } = clause;
+  if (!needsSplitting(clause)) {
+    return [clause];
+  }
+  const chunks = chunkArray(value, 30);
+  return chunks.map((chunk) => ({
+    field,
+    operator,
+    value: chunk
+  }));
+}
+function applyWhereClausesToQuery(baseQuery, whereClauses) {
+  let q = baseQuery;
+  for (const clause of whereClauses) {
+    q = q.where(String(clause.field), clause.operator, clause.value);
+  }
+  return q;
+}
+async function executeAndMergeQueries(queries) {
+  const snapshots = await Promise.all(queries.map((q) => q.get()));
+  const docsMap = /* @__PURE__ */ new Map();
+  snapshots.forEach((snapshot) => {
+    snapshot.docs.forEach((doc) => {
+      if (!docsMap.has(doc.id)) {
+        docsMap.set(doc.id, doc);
+      }
+    });
+  });
+  const firstSnapshot = snapshots[0];
+  if (!firstSnapshot) {
+    throw new Error("No snapshots returned");
+  }
+  return {
+    ...firstSnapshot,
+    docs: Array.from(docsMap.values()),
+    size: docsMap.size,
+    empty: docsMap.size === 0
+  };
+}
+async function buildAndExecuteQuery(baseQuery, options) {
+  if (options.where && !options.orWhere) {
+    const needsSplit = options.where.some(needsSplitting);
+    if (!needsSplit) {
+      let q2 = applyWhereClausesToQuery(baseQuery, options.where);
+      q2 = applyBasicQueryOptions(q2, options);
+      return q2.get();
+    }
+    const splitClauses = options.where.map(splitWhereClause);
+    const combinations = cartesianProduct(splitClauses);
+    const queries = combinations.map((combination) => {
+      let q2 = applyWhereClausesToQuery(baseQuery, combination);
+      q2 = applyBasicQueryOptions(q2, options);
+      return q2;
+    });
+    return executeAndMergeQueries(queries);
+  }
+  if (options.orWhere) {
+    const allQueries = [];
+    for (const orGroup of options.orWhere) {
+      const needsSplit = orGroup.some(needsSplitting);
+      if (!needsSplit) {
+        let q2 = applyWhereClausesToQuery(baseQuery, orGroup);
+        q2 = applyBasicQueryOptions(q2, options);
+        allQueries.push(q2);
+      } else {
+        const splitClauses = orGroup.map(splitWhereClause);
+        const combinations = cartesianProduct(splitClauses);
+        const groupQueries = combinations.map((combination) => {
+          let q2 = applyWhereClausesToQuery(baseQuery, combination);
+          q2 = applyBasicQueryOptions(q2, options);
+          return q2;
+        });
+        allQueries.push(...groupQueries);
+      }
+    }
+    return executeAndMergeQueries(allQueries);
+  }
+  const q = applyBasicQueryOptions(baseQuery, options);
+  return q.get();
+}
+function cartesianProduct(arrays) {
+  if (arrays.length === 0) return [[]];
+  const first = arrays[0];
+  if (arrays.length === 1 && first) {
+    return first.map((item) => [item]);
+  }
+  if (!first) return [[]];
+  const rest = arrays.slice(1);
+  const restProduct = cartesianProduct(rest);
+  const result = [];
+  for (const item of first) {
+    for (const combo of restProduct) {
+      result.push([item, ...combo]);
+    }
+  }
+  return result;
+}
+
+// src/pagination.ts
+function applyQueryOptions(q, options) {
+  if (options.where) {
+    options.where.forEach((w) => {
+      q = q.where(String(w.field), w.operator, w.value);
+    });
+  }
+  if (options.orderBy) {
+    options.orderBy.forEach((o) => {
+      q = q.orderBy(String(o.field), o.direction || "asc");
+    });
+  }
+  if (options.limit) {
+    q = q.limit(options.limit);
+  }
+  if (options.offset) {
+    q = q.offset(options.offset);
+  }
+  if (options.startAt) {
+    q = Array.isArray(options.startAt) ? q.startAt(...options.startAt) : q.startAt(options.startAt);
+  }
+  if (options.startAfter) {
+    q = Array.isArray(options.startAfter) ? q.startAfter(...options.startAfter) : q.startAfter(options.startAfter);
+  }
+  if (options.endAt) {
+    q = Array.isArray(options.endAt) ? q.endAt(...options.endAt) : q.endAt(options.endAt);
+  }
+  if (options.endBefore) {
+    q = Array.isArray(options.endBefore) ? q.endBefore(...options.endBefore) : q.endBefore(options.endBefore);
+  }
+  return q;
+}
+async function executePaginatedQuery(baseQuery, options) {
+  const queryOptions = {
+    ...options,
+    limit: options.pageSize + 1
+    // Fetch one extra to check if there's a next page
+  };
+  if (options.cursor) {
+    if (options.direction === "prev") {
+      queryOptions.endBefore = options.cursor;
+    } else {
+      queryOptions.startAfter = options.cursor;
+    }
+  }
+  const snapshot = await buildAndExecuteQuery(baseQuery, queryOptions);
+  const docs = snapshot.docs;
+  const hasMore = docs.length > options.pageSize;
+  const actualDocs = hasMore ? docs.slice(0, options.pageSize) : docs;
+  const data = actualDocs.map((doc) => ({
+    ...doc.data(),
+    docId: doc.id
+  }));
+  return {
+    data,
+    nextCursor: hasMore ? actualDocs[actualDocs.length - 1] : void 0,
+    prevCursor: actualDocs[0],
+    hasNextPage: hasMore,
+    hasPrevPage: !!options.cursor,
+    pageSize: data.length
+  };
+}
+async function* createPaginationIterator(baseQuery, options) {
+  let cursor;
+  let hasMore = true;
+  while (hasMore) {
+    const result = await executePaginatedQuery(baseQuery, {
+      ...options,
+      cursor,
+      direction: "next"
+    });
+    yield result;
+    hasMore = result.hasNextPage;
+    cursor = result.nextCursor;
+  }
+}
+
+// src/shared/utils.ts
+function chunkArray2(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/methods/query.ts
+function applyQueryOptions2(q, options) {
+  if (options.where) {
+    options.where.forEach((w) => {
+      q = q.where(String(w.field), w.operator, w.value);
+    });
+  }
+  if (options.orderBy) {
+    options.orderBy.forEach((o) => {
+      q = q.orderBy(String(o.field), o.direction || "asc");
+    });
+  }
+  if (options.limit) {
+    q = q.limit(options.limit);
+  }
+  if (options.offset) {
+    q = q.offset(options.offset);
+  }
+  if (options.startAt) {
+    q = Array.isArray(options.startAt) ? q.startAt(...options.startAt) : q.startAt(options.startAt);
+  }
+  if (options.startAfter) {
+    q = Array.isArray(options.startAfter) ? q.startAfter(...options.startAfter) : q.startAfter(options.startAfter);
+  }
+  if (options.endAt) {
+    q = Array.isArray(options.endAt) ? q.endAt(...options.endAt) : q.endAt(options.endAt);
+  }
+  if (options.endBefore) {
+    q = Array.isArray(options.endBefore) ? q.endBefore(...options.endBefore) : q.endBefore(options.endBefore);
+  }
+  return q;
+}
+function createQueryMethods(collectionRef, queryKeys) {
+  const queryMethods = {};
+  queryKeys.forEach((queryKey) => {
+    const methodName = `by${capitalize(String(queryKey))}`;
+    queryMethods[methodName] = async (value, options = {}) => {
+      let q = collectionRef;
+      q = q.where(String(queryKey), "==", value);
+      q = applyQueryOptions2(q, options);
+      const snapshot = await q.get();
+      return snapshot.docs.map((doc) => ({ ...doc.data(), docId: doc.id }));
+    };
+  });
+  queryMethods.by = async (options) => {
+    let q = collectionRef;
+    q = applyQueryOptions2(q, options);
+    const snapshot = await q.get();
+    return snapshot.docs.map((doc) => ({ ...doc.data(), docId: doc.id }));
+  };
+  queryMethods.getAll = async (options = {}) => {
+    let q = collectionRef;
+    q = applyQueryOptions2(q, options);
+    const snapshot = await q.get();
+    return snapshot.docs.map((doc) => ({ ...doc.data(), docId: doc.id }));
+  };
+  queryMethods.onSnapshot = (options, onNext, onError) => {
+    let q = collectionRef;
+    q = applyQueryOptions2(q, options);
+    return q.onSnapshot((snapshot) => {
+      const data = snapshot.docs.map((doc) => ({
+        ...doc.data(),
+        docId: doc.id
+      }));
+      onNext(data);
+    }, onError);
+  };
+  queryMethods.paginate = async (options) => {
+    return executePaginatedQuery(collectionRef, options);
+  };
+  queryMethods.paginateAll = (options) => {
+    return createPaginationIterator(collectionRef, options);
+  };
+  return queryMethods;
+}
+
+// src/methods/aggregate.ts
+function createAggregateMethods(collectionRef) {
+  return {
+    // Count documents matching query options
+    count: async (options = {}) => {
+      let q = collectionRef;
+      q = applyQueryOptions2(q, options);
+      const snapshot = await q.count().get();
+      return snapshot.data().count;
+    },
+    // Sum of a numeric field
+    sum: async (field, options = {}) => {
+      let q = collectionRef;
+      q = applyQueryOptions2(q, options);
+      const snapshot = await q.get();
+      let total = 0;
+      snapshot.forEach((doc) => {
+        const value = doc.data()[field];
+        if (typeof value === "number") {
+          total += value;
+        }
+      });
+      return total;
+    },
+    // Average of a numeric field
+    average: async (field, options = {}) => {
+      let q = collectionRef;
+      q = applyQueryOptions2(q, options);
+      const snapshot = await q.get();
+      if (snapshot.empty) return null;
+      let total = 0;
+      let count = 0;
+      snapshot.forEach((doc) => {
+        const value = doc.data()[field];
+        if (typeof value === "number") {
+          total += value;
+          count++;
+        }
+      });
+      return count > 0 ? total / count : null;
+    }
+  };
+}
+
+// src/methods/batch.ts
+function createBatchMethods(db, documentRef) {
+  return {
+    create: () => {
+      const batch = db.batch();
+      return {
+        batch,
+        set: (...args) => {
+          const lastArg = args[args.length - 1];
+          const hasOptions = typeof lastArg === "object" && lastArg !== null && "merge" in lastArg;
+          const data = hasOptions ? args[args.length - 2] : args[args.length - 1];
+          const pathArgs = hasOptions ? args.slice(0, -2) : args.slice(0, -1);
+          const mergeOption = hasOptions ? lastArg : { merge: true };
+          const docRef = documentRef(...pathArgs);
+          batch.set(docRef, data, mergeOption);
+        },
+        update: (...args) => {
+          const data = args.pop();
+          const pathArgs = args;
+          const docRef = documentRef(...pathArgs);
+          batch.update(docRef, data);
+        },
+        delete: (...args) => {
+          const docRef = documentRef(...args);
+          batch.delete(docRef);
+        },
+        commit: async () => {
+          await batch.commit();
+        }
+      };
+    }
+  };
+}
+
+// src/methods/bulk.ts
+function createBulkMethods(db) {
+  return {
+    // Set multiple documents with automatic batching (500 ops per flush)
+    set: async (items) => {
+      const bulkWriter = db.bulkWriter();
+      let pendingOps = 0;
+      for (const item of items) {
+        if (!item) continue;
+        const { docRef, data, merge = true } = item;
+        bulkWriter.set(docRef, data, { merge });
+        pendingOps++;
+        if (pendingOps >= 500) {
+          await bulkWriter.flush();
+          pendingOps = 0;
+        }
+      }
+      await bulkWriter.close();
+    },
+    // Update multiple documents with automatic batching
+    update: async (items) => {
+      const bulkWriter = db.bulkWriter();
+      let pendingOps = 0;
+      for (const item of items) {
+        if (!item) continue;
+        const { docRef, data } = item;
+        bulkWriter.update(docRef, data);
+        pendingOps++;
+        if (pendingOps >= 500) {
+          await bulkWriter.flush();
+          pendingOps = 0;
+        }
+      }
+      await bulkWriter.close();
+    },
+    // Delete multiple documents with automatic batching
+    delete: async (docRefs) => {
+      const bulkWriter = db.bulkWriter();
+      let pendingOps = 0;
+      for (const docRef of docRefs) {
+        if (!docRef) continue;
+        bulkWriter.delete(docRef);
+        pendingOps++;
+        if (pendingOps >= 500) {
+          await bulkWriter.flush();
+          pendingOps = 0;
+        }
+      }
+      await bulkWriter.close();
+    }
+  };
+}
+
+// src/methods/crud.ts
+function createCrudMethods(actualCollection, documentRef) {
+  const create = async (data) => {
+    if (!actualCollection) {
+      throw new Error(
+        "Cannot use create() on collection groups. Use set() with a specific document ID instead."
+      );
+    }
+    const docRef = await actualCollection.add(data);
+    const createdDoc = await docRef.get();
+    return { ...createdDoc.data(), docId: docRef.id };
+  };
+  const set = async (...args) => {
+    const lastArg = args[args.length - 1];
+    const hasOptions = typeof lastArg === "object" && lastArg !== null && "merge" in lastArg;
+    const data = hasOptions ? args[args.length - 2] : args[args.length - 1];
+    const pathArgs = hasOptions ? args.slice(0, -2) : args.slice(0, -1);
+    const mergeOption = hasOptions ? lastArg : { merge: true };
+    const docRef = documentRef(...pathArgs);
+    await docRef.set(data, mergeOption);
+    const setDocument = await docRef.get();
+    return { ...setDocument.data(), docId: docRef.id };
+  };
+  const update = async (...args) => {
+    const data = args.pop();
+    const pathArgs = args;
+    const docRef = documentRef(...pathArgs);
+    await docRef.update(data);
+    const updatedDoc = await docRef.get();
+    return { ...updatedDoc.data(), docId: docRef.id };
+  };
+  const deleteMethod = async (...args) => {
+    const docRef = documentRef(...args);
+    await docRef.delete();
+  };
+  return {
+    create,
+    set,
+    update,
+    delete: deleteMethod
+  };
+}
+
+// src/methods/get.ts
+function createGetMethods(collectionRef, foreignKeys, actualCollection, documentRef) {
+  const getMethods = {};
+  getMethods.byList = async (key, values, operator = "in", returnDoc = false) => {
+    if (values.length === 0) return [];
+    const results = [];
+    const chunks = chunkArray2(values, 30);
+    for (const chunk of chunks) {
+      let q = collectionRef;
+      q = q.where(key, operator, chunk);
+      const snapshot = await q.get();
+      snapshot.forEach((doc) => {
+        const data = doc.data();
+        results.push(returnDoc ? { data, doc } : { ...data, docId: doc.id });
+      });
+    }
+    return results;
+  };
+  foreignKeys.forEach((foreignKey) => {
+    const methodName = `by${capitalize(String(foreignKey))}`;
+    getMethods[methodName] = async (value, returnDoc = false) => {
+      if (String(foreignKey) === "docId") {
+        const docRef = documentRef(value);
+        const doc2 = await docRef.get();
+        if (!doc2.exists) return null;
+        const data2 = doc2.data();
+        return returnDoc ? { data: data2, doc: doc2 } : { ...data2, docId: doc2.id };
+      }
+      let q = collectionRef;
+      q = q.where(String(foreignKey), "==", value).limit(1);
+      const snapshot = await q.get();
+      if (snapshot.empty) return null;
+      const doc = snapshot.docs[0];
+      if (!doc) return null;
+      const data = doc.data();
+      return returnDoc ? { data, doc } : { ...data, docId: doc.id };
+    };
+  });
+  return getMethods;
+}
+
+// src/methods/relations.ts
+function createPopulateMethods(config, allRepositories) {
+  return {
+    populate: async (document, relationKey) => {
+      if (!config.relationalKeys) {
+        return { ...document, populated: {} };
+      }
+      const keys = Array.isArray(relationKey) ? relationKey : [relationKey];
+      const result = { ...document };
+      const populated = {};
+      for (const key of keys) {
+        const relation = config.relationalKeys?.[key];
+        if (!relation) {
+          console.warn(
+            `[populate] Relation "${String(key)}" not found in config`
+          );
+          continue;
+        }
+        const targetRepo = allRepositories[relation.repo];
+        if (!targetRepo) {
+          console.warn(
+            `[populate] Repository "${relation.repo}" not found in mapping`
+          );
+          continue;
+        }
+        const fieldValue = document[key];
+        if (fieldValue === void 0 || fieldValue === null) {
+          populated[relation.repo] = relation.type === "one" ? null : [];
+          continue;
+        }
+        try {
+          if (relation.type === "one") {
+            const getMethod = `by${capitalize2(relation.key)}`;
+            if (typeof targetRepo.get?.[getMethod] === "function") {
+              populated[relation.repo] = await targetRepo.get[getMethod](
+                fieldValue
+              );
+            } else {
+              console.warn(
+                `[populate] Method "get.${getMethod}" not found in ${relation.repo}`
+              );
+              populated[relation.repo] = null;
+            }
+          } else {
+            const queryMethod = `by${capitalize2(relation.key)}`;
+            if (typeof targetRepo.query[queryMethod] === "function") {
+              populated[relation.repo] = await targetRepo.query[queryMethod](
+                fieldValue
+              );
+            } else {
+              console.warn(
+                `[populate] Method "query.${queryMethod}" not found in ${relation.repo}`
+              );
+              populated[relation.repo] = [];
+            }
+          }
+        } catch (error) {
+          console.error(`[populate] Error populating "${String(key)}":`, error);
+          populated[relation.repo] = relation.type === "one" ? null : [];
+        }
+      }
+      return { ...result, populated };
+    }
+  };
+}
+function capitalize2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/methods/transaction.ts
+function createTransactionMethods(db, documentRef) {
+  return {
+    run: async (updateFunction) => {
+      return db.runTransaction(async (rawTransaction) => {
+        const typedTransaction = {
+          // Type-safe get method
+          get: async (...args) => {
+            const docRef = documentRef(...args);
+            const docSnap = await rawTransaction.get(docRef);
+            if (!docSnap.exists) return null;
+            return { ...docSnap.data(), docId: docSnap.id };
+          },
+          // Type-safe set method
+          set: (...args) => {
+            const options = args[args.length - 1];
+            const hasOptions = typeof options === "object" && options !== null && "merge" in options;
+            const data = hasOptions ? args[args.length - 2] : args[args.length - 1];
+            const pathArgs = hasOptions ? args.slice(0, -2) : args.slice(0, -1);
+            const mergeOption = hasOptions ? options : { merge: true };
+            const docRef = documentRef(...pathArgs);
+            rawTransaction.set(docRef, data, mergeOption);
+          },
+          // Type-safe update method
+          update: (...args) => {
+            const data = args[args.length - 1];
+            const pathArgs = args.slice(0, -1);
+            const docRef = documentRef(...pathArgs);
+            rawTransaction.update(docRef, data);
+          },
+          // Delete method
+          delete: (...args) => {
+            const docRef = documentRef(...args);
+            rawTransaction.delete(docRef);
+          },
+          // Access to raw transaction
+          raw: rawTransaction
+        };
+        return updateFunction(typedTransaction);
+      });
+    }
+  };
+}
+
+// src/repositories/factory.ts
+function createRepository(db, config, allRepositories = {}) {
+  const collectionRef = config.isGroup ? db.collectionGroup(config.path) : db.collection(config.path);
+  const actualCollection = config.isGroup ? null : db.collection(config.path);
+  const documentRef = (...args) => config.refCb(db, ...args);
+  const getMethods = createGetMethods(
+    collectionRef,
+    config.foreignKeys,
+    actualCollection,
+    documentRef
+  );
+  const queryMethods = createQueryMethods(
+    collectionRef,
+    config.queryKeys
+  );
+  const aggregateMethods = createAggregateMethods(collectionRef);
+  const crudMethods = createCrudMethods(actualCollection, documentRef);
+  const batchMethods = createBatchMethods(db, documentRef);
+  const transactionMethods = createTransactionMethods(db, documentRef);
+  const bulkMethods = createBulkMethods(db);
+  const populateMethods = createPopulateMethods(config, allRepositories);
+  return {
+    ref: collectionRef,
+    documentRef,
+    get: getMethods,
+    query: queryMethods,
+    aggregate: aggregateMethods,
+    ...crudMethods,
+    batch: batchMethods,
+    transaction: transactionMethods,
+    bulk: bulkMethods,
+    ...populateMethods
+  };
+}
+
+// index.ts
+function createRepositoryConfig() {
+  return (config) => {
+    return {
+      ...config,
+      type: null,
+      documentRef: null,
+      update: null
+    };
+  };
+}
+function buildRepositoryRelations(mapping, relations) {
+  const result = { ...mapping };
+  for (const repoKey in relations) {
+    if (relations[repoKey]) {
+      result[repoKey] = {
+        ...mapping[repoKey],
+        relationalKeys: relations[repoKey]
+      };
+    }
+  }
+  return result;
+}
+var RepositoryMapping = class {
+  /**
+   * Creates a new RepositoryMapping instance
+   * @param db - Firestore instance from firebase-admin
+   * @param mapping - Repository configuration mapping
+   */
+  constructor(db, mapping) {
+    this.repositoryCache = /* @__PURE__ */ new Map();
+    this.allRepositories = {};
+    this.db = db;
+    this.mapping = mapping;
+    this.initializeRepositories();
+  }
+  /**
+   * Initialize all repositories in two passes to handle circular dependencies
+   * @private
+   */
+  initializeRepositories() {
+    for (const key of Object.keys(this.mapping)) {
+      this.allRepositories[key] = createRepository(
+        this.db,
+        this.mapping[key],
+        {}
+      );
+    }
+    for (const key of Object.keys(this.mapping)) {
+      this.allRepositories[key] = createRepository(
+        this.db,
+        this.mapping[key],
+        this.allRepositories
+      );
+    }
+  }
+  /**
+   * Gets a repository (already initialized)
+   * @template K - Repository key
+   * @param key - Repository identifier
+   * @returns Configured repository instance
+   */
+  getRepository(key) {
+    return this.allRepositories[key];
+  }
+};
+function createRepositoryMapping(db, mapping) {
+  const instance = new RepositoryMapping(db, mapping);
+  return new Proxy(instance, {
+    get(target, prop) {
+      if (typeof prop === "string" && prop in mapping) {
+        return target.getRepository(prop);
+      }
+      return target[prop];
+    }
+  });
+}
+
+export { RepositoryMapping, applyQueryOptions as applyPaginationQueryOptions, buildAndExecuteQuery, buildRepositoryRelations, createPaginationIterator, createRepositoryConfig, createRepositoryMapping, executePaginatedQuery };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map