strapi-plugin-firebase-authentication 1.2.5 → 1.4.0

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

@@ -41,6 +41,13 @@ export type FirebaseAuthConfig = {
      * @default '{randomString}@phone-user.firebase.local'
      */
     emailPattern?: string;
+    /**
+     * Number of days to retain activity logs. If not set, logs are kept forever.
+     * Set via FIREBASE_ACTIVITY_LOG_RETENTION_DAYS environment variable.
+     *
+     * @default null (never delete)
+     */
+    activityLogRetentionDays?: number | null;
 };
 declare const _default: {
     default: ({ env }: {
@@ -49,6 +56,7 @@ declare const _default: {
         firebaseJsonEncryptionKey: any;
         emailRequired: any;
         emailPattern: string;
+        activityLogRetentionDays: any;
     };
     validator(config: FirebaseAuthConfig): void;
 };

package/dist/server/src/content-types/index.d.ts

@@ -141,5 +141,79 @@ declare const _default: {
             };
         };
     };
+    "firebase-activity-log": {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                firebaseUserId: {
+                    type: string;
+                    required: boolean;
+                };
+                strapiUserId: {
+                    type: string;
+                };
+                activityType: {
+                    type: string;
+                    enum: string[];
+                    required: boolean;
+                };
+                action: {
+                    type: string;
+                    required: boolean;
+                };
+                endpoint: {
+                    type: string;
+                };
+                method: {
+                    type: string;
+                };
+                ipAddress: {
+                    type: string;
+                };
+                userAgent: {
+                    type: string;
+                };
+                changes: {
+                    type: string;
+                };
+                metadata: {
+                    type: string;
+                };
+                success: {
+                    type: string;
+                    default: boolean;
+                };
+                errorMessage: {
+                    type: string;
+                };
+                performedBy: {
+                    type: string;
+                };
+                performedByType: {
+                    type: string;
+                    enum: string[];
+                    default: string;
+                };
+            };
+        };
+    };
 };
 export default _default;

package/dist/server/src/controllers/activityLogController.d.ts

@@ -0,0 +1,8 @@
+import { Context, DefaultContext } from "koa";
+declare const _default: {
+    /**
+     * GET /activity-logs?firebaseUserId=xxx&page=1&pageSize=20&activityType=...&startDate=...&endDate=...
+     */
+    list(ctx: DefaultContext | Context): Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/firebaseController.d.ts

@@ -58,5 +58,14 @@ declare const firebaseController: {
      * @returns { success: true, message: "Email verified successfully" }
      */
     verifyEmail(ctx: Context): Promise<Context>;
+    /**
+     * Check password - validates a password against the authenticated user's Firebase account
+     * POST /api/firebase-authentication/checkPassword
+     * Authenticated endpoint - requires valid JWT (enforced by is-authenticated policy)
+     *
+     * @param ctx - Koa context with { password } in body
+     * @returns { valid: true } or { valid: false }
+     */
+    checkPassword(ctx: Context): Promise<void>;
 };
 export default firebaseController;

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

@@ -10,6 +10,7 @@ declare const _default: {
         resetPasswordWithToken(ctx: import("koa").Context): Promise<void>;
         sendVerificationEmail(ctx: import("koa").Context): Promise<void>;
         verifyEmail(ctx: import("koa").Context): Promise<import("koa").Context>;
+        checkPassword(ctx: import("koa").Context): Promise<void>;
     };
     userController: {
         list: (ctx: import("koa").Context | import("koa").DefaultContext) => Promise<void>;
@@ -30,5 +31,8 @@ declare const _default: {
         getPublicConfig(ctx: import("koa").Context | import("koa").DefaultContext): Promise<any>;
         savePasswordConfig(ctx: import("koa").Context | import("koa").DefaultContext): Promise<void>;
     };
+    activityLogController: {
+        list(ctx: import("koa").Context | import("koa").DefaultContext): Promise<void>;
+    };
 };
 export default _default;

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

@@ -16,6 +16,7 @@ declare const _default: {
             firebaseJsonEncryptionKey: any;
             emailRequired: any;
             emailPattern: string;
+            activityLogRetentionDays: any;
         };
         validator(config: import("./config").FirebaseAuthConfig): void;
     };
