@blackcode_sa/metaestetics-api 1.7.42 → 1.7.44

package/dist/index.js

@@ -882,12 +882,21 @@ var passwordSchema = import_zod4.z.string().min(8, "Password must be at least 8
 );
 var userRoleSchema = import_zod4.z.nativeEnum(UserRole);
 var userRolesSchema = import_zod4.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = import_zod4.z.custom((data) => {
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
-  return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
-}, "Must be a Timestamp object or serverTimestamp");
+var timestampSchema = import_zod4.z.custom(
+  (data) => {
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
+    if (data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data) {
+      return true;
+    }
+    if (data instanceof Date) {
+      return true;
+    }
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 var clinicAdminOptionsSchema = import_zod4.z.object({
   isGroupOwner: import_zod4.z.boolean(),
   groupToken: import_zod4.z.string().optional(),
@@ -914,9 +923,9 @@ var userSchema = import_zod4.z.object({
   email: import_zod4.z.string().email().nullable(),
   roles: import_zod4.z.array(userRoleSchema),
   isAnonymous: import_zod4.z.boolean(),
-  createdAt: timestampSchema,
-  updatedAt: timestampSchema,
-  lastLoginAt: timestampSchema,
+  createdAt: import_zod4.z.any(),
+  updatedAt: import_zod4.z.any(),
+  lastLoginAt: import_zod4.z.any(),
   patientProfile: import_zod4.z.string().optional(),
   practitionerProfile: import_zod4.z.string().optional(),
   adminProfile: import_zod4.z.string().optional()
@@ -1700,11 +1709,16 @@ var timestampSchema2 = import_zod5.z.union([
     seconds: import_zod5.z.number(),
     nanoseconds: import_zod5.z.number()
   }),
-  import_zod5.z.instanceof(import_firestore4.Timestamp)
+  import_zod5.z.instanceof(import_firestore4.Timestamp),
+  import_zod5.z.instanceof(Date)
+  // Add support for Date objects that Firestore returns on client
 ]).transform((data) => {
   if (data instanceof import_firestore4.Timestamp) {
     return data;
   }
+  if (data instanceof Date) {
+    return import_firestore4.Timestamp.fromDate(data);
+  }
   return new import_firestore4.Timestamp(data.seconds, data.nanoseconds);
 });
 
@@ -5941,7 +5955,7 @@ var UserService = class extends BaseService {
     const q = (0, import_firestore19.query)((0, import_firestore19.collection)(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore19.getDocs)(q);
     const users = querySnapshot.docs.map((doc36) => doc36.data());
-    return Promise.all(users.map((userData) => userSchema.parse(userData)));
+    return users.map((userData) => userSchema.parse(userData));
   }
   /**
    * Ažurira timestamp poslednjeg logovanja

package/dist/index.mjs

@@ -657,12 +657,21 @@ var passwordSchema = z4.string().min(8, "Password must be at least 8 characters"
 );
 var userRoleSchema = z4.nativeEnum(UserRole);
 var userRolesSchema = z4.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = z4.custom((data) => {
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
-  return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
-}, "Must be a Timestamp object or serverTimestamp");
+var timestampSchema = z4.custom(
+  (data) => {
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
+    if (data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data) {
+      return true;
+    }
+    if (data instanceof Date) {
+      return true;
+    }
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 var clinicAdminOptionsSchema = z4.object({
   isGroupOwner: z4.boolean(),
   groupToken: z4.string().optional(),
@@ -689,9 +698,9 @@ var userSchema = z4.object({
   email: z4.string().email().nullable(),
   roles: z4.array(userRoleSchema),
   isAnonymous: z4.boolean(),
-  createdAt: timestampSchema,
-  updatedAt: timestampSchema,
-  lastLoginAt: timestampSchema,
+  createdAt: z4.any(),
+  updatedAt: z4.any(),
+  lastLoginAt: z4.any(),
   patientProfile: z4.string().optional(),
   practitionerProfile: z4.string().optional(),
   adminProfile: z4.string().optional()
@@ -1527,11 +1536,16 @@ var timestampSchema2 = z5.union([
     seconds: z5.number(),
     nanoseconds: z5.number()
   }),
-  z5.instanceof(Timestamp2)
+  z5.instanceof(Timestamp2),
+  z5.instanceof(Date)
+  // Add support for Date objects that Firestore returns on client
 ]).transform((data) => {
   if (data instanceof Timestamp2) {
     return data;
   }
+  if (data instanceof Date) {
+    return Timestamp2.fromDate(data);
+  }
   return new Timestamp2(data.seconds, data.nanoseconds);
 });
 
@@ -5846,7 +5860,7 @@ var UserService = class extends BaseService {
     const q = query8(collection8(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs8(q);
     const users = querySnapshot.docs.map((doc36) => doc36.data());
-    return Promise.all(users.map((userData) => userSchema.parse(userData)));
+    return users.map((userData) => userSchema.parse(userData));
   }
   /**
    * Ažurira timestamp poslednjeg logovanja

package/package.json

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

package/src/services/user.service.ts

@@ -264,7 +264,7 @@ export class UserService extends BaseService {
     }
 
     const userData = userDoc.data();
-    return userSchema.parse(userData);
+    return userSchema.parse(userData) as User;
   }
 
   /**
@@ -278,7 +278,7 @@ export class UserService extends BaseService {
     if (querySnapshot.empty) return null;
 
     const userData = querySnapshot.docs[0].data();
-    return userSchema.parse(userData);
+    return userSchema.parse(userData) as User;
   }
 
   async getUsersByRole(role: UserRole): Promise<User[]> {
@@ -289,7 +289,7 @@ export class UserService extends BaseService {
     const querySnapshot = await getDocs(q);
 
     const users = querySnapshot.docs.map((doc) => doc.data());
-    return Promise.all(users.map((userData) => userSchema.parse(userData)));
+    return users.map((userData) => userSchema.parse(userData) as User);
   }
 
   /**

package/src/types/index.ts

@@ -14,9 +14,9 @@ export interface User {
   email: string | null;
   roles: UserRole[];
   isAnonymous: boolean;
-  createdAt: Timestamp | FieldValue;
-  updatedAt: Timestamp | FieldValue;
-  lastLoginAt: Timestamp | FieldValue;
+  createdAt: any;
+  updatedAt: any;
+  lastLoginAt: any;
   patientProfile?: string;
   practitionerProfile?: string;
   adminProfile?: string;

package/src/validations/common.schema.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { Timestamp } from "firebase/firestore";
 
-// Create a custom schema for Timestamp that properly handles both raw objects and Timestamp instances
+// Create a custom schema for Timestamp that properly handles Timestamp instances, raw objects, and Date objects
 export const timestampSchema = z
   .union([
     z.object({
@@ -9,11 +9,16 @@ export const timestampSchema = z
       nanoseconds: z.number(),
     }),
     z.instanceof(Timestamp),
+    z.instanceof(Date), // Add support for Date objects that Firestore returns on client
   ])
   .transform((data) => {
     if (data instanceof Timestamp) {
       return data;
     }
+    if (data instanceof Date) {
+      // Convert Date back to Timestamp for consistency
+      return Timestamp.fromDate(data);
+    }
     return new Timestamp(data.seconds, data.nanoseconds);
   });
 

package/src/validations/schemas.ts

@@ -24,21 +24,33 @@ export const userRolesSchema = z
   .min(1, "User must have at least one role")
   .max(3, "User cannot have more than 3 roles");
 
-export const timestampSchema = z.custom<Timestamp | FieldValue>((data) => {
-  // If it's a serverTimestamp (FieldValue), it's valid
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
+export const timestampSchema = z.custom<Timestamp | FieldValue | Date>(
+  (data) => {
+    // If it's a serverTimestamp (FieldValue), it's valid
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
 
-  // If it's a Timestamp object, validate its structure
-  return (
-    data &&
-    typeof data === "object" &&
-    "toDate" in data &&
-    "seconds" in data &&
-    "nanoseconds" in data
-  );
-}, "Must be a Timestamp object or serverTimestamp");
+    // If it's a Timestamp object, validate its structure
+    if (
+      data &&
+      typeof data === "object" &&
+      "toDate" in data &&
+      "seconds" in data &&
+      "nanoseconds" in data
+    ) {
+      return true;
+    }
+
+    // If it's a JavaScript Date object (what Firestore returns on client), it's valid
+    if (data instanceof Date) {
+      return true;
+    }
+
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 
 /**
  * Validaciona šema za clinic admin opcije pri kreiranju
@@ -78,9 +90,9 @@ export const userSchema = z.object({
   email: z.string().email().nullable(),
   roles: z.array(userRoleSchema),
   isAnonymous: z.boolean(),
-  createdAt: timestampSchema,
-  updatedAt: timestampSchema,
-  lastLoginAt: timestampSchema,
+  createdAt: z.any(),
+  updatedAt: z.any(),
+  lastLoginAt: z.any(),
   patientProfile: z.string().optional(),
   practitionerProfile: z.string().optional(),
   adminProfile: z.string().optional(),