@blackcode_sa/metaestetics-api 1.12.62 → 1.12.64

package/src/backoffice/validations/schemas.ts

@@ -1,163 +1,164 @@
-import { z } from "zod";
-import { ProcedureFamily } from "../types/static/procedure-family.types";
-import { BlockingCondition } from "../types/static/blocking-condition.types";
-import { TimeUnit, RequirementType } from "../types/requirement.types";
-import {
-  CertificationLevel,
-  CertificationSpecialty,
-} from "../types/static/certification.types";
-
-import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
-
-/**
- * Zod validation schema for a single dynamic contraindication.
- * @see ContraindicationDynamic in admin-constants.types.ts
- */
-export const contraindicationDynamicSchema = z.object({
-  id: z
-    .string()
-    .min(1, "Contraindication ID is required")
-    .regex(
-      /^[a-z0-9_]+$/,
-      "ID must be in snake_case (lowercase, numbers, and underscores only)"
-    ),
-  name: z.string().min(1, "Contraindication name is required"),
-  description: z.string().optional(),
-});
-
-/**
- * Zod validation schema for a single dynamic treatment benefit.
- * @see TreatmentBenefitDynamic in admin-constants.types.ts
- */
-export const treatmentBenefitDynamicSchema = z.object({
-  id: z
-    .string()
-    .min(1, "Benefit ID is required")
-    .regex(
-      /^[a-z0-9_]+$/,
-      "ID must be in snake_case (lowercase, numbers, and underscores only)"
-    ),
-  name: z.string().min(1, "Benefit name is required"),
-  description: z.string().optional(),
-});
-
-/**
- * Base validation schemas for enums
- */
-export const blockingConditionSchemaBackoffice =
-  z.nativeEnum(BlockingCondition);
-export const contraindicationSchemaBackoffice = contraindicationDynamicSchema;
-export const treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
-export const procedureFamilySchemaBackoffice = z.nativeEnum(ProcedureFamily);
-export const timeUnitSchemaBackoffice = z.nativeEnum(TimeUnit);
-export const requirementTypeSchema = z.nativeEnum(RequirementType);
-export const certificationLevelSchema = z.nativeEnum(CertificationLevel);
-export const certificationSpecialtySchema = z.nativeEnum(
-  CertificationSpecialty
-);
-
-/**
- * Certification requirement validation schema
- */
-export const certificationRequirementSchema = z.object({
-  minimumLevel: certificationLevelSchema,
-  requiredSpecialties: z
-    .array(certificationSpecialtySchema)
-    .max(5, "Maximum 5 specialties allowed")
-    .optional(),
-});
-
-/**
- * Timeframe validation schema
- */
-export const timeframeSchema = z.object({
-  duration: z.number().min(1, "Duration must be positive"),
-  unit: timeUnitSchemaBackoffice,
-  notifyAt: z
-    .array(z.number())
-    .min(1, "At least one notification point is required"),
-});
-
-/**
- * Requirement validation schema
- */
-export const requirementSchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().min(1, "Description is required"),
-  type: requirementTypeSchema,
-  timeframe: timeframeSchema,
-  importance: z.enum(["low", "medium", "high"]),
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Technology requirements validation schema
- */
-export const technologyRequirementsSchema = z.object({
-  pre: z.array(requirementSchema),
-  post: z.array(requirementSchema),
-});
-
-/**
- * Technology validation schema
- */
-export const technologySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().max(1000, "Description is too long").optional(),
-  technicalDetails: z
-    .string()
-    .max(2000, "Technical details are too long")
-    .optional(),
-  family: procedureFamilySchemaBackoffice,
-  categoryId: z.string().min(1, "Category ID is required"),
-  subcategoryId: z.string().min(1, "Subcategory ID is required"),
-  requirements: technologyRequirementsSchema.default({
-    pre: [],
-    post: [],
-  }),
-  blockingConditions: z.array(blockingConditionSchemaBackoffice),
-  contraindications: z.array(contraindicationSchemaBackoffice),
-  documentationTemplates: z.array(documentTemplateSchema),
-  benefits: z.array(treatmentBenefitSchemaBackoffice),
-  certificationRequirement: certificationRequirementSchema,
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Category validation schema
- */
-export const categorySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().optional(),
-  family: procedureFamilySchemaBackoffice,
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Subcategory validation schema
- */
-export const subcategorySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().optional(),
-  categoryId: z.string().min(1, "Category ID is required"),
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Partial schemas for updates
- */
-export const categoryUpdateSchema = categorySchema.partial();
-export const subcategoryUpdateSchema = subcategorySchema.partial();
-export const technologyUpdateSchema = technologySchema.partial();
-export const requirementUpdateSchema = requirementSchema.partial();
-
-/**
- * Documentation Templates schemas
- */
-export {
-  createDocumentTemplateSchema,
-  updateDocumentTemplateSchema,
-  documentTemplateSchema,
-  documentElementSchema,
-  documentElementWithoutIdSchema,
-} from "../../validations/documentation-templates.schema";
+import { z } from "zod";
+import { ProcedureFamily } from "../types/static/procedure-family.types";
+import { BlockingCondition } from "../types/static/blocking-condition.types";
+import { TimeUnit, RequirementType } from "../types/requirement.types";
+import {
+  CertificationLevel,
+  CertificationSpecialty,
+} from "../types/static/certification.types";
+
+import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
+
+/**
+ * Zod validation schema for a single dynamic contraindication.
+ * @see ContraindicationDynamic in admin-constants.types.ts
+ */
+export const contraindicationDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Contraindication ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Contraindication name is required"),
+  description: z.string().optional(),
+});
+
+/**
+ * Zod validation schema for a single dynamic treatment benefit.
+ * @see TreatmentBenefitDynamic in admin-constants.types.ts
+ */
+export const treatmentBenefitDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Benefit ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Benefit name is required"),
+  description: z.string().optional(),
+});
+
+/**
+ * Base validation schemas for enums
+ */
+export const blockingConditionSchemaBackoffice =
+  z.nativeEnum(BlockingCondition);
+export const contraindicationSchemaBackoffice = contraindicationDynamicSchema;
+export const treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
+export const procedureFamilySchemaBackoffice = z.nativeEnum(ProcedureFamily);
+export const timeUnitSchemaBackoffice = z.nativeEnum(TimeUnit);
+export const requirementTypeSchema = z.nativeEnum(RequirementType);
+export const certificationLevelSchema = z.nativeEnum(CertificationLevel);
+export const certificationSpecialtySchema = z.nativeEnum(
+  CertificationSpecialty
+);
+
+/**
+ * Certification requirement validation schema
+ */
+export const certificationRequirementSchema = z.object({
+  minimumLevel: certificationLevelSchema,
+  requiredSpecialties: z
+    .array(certificationSpecialtySchema)
+    .max(5, "Maximum 5 specialties allowed")
+    .optional(),
+});
+
+/**
+ * Timeframe validation schema
+ */
+export const timeframeSchema = z.object({
+  duration: z.number().min(1, "Duration must be positive"),
+  unit: timeUnitSchemaBackoffice,
+  notifyAt: z
+    .array(z.number())
+    .min(1, "At least one notification point is required"),
+});
+
+/**
+ * Requirement validation schema
+ */
+export const requirementSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().min(1, "Description is required"),
+  type: requirementTypeSchema,
+  timeframe: timeframeSchema,
+  importance: z.enum(["low", "medium", "high"]),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Technology requirements validation schema
+ */
+export const technologyRequirementsSchema = z.object({
+  pre: z.array(requirementSchema),
+  post: z.array(requirementSchema),
+});
+
+/**
+ * Technology validation schema
+ */
+export const technologySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().max(1000, "Description is too long").optional(),
+  technicalDetails: z
+    .string()
+    .max(2000, "Technical details are too long")
+    .optional(),
+  family: procedureFamilySchemaBackoffice,
+  categoryId: z.string().min(1, "Category ID is required"),
+  subcategoryId: z.string().min(1, "Subcategory ID is required"),
+  requirements: technologyRequirementsSchema.default({
+    pre: [],
+    post: [],
+  }),
+  blockingConditions: z.array(blockingConditionSchemaBackoffice),
+  contraindications: z.array(contraindicationSchemaBackoffice),
+  documentationTemplates: z.array(documentTemplateSchema),
+  benefits: z.array(treatmentBenefitSchemaBackoffice),
+  certificationRequirement: certificationRequirementSchema,
+  photoTemplate: z.string().url("Photo template must be a valid URL").optional(),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Category validation schema
+ */
+export const categorySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().optional(),
+  family: procedureFamilySchemaBackoffice,
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Subcategory validation schema
+ */
+export const subcategorySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().optional(),
+  categoryId: z.string().min(1, "Category ID is required"),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Partial schemas for updates
+ */
+export const categoryUpdateSchema = categorySchema.partial();
+export const subcategoryUpdateSchema = subcategorySchema.partial();
+export const technologyUpdateSchema = technologySchema.partial();
+export const requirementUpdateSchema = requirementSchema.partial();
+
+/**
+ * Documentation Templates schemas
+ */
+export {
+  createDocumentTemplateSchema,
+  updateDocumentTemplateSchema,
+  documentTemplateSchema,
+  documentElementSchema,
+  documentElementWithoutIdSchema,
+} from "../../validations/documentation-templates.schema";

