@mohasinac/appkit 3.6.5 → 3.8.0

package/dist/features/tester/repository/tester-checklist-item.repository.js

@@ -0,0 +1,55 @@
+import { BaseRepository } from "../../../providers/db-firebase";
+import { DatabaseError } from "../../../errors";
+import { TESTER_CHECKLIST_ITEM_COLLECTION, TESTER_CHECKLIST_ITEM_FIELDS, createChecklistItemId, } from "../schemas/firestore";
+export class TesterChecklistItemRepository extends BaseRepository {
+    constructor() {
+        super(TESTER_CHECKLIST_ITEM_COLLECTION);
+    }
+    buildSearchTokens(input) {
+        const rawText = [input.label, input.description, input.groupLabel, input.pageLabel]
+            .filter(Boolean)
+            .join(" ")
+            .toLowerCase();
+        return Array.from(new Set(rawText
+            .split(/[^a-z0-9]+/i)
+            .map((token) => token.trim())
+            .filter((token) => token.length >= 2))).slice(0, 50);
+    }
+    async createItem(input) {
+        const id = createChecklistItemId(input.groupKey, input.pageKey, input.label);
+        const searchTokens = this.buildSearchTokens(input);
+        return this.createWithId(id, { ...input, searchTokens });
+    }
+    async update(id, data) {
+        const current = await this.findById(id);
+        if (!current) {
+            throw new DatabaseError(`Failed to update checklist item: missing document ${id}`);
+        }
+        const merged = { ...current, ...data };
+        return super.update(id, {
+            ...data,
+            searchTokens: this.buildSearchTokens(merged),
+        });
+    }
+    async listActive() {
+        const snapshot = await this.db
+            .collection(this.collection)
+            .where(TESTER_CHECKLIST_ITEM_FIELDS.IS_ACTIVE, "==", true)
+            .orderBy(TESTER_CHECKLIST_ITEM_FIELDS.ORDER, "asc")
+            .get();
+        return snapshot.docs.map((doc) => this.mapDoc(doc));
+    }
+    async list(model) {
+        return this.sieveQuery(model, TesterChecklistItemRepository.SIEVE_FIELDS);
+    }
+}
+TesterChecklistItemRepository.SIEVE_FIELDS = {
+    groupKey: { canFilter: true, canSort: true },
+    pageKey: { canFilter: true, canSort: true },
+    label: { canFilter: true, canSort: false },
+    order: { canFilter: true, canSort: true },
+    isActive: { canFilter: true, canSort: false },
+    searchTokens: { canFilter: true, canSort: false },
+    createdAt: { canFilter: true, canSort: true },
+};
+export const testerChecklistItemRepository = new TesterChecklistItemRepository();

package/dist/features/tester/repository/tester-checklist-response.repository.d.ts

@@ -0,0 +1,50 @@
+import { BaseRepository } from "../../../providers/db-firebase";
+import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
+import { type TesterAnswer, type TesterChecklistResponseDocument } from "../schemas/firestore";
+export interface UpsertResponseInput {
+    testerId: string;
+    testerDisplayName: string;
+    checklistItemId: string;
+    groupKey: string;
+    pageKey: string;
+    answer?: TesterAnswer | null;
+    comment?: string;
+    screenshotUrl?: string;
+}
+export interface ChecklistItemCoverage {
+    checklistItemId: string;
+    groupKey: string;
+    pageKey: string;
+    yesCount: number;
+    noCount: number;
+    totalAnswered: number;
+}
+export interface CoverageReport {
+    itemCoverage: ChecklistItemCoverage[];
+    issues: TesterChecklistResponseDocument[];
+    totals: {
+        totalAnswered: number;
+        totalYes: number;
+        totalNo: number;
+    };
+}
+export declare class TesterChecklistResponseRepository extends BaseRepository<TesterChecklistResponseDocument> {
+    static readonly SIEVE_FIELDS: FirebaseSieveFields;
+    constructor();
+    /** Deterministic-ID upsert — the only mutation path for tester responses. */
+    upsertResponse(input: UpsertResponseInput): Promise<TesterChecklistResponseDocument>;
+    listForTester(testerId: string): Promise<TesterChecklistResponseDocument[]>;
+    list(model: SieveModel): Promise<FirebaseSieveResult<TesterChecklistResponseDocument>>;
+    markReviewed(id: string): Promise<TesterChecklistResponseDocument>;
+    /** Single collection scan (small table: testers x cases) — no join needed. */
+    getCoverageReport(): Promise<CoverageReport>;
+    /**
+     * Markdown dump of every answered case, joined against the checklist item
+     * catalog for the human-readable label/href — optimized for a future dev
+     * (or Claude session) to read directly and go fix the reported issues.
+     * Mirrors appkit/scripts/export-tester-feedback.mjs's CLI output exactly;
+     * keep the two in sync.
+     */
+    getMarkdownReport(siteOrigin: string): Promise<string>;
+}
+export declare const testerChecklistResponseRepository: TesterChecklistResponseRepository;

