strapi-plugin-firebase-authentication 1.0.13 → 1.1.0

package/dist/server/src/migrations/migrate-firebase-user-data.d.ts

@@ -0,0 +1,30 @@
+import type { Core } from "@strapi/strapi";
+interface MigrationResult {
+    totalUsers: number;
+    usersWithFirebaseData: number;
+    migrated: number;
+    skipped: number;
+    errors: Array<{
+        user: string;
+        error: string;
+    }>;
+}
+/**
+ * Migrate Firebase user data from up_users table to firebase_user_data table
+ *
+ * This script:
+ * 1. Finds all users with Firebase data (firebaseUserID or appleEmail)
+ * 2. Creates corresponding firebase_user_data records
+ * 3. Skips users that already have firebase_user_data records
+ * 4. Logs all operations for verification
+ *
+ * Note: idToken is NOT migrated (tokens expire in 1 hour, not needed)
+ *
+ * Run this script via:
+ * yarn strapi migrate:firebase-user-data
+ *
+ * Or in development:
+ * Call this function from bootstrap() temporarily
+ */
+declare function migrateFirebaseUserData(strapi: Core.Strapi, dryRun?: boolean): Promise<MigrationResult>;
+export default migrateFirebaseUserData;

package/dist/server/src/routes/admin.d.ts

@@ -5,7 +5,7 @@ declare const _default: {
         path: string;
         handler: string;
         config: {
-            policies: any[];
+            policies: string[];
         };
     }[];
 };

package/dist/server/src/routes/content-api.d.ts

@@ -5,6 +5,7 @@ declare const _default: {
         path: string;
         handler: string;
         config: {
+            auth: boolean;
             policies: any[];
         };
     }[];

package/dist/server/src/routes/content-internal-api.d.ts

@@ -4,7 +4,7 @@ declare const _default: {
         path: string;
         handler: string;
         config: {
-            policies: any[];
+            policies: string[];
         };
     }[];
 };

package/dist/server/src/routes/index.d.ts

@@ -6,7 +6,7 @@ declare const _default: {
             path: string;
             handler: string;
             config: {
-                policies: any[];
+                policies: string[];
             };
         }[];
     };
@@ -17,6 +17,7 @@ declare const _default: {
             path: string;
             handler: string;
             config: {
+                auth: boolean;
                 policies: any[];
             };
         }[];
@@ -27,7 +28,7 @@ declare const _default: {
             path: string;
             handler: string;
             config: {
-                policies: any[];
+                policies: string[];
             };
         }[];
     };

package/dist/server/src/routes/settingsRoutes.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     path: string;
     handler: string;
     config: {
-        policies: any[];
+        policies: string[];
     };
 }[];
 export default _default;

package/dist/server/src/services/autoLinkService.d.ts

@@ -0,0 +1,29 @@
+import type { Core } from "@strapi/strapi";
+export interface LinkResult {
+    totalStrapiUsers: number;
+    totalFirebaseUsers: number;
+    linked: number;
+    skipped: number;
+    errors: number;
+}
+/**
+ * Auto-Link Service
+ *
+ * Automatically links existing Strapi users with their Firebase counterparts
+ * by matching email and phone numbers.
+ *
+ * Runs on every Strapi startup in the background (non-blocking).
+ */
+declare const _default: {
+    /**
+     * Link all Strapi users with matching Firebase users
+     *
+     * This runs automatically on Strapi startup to ensure all users
+     * who exist in both Strapi and Firebase are properly linked.
+     *
+     * @param strapi - Strapi instance
+     * @returns Promise<LinkResult> - Summary of linking operation
+     */
+    linkAllUsers(strapi: Core.Strapi): Promise<LinkResult>;
+};
+export default _default;

package/dist/server/src/services/emailService.d.ts

