dgc-core 2.0.4 → 2.0.7

package/dist/giveaways/giveaway-repository.js

@@ -9,6 +9,7 @@ const node_crypto_1 = require("node:crypto");
 const mongodb_1 = require("mongodb");
 const entry_id_1 = require("./entry-id");
 const api_pagination_1 = require("./api-pagination");
+const eligibility_1 = require("./eligibility");
 const domain_1 = require("./domain");
 const schemas_1 = require("./schemas");
 const projection = { entryVersion: 0 };
@@ -30,6 +31,9 @@ function normalizeEntry(record) {
     delete fields.username;
     return { ...fields, name: record.name ?? legacy.fullName ?? '' };
 }
+function normalizeCountries(record) {
+    return record.category === giveaway_2.GiveawayCategory.Credits ? { ...record, countries: [] } : record;
+}
 function pagination(params) {
     const integer = (key, fallback, max) => {
         const value = Number(params.get(key));
@@ -126,9 +130,10 @@ function filterCategory(filter, params) {
 }
 /** Each method reads only its own records. Transactions contain related writes only. */
 class GiveawayRepository {
-    constructor(db, client) {
+    constructor(db, client, options = {}) {
         this.db = db;
         this.client = client;
+        this.options = options;
     }
     get giveaways() {
         return this.db.collection('giveaways');
@@ -148,6 +153,111 @@ class GiveawayRepository {
     get activity() {
         return this.db.collection('audit');
     }
+    async checkCreditCandidate(entry) {
+        const check = this.options.checkCreditEligibility;
+        if (!check)
+            throw new domain_1.DomainError('RevenueCat entitlement verification is not configured', 503);
+        if (typeof entry.userId !== 'string' ||
+            !entry.userId ||
+            entry.userId.length > 128 ||
+            /[.#$[\]/]/.test(entry.userId))
+            throw new domain_1.DomainError('The entrant has no valid DGC account identity', 503);
+        let evidence;
+        try {
+            evidence = await check(entry.userId);
+        }
+        catch {
+            throw new domain_1.DomainError('Unable to verify active membership. Try again.', 503);
+        }
+        if (evidence === null)
+            return null;
+        if (!evidence ||
+            evidence.userId !== entry.userId ||
+            typeof evidence.entitlementId !== 'string' ||
+            !evidence.entitlementId.trim() ||
+            evidence.entitlementId.length > 255 ||
+            !(0, eligibility_1.isGiveawayMemberEligible)(giveaway_2.GiveawayCategory.Credits, evidence.collectorType) ||
+            typeof evidence.checkedAt !== 'string' ||
+            !Number.isFinite(Date.parse(evidence.checkedAt)) ||
+            Date.parse(evidence.checkedAt) > Date.now() + 5000 ||
+            (evidence.expiresAt !== null &&
+                (typeof evidence.expiresAt !== 'number' || !Number.isFinite(evidence.expiresAt))))
+            throw new domain_1.DomainError('Unable to verify active membership. Try again.', 503);
+        this.assertFreshCreditEvidence(evidence);
+        return {
+            userId: evidence.userId,
+            checkedAt: evidence.checkedAt,
+            entitlementId: evidence.entitlementId,
+            collectorType: evidence.collectorType,
+            expiresAt: evidence.expiresAt
+        };
+    }
+    assertFreshCreditEvidence(evidence) {
+        if (Date.now() - Date.parse(evidence.checkedAt) > 60000 ||
+            (evidence.expiresAt !== null && evidence.expiresAt <= Date.now()))
+            throw new domain_1.DomainError('Entitlement verification expired. Review and try again.', 409);
+    }
+    assertVerifiedCreditCandidate(g, reviewed, entry, verified) {
+        if (g.category !== reviewed.category || g.revision !== reviewed.revision)
+            throw new domain_1.DomainError('Giveaway changed. Review the selection again.', 409);
+        if (g.category !== giveaway_2.GiveawayCategory.Credits)
+            return;
+        if (!verified || verified.entryId !== entry._id || verified.evidence.userId !== entry.userId)
+            throw new domain_1.DomainError('Active membership must be verified before awarding credits', 503);
+        this.assertFreshCreditEvidence(verified.evidence);
+    }
+    async verifiedCreditSelection(g, input) {
+        if ((0, domain_1.effectiveStatus)(g) !== giveaway_2.GiveawayStatus.Closed)
+            throw new domain_1.DomainError('Close entries before selecting a winner', 409);
+        if (g.revision !== input.revision)
+            throw new domain_1.DomainError('Giveaway changed. Refresh before selecting.', 409);
+        if (g.selection ||
+            (await this.winners.findOne({ giveawayId: g._id, replacedAt: null }, { projection: { _id: 1 } })))
+            throw new domain_1.DomainError('A winner is already selected. Explicitly reset the selection to change it.', 409);
+        const maxAttempts = this.options.creditWinnerMaxAttempts ?? 5;
+        if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 100)
+            throw new domain_1.DomainError('Credit winner attempts must be an integer between 1 and 100', 503);
+        const tiers = (0, eligibility_1.giveawayEligibleCollectorTypes)(giveaway_2.GiveawayCategory.Credits);
+        const rejected = [];
+        const deadline = Date.now() + 30000;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (Date.now() >= deadline)
+                throw new domain_1.DomainError('Membership verification is taking too long. Try the draw again.', 503);
+            const eligible = {
+                giveawayId: g._id,
+                _collectorType: { $in: [...tiers] },
+                ...(rejected.length > 0 && { _id: { $nin: rejected } })
+            };
+            const count = await this.entries.countDocuments(eligible, {});
+            if (!count)
+                throw new domain_1.DomainError('This giveaway has no entries with an active eligible entitlement', 409);
+            const entry = input.method === giveaway_2.GiveawaySelectionMethod.Manual
+                ? await this.entries.findOne({ ...eligible, _id: input.entryId }, {})
+                : await this.entries
+                    .find(eligible, {
+                    projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 }
+                })
+                    .sort({ _id: 1 })
+                    .skip((0, node_crypto_1.randomInt)(count))
+                    .limit(1)
+                    .next();
+            if (!entry)
+                throw new domain_1.DomainError('Select a valid entry in this giveaway', 422);
+            if (!(0, eligibility_1.isGiveawayMemberEligible)(g.category, entry._collectorType))
+                throw new domain_1.DomainError('This entry is not eligible for the giveaway prize', 403);
+            const evidence = await this.checkCreditCandidate(entry);
+            if (Date.now() >= deadline)
+                throw new domain_1.DomainError('Membership verification is taking too long. Try the draw again.', 503);
+            if (evidence)
+                return { entryId: entry._id, evidence, skipped: rejected.length };
+            if (input.method === giveaway_2.GiveawaySelectionMethod.Manual)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            rejected.push(entry._id);
+            if (count === 1)
+                throw new domain_1.DomainError('This giveaway has no entries with an active eligible entitlement', 409);
+        }
+        throw new domain_1.DomainError(`No verified winner found after checking ${maxAttempts} candidate${maxAttempts === 1 ? '' : 's'}. Try the draw again.`, 503);
+    }
     async transaction(operation) {
         const session = this.client.startSession();
         try {
@@ -173,7 +283,7 @@ class GiveawayRepository {
         const giveaway = await this.giveaways.findOne({ _id: objectId(id) }, { session, projection });
         if (!giveaway)
             throw new domain_1.DomainError('Giveaway not found', 404);
-        return serialize(giveaway);
+        return normalizeCountries(serialize(giveaway));
     }
     async getPublicGiveaway(id) {
         const g = await this.getGiveaway(id);
@@ -224,7 +334,7 @@ class GiveawayRepository {
             totalCount: total,
             data: rows.map(row => {
                 const g = row;
-                return { ...g, status: (0, domain_1.effectiveStatus)(g) };
+                return { ...normalizeCountries(g), status: (0, domain_1.effectiveStatus)(g) };
             })
         };
     }
@@ -240,7 +350,13 @@ class GiveawayRepository {
         if (country && country !== 'all')
             filter.$and = [
                 ...(filter.$and || []),
-                { $or: [{ countries: country }, { countries: { $size: 0 } }] }
+                {
+                    $or: [
+                        { category: giveaway_2.GiveawayCategory.Credits },
+                        { countries: country },
+                        { countries: { $size: 0 } }
+                    ]
+                }
             ];
         const sort = params.get('sort') || 'recent';
         const order = sort === 'closing'
@@ -259,7 +375,7 @@ class GiveawayRepository {
             this.giveaways.countDocuments(filter)
         ]);
         return {
-            data: rows.map(g => ({ ...g, status: (0, domain_1.effectiveStatus)(g) })),
+            data: rows.map(g => ({ ...normalizeCountries(g), status: (0, domain_1.effectiveStatus)(g) })),
             total,
             page,
             limit
@@ -570,6 +686,49 @@ class GiveawayRepository {
                 { $sort: { _id: -1 } },
                 { $skip: skip },
                 { $limit: limit },
+                {
+                    $lookup: {
+                        from: 'notification_deliveries',
+                        let: { notification: { $toString: '$_id' } },
+                        pipeline: [
+                            { $match: { $expr: { $eq: ['$notificationId', '$$notification'] } } },
+                            {
+                                $group: {
+                                    _id: null,
+                                    queued: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Queued] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    },
+                                    skipped: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Skipped] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    },
+                                    pending: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Pending] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    }
+                                }
+                            },
+                            { $project: { _id: 0, queued: 1, skipped: 1, pending: 1 } }
+                        ],
+                        as: 'deliveryTotals'
+                    }
+                },
                 {
                     $lookup: {
                         from: 'giveaways',
@@ -585,10 +744,13 @@ class GiveawayRepository {
                     $set: {
                         giveawayTitle: {
                             $ifNull: [{ $first: '$campaign.title' }, '$giveawayId']
+                        },
+                        deliveryCounts: {
+                            $ifNull: [{ $first: '$deliveryTotals' }, { queued: 0, skipped: 0, pending: 0 }]
                         }
                     }
                 },
-                { $unset: ['campaign', 'claimToken'] },
+                { $unset: ['campaign', 'claimToken', 'deliveryTotals'] },
                 stringId
             ])
                 .toArray(),
@@ -732,6 +894,20 @@ class GiveawayRepository {
     }
     async confirmWinners(actor, id, raw) {
         const input = schemas_1.assignmentsSchema.parse(raw);
+        const reviewed = await this.getGiveaway(id);
+        let verified;
+        if (reviewed.category === giveaway_2.GiveawayCategory.Credits) {
+            const rows = await this.entries
+                .find({ giveawayId: id, _id: { $in: input.assignments.map(a => a.entryId) } }, { projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } })
+                .limit(1)
+                .toArray();
+            const existing = await this.winners.findOne({ giveawayId: id, replacedAt: null }, { projection: { _id: 1 } });
+            (0, domain_1.confirmWinners)(reviewed, rows, !!existing, actor, input);
+            const evidence = await this.checkCreditCandidate(rows[0]);
+            if (!evidence)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            verified = { entryId: rows[0]._id, evidence, skipped: 0 };
+        }
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             const rows = await this.entries
@@ -740,17 +916,25 @@ class GiveawayRepository {
                 _id: { $in: input.assignments.map(a => a.entryId) }
             }, {
                 session,
-                projection: { _id: 1, userId: 1, giveawayId: 1 }
+                projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 }
             })
                 .limit(1000)
                 .toArray();
             const entries = rows;
             const existing = await this.winners.findOne({ giveawayId: id, replacedAt: null }, { session, projection: { _id: 1 } });
             const winners = (0, domain_1.confirmWinners)(g, entries, !!existing, actor, input);
+            this.assertVerifiedCreditCandidate(g, reviewed, entries[0], verified);
+            if (verified)
+                winners[0].creditEligibility = verified.evidence;
             await this.updateGiveaway({ ...g, status: giveaway_2.GiveawayStatus.AwaitingClaim, revision: g.revision + 1 }, g.revision, session);
             const result = await this.winners.insertMany(winners.map(winner => ({ ...winner })), { session });
-            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedIds[0].toHexString(), session);
-            await this.audit(actor, 'Winners confirmed', id, winners.length + ' prize assignments', session);
+            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedIds[0].toHexString(), session, winners[0].claimDeadline);
+            await this.audit(actor, 'Winners confirmed', id, verified
+                ? JSON.stringify({
+                    prizeAssignments: winners.length,
+                    creditEligibility: verified.evidence
+                })
+                : winners.length + ' prize assignments', session);
             return winners.map((winner, index) => ({
                 ...winner,
                 _id: result.insertedIds[index].toHexString()
@@ -758,22 +942,52 @@ class GiveawayRepository {
         });
     }
     async replaceWinner(actor, id, winnerId, replacementEntryId, reason) {
+        const reviewed = await this.getGiveaway(id);
+        let verified;
+        if (reviewed.category === giveaway_2.GiveawayCategory.Credits) {
+            const previous = await this.winners.findOne({
+                _id: objectId(winnerId),
+                giveawayId: id,
+                replacedAt: null
+            });
+            const entry = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } });
+            if (!previous || !entry)
+                throw new domain_1.DomainError('Winner or entrant not found', 404);
+            const existing = await this.winners.findOne({ giveawayId: id, entryId: replacementEntryId, replacedAt: null }, { projection: { _id: 1 } });
+            (0, domain_1.replaceWinner)(reviewed, serialize(previous), entry, !!existing, actor, reason);
+            const evidence = await this.checkCreditCandidate(entry);
+            if (!evidence)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            verified = { entryId: entry._id, evidence, skipped: 0 };
+        }
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             const previousWinner = await this.winners.findOne({ _id: objectId(winnerId), giveawayId: id, replacedAt: null }, { session });
-            const entrant = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { session, projection: { _id: 1, giveawayId: 1 } });
+            const entrant = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { session, projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } });
             if (!previousWinner || !entrant)
                 throw new domain_1.DomainError('Winner or entrant not found', 404);
             const old = serialize(previousWinner);
             const entry = entrant;
             const existing = await this.winners.findOne({ giveawayId: id, entryId: replacementEntryId, replacedAt: null }, { session, projection: { _id: 1 } });
             const { previous, replacement } = (0, domain_1.replaceWinner)(g, old, entry, !!existing, actor, reason);
