@btst/plugin-affiliate 0.0.0-stage → 1.0.0

package/dist/api/mutations.mjs

@@ -0,0 +1,352 @@
+import { OperationHttpError } from '@btst/stack/plugins/api';
+import { isClickWithinWindow, safeLandingPath } from '../attribution.mjs';
+import { calculateCommission } from '../commission.mjs';
+import { createAffiliateSchema, createConversionSchema, createPayoutSchema, trackClickSchema, updateAffiliateSchema, updateCommissionSchema, updatePayoutSchema } from '../schemas.mjs';
+import { getReferralClick, getAffiliate, getAffiliateByCode, serializeAffiliateRecord, getCommission, getPayout, getConversionByExternalRef, allRows } from './getters.mjs';
+
+function assertAffiliateSnapshot(current, expected) {
+  if (expected && (current.id !== expected.id || current.userId !== expected.userId || current.status !== expected.status)) {
+    fail("Affiliate changed after authorization");
+  }
+}
+const queues = /* @__PURE__ */ new WeakMap();
+function fail(message, status = 409) {
+  throw new OperationHttpError(status, message, "AFFILIATE_CONFLICT");
+}
+async function withAffiliateTransaction(adapter, affiliateId, run) {
+  const config = adapter.options?.adapterConfig;
+  if (!config?.transaction)
+    fail("Affiliate writes require an adapter with transactions enabled", 503);
+  let pending = queues.get(adapter);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    queues.set(adapter, pending);
+  }
+  const key = config.adapterId === "memory" ? "*" : affiliateId ?? "create";
+  const previous = pending.get(key) ?? Promise.resolve();
+  const operation = previous.catch(() => {
+  }).then(
+    () => adapter.transaction(async (tx) => {
+      if (affiliateId) {
+        const locked = await tx.update({
+          model: "affiliate",
+          where: [{ field: "id", value: affiliateId, operator: "eq" }],
+          update: { lockVersion: crypto.randomUUID() }
+        });
+        if (!locked) fail("Affiliate not found", 404);
+      }
+      return run(tx);
+    })
+  );
+  pending.set(key, operation);
+  try {
+    return await operation;
+  } finally {
+    if (pending.get(key) === operation) pending.delete(key);
+  }
+}
+async function ensureUniqueAffiliate(adapter, input, excludeId) {
+  for (const field of ["code", "email", "userId"]) {
+    const value = input[field];
+    if (!value) continue;
+    const existing = await adapter.findOne({
+      model: "affiliate",
+      where: [{ field, value, operator: "eq" }]
+    });
+    if (existing && existing.id !== excludeId)
+      fail(`Affiliate ${field} is already in use`);
+  }
+}
+async function createAffiliate(adapter, input) {
+  const data = createAffiliateSchema.parse(input);
+  return withAffiliateTransaction(adapter, null, async (tx) => {
+    const values = {
+      ...data,
+      email: data.email.toLowerCase(),
+      code: data.code ?? `partner-${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}`
+    };
+    await ensureUniqueAffiliate(tx, values);
+    return serializeAffiliateRecord(
+      await tx.create({
+        model: "affiliate",
+        data: {
+          ...values,
+          status: "pending",
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+  });
+}
+async function updateAffiliate(adapter, id, input, expected) {
+  const data = updateAffiliateSchema.parse(input);
+  return withAffiliateTransaction(adapter, id, async (tx) => {
+    const current = await getAffiliate(tx, id);
+    if (!current) fail("Affiliate not found", 404);
+    assertAffiliateSnapshot(current, expected);
+    const values = {
+      ...data,
+      ...data.email ? { email: data.email.toLowerCase() } : {}
+    };
+    await ensureUniqueAffiliate(tx, values, id);
+    if (data.status && data.status !== current.status) {
+      const allowed = current.status === "pending" ? ["approved", "suspended"] : current.status === "approved" ? ["suspended"] : ["approved"];
+      if (!allowed.includes(data.status))
+        fail("Invalid affiliate status transition");
+    }
+    const ruleType = data.commissionType === void 0 ? current.commissionType : data.commissionType;
+    const ruleValue = data.commissionValue === void 0 ? current.commissionValue : data.commissionValue;
+    if (ruleType == null !== (ruleValue == null))
+      fail("Commission override requires both type and value", 400);
+    if (ruleType != null && ruleValue != null) {
+      try {
+        calculateCommission(0, ruleType, ruleValue);
+      } catch (error) {
+        fail(
+          error instanceof Error ? error.message : "Invalid commission rule",
+          400
+        );
+      }
+    }
+    return serializeAffiliateRecord(
+      await tx.update({
+        model: "affiliate",
+        where: [{ field: "id", value: id, operator: "eq" }],
+        update: { ...values, updatedAt: /* @__PURE__ */ new Date() }
+      })
+    );
+  });
+}
+async function deleteAffiliate(adapter, id, expected) {
+  return withAffiliateTransaction(adapter, id, async (tx) => {
+    const current = await getAffiliate(tx, id);
+    if (!current) fail("Affiliate not found", 404);
+    assertAffiliateSnapshot(current, expected);
+    for (const model of [
+      "affiliateConversion",
+      "affiliateCommission",
+      "affiliatePayout"
+    ]) {
+      if (await tx.count({
+        model,
+        where: [{ field: "affiliateId", value: id, operator: "eq" }]
+      }))
+        fail(
+          "Affiliates with financial history must be suspended instead of deleted"
+        );
+    }
+    await tx.deleteMany({
+      model: "referralClick",
+      where: [{ field: "affiliateId", value: id, operator: "eq" }]
+    });
+    await tx.delete({
+      model: "affiliate",
+      where: [{ field: "id", value: id, operator: "eq" }]
+    });
+    return { success: true };
+  });
+}
+async function trackClick(adapter, input) {
+  const data = trackClickSchema.parse(input);
+  const landingPath = safeLandingPath(data.landingPath);
+  const affiliate = await getAffiliateByCode(adapter, data.code);
+  if (!affiliate || affiliate.status !== "approved")
+    fail("Approved affiliate not found", 404);
+  return withAffiliateTransaction(adapter, affiliate.id, async (tx) => {
+    if ((await getAffiliate(tx, affiliate.id))?.status !== "approved")
+      fail("Approved affiliate not found", 404);
+    return serializeAffiliateRecord(
+      await tx.create({
+        model: "referralClick",
+        data: {
+          ...data,
+          landingPath,
+          affiliateId: affiliate.id,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+  });
+}
+async function previousConversion(adapter, input) {
+  if (!input.externalRef) return null;
+  const conversion = await getConversionByExternalRef(
+    adapter,
+    input.externalRef
+  );
+  if (!conversion) return null;
+  if (conversion.amount !== input.amount || conversion.currency !== (input.currency ?? "USD"))
+    fail("Conversion external reference already has different values");
+  const commission = await adapter.findOne({
+    model: "affiliateCommission",
+    where: [{ field: "conversionId", value: conversion.id, operator: "eq" }]
+  });
+  if (!commission) fail("Conversion commission is missing");
+  return {
+    conversion,
+    commission: serializeAffiliateRecord(commission)
+  };
+}
+async function createConversion(adapter, input, options = {}) {
+  const data = createConversionSchema.parse(input);
+  const existing = await previousConversion(adapter, data);
+  if (existing) return existing;
+  if (!data.attribution) return null;
+  const click = data.attribution.clickId ? await getReferralClick(adapter, data.attribution.clickId) : null;
+  if (data.attribution.clickId && (!click || !isClickWithinWindow(click, options.attributionWindowDays)))
+    return null;
+  const affiliate = click ? await getAffiliate(adapter, click.affiliateId) : data.attribution.code ? await getAffiliateByCode(adapter, data.attribution.code) : null;
+  if (!affiliate || affiliate.status !== "approved") return null;
+  if (click && data.attribution.code && click.code !== data.attribution.code)
+    fail("Attribution code does not match referral click", 400);
+  try {
+    return await withAffiliateTransaction(adapter, affiliate.id, async (tx) => {
+      const duplicate = await previousConversion(tx, data);
+      if (duplicate) return duplicate;
+      const current = await getAffiliate(tx, affiliate.id);
+      if (!current || current.status !== "approved") return null;
+      const type = current.commissionType ?? options.defaultCommissionType ?? "percent";
+      const value = current.commissionValue ?? options.defaultCommissionValue ?? 20;
+      const amount = calculateCommission(data.amount, type, value);
+      const conversion = serializeAffiliateRecord(
+        await tx.create({
+          model: "affiliateConversion",
+          data: {
+            affiliateId: affiliate.id,
+            ...click ? { clickId: click.id } : {},
+            ...data.externalRef ? { externalRef: data.externalRef } : {},
+            amount: data.amount,
+            currency: data.currency,
+            status: "pending",
+            createdAt: /* @__PURE__ */ new Date()
+          }
+        })
+      );
+      const commission = serializeAffiliateRecord(
+        await tx.create({
+          model: "affiliateCommission",
+          data: {
+            affiliateId: affiliate.id,
+            conversionId: conversion.id,
+            amount,
+            currency: data.currency,
+            status: "pending",
+            payoutId: "",
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        })
+      );
+      return { conversion, commission };
+    });
+  } catch (error) {
+    const duplicate = await previousConversion(adapter, data);
+    if (duplicate) return duplicate;
+    throw error;
+  }
+}
+async function updateCommission(adapter, id, input, expected) {
+  const data = updateCommissionSchema.parse(input);
+  const found = await getCommission(adapter, id);
+  if (!found) fail("Commission not found", 404);
+  return withAffiliateTransaction(adapter, found.affiliateId, async (tx) => {
+    const current = await getCommission(tx, id);
+    if (!current) fail("Commission not found", 404);
+    if (expected && (current.id !== expected.id || current.affiliateId !== expected.affiliateId || current.status !== expected.status))
+      fail("Commission changed after authorization");
+    if (current.status === data.status) return current;
+    if (current.payoutId || !["pending", "approved"].includes(current.status) || current.status === "approved" && data.status !== "voided")
+      fail("Commission is paid, reserved, or cannot transition to that status");
+    const result = await tx.update({
+      model: "affiliateCommission",
+      where: [{ field: "id", value: id, operator: "eq" }],
+      update: { status: data.status, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    await tx.update({
+      model: "affiliateConversion",
+      where: [{ field: "id", value: current.conversionId, operator: "eq" }],
+      update: { status: data.status === "approved" ? "approved" : "rejected" }
+    });
+    return serializeAffiliateRecord(result);
+  });
+}
+async function createPayout(adapter, input) {
+  const data = createPayoutSchema.parse(input);
+  return withAffiliateTransaction(adapter, data.affiliateId, async (tx) => {
+    const affiliate = await getAffiliate(tx, data.affiliateId);
+    if (!affiliate || affiliate.status !== "approved")
+      fail("Payouts require an approved affiliate");
+    const all = await allRows(tx, "affiliateCommission", [
+      { field: "affiliateId", value: data.affiliateId, operator: "eq" },
+      { field: "currency", value: data.currency, operator: "eq" },
+      { field: "status", value: "approved", operator: "eq" },
+      { field: "payoutId", value: "", operator: "eq" }
+    ]);
+    const selected = data.commissionIds ? all.filter((item) => data.commissionIds?.includes(item.id)) : all;
+    if (!selected.length || data.commissionIds && selected.length !== new Set(data.commissionIds).size)
+      fail("Select available approved commissions in one currency");
+    const amount = selected.reduce(
+      (total, item) => total + BigInt(item.amount),
+      0n
+    );
+    if (amount > BigInt(Number.MAX_SAFE_INTEGER))
+      fail("Payout exceeds safe integer range", 400);
+    const payout = serializeAffiliateRecord(
+      await tx.create({
+        model: "affiliatePayout",
+        data: {
+          affiliateId: data.affiliateId,
+          amount: Number(amount),
+          currency: data.currency,
+          status: "pending",
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+    for (const item of selected) {
+      await tx.update({
+        model: "affiliateCommission",
+        where: [{ field: "id", value: item.id, operator: "eq" }],
+        update: { payoutId: payout.id, updatedAt: /* @__PURE__ */ new Date() }
+      });
+    }
+    return payout;
+  });
+}
+async function updatePayout(adapter, id, input, expected) {
+  const data = updatePayoutSchema.parse(input);
+  const found = await getPayout(adapter, id);
+  if (!found) fail("Payout not found", 404);
+  return withAffiliateTransaction(adapter, found.affiliateId, async (tx) => {
+    const current = await getPayout(tx, id);
+    if (!current) fail("Payout not found", 404);
+    if (expected && (current.id !== expected.id || current.affiliateId !== expected.affiliateId || current.status !== expected.status))
+      fail("Payout changed after authorization");
+    if (current.status === data.status) return current;
+    if (current.status !== "pending")
+      fail("Only pending payouts can be marked sent or failed");
+    const commissions = await allRows(tx, "affiliateCommission", [
+      { field: "payoutId", value: id, operator: "eq" }
+    ]);
+    for (const commission of commissions) {
+      await tx.update({
+        model: "affiliateCommission",
+        where: [{ field: "id", value: commission.id, operator: "eq" }],
+        update: data.status === "sent" ? { status: "paid", updatedAt: /* @__PURE__ */ new Date() } : { payoutId: "", updatedAt: /* @__PURE__ */ new Date() }
+      });
+    }
+    return serializeAffiliateRecord(
+      await tx.update({
+        model: "affiliatePayout",
+        where: [{ field: "id", value: id, operator: "eq" }],
+        update: {
+          ...data,
+          ...data.status === "sent" ? { paidAt: /* @__PURE__ */ new Date() } : {}
+        }
+      })
+    );
+  });
+}
+
+export { createAffiliate, createConversion, createPayout, deleteAffiliate, trackClick, updateAffiliate, updateCommission, updatePayout, withAffiliateTransaction };

package/dist/api/operations.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const zod = require('zod');
+const attribution = require('../attribution.cjs');
+const permissions = require('../permissions.cjs');
+const schemas = require('../schemas.cjs');
+const getters = require('./getters.cjs');
+const mutations = require('./mutations.cjs');
+
+function fail(status, message) {
+  throw new api.OperationHttpError(status, message, "AFFILIATE_ERROR");
+}
+async function requireAffiliate(adapter, id) {
+  return await getters.getAffiliate(adapter, id) ?? fail(404, "Affiliate not found");
+}
+async function affiliateFacts(adapter, id) {
+  const affiliate = await requireAffiliate(adapter, id);
+  return {
+    affiliateId: affiliate.id,
+    userId: affiliate.userId,
+    status: affiliate.status
+  };
+}
+function requireIdentity(identity) {
+  return identity?.id ?? fail(401, "Sign in to manage your affiliate profile");
+}
+function attributionCookie(request) {
+  const value = request?.headers.get("cookie")?.split(";").map((entry) => entry.trim()).find((entry) => entry.startsWith(`${attribution.AFFILIATE_COOKIE_NAME}=`))?.slice(attribution.AFFILIATE_COOKIE_NAME.length + 1);
+  return value && /^[a-zA-Z0-9_-]{1,200}$/.test(value) ? value : void 0;
+}
+function createAffiliateOperations(adapter, options) {
+  return {
+    listAffiliates: api.defineOperation({
+      input: schemas.affiliateListSchema,
+      permission: permissions.affiliatePermissions.affiliate.read,
+      facts: () => ({ scope: "collection" }),
+      execute: async ({ input }) => {
+        const result = await getters.listAffiliates(adapter, input);
+        return {
+          ...result,
+          items: result.items.map((affiliate) => ({ ...affiliate }))
+        };
+      }
+    }),
+    getAffiliate: api.defineOperation({
+      input: schemas.idSchema,
+      permission: permissions.affiliatePermissions.affiliate.read,
+      facts: ({ input }) => ({
+        scope: "record",
+        affiliateId: input.id
+      }),
+      execute: async ({ input }) => ({
+        affiliate: { ...await requireAffiliate(adapter, input.id) },
+        stats: { ...await getters.getAffiliateStats(adapter, input.id) }
+      })
+    }),
+    createAffiliate: api.defineOperation({
+      input: schemas.createAffiliateSchema,
+      permission: permissions.affiliatePermissions.affiliate.create,
+      facts: () => void 0,
+      execute: async ({ input }) => ({
+        ...await mutations.createAffiliate(adapter, input)
+      })
+    }),
+    updateAffiliate: api.defineOperation({
+      input: schemas.idSchema.extend({ data: schemas.updateAffiliateSchema }),
+      permission: permissions.affiliatePermissions.affiliate.update,
+      facts: ({ input }) => affiliateFacts(adapter, input.id),
+      before: async (context) => {
+        if (context.input.data.status === "approved")
+          await options.hooks?.onBeforeApproveAffiliate?.(
+            await requireAffiliate(adapter, context.input.id),
+            context
+          );
+      },
+      execute: async ({ input, facts }) => ({
+        ...await mutations.updateAffiliate(adapter, input.id, input.data, {
+          id: facts.affiliateId,
+          userId: facts.userId,
+          status: facts.status
+        })
+      })
+    }),
+    deleteAffiliate: api.defineOperation({
+      input: schemas.idSchema,
+      permission: permissions.affiliatePermissions.affiliate.delete,
+      facts: ({ input }) => affiliateFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        await mutations.deleteAffiliate(adapter, input.id, {
+          id: facts.affiliateId,
+          userId: facts.userId,
+          status: facts.status
+        });
+        return { success: true };
+      }
+    }),
+    apply: api.defineOperation({
+      input: schemas.applicationSchema,
+      permission: permissions.affiliatePermissions.application.create,
+      facts: () => void 0,
+      execute: async ({ input, identity }) => ({
+        ...await mutations.createAffiliate(adapter, {
+          ...input,
+          userId: requireIdentity(identity)
+        })
+      })
+    }),
+    getPortal: api.defineOperation({
+      input: zod.z.object({}),
+      permission: permissions.affiliatePermissions.portal.read,
+      facts: () => void 0,
+      execute: async ({ identity }) => {
+        const portal = await getters.getPortal(
+          adapter,
+          requireIdentity(identity),
+          options.marketingAssets
+        );
+        return {
+          affiliate: portal.affiliate ? { ...portal.affiliate } : null,
+          stats: { ...portal.stats },
+          commissions: portal.commissions.map((commission) => ({
+            ...commission
+          })),
+          payouts: portal.payouts.map((payout) => ({ ...payout })),
+          assets: portal.assets.map((asset) => ({ ...asset }))
+        };
+      }
+    }),
+    updatePortal: api.defineOperation({
+      input: schemas.updatePortalSchema,
+      permission: permissions.affiliatePermissions.portal.update,
+      facts: () => void 0,
+      execute: async ({ input, identity }) => {
+        const affiliate = await getters.getAffiliateByUserId(
+          adapter,
+          requireIdentity(identity)
+        ) ?? fail(404, "Apply to the affiliate program first");
+        const updated = await mutations.updateAffiliate(
+          adapter,
+          affiliate.id,
+          input
+        );
+        const { notes: _notes, ...profile } = updated;
+        return profile;
+      }
+    }),
+    trackClick: api.definePassthroughOperation({
+      input: schemas.trackClickSchema,
+      permission: permissions.affiliatePermissions.tracking.track,
+      access: "public",
+      facts: () => void 0,
+      execute: async ({ input, request }) => {
+        let landingPath;
+        try {
+          landingPath = attribution.safeLandingPath(input.landingPath);
+        } catch {
+          fail(400, "Landing path must be a local absolute path");
+        }
+        const destination = new URL(
+          landingPath,
+          options.siteOrigin ?? request?.url ?? "https://affiliate.invalid"
+        );
+        const click = await mutations.trackClick(adapter, {
+          ...input,
+          landingPath,
+          referrer: request?.headers.get("referer")?.slice(0, 2048) ?? input.referrer,
+          userAgent: request?.headers.get("user-agent")?.slice(0, 2048) ?? input.userAgent
+        });
+        const previousId = attributionCookie(request);
+        const previous = previousId ? await getters.getReferralClick(adapter, previousId) : null;
+        const previousAffiliate = previous ? await getters.getAffiliate(adapter, previous.affiliateId) : null;
+        const selected = attribution.selectAttributionClick(
+          previousAffiliate?.status === "approved" ? previous : null,
+          click,
+          options
+        );
+        const headers = new Headers({
+          Location: options.siteOrigin ? destination.href : destination.pathname + destination.search + destination.hash,
+          "Cache-Control": "no-store, private",
+          "Referrer-Policy": "no-referrer"
+        });
+        if (selected) {
+          const maxAge = Math.max(
+            0,
+            Math.floor(
+              (new Date(selected.createdAt).getTime() + (options.attributionWindowDays ?? 30) * 864e5 - Date.now()) / 1e3
+            )
+          );
+          headers.set(
+            "Set-Cookie",
+            `${attribution.AFFILIATE_COOKIE_NAME}=${selected.id}; Path=/; Max-Age=${maxAge}; HttpOnly; SameSite=Lax${request && new URL(request.url).protocol === "https:" ? "; Secure" : ""}`
+          );
+        }
+        return new Response(null, { status: 302, headers });
+      }
+    }),
+    createConversion: api.defineOperation({
+      input: schemas.createConversionSchema,
+      permission: permissions.affiliatePermissions.conversion.create,
+      facts: () => void 0,
+      execute: async ({ input, request }) => {
+        let requestAttribution = request ? attribution.attributionFromRequest(request) : void 0;
+        if (!input.attribution) {
+          const cookieId = attributionCookie(request);
+          const click = cookieId ? await getters.getReferralClick(adapter, cookieId) : null;
+          if (click && attribution.isClickWithinWindow(click, options.attributionWindowDays) && (await getters.getAffiliate(adapter, click.affiliateId))?.status === "approved")
+            requestAttribution = { clickId: click.id };
+        }
+        if (!input.attribution && !schemas.createConversionSchema.shape.attribution.safeParse(
+          requestAttribution
+        ).success)
+          fail(400, "Invalid referral attribution");
+        const result = await mutations.createConversion(
+          adapter,
+          {
+            ...input,
+            attribution: input.attribution ?? requestAttribution
+          },
+          options
+        );
+        return result ? {
+          conversion: { ...result.conversion },
+          commission: { ...result.commission }
+        } : null;
+      },
+      after: async (context) => {
+        if (context.result)
+          await options.hooks?.onAfterConversion?.(
+            context.result.conversion,
+            context.result.commission,
+            context
+          );
+      }
+    }),
+    listCommissions: api.defineOperation({
+      input: schemas.listSchema,
+      permission: permissions.affiliatePermissions.commission.read,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        const result = await getters.listCommissions(adapter, input);
+        return {
+          ...result,
+          items: result.items.map((commission) => ({ ...commission }))
+        };
+      }
+    }),
+    updateCommission: api.defineOperation({
+      input: schemas.idSchema.extend({ data: schemas.updateCommissionSchema }),
+      permission: permissions.affiliatePermissions.commission.update,
+      facts: async ({ input }) => {
+        const commission = await getters.getCommission(adapter, input.id) ?? fail(404, "Commission not found");
+        return {
+          commissionId: commission.id,
+          affiliateId: commission.affiliateId,
+          status: commission.status
+        };
+      },
+      execute: async ({ input, facts }) => ({
+        ...await mutations.updateCommission(adapter, input.id, input.data, {
+          id: facts.commissionId,
+          affiliateId: facts.affiliateId,
+          status: facts.status
+        })
+      })
+    }),
+    listPayouts: api.defineOperation({
+      input: schemas.listSchema,
+      permission: permissions.affiliatePermissions.payout.read,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        const result = await getters.listPayouts(adapter, input);
+        return {
+          ...result,
+          items: result.items.map((payout) => ({ ...payout }))
+        };
+      }
+    }),
+    createPayout: api.defineOperation({
+      input: schemas.createPayoutSchema,
+      permission: permissions.affiliatePermissions.payout.create,
+      facts: async ({ input }) => {
+        await requireAffiliate(adapter, input.affiliateId);
+        return { affiliateId: input.affiliateId, currency: input.currency };
+      },
+      before: (context) => options.hooks?.onBeforePayout?.(context.input, context),
+      execute: async ({ input }) => ({
+        ...await mutations.createPayout(adapter, {
+          ...input,
+          commissionIds: input.commissionIds ? [...input.commissionIds] : void 0
+        })
+      })
+    }),
+    updatePayout: api.defineOperation({
+      input: schemas.idSchema.extend({ data: schemas.updatePayoutSchema }),
+      permission: permissions.affiliatePermissions.payout.update,
+      facts: async ({ input }) => {
+        const payout = await getters.getPayout(adapter, input.id) ?? fail(404, "Payout not found");
+        return {
+          payoutId: payout.id,
+          affiliateId: payout.affiliateId,
+          status: payout.status
+        };
+      },
+      execute: async ({ input, facts }) => ({
+        ...await mutations.updatePayout(adapter, input.id, input.data, {
+          id: facts.payoutId,
+          affiliateId: facts.affiliateId,
+          status: facts.status
+        })
+      }),
+      after: async (context) => {
+        if (context.result.status === "sent")
+          await options.hooks?.onAfterPayout?.(context.result, context);
+      }
+    }),
+    exportPayouts: api.defineOperation({
+      input: schemas.listSchema,
+      permission: permissions.affiliatePermissions.payout.export,
+      facts: () => void 0,
+      execute: async ({ input }) => ({
+        csv: await getters.exportPayouts(adapter, input)
+      })
+    })
+  };
+}
+
+exports.createAffiliateOperations = createAffiliateOperations;