@ketvietlab/ketsuite 0.1.2 → 0.1.3

package/dist/modules/loyalty/order-functions.js

@@ -1,8 +1,20 @@
 import { createHash } from 'node:crypto';
-import { defineFn } from '@ketvietlab/ketjs';
+import { and, asc, defineFn, desc, eq, from, gt, gte, ilike, inArray, isNull, lte, or, } from '@ketvietlab/ketjs';
+import { canonicalDecimalText, minorText, moneyMinor, percentOfMinor, scaleOf } from '../account/money.js';
 import { decimal, evaluate, invalid, issue, n, normalizeCode, now, snapshotOf } from './engine.js';
 import { finalizeReservation, InsufficientBalance, LoyaltyConflict, postDelta, release, reserve, walletSummary, } from './ledger.js';
 import { refreshMembershipRow } from './membership-functions.js';
+/**
+ * A page of a list, bounded whether or not the caller asked for one.
+ *
+ * The cap is the point: a screen asks for twenty, an export asks for a thousand,
+ * and nothing gets to ask for the whole table by leaving the argument out.
+ */
+const paged = (query, args) => {
+    const size = Math.min(1000, Math.max(1, n(args.limit ?? 100)));
+    const skip = Math.max(0, n(args.offset ?? 0));
+    return skip ? query.limit(size).offset(skip) : query.limit(size);
+};
 const codeFor = (seed) => `KET-${createHash('sha256').update(seed).digest('hex').slice(0, 12).toUpperCase()}`;
 const applicationId = (orderType, orderId, programId) => `${orderType}:${orderId}:${programId}`;
 const codeAvailable = async (ctx, code, exceptWalletId) => !(await ctx.db.select('loyalty.Rule', { normalizedCode: code })).some((row) => row.active) &&
