@blackcode_sa/metaestetics-api 1.6.23 → 1.6.24

package/dist/backoffice/index.d.mts

@@ -5421,9 +5421,10 @@ declare class DocumentationTemplateService {
     /**
      * 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
      */
-    getTemplateById(templateId: string): Promise<DocumentTemplate | null>;
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
     /**
      * Update an existing document template
      * @param templateId - ID of the template to update
@@ -5468,6 +5469,19 @@ declare class DocumentationTemplateService {
         templates: DocumentTemplate[];
         lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
     }>;
+    /**
+     * 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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
 }
 
 export { BackofficeError, BlockingCondition, BlockingConditionError, type Brand, BrandService, type Category, CategoryError, CategoryNotFoundError, CategoryService, CertificationLevel, type CertificationRequirement, CertificationSpecialty, CircularReferenceError, Contraindication, ContraindicationError, type CreateDocumentTemplateData, DEFAULT_CERTIFICATION_REQUIREMENT, type DocumentElement, DocumentElementType, type DocumentTemplate, DocumentationTemplateService, DynamicVariable, HeadingLevel, InvalidBlockingConditionError, InvalidCategoryDataError, InvalidContraindicationError, InvalidHierarchyError, InvalidRequirementDataError, InvalidSubcategoryDataError, InvalidTechnologyDataError, InvalidTimeframeError, InvalidTreatmentBenefitError, ListType, ProcedureFamily, type Product, ProductService, RelationshipError, type Requirement, RequirementError, type RequirementImportance, RequirementNotFoundError, RequirementService, RequirementType, type Subcategory, SubcategoryError, SubcategoryNotFoundError, SubcategoryService, type Technology, TechnologyError, TechnologyNotFoundError, type TechnologyRequirements, TechnologyService, type TimeFrame, TimeUnit, TreatmentBenefit, TreatmentBenefitError, type UpdateDocumentTemplateData, blockingConditionSchema, categorySchema, categoryUpdateSchema, certificationLevelSchema, certificationRequirementSchema, certificationSpecialtySchema, contraindicationSchema, createDocumentTemplateSchema, documentElementSchema, documentElementWithoutIdSchema, documentTemplateSchema, procedureFamilySchema, requirementSchema, requirementTypeSchema, requirementUpdateSchema, subcategorySchema, subcategoryUpdateSchema, technologyRequirementsSchema, technologySchema, technologyUpdateSchema, timeUnitSchema, timeframeSchema, treatmentBenefitSchema, updateDocumentTemplateSchema };

package/dist/backoffice/index.d.ts

@@ -5421,9 +5421,10 @@ declare class DocumentationTemplateService {
     /**
      * 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
      */
-    getTemplateById(templateId: string): Promise<DocumentTemplate | null>;
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
     /**
      * Update an existing document template
      * @param templateId - ID of the template to update
@@ -5468,6 +5469,19 @@ declare class DocumentationTemplateService {
         templates: DocumentTemplate[];
         lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
     }>;
+    /**
+     * 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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
 }
 
 export { BackofficeError, BlockingCondition, BlockingConditionError, type Brand, BrandService, type Category, CategoryError, CategoryNotFoundError, CategoryService, CertificationLevel, type CertificationRequirement, CertificationSpecialty, CircularReferenceError, Contraindication, ContraindicationError, type CreateDocumentTemplateData, DEFAULT_CERTIFICATION_REQUIREMENT, type DocumentElement, DocumentElementType, type DocumentTemplate, DocumentationTemplateService, DynamicVariable, HeadingLevel, InvalidBlockingConditionError, InvalidCategoryDataError, InvalidContraindicationError, InvalidHierarchyError, InvalidRequirementDataError, InvalidSubcategoryDataError, InvalidTechnologyDataError, InvalidTimeframeError, InvalidTreatmentBenefitError, ListType, ProcedureFamily, type Product, ProductService, RelationshipError, type Requirement, RequirementError, type RequirementImportance, RequirementNotFoundError, RequirementService, RequirementType, type Subcategory, SubcategoryError, SubcategoryNotFoundError, SubcategoryService, type Technology, TechnologyError, TechnologyNotFoundError, type TechnologyRequirements, TechnologyService, type TimeFrame, TimeUnit, TreatmentBenefit, TreatmentBenefitError, type UpdateDocumentTemplateData, blockingConditionSchema, categorySchema, categoryUpdateSchema, certificationLevelSchema, certificationRequirementSchema, certificationSpecialtySchema, contraindicationSchema, createDocumentTemplateSchema, documentElementSchema, documentElementWithoutIdSchema, documentTemplateSchema, procedureFamilySchema, requirementSchema, requirementTypeSchema, requirementUpdateSchema, subcategorySchema, subcategoryUpdateSchema, technologyRequirementsSchema, technologySchema, technologyUpdateSchema, timeUnitSchema, timeframeSchema, treatmentBenefitSchema, updateDocumentTemplateSchema };

package/dist/backoffice/index.js

@@ -1611,9 +1611,23 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * 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) {
+  async getTemplateById(templateId, version) {
+    if (version !== void 0) {
+      try {
+        const versionTemplate = await this.getTemplateVersion(
+          templateId,
+          version
+        );
+        if (versionTemplate) {
+          return versionTemplate;
+        }
+      } catch (error) {
+        console.error(`Error getting template version ${version}:`, error);
+      }
+    }
     const docRef = (0, import_firestore7.doc)(this.collectionRef, templateId);
     const docSnap = await (0, import_firestore7.getDoc)(docRef);
     if (!docSnap.exists()) {
@@ -1635,6 +1649,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = (0, import_firestore7.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = (0, import_firestore7.doc)(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await (0, import_firestore7.setDoc)(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -1663,6 +1686,41 @@ var DocumentationTemplateService = class extends BaseService {
     await (0, import_firestore7.updateDoc)(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * 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, versionNumber) {
+    const versionDocRef = (0, import_firestore7.doc)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await (0, import_firestore7.getDoc)(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = (0, import_firestore7.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = (0, import_firestore7.query)(versionsCollectionRef, (0, import_firestore7.orderBy)("version", "desc"));
+    const querySnapshot = await (0, import_firestore7.getDocs)(q);
+    const versions = [];
+    querySnapshot.forEach((doc9) => {
+      versions.push(doc9.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete
@@ -1810,10 +1868,11 @@ var DocumentationTemplateService2 = class {
   /**
    * 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) {
-    return this.apiService.getTemplateById(templateId);
+  async getTemplateById(templateId, version) {
+    return this.apiService.getTemplateById(templateId, version);
   }
   /**
    * Update an existing document template
@@ -1860,6 +1919,23 @@ var DocumentationTemplateService2 = class {
   async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
     return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
   }
+  /**
+   * 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, versionNumber) {
+    return this.apiService.getTemplateVersion(templateId, versionNumber);
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateVersions(templateId) {
+    return this.apiService.getTemplateOldVersions(templateId);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/backoffice/index.mjs

@@ -1588,9 +1588,23 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * 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) {
+  async getTemplateById(templateId, version) {
+    if (version !== void 0) {
+      try {
+        const versionTemplate = await this.getTemplateVersion(
+          templateId,
+          version
+        );
+        if (versionTemplate) {
+          return versionTemplate;
+        }
+      } catch (error) {
+        console.error(`Error getting template version ${version}:`, error);
+      }
+    }
     const docRef = doc7(this.collectionRef, templateId);
     const docSnap = await getDoc7(docRef);
     if (!docSnap.exists()) {
@@ -1612,6 +1626,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = collection7(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc7(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -1640,6 +1663,41 @@ var DocumentationTemplateService = class extends BaseService {
     await updateDoc7(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * 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, versionNumber) {
+    const versionDocRef = doc7(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc7(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = collection7(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query7(versionsCollectionRef, orderBy("version", "desc"));
+    const querySnapshot = await getDocs7(q);
+    const versions = [];
+    querySnapshot.forEach((doc9) => {
+      versions.push(doc9.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete
@@ -1798,10 +1856,11 @@ var DocumentationTemplateService2 = class {
   /**
    * 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) {
-    return this.apiService.getTemplateById(templateId);
+  async getTemplateById(templateId, version) {
+    return this.apiService.getTemplateById(templateId, version);
   }
   /**
    * Update an existing document template
@@ -1848,6 +1907,23 @@ var DocumentationTemplateService2 = class {
   async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
     return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
   }
+  /**
+   * 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, versionNumber) {
+    return this.apiService.getTemplateVersion(templateId, versionNumber);
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateVersions(templateId) {
+    return this.apiService.getTemplateOldVersions(templateId);
+  }
 };
 export {
   BackofficeError,

package/dist/index.d.mts

@@ -6409,9 +6409,10 @@ declare class DocumentationTemplateService extends BaseService {
     /**
      * 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
      */
-    getTemplateById(templateId: string): Promise<DocumentTemplate | null>;
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
     /**
      * Update an existing document template
      * @param templateId - ID of the template to update
@@ -6419,6 +6420,19 @@ declare class DocumentationTemplateService extends BaseService {
      * @returns The updated template
      */
     updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateOldVersions(templateId: string): Promise<DocumentTemplate[]>;
     /**
      * Delete a document template
      * @param templateId - ID of the template to delete

package/dist/index.d.ts

@@ -6409,9 +6409,10 @@ declare class DocumentationTemplateService extends BaseService {
     /**
      * 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
      */
-    getTemplateById(templateId: string): Promise<DocumentTemplate | null>;
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
     /**
      * Update an existing document template
      * @param templateId - ID of the template to update
@@ -6419,6 +6420,19 @@ declare class DocumentationTemplateService extends BaseService {
      * @returns The updated template
      */
     updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateOldVersions(templateId: string): Promise<DocumentTemplate[]>;
     /**
      * Delete a document template
      * @param templateId - ID of the template to delete

package/dist/index.js

@@ -8426,9 +8426,23 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * 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) {
+  async getTemplateById(templateId, version) {
+    if (version !== void 0) {
+      try {
+        const versionTemplate = await this.getTemplateVersion(
+          templateId,
+          version
+        );
+        if (versionTemplate) {
+          return versionTemplate;
+        }
+      } catch (error) {
+        console.error(`Error getting template version ${version}:`, error);
+      }
+    }
     const docRef = (0, import_firestore25.doc)(this.collectionRef, templateId);
     const docSnap = await (0, import_firestore25.getDoc)(docRef);
     if (!docSnap.exists()) {
@@ -8450,6 +8464,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = (0, import_firestore25.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = (0, import_firestore25.doc)(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await (0, import_firestore25.setDoc)(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -8478,6 +8501,41 @@ var DocumentationTemplateService = class extends BaseService {
     await (0, import_firestore25.updateDoc)(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * 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, versionNumber) {
+    const versionDocRef = (0, import_firestore25.doc)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await (0, import_firestore25.getDoc)(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = (0, import_firestore25.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = (0, import_firestore25.query)(versionsCollectionRef, (0, import_firestore25.orderBy)("version", "desc"));
+    const querySnapshot = await (0, import_firestore25.getDocs)(q);
+    const versions = [];
+    querySnapshot.forEach((doc33) => {
+      versions.push(doc33.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete

package/dist/index.mjs

@@ -8414,9 +8414,23 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * 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) {
+  async getTemplateById(templateId, version) {
+    if (version !== void 0) {
+      try {
+        const versionTemplate = await this.getTemplateVersion(
+          templateId,
+          version
+        );
+        if (versionTemplate) {
+          return versionTemplate;
+        }
+      } catch (error) {
+        console.error(`Error getting template version ${version}:`, error);
+      }
+    }
     const docRef = doc16(this.collectionRef, templateId);
     const docSnap = await getDoc19(docRef);
     if (!docSnap.exists()) {
@@ -8438,6 +8452,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = collection16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc16(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc14(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -8466,6 +8489,41 @@ var DocumentationTemplateService = class extends BaseService {
     await updateDoc16(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * 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, versionNumber) {
+    const versionDocRef = doc16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc19(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = collection16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query16(versionsCollectionRef, orderBy5("version", "desc"));
+    const querySnapshot = await getDocs16(q);
+    const versions = [];
+    querySnapshot.forEach((doc33) => {
+      versions.push(doc33.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.6.23",
+  "version": "1.6.24",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

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

@@ -41,10 +41,14 @@ export class DocumentationTemplateService {
   /**
    * 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): Promise<DocumentTemplate | null> {
-    return this.apiService.getTemplateById(templateId);
+  async getTemplateById(
+    templateId: string,
+    version?: number
+  ): Promise<DocumentTemplate | null> {
+    return this.apiService.getTemplateById(templateId, version);
   }
 
   /**
@@ -119,4 +123,26 @@ export class DocumentationTemplateService {
   }> {
     return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
   }
+
+  /**
+   * 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> {
+    return this.apiService.getTemplateVersion(templateId, versionNumber);
+  }
+
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateVersions(templateId: string): Promise<DocumentTemplate[]> {
+    return this.apiService.getTemplateOldVersions(templateId);
+  }
 }

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

@@ -88,9 +88,32 @@ export class DocumentationTemplateService extends BaseService {
   /**
    * 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): Promise<DocumentTemplate | null> {
+  async getTemplateById(
+    templateId: string,
+    version?: number
+  ): Promise<DocumentTemplate | null> {
+    // If version is specified, try to get that specific version
+    if (version !== undefined) {
+      try {
+        const versionTemplate = await this.getTemplateVersion(
+          templateId,
+          version
+        );
+        // If the version exists, return it
+        if (versionTemplate) {
+          return versionTemplate;
+        }
+        // If version doesn't exist, fall back to latest version (continue with code below)
+      } catch (error) {
+        console.error(`Error getting template version ${version}:`, error);
+        // Fall back to latest version if error occurs
+      }
+    }
+
+    // Get the latest version (default behavior)
     const docRef = doc(this.collectionRef, templateId);
     const docSnap = await getDoc(docRef);
 
@@ -121,6 +144,17 @@ export class DocumentationTemplateService extends BaseService {
       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) {
@@ -158,6 +192,53 @@ export class DocumentationTemplateService extends BaseService {
     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