package/src/config/__mocks__/firebase.ts

@@ -1,99 +1,99 @@
-import { FirebaseApp } from "firebase/app";
-import { Firestore, Timestamp } from "firebase/firestore";
-import { Auth } from "firebase/auth";
-import { Analytics } from "firebase/analytics";
-
-interface FirebaseInstance {
-  app: FirebaseApp;
-  db: Firestore;
-  auth: Auth;
-  analytics: Analytics | null;
-}
-
-let initializationAttempts = 0;
-const MAX_ATTEMPTS = 3;
-const RETRY_DELAY = 1000;
-
-export const mockDb = {
-  collection: jest.fn((db, collectionPath, ...pathSegments) => {
-    const fullPath = [collectionPath, ...pathSegments].join("/");
-    return {
-      doc: jest.fn().mockReturnValue({
-        collection: jest.fn(),
-        get: jest.fn().mockResolvedValue({ exists: true, data: () => ({}) }),
-        set: jest.fn().mockResolvedValue(undefined),
-        update: jest.fn().mockResolvedValue(undefined),
-        delete: jest.fn().mockResolvedValue(undefined),
-      }),
-      where: jest.fn().mockReturnThis(),
-      orderBy: jest.fn().mockReturnThis(),
-      limit: jest.fn().mockReturnThis(),
-      get: jest.fn().mockResolvedValue({
-        docs: [],
-        forEach: jest.fn(),
-      }),
-    };
-  }),
-  doc: jest.fn((db, collectionPath, docPath, ...pathSegments) => {
-    const fullPath = [collectionPath, docPath, ...pathSegments].join("/");
-    return {
-      collection: jest.fn(),
-      get: jest.fn().mockResolvedValue({ exists: true, data: () => ({}) }),
-      set: jest.fn().mockResolvedValue(undefined),
-      update: jest.fn().mockResolvedValue(undefined),
-      delete: jest.fn().mockResolvedValue(undefined),
-    };
-  }),
-} as unknown as Firestore & {
-  collection: jest.Mock;
-  doc: jest.Mock;
-};
-
-export const mockAuth = {
-  currentUser: {
-    uid: "test-uid",
-    email: "test@example.com",
-    isAnonymous: false,
-  },
-  signInWithEmailAndPassword: jest.fn(),
-  createUserWithEmailAndPassword: jest.fn(),
-  signOut: jest.fn(),
-} as unknown as Auth;
-
-export const mockTimestamp = {
-  now: jest.fn().mockReturnValue({
-    toDate: jest.fn().mockReturnValue(new Date()),
-  }),
-  fromDate: jest.fn().mockReturnValue({
-    toDate: jest.fn().mockReturnValue(new Date()),
-  }),
-} as unknown as typeof Timestamp;
-
-export const mockFirebaseInstance: FirebaseInstance = {
-  app: {} as FirebaseApp,
-  db: mockDb,
-  auth: mockAuth,
-  analytics: null,
-};
-
-export const getFirebaseInstance = jest.fn().mockImplementation(() => {
-  if (initializationAttempts >= MAX_ATTEMPTS) {
-    initializationAttempts = 0;
-    return Promise.reject(
-      new Error("Firebase inicijalizacija nije uspela nakon više pokušaja")
-    );
-  }
-
-  initializationAttempts++;
-  return Promise.resolve(mockFirebaseInstance);
-});
-
-export const getFirebaseAuth = jest.fn().mockResolvedValue(mockAuth);
-export const getFirebaseDB = jest.fn().mockResolvedValue(mockDb);
-export const getFirebaseApp = jest.fn().mockResolvedValue({} as FirebaseApp);
-
-// Reset mock state before each test
-beforeEach(() => {
-  initializationAttempts = 0;
-  jest.clearAllMocks();
-});
+import { FirebaseApp } from "firebase/app";
+import { Firestore, Timestamp } from "firebase/firestore";
+import { Auth } from "firebase/auth";
+import { Analytics } from "firebase/analytics";
+
+interface FirebaseInstance {
+  app: FirebaseApp;
+  db: Firestore;
+  auth: Auth;
+  analytics: Analytics | null;
+}
+
+let initializationAttempts = 0;
+const MAX_ATTEMPTS = 3;
+const RETRY_DELAY = 1000;
+
+export const mockDb = {
+  collection: jest.fn((db, collectionPath, ...pathSegments) => {
+    const fullPath = [collectionPath, ...pathSegments].join("/");
+    return {
+      doc: jest.fn().mockReturnValue({
+        collection: jest.fn(),
+        get: jest.fn().mockResolvedValue({ exists: true, data: () => ({}) }),
+        set: jest.fn().mockResolvedValue(undefined),
+        update: jest.fn().mockResolvedValue(undefined),
+        delete: jest.fn().mockResolvedValue(undefined),
+      }),
+      where: jest.fn().mockReturnThis(),
+      orderBy: jest.fn().mockReturnThis(),
+      limit: jest.fn().mockReturnThis(),
+      get: jest.fn().mockResolvedValue({
+        docs: [],
+        forEach: jest.fn(),
+      }),
+    };
+  }),
+  doc: jest.fn((db, collectionPath, docPath, ...pathSegments) => {
+    const fullPath = [collectionPath, docPath, ...pathSegments].join("/");
+    return {
+      collection: jest.fn(),
+      get: jest.fn().mockResolvedValue({ exists: true, data: () => ({}) }),
+      set: jest.fn().mockResolvedValue(undefined),
+      update: jest.fn().mockResolvedValue(undefined),
+      delete: jest.fn().mockResolvedValue(undefined),
+    };
+  }),
+} as unknown as Firestore & {
+  collection: jest.Mock;
+  doc: jest.Mock;
+};
+
+export const mockAuth = {
+  currentUser: {
+    uid: "test-uid",
+    email: "test@example.com",
+    isAnonymous: false,
+  },
+  signInWithEmailAndPassword: jest.fn(),
+  createUserWithEmailAndPassword: jest.fn(),
+  signOut: jest.fn(),
+} as unknown as Auth;
+
+export const mockTimestamp = {
+  now: jest.fn().mockReturnValue({
+    toDate: jest.fn().mockReturnValue(new Date()),
+  }),
+  fromDate: jest.fn().mockReturnValue({
+    toDate: jest.fn().mockReturnValue(new Date()),
+  }),
+} as unknown as typeof Timestamp;
+
+export const mockFirebaseInstance: FirebaseInstance = {
+  app: {} as FirebaseApp,
+  db: mockDb,
+  auth: mockAuth,
+  analytics: null,
+};
+
+export const getFirebaseInstance = jest.fn().mockImplementation(() => {
+  if (initializationAttempts >= MAX_ATTEMPTS) {
+    initializationAttempts = 0;
+    return Promise.reject(
+      new Error("Firebase inicijalizacija nije uspela nakon više pokušaja")
+    );
+  }
+
+  initializationAttempts++;
+  return Promise.resolve(mockFirebaseInstance);
+});
+
+export const getFirebaseAuth = jest.fn().mockResolvedValue(mockAuth);
+export const getFirebaseDB = jest.fn().mockResolvedValue(mockDb);
+export const getFirebaseApp = jest.fn().mockResolvedValue({} as FirebaseApp);
+
+// Reset mock state before each test
+beforeEach(() => {
+  initializationAttempts = 0;
+  jest.clearAllMocks();
+});