@blackcode_sa/metaestetics-api 1.12.65 → 1.12.67

package/src/services/documentation-templates/documentation-template.service.ts

@@ -1,537 +1,537 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  setDoc,
-  updateDoc,
-  deleteDoc,
-  query,
-  where,
-  orderBy,
-  limit,
-  startAfter,
-  DocumentSnapshot,
-  QueryDocumentSnapshot,
-  serverTimestamp,
-  Timestamp,
-  QueryConstraint,
-} from "firebase/firestore";
-import { BaseService } from "../base.service";
-import {
-  CreateDocumentTemplateData,
-  DocumentElement,
-  DocumentTemplate,
-  UpdateDocumentTemplateData,
-} from "../../types";
-import { DOCUMENTATION_TEMPLATES_COLLECTION } from "../../types";
-import {
-  createDocumentTemplateSchema,
-  updateDocumentTemplateSchema,
-} from "../../validations/documentation-templates.schema";
-import { getCountFromServer } from "firebase/firestore";
-
-/**
- * Service for managing documentation templates
- */
-export class DocumentationTemplateService extends BaseService {
-  private readonly collectionRef = collection(
-    this.db,
-    DOCUMENTATION_TEMPLATES_COLLECTION
-  );
-
-  constructor(...args: ConstructorParameters<typeof BaseService>) {
-    super(...args);
-  }
-
-  /**
-   * Create a new document template
-   * @param data - Template data
-   * @param userId - ID of the user creating the template
-   * @returns The created template
-   */
-  async createTemplate(
-    data: CreateDocumentTemplateData,
-    userId: string
-  ): Promise<DocumentTemplate> {
-    // Validate data
-    const validatedData = createDocumentTemplateSchema.parse(data);
-
-    // Generate ID for the template
-    const templateId = this.generateId();
-
-    // Generate IDs for elements
-    const elementsWithIds = validatedData.elements.map((element) => ({
-      ...element,
-      id: this.generateId(),
-    }));
-
-    // Create template object
-    const now = Date.now();
-    const template: DocumentTemplate = {
-      id: templateId,
-      title: validatedData.title,
-      description: validatedData.description,
-      elements: elementsWithIds as DocumentElement[],
-      createdAt: now,
-      updatedAt: now,
-      createdBy: userId,
-      version: 1,
-      isActive: true,
-      tags: validatedData.tags || [],
-      isUserForm: validatedData.isUserForm || false,
-      isRequired: validatedData.isRequired || false,
-      sortingOrder: validatedData.sortingOrder || 0,
-    };
-
-    // Save to Firestore
-    const docRef = doc(this.collectionRef, templateId);
-    await setDoc(docRef, template);
-
-    return template;
-  }
-
-  /**
-   * Get a document template by ID
-   * @param templateId - ID of the template to retrieve
-   * @param version - Optional version number to retrieve (defaults to latest version)
-   * @returns The template or null if not found
-   */
-  async getTemplateById(
-    templateId: string,
-    version?: number
-  ): Promise<DocumentTemplate | null> {
-    // First, check if the template exists at all
-    const docRef = doc(this.collectionRef, templateId);
-    const docSnap = await getDoc(docRef);
-
-    if (!docSnap.exists()) {
-      return null; // Template doesn't exist
-    }
-
-    const currentTemplate = docSnap.data() as DocumentTemplate;
-
-    // If no specific version is requested, simply return the current template
-    if (version === undefined) {
-      return currentTemplate;
-    }
-
-    // If the requested version matches the current version, return it
-    if (currentTemplate.version === version) {
-      return currentTemplate;
-    }
-
-    // Otherwise, try to find the requested version in the versions subcollection
-    try {
-      const versionTemplate = await this.getTemplateVersion(
-        templateId,
-        version
-      );
-      if (versionTemplate) {
-        return versionTemplate;
-      }
-    } catch (error) {
-      console.error(`Error getting template version ${version}:`, error);
-    }
-
-    // If we get here, the requested version doesn't exist
-    // Option 1: Return null (strict approach)
-    return null;
-
-    // Option 2: Return current version but indicate it's not the requested version (uncomment to use)
-    // return {
-    //   ...currentTemplate,
-    //   _versionRequested: version,
-    //   _versionNotFound: true
-    // } as DocumentTemplate;
-  }
-
-  /**
-   * Update an existing document template
-   * @param templateId - ID of the template to update
-   * @param data - Updated template data
-   * @returns The updated template
-   */
-  async updateTemplate(
-    templateId: string,
-    data: UpdateDocumentTemplateData
-  ): Promise<DocumentTemplate> {
-    // Validate data
-    const validatedData = updateDocumentTemplateSchema.parse(data);
-    console.log("Validated data", validatedData);
-
-    // Get existing template
-    const template = await this.getTemplateById(templateId);
-    if (!template) {
-      throw new Error(`Template with ID ${templateId} not found`);
-    }
-
-    // Store the current version in the versions subcollection
-    const versionsCollectionRef = collection(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
-    );
-    const versionDocRef = doc(
-      versionsCollectionRef,
-      template.version.toString()
-    );
-    await setDoc(versionDocRef, template);
-
-    // Process elements if provided
-    let updatedElements = template.elements;
-    if (validatedData.elements) {
-      updatedElements = validatedData.elements.map((element) => ({
-        ...element,
-        id: (element as any).id || this.generateId(),
-      })) as DocumentElement[];
-    }
-
-    const updatePayload: Partial<DocumentTemplate> = {
-      elements: updatedElements,
-      updatedAt: Date.now(),
-      version: template.version + 1,
-    };
-
-    // Conditionally add fields from validatedData to avoid overwriting with undefined
-    if (validatedData.title !== undefined)
-      updatePayload.title = validatedData.title;
-    if (validatedData.description !== undefined)
-      updatePayload.description = validatedData.description;
-    if (validatedData.isActive !== undefined)
-      updatePayload.isActive = validatedData.isActive;
-    if (validatedData.tags !== undefined)
-      updatePayload.tags = validatedData.tags;
-
-    // Always include these properties with defaults if they're missing
-    updatePayload.isUserForm = validatedData.isUserForm ?? false;
-    updatePayload.isRequired = validatedData.isRequired ?? false;
-    updatePayload.sortingOrder = validatedData.sortingOrder ?? 0;
-
-    const docRef = doc(this.collectionRef, templateId);
-    console.log("Update payload", updatePayload);
-    await updateDoc(docRef, updatePayload);
-
-    return { ...template, ...updatePayload } as DocumentTemplate;
-  }
-
-  /**
-   * Get a specific version of a template
-   * @param templateId - ID of the template
-   * @param versionNumber - Version number to retrieve
-   * @returns The template version or null if not found
-   */
-  async getTemplateVersion(
-    templateId: string,
-    versionNumber: number
-  ): Promise<DocumentTemplate | null> {
-    const versionDocRef = doc(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
-    );
-    const versionDocSnap = await getDoc(versionDocRef);
-
-    if (!versionDocSnap.exists()) {
-      return null;
-    }
-
-    return versionDocSnap.data() as DocumentTemplate;
-  }
-
-  /**
-   * Get all versions of a template
-   * @param templateId - ID of the template
-   * @returns Array of template versions
-   */
-  async getTemplateOldVersions(
-    templateId: string
-  ): Promise<DocumentTemplate[]> {
-    const versionsCollectionRef = collection(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
-    );
-    const q = query(versionsCollectionRef, orderBy("version", "desc"));
-
-    const querySnapshot = await getDocs(q);
-    const versions: DocumentTemplate[] = [];
-
-    querySnapshot.forEach((doc) => {
-      versions.push(doc.data() as DocumentTemplate);
-    });
-
-    return versions;
-  }
-
-  /**
-   * Delete a document template
-   * @param templateId - ID of the template to delete
-   */
-  async deleteTemplate(templateId: string): Promise<void> {
-    const docRef = doc(this.collectionRef, templateId);
-    await deleteDoc(docRef);
-  }
-
-  /**
-   * Get all active templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getActiveTemplates(
-    pageSize = 20,
-    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
-  ): Promise<{
-    templates: DocumentTemplate[];
-    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-  }> {
-    let q = query(
-      this.collectionRef,
-      where("isActive", "==", true),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-
-    if (lastDoc) {
-      q = query(q, startAfter(lastDoc));
-    }
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
-    });
-
-    return {
-      templates,
-      lastDoc: lastVisible,
-    };
-  }
-
-  /**
-   * Get all active templates with optional filters and pagination.
-   * @param options - Options for filtering and pagination.
-   * @returns A promise that resolves to the templates and the last visible document.
-   */
-  async getTemplates(options: {
-    pageSize?: number;
-    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>;
-    isUserForm?: boolean;
-    isRequired?: boolean;
-    sortingOrder?: number;
-  }): Promise<{
-    templates: DocumentTemplate[];
-    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-  }> {
-    const {
-      pageSize = 20,
-      lastDoc,
-      isUserForm,
-      isRequired,
-      sortingOrder,
-    } = options;
-    const constraints: QueryConstraint[] = [
-      where("isActive", "==", true),
-      orderBy("sortingOrder", "asc"),
-      orderBy("title", "asc"),
-      limit(pageSize),
-    ];
-
-    if (isUserForm !== undefined) {
-      constraints.push(where("isUserForm", "==", isUserForm));
-    }
-    if (isRequired !== undefined) {
-      constraints.push(where("isRequired", "==", isRequired));
-    }
-    if (sortingOrder !== undefined) {
-      constraints.push(where("sortingOrder", "==", sortingOrder));
-    }
-    if (lastDoc) {
-      constraints.push(startAfter(lastDoc));
-    }
-
-    const q = query(this.collectionRef, ...constraints.filter((c) => c));
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
-    });
-
-    return {
-      templates,
-      lastDoc: lastVisible,
-    };
-  }
-
-  /**
-   * Get the total count of active templates with optional filters.
-   * @param options - Options for filtering.
-   * @returns A promise that resolves to the total count of templates.
-   */
-  async getTemplatesCount(options: {
-    isUserForm?: boolean;
-    isRequired?: boolean;
-    sortingOrder?: number;
-    search?: string; // Search will be applied in-memory for now
-  }): Promise<number> {
-    const { isUserForm, isRequired, sortingOrder } = options;
-    const constraints = [where("isActive", "==", true)];
-
-    if (isUserForm !== undefined) {
-      constraints.push(where("isUserForm", "==", isUserForm));
-    }
-    if (isRequired !== undefined) {
-      constraints.push(where("isRequired", "==", isRequired));
-    }
-    if (sortingOrder !== undefined) {
-      constraints.push(where("sortingOrder", "==", sortingOrder));
-    }
-
-    const q = query(this.collectionRef, ...constraints.filter((c) => c));
-    const snapshot = await getCountFromServer(q);
-
-    return snapshot.data().count;
-  }
-
-  /**
-   * Get all active templates without pagination for filtering purposes.
-   * @returns A promise that resolves to an array of all active templates.
-   */
-  async getAllActiveTemplates(): Promise<DocumentTemplate[]> {
-    const q = query(
-      this.collectionRef,
-      where("isActive", "==", true),
-      orderBy("title", "asc")
-    );
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-    });
-
-    return templates;
-  }
-
-  /**
-   * Get templates by tags
-   * @param tags - Tags to filter by
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByTags(
-    tags: string[],
-    pageSize = 20,
-    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
-  ): Promise<{
-    templates: DocumentTemplate[];
-    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-  }> {
-    let q = query(
-      this.collectionRef,
-      where("isActive", "==", true),
-      where("tags", "array-contains-any", tags),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-
-    if (lastDoc) {
-      q = query(q, startAfter(lastDoc));
-    }
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
-    });
-
-    return {
-      templates,
-      lastDoc: lastVisible,
-    };
-  }
-
-  /**
-   * Get templates created by a specific user
-   * @param userId - ID of the user who created the templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByCreator(
-    userId: string,
-    pageSize = 20,
-    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
-  ): Promise<{
-    templates: DocumentTemplate[];
-    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-  }> {
-    let q = query(
-      this.collectionRef,
-      where("createdBy", "==", userId),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-
-    if (lastDoc) {
-      q = query(q, startAfter(lastDoc));
-    }
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
-    });
-
-    return {
-      templates,
-      lastDoc: lastVisible,
-    };
-  }
-
-  /**
-   * Get all templates for selection with optional filtering
-   * @param options - Filtering options
-   * @returns Array of templates
-   */
-  async getAllTemplatesForSelection(options?: {
-    isUserForm?: boolean;
-    isRequired?: boolean;
-  }): Promise<DocumentTemplate[]> {
-    let q = query(
-      this.collectionRef,
-      where("isActive", "==", true),
-      orderBy("updatedAt", "desc")
-    );
-
-    if (options?.isUserForm !== undefined) {
-      q = query(q, where("isUserForm", "==", options.isUserForm));
-    }
-
-    if (options?.isRequired !== undefined) {
-      q = query(q, where("isRequired", "==", options.isRequired));
-    }
-
-    const querySnapshot = await getDocs(q);
-    const templates: DocumentTemplate[] = [];
-
-    querySnapshot.forEach((doc) => {
-      templates.push(doc.data() as DocumentTemplate);
-    });
-
-    return templates;
-  }
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  limit,
+  startAfter,
+  DocumentSnapshot,
+  QueryDocumentSnapshot,
+  serverTimestamp,
+  Timestamp,
+  QueryConstraint,
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
+import {
+  CreateDocumentTemplateData,
+  DocumentElement,
+  DocumentTemplate,
+  UpdateDocumentTemplateData,
+} from "../../types";
+import { DOCUMENTATION_TEMPLATES_COLLECTION } from "../../types";
+import {
+  createDocumentTemplateSchema,
+  updateDocumentTemplateSchema,
+} from "../../validations/documentation-templates.schema";
+import { getCountFromServer } from "firebase/firestore";
+
+/**
+ * Service for managing documentation templates
+ */
+export class DocumentationTemplateService extends BaseService {
+  private readonly collectionRef = collection(
+    this.db,
+    DOCUMENTATION_TEMPLATES_COLLECTION
+  );
+
+  constructor(...args: ConstructorParameters<typeof BaseService>) {
+    super(...args);
+  }
+
+  /**
+   * Create a new document template
+   * @param data - Template data
+   * @param userId - ID of the user creating the template
+   * @returns The created template
+   */
+  async createTemplate(
+    data: CreateDocumentTemplateData,
+    userId: string
+  ): Promise<DocumentTemplate> {
+    // Validate data
+    const validatedData = createDocumentTemplateSchema.parse(data);
+
+    // Generate ID for the template
+    const templateId = this.generateId();
+
+    // Generate IDs for elements
+    const elementsWithIds = validatedData.elements.map((element) => ({
+      ...element,
+      id: this.generateId(),
+    }));
+
+    // Create template object
+    const now = Date.now();
+    const template: DocumentTemplate = {
+      id: templateId,
+      title: validatedData.title,
+      description: validatedData.description,
+      elements: elementsWithIds as DocumentElement[],
+      createdAt: now,
+      updatedAt: now,
+      createdBy: userId,
+      version: 1,
+      isActive: true,
+      tags: validatedData.tags || [],
+      isUserForm: validatedData.isUserForm || false,
+      isRequired: validatedData.isRequired || false,
+      sortingOrder: validatedData.sortingOrder || 0,
+    };
+
+    // Save to Firestore
+    const docRef = doc(this.collectionRef, templateId);
+    await setDoc(docRef, template);
+
+    return template;
+  }
+
+  /**
+   * Get a document template by ID
+   * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
+   * @returns The template or null if not found
+   */
+  async getTemplateById(
+    templateId: string,
+    version?: number
+  ): Promise<DocumentTemplate | null> {
+    // First, check if the template exists at all
+    const docRef = doc(this.collectionRef, templateId);
+    const docSnap = await getDoc(docRef);
+
+    if (!docSnap.exists()) {
+      return null; // Template doesn't exist
+    }
+
+    const currentTemplate = docSnap.data() as DocumentTemplate;
+
+    // If no specific version is requested, simply return the current template
+    if (version === undefined) {
+      return currentTemplate;
+    }
+
+    // If the requested version matches the current version, return it
+    if (currentTemplate.version === version) {
+      return currentTemplate;
+    }
+
+    // Otherwise, try to find the requested version in the versions subcollection
+    try {
+      const versionTemplate = await this.getTemplateVersion(
+        templateId,
+        version
+      );
+      if (versionTemplate) {
+        return versionTemplate;
+      }
+    } catch (error) {
+      console.error(`Error getting template version ${version}:`, error);
+    }
+
+    // If we get here, the requested version doesn't exist
+    // Option 1: Return null (strict approach)
+    return null;
+
+    // Option 2: Return current version but indicate it's not the requested version (uncomment to use)
+    // return {
+    //   ...currentTemplate,
+    //   _versionRequested: version,
+    //   _versionNotFound: true
+    // } as DocumentTemplate;
+  }
+
+  /**
+   * Update an existing document template
+   * @param templateId - ID of the template to update
+   * @param data - Updated template data
+   * @returns The updated template
+   */
+  async updateTemplate(
+    templateId: string,
+    data: UpdateDocumentTemplateData
+  ): Promise<DocumentTemplate> {
+    // Validate data
+    const validatedData = updateDocumentTemplateSchema.parse(data);
+    console.log("Validated data", validatedData);
+
+    // Get existing template
+    const template = await this.getTemplateById(templateId);
+    if (!template) {
+      throw new Error(`Template with ID ${templateId} not found`);
+    }
+
+    // Store the current version in the versions subcollection
+    const versionsCollectionRef = collection(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc(versionDocRef, template);
+
+    // Process elements if provided
+    let updatedElements = template.elements;
+    if (validatedData.elements) {
+      updatedElements = validatedData.elements.map((element) => ({
+        ...element,
+        id: (element as any).id || this.generateId(),
+      })) as DocumentElement[];
+    }
+
+    const updatePayload: Partial<DocumentTemplate> = {
+      elements: updatedElements,
+      updatedAt: Date.now(),
+      version: template.version + 1,
+    };
+
+    // Conditionally add fields from validatedData to avoid overwriting with undefined
+    if (validatedData.title !== undefined)
+      updatePayload.title = validatedData.title;
+    if (validatedData.description !== undefined)
+      updatePayload.description = validatedData.description;
+    if (validatedData.isActive !== undefined)
+      updatePayload.isActive = validatedData.isActive;
+    if (validatedData.tags !== undefined)
+      updatePayload.tags = validatedData.tags;
+
+    // Always include these properties with defaults if they're missing
+    updatePayload.isUserForm = validatedData.isUserForm ?? false;
+    updatePayload.isRequired = validatedData.isRequired ?? false;
+    updatePayload.sortingOrder = validatedData.sortingOrder ?? 0;
+
+    const docRef = doc(this.collectionRef, templateId);
+    console.log("Update payload", updatePayload);
+    await updateDoc(docRef, updatePayload);
+
+    return { ...template, ...updatePayload } as DocumentTemplate;
+  }
+
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(
+    templateId: string,
+    versionNumber: number
+  ): Promise<DocumentTemplate | null> {
+    const versionDocRef = doc(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc(versionDocRef);
+
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+
+    return versionDocSnap.data() as DocumentTemplate;
+  }
+
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(
+    templateId: string
+  ): Promise<DocumentTemplate[]> {
+    const versionsCollectionRef = collection(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query(versionsCollectionRef, orderBy("version", "desc"));
+
+    const querySnapshot = await getDocs(q);
+    const versions: DocumentTemplate[] = [];
+
+    querySnapshot.forEach((doc) => {
+      versions.push(doc.data() as DocumentTemplate);
+    });
+
+    return versions;
+  }
+
+  /**
+   * Delete a document template
+   * @param templateId - ID of the template to delete
+   */
+  async deleteTemplate(templateId: string): Promise<void> {
+    const docRef = doc(this.collectionRef, templateId);
+    await deleteDoc(docRef);
+  }
+
+  /**
+   * Get all active templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getActiveTemplates(
+    pageSize = 20,
+    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
+  ): Promise<{
+    templates: DocumentTemplate[];
+    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+  }> {
+    let q = query(
+      this.collectionRef,
+      where("isActive", "==", true),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+
+    if (lastDoc) {
+      q = query(q, startAfter(lastDoc));
+    }
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
+    });
+
+    return {
+      templates,
+      lastDoc: lastVisible,
+    };
+  }
+
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options: {
+    pageSize?: number;
+    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>;
+    isUserForm?: boolean;
+    isRequired?: boolean;
+    sortingOrder?: number;
+  }): Promise<{
+    templates: DocumentTemplate[];
+    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+  }> {
+    const {
+      pageSize = 20,
+      lastDoc,
+      isUserForm,
+      isRequired,
+      sortingOrder,
+    } = options;
+    const constraints: QueryConstraint[] = [
+      where("isActive", "==", true),
+      orderBy("sortingOrder", "asc"),
+      orderBy("title", "asc"),
+      limit(pageSize),
+    ];
+
+    if (isUserForm !== undefined) {
+      constraints.push(where("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== undefined) {
+      constraints.push(where("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== undefined) {
+      constraints.push(where("sortingOrder", "==", sortingOrder));
+    }
+    if (lastDoc) {
+      constraints.push(startAfter(lastDoc));
+    }
+
+    const q = query(this.collectionRef, ...constraints.filter((c) => c));
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
+    });
+
+    return {
+      templates,
+      lastDoc: lastVisible,
+    };
+  }
+
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options: {
+    isUserForm?: boolean;
+    isRequired?: boolean;
+    sortingOrder?: number;
+    search?: string; // Search will be applied in-memory for now
+  }): Promise<number> {
+    const { isUserForm, isRequired, sortingOrder } = options;
+    const constraints = [where("isActive", "==", true)];
+
+    if (isUserForm !== undefined) {
+      constraints.push(where("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== undefined) {
+      constraints.push(where("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== undefined) {
+      constraints.push(where("sortingOrder", "==", sortingOrder));
+    }
+
+    const q = query(this.collectionRef, ...constraints.filter((c) => c));
+    const snapshot = await getCountFromServer(q);
+
+    return snapshot.data().count;
+  }
+
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates(): Promise<DocumentTemplate[]> {
+    const q = query(
+      this.collectionRef,
+      where("isActive", "==", true),
+      orderBy("title", "asc")
+    );
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+    });
+
+    return templates;
+  }
+
+  /**
+   * Get templates by tags
+   * @param tags - Tags to filter by
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getTemplatesByTags(
+    tags: string[],
+    pageSize = 20,
+    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
+  ): Promise<{
+    templates: DocumentTemplate[];
+    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+  }> {
+    let q = query(
+      this.collectionRef,
+      where("isActive", "==", true),
+      where("tags", "array-contains-any", tags),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+
+    if (lastDoc) {
+      q = query(q, startAfter(lastDoc));
+    }
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
+    });
+
+    return {
+      templates,
+      lastDoc: lastVisible,
+    };
+  }
+
+  /**
+   * Get templates created by a specific user
+   * @param userId - ID of the user who created the templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getTemplatesByCreator(
+    userId: string,
+    pageSize = 20,
+    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>
+  ): Promise<{
+    templates: DocumentTemplate[];
+    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+  }> {
+    let q = query(
+      this.collectionRef,
+      where("createdBy", "==", userId),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+
+    if (lastDoc) {
+      q = query(q, startAfter(lastDoc));
+    }
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+    let lastVisible: QueryDocumentSnapshot<DocumentTemplate> | null = null;
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+      lastVisible = doc as QueryDocumentSnapshot<DocumentTemplate>;
+    });
+
+    return {
+      templates,
+      lastDoc: lastVisible,
+    };
+  }
+
+  /**
+   * Get all templates for selection with optional filtering
+   * @param options - Filtering options
+   * @returns Array of templates
+   */
+  async getAllTemplatesForSelection(options?: {
+    isUserForm?: boolean;
+    isRequired?: boolean;
+  }): Promise<DocumentTemplate[]> {
+    let q = query(
+      this.collectionRef,
+      where("isActive", "==", true),
+      orderBy("updatedAt", "desc")
+    );
+
+    if (options?.isUserForm !== undefined) {
+      q = query(q, where("isUserForm", "==", options.isUserForm));
+    }
+
+    if (options?.isRequired !== undefined) {
+      q = query(q, where("isRequired", "==", options.isRequired));
+    }
+
+    const querySnapshot = await getDocs(q);
+    const templates: DocumentTemplate[] = [];
+
+    querySnapshot.forEach((doc) => {
+      templates.push(doc.data() as DocumentTemplate);
+    });
+
+    return templates;
+  }
+}