@btst/plugin-affiliate 0.0.0-stage → 1.0.0

package/dist/api/index.mjs

@@ -0,0 +1,7 @@
+export { affiliateBackendPlugin } from './plugin.mjs';
+export { affiliateSchema } from '../db.mjs';
+export { affiliatePermissions } from '../permissions.mjs';
+export { allRows, exportPayouts, getAffiliate, getAffiliateByCode, getAffiliateByUserId, getAffiliateStats, getCommission, getConversionByExternalRef, getPayout, getPortal, getReferralClick, listAffiliates, listCommissions, listPayouts, serializeAffiliateRecord } from './getters.mjs';
+export { createAffiliate, createConversion, createPayout, deleteAffiliate, trackClick, updateAffiliate, updateCommission, updatePayout, withAffiliateTransaction } from './mutations.mjs';
+export { AFFILIATE_COOKIE_NAME, attributionFromRequest, createReferralLink, createTrackingLink, getReferralRedirect, isClickWithinWindow, referralCodeFromURL, safeLandingPath, selectAttributionClick } from '../attribution.mjs';
+export { calculateCommission } from '../commission.mjs';

package/dist/api/mutations.cjs

@@ -0,0 +1,362 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const attribution = require('../attribution.cjs');
+const commission = require('../commission.cjs');
+const schemas = require('../schemas.cjs');
+const getters = require('./getters.cjs');
+
+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 api.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 = schemas.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 getters.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 = schemas.updateAffiliateSchema.parse(input);
+  return withAffiliateTransaction(adapter, id, async (tx) => {
+    const current = await getters.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 {
+        commission.calculateCommission(0, ruleType, ruleValue);
+      } catch (error) {
+        fail(
+          error instanceof Error ? error.message : "Invalid commission rule",
+          400
+        );
+      }
+    }
+    return getters.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 getters.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 = schemas.trackClickSchema.parse(input);
+  const landingPath = attribution.safeLandingPath(data.landingPath);
+  const affiliate = await getters.getAffiliateByCode(adapter, data.code);
+  if (!affiliate || affiliate.status !== "approved")
+    fail("Approved affiliate not found", 404);
+  return withAffiliateTransaction(adapter, affiliate.id, async (tx) => {
+    if ((await getters.getAffiliate(tx, affiliate.id))?.status !== "approved")
+      fail("Approved affiliate not found", 404);
+    return getters.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 getters.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: getters.serializeAffiliateRecord(commission)
+  };
+}
+async function createConversion(adapter, input, options = {}) {
+  const data = schemas.createConversionSchema.parse(input);
+  const existing = await previousConversion(adapter, data);
+  if (existing) return existing;
+  if (!data.attribution) return null;
+  const click = data.attribution.clickId ? await getters.getReferralClick(adapter, data.attribution.clickId) : null;
+  if (data.attribution.clickId && (!click || !attribution.isClickWithinWindow(click, options.attributionWindowDays)))
+    return null;
+  const affiliate = click ? await getters.getAffiliate(adapter, click.affiliateId) : data.attribution.code ? await getters.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 getters.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 = commission.calculateCommission(data.amount, type, value);
+      const conversion = getters.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$1 = getters.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: commission$1 };
+    });
+  } catch (error) {
+    const duplicate = await previousConversion(adapter, data);
+    if (duplicate) return duplicate;
+    throw error;
+  }
+}
+async function updateCommission(adapter, id, input, expected) {
+  const data = schemas.updateCommissionSchema.parse(input);
+  const found = await getters.getCommission(adapter, id);
+  if (!found) fail("Commission not found", 404);
+  return withAffiliateTransaction(adapter, found.affiliateId, async (tx) => {
+    const current = await getters.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 getters.serializeAffiliateRecord(result);
+  });
+}
+async function createPayout(adapter, input) {
+  const data = schemas.createPayoutSchema.parse(input);
+  return withAffiliateTransaction(adapter, data.affiliateId, async (tx) => {
+    const affiliate = await getters.getAffiliate(tx, data.affiliateId);
+    if (!affiliate || affiliate.status !== "approved")
+      fail("Payouts require an approved affiliate");
+    const all = await getters.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 = getters.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 = schemas.updatePayoutSchema.parse(input);
+  const found = await getters.getPayout(adapter, id);
+  if (!found) fail("Payout not found", 404);
+  return withAffiliateTransaction(adapter, found.affiliateId, async (tx) => {
+    const current = await getters.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 getters.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 getters.serializeAffiliateRecord(
+      await tx.update({
+        model: "affiliatePayout",
+        where: [{ field: "id", value: id, operator: "eq" }],
+        update: {
+          ...data,
+          ...data.status === "sent" ? { paidAt: /* @__PURE__ */ new Date() } : {}
+        }
+      })
+    );
+  });
+}
+
+exports.createAffiliate = createAffiliate;
+exports.createConversion = createConversion;
+exports.createPayout = createPayout;
+exports.deleteAffiliate = deleteAffiliate;
+exports.trackClick = trackClick;
+exports.updateAffiliate = updateAffiliate;
+exports.updateCommission = updateCommission;
+exports.updatePayout = updatePayout;
+exports.withAffiliateTransaction = withAffiliateTransaction;