@mohasinac/appkit 2.6.3 → 2.6.4

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

@@ -0,0 +1,138 @@
+/**
+ * Core: server-to-server listing proxy. Every appkit repository routes its
+ * `.list()` through the same Sieve adapter, so adding a new collection is a
+ * one-line addition to `LISTERS`.
+ *
+ * Cursor: opaque base64 over `{ page }`. Callers may use either page-mode
+ * (`p` directly) or infinite-mode (forward `cursor` from previous response).
+ */
+import { bidRepository, blogRepository, categoriesRepository, couponsRepository, eventEntryRepository, eventRepository, faqsRepository, homepageSectionsRepository, notificationRepository, orderRepository, payoutRepository, productFeaturesRepository, productRepository, productTemplateRepository, reviewRepository, scammerRepository, storeRepository, userRepository, } from "../../../../repositories";
+const DEFAULT_SORT = "-createdAt";
+const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+class ListingError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.name = "ListingError";
+        this.httpStatus = status;
+    }
+}
+function requireOpt(baseOpts, key, collection) {
+    const value = baseOpts[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ListingError(400, `${collection} listing requires baseOpts.${key}`);
+    }
+    return value;
+}
+function getBoolOpt(baseOpts, key, fallback) {
+    const value = baseOpts[key];
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return fallback;
+}
+const LISTERS = {
+    products: (m, o) => productRepository.list(m, o),
+    categories: (m) => categoriesRepository.list(m),
+    brands: (m) => categoriesRepository.list({
+        ...m,
+        filters: m.filters
+            ? `${m.filters},categoryType==brand`
+            : "categoryType==brand",
+    }),
+    orders: (m) => orderRepository.listAll(m),
+    reviews: (m) => reviewRepository.listAll(m),
+    coupons: (m) => couponsRepository.list(m),
+    bids: (m) => bidRepository.list(m),
+    payouts: (m) => payoutRepository.list(m),
+    blogPosts: (m) => blogRepository.listAll(m),
+    events: (m) => eventRepository.list(m),
+    faqs: (m) => faqsRepository.list(m),
+    notifications: (m) => notificationRepository.list(m),
+    scammers: (m) => scammerRepository.listAll(m),
+    sublistingCategories: (m) => categoriesRepository.list({
+        ...m,
+        filters: m.filters
+            ? `${m.filters},categoryType==sublisting`
+            : "categoryType==sublisting",
+    }),
+    productFeatures: (m) => productFeaturesRepository.list(m),
+    homepageSections: (m) => homepageSectionsRepository.list(m),
+    users: (m) => userRepository.list(m),
+    stores: (m, o) => storeRepository.listStores(m, getBoolOpt(o, "activeOnly", true)),
+    eventEntries: (m, o) => {
+        const eventId = requireOpt(o, "eventId", "eventEntries");
+        return eventEntryRepository.listForEvent(eventId, m);
+    },
+    productTemplates: (m, o) => {
+        const storeId = requireOpt(o, "storeId", "productTemplates");
+        return productTemplateRepository.listByStore(storeId, m);
+    },
+};
+const SUPPORTED_COLLECTIONS = Object.keys(LISTERS);
+function decodeCursor(cursor) {
+    if (!cursor)
+        return null;
+    try {
+        const json = Buffer.from(cursor, "base64").toString("utf8");
+        const parsed = JSON.parse(json);
+        const page = Number(parsed.page);
+        return Number.isFinite(page) && page > 0 ? page : null;
+    }
+    catch {
+        return null;
+    }
+}
+function encodeCursor(page) {
+    return Buffer.from(JSON.stringify({ page }), "utf8").toString("base64");
+}
+function clampPageSize(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_PAGE_SIZE;
+    return Math.min(Math.floor(n), MAX_PAGE_SIZE);
+}
+function clampPage(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1)
+        return DEFAULT_PAGE;
+    return Math.floor(n);
+}
+export async function runListingProcessor(body, ctx) {
+    if (!body || typeof body.collection !== "string") {
+        throw new ListingError(400, "Missing collection");
+    }
+    const lister = LISTERS[body.collection];
+    if (!lister) {
+        throw new ListingError(400, `Unsupported collection: ${body.collection}. Supported: ${SUPPORTED_COLLECTIONS.join(",")}`);
+    }
+    const cursorPage = decodeCursor(body.cursor);
+    const page = cursorPage ?? clampPage(body.p);
+    const pageSize = clampPageSize(body.ps);
+    const result = await lister({
+        filters: body.f ?? "",
+        sorts: body.s ?? DEFAULT_SORT,
+        page: String(page),
+        pageSize: String(pageSize),
+    }, body.baseOpts ?? {});
+    ctx.logger.info("listing served", {
+        collection: body.collection,
+        page: result.page,
+        pageSize: result.pageSize,
+        total: result.total,
+    });
+    return {
+        items: result.items,
+        total: result.total,
+        page: result.page,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+        hasMore: result.hasMore,
+        cursor: result.hasMore ? encodeCursor(result.page + 1) : null,
+    };
+}
+export const supportedListingCollections = SUPPORTED_COLLECTIONS;

