@mohasinac/appkit 3.2.9 → 3.2.11

package/dist/_internal/client/features/filters/filter-load-options.js

@@ -10,6 +10,7 @@
  *   <AsyncFacetSection loadOptions={load} ... />
  */
 import { apiClient } from "../../../../http/ApiClient";
+import { normalizeError } from "../../../../errors/normalize";
 const PAGE_SIZE = 25;
 function buildUrl(base, q, page, extra) {
     const params = new URLSearchParams({
@@ -29,7 +30,7 @@ async function fetchPage(url, mapItem) {
         };
     }
     catch (_err) {
-        // PaginatedSelect degrades to an empty page on load error — caller can retry by re-typing
+        void normalizeError(_err); // PaginatedSelect degrades to empty page; caller can retry by re-typing
         return { items: [], hasMore: false };
     }
 }

package/dist/_internal/server/features/auth/firebase-identity.d.ts

@@ -1,3 +1,4 @@
+import type { JsonObject } from "../../../../schemas/types";
 type IdentityOperation = "signInWithPassword" | "signInWithCustomToken";
 /**
  * Calls the Firebase Identity Toolkit REST API with one retry for transient
@@ -8,5 +9,5 @@ type IdentityOperation = "signInWithPassword" | "signInWithCustomToken";
  * into a session cookie. Centralised here so the URL, Content-Type, and retry
  * config are in one place.
  */
-export declare function callFirebaseIdentityToolkit<T extends Record<string, unknown>>(operation: IdentityOperation, body: Record<string, unknown>, apiKey: string): Promise<T>;
+export declare function callFirebaseIdentityToolkit<T extends JsonObject>(operation: IdentityOperation, body: JsonObject, apiKey: string): Promise<T>;
 export {};

package/dist/_internal/server/jobs/core/cleanupRtdbEvents.js

@@ -17,7 +17,10 @@ export async function runCleanupRtdbEvents(ctx) {
             if (staleAuthIds.length > 0) {
                 await Promise.all(staleAuthIds.flatMap((id) => [
                     rtdb.ref(`auth_events/${id}`).remove(),
-                    auth.deleteUser(`auth_event_${id}`).catch(console.error),
+                    auth.deleteUser(`auth_event_${id}`).catch((err) => {
+                        void normalizeError(err);
+                        ctx.logger.warn("cleanupRtdbEvents: deleteUser skipped — may already be absent", { userId: `auth_event_${id}`, error: err instanceof Error ? err.message : String(err) });
+                    }),
                 ]));
                 ctx.logger.info("Auth events removed", { count: staleAuthIds.length });
             }

package/dist/_internal/shared/listing-types/action-tracker.js

@@ -1,3 +1,4 @@
+import { normalizeError } from "../../../errors/normalize";
 function defaultSink(event) {
     if (typeof window === "undefined") {
         // SSR / Node — best-effort console log; production servers can swap
@@ -32,7 +33,7 @@ export const actionTracker = {
             const result = currentSink(event);
             // Swallow promise rejections so the caller path is never affected.
             if (result && typeof result.catch === "function") {
-                result.catch(console.error);
+                result.catch((err) => { void normalizeError(err); });
             }
         }
         catch {

package/dist/features/blog/api/[slug]/route.js

@@ -11,6 +11,7 @@
 import { NextResponse } from "next/server.js";
 import { blogRepository } from "../../repository/blog.repository";
 import { normalizeError } from "../../../../errors/normalize";
+import { safeFireAndForget } from "../../../../utils/safe-fire-forget";
 function toBlogPost(doc) {
     return {
         ...doc,
@@ -28,7 +29,7 @@ export async function GET(_request, context) {
             return NextResponse.json({ success: false, error: "Blog post not found" }, { status: 404 });
         }
         // Increment view count fire-and-forget — must not block response
-        blogRepository.incrementViews(post.id).catch(console.error);
+        safeFireAndForget(blogRepository.incrementViews(post.id), "blog: incrementViews");
         // Related posts: same category, latest 3, excluding current
         const related = (await blogRepository.findRelated(post.category, post.id, 3)).map(toBlogPost);
         const body = { post: toBlogPost(post), related };

package/dist/features/homepage/lib/live-stats.js

@@ -8,6 +8,8 @@
 import { ALLOWED_LIVE_COLLECTIONS } from "../schemas/firestore";
 import { productRepository, storeRepository, userRepository, reviewRepository, orderRepository, } from "../../../repositories";
 import { getAdminDb, getFirestoreCount } from "../../../providers/db-firebase";
+import { normalizeError } from "../../../errors/normalize";
+import { serverLogger } from "../../../monitoring/server-logger";
 /**
  * Fetch live stats for all requested metrics.
  * Preset metrics are deduped so each Firestore query runs at most once.
@@ -27,22 +29,22 @@ export async function fetchLiveStats(requests) {
     if (neededPresets.has("total_listings")) {
         tasks.push(productRepository.count()
             .then((n) => { resolvedPresets.total_listings = String(n); })
-            .catch(console.error));
+            .catch((err) => { void normalizeError(err); serverLogger.warn("live-stats: total_listings query failed — stat omitted", { error: err instanceof Error ? err.message : String(err) }); }));
     }
     if (neededPresets.has("verified_sellers")) {
         tasks.push(storeRepository.count()
             .then((n) => { resolvedPresets.verified_sellers = String(n); })
-            .catch(console.error));
+            .catch((err) => { void normalizeError(err); serverLogger.warn("live-stats: verified_sellers query failed — stat omitted", { error: err instanceof Error ? err.message : String(err) }); }));
     }
     if (neededPresets.has("total_buyers")) {
         tasks.push(userRepository.countByRole("user")
             .then((n) => { resolvedPresets.total_buyers = String(n); })
-            .catch(console.error));
+            .catch((err) => { void normalizeError(err); serverLogger.warn("live-stats: total_buyers query failed — stat omitted", { error: err instanceof Error ? err.message : String(err) }); }));
     }
     if (neededPresets.has("total_orders")) {
         tasks.push(orderRepository.count()
             .then((n) => { resolvedPresets.total_orders = String(n); })
-            .catch(console.error));
+            .catch((err) => { void normalizeError(err); serverLogger.warn("live-stats: total_orders query failed — stat omitted", { error: err instanceof Error ? err.message : String(err) }); }));
     }
     if (neededPresets.has("total_reviews") || neededPresets.has("platform_rating")) {
         tasks.push(reviewRepository.findAll()
@@ -57,7 +59,7 @@ export async function fetchLiveStats(requests) {
                 resolvedPresets.platform_rating = avg.toFixed(1) + "★";
             }
         })
-            .catch(console.error));
+            .catch((err) => { void normalizeError(err); serverLogger.warn("live-stats: reviews/rating query failed — stat omitted", { error: err instanceof Error ? err.message : String(err) }); }));
     }
     // --- Collection-query metrics ------------------------------------------------
     const queryRequests = requests.filter((r) => r.source === "live-collection" && r.collectionQuery !== undefined);

package/dist/features/scams/actions/scam-actions.js

@@ -1,6 +1,7 @@
 "use server";
 import { sieveFilter, SIEVE_OP } from "@mohasinac/appkit";
 import { scammerRepository } from "../repository/scammer.repository";
+import { safeFireAndForget } from "../../../utils/safe-fire-forget";
 /**
  * List verified scammer profiles for the public registry page.
  * Accepts sieve-style searchParams from Next.js page props.
@@ -43,7 +44,7 @@ export async function getPublicScammerById(id) {
     if (!doc || doc.status !== "verified")
         return null;
     // Increment views — non-blocking.
-    scammerRepository.incrementViews(doc.id).catch(console.error);
+    safeFireAndForget(scammerRepository.incrementViews(doc.id), "scam: incrementViews");
     return doc;
 }
 /**

package/dist/providers/storage-firebase/provider.js

@@ -20,6 +20,9 @@
  * ```
  */
 import { getAdminStorageLite } from "../db-firebase/admin-storage-lite";
+import { withRetry } from "../../http/retry";
+import { normalizeError } from "../../errors/normalize";
+import { serverLogger } from "../../monitoring/server-logger";
 function getBucket() {
     const bucketName = process.env.FIREBASE_ADMIN_STORAGE_BUCKET?.trim() ??
         process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET?.trim();
@@ -29,75 +32,126 @@ function getBucket() {
 }
 export const firebaseStorageProvider = {
     async upload(file, storagePath, options) {
-        const bucket = getBucket();
-        const fileRef = bucket.file(storagePath);
-        await fileRef.save(file, {
-            metadata: {
-                contentType: options?.contentType ?? "application/octet-stream",
-                cacheControl: options?.cacheControl ?? "public, max-age=31536000",
-                metadata: options?.metadata ?? {},
-            },
-            public: options?.isPublic !== false,
-        });
-        const [metadata] = await fileRef.getMetadata();
-        const url = options?.isPublic !== false
-            ? `https://storage.googleapis.com/${bucket.name}/${storagePath}`
-            : await fileRef
-                .getSignedUrl({
-                action: "read",
-                expires: Date.now() + 60 * 60 * 1000, // 1 hour
-            })
-                .then(([u]) => u);
-        return {
-            path: storagePath,
-            url,
-            contentType: metadata.contentType,
-            size: Number(metadata.size),
-            updatedAt: metadata.updated,
-        };
+        try {
+            const bucket = getBucket();
+            const fileRef = bucket.file(storagePath);
+            await withRetry(() => fileRef.save(file, {
+                metadata: {
+                    contentType: options?.contentType ?? "application/octet-stream",
+                    cacheControl: options?.cacheControl ?? "public, max-age=31536000",
+                    metadata: options?.metadata ?? {},
+                },
+                public: options?.isPublic !== false,
+            }), 2, 300);
+            const [metadata] = await withRetry(() => fileRef.getMetadata(), 2, 300);
+            const url = options?.isPublic !== false
+                ? `https://storage.googleapis.com/${bucket.name}/${storagePath}`
+                : await withRetry(() => fileRef
+                    .getSignedUrl({
+                    action: "read",
+                    expires: Date.now() + 60 * 60 * 1000,
+                })
+                    .then(([u]) => u), 2, 300);
+            return {
+                path: storagePath,
+                url,
+                contentType: metadata.contentType,
+                size: Number(metadata.size),
+                updatedAt: metadata.updated,
+            };
+        }
+        catch (err) {
+            void normalizeError(err);
+            serverLogger.error("storage-provider: upload failed", {
+                storagePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     },
     async delete(storagePath) {
-        await getBucket().file(storagePath).delete({ ignoreNotFound: true });
+        try {
+            await withRetry(() => getBucket().file(storagePath).delete({ ignoreNotFound: true }), 2, 300);
+        }
+        catch (err) {
+            void normalizeError(err);
+            serverLogger.error("storage-provider: delete failed", {
+                storagePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     },
     getPublicUrl(storagePath) {
         const bucket = getBucket();
         return `https://storage.googleapis.com/${bucket.name}/${storagePath}`;
     },
     async getSignedUrl(storagePath, expiresInSeconds = 3600) {
-        const [url] = await getBucket()
-            .file(storagePath)
-            .getSignedUrl({
-            action: "read",
-            expires: Date.now() + expiresInSeconds * 1000,
-        });
-        return url;
+        try {
+            const [url] = await withRetry(() => getBucket()
+                .file(storagePath)
+                .getSignedUrl({
+                action: "read",
+                expires: Date.now() + expiresInSeconds * 1000,
+            }), 2, 300);
+            return url;
+        }
+        catch (err) {
+            void normalizeError(err);
+            serverLogger.error("storage-provider: getSignedUrl failed", {
+                storagePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     },
     async copy(from, to) {
-        const bucket = getBucket();
-        const src = bucket.file(from);
-        const dest = bucket.file(to);
-        await src.copy(dest);
-        const [metadata] = await dest.getMetadata();
-        return {
-            path: to,
-            url: `https://storage.googleapis.com/${bucket.name}/${to}`,
-            contentType: metadata.contentType,
-            size: Number(metadata.size),
-            updatedAt: metadata.updated,
-        };
-    },
-    async list(prefix) {
-        const bucket = getBucket();
-        const [files] = await bucket.getFiles({ prefix });
-        return Promise.all(files.map(async (f) => {
-            const [metadata] = await f.getMetadata();
+        try {
+            const bucket = getBucket();
+            const src = bucket.file(from);
+            const dest = bucket.file(to);
+            await withRetry(() => src.copy(dest), 2, 300);
+            const [metadata] = await withRetry(() => dest.getMetadata(), 2, 300);
             return {
-                path: f.name,
-                url: `https://storage.googleapis.com/${bucket.name}/${f.name}`,
+                path: to,
+                url: `https://storage.googleapis.com/${bucket.name}/${to}`,
                 contentType: metadata.contentType,
                 size: Number(metadata.size),
                 updatedAt: metadata.updated,
             };
-        }));
+        }
+        catch (err) {
+            void normalizeError(err);
+            serverLogger.error("storage-provider: copy failed", {
+                from,
+                to,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+    },
+    async list(prefix) {
+        try {
+            const bucket = getBucket();
+            const [files] = await withRetry(() => bucket.getFiles({ prefix }), 2, 300);
+            return Promise.all(files.map(async (f) => {
+                const [metadata] = await withRetry(() => f.getMetadata(), 2, 300);
+                return {
+                    path: f.name,
+                    url: `https://storage.googleapis.com/${bucket.name}/${f.name}`,
+                    contentType: metadata.contentType,
+                    size: Number(metadata.size),
+                    updatedAt: metadata.updated,
+                };
+            }));
+        }
+        catch (err) {
+            void normalizeError(err);
+            serverLogger.error("storage-provider: list failed", {
+                prefix,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohasinac/appkit",
-  "version": "3.2.9",
+  "version": "3.2.11",
   "license": "MIT",
   "publishConfig": {
     "access": "public"