@@ -31,6 +32,7 @@ declare const _default: {
             resetPasswordWithToken(ctx: import("koa").Context): Promise<void>;
             sendVerificationEmail(ctx: import("koa").Context): Promise<void>;
             verifyEmail(ctx: import("koa").Context): Promise<import("koa").Context>;
+            checkPassword(ctx: import("koa").Context): Promise<void>;
         };
         userController: {
             list: (ctx: import("koa").Context | import("koa").DefaultContext) => Promise<void>;
@@ -51,6 +53,9 @@ declare const _default: {
             getPublicConfig(ctx: import("koa").Context | import("koa").DefaultContext): Promise<any>;
             savePasswordConfig(ctx: import("koa").Context | import("koa").DefaultContext): Promise<void>;
         };
+        activityLogController: {
+            list(ctx: import("koa").Context | import("koa").DefaultContext): Promise<void>;
+        };
     };
     routes: {
         admin: {
@@ -152,6 +157,7 @@ declare const _default: {
             resetPasswordWithToken: (token: string, newPassword: string) => Promise<{
                 success: boolean;
                 message: string;
+                uid: any;
             }>;
             sendVerificationEmail: (entityId: string) => Promise<any>;
         };
@@ -209,6 +215,10 @@ declare const _default: {
             verifyEmail(token: string): Promise<{
                 success: boolean;
                 message: string;
+                uid: any;
+            }>;
+            checkPassword(user: any, password: string): Promise<{
+                valid: boolean;
             }>;
         };
         templateService: ({ strapi }: {
@@ -268,6 +278,14 @@ declare const _default: {
             validateVerificationToken(token: string): Promise<import("./services/tokenService").VerificationTokenValidationResult>;
             invalidateVerificationToken(firebaseUserDataDocumentId: string): Promise<void>;
         };
+        activityLogService: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            logActivity(params: import("./services/activityLogService").LogActivityParams): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            getActivityLogs(firebaseUserId: string, options?: import("./services/activityLogService").GetActivityLogsOptions): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+            getActivityCount(firebaseUserId: string, options?: import("./services/activityLogService").GetActivityLogsOptions): Promise<number>;
+            cleanupOldLogs(retentionDays: number): Promise<number>;
+        };
     };
     contentTypes: {
         "firebase-authentication-configuration": {
@@ -412,10 +430,88 @@ declare const _default: {
                 };
             };
         };
+        "firebase-activity-log": {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    firebaseUserId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    strapiUserId: {
+                        type: string;
+                    };
+                    activityType: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                    };
+                    action: {
+                        type: string;
+                        required: boolean;
+                    };
+                    endpoint: {
+                        type: string;
+                    };
+                    method: {
+                        type: string;
+                    };
+                    ipAddress: {
+                        type: string;
+                    };
+                    userAgent: {
+                        type: string;
+                    };
+                    changes: {
+                        type: string;
+                    };
+                    metadata: {
+                        type: string;
+                    };
+                    success: {
+                        type: string;
+                        default: boolean;
+                    };
+                    errorMessage: {
+                        type: string;
+                    };
+                    performedBy: {
+                        type: string;
+                    };
+                    performedByType: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                };
+            };
+        };
     };
     policies: {
         "is-authenticated": (policyContext: any) => Promise<boolean>;
     };
-    middlewares: {};
+    middlewares: {
+        "activity-logger": ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => (ctx: import("koa").Context, next: import("koa").Next) => Promise<void>;
+    };
 };
 export default _default;

package/dist/server/src/middlewares/activity-logger.d.ts

@@ -0,0 +1,9 @@
+import type { Core } from "@strapi/strapi";
+import type Koa from "koa";
+/**
+ * Factory function that creates the activity logger middleware
+ */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => (ctx: Koa.Context, next: Koa.Next) => Promise<void>;
+export default _default;

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

@@ -1,2 +1,6 @@
-declare const _default: {};
+declare const _default: {
+    "activity-logger": ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => (ctx: import("koa").Context, next: import("koa").Next) => Promise<void>;
+};
 export default _default;

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