package/dist/_internal/server/jobs/core/mediaTmpCleanup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Core: media tmp cleanup.
+ *
+ * Sweeps Firebase Storage for stale objects under the tmp/ prefix. Layer 2 of
+ * the dual-layer scheme — Layer 1 is the form-level onAbort() DELETE call;
+ * this job mops up anything that escaped (crashes, expired sessions).
+ *
+ * Safety invariants:
+ *  - Only touches objects whose name starts with `tmp/`.
+ *  - Only deletes objects older than `ttlHours` (default 24).
+ *  - Idempotent: 404s on delete are swallowed (Layer 1 already removed it).
+ */
+import type { JobContext } from "../runtime/types";
+export declare function runMediaTmpCleanup(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,68 @@
+/**
+ * Core: media tmp cleanup.
+ *
+ * Sweeps Firebase Storage for stale objects under the tmp/ prefix. Layer 2 of
+ * the dual-layer scheme — Layer 1 is the form-level onAbort() DELETE call;
+ * this job mops up anything that escaped (crashes, expired sessions).
+ *
+ * Safety invariants:
+ *  - Only touches objects whose name starts with `tmp/`.
+ *  - Only deletes objects older than `ttlHours` (default 24).
+ *  - Idempotent: 404s on delete are swallowed (Layer 1 already removed it).
+ */
+import { getAdminStorageLite } from "../../../../providers/db-firebase/admin-storage-lite";
+const TMP_PREFIX = "tmp/";
+const DEFAULT_TTL_HOURS = 24;
+function getBucket() {
+    const bucketName = process.env.FIREBASE_ADMIN_STORAGE_BUCKET?.trim() ??
+        process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET?.trim();
+    return bucketName ? getAdminStorageLite().bucket(bucketName) : getAdminStorageLite().bucket();
+}
+export async function runMediaTmpCleanup(ctx) {
+    const ttlHours = Number(ctx.env("MEDIA_TMP_TTL_HOURS") ?? DEFAULT_TTL_HOURS);
+    const cutoff = new Date(Date.now() - ttlHours * 60 * 60 * 1000);
+    ctx.logger.info("Starting media tmp cleanup", { prefix: TMP_PREFIX, ttlHours });
+    let scanned = 0;
+    let deleted = 0;
+    let skipped = 0;
+    let errors = 0;
+    try {
+        const bucket = getBucket();
+        const [files] = await bucket.getFiles({ prefix: TMP_PREFIX, autoPaginate: true });
+        scanned = files.length;
+        ctx.logger.info("Objects under tmp prefix", { count: scanned });
+        for (const file of files) {
+            try {
+                if (!file.name.startsWith(TMP_PREFIX)) {
+                    skipped++;
+                    continue;
+                }
+                const [metadata] = await file.getMetadata();
+                const updated = metadata.updated ?? metadata.timeCreated;
+                if (!updated) {
+                    skipped++;
+                    continue;
+                }
+                if (new Date(updated) >= cutoff) {
+                    skipped++;
+                    continue;
+                }
+                await file.delete();
+                deleted++;
+            }
+            catch (fileError) {
+                errors++;
+                const code = fileError?.code;
+                if (code === 404) {
+                    continue;
+                }
+                ctx.logger.error("Failed to delete tmp file", fileError, { name: file.name });
+            }
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Fatal error during media tmp cleanup", err);
+        throw err;
+    }
+    ctx.logger.info("Media tmp cleanup complete", { scanned, deleted, skipped, errors });
+}

package/dist/_internal/server/jobs/core/notificationPrune.d.ts

@@ -0,0 +1,2 @@
+import type { JobContext } from "../runtime/types";
+export declare function runNotificationPrune(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { notificationRepository } from "../../../../repositories";
+import { NOTIFICATION_TTL_DAYS } from "../handlers/messages";
+import { batchDelete } from "../handlers/_helpers";
+export async function runNotificationPrune(ctx) {
+    ctx.logger.info(`Pruning read notifications older than ${NOTIFICATION_TTL_DAYS} days`);
+    const refs = await notificationRepository.getOldReadRefs(NOTIFICATION_TTL_DAYS);
+    if (refs.length === 0) {
+        ctx.logger.info("No stale read notifications found");
+        return;
+    }
+    const deleted = await batchDelete(ctx, refs);
+    ctx.logger.info("Notification prune complete", { deleted });
+}

package/dist/_internal/server/jobs/core/offerExpiry.d.ts

@@ -0,0 +1,2 @@
+import type { JobContext } from "../runtime/types";
+export declare function runOfferExpiry(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,50 @@
+import { offerRepository, notificationRepository } from "../../../../repositories";
+export async function runOfferExpiry(ctx) {
+    ctx.logger.info("Starting offer expiry sweep");
+    let expiredOffers;
+    try {
+        expiredOffers = await offerRepository.findExpiredActive(ctx.now);
+    }
+    catch (err) {
+        ctx.logger.error("Failed to query expired offers", err);
+        throw err;
+    }
+    if (expiredOffers.length === 0) {
+        ctx.logger.info("No expired offers found");
+        return;
+    }
+    ctx.logger.info(`Found ${expiredOffers.length} expired offer(s) to process`);
+    const expiredIds = [];
+    for (const offer of expiredOffers) {
+        try {
+            expiredIds.push(offer.id);
+            await notificationRepository.create({
+                userId: offer.buyerUid,
+                type: "offer_expired",
+                priority: "normal",
+                title: "Offer expired",
+                message: `Your offer on "${offer.productTitle}" expired without a response.`,
+                relatedId: offer.id,
+                relatedType: "offer",
+            });
+        }
+        catch (err) {
+            ctx.logger.warn(`Failed to process expiry for offer ${offer.id}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    if (expiredIds.length > 0) {
+        try {
+            await offerRepository.expireMany(expiredIds);
+        }
+        catch (err) {
+            ctx.logger.error("Failed to batch-expire offers", err);
+            throw err;
+        }
+    }
+    ctx.logger.info("Offer expiry complete", {
+        processed: expiredIds.length,
+        skipped: expiredOffers.length - expiredIds.length,
+    });
+}

package/dist/_internal/server/jobs/core/onBidPlaced.d.ts

@@ -0,0 +1,15 @@
+import type { JobContext } from "../runtime/types";
+export interface NewBid {
+    id: string;
+    productId: string;
+    productTitle: string;
+    userId: string;
+    userName: string;
+    bidAmount: number;
+    currency: string;
+}
+export interface HandleBidPlacedInput {
+    bidId: string;
+    bid: NewBid;
+}
+export declare function handleBidPlaced(input: HandleBidPlacedInput, ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,59 @@
+import { bidRepository, notificationRepository, productRepository, } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { BID_MESSAGES } from "../handlers/messages";
+const BIDS_COLLECTION = "bids";
+export async function handleBidPlaced(input, ctx) {
+    const { bidId, bid: newBid } = input;
+    newBid.userName = decryptPii(newBid.userName);
+    try {
+        const prevWinning = await bidRepository.getWinningBid(newBid.productId);
+        const batch = ctx.db.batch();
+        const newBidRef = ctx.db.collection(BIDS_COLLECTION).doc(bidId);
+        bidRepository.markWinning(batch, newBidRef);
+        let outbidUserId = null;
+        if (prevWinning && prevWinning.data.userId !== newBid.userId) {
+            outbidUserId = prevWinning.data.userId;
+            bidRepository.markOutbid(batch, prevWinning.ref);
+            notificationRepository.createInBatch(batch, {
+                userId: outbidUserId,
+                type: "bid_outbid",
+                priority: "high",
+                title: BID_MESSAGES.OUTBID_TITLE,
+                message: BID_MESSAGES.OUTBID_MESSAGE(newBid.productTitle, newBid.currency, newBid.bidAmount),
+                relatedId: newBid.productId,
+                relatedType: "product",
+            });
+        }
+        productRepository.incrementBidCountInBatch(batch, newBid.productId, newBid.bidAmount);
+        await batch.commit();
+        try {
+            if (outbidUserId) {
+                await getAdminRealtimeDb()
+                    .ref(`notifications/${outbidUserId}`)
+                    .push({
+                    type: "bid_outbid",
+                    title: BID_MESSAGES.OUTBID_TITLE,
+                    message: BID_MESSAGES.OUTBID_MESSAGE(newBid.productTitle, newBid.currency, newBid.bidAmount),
+                    timestamp: Date.now(),
+                    read: false,
+                });
+            }
+        }
+        catch (rtdbError) {
+            ctx.logger.error("Realtime DB push failed (non-fatal)", rtdbError);
+        }
+        ctx.logger.info(`Bid placed on ${newBid.productId}`, {
+            bidId,
+            amount: newBid.bidAmount,
+            outbidUserId,
+        });
+    }
+    catch (error) {
+        ctx.logger.error("Error handling bid placement", error, {
+            bidId,
+            productId: newBid.productId,
+        });
+        throw error;
+    }
+}

package/dist/_internal/server/jobs/core/onCategoryWrite.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Core: maintain DFS `position` + `subtreeSize` on every category write.
+ * CREATE → insert into parent's subtree + shift later siblings;
+ * DELETE → shift back; MOVE → mark `positionDirty` so the nightly reconcile
+ * job rebuilds.
+ */
+import type { JobContext } from "../runtime/types";
+export type CategoryDoc = Record<string, unknown>;
+export interface HandleCategoryWriteInput {
+    categoryId: string;
+    before: CategoryDoc | null;
+    after: CategoryDoc | null;
+}
+export declare function handleCategoryWrite(input: HandleCategoryWriteInput, ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,134 @@
+/**
+ * Core: maintain DFS `position` + `subtreeSize` on every category write.
+ * CREATE → insert into parent's subtree + shift later siblings;
+ * DELETE → shift back; MOVE → mark `positionDirty` so the nightly reconcile
+ * job rebuilds.
+ */
+import { FieldValue } from "firebase-admin/firestore";
+import { BATCH_LIMIT } from "../handlers/messages";
+const CATEGORIES = "categories";
+async function shiftPositions(ctx, threshold, delta, excludeId) {
+    const snap = await ctx.db.collection(CATEGORIES).where("position", ">=", threshold).get();
+    const docs = snap.docs.filter((d) => d.id !== excludeId && d.data().position >= threshold);
+    if (docs.length === 0)
+        return 0;
+    for (let i = 0; i < docs.length; i += BATCH_LIMIT) {
+        const batch = ctx.db.batch();
+        for (const doc of docs.slice(i, i + BATCH_LIMIT)) {
+            batch.update(doc.ref, {
+                position: doc.data().position + delta,
+                updatedAt: new Date(),
+            });
+        }
+        await batch.commit();
+    }
+    return docs.length;
+}
+async function adjustAncestorSubtreeSize(ctx, ancestorIds, delta) {
+    if (ancestorIds.length === 0)
+        return;
+    for (let i = 0; i < ancestorIds.length; i += BATCH_LIMIT) {
+        const batch = ctx.db.batch();
+        for (const id of ancestorIds.slice(i, i + BATCH_LIMIT)) {
+            batch.update(ctx.db.collection(CATEGORIES).doc(id), {
+                subtreeSize: FieldValue.increment(delta),
+                updatedAt: new Date(),
+            });
+        }
+        await batch.commit();
+    }
+}
+async function getMaxPosition(ctx, excludeId) {
+    const snap = await ctx.db
+        .collection(CATEGORIES)
+        .orderBy("position", "desc")
+        .limit(excludeId ? 2 : 1)
+        .get();
+    for (const doc of snap.docs) {
+        if (doc.id === excludeId)
+            continue;
+        return doc.data().position ?? 0;
+    }
+    return 0;
+}
+export async function handleCategoryWrite(input, ctx) {
+    const { categoryId, before, after } = input;
+    const isCreate = !before && !!after;
+    const isDelete = !!before && !after;
+    const isUpdate = !!before && !!after;
+    try {
+        if (isCreate) {
+            const parentIds = after.parentIds ?? [];
+            const parentId = parentIds.length > 0 ? parentIds[parentIds.length - 1] : null;
+            let insertPosition;
+            if (parentId) {
+                const parentSnap = await ctx.db.collection(CATEGORIES).doc(parentId).get();
+                if (!parentSnap.exists) {
+                    ctx.logger.warn("Parent not found, appending at end", { categoryId, parentId });
+                    insertPosition = (await getMaxPosition(ctx, categoryId)) + 1;
+                }
+                else {
+                    const p = parentSnap.data();
+                    const parentPos = p.position ?? 0;
+                    const parentSize = p.subtreeSize ?? 1;
+                    insertPosition = parentPos + parentSize;
+                }
+            }
+            else {
+                insertPosition = (await getMaxPosition(ctx, categoryId)) + 1;
+            }
+            const shifted = await shiftPositions(ctx, insertPosition, +1, categoryId);
+            await ctx.db.collection(CATEGORIES).doc(categoryId).update({
+                position: insertPosition,
+                subtreeSize: 1,
+                updatedAt: new Date(),
+            });
+            await adjustAncestorSubtreeSize(ctx, parentIds, +1);
+            ctx.logger.info("Category created — position assigned", {
+                categoryId,
+                position: insertPosition,
+                parentId,
+                shifted,
+            });
+        }
+        else if (isDelete) {
+            const deletedPos = before.position ?? 0;
+            const deletedSize = before.subtreeSize ?? 1;
+            const parentIds = before.parentIds ?? [];
+            if (deletedPos === 0) {
+                ctx.logger.warn("Deleted category had no position — skipping shift", { categoryId });
+                return;
+            }
+            const shifted = await shiftPositions(ctx, deletedPos + deletedSize, -deletedSize);
+            await adjustAncestorSubtreeSize(ctx, parentIds, -deletedSize);
+            ctx.logger.info("Category deleted — positions shifted", {
+                categoryId,
+                position: deletedPos,
+                subtreeSize: deletedSize,
+                shifted,
+            });
+        }
+        else if (isUpdate) {
+            const beforeParents = before.parentIds ?? [];
+            const afterParents = after.parentIds ?? [];
+            const beforeParent = beforeParents[beforeParents.length - 1] ?? null;
+            const afterParent = afterParents[afterParents.length - 1] ?? null;
+            if (beforeParent !== afterParent) {
+                await ctx.db
+                    .collection(CATEGORIES)
+                    .doc(categoryId)
+                    .update({ positionDirty: true, updatedAt: new Date() });
+                ctx.logger.warn("Category moved — positionDirty flagged for nightly reconcile", {
+                    categoryId,
+                    fromParent: beforeParent,
+                    toParent: afterParent,
+                });
+            }
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Position update failed (non-fatal — will heal on next reconcile)", err, {
+            categoryId,
+        });
+    }
+}

package/dist/_internal/server/jobs/core/onOrderCreate.d.ts

@@ -0,0 +1,18 @@
+import type { JobContext } from "../runtime/types";
+interface OrderItem {
+    title?: string;
+    name?: string;
+}
+export interface NewOrder {
+    buyerDisplayName?: string;
+    buyerId?: string;
+    items?: OrderItem[];
+    totalAmount?: number;
+    storeId?: string;
+}
+export interface HandleOrderCreateInput {
+    orderId: string;
+    order: NewOrder;
+}
+export declare function handleOrderCreate(input: HandleOrderCreateInput, ctx: JobContext): Promise<void>;
+export {};

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

@@ -0,0 +1,78 @@
+import { storeRepository, userRepository } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+import { sendWhatsAppBusinessMessage, buildPurchaseAnnouncementMessage, } from "../../../../features/whatsapp-bot/server";
+async function sendAnnouncement(ctx, toPhone, message, phoneNumberId, accessToken, label, orderId) {
+    try {
+        const sent = await sendWhatsAppBusinessMessage({
+            toPhone,
+            message,
+            phoneNumberId,
+            accessToken,
+        });
+        if (sent) {
+            ctx.logger.info(`Announcement sent to ${label}`, {
+                orderId,
+                toPhone: `...${toPhone.slice(-4)}`,
+            });
+        }
+        else {
+            ctx.logger.error(`Announcement delivery failed for ${label} (non-fatal)`, null, { orderId });
+        }
+    }
+    catch (err) {
+        ctx.logger.error(`Announcement send threw for ${label} (non-fatal)`, err, { orderId });
+    }
+}
+export async function handleOrderCreate(input, ctx) {
+    const { orderId, order } = input;
+    const phoneNumberId = ctx.env("WHATSAPP_PHONE_NUMBER_ID") ?? "";
+    const accessToken = ctx.env("WHATSAPP_CLOUD_API_TOKEN") ?? "";
+    if (!phoneNumberId || !accessToken) {
+        ctx.logger.info("WhatsApp Cloud API not configured — skipping announcement", { orderId });
+        return;
+    }
+    const items = order.items ?? [];
+    const firstItem = items[0];
+    const firstItemName = firstItem?.title ?? firstItem?.name ?? "an item";
+    const additionalItemCount = Math.max(0, items.length - 1);
+    const buyerName = order.buyerDisplayName ?? "A customer";
+    const message = buildPurchaseAnnouncementMessage({
+        buyerName,
+        firstItemName,
+        additionalItemCount,
+        totalAmount: order.totalAmount ?? 0,
+        orderId,
+    });
+    const adminNumbersRaw = ctx.env("WHATSAPP_ADMIN_NOTIFY_NUMBERS") ?? "";
+    const adminNumbers = adminNumbersRaw
+        .split(",")
+        .map((n) => n.trim().replace(/\D/g, ""))
+        .filter(Boolean);
+    for (const num of adminNumbers) {
+        await sendAnnouncement(ctx, num, message, phoneNumberId, accessToken, "admin", orderId);
+    }
+    const storeId = order.storeId;
+    if (storeId) {
+        try {
+            const store = await storeRepository.findBySlug(storeId);
+            if (store?.ownerId) {
+                const owner = await userRepository.findById(store.ownerId);
+                const encryptedPhone = owner?.phoneNumber;
+                if (encryptedPhone) {
+                    const ownerPhone = decryptPii(encryptedPhone);
+                    if (ownerPhone) {
+                        await sendAnnouncement(ctx, ownerPhone, message, phoneNumberId, accessToken, "store-owner", orderId);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            ctx.logger.error("Store owner lookup failed (non-fatal)", err, { orderId, storeId });
+        }
+    }
+    ctx.logger.info(`Order announcement complete`, {
+        orderId,
+        adminCount: adminNumbers.length,
+        storeId: storeId ?? "unknown",
+    });
+}

package/dist/_internal/server/jobs/core/onOrderStatusChange.d.ts

@@ -0,0 +1,19 @@
+import type { JobContext } from "../runtime/types";
+type OrderStatus = "pending" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned";
+export type OrderAfter = {
+    status: OrderStatus;
+    userId: string;
+    userEmail: string;
+    productTitle: string;
+    trackingNumber?: string;
+};
+export type OrderBefore = {
+    status: OrderStatus;
+};
+export interface HandleOrderStatusChangeInput {
+    orderId: string;
+    before: OrderBefore | null;
+    after: OrderAfter | null;
+}
+export declare function handleOrderStatusChange(input: HandleOrderStatusChangeInput, ctx: JobContext): Promise<void>;
+export {};