import { and, eq, sql } from 'drizzle-orm';
import { z } from 'zod';
import type { DrizzleClient } from '@/server/db/client';
import {
  dealSkus,
  adminActions,
  dealVariantAxes,
  dealVariantOptions,
  dealCategories,
  categoryTranslations,
  dealImages,
  dealItemConfig,
  dealTranslations,
  deals,
  groupDeals,
  groupReservations,
  order,
  orderLine,
  orderLineVoucherExt,
  refundIntent,
  refundIntentLineExt,
  outbox,
  payouts,
  personalDealRequests,
  shipmentPurchases,
  shipments,
  shareLinks,
  users,
  userRecentlyViewed,
  vendorPayoutReleases,
  vendors,
  vendorAddresses,
  wishlistItems,
  caseOffers,
  caseResolutions,
  returns,
  transactionCases,
  affiliateEnrollments,
  referralLinks,
  kycVerifications,
  userGalleryImages,
} from '@/server/db/schema';
import { voucher } from '@platform-modules/commerce-fulfillment';
import * as userQueries from '@/server/db/queries/users';
import * as vendorQueries from '@/server/db/queries/vendors';
import * as dealTranslationQueries from '@/server/db/queries/deal-translations';
import { blindIndex, encrypt } from '@/server/db/crypto';
import { createDealWithSkus } from '@/server/domain/vendor-deal/create-deal';
import { FactoryOperationError } from '@/server/testing/factory/core';
import { computeReleaseAt, triggerReasonFor } from '@/server/domain/settlement-release/machine';
import { generateVoucherQrToken } from '@/server/fulfillment/fulfillment-platform';
import {
  asOrderId,
  asOrderLineId,
  asVendorId,
  asVoucherId,
  toModuleRef,
} from '@/server/platform-seams/ids';
import type { FactoryOperationHandler, FactoryStore } from './core';
import { assertSingleOrderLine, purchaseInputSchema } from './purchase-contract';
import { readFactoryMailbox } from './mail-capture';
import { applyVendorAccountUpdated } from '@/server/payments/vendor-account-updated';
import { formatAgorotPlain } from '@/lib/money';

const uuid = z.uuid();
const actorInput = z.object({
  key: uuid,
  accountState: z.enum(['ACTIVE', 'FROZEN', 'DELETED_PENDING']).default('ACTIVE'),
  hasPhone: z.boolean().default(true),
  isAdmin: z.boolean().default(false),
});
const adoptRegisteredActorInput = z.object({ actorId: uuid, mailboxId: uuid });
const otpRegistrationProofInput = z.object({ key: uuid });
const adoptVendorRegistrationInput = z.object({ actorId: uuid, proofId: uuid });
const adoptVendorUpgradeInput = z.object({ actorId: uuid });
const adoptDealInput = z.object({ dealId: uuid, vendorId: uuid });
const dealCategoryInput = z.object({
  key: uuid,
  type: z.enum(['COUPON', 'GROUP', 'ITEM']),
  name: z.string().min(1).max(120),
});
const vendorAccountUpdatedInput = z.object({
  vendorId: uuid,
  chargesEnabled: z.boolean(),
  payoutsEnabled: z.boolean(),
  detailsSubmitted: z.boolean(),
  requirementsCurrentlyDue: z.array(z.string()).nullable(),
});
const vendorInput = z.object({
  key: uuid,
  ownerUserId: uuid,
  businessName: z.string().min(1).max(120),
  accountState: z
    .enum([
      'PENDING_FIRST_APPROVAL',
      'PENDING_PROCESSOR',
      'ACTIVE',
      'VETERAN',
      'FROZEN',
      'BANNED',
      'REJECTED',
    ])
    .default('ACTIVE'),
  stripeFixture: z.enum(['none', 'account_created', 'details_submitted', 'ready']).default('none'),
  flagReason: z.string().min(1).max(500).optional(),
  mockScenario: z
    .enum(['success', 'decline', 'insufficient_funds', 'token_expired', 'token_invalid'])
    .default('success'),
});
const vendorAddressInput = z.object({
  key: uuid,
  vendorId: uuid,
  label: z.string().min(1).max(80),
  fullAddress: z.string().min(1).max(240),
  city: z.string().min(1).max(120),
  cityCode: z.string().min(1).max(40),
  lat: z.number().min(-90).max(90),
  lng: z.number().min(-180).max(180),
  isPublic: z.boolean().default(true),
});
const variantAxis = z.object({
  kind: z.enum(['SIZE', 'COLOR', 'TIMESLOT', 'CUSTOM']),
  nameHe: z.string().min(1),
  nameEn: z.string().min(1),
  options: z
    .array(
      z.object({
        valueCode: z.string().min(1),
        labelHe: z.string().min(1),
        labelEn: z.string().min(1),
      }),
    )
    .min(1),
});
const skuInput = z.object({
  optionValueCodes: z.array(z.string()),
  priceAgorot: z.number().int().positive(),
  stock: z.number().int().nonnegative(),
});
const dealInput = z.object({
  key: uuid,
  vendorId: uuid,
  type: z.enum(['COUPON', 'GROUP', 'ITEM']).default('COUPON'),
  title: z.string().min(1).max(160),
  priceAgorot: z.number().int().positive(),
  stock: z.number().int().nonnegative(),
  state: z.enum(['ACTIVE', 'SOLD_OUT', 'UNDER_REVIEW', 'PENDING_APPROVAL']).default('ACTIVE'),
  axes: z.array(variantAxis).optional(),
  skus: z.array(skuInput).optional(),
  fulfillment: z.enum(['delivery', 'pickup']).optional(),
  pickupAddress: z.string().min(1).max(240).optional(),
  pickupStart: z
    .string()
    .regex(/^\d{2}:\d{2}$/)
    .optional(),
  pickupEnd: z
    .string()
    .regex(/^\d{2}:\d{2}$/)
    .optional(),
});
const adoptPurchaseInput = z.object({
  purchaseId: uuid,
  buyerUserId: uuid,
  dealId: uuid,
});
const dealSkuStateInput = z.object({
  dealId: uuid,
  skuId: uuid,
  isActive: z.boolean(),
});
const adoptPersonalDealRequestInput = z.object({
  requestId: uuid,
  buyerUserId: uuid,
  vendorId: uuid,
  sourceDealId: uuid,
});

function price(agorot: number): string {
  return formatAgorotPlain(agorot, 2);
}

export async function buildFactoryVoucherUnits(input: {
  lineId: string;
  quantity: number;
  qrSecret: string;
  firstQrTokenHash?: string;
}): Promise<
  Array<{
    voucherId: string;
    unitIndex: number;
    qrToken: string | null;
    qrTokenHash: string;
  }>
