@mohasinac/appkit 2.1.3 → 2.2.0

package/dist/providers/db-firebase/admin.js

@@ -0,0 +1,163 @@
+/**
+ * Firebase Admin SDK singletons.
+ *
+ * Supports two init methods (checked in order):
+ *   1. `firebase-admin-key.json` in process.cwd() — development
+ *   2. FIREBASE_ADMIN_PROJECT_ID / CLIENT_EMAIL / PRIVATE_KEY env vars — production
+ *
+ * All getters are lazy — the SDK is not touched until first use.
+ */
+import "server-only";
+import * as path from "path";
+import * as fs from "fs";
+// Lazy loaders — prevents webpack from bundling firebase-admin into browser chunks.
+// (module as any).require() is used because webpack's static analysis does NOT trace
+// module.require() calls, unlike calls to the literal `require` or aliased `require`.
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function loadApp() {
+    return module.require("firebase-admin/app");
+}
+function loadAuth() {
+    return module.require("firebase-admin/auth");
+}
+function loadFirestore() {
+    return module.require("firebase-admin/firestore");
+}
+function loadStorage() {
+    return module.require("firebase-admin/storage");
+}
+function loadDatabase() {
+    return module.require("firebase-admin/database");
+}
+/* eslint-enable @typescript-eslint/no-require-imports */
+// ─── Private key normalisation ────────────────────────────────────────────────
+//
+// Vercel (and other platforms) can store the private key in several formats:
+//   1. Literal \n sequences  (common — copied from JSON value)
+//   2. Real newlines          (set via CLI / multiline input)
+//   3. Windows \r\n endings   (copied on Windows)
+//   4. Wrapped in double-quotes (pasted with JSON quotes intact)
+//
+// OpenSSL 3 (Node 18+) rejects malformed PEM — ensure the key is normalised
+// before passing it to `cert()`.
+//
+function parsePrivateKey(raw) {
+    return raw
+        .replace(/^["']|["']$/g, "") // strip optional surrounding quotes
+        .replace(/\\n/g, "\n") // literal \n → real newline
+        .replace(/\r\n/g, "\n") // Windows CRLF → LF
+        .trim();
+}
+function get(key) {
+    return globalThis[key] ?? null;
+}
+function set(key, value) {
+    globalThis[key] = value;
+}
+// ─── App ──────────────────────────────────────────────────────────────────────
+export function getAdminApp() {
+    const cached = get("__mohasinac_firebase_admin_app__");
+    if (cached)
+        return cached;
+    const { initializeApp, getApps, cert } = loadApp();
+    if (getApps().length) {
+        const existing = getApps()[0];
+        set("__mohasinac_firebase_admin_app__", existing);
+        return existing;
+    }
+    const keyPath = path.join(process.cwd(), "firebase-admin-key.json");
+    let app;
+    try {
+        if (fs.existsSync(keyPath)) {
+            const sa = JSON.parse(fs.readFileSync(keyPath, "utf8"));
+            const dbUrl = process.env.NEXT_PUBLIC_FIREBASE_DATABASE_URL ??
+                `https://${sa.project_id}-default-rtdb.firebaseio.com`;
+            app = initializeApp({ credential: cert(keyPath), databaseURL: dbUrl });
+        }
+        else if (process.env.FIREBASE_ADMIN_PROJECT_ID &&
+            process.env.FIREBASE_ADMIN_CLIENT_EMAIL &&
+            process.env.FIREBASE_ADMIN_PRIVATE_KEY) {
+            const projectId = process.env.FIREBASE_ADMIN_PROJECT_ID.trim();
+            const dbUrl = process.env.FIREBASE_ADMIN_DATABASE_URL?.trim() ??
+                process.env.NEXT_PUBLIC_FIREBASE_DATABASE_URL?.trim() ??
+                `https://${projectId}-default-rtdb.firebaseio.com`;
+            app = initializeApp({
+                credential: cert({
+                    projectId,
+                    clientEmail: process.env.FIREBASE_ADMIN_CLIENT_EMAIL.trim(),
+                    privateKey: parsePrivateKey(process.env.FIREBASE_ADMIN_PRIVATE_KEY),
+                }),
+                databaseURL: dbUrl,
+            });
+        }
+        else {
+            throw new Error("@mohasinac/db-firebase: Firebase Admin credentials not found.\n" +
+                "Add firebase-admin-key.json to project root, or set " +
+                "FIREBASE_ADMIN_PROJECT_ID, FIREBASE_ADMIN_CLIENT_EMAIL, " +
+                "FIREBASE_ADMIN_PRIVATE_KEY environment variables.");
+        }
+    }
+    catch (err) {
+        console.error("[@mohasinac/db-firebase] Failed to initialise Admin SDK:", err);
+        throw err;
+    }
+    set("__mohasinac_firebase_admin_app__", app);
+    return app;
+}
+// ─── Auth ─────────────────────────────────────────────────────────────────────
+export function getAdminAuth() {
+    const cached = get("__mohasinac_firebase_admin_auth__");
+    if (cached)
+        return cached;
+    const { getAuth } = loadAuth();
+    const auth = getAuth(getAdminApp());
+    set("__mohasinac_firebase_admin_auth__", auth);
+    return auth;
+}
+// ─── Firestore ────────────────────────────────────────────────────────────────
+export function getAdminDb() {
+    const cached = get("__mohasinac_firebase_admin_db__");
+    if (cached)
+        return cached;
+    const { getFirestore } = loadFirestore();
+    const db = getFirestore(getAdminApp());
+    try {
+        // settings() can only be called once per Firestore instance — guard for
+        // HMR reloads and duplicate module instances.
+        db.settings({ ignoreUndefinedProperties: true });
+    }
+    catch {
+        // Already configured — safe to ignore.
+    }
+    set("__mohasinac_firebase_admin_db__", db);
+    return db;
+}
+// ─── Cloud Storage ────────────────────────────────────────────────────────────
+export function getAdminStorage() {
+    const cached = get("__mohasinac_firebase_admin_storage__");
+    if (cached)
+        return cached;
+    const { getStorage: getFirebaseStorage } = loadStorage();
+    const storage = getFirebaseStorage(getAdminApp());
+    set("__mohasinac_firebase_admin_storage__", storage);
+    return storage;
+}
+// ─── Realtime DB ──────────────────────────────────────────────────────────────
+export function getAdminRealtimeDb() {
+    const cached = get("__mohasinac_firebase_admin_rtdb__");
+    if (cached)
+        return cached;
+    const { getDatabase } = loadDatabase();
+    const rtdb = getDatabase(getAdminApp());
+    set("__mohasinac_firebase_admin_rtdb__", rtdb);
+    return rtdb;
+}
+/** Reset all singletons — useful in tests. */
+export function _resetAdminSingletons() {
+    set("__mohasinac_firebase_admin_app__", null);
+    set("__mohasinac_firebase_admin_auth__", null);
+    set("__mohasinac_firebase_admin_db__", null);
+    set("__mohasinac_firebase_admin_storage__", null);
+    set("__mohasinac_firebase_admin_rtdb__", null);
+}

package/dist/providers/db-firebase/base.d.ts

@@ -0,0 +1,44 @@
+import "server-only";
+/**
+ * FirebaseRepository<T>
+ *
+ * Generic abstract base class implementing `IRepository<T>` from
+ * `@mohasinac/contracts` against Firebase Firestore (Admin SDK).
+ *
+ * Usage:
+ * ```ts
+ * import { FirebaseRepository } from "@mohasinac/db-firebase";
+ * import type { Product } from "@/types";
+ *
+ * export class ProductRepository extends FirebaseRepository<Product> {
+ *   constructor() { super("products"); }
+ * }
+ * ```
+ *
+ * `findAll(query?)` maps the provider-agnostic `SieveQuery` from
+ * `@mohasinac/contracts` to Firestore native queries (no in-memory fan-out).
+ */
+import type { CollectionReference, DocumentData, DocumentSnapshot, Firestore } from "firebase-admin/firestore";
+import type { IRepository, PagedResult, SieveQuery, WhereOp } from "../../contracts";
+export declare class FirebaseRepository<T extends DocumentData> implements IRepository<T> {
+    protected readonly collection: string;
+    constructor(collectionName: string);
+    protected get db(): Firestore;
+    protected getCollection(): CollectionReference;
+    /** Single adapter boundary: DocumentSnapshot → typed entity. */
+    protected mapDoc<D = T>(snap: DocumentSnapshot): D;
+    findById(id: string): Promise<T | null>;
+    findAll(query?: SieveQuery): Promise<PagedResult<T>>;
+    findWhere(field: keyof T, op: WhereOp, value: unknown): Promise<T[]>;
+    create(data: Omit<T, "id" | "createdAt" | "updatedAt">): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    delete(id: string): Promise<void>;
+    batchCreate(items: Array<Omit<T, "id" | "createdAt" | "updatedAt">>): Promise<T[]>;
+    batchDelete(ids: string[]): Promise<void>;
+    /** Find by ID or throw `Error` with a descriptive message. */
+    findByIdOrFail(id: string): Promise<T>;
+    /** Find first document where `field == value`. */
+    findOneBy(field: string, value: unknown): Promise<T | null>;
+    /** Count all documents in the collection. */
+    count(): Promise<number>;
+}

package/dist/providers/db-firebase/base.js

@@ -0,0 +1,180 @@
+import "server-only";
+import { getAdminDb } from "./admin";
+import { prepareForFirestore, deserializeTimestamps } from "./helpers";
+export class FirebaseRepository {
+    constructor(collectionName) {
+        this.collection = collectionName;
+    }
+    // ── Internals ──────────────────────────────────────────────────────────────
+    get db() {
+        return getAdminDb();
+    }
+    getCollection() {
+        return this.db.collection(this.collection);
+    }
+    /** Single adapter boundary: DocumentSnapshot → typed entity. */
+    mapDoc(snap) {
+        return deserializeTimestamps({
+            id: snap.id,
+            ...(snap.data() ?? {}),
+        });
+    }
+    // ── IReadRepository ────────────────────────────────────────────────────────
+    async findById(id) {
+        const snap = await this.getCollection().doc(id).get();
+        if (!snap.exists)
+            return null;
+        return this.mapDoc(snap);
+    }
+    async findAll(query) {
+        const page = Math.max(1, query?.page ?? 1);
+        const perPage = Math.max(1, Math.min(query?.perPage ?? 20, 500));
+        let q = this.getCollection();
+        // ── Sort ──────────────────────────────────────────────────────────────────
+        // SieveQuery.sort supports a leading "-" prefix for descending order
+        // (e.g. "-createdAt" means ORDER BY createdAt DESC).
+        if (query?.sort) {
+            const rawSort = query.sort;
+            const descPrefix = rawSort.startsWith("-");
+            const sortField = descPrefix ? rawSort.slice(1) : rawSort;
+            const sortDir = descPrefix
+                ? "desc"
+                : query.order === "desc"
+                    ? "desc"
+                    : "asc";
+            q = q.orderBy(sortField, sortDir);
+        }
+        // ── Basic Sieve filter parsing ────────────────────────────────────────────
+        // Supports: ==, !=, <, <=, >, >=, @= (array-contains)
+        if (query?.filters) {
+            const clauses = query.filters
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+            for (const clause of clauses) {
+                const match = clause.match(/^([^<>=!@]+)\s*(==|!=|<=|>=|<|>|@=)\s*(.+)$/);
+                if (!match)
+                    continue;
+                const [, fieldRaw, opToken, valueRaw] = match;
+                const field = fieldRaw.trim();
+                const op = TOKEN_TO_OP[opToken.trim()] ?? "==";
+                const value = coerceValue(valueRaw.trim());
+                q = q.where(field, op, value);
+            }
+        }
+        // ── Count ─────────────────────────────────────────────────────────────────
+        const countSnap = await q.count().get();
+        const total = countSnap.data().count;
+        // ── Paginate ──────────────────────────────────────────────────────────────
+        const offset = (page - 1) * perPage;
+        const pagedSnap = await q.offset(offset).limit(perPage).get();
+        const data = pagedSnap.docs.map((d) => this.mapDoc(d));
+        const totalPages = total === 0 ? 0 : Math.max(1, Math.ceil(total / perPage));
+        return { data, total, page, perPage, totalPages };
+    }
+    async findWhere(field, op, value) {
+        const snap = await this.getCollection()
+            .where(field, op, value)
+            .get();
+        return snap.docs.map((d) => this.mapDoc(d));
+    }
+    // ── IWriteRepository ───────────────────────────────────────────────────────
+    async create(data) {
+        const now = new Date();
+        const payload = prepareForFirestore({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        });
+        const ref = await this.getCollection().add(payload);
+        const snap = await ref.get();
+        return this.mapDoc(snap);
+    }
+    async update(id, data) {
+        const payload = prepareForFirestore({
+            ...data,
+            updatedAt: new Date(),
+        });
+        await this.getCollection()
+            .doc(id)
+            .update(payload);
+        const snap = await this.getCollection().doc(id).get();
+        if (!snap.exists)
+            throw new Error(`Document not found after update: ${id}`);
+        return this.mapDoc(snap);
+    }
+    async delete(id) {
+        await this.getCollection().doc(id).delete();
+    }
+    async batchCreate(items) {
+        const now = new Date();
+        const batch = this.db.batch();
+        const refs = items.map((item) => {
+            const ref = this.getCollection().doc();
+            const payload = prepareForFirestore({
+                ...item,
+                createdAt: now,
+                updatedAt: now,
+            });
+            batch.set(ref, payload);
+            return ref;
+        });
+        await batch.commit();
+        // Fetch created docs in one round-trip
+        const snaps = await Promise.all(refs.map((r) => r.get()));
+        return snaps.map((s) => this.mapDoc(s));
+    }
+    async batchDelete(ids) {
+        const batch = this.db.batch();
+        for (const id of ids) {
+            batch.delete(this.getCollection().doc(id));
+        }
+        await batch.commit();
+    }
+    // ── Extended helpers (not in IRepository contract) ────────────────────────
+    /** Find by ID or throw `Error` with a descriptive message. */
+    async findByIdOrFail(id) {
+        const doc = await this.findById(id);
+        if (!doc)
+            throw new Error(`Document not found: ${this.collection}/${id}`);
+        return doc;
+    }
+    /** Find first document where `field == value`. */
+    async findOneBy(field, value) {
+        const snap = await this.getCollection()
+            .where(field, "==", value)
+            .limit(1)
+            .get();
+        if (snap.empty)
+            return null;
+        return this.mapDoc(snap.docs[0]);
+    }
+    /** Count all documents in the collection. */
+    async count() {
+        const snap = await this.getCollection().count().get();
+        return snap.data().count;
+    }
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+const TOKEN_TO_OP = {
+    "==": "==",
+    "!=": "!=",
+    "<": "<",
+    "<=": "<=",
+    ">": ">",
+    ">=": ">=",
+    "@=": "array-contains",
+};
+/** Best-effort scalar coercion for sieve filter values. */
+function coerceValue(raw) {
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    if (raw === "null")
+        return null;
+    const n = Number(raw);
+    if (!Number.isNaN(n) && raw !== "")
+        return n;
+    return raw;
+}

package/dist/providers/db-firebase/base.repository.d.ts

@@ -0,0 +1,34 @@
+import "server-only";
+import type { CollectionReference, DocumentData, DocumentReference, DocumentSnapshot, Firestore, Query, Transaction, WriteBatch } from "firebase-admin/firestore";
+import { type FirebaseSieveFields, type FirebaseSieveOptions, type FirebaseSieveResult, type SieveModel } from "./sieve";
+export declare abstract class BaseRepository<T extends DocumentData> {
+    protected collection: string;
+    constructor(collectionName: string);
+    protected get db(): Firestore;
+    protected getCollection(): CollectionReference<DocumentData, DocumentData>;
+    protected mapDoc<D = T>(snap: DocumentSnapshot): D;
+    findById(id: string): Promise<T | null>;
+    findByIdOrFail(id: string): Promise<T>;
+    findBy(field: string, value: unknown): Promise<T[]>;
+    findOneBy(field: string, value: unknown): Promise<T | null>;
+    findAll(limit?: number): Promise<T[]>;
+    create(data: Partial<T> | Record<string, unknown>): Promise<T>;
+    createWithId(id: string, data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    count(): Promise<number>;
+    protected sieveQuery<TResult extends DocumentData = T>(model: SieveModel, fields: FirebaseSieveFields, options?: FirebaseSieveOptions & {
+        baseQuery?: CollectionReference | Query;
+    }): Promise<FirebaseSieveResult<TResult>>;
+    findByIdInTx(tx: Transaction, id: string): Promise<T | null>;
+    findByIdOrFailInTx(tx: Transaction, id: string): Promise<T>;
+    createInTx(tx: Transaction, data: Partial<T> | Record<string, unknown>): DocumentReference;
+    createWithIdInTx(tx: Transaction, id: string, data: Partial<T> | Record<string, unknown>): DocumentReference;
+    updateInTx(tx: Transaction, id: string, data: Partial<T>): void;
+    deleteInTx(tx: Transaction, id: string): void;
+    createInBatch(batch: WriteBatch, data: Partial<T> | Record<string, unknown>): DocumentReference;
+    createWithIdInBatch(batch: WriteBatch, id: string, data: Partial<T> | Record<string, unknown>): void;
+    updateInBatch(batch: WriteBatch, id: string, data: Partial<T>): void;
+    deleteInBatch(batch: WriteBatch, id: string): void;
+}

package/dist/providers/db-firebase/base.repository.js

@@ -0,0 +1,235 @@
+import "server-only";
+import { DatabaseError, NotFoundError } from "../../errors";
+import { serverLogger } from "../../monitoring";
+import { applySieveToFirestore, } from "./sieve";
+import { deserializeTimestamps, prepareForFirestore } from "./helpers";
+import { getAdminDb } from "./admin";
+export class BaseRepository {
+    constructor(collectionName) {
+        this.collection = collectionName;
+    }
+    get db() {
+        return getAdminDb();
+    }
+    getCollection() {
+        return this.db.collection(this.collection);
+    }
+    mapDoc(snap) {
+        return deserializeTimestamps({
+            id: snap.id,
+            ...(snap.data() ?? {}),
+        });
+    }
+    async findById(id) {
+        try {
+            const doc = await this.getCollection().doc(id).get();
+            if (!doc.exists) {
+                return null;
+            }
+            return this.mapDoc(doc);
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to find document by ID: ${id}`, error);
+        }
+    }
+    async findByIdOrFail(id) {
+        const doc = await this.findById(id);
+        if (!doc) {
+            throw new NotFoundError(`Document not found: ${id}`);
+        }
+        return doc;
+    }
+    async findBy(field, value) {
+        try {
+            const snapshot = await this.getCollection()
+                .where(field, "==", value)
+                .get();
+            return snapshot.docs.map((doc) => this.mapDoc(doc));
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to find documents by ${field}`, error);
+        }
+    }
+    async findOneBy(field, value) {
+        try {
+            const snapshot = await this.getCollection()
+                .where(field, "==", value)
+                .limit(1)
+                .get();
+            if (snapshot.empty) {
+                return null;
+            }
+            return this.mapDoc(snapshot.docs[0]);
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to find document by ${field}`, error);
+        }
+    }
+    async findAll(limit) {
+        try {
+            let query = this.getCollection();
+            if (limit) {
+                query = query.limit(limit);
+            }
+            const snapshot = await query.get();
+            return snapshot.docs.map((doc) => this.mapDoc(doc));
+        }
+        catch (error) {
+            throw new DatabaseError("Failed to fetch all documents", error);
+        }
+    }
+    async create(data) {
+        try {
+            const cleanData = prepareForFirestore({
+                ...data,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            });
+            const docRef = await this.getCollection().add(cleanData);
+            const doc = await docRef.get();
+            return this.mapDoc(doc);
+        }
+        catch (error) {
+            throw new DatabaseError("Failed to create document", error);
+        }
+    }
+    async createWithId(id, data) {
+        try {
+            const now = new Date();
+            const cleanData = prepareForFirestore({
+                ...data,
+                createdAt: now,
+                updatedAt: now,
+            });
+            serverLogger.debug(`Creating document with ID: ${id} in collection: ${this.collection}`);
+            await this.getCollection().doc(id).set(cleanData);
+            serverLogger.info(`Document created successfully: ${id}`);
+            const doc = await this.getCollection().doc(id).get();
+            return this.mapDoc(doc);
+        }
+        catch (error) {
+            serverLogger.error(`Failed to create document with ID: ${id}`, {
+                collection: this.collection,
+                error: error.message,
+                code: error.code,
+            });
+            throw new DatabaseError(`Failed to create document with ID: ${id}`, error);
+        }
+    }
+    async update(id, data) {
+        try {
+            const cleanData = prepareForFirestore({
+                ...data,
+                updatedAt: new Date(),
+            });
+            await this.getCollection().doc(id).update(cleanData);
+            return this.findByIdOrFail(id);
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to update document: ${id}`, error);
+        }
+    }
+    async delete(id) {
+        try {
+            await this.getCollection().doc(id).delete();
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to delete document: ${id}`, error);
+        }
+    }
+    async exists(id) {
+        try {
+            const doc = await this.getCollection().doc(id).get();
+            return doc.exists;
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to check document existence: ${id}`, error);
+        }
+    }
+    async count() {
+        try {
+            const snapshot = await this.getCollection().get();
+            return snapshot.size;
+        }
+        catch (error) {
+            throw new DatabaseError("Failed to count documents", error);
+        }
+    }
+    async sieveQuery(model, fields, options) {
+        const { baseQuery, ...sieveOptions } = options ?? {};
+        return applySieveToFirestore({
+            baseQuery: baseQuery ?? this.getCollection(),
+            model,
+            fields,
+            options: sieveOptions,
+        });
+    }
+    async findByIdInTx(tx, id) {
+        const docRef = this.getCollection().doc(id);
+        const snap = await tx.get(docRef);
+        if (!snap.exists)
+            return null;
+        return this.mapDoc(snap);
+    }
+    async findByIdOrFailInTx(tx, id) {
+        const doc = await this.findByIdInTx(tx, id);
+        if (!doc)
+            throw new NotFoundError(`Document not found: ${id}`);
+        return doc;
+    }
+    createInTx(tx, data) {
+        const docRef = this.getCollection().doc();
+        const now = new Date();
+        tx.set(docRef, prepareForFirestore({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return docRef;
+    }
+    createWithIdInTx(tx, id, data) {
+        const docRef = this.getCollection().doc(id);
+        const now = new Date();
+        tx.set(docRef, prepareForFirestore({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return docRef;
+    }
+    updateInTx(tx, id, data) {
+        const docRef = this.getCollection().doc(id);
+        tx.update(docRef, prepareForFirestore({ ...data, updatedAt: new Date() }));
+    }
+    deleteInTx(tx, id) {
+        const docRef = this.getCollection().doc(id);
+        tx.delete(docRef);
+    }
+    createInBatch(batch, data) {
+        const docRef = this.getCollection().doc();
+        const now = new Date();
+        batch.set(docRef, prepareForFirestore({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return docRef;
+    }
+    createWithIdInBatch(batch, id, data) {
+        const docRef = this.getCollection().doc(id);
+        const now = new Date();
+        batch.set(docRef, prepareForFirestore({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        }));
+    }
+    updateInBatch(batch, id, data) {
+        const docRef = this.getCollection().doc(id);
+        batch.update(docRef, prepareForFirestore({ ...data, updatedAt: new Date() }));
+    }
+    deleteInBatch(batch, id) {
+        const docRef = this.getCollection().doc(id);
+        batch.delete(docRef);
+    }
+}