+            this.assertVerifiedCreditCandidate(g, reviewed, entry, verified);
+            replacement.userId = entry.userId;
+            if (verified) {
+                replacement.creditEligibility = verified.evidence;
+                replacement.selection.creditEligibility = verified.evidence;
+            }
             await this.updateGiveaway({ ...g, status: giveaway_2.GiveawayStatus.AwaitingClaim, revision: g.revision + 1 }, g.revision, session);
             const { _id, ...previousFields } = previous;
             await this.winners.updateOne({ _id: objectId(_id), replacedAt: null }, { $set: previousFields }, { session });
             const result = await this.winners.insertOne({ ...replacement }, { session });
-            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedId.toHexString(), session);
-            await this.audit(actor, 'Winner replaced', id, old._id + ': ' + reason.trim(), session);
+            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedId.toHexString(), session, replacement.claimDeadline);
+            await this.audit(actor, 'Winner replaced', id, verified
+                ? JSON.stringify({
+                    previousWinnerId: old._id,
+                    reason: reason.trim(),
+                    creditEligibility: verified.evidence
+                })
+                : old._id + ': ' + reason.trim(), session);
             return { ...replacement, _id: result.insertedId.toHexString() };
         });
     }
@@ -809,7 +1023,7 @@ class GiveawayRepository {
             return winner;
         });
     }