@@ -0,0 +1,58 @@
+import type { Core } from "@strapi/strapi";
+export interface LogActivityParams {
+    firebaseUserId: string;
+    strapiUserId?: string;
+    activityType: "authentication" | "tokenValidation" | "fieldUpdate" | "passwordReset" | "emailVerification" | "accountCreation" | "accountDeletion" | "adminAction";
+    action: string;
+    endpoint?: string;
+    method?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    changes?: Record<string, {
+        old: any;
+        new: any;
+    }>;
+    metadata?: Record<string, any>;
+    success?: boolean;
+    errorMessage?: string;
+    performedBy?: string;
+    performedByType?: "user" | "admin" | "system";
+}
+export interface GetActivityLogsOptions {
+    page?: number;
+    pageSize?: number;
+    activityType?: string;
+    startDate?: string;
+    endDate?: string;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Log an activity (non-blocking - errors are caught internally)
+     * @param params - Activity log parameters
+     * @returns Created activity log or undefined on error
+     */
+    logActivity(params: LogActivityParams): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+    /**
+     * Get paginated activity logs for a user with optional filters
+     * @param firebaseUserId - Firebase UID
+     * @param options - Pagination and filter options
+     * @returns Array of activity logs
+     */
+    getActivityLogs(firebaseUserId: string, options?: GetActivityLogsOptions): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+    /**
+     * Get total count for pagination
+     * @param firebaseUserId - Firebase UID
+     * @param options - Filter options
+     * @returns Total count of matching logs
+     */
+    getActivityCount(firebaseUserId: string, options?: GetActivityLogsOptions): Promise<number>;
+    /**
+     * Delete logs older than specified days
+     * @param retentionDays - Number of days to retain logs
+     * @returns Number of deleted entries
+     */
+    cleanupOldLogs(retentionDays: number): Promise<number>;
+};
+export default _default;

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

@@ -130,6 +130,18 @@ declare const _default: ({ strapi }: {
     verifyEmail(token: string): Promise<{
         success: boolean;
         message: string;
+        uid: any;
+    }>;
+    /**
+     * Check if a password is valid for the authenticated user
+     * Uses Firebase Identity Toolkit API to verify the password
+     *
+     * @param user - Authenticated user from ctx.state.user
+     * @param password - Password to check
+     * @returns { valid: true } or { valid: false }
+     */
+    checkPassword(user: any, password: string): Promise<{
+        valid: boolean;
     }>;
 };
 export default _default;

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

@@ -15,6 +15,7 @@ declare const _default: ({ strapi }: {
     getByFirebaseUID(firebaseUID: string): Promise<any>;
     /**
      * Update Firebase-specific fields for a user (creates if doesn't exist)
+     * Handles orphaned records and race conditions gracefully
      * @param userId - Strapi user documentId
      * @param data - Fields to update
      */

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

@@ -63,6 +63,7 @@ declare const _default: {
         resetPasswordWithToken: (token: string, newPassword: string) => Promise<{
             success: boolean;
             message: string;
+            uid: any;
         }>;
         sendVerificationEmail: (entityId: string) => Promise<any>;
     };
@@ -120,6 +121,10 @@ declare const _default: {
         verifyEmail(token: string): Promise<{
             success: boolean;
             message: string;
+            uid: any;
+        }>;
+        checkPassword(user: any, password: string): Promise<{
+            valid: boolean;
         }>;
     };
     templateService: ({ strapi }: {
@@ -179,5 +184,13 @@ declare const _default: {
         validateVerificationToken(token: string): Promise<import("./tokenService").VerificationTokenValidationResult>;
         invalidateVerificationToken(firebaseUserDataDocumentId: string): Promise<void>;
     };
+    activityLogService: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        logActivity(params: import("./activityLogService").LogActivityParams): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+        getActivityLogs(firebaseUserId: string, options?: import("./activityLogService").GetActivityLogsOptions): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+        getActivityCount(firebaseUserId: string, options?: import("./activityLogService").GetActivityLogsOptions): Promise<number>;
+        cleanupOldLogs(retentionDays: number): Promise<number>;
+    };
 };
 export default _default;

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

@@ -42,6 +42,7 @@ declare const _default: ({ strapi }: {
     resetPasswordWithToken: (token: string, newPassword: string) => Promise<{
         success: boolean;
         message: string;
+        uid: any;
     }>;
     /**
      * Send email verification email (admin-initiated)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-firebase-authentication",
-  "version": "1.2.5",
+  "version": "1.4.0",
   "description": "Allows easy integration between clients utilizing Firebase for authentication and Strapi",
   "license": "MIT",
   "repository": {
@@ -85,6 +85,7 @@
   },
   "peerDependencies": {
     "@strapi/strapi": "^5.0.0",
+    "@strapi/utils": "^5.0.0",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "react-router-dom": "^6.0.0",