package/dist/features/tester/repository/tester-checklist-response.repository.js

@@ -0,0 +1,196 @@
+import { BaseRepository } from "../../../providers/db-firebase";
+import { TESTER_CHECKLIST_RESPONSE_COLLECTION, TESTER_CHECKLIST_RESPONSE_FIELDS, createChecklistResponseId, } from "../schemas/firestore";
+import { testerChecklistItemRepository } from "./tester-checklist-item.repository";
+function escapeMd(text) {
+    return (text ?? "").replace(/\r?\n/g, " ").trim();
+}
+function screenshotLink(screenshotUrl, siteOrigin) {
+    if (!screenshotUrl)
+        return "(none)";
+    const abs = screenshotUrl.startsWith("http") ? screenshotUrl : `${siteOrigin}${screenshotUrl}`;
+    return `[view](${abs})`;
+}
+export class TesterChecklistResponseRepository extends BaseRepository {
+    constructor() {
+        super(TESTER_CHECKLIST_RESPONSE_COLLECTION);
+    }
+    /** Deterministic-ID upsert — the only mutation path for tester responses. */
+    async upsertResponse(input) {
+        const id = createChecklistResponseId(input.testerId, input.checklistItemId);
+        const existing = await this.findById(id);
+        const patch = {
+            testerId: input.testerId,
+            testerDisplayName: input.testerDisplayName,
+            checklistItemId: input.checklistItemId,
+            groupKey: input.groupKey,
+            pageKey: input.pageKey,
+            status: "new",
+        };
+        if (input.answer !== undefined)
+            patch.answer = input.answer;
+        if (input.comment !== undefined)
+            patch.comment = input.comment;
+        if (input.screenshotUrl !== undefined)
+            patch.screenshotUrl = input.screenshotUrl;
+        if (existing) {
+            return this.update(id, patch);
+        }
+        return this.createWithId(id, {
+            answer: null,
+            ...patch,
+        });
+    }
+    async listForTester(testerId) {
+        const snapshot = await this.db
+            .collection(this.collection)
+            .where(TESTER_CHECKLIST_RESPONSE_FIELDS.TESTER_ID, "==", testerId)
+            .get();
+        return snapshot.docs.map((doc) => this.mapDoc(doc));
+    }
+    async list(model) {
+        return this.sieveQuery(model, TesterChecklistResponseRepository.SIEVE_FIELDS);
+    }
+    async markReviewed(id) {
+        return this.update(id, {
+            status: "reviewed",
+        });
+    }
+    /** Single collection scan (small table: testers x cases) — no join needed. */
+    async getCoverageReport() {
+        const snapshot = await this.db.collection(this.collection).get();
+        const docs = snapshot.docs.map((doc) => this.mapDoc(doc));
+        const byItem = new Map();
+        const issues = [];
+        let totalYes = 0;
+        let totalNo = 0;
+        for (const doc of docs) {
+            if (!doc.answer)
+                continue;
+            let entry = byItem.get(doc.checklistItemId);
+            if (!entry) {
+                entry = {
+                    checklistItemId: doc.checklistItemId,
+                    groupKey: doc.groupKey,
+                    pageKey: doc.pageKey,
+                    yesCount: 0,
+                    noCount: 0,
+                    totalAnswered: 0,
+                };
+                byItem.set(doc.checklistItemId, entry);
+            }
+            entry.totalAnswered += 1;
+            if (doc.answer === "yes") {
+                entry.yesCount += 1;
+                totalYes += 1;
+            }
+            else {
+                entry.noCount += 1;
+                totalNo += 1;
+                issues.push(doc);
+            }
+        }
+        return {
+            itemCoverage: Array.from(byItem.values()),
+            issues,
+            totals: { totalAnswered: totalYes + totalNo, totalYes, totalNo },
+        };
+    }
+    /**
+     * Markdown dump of every answered case, joined against the checklist item
+     * catalog for the human-readable label/href — optimized for a future dev
+     * (or Claude session) to read directly and go fix the reported issues.
+     * Mirrors appkit/scripts/export-tester-feedback.mjs's CLI output exactly;
+     * keep the two in sync.
+     */
+    async getMarkdownReport(siteOrigin) {
+        const [items, snapshot] = await Promise.all([
+            testerChecklistItemRepository.list({ page: "1", pageSize: "1000" }),
+            this.db.collection(this.collection).get(),
+        ]);
+        const itemById = new Map(items.items.map((item) => [item.id, item]));
+        const responses = snapshot.docs
+            .map((d) => this.mapDoc(d))
+            .filter((r) => r.answer === "yes" || r.answer === "no");
+        const grouped = new Map();
+        for (const r of responses) {
+            const item = itemById.get(r.checklistItemId);
+            const groupLabel = item?.groupLabel ?? r.groupKey ?? "Unknown group";
+            const pageLabel = item?.pageLabel ?? r.pageKey ?? "Unknown page";
+            const key = `${groupLabel}␟${pageLabel}`;
+            if (!grouped.has(key))
+                grouped.set(key, { groupLabel, pageLabel, items: [] });
+            grouped.get(key).items.push({ ...r, label: item?.label ?? r.checklistItemId, href: item?.href });
+        }
+        const sortedGroups = Array.from(grouped.values()).sort((a, b) => a.groupLabel.localeCompare(b.groupLabel) || a.pageLabel.localeCompare(b.pageLabel));
+        const issues = responses.filter((r) => r.answer === "no");
+        const passingWithNotes = responses.filter((r) => r.answer === "yes" && r.comment?.trim());
+        const lines = [];
+        lines.push("# Tester Feedback Report");
+        lines.push("");
+        lines.push(`Generated ${new Date().toISOString()} — ${issues.length} issue(s) ("No" answers) across ${responses.length} answered case(s), plus ${passingWithNotes.length} note(s) on passing cases.`);
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+        lines.push('## Issues ("No" answers) — fix these');
+        lines.push("");
+        if (issues.length === 0) {
+            lines.push("_No issues reported yet._");
+            lines.push("");
+        }
+        else {
+            for (const group of sortedGroups) {
+                const groupIssues = group.items.filter((r) => r.answer === "no");
+                if (groupIssues.length === 0)
+                    continue;
+                lines.push(`### ${group.groupLabel} › ${group.pageLabel}`);
+                lines.push("");
+                for (const r of groupIssues) {
+                    lines.push(`- [ ] **${escapeMd(r.label)}**`);
+                    lines.push(`  - Tester: ${escapeMd(r.testerDisplayName)}`);
+                    if (r.comment)
+                        lines.push(`  - Comment: ${escapeMd(r.comment)}`);
+                    lines.push(`  - Screenshot: ${screenshotLink(r.screenshotUrl, siteOrigin)}`);
+                    if (r.href)
+                        lines.push(`  - Test this: ${r.href}`);
+                    lines.push(`  - Status: ${r.status === "reviewed" ? "reviewed" : "new"}`);
+                    lines.push("");
+                }
+            }
+        }
+        lines.push("---");
+        lines.push("");
+        lines.push('## Notes on passing cases ("Yes" with a comment)');
+        lines.push("");
+        if (passingWithNotes.length === 0) {
+            lines.push("_No notes on passing cases._");
+            lines.push("");
+        }
+        else {
+            for (const group of sortedGroups) {
+                const groupNotes = group.items.filter((r) => r.answer === "yes" && r.comment?.trim());
+                if (groupNotes.length === 0)
+                    continue;
+                lines.push(`### ${group.groupLabel} › ${group.pageLabel}`);
+                lines.push("");
+                for (const r of groupNotes) {
+                    lines.push(`- **${escapeMd(r.label)}** (works)`);
+                    lines.push(`  - Tester: ${escapeMd(r.testerDisplayName)}`);
+                    lines.push(`  - Comment: ${escapeMd(r.comment)}`);
+                    lines.push(`  - Screenshot: ${screenshotLink(r.screenshotUrl, siteOrigin)}`);
+                    lines.push("");
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+}
+TesterChecklistResponseRepository.SIEVE_FIELDS = {
+    testerId: { canFilter: true, canSort: false },
+    checklistItemId: { canFilter: true, canSort: false },
+    groupKey: { canFilter: true, canSort: true },
+    pageKey: { canFilter: true, canSort: true },
+    answer: { canFilter: true, canSort: false },
+    status: { canFilter: true, canSort: false },
+    createdAt: { canFilter: true, canSort: true },
+};
+export const testerChecklistResponseRepository = new TesterChecklistResponseRepository();

package/dist/features/tester/schemas/firestore.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Tester Feature Firestore Document Types & Constants
+ *
+ * Two distinct collections, deliberately separate:
+ *  - TesterChecklistItemDocument — the admin-authored catalog of test cases (mirrors FAQs).
+ *  - TesterChecklistResponseDocument — one doc per (tester, case) answer, upserted by testerId+checklistItemId.
+ */
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+export interface TesterChecklistItemDocument extends BaseDocument {
+    groupKey: string;
+    groupLabel: string;
+    pageKey: string;
+    pageLabel: string;
+    label: string;
+    description?: string;
+    href?: string;
+    order: number;
+    isActive: boolean;
+    searchTokens: string[];
+}
+export declare const TESTER_CHECKLIST_ITEM_COLLECTION: "testerChecklistItems";
+export declare const TESTER_CHECKLIST_ITEM_ID_PREFIX: "checklist-";
+export declare const TESTER_CHECKLIST_ITEM_INDEXED_FIELDS: readonly ["groupKey", "pageKey", "order", "isActive", "searchTokens", "createdAt"];
+export declare const DEFAULT_TESTER_CHECKLIST_ITEM_DATA: Partial<TesterChecklistItemDocument>;
+export type TesterChecklistItemCreateInput = Omit<TesterChecklistItemDocument, "id" | "createdAt" | "updatedAt" | "searchTokens">;
+export type TesterChecklistItemUpdateInput = Partial<Pick<TesterChecklistItemDocument, "groupKey" | "groupLabel" | "pageKey" | "pageLabel" | "label" | "description" | "href" | "order" | "isActive">>;
+export declare const testerChecklistItemQueryHelpers: {
+    readonly byGroup: (groupKey: string) => readonly ["groupKey", "==", string];
+    readonly byPage: (pageKey: string) => readonly ["pageKey", "==", string];
+    readonly active: () => readonly ["isActive", "==", true];
+};
+export declare function slugifyChecklistLabel(label: string): string;
+export declare function createChecklistItemId(groupKey: string, pageKey: string, label: string): string;
+export type TesterAnswer = "yes" | "no";
+export type TesterFeedbackStatus = "new" | "reviewed";
+export interface TesterChecklistResponseDocument extends BaseDocument {
+    testerId: string;
+    testerDisplayName: string;
+    checklistItemId: string;
+    groupKey: string;
+    pageKey: string;
+    answer: TesterAnswer | null;
+    comment?: string;
+    screenshotUrl?: string;
+    status: TesterFeedbackStatus;
+}
+export declare const TESTER_CHECKLIST_RESPONSE_COLLECTION: "testerChecklistResponses";
+export declare const TESTER_CHECKLIST_RESPONSE_INDEXED_FIELDS: readonly ["testerId", "checklistItemId", "groupKey", "pageKey", "answer", "status", "createdAt"];
+export declare const DEFAULT_TESTER_CHECKLIST_RESPONSE_DATA: Partial<TesterChecklistResponseDocument>;
+export declare function createChecklistResponseId(testerId: string, checklistItemId: string): string;
+export declare const testerChecklistResponseQueryHelpers: {
+    readonly byTester: (testerId: string) => readonly ["testerId", "==", string];
+    readonly byItem: (checklistItemId: string) => readonly ["checklistItemId", "==", string];
+    readonly byAnswer: (answer: TesterAnswer) => readonly ["answer", "==", TesterAnswer];
+    readonly byStatus: (status: TesterFeedbackStatus) => readonly ["status", "==", TesterFeedbackStatus];
+};
+export declare const TESTER_CHECKLIST_ITEM_FIELDS: {
+    readonly ID: "id";
+    readonly GROUP_KEY: "groupKey";
+    readonly GROUP_LABEL: "groupLabel";
+    readonly PAGE_KEY: "pageKey";
+    readonly PAGE_LABEL: "pageLabel";
+    readonly LABEL: "label";
+    readonly DESCRIPTION: "description";
+    readonly HREF: "href";
+    readonly ORDER: "order";
+    readonly IS_ACTIVE: "isActive";
+    readonly SEARCH_TOKENS: "searchTokens";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+};
+export declare const TESTER_CHECKLIST_RESPONSE_FIELDS: {
+    readonly ID: "id";
+    readonly TESTER_ID: "testerId";
+    readonly TESTER_DISPLAY_NAME: "testerDisplayName";
+    readonly CHECKLIST_ITEM_ID: "checklistItemId";
+    readonly GROUP_KEY: "groupKey";
+    readonly PAGE_KEY: "pageKey";
+    readonly ANSWER: "answer";
+    readonly COMMENT: "comment";
+    readonly SCREENSHOT_URL: "screenshotUrl";
+    readonly STATUS: "status";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+};

package/dist/features/tester/schemas/firestore.js

@@ -0,0 +1,93 @@
+/**
+ * Tester Feature Firestore Document Types & Constants
+ *
+ * Two distinct collections, deliberately separate:
+ *  - TesterChecklistItemDocument — the admin-authored catalog of test cases (mirrors FAQs).
+ *  - TesterChecklistResponseDocument — one doc per (tester, case) answer, upserted by testerId+checklistItemId.
+ */
+import { generateChecklistItemId } from "../../../utils/id-generators";
+export const TESTER_CHECKLIST_ITEM_COLLECTION = "testerChecklistItems";
+export const TESTER_CHECKLIST_ITEM_ID_PREFIX = "checklist-";
+export const TESTER_CHECKLIST_ITEM_INDEXED_FIELDS = [
+    "groupKey",
+    "pageKey",
+    "order",
+    "isActive",
+    "searchTokens",
+    "createdAt",
+];
+export const DEFAULT_TESTER_CHECKLIST_ITEM_DATA = {
+    order: 0,
+    isActive: true,
+    searchTokens: [],
+};
+export const testerChecklistItemQueryHelpers = {
+    byGroup: (groupKey) => ["groupKey", "==", groupKey],
+    byPage: (pageKey) => ["pageKey", "==", pageKey],
+    active: () => ["isActive", "==", true],
+};
+export function slugifyChecklistLabel(label) {
+    return label
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+export function createChecklistItemId(groupKey, pageKey, label) {
+    return generateChecklistItemId({ groupKey, pageKey, label });
+}
+export const TESTER_CHECKLIST_RESPONSE_COLLECTION = "testerChecklistResponses";
+export const TESTER_CHECKLIST_RESPONSE_INDEXED_FIELDS = [
+    "testerId",
+    "checklistItemId",
+    "groupKey",
+    "pageKey",
+    "answer",
+    "status",
+    "createdAt",
+];
+export const DEFAULT_TESTER_CHECKLIST_RESPONSE_DATA = {
+    answer: null,
+    status: "new",
+};
+export function createChecklistResponseId(testerId, checklistItemId) {
+    return `${testerId}__${checklistItemId}`;
+}
+export const testerChecklistResponseQueryHelpers = {
+    byTester: (testerId) => ["testerId", "==", testerId],
+    byItem: (checklistItemId) => ["checklistItemId", "==", checklistItemId],
+    byAnswer: (answer) => ["answer", "==", answer],
+    byStatus: (status) => ["status", "==", status],
+};
+// --- Field name constants -----------------------------------------------------
+export const TESTER_CHECKLIST_ITEM_FIELDS = {
+    ID: "id",
+    GROUP_KEY: "groupKey",
+    GROUP_LABEL: "groupLabel",
+    PAGE_KEY: "pageKey",
+    PAGE_LABEL: "pageLabel",
+    LABEL: "label",
+    DESCRIPTION: "description",
+    HREF: "href",
+    ORDER: "order",
+    IS_ACTIVE: "isActive",
+    SEARCH_TOKENS: "searchTokens",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+};
+export const TESTER_CHECKLIST_RESPONSE_FIELDS = {
+    ID: "id",
+    TESTER_ID: "testerId",
+    TESTER_DISPLAY_NAME: "testerDisplayName",
+    CHECKLIST_ITEM_ID: "checklistItemId",
+    GROUP_KEY: "groupKey",
+    PAGE_KEY: "pageKey",
+    ANSWER: "answer",
+    COMMENT: "comment",
+    SCREENSHOT_URL: "screenshotUrl",
+    STATUS: "status",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+};

package/dist/features/tester/schemas/index.d.ts

@@ -0,0 +1 @@
+export * from "./firestore";

package/dist/features/tester/schemas/index.js

@@ -0,0 +1 @@
+export * from "./firestore";

package/dist/features/tester/seed-data/blog-tester-seed-data.d.ts

@@ -0,0 +1,2 @@
+import type { BlogPostDocument } from "../../blog/schemas";
+export declare const blogTesterSeedData: Partial<BlogPostDocument>[];

package/dist/features/tester/seed-data/blog-tester-seed-data.js

@@ -0,0 +1,40 @@
+/*
+ * WHY: Shared tester sandbox — 1 disposable test blog post so testers can exercise the
+ *      blog reading flow. Auto-expires after 7 days (testerSandboxCleanup).
+ * WHAT: Exports blogTesterSeedData — 1 Partial<BlogPostDocument> tagged isTestData:true.
+ *
+ * EXPORTS:
+ *   blogTesterSeedData — Array of 1 Partial<BlogPostDocument> for the seed runner
+ *
+ * @tag domain:blog,tester
+ * @tag layer:seed
+ * @tag pattern:none
+ * @tag access:server-only
+ * @tag consumers:seed/index.ts,seed-cli.mjs
+ * @tag sideEffects:none
+ */
+import { seedExtMedia } from "../../../seed/_helpers/media";
+import { testDataExpiresAt } from "./tester-ttl";
+export const blogTesterSeedData = [
+    {
+        id: "blog-tester-sandbox-post",
+        title: "Welcome to the Tester Sandbox",
+        slug: "tester-sandbox-post",
+        excerpt: "A disposable test blog post for the tester QA program — check that images, formatting, and reading flow work correctly.",
+        content: `<h2>This is a test post</h2><p>It exists only for the tester QA program and will be deleted automatically after 7 days.</p><p>Check: does this render correctly? Are images loading? Is the layout readable?</p>`,
+        coverImage: { type: "image", url: seedExtMedia("https://picsum.photos/seed/blog-cover-tester-sandbox-post-20260101/1200/600"), alt: "Test cover image" },
+        category: "guides",
+        tags: ["test"],
+        isFeatured: false,
+        status: "published",
+        publishedAt: new Date(),
+        authorId: "user-admin-letitrip",
+        authorName: "LetItRip Admin",
+        readTimeMinutes: 1,
+        views: 0,
+        isTestData: true,
+        testDataExpiresAt: testDataExpiresAt(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    },
+];

package/dist/features/tester/seed-data/categories-tester-seed-data.d.ts

@@ -0,0 +1,2 @@
+import type { CategoryDocument } from "../../categories/schemas";
+export declare const categoriesTesterSeedData: Partial<CategoryDocument>[];