-    async enqueueEvent(g, kind, eventKey, session) {
+    async enqueueEvent(g, kind, eventKey, session, expiresAt) {
         const copy = g.reminders?.[kind];
         if (!copy?.enabled)
             return;
@@ -819,6 +1033,11 @@ class GiveawayRepository {
                 eventKey,
                 kind,
                 audience: giveaway_2.GiveawayNotificationAudience.Entrants,
+                category: g.category,
+                expiresAt: kind === giveaway_2.GiveawayNotificationKind.Closing
+                    ? g.closesAt
+                    : expiresAt ||
+                        new Date(Date.now() + (g.claimWindowDays || 14) * 86400000).toISOString(),
                 title: copy.title,
                 message: copy.message,
                 status: giveaway_2.GiveawayNotificationStatus.Pending,
@@ -828,6 +1047,10 @@ class GiveawayRepository {
     }
     async selectWinner(actor, id, raw) {
         const input = schemas_1.selectionSchema.parse(raw);
+        const reviewed = await this.getGiveaway(id);
+        const verified = reviewed.category === giveaway_2.GiveawayCategory.Credits
+            ? await this.verifiedCreditSelection(reviewed, input)
+            : undefined;
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             if ((0, domain_1.effectiveStatus)(g) !== giveaway_2.GiveawayStatus.Closed)
@@ -837,29 +1060,47 @@ class GiveawayRepository {
             if (g.selection ||
                 (await this.winners.findOne({ giveawayId: id, replacedAt: null }, { session })))
                 throw new domain_1.DomainError('A winner is already selected. Explicitly reset the selection to change it.', 409);
-            const count = await this.entries.countDocuments({ giveawayId: id }, { session });
+            const collectorTypes = (0, eligibility_1.giveawayEligibleCollectorTypes)(g.category);
+            const eligible = {
+                giveawayId: id,
+                ...(collectorTypes !== null && { _collectorType: { $in: [...collectorTypes] } })
+            };
+            const count = verified ? 1 : await this.entries.countDocuments(eligible, { session });
             if (!count)
                 throw new domain_1.DomainError('This giveaway has no eligible entries', 409);
-            const entry = input.method === giveaway_2.GiveawaySelectionMethod.Manual
-                ? await this.entries.findOne({ giveawayId: id, _id: input.entryId }, { session })
+            const candidateId = verified?.entryId ||
+                (input.method === giveaway_2.GiveawaySelectionMethod.Manual ? input.entryId : undefined);
+            const entry = candidateId
+                ? await this.entries.findOne({ ...eligible, _id: candidateId }, { session })
                 : await this.entries
-                    .find({ giveawayId: id }, { session })
+                    .find(eligible, { session })
                     .sort({ _id: 1 })
                     .skip((0, node_crypto_1.randomInt)(count))
                     .limit(1)
                     .next();
             if (!entry)
                 throw new domain_1.DomainError('Select a valid entry in this giveaway', 422);
+            if (!(0, eligibility_1.isGiveawayMemberEligible)(g.category, entry._collectorType))
+                throw new domain_1.DomainError('This entry is not eligible for the giveaway prize', 403);
+            this.assertVerifiedCreditCandidate(g, reviewed, entry, verified);
             const selection = {
                 entryId: entry._id,
                 method: input.method,
                 reason: input.method === giveaway_2.GiveawaySelectionMethod.Manual ? input.reason : '',
                 selectedBy: actor,
-                selectedAt: new Date().toISOString()
+                selectedAt: new Date().toISOString(),
+                ...(verified && { creditEligibility: verified.evidence })
             };
             const updated = { ...g, selection, revision: g.revision + 1 };
             await this.updateGiveaway(updated, g.revision, session);
-            await this.audit(actor, 'Winner selected: ' + input.method, id, entry._id + (selection.reason ? ': ' + selection.reason : ''), session);
+            await this.audit(actor, 'Winner selected: ' + input.method, id, verified
+                ? JSON.stringify({
+                    entryId: entry._id,
+                    reason: selection.reason,
+                    creditEligibility: verified.evidence,
+                    skippedIneligibleEntries: verified.skipped
+                })
+                : entry._id + (selection.reason ? ': ' + selection.reason : ''), session);
             return { giveaway: updated, entry: normalizeEntry(entry) };
         });
     }
@@ -895,7 +1136,7 @@ class GiveawayRepository {
             .findOne({ _id: objectId(id) }, { session });
         if (!preset)
             throw new domain_1.DomainError('Preset not found', 404);
-        return serialize(preset);
+        return normalizeCountries(serialize(preset));
     }
     async listPresets() {
         return (await this.db
@@ -903,7 +1144,7 @@ class GiveawayRepository {
             .find({})
             .sort({ name: 1 })
             .limit(100)
-            .toArray()).map(serialize);
+            .toArray()).map(preset => normalizeCountries(serialize(preset)));
     }
     async installCreditPresets(actor) {
         const now = new Date().toISOString();
@@ -921,7 +1162,7 @@ class GiveawayRepository {
                     category: giveaway_2.GiveawayCategory.Credits,
                     creditAmount: amount,
                     countries: [],
-                    rules: 'One ticket per DGC account. All members have equal chances. One winner. The winner must claim within the stated claim window.',
+                    rules: 'One ticket per eligible DGC account. Eligible members have equal chances. One winner. The winner must claim within the stated claim window.',
                     deliveryInformation: '',
                     revision: 1,
                     createdAt: now,
@@ -1006,7 +1247,7 @@ class GiveawayRepository {
         };
     }
     async getUserClaim(giveawayId, userId) {
-        const entry = await this.entries.findOne({ giveawayId, userId }, { projection: { _id: 1 } });
+        const entry = await this.entries.findOne({ giveawayId, userId }, { projection: { _id: 1, name: 1, fullName: 1 } });
         if (!entry)
             throw new domain_1.DomainError('Winning entry not found', 404);
         const winner = await this.winners.findOne({ giveawayId, entryId: entry._id, replacedAt: null });
@@ -1027,7 +1268,14 @@ class GiveawayRepository {
             tracking: value.tracking,
             dispatchedAt: value.dispatchedAt,
             creditedAt: value.creditedAt,
-            claimExpired: !value.claimedAt && !!value.claimDeadline && new Date(value.claimDeadline) <= new Date()
+            claimExpired: !value.claimedAt && !!value.claimDeadline && new Date(value.claimDeadline) <= new Date(),
+            ...(value.category === giveaway_2.GiveawayCategory.Products
+                ? {
+                    defaults: {
+                        fullName: value.claim?.fullName ?? normalizeEntry(entry).name
+                    }
+                }
+                : {})
         };
     }
     async claimPrize(giveawayId, userId, raw) {
@@ -1036,7 +1284,7 @@ class GiveawayRepository {
             const entry = await this.entries.findOne({ giveawayId, userId }, { session });
             const winner = entry &&
                 (await this.winners.findOne({ giveawayId, entryId: entry._id, replacedAt: null }, { session }));
-            if (!winner)
+            if (!entry || !winner)
                 throw new domain_1.DomainError('Winning entry not found', 404);
             if (!Object.values(giveaway_2.GiveawayCategory).includes(winner.category))
                 throw new domain_1.DomainError('Invalid giveaway category', 409);
@@ -1048,7 +1296,15 @@ class GiveawayRepository {
                 throw new domain_1.DomainError('The claim window has closed', 409);
             if (winner.category === giveaway_2.GiveawayCategory.Credits)
                 schemas_1.creditClaimSchema.parse(raw);
-            const claim = winner.category === giveaway_2.GiveawayCategory.Products ? schemas_1.physicalClaimSchema.parse(raw) : undefined;
+            const input = winner.category === giveaway_2.GiveawayCategory.Products ? schemas_1.physicalClaimSchema.parse(raw) : undefined;
+            const claim = input
+                ? {
+                    ...input,
+                    fullName: schemas_1.physicalClaimSchema.shape.fullName
+                        .unwrap()
+                        .parse(input.fullName ?? normalizeEntry(entry).name)
+                }
+                : undefined;
             if (claim && g.countries.length && !g.countries.includes(claim.address.country))
                 throw new domain_1.DomainError('This delivery country is not eligible', 422);
             const fields = {
@@ -1060,6 +1316,17 @@ class GiveawayRepository {
                 ...(claim ? { claim } : {})
             };
             await this.winners.updateOne({ _id: winner._id, replacedAt: null }, { $set: fields }, { session });
+            if (claim) {
+                const savedEntry = await this.entries.updateOne({ _id: entry._id, giveawayId, userId }, {
+                    $set: {
+                        deliveryName: claim.fullName,
+                        address: claim.address,
+                        contactNumber: claim.contactNumber
+                    }
+                }, { session });
+                if (!savedEntry.matchedCount)
+                    throw new domain_1.DomainError('Winning entry changed. Please check your claim status.', 409);
+            }
             await this.updateGiveaway({ ...g, revision: g.revision + 1 }, g.revision, session);
             await this.audit(userId, 'Prize claimed', giveawayId, winner._id.toHexString(), session);
             return { ...serialize(winner), ...fields };
@@ -1228,7 +1495,11 @@ class GiveawayRepository {
             const now = new Date().toISOString();
             const updated = await this.notifications.updateOne(filter, successful
                 ? {
-                    $set: { status: giveaway_2.GiveawayNotificationStatus.Sent, sentAt: now },
+                    $set: {
+                        status: giveaway_2.GiveawayNotificationStatus.Sent,
+                        sentAt: now,
+                        dispatchCompletedAt: now
+                    },
                     $unset: { error: '', claimToken: '' }
                 }
                 : {
@@ -1245,7 +1516,8 @@ class GiveawayRepository {
         });
     }
     async exportEntries(actor, id, marketingOnly) {
-        await this.getGiveaway(id);
+        const giveaway = await this.getGiveaway(id);
+        const includeDelivery = giveaway.category === giveaway_2.GiveawayCategory.Products;
         await this.audit(actor, marketingOnly ? 'Marketing opt-ins export started' : 'Entrants export started', id);
         const pipeline = [
             {
@@ -1270,12 +1542,18 @@ class GiveawayRepository {
                         : [
                             'Name',
                             'Email',
-                            'Address 1',
-                            'Address 2',
-                            'City',
-                            'County / State',
-                            'Postcode / ZIP',
-                            'Country',
+                            ...(includeDelivery
+                                ? [
+                                    'Delivery name',
+                                    'Address 1',
+                                    'Address 2',
+                                    'City',
+                                    'County / State',
+                                    'Postcode / ZIP',
+                                    'Country',
+                                    'Contact number'
+                                ]
+                                : []),
                             'User ID',
                             'Collector type',
                             'Entry time',
@@ -1291,12 +1569,18 @@ class GiveawayRepository {
                         : [
                             e.name,
                             e.email,
-                            e.address?.line1 || '',
-                            e.address?.line2 || '',
-                            e.address?.city || '',
-                            e.address?.region || '',
-                            e.address?.postalCode || '',
-                            e.address?.country || '',
+                            ...(includeDelivery
+                                ? [
+                                    e.deliveryName || '',
+                                    e.address?.line1 || '',
+                                    e.address?.line2 || '',
+                                    e.address?.city || '',
+                                    e.address?.region || '',
+                                    e.address?.postalCode || '',
+                                    e.address?.country || e.country || '',
+                                    e.contactNumber || ''
+                                ]
+                                : []),
                             e.userId,
                             e._collectorType === null ? 'Unknown' : user_1.UserCollectorType[e._collectorType],
                             e.enteredAt,

package/dist/giveaways/index.d.ts

@@ -2,6 +2,7 @@
 export * from './domain';
 export * from './api-pagination';
 export * from './entry-id';
+export * from './eligibility';
 export * from './giveaway-repository';
 export * from './schemas';
 export * from './credit-award';

package/dist/giveaways/index.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./domain"), exports);
 __exportStar(require("./api-pagination"), exports);
 __exportStar(require("./entry-id"), exports);
+__exportStar(require("./eligibility"), exports);
 __exportStar(require("./giveaway-repository"), exports);
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./credit-award"), exports);