@@ -0,0 +1,32 @@
+import { TemplateVariables, TemplateType } from "../templates/types";
+declare class EmailService {
+    /**
+     * Send a templated email using Strapi's email service
+     * Templates are compiled with Lodash before sending
+     */
+    sendTemplatedEmail(to: string, templateType: TemplateType, variables: Partial<TemplateVariables>): Promise<void>;
+    /**
+     * Send password reset email with three-tier fallback system
+     * Tier 1: Strapi Email Plugin (if configured)
+     * Tier 2: Custom Hook Function (if provided in config)
+     * Tier 3: Development Console Logging (dev mode only)
+     */
+    sendPasswordResetEmail(user: any, resetLink: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Send magic link email with three-tier fallback system
+     * Tier 1: Strapi Email Plugin (if configured)
+     * Tier 2: Custom Hook Function (if provided in config)
+     * Tier 3: Development Console Logging (dev mode only)
+     */
+    sendMagicLinkEmail(email: string, magicLink: string, config: any): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => EmailService;
+export default _default;

package/dist/server/src/services/firebaseService.d.ts

@@ -7,24 +7,98 @@ declare const _default: ({ strapi }: {
     }>;
     validateExchangeTokenPayload: (requestPayload: any) => Promise<any>;
     decodeIDToken: (idToken: any) => Promise<any>;
-    overrideFirebaseAccess: (ctx: any) => Promise<any>;
+    overrideFirebaseAccess: (overrideUserId: string, populate?: string[]) => Promise<{
+        user: any;
+        jwt: any;
+    }>;
     checkIfUserExists(decodedToken: any): Promise<any>;
     fetchUser: (decodedToken: any) => Promise<any>;
     generateJWTForCurrentUser: (user: any) => Promise<any>;
     createStrapiUser(decodedToken: any, idToken: any, profileMetaData: any): Promise<any>;
-    updateUserIDToken: (user: any, idToken: any, decodedToken: any) => Promise<any>;
-    validateFirebaseToken: (ctx: any) => Promise<{
-        error: any;
-        user?: undefined;
-        jwt?: undefined;
-    } | {
-        user: {
-            id: import("@strapi/types/dist/data").ID;
-        } & {
-            [key: string]: any;
-        };
+    validateFirebaseToken: (idToken: string, profileMetaData?: any, populate?: string[]) => Promise<{
+        user: any;
+        jwt: any;
+    }>;
+    /**
+     * Authenticates a user with email and password through Firebase Identity Toolkit API
+     *
+     * @param ctx - Koa context object containing the HTTP request and response
+     * @returns Response object containing user and JWT token
+     *
+     * @throws ValidationError - When email/password are missing or invalid
+     * @throws ApplicationError - When Firebase Web API key is not configured or authentication fails
+     *
+     * @example
+     * ```typescript
+     * // Request
+     * POST /api/firebase-authentication/emailLogin
+     * {
+     *   "email": "user@example.com",
+     *   "password": "securePassword123"
+     * }
+     *
+     * // Response
+     * {
+     *   "user": {
+     *     "id": 1,
+     *     "email": "user@example.com",
+     *     "username": "user",
+     *     "confirmed": true,
+     *     "blocked": false
+     *   },
+     *   "jwt": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+     * }
+     * ```
+     *
+     * @remarks
+     * This method acts as a proxy to Firebase's REST API, eliminating the need for
+     * Firebase SDK on the client. It performs the following steps:
+     * 1. Validates email and password inputs
+     * 2. Retrieves Firebase Web API key from configuration
+     * 3. Calls Firebase Identity Toolkit API for authentication
+     * 4. Processes Firebase response and handles errors
+     * 5. Looks up or creates Strapi user
+     * 6. Generates and returns Strapi JWT token
+     */
+    emailLogin: (email: string, password: string, populate?: string[]) => Promise<{
+        user: any;
+        jwt: any;
+    }>;
+    /**
+     * Forgot password flow - sends reset email
+     * Public endpoint that generates a JWT token and sends a password reset email
+     */
+    forgotPassword: (ctx: any) => Promise<{
+        message: string;
+    }>;
+    /**
+     * Reset password with authenticated JWT
+     * Public endpoint that validates a JWT token and resets the user's password
+     */
+    resetPassword: (ctx: any) => Promise<{
+        user: any;
         jwt: any;
-        error?: undefined;
+    }>;
+    /**
+     * Request Magic Link for passwordless authentication
+     * Generates a sign-in link using Firebase Admin SDK
+     * Note: Verification requires client-side completion
+     */
+    requestMagicLink(ctx: any): Promise<{
+        debug: {
+            linkSent: any;
+            email: string;
+            message: any;
+        };
+        success: boolean;
+        message: string;
+        requiresFrontend: boolean;
+        verificationUrl: any;
+    } | {
+        success: boolean;
+        message: string;
+        requiresFrontend: boolean;
+        verificationUrl: any;
     }>;
 };
 export default _default;

package/dist/server/src/services/firebaseStrapiLinkService.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Firebase-Strapi Link Service
+ *
+ * Links Firebase users with Strapi users via the firebase_user_data table.
+ * Uses Firebase UID as the sole source of truth for linking.
+ */
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    /**
+     * Builds a Map of Firebase UID → Strapi User for O(1) lookups
+     *
+     * Fetches all firebase_user_data records with populated user relation.
+     * Uses Document Service API for proper Strapi v5 relation handling.
+     *
+     * @returns Map<firebaseUID, strapiUserWithAppleEmail>
+     */
+    buildUserMap(): Promise<Map<any, any>>;
+    /**
+     * Links Firebase users with Strapi data using firebase_user_data table
+     *
+     * Matching Strategy:
+     * - ONLY uses Firebase UID → firebase_user_data.firebaseUserID
+     * - firebase_user_data table is the source of truth
+     * - No email/phone fallback (security risk from recycled identifiers)
+     *
+     * @param firebaseUsers - Array of Firebase user objects
+     * @param uidToUserMap - Map from buildUserMap()
+     * @param allStrapiUsers - Unused (kept for backward compatibility)
+     * @returns Array of linked user objects with linkStatus and warnings
+     */
+    linkFirebaseUsers(firebaseUsers: any[], uidToUserMap: Map<string, any>, allStrapiUsers: any[]): any[];
+};
+export default _default;

package/dist/server/src/services/firebaseUserDataService.d.ts

@@ -0,0 +1,26 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    /**
+     * Find or create Firebase user data for a Strapi user
+     * @param userId - Strapi user documentId
+     * @returns Firebase user data record
+     */
+    findOrCreateForUser(userId: string): Promise<any>;
+    /**
+     * Get Firebase user data by Firebase UID
+     * @param firebaseUID - Firebase user ID
+     * @returns Firebase user data with populated user
+     */
+    getByFirebaseUID(firebaseUID: string): Promise<any>;
+    /**
+     * Update Firebase-specific fields for a user (creates if doesn't exist)
+     * @param userId - Strapi user documentId
+     * @param data - Fields to update
+     */
+    updateForUser(userId: string, data: {
+        firebaseUserID?: string;
+        appleEmail?: string;
+    }): Promise<any>;
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="koa" />
+/// <reference types="lodash" />
 declare const _default: {
     settingsService: ({ strapi }: {
         strapi: any;
@@ -6,9 +6,24 @@ declare const _default: {
         init(): Promise<void>;
         getFirebaseConfigJson(): Promise<{
             firebaseConfigJson: any;
+            firebaseWebApiKey: any;
+            passwordRequirementsRegex: any;
+            passwordRequirementsMessage: any;
+            passwordResetUrl: any;
+            passwordResetEmailSubject: any;
+            enableMagicLink: any;
+            magicLinkUrl: any;
+            magicLinkEmailSubject: any;
+            magicLinkExpiryHours: any;
         }>;
-        setFirebaseConfigJson(ctx: import("koa").DefaultContext | import("koa").Context): Promise<any>;
+        setFirebaseConfigJson(ctx: import("koa").Context | import("koa").DefaultContext): Promise<any>;
         delFirebaseConfigJson: () => Promise<any>;
+        updateMagicLinkSettings(settings: any): Promise<{
+            enableMagicLink: any;
+            magicLinkUrl: any;
+            magicLinkEmailSubject: any;
+            magicLinkExpiryHours: any;
+        }>;
         encryptJson(key: string, json: string): Promise<any>;
         decryptJson(key: string, hash: string): Promise<any>;
         restart(): Promise<void>;
@@ -19,7 +34,7 @@ declare const _default: {
         get: (entityId: string) => Promise<any>;
         create: (payload: any) => Promise<any>;
         register: (userID: any, payload: any) => Promise<void>;
-        list: (pagination: any, nextPageToken: any) => Promise<{
+        list: (pagination: any, nextPageToken: any, sort: any, searchQuery: any) => Promise<{
             data: any;
             pageToken: any;
             meta: {
@@ -36,6 +51,7 @@ declare const _default: {
         deleteStrapiUser: (entityId: any) => Promise<any>;
         deleteMany: (entityIDs: any) => Promise<any>;
         setSocialMetaData(): Promise<void>;
+        sendPasswordResetEmail: (entityId: any) => Promise<any>;
     };
     firebaseService: ({ strapi }: {
         strapi: any;
@@ -46,25 +62,84 @@ declare const _default: {
         }>;
         validateExchangeTokenPayload: (requestPayload: any) => Promise<any>;
         decodeIDToken: (idToken: any) => Promise<any>;
-        overrideFirebaseAccess: (ctx: any) => Promise<any>;
+        overrideFirebaseAccess: (overrideUserId: string, populate?: string[]) => Promise<{
+            user: any;
+            jwt: any;
+        }>;
         checkIfUserExists(decodedToken: any): Promise<any>;
         fetchUser: (decodedToken: any) => Promise<any>;
         generateJWTForCurrentUser: (user: any) => Promise<any>;
         createStrapiUser(decodedToken: any, idToken: any, profileMetaData: any): Promise<any>;
-        updateUserIDToken: (user: any, idToken: any, decodedToken: any) => Promise<any>;
-        validateFirebaseToken: (ctx: any) => Promise<{
-            error: any;
-            user?: undefined;
-            jwt?: undefined;
-        } | {
-            user: {
-                id: import("@strapi/types/dist/data").ID;
-            } & {
-                [key: string]: any;
-            };
+        validateFirebaseToken: (idToken: string, profileMetaData?: any, populate?: string[]) => Promise<{
+            user: any;
+            jwt: any;
+        }>;
+        emailLogin: (email: string, password: string, populate?: string[]) => Promise<{
+            user: any;
+            jwt: any;
+        }>;
+        forgotPassword: (ctx: any) => Promise<{
+            message: string;
+        }>;
+        resetPassword: (ctx: any) => Promise<{
+            user: any;
             jwt: any;
-            error?: undefined;
         }>;
+        requestMagicLink(ctx: any): Promise<{
+            debug: {
+                linkSent: any;
+                email: string;
+                message: any;
+            };
+            success: boolean;
+            message: string;
+            requiresFrontend: boolean;
+            verificationUrl: any;
+        } | {
+            success: boolean;
+            message: string;
+            requiresFrontend: boolean;
+            verificationUrl: any;
+        }>;
+    };
+    templateService: ({ strapi }: {
+        strapi: any;
+    }) => {
+        getTemplate(templateType: import("../templates/types").TemplateType): Promise<import("../templates/types").EmailTemplate>;
+        compileTemplate(templateString: string): import("lodash").TemplateExecutor;
+        validateVariables(variables: Partial<import("../templates/types").TemplateVariables>, required: string[]): void;
+    };
+    emailService: ({ strapi }: {
+        strapi: any;
+    }) => {
+        sendTemplatedEmail(to: string, templateType: import("../templates/types").TemplateType, variables: Partial<import("../templates/types").TemplateVariables>): Promise<void>;
+        sendPasswordResetEmail(user: any, resetLink: string): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        sendMagicLinkEmail(email: string, magicLink: string, config: any): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+    };
+    firebaseUserDataService: ({ strapi }: {
+        strapi: any;
+    }) => {
+        findOrCreateForUser(userId: string): Promise<any>;
+        getByFirebaseUID(firebaseUID: string): Promise<any>;
+        updateForUser(userId: string, data: {
+            firebaseUserID?: string;
+            appleEmail?: string;
+        }): Promise<any>;
+    };
+    autoLinkService: {
+        linkAllUsers(strapi: import("@strapi/types/dist/core").Strapi): Promise<import("./autoLinkService").LinkResult>;
+    };
+    firebaseStrapiLinkService: ({ strapi }: {
+        strapi: any;
+    }) => {
+        buildUserMap(): Promise<Map<any, any>>;
+        linkFirebaseUsers(firebaseUsers: any[], uidToUserMap: Map<string, any>, allStrapiUsers: any[]): any[];
     };
 };
 export default _default;

package/dist/server/src/services/settingsService.d.ts

@@ -3,11 +3,66 @@ declare const _default: ({ strapi }: {
     strapi: any;
 }) => {
     init(): Promise<void>;
+    /**
+     * Retrieves and decrypts the Firebase configuration including Web API key and password reset settings
+     *
+     * @returns Firebase configuration object or null if not configured
+     *
+     * @throws ApplicationError - When there's an error retrieving or decrypting the configuration
+     *
+     * @remarks
+     * Returns an object containing:
+     * - `firebaseConfigJson`: Decrypted Firebase service account JSON string
+     * - `firebaseWebApiKey`: Firebase Web API key for Identity Toolkit API calls
+     * - `passwordRequirementsRegex`: Regex pattern for password validation
+     * - `passwordRequirementsMessage`: Error message for invalid passwords
+     * - `passwordResetUrl`: URL for password reset page
+     * - `passwordResetEmailSubject`: Subject line for reset emails
+     */
     getFirebaseConfigJson(): Promise<{
         firebaseConfigJson: any;
+        firebaseWebApiKey: any;
+        passwordRequirementsRegex: any;
+        passwordRequirementsMessage: any;
+        passwordResetUrl: any;
+        passwordResetEmailSubject: any;
+        enableMagicLink: any;
+        magicLinkUrl: any;
+        magicLinkEmailSubject: any;
+        magicLinkExpiryHours: any;
     }>;
+    /**
+     * Stores and encrypts Firebase configuration including Web API key and password reset settings
+     *
+     * @param ctx - Koa context object containing the configuration in request body
+     * @returns The saved configuration object with decrypted values
+     *
+     * @throws ValidationError - When required data is missing
+     * @throws ApplicationError - When there's an error saving the configuration
+     *
+     * @remarks
+     * Expects request body to contain:
+     * - `firebaseConfigJson`: Firebase service account JSON as string
+     * - `firebaseWebApiKey`: Firebase Web API key for REST API calls
+     * - `passwordRequirementsRegex`: Regex pattern for password validation
+     * - `passwordRequirementsMessage`: Error message for invalid passwords
+     * - `passwordResetUrl`: URL for password reset page
+     * - `passwordResetEmailSubject`: Subject line for reset emails
+     *
+     * The service account JSON is encrypted using AES before storage,
+     * while the Web API key and password settings are stored in plain text.
+     */
     setFirebaseConfigJson(ctx: DefaultContext | Context): Promise<any>;
     delFirebaseConfigJson: () => Promise<any>;
+    /**
+     * Updates only the magic link settings without affecting other configuration
+     */
+    updateMagicLinkSettings(settings: any): Promise<{
+        enableMagicLink: any;
+        magicLinkUrl: any;
+        magicLinkEmailSubject: any;
+        magicLinkExpiryHours: any;
+    }>;
     encryptJson(key: string, json: string): Promise<any>;
     decryptJson(key: string, hash: string): Promise<any>;
     restart(): Promise<void>;

package/dist/server/src/services/templateService.d.ts

@@ -0,0 +1,21 @@
+import _ from "lodash";
+import { EmailTemplate, TemplateVariables, TemplateType } from "../templates/types";
+declare class TemplateService {
+    /**
+     * Get template with user overrides from configuration
+     */
+    getTemplate(templateType: TemplateType): Promise<EmailTemplate>;
+    /**
+     * Compile a template string using Lodash
+     * Uses Lodash default delimiters: <%= %>
+     */
+    compileTemplate(templateString: string): _.TemplateExecutor;
+    /**
+     * Validate that required variables are present
+     */
+    validateVariables(variables: Partial<TemplateVariables>, required: string[]): void;
+}
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => TemplateService;
+export default _default;

package/dist/server/src/services/userService.d.ts

@@ -4,7 +4,7 @@ declare const _default: ({ strapi }: {
     get: (entityId: string) => Promise<any>;
     create: (payload: any) => Promise<any>;
     register: (userID: any, payload: any) => Promise<void>;
-    list: (pagination: any, nextPageToken: any) => Promise<{
+    list: (pagination: any, nextPageToken: any, sort: any, searchQuery: any) => Promise<{
         data: any;
         pageToken: any;
         meta: {
@@ -21,5 +21,6 @@ declare const _default: ({ strapi }: {
     deleteStrapiUser: (entityId: any) => Promise<any>;
     deleteMany: (entityIDs: any) => Promise<any>;
     setSocialMetaData(): Promise<void>;
+    sendPasswordResetEmail: (entityId: any) => Promise<any>;
 };
 export default _default;

package/dist/server/src/templates/defaults/index.d.ts

@@ -0,0 +1,2 @@
+export { passwordResetTemplate } from "./password-reset";
+export { magicLinkTemplate } from "./magic-link";

package/dist/server/src/templates/defaults/magic-link.d.ts

@@ -0,0 +1,2 @@
+import { EmailTemplate } from "../types";
+export declare const magicLinkTemplate: EmailTemplate;

package/dist/server/src/templates/defaults/password-reset.d.ts

@@ -0,0 +1,2 @@
+import { EmailTemplate } from "../types";
+export declare const passwordResetTemplate: EmailTemplate;

package/dist/server/src/templates/types.d.ts

@@ -0,0 +1,30 @@
+export interface EmailTemplate {
+    subject: string;
+    html?: string;
+    text?: string;
+    htmlFile?: string;
+    textFile?: string;
+}
+export interface EmailTemplateConfig {
+    passwordReset?: Partial<EmailTemplate>;
+    magicLink?: Partial<EmailTemplate>;
+}
+export interface TemplateVariables {
+    user: {
+        email: string;
+        firstName?: string;
+        lastName?: string;
+        displayName?: string;
+        phoneNumber?: string;
+        uid: string;
+    };
+    link?: string;
+    resetLink?: string;
+    magicLink?: string;
+    appName: string;
+    appUrl: string;
+    expiresIn: string;
+    year: number;
+    supportEmail?: string;
+}
+export type TemplateType = "passwordReset" | "magicLink";

package/dist/server/src/utils/fetch-me.d.ts

@@ -1,10 +1,2 @@
-export declare const fetchUser: (currentUser: any, populate?: string[]) => Promise<{
-    id: import("@strapi/types/dist/data").ID;
-} & {
-    [key: string]: any;
-}>;
-export declare const processMeData: (currentUser: any, populate?: string[]) => Promise<{
-    id: import("@strapi/types/dist/data").ID;
-} & {
-    [key: string]: any;
-}>;
+export declare const fetchUser: (currentUser: any, populate?: string[]) => Promise<any>;
+export declare const processMeData: (currentUser: any, populate?: string[]) => Promise<any>;

package/dist/server/src/utils/get-user-by-id.d.ts

@@ -1,6 +1,2 @@
-declare const _default: (userID: any) => Promise<{
-    id: import("@strapi/types/dist/data").ID;
-} & {
-    [key: string]: any;
-}>;
+declare const _default: (userID: any) => Promise<any>;
 export default _default;

package/dist/server/src/utils/users.d.ts

@@ -1,2 +1,16 @@
 import { StrapiUser } from "../../../model/User";
+/**
+ * @deprecated This utility is deprecated and should not be used.
+ * Use firebaseStrapiLinkService.linkFirebaseUsers() instead.
+ *
+ * This function incorrectly looks for firebaseUserID on the User table,
+ * which was moved to the firebase_user_data table.
+ *
+ * Replacement:
+ * ```typescript
+ * const linkService = strapi.plugin('firebase-authentication').service('firebaseStrapiLinkService');
+ * const uidToUserMap = await linkService.buildUserMap();
+ * const linkedUsers = linkService.linkFirebaseUsers(firebaseUsers, uidToUserMap, strapiUsers);
+ * ```
+ */
 export declare const formatUserData: (result: any, strapiUsersData: StrapiUser[]) => any;