@@ -52,7 +64,7 @@ const upsertApplication = async (ctx, values) => {
         code: values.code ?? null,
         pointsEarned: decimal(values.pointsEarned ?? 0),
         pointsSpent: decimal(values.pointsSpent ?? 0),
-        discountAmount: decimal(values.discountAmount ?? 0),
+        discountAmount: canonicalDecimalText(values.discountAmount ?? '0'),
         rewardPayload: values.rewardPayload ?? null,
         currency: values.currency,
         state: values.state ?? 'draft',
@@ -61,7 +73,11 @@ const upsertApplication = async (ctx, values) => {
     if (existing)
         await ctx.db.update('loyalty.Application', { id }, patch);
     else
-        await ctx.db.insert('loyalty.Application', { id, ...patch, createdAt: now() });
+        await ctx.db.insert('loyalty.Application', {
+            id,
+            ...patch,
+            createdAt: now(),
+        });
     return (await ctx.db.select('loyalty.Application', { id }))[0];
 };
 const evaluationEffects = [
@@ -72,6 +88,7 @@ const evaluationEffects = [
     'read:loyalty.Reward',
     'read:loyalty.RewardProduct',
     'read:loyalty.Wallet',
+    'read:loyalty.Reservation',
     'read:loyalty.Application',
     'read:loyalty.ProductTag',
     'read:loyalty.MembershipConfig',
@@ -110,16 +127,426 @@ const concurrentError = (error) => {
         return invalid(issue('wallet', 'loyalty.error.concurrent'));
     throw error;
 };
+const transact = (ctx, options, body) => options.inTransaction ? body(ctx) : ctx.tx(body);
+export const applyOrderReward = async (ctx, args, options = {}) => {
+    const snapshot = snapshotOf(args.order);
+    if (!snapshot)
+        return invalid(issue('order', 'loyalty.error.order'));
+    const program = (await ctx.db.select('loyalty.Program', { id: args.programId }))[0];
+    if (!program)
+        return invalid(issue('programId', 'loyalty.error.programMissing'));
+    const reward = (await ctx.db.select('loyalty.Reward', {
+        id: args.rewardId,
+        programId: args.programId,
+    }))[0];
+    if (!reward?.active)
+        return invalid(issue('rewardId', 'loyalty.error.rewardMissing'));
+    const current = (await ctx.db.select('loyalty.Application', {
+        orderType: snapshot.orderType,
+        orderId: snapshot.orderId,
+        programId: args.programId,
+    }))[0];
+    const codes = current?.code
+        ? [...new Set([...(snapshot.codes ?? []), normalizeCode(current.code)])]
+        : snapshot.codes;
+    const evaluated = await evaluate(ctx, { ...snapshot, codes }, {
+        onlyProgramId: String(args.programId),
+        ...(args.points === undefined ? {} : { requestedPoints: n(args.points) }),
+    });
+    const result = evaluated[0], quote = result?.rewards.find((candidate) => candidate.rewardId === args.rewardId);
+    if (!result || !quote)
+        return invalid(issue('rewardId', 'loyalty.error.ineligible'));
+    const requestedPoints = n(args.points ?? quote.requiredPoints);
+    const config = (await ctx.db.select('loyalty.MembershipConfig', {
+        programId: args.programId,
+    }))[0];
+    if (config && program.programType === 'loyalty') {
+        const step = n(config.minimumRedeemStep);
+        if (step > 0 && Math.abs(requestedPoints / step - Math.round(requestedPoints / step)) > 0.000001)
+            return invalid(issue('points', 'loyalty.error.redeemStep'));
+        if (!snapshot.partnerId)
+            return invalid(issue('partnerId', 'loyalty.error.partnerMissing'));
+        const membership = await refreshMembershipRow(ctx, snapshot.partnerId);
+        const tier = membership?.tierId
+            ? (await ctx.db.select('loyalty.Tier', { id: membership.tierId }))[0]
+            : null;
+        const scale = scaleOf(snapshot.currency);
+        let merchandise = 0n;
+        for (const line of snapshot.lines.filter((line) => line.lineKind === 'product'))
+            merchandise += moneyMinor(line.untaxed, scale);
+        const maximumDiscount = percentOfMinor(merchandise, String(tier?.redeemPercent ?? '0'));
+        if (moneyMinor(quote.discountAmount, scale) > maximumDiscount)
+            return invalid(issue('points', 'loyalty.error.redeemCap'));
+    }
+    const walletId = String(current?.walletId ?? result.walletId ?? '');
+    const fromCurrentOrder = program.appliesOn === 'future' ? 0 : result.points;
+    const walletSpend = Math.max(0, requestedPoints - fromCurrentOrder);
+    if (walletSpend > 0 && !walletId)
+        return invalid(issue('points', 'loyalty.error.insufficientPoints'));
+    try {
+        const application = await transact(ctx, options, async (tx) => {
+            for (const held of await tx.db.select('loyalty.Reservation', {
+                orderType: snapshot.orderType,
+                orderId: snapshot.orderId,
+            }))
+                if (held.state === 'reserved' && held.rewardId !== args.rewardId)
+                    await release(tx, held);
+            if (walletSpend > 0)
+                await reserve(tx, {
+                    id: `${snapshot.orderType}:${snapshot.orderId}:${String(args.rewardId)}`,
+                    walletId,
+                    orderType: snapshot.orderType,
+                    orderId: snapshot.orderId,
+                    rewardId: String(args.rewardId),
+                    amount: walletSpend,
+                });
+            return upsertApplication(tx, {
+                orderType: snapshot.orderType,
+                orderId: snapshot.orderId,
+                partnerId: snapshot.partnerId,
+                programId: String(args.programId),
+                walletId: walletId || null,
+                rewardId: String(args.rewardId),
+                code: current?.code ? String(current.code) : null,
+                pointsEarned: result.points,
+                pointsSpent: requestedPoints,
+                discountAmount: quote.discountAmount,
+                rewardPayload: { ...quote, requiredPoints: requestedPoints },
+                currency: snapshot.currency,
+                state: walletSpend > 0 ? 'reserved' : 'draft',
+            });
+        });
+        return {
+            ok: true,
+            applicationId: application.id,
+            reward: { ...quote, requiredPoints: requestedPoints },
+        };
+    }
+    catch (error) {
+        return concurrentError(error);
+    }
+};
+export const removeOrderReward = async (ctx, args, options = {}) => {
+    const application = (await ctx.db.select('loyalty.Application', {
+        orderType: args.orderType,
+        orderId: args.orderId,
+        programId: args.programId,
+    }))[0];
+    if (!application)
+        return { ok: true };
+    try {
+        await transact(ctx, options, async (tx) => {
+            for (const reservation of await tx.db.select('loyalty.Reservation', {
+                orderType: args.orderType,
+                orderId: args.orderId,
+            }))
+                if (reservation.state === 'reserved')
+                    await release(tx, reservation);
+            await tx.db.update('loyalty.Application', { id: application.id }, {
+                rewardId: null,
+                pointsSpent: '0',
+                discountAmount: '0',
+                rewardPayload: null,
+                state: 'draft',
+                updatedAt: now(),
+            });
+        });
+        return { ok: true, id: String(application.id) };
+    }
+    catch (error) {
+        return concurrentError(error);
+    }
+};
+/**
+ * Finalize one loyalty order as part of either its own transaction or a wider
+ * channel transaction. Vertical adapters use `inTransaction` so their order,
+ * reservation and loyalty ledger commit atomically without nesting a database
+ * transaction.
+ */
+export const finalizeOrderLoyalty = async (ctx, args, options = {}) => {
+    const snapshot = snapshotOf(args.order);
+    if (!snapshot)
+        return invalid(issue('order', 'loyalty.error.order'));
+    if (snapshot.partnerId && !(await ctx.db.select('partner.Partner', { id: snapshot.partnerId }))[0])
+        return invalid(issue('partnerId', 'loyalty.error.partnerMissing'));
+    try {
+        const finalized = await transact(ctx, options, async (tx) => {
+            const prior = await tx.db.select('loyalty.Application', {
+                orderType: snapshot.orderType,
+                orderId: snapshot.orderId,
+            });
+            const priorByProgram = new Map(prior.map((row) => [String(row.programId), row]));
+            const codes = [
+                ...(snapshot.codes ?? []),
+                ...prior.map((row) => normalizeCode(row.code)).filter(Boolean),
+            ];
+            const evaluated = await evaluate(tx, {
+                ...snapshot,
+                codes: [...new Set(codes)],
+            });
+            const applications = [];
+            const issuedWallets = [];
+            for (const result of evaluated) {
+                const program = (await tx.db.select('loyalty.Program', { id: result.programId }))[0];
+                const previous = priorByProgram.get(result.programId);
+                let wallet = previous?.walletId
+                    ? ((await tx.db.select('loyalty.Wallet', { id: previous.walletId }))[0] ?? null)
+                    : result.walletId
+                        ? ((await tx.db.select('loyalty.Wallet', { id: result.walletId }))[0] ?? null)
+                        : null;
+                if (['future', 'both'].includes(String(program.appliesOn)) &&
+                    snapshot.partnerId &&
+                    ['loyalty', 'ewallet'].includes(String(program.programType)))
+                    wallet = await ensureWallet(tx, program, {
+                        id: `member:${String(program.id)}:${snapshot.partnerId}`,
+                        partnerId: snapshot.partnerId,
+                    });
+                const points = result.splitPoints.length ? 0 : result.points;
+                if (['future', 'both'].includes(String(program.appliesOn))) {
+                    if (result.splitPoints.length) {
+                        let index = 0;
+                        for (const split of result.splitPoints) {
+                            const coupon = await ensureWallet(tx, program, {
+                                id: `coupon:${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:${index}`,
+                                partnerId: snapshot.partnerId,
+                            });
+                            await postDelta(tx, {
+                                id: `${String(coupon.id)}:earn`,
+                                walletId: String(coupon.id),
+                                operation: 'earn',
+                                amount: split,
+                                balanceDelta: split,
+                                sourceType: snapshot.orderType,
+                                sourceId: snapshot.orderId,
+                                sourceOperation: `earn:${String(program.id)}:${index}`,
+                                sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn:${index}`,
+                                descriptionCode: 'loyalty.ledger.description.earn',
+                            });
+                            issuedWallets.push((await tx.db.select('loyalty.Wallet', { id: coupon.id }))[0]);
+                            index += 1;
+                        }
+                    }
+                    else if (points > 0) {
+                        if (!wallet)
+                            wallet = await ensureWallet(tx, program, {
+                                id: `coupon:${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:0`,
+                                partnerId: snapshot.partnerId,
+                            });
+                        await postDelta(tx, {
+                            id: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn`,
+                            walletId: String(wallet.id),
+                            operation: 'earn',
+                            amount: points,
+                            balanceDelta: points,
+                            sourceType: snapshot.orderType,
+                            sourceId: snapshot.orderId,
+                            sourceOperation: `earn:${String(program.id)}`,
+                            sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn`,
+                            descriptionCode: 'loyalty.ledger.description.earn',
+                        });
+                        issuedWallets.push((await tx.db.select('loyalty.Wallet', { id: wallet.id }))[0]);
+                    }
+                }
+                const pointsSpent = n(previous?.pointsSpent);
+                if (previous?.rewardId && pointsSpent > 0 && wallet) {
+                    const reservation = (await tx.db.select('loyalty.Reservation', {
+                        orderType: snapshot.orderType,
+                        orderId: snapshot.orderId,
+                        rewardId: previous.rewardId,
+                    }))[0];
+                    if (reservation)
+                        await finalizeReservation(tx, reservation, pointsSpent);
+                    else
+                        await postDelta(tx, {
+                            id: `${snapshot.orderType}:${snapshot.orderId}:${String(previous.rewardId)}:redeem`,
+                            walletId: String(wallet.id),
+                            operation: 'redeem',
+                            amount: pointsSpent,
+                            balanceDelta: -pointsSpent,
+                            sourceType: snapshot.orderType,
+                            sourceId: snapshot.orderId,
+                            sourceOperation: 'redeem',
+                            sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(previous.rewardId)}:redeem`,
+                            descriptionCode: 'loyalty.ledger.description.redeem',
+                        });
+                }
+                applications.push(await upsertApplication(tx, {
+                    orderType: snapshot.orderType,
+                    orderId: snapshot.orderId,
+                    partnerId: snapshot.partnerId,
+                    programId: result.programId,
+                    walletId: wallet ? String(wallet.id) : null,
+                    rewardId: previous?.rewardId ? String(previous.rewardId) : null,
+                    code: previous?.code ? String(previous.code) : null,
+                    pointsEarned: result.points + result.splitPoints.reduce((sum, value) => sum + value, 0),
+                    pointsSpent,
+                    discountAmount: canonicalDecimalText(String(previous?.discountAmount ?? '0')),
+                    rewardPayload: previous?.rewardPayload ?? null,
+                    currency: snapshot.currency,
+                    state: 'finalized',
+                }));
+            }
+            if (snapshot.partnerId) {
+                let spend = 0n;
+                const scale = scaleOf(snapshot.currency);
+                for (const line of snapshot.lines.filter((line) => line.lineKind === 'product'))
+                    spend += moneyMinor(line.total, scale);
+                await tx.db.insertIfAbsent('loyalty.SpendEntry', {
+                    id: `${snapshot.orderType}:${snapshot.orderId}`,
+                    partnerId: snapshot.partnerId,
+                    sourceType: snapshot.orderType,
+                    sourceId: snapshot.orderId,
+                    amount: minorText(spend, scale),
+                    currency: snapshot.currency,
+                    occurredAt: snapshot.date,
+                    reversedAt: null,
+                });
+            }
+            return { applications, issuedWallets };
+        });
+        const membership = snapshot.partnerId ? await refreshMembershipRow(ctx, snapshot.partnerId) : null;
+        return {
+            ok: true,
+            applications: finalized.applications,
+            issuedWallets: finalized.issuedWallets.map(walletSummary),
+            membership,
+        };
+    }
+    catch (error) {
+        return concurrentError(error);
+    }
+};
+/** Reverse a deterministic portion while participating in an adapter-owned transaction. */
+export const reverseOrderLoyaltyPortion = async (ctx, args, options = {}) => {
+    const portion = n(args.portion);
+    if (!(portion > 0) || portion > 1.000001)
+        return invalid(issue('portion', 'loyalty.error.order'));
+    let partnerId = null;
+    try {
+        const reversed = await transact(ctx, options, async (tx) => {
+            const applications = await tx.db.select('loyalty.Application', {
+                orderType: args.orderType,
+                orderId: args.orderId,
+            });
+            partnerId = applications[0]?.partnerId ? String(applications[0].partnerId) : null;
+            const entries = (await tx.db.select('loyalty.LedgerEntry', {
+                sourceType: args.orderType,
+                sourceId: args.orderId,
+            })).filter((entry) => entry.operation !== 'reverse');
+            let count = 0;
+            for (const entry of entries) {
+                const prior = await tx.db.select('loyalty.LedgerEntry', { reversedEntryId: entry.id });
+                const remaining = Math.max(0, Math.abs(n(entry.balanceDelta)) -
+                    prior.reduce((sum, reversal) => sum + Math.abs(n(reversal.balanceDelta)), 0));
+                const amount = args.complete
+                    ? remaining
+                    : Math.min(remaining, Math.abs(n(entry.balanceDelta)) * portion);
+                if (amount <= 0.000001)
+                    continue;
+                const result = await postDelta(tx, {
+                    id: `${String(entry.id)}:reverse:${String(args.reversalId)}`,
+                    walletId: String(entry.walletId),
+                    operation: 'reverse',
+                    amount,
+                    balanceDelta: n(entry.balanceDelta) > 0 ? -amount : amount,
+                    sourceType: `${String(args.orderType)}_return`,
+                    sourceId: String(args.reversalId),
+                    sourceOperation: `reverse:${String(entry.id)}`,
+                    sourceKey: `${String(entry.sourceKey)}:reverse:${String(args.reversalId)}`,
+                    descriptionCode: 'loyalty.ledger.description.reverse',
+                    reversedEntryId: String(entry.id),
+                    metadata: {
+                        originalOrderType: String(args.orderType),
+                        originalOrderId: String(args.orderId),
+                        portion: decimal(portion),
+                        complete: Boolean(args.complete),
+                    },
+                    allowNegative: true,
+                });
+                if (!result.replayed)
+                    count += 1;
+            }
+            const originalSpend = (await tx.db.select('loyalty.SpendEntry', {
+                sourceType: args.orderType,
+                sourceId: args.orderId,
+            }))[0];
+            if (originalSpend) {
+                const returnSourceType = `${String(args.orderType)}_return:${String(args.orderId)}`;
+                const previousSpend = await tx.db.select('loyalty.SpendEntry', { sourceType: returnSourceType });
+                const remainingSpend = Math.max(0, n(originalSpend.amount) + previousSpend.reduce((sum, entry) => sum + n(entry.amount), 0));
+                const amount = args.complete
+                    ? remainingSpend
+                    : Math.min(remainingSpend, n(originalSpend.amount) * portion);
+                await tx.db.insertIfAbsent('loyalty.SpendEntry', {
+                    id: `${String(args.orderType)}:${String(args.reversalId)}:spend`,
+                    partnerId: originalSpend.partnerId,
+                    sourceType: returnSourceType,
+                    sourceId: String(args.reversalId),
+                    amount: decimal(-amount),
+                    currency: originalSpend.currency,
+                    occurredAt: args.reversedAt ?? now(),
+                    reversedAt: null,
+                });
+            }
+            if (args.complete)
+                for (const application of applications)
+                    await tx.db.update('loyalty.Application', { id: application.id }, { state: 'reversed', updatedAt: now() });
+            return count;
+        });
+        const membership = partnerId ? await refreshMembershipRow(ctx, partnerId) : null;
+        return { ok: true, reversed, membership };
+    }
+    catch (error) {
+        return concurrentError(error);
+    }
+};
 export const orderFunctions = {
+    /**
+     * Wallets, filtered and paged by the store rather than in memory.
+     *
+     * A tenant of any size has more wallets than a screen shows, and reading all
+     * of them to display twenty is the kind of thing that works until it does not.
+     * `state` is separate from `includeArchived` because expiry and locking are
+     * different endings: `active` is live, `locked` was switched off by somebody,
+     * `expired` simply ran out of time.
+     */
     'wallet.list': defineFn({
-        input: { programId: 'id?', partnerId: 'id?', includeArchived: 'bool?' },
+        input: {
+            programId: 'id?',
+            partnerId: 'id?',
+            includeArchived: 'bool?',
+            state: 'text?',
+            search: 'text?',
+            limit: 'int?',
+            offset: 'int?',
+        },
         effects: ['read:loyalty.Wallet'],
         agent: true,
-        handler: async (ctx, args) => (await ctx.db.select('loyalty.Wallet'))
-            .filter((wallet) => (args.includeArchived || wallet.active) &&
-            (!args.programId || wallet.programId === args.programId) &&
-            (!args.partnerId || wallet.partnerId === args.partnerId))
-            .map(walletSummary),
+        handler: async (ctx, args) => {
+            const W = ctx.table('loyalty.Wallet');
+            const at = now();
+            const parts = [];
+            if (args.programId)
+                parts.push(eq(W.programId, args.programId));
+            if (args.partnerId)
+                parts.push(eq(W.partnerId, args.partnerId));
+            if (args.state === 'active')
+                parts.push(and(eq(W.active, true), or(gt(W.expiresAt, at), isNull(W.expiresAt))));
+            else if (args.state === 'locked')
+                parts.push(eq(W.active, false));
+            else if (args.state === 'expired')
+                parts.push(and(eq(W.active, true), lte(W.expiresAt, at)));
+            else if (!args.includeArchived)
+                parts.push(eq(W.active, true));
+            // The code is what an operator has in front of them — on a card, in an
+            // email — so it is what the search box looks at.
+            if (args.search)
+                parts.push(ilike(W.normalizedCode, `%${normalizeCode(String(args.search))}%`));
+            let query = from(W).orderBy(desc(W.createdAt), asc(W.id));
+            if (parts.length)
+                query = query.where(and(...parts));
+            return (await ctx.db.all(paged(query, args))).map(walletSummary);
+        },
     }),
     'wallet.get': defineFn({
         input: { id: 'id?', code: 'text?', partnerId: 'id?', programId: 'id?' },
@@ -130,7 +557,9 @@ export const orderFunctions = {
             if (args.id)
                 wallet = (await ctx.db.select('loyalty.Wallet', { id: args.id }))[0];
             else if (args.code)
-                wallet = (await ctx.db.select('loyalty.Wallet', { normalizedCode: normalizeCode(args.code) }))[0];
+                wallet = (await ctx.db.select('loyalty.Wallet', {
+                    normalizedCode: normalizeCode(args.code),
+                }))[0];
             else if (args.partnerId && args.programId)
                 wallet = (await ctx.db.select('loyalty.Wallet', {
                     partnerId: args.partnerId,
@@ -145,15 +574,51 @@ export const orderFunctions = {
             };
         },
     }),
+    /**
+     * The ledger over a period, newest first.
+     *
+     * A statement is read by date, so the window is a first-class filter rather
+     * than something the caller trims off the end. Filtering by program resolves
+     * that program's wallets first: the entry carries a wallet, not a program, and
+     * this query layer does not join.
+     */
     'ledger.list': defineFn({
-        input: { walletId: 'id?', operation: 'text?', limit: 'int?' },
-        effects: ['read:loyalty.LedgerEntry'],
+        input: {
+            walletId: 'id?',
+            programId: 'id?',
+            operation: 'text?',
+            from: 'datetime?',
+            to: 'datetime?',
+            limit: 'int?',
+            offset: 'int?',
+        },
+        effects: ['read:loyalty.LedgerEntry', 'read:loyalty.Wallet'],
         agent: true,
-        handler: async (ctx, args) => (await ctx.db.select('loyalty.LedgerEntry'))
-            .filter((entry) => (!args.walletId || entry.walletId === args.walletId) &&
-            (!args.operation || entry.operation === args.operation))
-            .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
-            .slice(0, Math.min(1000, Math.max(1, n(args.limit ?? 100)))),
+        handler: async (ctx, args) => {
+            const L = ctx.table('loyalty.LedgerEntry');
+            const parts = [];
+            if (args.walletId)
+                parts.push(eq(L.walletId, args.walletId));
+            if (args.programId) {
+                const W = ctx.table('loyalty.Wallet');
+                const wallets = (await ctx.db.all(from(W).where(eq(W.programId, args.programId)))).map((row) => row.id);
+                // No wallets means no entries. An empty `IN ()` is not a filter, so
+                // saying so here is what keeps it from reading as "no filter at all".
+                if (!wallets.length)
+                    return [];
+                parts.push(inArray(L.walletId, wallets));
+            }
+            if (args.operation)
+                parts.push(eq(L.operation, args.operation));
+            if (args.from)
+                parts.push(gte(L.createdAt, args.from));
+            if (args.to)
+                parts.push(lte(L.createdAt, args.to));
+            let query = from(L).orderBy(desc(L.createdAt), desc(L.id));
+            if (parts.length)
+                query = query.where(and(...parts));
+            return ctx.db.all(paged(query, args));
+        },
     }),
     'wallet.create': defineFn({
         input: {
@@ -239,7 +704,11 @@ export const orderFunctions = {
                     descriptionCode: 'loyalty.ledger.description.adjust',
                     metadata: args.note ? { note: args.note } : null,
                 }));
-                return { ok: true, wallet: walletSummary(result.wallet), replayed: result.replayed };
+                return {
+                    ok: true,
+                    wallet: walletSummary(result.wallet),
+                    replayed: result.replayed,
+                };
             }
             catch (error) {
                 return concurrentError(error);
@@ -275,7 +744,10 @@ export const orderFunctions = {
             if (wallet?.partnerId && wallet.partnerId !== snapshot.partnerId)
                 return invalid(issue('code', 'loyalty.error.codeInvalid'));
             const programId = String(rule?.programId ?? wallet?.programId);
-            const evaluated = await evaluate(ctx, { ...snapshot, codes: [...new Set([...(snapshot.codes ?? []), normalized])] }, { onlyProgramId: programId });
+            const evaluated = await evaluate(ctx, {
+                ...snapshot,
+                codes: [...new Set([...(snapshot.codes ?? []), normalized])],
+            }, { onlyProgramId: programId });
             if (!evaluated[0])
                 return invalid(issue('code', 'loyalty.error.ineligible'));
             const result = evaluated[0];
@@ -293,102 +765,16 @@ export const orderFunctions = {
         },
     }),
     applyReward: defineFn({
-        input: { order: 'json', programId: 'id', rewardId: 'id', points: 'decimal?' },
+        input: {
+            order: 'json',
+            programId: 'id',
+            rewardId: 'id',
+            points: 'decimal?',
+        },
         effects: [...orderWriteEffects],
         idempotent: true,
         agent: true,
-        handler: async (ctx, args) => {
-            const snapshot = snapshotOf(args.order);
-            if (!snapshot)
-                return invalid(issue('order', 'loyalty.error.order'));
-            const program = (await ctx.db.select('loyalty.Program', { id: args.programId }))[0];
-            if (!program)
-                return invalid(issue('programId', 'loyalty.error.programMissing'));
-            const reward = (await ctx.db.select('loyalty.Reward', { id: args.rewardId, programId: args.programId }))[0];
-            if (!reward?.active)
-                return invalid(issue('rewardId', 'loyalty.error.rewardMissing'));
-            const current = (await ctx.db.select('loyalty.Application', {
-                orderType: snapshot.orderType,
-                orderId: snapshot.orderId,
-                programId: args.programId,
-            }))[0];
-            const codes = current?.code
-                ? [...new Set([...(snapshot.codes ?? []), normalizeCode(current.code)])]
-                : snapshot.codes;
-            const evaluated = await evaluate(ctx, { ...snapshot, codes }, {
-                onlyProgramId: String(args.programId),
-                ...(args.points === undefined ? {} : { requestedPoints: n(args.points) }),
-            });
-            const result = evaluated[0], quote = result?.rewards.find((candidate) => candidate.rewardId === args.rewardId);
-            if (!result || !quote)
-                return invalid(issue('rewardId', 'loyalty.error.ineligible'));
-            const requestedPoints = n(args.points ?? quote.requiredPoints);
-            const config = (await ctx.db.select('loyalty.MembershipConfig', { programId: args.programId }))[0];
-            if (config && program.programType === 'loyalty') {
-                const step = n(config.minimumRedeemStep);
-                if (step > 0 && Math.abs(requestedPoints / step - Math.round(requestedPoints / step)) > 0.000001)
-                    return invalid(issue('points', 'loyalty.error.redeemStep'));
-                if (!snapshot.partnerId)
-                    return invalid(issue('partnerId', 'loyalty.error.partnerMissing'));
-                const membership = await refreshMembershipRow(ctx, snapshot.partnerId);
-                const tier = membership?.tierId
-                    ? (await ctx.db.select('loyalty.Tier', { id: membership.tierId }))[0]
-                    : null;
-                const merchandise = snapshot.lines
-                    .filter((line) => line.lineKind === 'product')
-                    .reduce((sum, line) => sum + line.untaxed, 0);
-                const maximumDiscount = merchandise * (n(tier?.redeemPercent) / 100);
-                if (quote.discountAmount > maximumDiscount + 0.000001)
-                    return invalid(issue('points', 'loyalty.error.redeemCap'));
-            }
-            const walletId = String(current?.walletId ?? result.walletId ?? '');
-            const fromCurrentOrder = program.appliesOn === 'future' ? 0 : result.points;
-            const walletSpend = Math.max(0, requestedPoints - fromCurrentOrder);
-            if (walletSpend > 0 && !walletId)
-                return invalid(issue('points', 'loyalty.error.insufficientPoints'));
-            try {
-                const application = await ctx.tx(async (tx) => {
-                    for (const held of await tx.db.select('loyalty.Reservation', {
-                        orderType: snapshot.orderType,
-                        orderId: snapshot.orderId,
-                    }))
-                        if (held.state === 'reserved' && held.rewardId !== args.rewardId)
-                            await release(tx, held);
-                    if (walletSpend > 0)
-                        await reserve(tx, {
-                            id: `${snapshot.orderType}:${snapshot.orderId}:${String(args.rewardId)}`,
-                            walletId,
-                            orderType: snapshot.orderType,
-                            orderId: snapshot.orderId,
-                            rewardId: String(args.rewardId),
-                            amount: walletSpend,
-                        });
-                    return upsertApplication(tx, {
-                        orderType: snapshot.orderType,
-                        orderId: snapshot.orderId,
-                        partnerId: snapshot.partnerId,
-                        programId: String(args.programId),
-                        walletId: walletId || null,
-                        rewardId: String(args.rewardId),
-                        code: current?.code ? String(current.code) : null,
-                        pointsEarned: result.points,
-                        pointsSpent: requestedPoints,
-                        discountAmount: quote.discountAmount,
-                        rewardPayload: { ...quote, requiredPoints: requestedPoints },
-                        currency: snapshot.currency,
-                        state: walletSpend > 0 ? 'reserved' : 'draft',
-                    });
-                });
-                return {
-                    ok: true,
-                    applicationId: application.id,
-                    reward: { ...quote, requiredPoints: requestedPoints },
-                };
-            }
-            catch (error) {
-                return concurrentError(error);
-            }
-        },
+        handler: (ctx, args) => applyOrderReward(ctx, args),
     }),
     removeReward: defineFn({
         input: { orderType: 'text', orderId: 'text', programId: 'id' },
@@ -403,192 +789,28 @@ export const orderFunctions = {
         ],
         idempotent: true,
         agent: true,
-        handler: async (ctx, args) => {
-            const application = (await ctx.db.select('loyalty.Application', {
-                orderType: args.orderType,
-                orderId: args.orderId,
-                programId: args.programId,
-            }))[0];
-            if (!application)
-                return { ok: true };
-            try {
-                await ctx.tx(async (tx) => {
-                    for (const reservation of await tx.db.select('loyalty.Reservation', {
-                        orderType: args.orderType,
-                        orderId: args.orderId,
-                    }))
-                        if (reservation.state === 'reserved')
-                            await release(tx, reservation);
-                    await tx.db.update('loyalty.Application', { id: application.id }, {
-                        rewardId: null,
-                        pointsSpent: '0',
-                        discountAmount: '0',
-                        rewardPayload: null,
-                        state: 'draft',
-                        updatedAt: now(),
-                    });
-                });
-                return { ok: true, id: String(application.id) };
-            }
-            catch (error) {
-                return concurrentError(error);
-            }
-        },
+        handler: (ctx, args) => removeOrderReward(ctx, args),
     }),
     'order.finalize': defineFn({
         input: { order: 'json' },
         effects: [...orderWriteEffects],
         idempotent: true,
         agent: true,
-        handler: async (ctx, args) => {
-            const snapshot = snapshotOf(args.order);
-            if (!snapshot)
-                return invalid(issue('order', 'loyalty.error.order'));
-            if (snapshot.partnerId && !(await ctx.db.select('partner.Partner', { id: snapshot.partnerId }))[0])
-                return invalid(issue('partnerId', 'loyalty.error.partnerMissing'));
-            try {
-                const finalized = await ctx.tx(async (tx) => {
-                    const prior = await tx.db.select('loyalty.Application', {
-                        orderType: snapshot.orderType,
-                        orderId: snapshot.orderId,
-                    });
-                    const priorByProgram = new Map(prior.map((row) => [String(row.programId), row]));
-                    const codes = [
-                        ...(snapshot.codes ?? []),
-                        ...prior.map((row) => normalizeCode(row.code)).filter(Boolean),
-                    ];
-                    const evaluated = await evaluate(tx, { ...snapshot, codes: [...new Set(codes)] });
-                    const applications = [];
-                    const issuedWallets = [];
-                    for (const result of evaluated) {
-                        const program = (await tx.db.select('loyalty.Program', { id: result.programId }))[0];
-                        const previous = priorByProgram.get(result.programId);
-                        let wallet = previous?.walletId
-                            ? ((await tx.db.select('loyalty.Wallet', { id: previous.walletId }))[0] ?? null)
-                            : result.walletId
-                                ? ((await tx.db.select('loyalty.Wallet', { id: result.walletId }))[0] ?? null)
-                                : null;
-                        if (['future', 'both'].includes(String(program.appliesOn)) &&
-                            snapshot.partnerId &&
-                            ['loyalty', 'ewallet'].includes(String(program.programType)))
-                            wallet = await ensureWallet(tx, program, {
-                                id: `member:${String(program.id)}:${snapshot.partnerId}`,
-                                partnerId: snapshot.partnerId,
-                            });
-                        const points = result.splitPoints.length ? 0 : result.points;
-                        if (['future', 'both'].includes(String(program.appliesOn))) {
-                            if (result.splitPoints.length) {
-                                let index = 0;
-                                for (const split of result.splitPoints) {
-                                    const coupon = await ensureWallet(tx, program, {
-                                        id: `coupon:${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:${index}`,
-                                        partnerId: snapshot.partnerId,
-                                    });
-                                    await postDelta(tx, {
-                                        id: `${String(coupon.id)}:earn`,
-                                        walletId: String(coupon.id),
-                                        operation: 'earn',
-                                        amount: split,
-                                        balanceDelta: split,
-                                        sourceType: snapshot.orderType,
-                                        sourceId: snapshot.orderId,
-                                        sourceOperation: `earn:${String(program.id)}:${index}`,
-                                        sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn:${index}`,
-                                        descriptionCode: 'loyalty.ledger.description.earn',
-                                    });
-                                    issuedWallets.push((await tx.db.select('loyalty.Wallet', { id: coupon.id }))[0]);
-                                    index += 1;
-                                }
-                            }
-                            else if (points > 0) {
-                                if (!wallet)
-                                    wallet = await ensureWallet(tx, program, {
-                                        id: `coupon:${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:0`,
-                                        partnerId: snapshot.partnerId,
-                                    });
-                                await postDelta(tx, {
-                                    id: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn`,
-                                    walletId: String(wallet.id),
-                                    operation: 'earn',
-                                    amount: points,
-                                    balanceDelta: points,
-                                    sourceType: snapshot.orderType,
-                                    sourceId: snapshot.orderId,
-                                    sourceOperation: `earn:${String(program.id)}`,
-                                    sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(program.id)}:earn`,
-                                    descriptionCode: 'loyalty.ledger.description.earn',
-                                });
-                                issuedWallets.push((await tx.db.select('loyalty.Wallet', { id: wallet.id }))[0]);
-                            }
-                        }
-                        const pointsSpent = n(previous?.pointsSpent);
-                        if (previous?.rewardId && pointsSpent > 0 && wallet) {
-                            const reservation = (await tx.db.select('loyalty.Reservation', {
-                                orderType: snapshot.orderType,
-                                orderId: snapshot.orderId,
-                                rewardId: previous.rewardId,
-                            }))[0];
-                            if (reservation)
-                                await finalizeReservation(tx, reservation, pointsSpent);
-                            else
-                                await postDelta(tx, {
-                                    id: `${snapshot.orderType}:${snapshot.orderId}:${String(previous.rewardId)}:redeem`,
-                                    walletId: String(wallet.id),
-                                    operation: 'redeem',
-                                    amount: pointsSpent,
-                                    balanceDelta: -pointsSpent,
-                                    sourceType: snapshot.orderType,
-                                    sourceId: snapshot.orderId,
-                                    sourceOperation: 'redeem',
-                                    sourceKey: `${snapshot.orderType}:${snapshot.orderId}:${String(previous.rewardId)}:redeem`,
-                                    descriptionCode: 'loyalty.ledger.description.redeem',
-                                });
-                        }
-                        applications.push(await upsertApplication(tx, {
-                            orderType: snapshot.orderType,
-                            orderId: snapshot.orderId,
-                            partnerId: snapshot.partnerId,
-                            programId: result.programId,
-                            walletId: wallet ? String(wallet.id) : null,
-                            rewardId: previous?.rewardId ? String(previous.rewardId) : null,
-                            code: previous?.code ? String(previous.code) : null,
-                            pointsEarned: result.points + result.splitPoints.reduce((sum, value) => sum + value, 0),
-                            pointsSpent,
-                            discountAmount: n(previous?.discountAmount),
-                            rewardPayload: previous?.rewardPayload ?? null,
-                            currency: snapshot.currency,
-                            state: 'finalized',
-                        }));
-                    }
-                    if (snapshot.partnerId) {
-                        const spend = snapshot.lines
-                            .filter((line) => line.lineKind === 'product')
-                            .reduce((sum, line) => sum + line.total, 0);
-                        await tx.db.insertIfAbsent('loyalty.SpendEntry', {
-                            id: `${snapshot.orderType}:${snapshot.orderId}`,
-                            partnerId: snapshot.partnerId,
-                            sourceType: snapshot.orderType,
-                            sourceId: snapshot.orderId,
-                            amount: decimal(spend),
-                            currency: snapshot.currency,
-                            occurredAt: snapshot.date,
-                            reversedAt: null,
-                        });
-                    }
-                    return { applications, issuedWallets };
-                });
-                const membership = snapshot.partnerId ? await refreshMembershipRow(ctx, snapshot.partnerId) : null;
-                return {
-                    ok: true,
-                    applications: finalized.applications,
-                    issuedWallets: finalized.issuedWallets.map(walletSummary),
-                    membership,
-                };
-            }
-            catch (error) {
-                return concurrentError(error);
-            }
+        handler: (ctx, args) => finalizeOrderLoyalty(ctx, args),
+    }),
+    'order.reversePortion': defineFn({
+        input: {
+            orderType: 'text',
+            orderId: 'text',
+            reversalId: 'text',
+            portion: 'decimal',
+            complete: 'bool?',
+            reversedAt: 'datetime?',
         },
+        effects: [...orderWriteEffects],
+        idempotent: true,
+        agent: true,
+        handler: (ctx, args) => reverseOrderLoyaltyPortion(ctx, args),
     }),
     'order.reverse': defineFn({
         input: { orderType: 'text', orderId: 'text', reversedAt: 'datetime?' },