> {
  return Promise.all(
    Array.from({ length: input.quantity }, async (_, unitIndex) => {
      const voucherId = unitIndex === 0 ? input.lineId : crypto.randomUUID();
      if (unitIndex === 0 && input.firstQrTokenHash) {
        return {
          voucherId,
          unitIndex,
          qrToken: null,
          qrTokenHash: input.firstQrTokenHash,
        };
      }
      const generated = await generateVoucherQrToken(voucherId, input.qrSecret, 3_600);
      return {
        voucherId,
        unitIndex,
        qrToken: generated.token,
        qrTokenHash: generated.tokenHash,
      };
    }),
  );
}

function actorPhone(key: string): string {
  const subscriber = BigInt(`0x${key.replaceAll('-', '').slice(-12)}`)
    .toString()
    .slice(-8)
    .padStart(8, '0');
  return `+9725${subscriber}`;
}

async function requireOwned(
  store: FactoryStore,
  runId: string,
  kind: string,
  entityId: string,
): Promise<void> {
  if (!(await store.findOwned(runId, kind, entityId))) {
    throw new FactoryOperationError(`${kind} is not owned by factory run`);
  }
}

export function createCommerceFactoryHandlers(input: {
  db: DrizzleClient;
  store: FactoryStore;
  piiKey: string;
  qrSecret: string;
  testStripeAccountId?: string;
  paymentProvider?: 'stripe' | 'mock';
  disarmPersonalOfferAlarm(requestId: string): Promise<void>;
}): Record<string, FactoryOperationHandler> {
  const {
    db,
    store,
    piiKey,
    qrSecret,
    testStripeAccountId,
    paymentProvider,
    disarmPersonalOfferAlarm,
  } = input;
  return {
    createOtpRegistrationProof: {
      dependencyOrder: 5,
      reserve: (raw) => ({
        kind: 'otp-registration',
        id: otpRegistrationProofInput.parse(raw).key,
      }),
      async execute({ input: raw }) {
        const parsed = otpRegistrationProofInput.parse(raw);
        const existingActor = await userQueries.findByPhone(
          db,
          await blindIndex(actorPhone(parsed.key), piiKey),
        );
        if (existingActor) throw new FactoryOperationError('registration actor already exists');
        return {
          entity: { kind: 'otp-registration', id: parsed.key },
          result: { proofId: parsed.key, phone: actorPhone(parsed.key) },
        };
      },
      async read({ entity }) {
        return { proofId: entity.entityId, phone: actorPhone(entity.entityId) };
      },
      async cleanup() {},
    },

    adoptVendorRegistration: {
      dependencyOrder: 20,
      async execute({ runId, input: raw }) {
        const parsed = adoptVendorRegistrationInput.parse(raw);
        await requireOwned(store, runId, 'otp-registration', parsed.proofId);
        const actor = await userQueries.findById(db, parsed.actorId);
        if (!actor || actor.phoneIndex !== (await blindIndex(actorPhone(parsed.proofId), piiKey))) {
          throw new Error('registered actor does not match owned OTP proof');
        }
        const [vendor] = await vendorQueries.findByOwnerId(db, actor.id);
        if (!vendor) throw new Error('registered vendor missing');
        return {
          entity: { kind: 'vendor', id: vendor.id },
          result: {
            actorId: actor.id,
            vendorId: vendor.id,
            ownerUserId: actor.id,
          },
        };
      },
      async read({ entity }) {
        const vendor = await vendorQueries.findById(db, entity.entityId);
        if (!vendor) throw new Error('Factory vendor missing');
        return {
          vendorId: vendor.id,
          ownerUserId: vendor.ownerUserId,
          businessName: vendor.businessName,
          accountState: vendor.accountState,
          stripeChargesEnabled: vendor.stripeChargesEnabled,
          stripePayoutsEnabled: vendor.stripePayoutsEnabled,
          stripeAccountId: vendor.stripeAccountId,
          stripeOnboardingState: vendor.stripeOnboardingState,
          stripeDetailsSubmitted: vendor.stripeDetailsSubmitted,
          stripeRequirementsCurrentlyDue: vendor.stripeRequirementsCurrentlyDue,
        };
      },
      async cleanup({ entity }) {
        const vendor = await vendorQueries.findById(db, entity.entityId);
        if (!vendor) return;
        await db.delete(vendors).where(eq(vendors.id, vendor.id));
        await db.delete(users).where(eq(users.id, vendor.ownerUserId));
      },
    },

    adoptVendorUpgrade: {
      dependencyOrder: 20,
      async execute({ runId, input: raw }) {
        const parsed = adoptVendorUpgradeInput.parse(raw);
        await requireOwned(store, runId, 'actor', parsed.actorId);
        const [vendor] = await vendorQueries.findByOwnerId(db, parsed.actorId);
        if (!vendor) throw new Error('upgraded vendor missing');
        return {
          entity: { kind: 'vendor', id: vendor.id },
          result: {
            actorId: parsed.actorId,
            vendorId: vendor.id,
            ownerUserId: parsed.actorId,
          },
        };
      },
      async read({ entity }) {
        const vendor = await vendorQueries.findById(db, entity.entityId);
        if (!vendor) throw new Error('Factory vendor missing');
        return {
          vendorId: vendor.id,
          ownerUserId: vendor.ownerUserId,
          businessName: vendor.businessName,
          accountState: vendor.accountState,
          stripeChargesEnabled: vendor.stripeChargesEnabled,
          stripePayoutsEnabled: vendor.stripePayoutsEnabled,
          stripeAccountId: vendor.stripeAccountId,
          stripeOnboardingState: vendor.stripeOnboardingState,
          stripeDetailsSubmitted: vendor.stripeDetailsSubmitted,
          stripeRequirementsCurrentlyDue: vendor.stripeRequirementsCurrentlyDue,
        };
      },
      async cleanup({ entity }) {
        await db.delete(vendors).where(eq(vendors.id, entity.entityId));
      },
    },

    adoptDeal: {
      dependencyOrder: 30,
      async execute({ runId, input: raw }) {
        const parsed = adoptDealInput.parse(raw);
        await requireOwned(store, runId, 'vendor', parsed.vendorId);
        const [deal] = await db
          .select({ id: deals.id, vendorId: deals.vendorId })
          .from(deals)
          .where(and(eq(deals.id, parsed.dealId), eq(deals.vendorId, parsed.vendorId)))
          .limit(1);
        if (!deal) throw new Error('deal does not belong to owned vendor');
        return {
          entity: { kind: 'deal', id: deal.id, operation: 'createDeal' },
          result: { dealId: deal.id, vendorId: deal.vendorId },
        };
      },
      async read() {
        throw new Error('adoptDeal uses createDeal readback');
      },
      async cleanup() {
        throw new Error('adoptDeal uses createDeal cleanup');
      },
    },

    emitVendorAccountUpdated: {
      dependencyOrder: 0,
      async execute({ runId, input: raw }) {
        const parsed = vendorAccountUpdatedInput.parse(raw);
        await requireOwned(store, runId, 'vendor', parsed.vendorId);
        const vendor = await vendorQueries.findById(db, parsed.vendorId);
        if (!vendor?.stripeAccountId) throw new Error('vendor provider account missing');
        const result = await applyVendorAccountUpdated(db, {
          id: vendor.stripeAccountId,
          chargesEnabled: parsed.chargesEnabled,
          payoutsEnabled: parsed.payoutsEnabled,
          detailsSubmitted: parsed.detailsSubmitted,
          requirementsCurrentlyDue: parsed.requirementsCurrentlyDue,
        });
        if (!result) throw new Error('provider event vendor missing');
        return { result };
      },
      async read() {
        throw new Error('Provider event has no entity');
      },
      async cleanup() {},
    },

    adoptRegisteredActor: {
      dependencyOrder: 10,
      async execute({ runId, input: raw }) {
        const parsed = adoptRegisteredActorInput.parse(raw);
        const mailbox = readFactoryMailbox(runId, parsed.mailboxId);
        if (!mailbox) throw new Error('mail capture is not owned by factory run');
        const [actor] = await db
          .select({ actorId: users.id, emailIndex: users.emailIndex })
          .from(users)
          .where(eq(users.id, parsed.actorId))
          .limit(1);
        if (!actor || actor.emailIndex !== (await blindIndex(mailbox.recipient, piiKey))) {
          throw new Error('registered actor does not match owned mail capture');
        }
        return {
          entity: {
            kind: 'actor',
            id: actor.actorId,
            operation: 'createActor',
          },
          result: { actorId: actor.actorId, runId },
        };
      },
      async read() {
        throw new Error('adoptRegisteredActor uses createActor readback');
      },
      async cleanup() {
        throw new Error('adoptRegisteredActor uses createActor cleanup');
      },
    },

    createActor: {
      dependencyOrder: 10,
      reserve: (raw) => ({ kind: 'actor', id: actorInput.parse(raw).key }),
      async execute({ runId, input: raw }) {
        const parsed = actorInput.parse(raw);
        const actor = await userQueries.createUser(db, {
          id: parsed.key,
          phone: actorPhone(parsed.key),
          email: `e2e+${parsed.key}@multideal.test`,
          piiKey,
        });
        if (!parsed.hasPhone) {
          await db
            .update(users)
            .set({ phone: null, phoneIndex: null, phoneHint: null })
            .where(eq(users.id, actor.id));
        }
        if (parsed.accountState !== 'ACTIVE') {
          await userQueries.updateAccountState(db, actor.id, parsed.accountState);
        }
        if (parsed.isAdmin) {
          await db.update(users).set({ isAdmin: true }).where(eq(users.id, actor.id));
        }
        return {
          entity: { kind: 'actor', id: actor.id },
          result: {
            actorId: actor.id,
            runId,
            accountState: parsed.accountState,
            isAdmin: parsed.isAdmin,
          },
        };
      },
      async read({ entity }) {
        const actor = await userQueries.findById(db, entity.entityId);
        if (!actor) throw new Error('Factory actor missing');
        const wishlist = await db
          .select({ dealId: wishlistItems.dealId })
          .from(wishlistItems)
          .where(eq(wishlistItems.userId, entity.entityId));
        const recentlyViewed = await db
          .select({ dealId: userRecentlyViewed.dealId })
          .from(userRecentlyViewed)
          .where(eq(userRecentlyViewed.userId, entity.entityId));
        return {
          actorId: actor.id,
          accountState: actor.accountState,
          isAdmin: actor.isAdmin,
          emailVerifiedAt: actor.emailVerifiedAt?.toISOString() ?? null,
          wishlistDealIds: wishlist.map(({ dealId }) => dealId).sort(),
          recentlyViewedDealIds: recentlyViewed.map(({ dealId }) => dealId).sort(),
        };
      },
      async cleanup({ entity }) {
        await db.execute(sql`DELETE FROM affiliate_payouts WHERE user_id = ${entity.entityId}`);
        await db.execute(sql`
          DELETE FROM affiliate_entries
          WHERE owner_id = ${entity.entityId}
            OR referral_id IN (
              SELECT id FROM referrals
              WHERE referrer_user_id = ${entity.entityId} OR referee_user_id = ${entity.entityId}
            )
        `);
        await db.execute(sql`
          DELETE FROM credit_ledger
          WHERE user_id = ${entity.entityId}
            OR referral_id IN (
              SELECT id FROM referrals
              WHERE referrer_user_id = ${entity.entityId} OR referee_user_id = ${entity.entityId}
            )
        `);
        await db.execute(sql`
          DELETE FROM fraud_events
          WHERE user_id = ${entity.entityId}
            OR referral_id IN (
              SELECT id FROM referrals
              WHERE referrer_user_id = ${entity.entityId} OR referee_user_id = ${entity.entityId}
            )
        `);
        await db.execute(sql`
          DELETE FROM referrals
          WHERE referrer_user_id = ${entity.entityId} OR referee_user_id = ${entity.entityId}
        `);
        await db.delete(adminActions).where(eq(adminActions.adminId, entity.entityId));
        await db.delete(kycVerifications).where(eq(kycVerifications.userId, entity.entityId));
        await db
          .delete(affiliateEnrollments)
          .where(eq(affiliateEnrollments.userId, entity.entityId));
        await db.delete(referralLinks).where(eq(referralLinks.ownerUserId, entity.entityId));
        await db.execute(sql`
          DELETE FROM affiliate_admin_actions
          WHERE target_user_id = ${entity.entityId} OR admin_user_id = ${entity.entityId}
        `);
        await db.execute(sql`DELETE FROM wallet_balances WHERE user_id = ${entity.entityId}`);
        await db.delete(users).where(eq(users.id, entity.entityId));
      },
    },

    createVendor: {
      dependencyOrder: 20,
      reserve: (raw) => ({ kind: 'vendor', id: vendorInput.parse(raw).key }),
      async execute({ runId, input: raw }) {
        const parsed = vendorInput.parse(raw);
        await requireOwned(store, runId, 'actor', parsed.ownerUserId);
        const vendor = await vendorQueries.createVendor(db, {
          id: parsed.key,
          ownerUserId: parsed.ownerUserId,
          businessName: parsed.businessName,
          displayName: parsed.businessName,
          phone: encrypt(actorPhone(parsed.key), piiKey),
          email: encrypt(`vendor+${parsed.key}@multideal.test`, piiKey),
        });
        await vendorQueries.setVendorAccountState(db, vendor.id, parsed.accountState);
        if (parsed.flagReason) {
          await db
            .update(vendors)
            .set({ flagReason: parsed.flagReason })
            .where(eq(vendors.id, vendor.id));
        }
        if (parsed.stripeFixture !== 'none') {
          const stripeAccountId =
            parsed.stripeFixture === 'ready'
              ? paymentProvider === 'mock'
                ? `acct_mock_${parsed.key.replaceAll('-', '')}`
                : testStripeAccountId
              : `acct_e2e_${parsed.key.replaceAll('-', '')}`;
          if (!stripeAccountId) {
            throw new Error('E2E_STRIPE_CONNECT_ACCOUNT_ID is required for ready Stripe fixture');
          }
          await vendorQueries.setVendorStripeAccount(db, vendor.id, stripeAccountId);
          await vendorQueries.setVendorStripeStatus(db, vendor.id, {
            stripeOnboardingState:
              parsed.stripeFixture === 'ready'
                ? 'charges_enabled'
                : parsed.stripeFixture === 'details_submitted'
                  ? 'kyc_pending'
                  : 'account_created',
            stripeChargesEnabled: parsed.stripeFixture === 'ready',
            stripePayoutsEnabled: parsed.stripeFixture === 'ready',
            stripeDetailsSubmitted:
              parsed.stripeFixture === 'ready' || parsed.stripeFixture === 'details_submitted',
            stripeRequirementsCurrentlyDue: parsed.stripeFixture === 'ready' ? [] : null,
          });
        }
        if (paymentProvider === 'mock') {
          await db
            .update(vendors)
            .set({ mockScenario: parsed.mockScenario })
            .where(eq(vendors.id, vendor.id));
        }
        return {
          entity: { kind: 'vendor', id: vendor.id },
          result: {
            vendorId: vendor.id,
            ownerUserId: parsed.ownerUserId,
            runId,
            accountState: parsed.accountState,
            stripeFixture: parsed.stripeFixture,
            mockScenario: parsed.mockScenario,
          },
        };
      },
      async read({ entity }) {
        const vendor = await vendorQueries.findById(db, entity.entityId);
        if (!vendor) throw new Error('Factory vendor missing');
        return {
          vendorId: vendor.id,
          ownerUserId: vendor.ownerUserId,
          businessName: vendor.businessName,
          accountState: vendor.accountState,
          stripeChargesEnabled: vendor.stripeChargesEnabled,
          stripePayoutsEnabled: vendor.stripePayoutsEnabled,
          stripeAccountId: vendor.stripeAccountId,
          stripeOnboardingState: vendor.stripeOnboardingState,
          stripeDetailsSubmitted: vendor.stripeDetailsSubmitted,
          stripeRequirementsCurrentlyDue: vendor.stripeRequirementsCurrentlyDue,
        };
      },
      async cleanup({ entity }) {
        // Settlement flows and browser checkout create payout rows FK'd to the vendor.
        await db.delete(payouts).where(eq(payouts.vendorId, entity.entityId));
        await db
          .delete(vendorPayoutReleases)
          .where(eq(vendorPayoutReleases.vendorId, entity.entityId));
        await db.delete(vendors).where(eq(vendors.id, entity.entityId));
      },
    },

    createVendorAddress: {
      dependencyOrder: 21,
      reserve: (raw) => ({
        kind: 'vendor-address',
        id: vendorAddressInput.parse(raw).key,
      }),
      async execute({ runId, input: raw }) {
        const parsed = vendorAddressInput.parse(raw);
        await requireOwned(store, runId, 'vendor', parsed.vendorId);
        const [address] = await db
          .insert(vendorAddresses)
          .values({
            id: parsed.key,
            vendorId: parsed.vendorId,
            label: parsed.label,
            fullAddress: parsed.fullAddress,
            city: parsed.city,
            cityCode: parsed.cityCode,
            lat: parsed.lat.toFixed(7),
            lng: parsed.lng.toFixed(7),
            isPublic: parsed.isPublic,
          })
          .returning({ addressId: vendorAddresses.id });
        if (!address) throw new Error('Factory vendor address insert failed');
        return {
          entity: { kind: 'vendor-address', id: address.addressId },
          result: { addressId: address.addressId, vendorId: parsed.vendorId },
        };
      },
      async read({ entity }) {
        const [address] = await db
          .select({
            addressId: vendorAddresses.id,
            vendorId: vendorAddresses.vendorId,
            fullAddress: vendorAddresses.fullAddress,
            city: vendorAddresses.city,
            cityCode: vendorAddresses.cityCode,
            lat: vendorAddresses.lat,
            lng: vendorAddresses.lng,
            isPublic: vendorAddresses.isPublic,
          })
          .from(vendorAddresses)
          .where(eq(vendorAddresses.id, entity.entityId))
          .limit(1);
        if (!address) throw new Error('Factory vendor address missing');
        return address;
      },
      async cleanup({ entity }) {
        await db.delete(vendorAddresses).where(eq(vendorAddresses.id, entity.entityId));
      },
    },

    createDealCategory: {
      dependencyOrder: 25,
      reserve: (raw) => ({
        kind: 'deal-category',
        id: dealCategoryInput.parse(raw).key,
      }),
      async execute({ input: raw }) {
        const parsed = dealCategoryInput.parse(raw);
        await db.insert(dealCategories).values({
          id: parsed.key,
          dealType: parsed.type,
          slug: `e2e-category-${parsed.key}`,
        });
        try {
          await db.insert(categoryTranslations).values(
            ['he', 'en'].map((locale) => ({
              categoryId: parsed.key,
              locale,
              name: parsed.name,
              nameSourceHash: `e2e:${parsed.key}`,
            })),
          );
        } catch (error) {
          await db.delete(dealCategories).where(eq(dealCategories.id, parsed.key));
          throw error;
        }
        return {
          entity: { kind: 'deal-category', id: parsed.key },
          result: {
            categoryId: parsed.key,
            name: parsed.name,
            type: parsed.type,
          },
        };
      },
      async read({ entity }) {
        const [category] = await db
          .select({
            categoryId: dealCategories.id,
            type: dealCategories.dealType,
            name: categoryTranslations.name,
          })
          .from(dealCategories)
          .innerJoin(
            categoryTranslations,
            and(
              eq(categoryTranslations.categoryId, dealCategories.id),
              eq(categoryTranslations.locale, 'en'),
            ),
          )
          .where(eq(dealCategories.id, entity.entityId))
          .limit(1);
        if (!category) throw new Error('Factory deal category missing');
        return category;
      },
      async cleanup({ entity }) {
        await db.delete(dealCategories).where(eq(dealCategories.id, entity.entityId));
      },
    },

    createDeal: {
      dependencyOrder: 30,
      reserve: (raw) => ({ kind: 'deal', id: dealInput.parse(raw).key }),
      async execute({ runId, input: raw }) {
        const parsed = dealInput.parse(raw);
        await requireOwned(store, runId, 'vendor', parsed.vendorId);
        const hasVariants = Boolean(parsed.axes?.length || parsed.skus?.length);
        if (hasVariants && (!parsed.axes?.length || !parsed.skus?.length)) {
          throw new Error('Variant deals require axes and skus');
        }
        const now = new Date();
        await db.insert(dealCategories).values({
          id: parsed.key,
          dealType: parsed.type,
          slug: `e2e-category-${parsed.key}`,
        });
        const created = await createDealWithSkus(db, {
          dealRow: {
            id: parsed.key,
            vendorId: parsed.vendorId,
            dealType: parsed.type,
            isPhysical: parsed.type === 'ITEM',
            title: parsed.title,
            description: `E2E factory ${runId}`,
            categoryId: parsed.key,
            dealState: 'DRAFT',
            windowStart: now,
            windowEnd: null,
            metadata: { e2eRunId: runId, e2eKey: parsed.key },
          },
          mode: hasVariants ? 'variants' : 'single',
          ...(hasVariants
            ? {
                variants: {
                  axes: parsed.axes!.map((axis, axisOrder) => ({
                    axisOrder,
                    kind: axis.kind,
                    nameHe: axis.nameHe,
                    nameEn: axis.nameEn,
                    options: axis.options.map((option, optionOrder) => ({
                      optionOrder,
                      ...option,
                    })),
                  })),
                  skus: parsed.skus!.map((sku) => ({
                    optionValueCodes: sku.optionValueCodes,
                    // sku_discount_percent_range requires 50-100; buyers pay discountedPrice,
                    // so priceAgorot stays the charged amount.
                    originalPrice: price(sku.priceAgorot * 2),
                    discountPercent: 50,
                    discountedPrice: price(sku.priceAgorot),
                    quantityTotal: sku.stock,
                  })),
                },
              }
            : {
                single: {
                  originalPrice: price(parsed.priceAgorot * 2),
                  discountPercent: 50,
                  discountedPrice: price(parsed.priceAgorot),
                  quantityTotal: parsed.stock,
                },
              }),
        });
        const slug = `e2e-${parsed.key}`;
        await db.insert(dealImages).values({
          dealId: created.dealId,
          // data: URI keeps the image CSP-clean and hermetic in browser E2E runs.
          url: 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==',
          isPrimary: true,
          approvalStatus: 'APPROVED',
        });
        if (parsed.type === 'ITEM') {
          await db.insert(dealItemConfig).values({
            dealId: created.dealId,
            handleSlaBusinessDays: 2,
            shippingMode: 'flat',
            shippingFlatAgorot: 0,
            pickupEnabled: parsed.fulfillment === 'pickup',
            returnWindowDays: 14,
          });
        }
        if (parsed.type === 'GROUP') {
          await db.insert(groupDeals).values({
            dealId: created.dealId,
            fillRule: 'ALL_OR_NOTHING',
            minGroupSize: 2,
            maxGroupSize: parsed.stock,
            perCustomerLimit: 1,
          });
        }
        await db
          .update(deals)
          .set({
            dealState: parsed.state,
            approvedAt: parsed.state === 'ACTIVE' ? now : null,
            approvedBy: parsed.state === 'ACTIVE' ? 'HUMAN' : null,
            soldOutAt: parsed.state === 'SOLD_OUT' ? now : null,
            pickupAddress: parsed.pickupAddress,
            pickupStart: parsed.pickupStart,
            pickupEnd: parsed.pickupEnd,
          })
          .where(eq(deals.id, created.dealId));
        await Promise.all(
          ['he', 'en'].map((locale) =>
            dealTranslationQueries.insertDealTranslation(db, {
              dealId: created.dealId,
              locale,
              slug,
              title: parsed.title,
              description: `E2E factory ${runId}`,
            }),
          ),
        );
        return {
          entity: { kind: 'deal', id: created.dealId },
          result: {
            dealId: created.dealId,
            vendorId: parsed.vendorId,
            slug,
            runId,
            currency: 'ILS',
          },
        };
      },
      async read({ entity }) {
        const [deal] = await db
          .select({
            dealId: deals.id,
            vendorId: deals.vendorId,
            type: deals.dealType,
            title: deals.title,
            state: deals.dealState,
            minPrice: deals.minPrice,
            maxPrice: deals.maxPrice,
            stockRemaining: deals.stockRemaining,
            approvedBy: deals.approvedBy,
            translationStatus: deals.translationStatus,
          })
          .from(deals)
          .where(eq(deals.id, entity.entityId))
          .limit(1);
        if (!deal) throw new Error('Factory deal missing');
        const [translation] = await db
          .select({ slug: dealTranslations.slug })
          .from(dealTranslations)
          .where(
            and(eq(dealTranslations.dealId, entity.entityId), eq(dealTranslations.locale, 'he')),
          )
          .limit(1);
        const [englishTranslation] = await db
          .select({
            title: dealTranslations.title,
            description: dealTranslations.description,
            status: dealTranslations.status,
          })
          .from(dealTranslations)
          .where(
            and(eq(dealTranslations.dealId, entity.entityId), eq(dealTranslations.locale, 'en')),
          )
          .limit(1);
        const skus = await db
          .select({
            skuId: dealSkus.id,
            optionIds: dealSkus.optionIds,
            optionIdsHash: dealSkus.optionIdsHash,
            price: dealSkus.discountedPrice,
            stock: dealSkus.quantityTotal,
            sold: dealSkus.quantitySold,
            isActive: dealSkus.isActive,
          })
          .from(dealSkus)
          .where(eq(dealSkus.dealId, entity.entityId));
        const reviewEvents = await db
          .select({ eventType: outbox.eventType, payload: outbox.payload })
          .from(outbox)
          .where(
            and(
              eq(outbox.aggregateType, 'deal'),
              eq(outbox.aggregateId, entity.entityId),
              eq(outbox.eventType, 'deal.review_required'),
            ),
          );
        const persistedShareLinks = await db
          .select({
            channel: shareLinks.channel,
            targetUrl: shareLinks.targetUrl,
          })
          .from(shareLinks)
          .where(eq(shareLinks.dealId, entity.entityId));
        return {
          ...deal,
          slug: translation?.slug ?? null,
          englishTranslation: englishTranslation ?? null,
          reviewEvents,
          shareLinks: persistedShareLinks,
          currency: 'ILS',
          skus,
        };
      },
      async cleanup({ entity }) {
        await db.delete(shareLinks).where(eq(shareLinks.dealId, entity.entityId));
        await db.delete(wishlistItems).where(eq(wishlistItems.dealId, entity.entityId));
        await db.delete(userRecentlyViewed).where(eq(userRecentlyViewed.dealId, entity.entityId));
        await db.delete(dealSkus).where(eq(dealSkus.dealId, entity.entityId));
        const axes = await db
          .select({ id: dealVariantAxes.id })
          .from(dealVariantAxes)
          .where(eq(dealVariantAxes.dealId, entity.entityId));
        for (const axis of axes) {
          await db.delete(dealVariantOptions).where(eq(dealVariantOptions.axisId, axis.id));
        }
        await db.delete(dealVariantAxes).where(eq(dealVariantAxes.dealId, entity.entityId));
        await db.delete(dealImages).where(eq(dealImages.dealId, entity.entityId));
        await db.delete(dealItemConfig).where(eq(dealItemConfig.dealId, entity.entityId));
        await db.delete(groupDeals).where(eq(groupDeals.dealId, entity.entityId));
        await db.delete(dealTranslations).where(eq(dealTranslations.dealId, entity.entityId));
        await db.delete(deals).where(eq(deals.id, entity.entityId));
        await db.delete(dealCategories).where(eq(dealCategories.id, entity.entityId));
      },
    },

    setDealSkuActive: {
      dependencyOrder: 31,
      async execute({ runId, input: raw }) {
        const parsed = dealSkuStateInput.parse(raw);
        await requireOwned(store, runId, 'deal', parsed.dealId);
        const updated = await db
          .update(dealSkus)
          .set({ isActive: parsed.isActive })
          .where(and(eq(dealSkus.id, parsed.skuId), eq(dealSkus.dealId, parsed.dealId)))
          .returning({ skuId: dealSkus.id });
        if (updated.length !== 1) throw new Error('Factory deal SKU missing');

        const activeSkus = await db
          .select({
            stock: dealSkus.quantityTotal,
            sold: dealSkus.quantitySold,
          })
          .from(dealSkus)
          .where(and(eq(dealSkus.dealId, parsed.dealId), eq(dealSkus.isActive, true)));
        const stockRemaining = activeSkus.reduce((sum, sku) => sum + sku.stock - sku.sold, 0);
        await db.update(deals).set({ stockRemaining }).where(eq(deals.id, parsed.dealId));
        return {
          result: {
            dealId: parsed.dealId,
            skuId: parsed.skuId,
            isActive: parsed.isActive,
          },
        };
      },
      async read() {
        throw new Error('setDealSkuActive does not own an entity');
      },
      async cleanup() {
        throw new Error('setDealSkuActive does not own an entity');
      },
    },

    adoptPurchase: {
      dependencyOrder: 40,
      async execute({ runId, input: raw }) {
        const parsed = adoptPurchaseInput.parse(raw);
        await requireOwned(store, runId, 'actor', parsed.buyerUserId);
        await requireOwned(store, runId, 'deal', parsed.dealId);
        const [purchase] = await db
          .select({
            purchaseId: orderLine.id,
            orderId: orderLine.orderId,
            buyerUserId: order.buyerUserId,
            dealId: dealSkus.dealId,
          })
          .from(orderLine)
          .innerJoin(order, eq(order.id, orderLine.orderId))
          .innerJoin(dealSkus, eq(dealSkus.id, orderLine.variantId))
          .where(eq(orderLine.id, parsed.purchaseId))
          .limit(1);
        if (
          !purchase ||
          purchase.buyerUserId !== parsed.buyerUserId ||
          purchase.dealId !== parsed.dealId
        ) {
          throw new Error('Purchase does not match run-owned buyer and deal');
        }
        const siblingLines = await db
          .select({ id: orderLine.id })
          .from(orderLine)
          .where(eq(orderLine.orderId, purchase.orderId));
        assertSingleOrderLine(siblingLines.length);
        return {
          entity: {
            kind: 'purchase',
            id: parsed.purchaseId,
            operation: 'createPurchase',
          },
          result: { purchaseId: parsed.purchaseId, runId, adopted: true },
        };
      },
      async read() {
        throw new Error('Adopted purchase read must use canonical purchase handler');
      },
      async cleanup() {
        throw new Error('Adopted purchase cleanup must use canonical purchase handler');
      },
    },

    adoptPersonalDealRequest: {
      dependencyOrder: 50,
      async execute({ runId, input: raw }) {
        const parsed = adoptPersonalDealRequestInput.parse(raw);
        await requireOwned(store, runId, 'actor', parsed.buyerUserId);
        await requireOwned(store, runId, 'vendor', parsed.vendorId);
        await requireOwned(store, runId, 'deal', parsed.sourceDealId);
        const [request] = await db
          .select({
            requestId: personalDealRequests.id,
            buyerUserId: personalDealRequests.userId,
            vendorId: personalDealRequests.vendorId,
            sourceDealId: personalDealRequests.sourceDealId,
          })
          .from(personalDealRequests)
          .where(eq(personalDealRequests.id, parsed.requestId))
          .limit(1);
        if (
          !request ||
          request.buyerUserId !== parsed.buyerUserId ||
          request.vendorId !== parsed.vendorId ||
          request.sourceDealId !== parsed.sourceDealId
        ) {
          throw new Error('Personal deal request does not match run-owned actors and deal');
        }
        return {
          entity: { kind: 'personal-deal-request', id: parsed.requestId },
          result: { requestId: parsed.requestId, runId },
        };
      },
      async read({ entity }) {
        const [request] = await db
          .select({
            requestId: personalDealRequests.id,
            buyerUserId: personalDealRequests.userId,
            vendorId: personalDealRequests.vendorId,
            sourceDealId: personalDealRequests.sourceDealId,
            status: personalDealRequests.status,
            responseDeadline: personalDealRequests.responseDeadline,
            respondedAt: personalDealRequests.respondedAt,
            createdDealId: personalDealRequests.createdDealId,
          })
          .from(personalDealRequests)
          .where(eq(personalDealRequests.id, entity.entityId))
          .limit(1);
        if (!request) throw new Error('Factory personal deal request missing');
        const [createdDeal] = request.createdDealId
          ? await db
              .select({
                dealId: deals.id,
                vendorId: deals.vendorId,
                state: deals.dealState,
                isPersonalDeal: deals.isPersonalDeal,
                personalDealForUserId: deals.personalDealForUserId,
                minPrice: deals.minPrice,
                maxPrice: deals.maxPrice,
                stockRemaining: deals.stockRemaining,
              })
              .from(deals)
              .where(eq(deals.id, request.createdDealId))
              .limit(1)
          : [];
        return {
          ...request,
          responseDeadline: request.responseDeadline.toISOString(),
          respondedAt: request.respondedAt?.toISOString() ?? null,
          createdDeal: createdDeal ?? null,
        };
      },
      async cleanup({ entity }) {
        const [request] = await db
          .select({ createdDealId: personalDealRequests.createdDealId })
          .from(personalDealRequests)
          .where(eq(personalDealRequests.id, entity.entityId))
          .limit(1);
        await disarmPersonalOfferAlarm(entity.entityId);
        await db.delete(personalDealRequests).where(eq(personalDealRequests.id, entity.entityId));
        if (request?.createdDealId) {
          await db.delete(deals).where(eq(deals.id, request.createdDealId));
        }
      },
    },

    createPurchase: {
      dependencyOrder: 40,
      reserve: (raw) => ({
        kind: 'purchase',
        id: purchaseInputSchema.parse(raw).key,
      }),
      async execute({ runId, input: raw }) {
        const parsed = purchaseInputSchema.parse(raw);
        await requireOwned(store, runId, 'actor', parsed.buyerUserId);
        await requireOwned(store, runId, 'deal', parsed.dealId);
        const [deal] = await db
          .select({ vendorId: deals.vendorId, type: deals.dealType })
          .from(deals)
          .where(eq(deals.id, parsed.dealId))
          .limit(1);
        if (!deal) throw new Error('Factory deal missing');
        if (parsed.dealType && parsed.dealType !== deal.type)
          throw new Error('Factory deal type mismatch');
        const [sku] = await db
          .select({ id: dealSkus.id, price: dealSkus.discountedPrice })
          .from(dealSkus)
          .where(and(eq(dealSkus.dealId, parsed.dealId), eq(dealSkus.isActive, true)))
          .limit(1);
        if (!sku) throw new Error('Factory deal SKU missing');

        const paymentIntentId = `mock_payment_intent_${parsed.key}`;
        const chargeId = `mock_charge_${parsed.key}`;
        const unitPriceAgorot = Math.round(Number(sku.price) * 100);
        if (!Number.isSafeInteger(unitPriceAgorot) || unitPriceAgorot <= 0) {
          throw new Error('Factory deal SKU has invalid price');
        }
        const total = BigInt(unitPriceAgorot * parsed.quantity);
        await db.insert(order).values({
          id: parsed.orderId,
          buyerUserId: parsed.buyerUserId,
          status: 'paid',
          chargeRef: paymentIntentId,
          currency: 'ILS',
          priceMode: 'inclusive',
          subtotal: total,
          tax: 0n,
          discount: 0n,
          total,
          idempotencyKey: `e2e-factory-${runId}-${parsed.key}`,
          requestHash: JSON.stringify({
            operation: 'createPurchase',
            runId,
            key: parsed.key,
          }),
        });
        await db.insert(orderLine).values({
          id: parsed.key,
          orderId: parsed.orderId,
          variantId: sku.id,
          kind: deal.type === 'ITEM' ? 'physical' : 'voucher',
          qty: parsed.quantity,
          unitPrice: BigInt(unitPriceAgorot),
          lineTotal: total,
          vendorId: deal.vendorId,
        });

        let shipmentId: string | null = null;
        let deliveredAt: Date | null = null;
        if (deal.type === 'ITEM') {
          shipmentId = parsed.key;
          deliveredAt =
            parsed.deliveredAtDaysAgo == null
              ? null
              : new Date(Date.now() - parsed.deliveredAtDaysAgo * 86_400_000);
          await db.insert(shipments).values({
            id: shipmentId,
            vendorId: deal.vendorId,
            buyerId: parsed.buyerUserId,
            status: deliveredAt ? 'delivered' : 'pending',
            handleByAt: new Date(Date.now() + 2 * 86_400_000),
            deliveredAt,
          });
          await db.insert(shipmentPurchases).values({ shipmentId, orderLineId: parsed.key });
        }

        let voucherId: string | null = null;
        let qrToken: string | null = null;
        let voucherIds: string[] = [];
        let qrTokens: string[] = [];
        if (deal.type === 'COUPON') {
          const state = parsed.redemptionState ?? 'UNREDEEMED';
          const units = await buildFactoryVoucherUnits({
            lineId: parsed.key,
            quantity: parsed.quantity,
            qrSecret,
            firstQrTokenHash: parsed.qrTokenHash,
          });
          voucherIds = units.map((unit) => unit.voucherId);
          qrTokens = units.flatMap((unit) => (unit.qrToken ? [unit.qrToken] : []));
          voucherId = voucherIds[0] ?? null;
          qrToken = units[0]?.qrToken ?? null;
          for (const unit of units) {
            await db.insert(voucher).values({
              id: toModuleRef(asVoucherId(unit.voucherId)),
              orderId: toModuleRef(asOrderId(parsed.orderId)),
              lineId: toModuleRef(asOrderLineId(parsed.key)),
              unitIndex: unit.unitIndex,
              vendorId: toModuleRef(asVendorId(deal.vendorId)),
              state,
              expiresAt: new Date(Date.now() + 30 * 86_400_000),
              redeemedAt: state === 'REDEEMED' ? new Date() : null,
            });
            await db.insert(orderLineVoucherExt).values({
              voucherId: unit.voucherId,
              lineId: parsed.key,
              qrTokenHash: unit.qrTokenHash,
              reviewEligible: state === 'REDEEMED',
            });
          }
        }

        if (deal.type !== 'ITEM' || deliveredAt) {
          const heldAt = deliveredAt ?? new Date();
          const fee = Math.floor(Number(total) * 0.1);
          await db.insert(vendorPayoutReleases).values({
            orderLineId: parsed.key,
            vendorId: deal.vendorId,
            vendorAcctId: `mock_vendor_account_${deal.vendorId}`,
            paymentIntentId,
            chargeId,
            transferId: `mock_transfer_${parsed.key}`,
            netAmountAgorot: Number(total) - fee,
            applicationFeeAgorot: fee,
            status: parsed.settlementState === 'RELEASED' ? 'released' : 'held',
            triggerReason: triggerReasonFor(deal.type),
            heldAt,
            releaseAt: computeReleaseAt(deal.type, heldAt, 14),
            releasedAt: parsed.settlementState === 'RELEASED' ? new Date() : null,
            metadata: { e2eRunId: runId },
          });
        }
        return {
          entity: { kind: 'purchase', id: parsed.key },
          result: {
            purchaseId: parsed.key,
            orderId: parsed.orderId,
            buyerUserId: parsed.buyerUserId,
            dealId: parsed.dealId,
            shipmentId,
            voucherId,
            voucherIds,
            qrToken,
            qrTokens,
            paymentIntentId,
            runId,
          },
        };
      },
      async read({ entity }) {
        const [row] = await db
          .select({
            purchaseId: orderLine.id,
            orderId: orderLine.orderId,
            dealSkuId: orderLine.variantId,
            buyerUserId: order.buyerUserId,
            orderStatus: order.status,
            quantity: orderLine.qty,
            unitPriceAgorot: orderLine.unitPrice,
            lineTotalAgorot: orderLine.lineTotal,
            vendorId: orderLine.vendorId,
            paymentIntentId: order.chargeRef,
            currency: order.currency,
          })
          .from(orderLine)
          .innerJoin(order, eq(order.id, orderLine.orderId))
          .where(eq(orderLine.id, entity.entityId))
          .limit(1);
        if (!row) throw new Error('Factory purchase missing');
        const [delivery] = await db
          .select({
            status: shipments.status,
            deliveredAt: shipments.deliveredAt,
          })
          .from(shipmentPurchases)
          .innerJoin(shipments, eq(shipments.id, shipmentPurchases.shipmentId))
          .where(eq(shipmentPurchases.orderLineId, entity.entityId))
          .limit(1);
        const [redemption] = await db
          .select({ state: voucher.state, redeemedAt: voucher.redeemedAt })
          .from(voucher)
          .where(eq(voucher.lineId, entity.entityId))
          .limit(1);
        const [hold] = await db
          .select({
            status: vendorPayoutReleases.status,
            releaseAt: vendorPayoutReleases.releaseAt,
          })
          .from(vendorPayoutReleases)
          .where(eq(vendorPayoutReleases.orderLineId, entity.entityId))
          .limit(1);
        const [refunds] = await db
          .select({
            intentCount: sql<number>`COUNT(${refundIntent.id})::int`,
            pendingAgorot: sql<number>`COALESCE(SUM(${refundIntent.amount}) FILTER (WHERE ${refundIntent.status} = 'pending'), 0)::int`,
            executedAgorot: sql<number>`COALESCE(SUM(${refundIntent.amount}) FILTER (WHERE ${refundIntent.status} = 'executed'), 0)::int`,
            failedAgorot: sql<number>`COALESCE(SUM(${refundIntent.amount}) FILTER (WHERE ${refundIntent.status} = 'failed'), 0)::int`,
          })
          .from(refundIntentLineExt)
          .innerJoin(refundIntent, eq(refundIntent.id, refundIntentLineExt.refundIntentId))
          .where(eq(refundIntentLineExt.orderLineId, entity.entityId));
        return {
          ...row,
          unitPriceAgorot: Number(row.unitPriceAgorot),
          lineTotalAgorot: Number(row.lineTotalAgorot),
          delivery: delivery
            ? {
                status: delivery.status,
                deliveredAt: delivery.deliveredAt?.toISOString() ?? null,
              }
            : null,
          redemption: redemption
            ? {
                state: redemption.state,
                redeemedAt: redemption.redeemedAt?.toISOString() ?? null,
              }
            : null,
          settlement: hold
            ? { status: hold.status, releaseAt: hold.releaseAt.toISOString() }
            : null,
          refunds: refunds ?? {
            intentCount: 0,
            pendingAgorot: 0,
            executedAgorot: 0,
            failedAgorot: 0,
          },
        };
      },
      async cleanup({ entity }) {
        const [line] = await db
          .select({ orderId: orderLine.orderId })
          .from(orderLine)
          .where(eq(orderLine.id, entity.entityId))
          .limit(1);
        if (!line) return;
        const orderLines = await db
          .select({ id: orderLine.id })
          .from(orderLine)
          .where(eq(orderLine.orderId, line.orderId));
        assertSingleOrderLine(orderLines.length);
        await db.delete(returns).where(eq(returns.orderLineId, entity.entityId));
        const linkedCases = await db
          .select({ id: transactionCases.id })
          .from(transactionCases)
          .where(eq(transactionCases.orderLineId, entity.entityId));
        for (const linkedCase of linkedCases) {
          await db.delete(caseOffers).where(eq(caseOffers.caseId, linkedCase.id));
          await db.delete(caseResolutions).where(eq(caseResolutions.caseId, linkedCase.id));
        }
        await db.delete(transactionCases).where(eq(transactionCases.orderLineId, entity.entityId));
        await db
          .delete(vendorPayoutReleases)
          .where(eq(vendorPayoutReleases.orderLineId, entity.entityId));
        await db
          .delete(refundIntentLineExt)
          .where(eq(refundIntentLineExt.orderLineId, entity.entityId));
        await db.delete(refundIntent).where(eq(refundIntent.orderId, line.orderId));
        await db.delete(orderLineVoucherExt).where(eq(orderLineVoucherExt.lineId, entity.entityId));
        await db.delete(voucher).where(eq(voucher.lineId, entity.entityId));
        const linked = await db
          .select({ shipmentId: shipmentPurchases.shipmentId })
          .from(shipmentPurchases)
          .where(eq(shipmentPurchases.orderLineId, entity.entityId));
        await db
          .delete(shipmentPurchases)
          .where(eq(shipmentPurchases.orderLineId, entity.entityId));
        for (const item of linked)
          await db.delete(shipments).where(eq(shipments.id, item.shipmentId));
        await db
          .delete(groupReservations)
          .where(eq(groupReservations.orderLineId, entity.entityId));
        await db
          .delete(userGalleryImages)
          .where(eq(userGalleryImages.orderLineId, entity.entityId));
        await db.delete(orderLine).where(eq(orderLine.id, entity.entityId));
        await db.delete(order).where(eq(order.id, line.orderId));
      },
    },
  };
}