@nlabs/reaktor 1.18.0 → 1.20.0-reactorbox.1

package/lib/actions/crmCanonicalPolicy.d.ts

@@ -0,0 +1,92 @@
+import type Stripe from 'stripe';
+export interface CrmCanonicalEvent {
+    adjustmentId?: string;
+    amountMinor?: number;
+    campaignId: string;
+    currency?: string;
+    deleted?: true;
+    eventId: string;
+    occurredAt: string;
+    orderId?: string;
+    productId?: string;
+    projectId: string;
+    revision: number;
+    type: 'lead' | 'qualified_lead' | 'lead_won' | 'lead_lost' | 'purchase' | 'refund' | 'order_canceled';
+    version: 1;
+}
+export interface CrmCanonicalAssociation {
+    appId: string;
+    campaignId: string;
+    canonicalConsent?: {
+        evidenceRef: string;
+        expiresAt: number;
+        purpose: 'canonical_campaign_outcomes';
+    };
+    id: string;
+    kind: string;
+    organizationId: string;
+    productId?: string;
+    projectId: string;
+    revision: number;
+    sourceId: string;
+    sourceRevision: string;
+    status: string;
+}
+export interface CrmCanonicalNativeHistory {
+    association: CrmCanonicalAssociation;
+    source: {
+        revision: string;
+        history: {
+            at: number;
+            id?: string;
+            revision?: number;
+            stage: string;
+            deleted?: boolean;
+        }[];
+        truncated?: boolean;
+        deleted?: boolean;
+    };
+    suppressed: boolean;
+}
+export declare const crmCanonicalDigest: (value: unknown) => string;
+/** Only real versioned native observations are eligible; legacy timestamps never become fabricated history. */
+export declare const crmCanonicalHistoryEvents: (row: CrmCanonicalNativeHistory, at: number) => {
+    events: CrmCanonicalEvent[];
+    held: string;
+    incomplete: boolean;
+};
+export interface CrmFinancialVerificationSource {
+    amountMinor: number;
+    chargeId: string;
+    currency: string;
+    customerId: string;
+    invoiceIssuedAt: number;
+    invoiceStatus: string;
+    invoiceTotalMinor: number;
+    nativePaymentAmountMinor: number;
+    nativePaymentChargeId: string;
+    nativePaymentCurrency: string;
+    nativePaymentUserId: string;
+    settlementReference: string;
+    userId: string;
+}
+export interface CrmVerifiedFinancialProviderEvidence {
+    amountMinor: number;
+    chargeId: string;
+    currency: string;
+    occurredAt: number;
+    provider: 'stripe';
+    refunds: {
+        amountMinor: number;
+        id: string;
+        occurredAt: number;
+    }[];
+    revision: string;
+}
+type ReadClient = Pick<Stripe, 'charges' | 'customers' | 'refunds'>;
+/** GET-only verification of an existing payment; legal registration alone cannot establish external settlement. */
+export declare const verifyCrmFinancialProviderEvidence: (source: CrmFinancialVerificationSource, at: number, client?: ReadClient) => Promise<{
+    evidence?: CrmVerifiedFinancialProviderEvidence;
+    held?: string;
+}>;
+export {};

package/lib/actions/crmCanonicalPolicy.js

@@ -0,0 +1,104 @@
+import { createHash } from 'node:crypto';
+import { getStripeClient } from '../utils/stripeUtils.js';
+export const crmCanonicalDigest = (value)=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const stages = {
+    lost: 'lead_lost',
+    new: 'lead',
+    qualified: 'qualified_lead',
+    won: 'lead_won'
+};
+/** Only real versioned native observations are eligible; legacy timestamps never become fabricated history. */ export const crmCanonicalHistoryEvents = (row, at)=>{
+    const { association, source } = row;
+    if (association.status !== 'active' || row.suppressed || source.deleted || source.revision !== association.sourceRevision || association.canonicalConsent?.purpose !== 'canonical_campaign_outcomes' || !Number.isFinite(association.canonicalConsent.expiresAt) || association.canonicalConsent.expiresAt <= at) {
+        return {
+            events: [],
+            held: 'source_or_consent_withdrawn',
+            incomplete: false
+        };
+    }
+    if (source.truncated || source.history.length > 100 || source.history.some((event)=>!event.id || !/^[a-f0-9]{64}$/.test(event.id) || !Number.isSafeInteger(event.revision) || event.revision < 1 || !Number.isSafeInteger(event.at) || event.at > at + 60000 || !Object.hasOwn(stages, event.stage))) {
+        return {
+            events: [],
+            held: 'unversioned_or_truncated_history',
+            incomplete: true
+        };
+    }
+    const events = source.history.filter((event)=>!event.deleted).map((event)=>({
+            campaignId: association.campaignId,
+            eventId: crmCanonicalDigest([
+                association.appId,
+                association.organizationId,
+                association.projectId,
+                association.campaignId,
+                association.id,
+                event.id,
+                event.stage
+            ]),
+            occurredAt: new Date(event.at).toISOString(),
+            productId: association.productId,
+            projectId: association.projectId,
+            revision: event.revision,
+            type: stages[event.stage],
+            version: 1
+        }));
+    return {
+        events,
+        held: undefined,
+        incomplete: false
+    };
+};
+/** GET-only verification of an existing payment; legal registration alone cannot establish external settlement. */ export const verifyCrmFinancialProviderEvidence = async (source, at, client)=>{
+    if (typeof source.nativePaymentCurrency !== 'string' || typeof source.currency !== 'string' || !/^ch_[A-Za-z0-9]{1,160}$/.test(source.chargeId) || !/^cus_[A-Za-z0-9]{1,160}$/.test(source.customerId) || source.settlementReference !== source.chargeId || source.nativePaymentChargeId !== source.chargeId || source.nativePaymentUserId !== source.userId || source.nativePaymentAmountMinor !== source.amountMinor || source.nativePaymentCurrency.toUpperCase() !== source.currency || source.invoiceStatus !== 'issued' || source.invoiceTotalMinor !== source.amountMinor || !Number.isSafeInteger(source.amountMinor) || source.amountMinor <= 0 || !/^[A-Z]{3}$/.test(source.currency) || !Number.isSafeInteger(source.invoiceIssuedAt) || source.invoiceIssuedAt > at) {
+        return {
+            held: 'native_legal_payment_binding_unverified'
+        };
+    }
+    let charge;
+    let customer;
+    let refunds;
+    try {
+        const provider = client || getStripeClient();
+        [charge, customer, refunds] = await Promise.all([
+            provider.charges.retrieve(source.chargeId),
+            provider.customers.retrieve(source.customerId),
+            provider.refunds.list({
+                charge: source.chargeId,
+                limit: 100
+            })
+        ]);
+    } catch  {
+        return {
+            held: 'provider_verification_unavailable'
+        };
+    }
+    const chargeCustomerId = typeof charge.customer === 'string' ? charge.customer : charge.customer?.id;
+    if (charge.id !== source.chargeId || chargeCustomerId !== source.customerId || customer.id !== source.customerId || customer.deleted || !('metadata' in customer) || customer.metadata.userId !== source.userId || charge.paid !== true || charge.captured !== true || charge.status !== 'succeeded' || charge.disputed || charge.livemode !== true || charge.amount !== source.amountMinor || charge.amount_captured !== source.amountMinor || charge.currency.toUpperCase() !== source.currency || !Number.isSafeInteger(charge.created) || charge.created * 1000 > at + 60000 || charge.created * 1000 < source.invoiceIssuedAt) {
+        return {
+            held: 'provider_customer_or_settlement_mismatch'
+        };
+    }
+    if (refunds.has_more || refunds.data.length > 100 || refunds.data.some((refund)=>refund.charge !== charge.id || refund.currency.toUpperCase() !== source.currency || refund.status !== 'succeeded' || !Number.isSafeInteger(refund.amount) || refund.amount <= 0 || !Number.isSafeInteger(refund.created) || refund.created < charge.created || refund.created * 1000 > at + 60000) || new Set(refunds.data.map((refund)=>refund.id)).size !== refunds.data.length || refunds.data.reduce((sum, refund)=>sum + refund.amount, 0) !== charge.amount_refunded || charge.amount_refunded > charge.amount) {
+        return {
+            held: 'provider_refund_evidence_incomplete'
+        };
+    }
+    const evidence = {
+        amountMinor: charge.amount,
+        chargeId: charge.id,
+        currency: source.currency,
+        occurredAt: charge.created * 1000,
+        provider: 'stripe',
+        refunds: refunds.data.map((refund)=>({
+                amountMinor: refund.amount,
+                id: refund.id,
+                occurredAt: refund.created * 1000
+            })).sort((left, right)=>left.id.localeCompare(right.id)),
+        revision: ''
+    };
+    evidence.revision = crmCanonicalDigest(evidence);
+    return {
+        evidence
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/crmCanonicalPolicy.ts"],"sourcesContent":["import {createHash} from 'node:crypto';\n\nimport {getStripeClient} from '../utils/stripeUtils.js';\n\nimport type Stripe from 'stripe';\n\nexport interface CrmCanonicalEvent {\n  adjustmentId?: string;\n  amountMinor?: number;\n  campaignId: string;\n  currency?: string;\n  deleted?: true;\n  eventId: string;\n  occurredAt: string;\n  orderId?: string;\n  productId?: string;\n  projectId: string;\n  revision: number;\n  type: 'lead' | 'qualified_lead' | 'lead_won' | 'lead_lost' | 'purchase' | 'refund' | 'order_canceled';\n  version: 1;\n}\nexport interface CrmCanonicalAssociation {\n  appId: string;\n  campaignId: string;\n  canonicalConsent?: {evidenceRef: string; expiresAt: number; purpose: 'canonical_campaign_outcomes'};\n  id: string;\n  kind: string;\n  organizationId: string;\n  productId?: string;\n  projectId: string;\n  revision: number;\n  sourceId: string;\n  sourceRevision: string;\n  status: string;\n}\nexport interface CrmCanonicalNativeHistory {\n  association: CrmCanonicalAssociation;\n  source: {revision: string; history: {at: number; id?: string; revision?: number; stage: string; deleted?: boolean}[];\n    truncated?: boolean; deleted?: boolean;};\n  suppressed: boolean;\n}\nexport const crmCanonicalDigest = (value: unknown): string =>\n  createHash('sha256').update(JSON.stringify(value)).digest('hex');\nconst stages = {lost: 'lead_lost', new: 'lead', qualified: 'qualified_lead', won: 'lead_won'} as const;\n/** Only real versioned native observations are eligible; legacy timestamps never become fabricated history. */\nexport const crmCanonicalHistoryEvents = (row: CrmCanonicalNativeHistory, at: number) => {\n  const {association, source} = row;\n  if(association.status !== 'active' || row.suppressed || source.deleted\n    || source.revision !== association.sourceRevision\n    || association.canonicalConsent?.purpose !== 'canonical_campaign_outcomes'\n    || !Number.isFinite(association.canonicalConsent.expiresAt) || association.canonicalConsent.expiresAt <= at) {\n    return {events: [] as CrmCanonicalEvent[], held: 'source_or_consent_withdrawn', incomplete: false};\n  }\n  if(source.truncated || source.history.length > 100 || source.history.some((event) =>\n    !event.id || !/^[a-f0-9]{64}$/.test(event.id) || !Number.isSafeInteger(event.revision) || event.revision! < 1\n    || !Number.isSafeInteger(event.at) || event.at > at + 60000 || !Object.hasOwn(stages, event.stage))) {\n    return {events: [] as CrmCanonicalEvent[], held: 'unversioned_or_truncated_history', incomplete: true};\n  }\n  const events: CrmCanonicalEvent[] = source.history.filter((event) => !event.deleted).map((event) => ({\n    campaignId: association.campaignId,\n    eventId: crmCanonicalDigest([association.appId, association.organizationId, association.projectId,\n      association.campaignId, association.id, event.id, event.stage]), occurredAt: new Date(event.at).toISOString(),\n    productId: association.productId, projectId: association.projectId, revision: event.revision!,\n    type: stages[event.stage as keyof typeof stages], version: 1}));\n  return {events, held: undefined, incomplete: false};\n};\nexport interface CrmFinancialVerificationSource {\n  amountMinor: number;\n  chargeId: string;\n  currency: string;\n  customerId: string;\n  invoiceIssuedAt: number;\n  invoiceStatus: string;\n  invoiceTotalMinor: number;\n  nativePaymentAmountMinor: number;\n  nativePaymentChargeId: string;\n  nativePaymentCurrency: string;\n  nativePaymentUserId: string;\n  settlementReference: string;\n  userId: string;\n}\nexport interface CrmVerifiedFinancialProviderEvidence {\n  amountMinor: number;\n  chargeId: string;\n  currency: string;\n  occurredAt: number;\n  provider: 'stripe';\n  refunds: {amountMinor: number; id: string; occurredAt: number}[];\n  revision: string;\n}\ntype ReadClient = Pick<Stripe, 'charges' | 'customers' | 'refunds'>;\n/** GET-only verification of an existing payment; legal registration alone cannot establish external settlement. */\nexport const verifyCrmFinancialProviderEvidence = async (\n  source: CrmFinancialVerificationSource, at: number, client?: ReadClient\n): Promise<{evidence?: CrmVerifiedFinancialProviderEvidence; held?: string}> => {\n  if(typeof source.nativePaymentCurrency !== 'string' || typeof source.currency !== 'string'\n    || !/^ch_[A-Za-z0-9]{1,160}$/.test(source.chargeId) || !/^cus_[A-Za-z0-9]{1,160}$/.test(source.customerId)\n    || source.settlementReference !== source.chargeId || source.nativePaymentChargeId !== source.chargeId\n    || source.nativePaymentUserId !== source.userId || source.nativePaymentAmountMinor !== source.amountMinor\n    || source.nativePaymentCurrency.toUpperCase() !== source.currency || source.invoiceStatus !== 'issued'\n    || source.invoiceTotalMinor !== source.amountMinor || !Number.isSafeInteger(source.amountMinor)\n    || source.amountMinor <= 0 || !/^[A-Z]{3}$/.test(source.currency)\n    || !Number.isSafeInteger(source.invoiceIssuedAt) || source.invoiceIssuedAt > at) {\n    return {held: 'native_legal_payment_binding_unverified'};\n  }\n  let charge: Stripe.Charge;\n  let customer: Stripe.Customer | Stripe.DeletedCustomer;\n  let refunds: Stripe.ApiList<Stripe.Refund>;\n  try {\n    const provider = client || getStripeClient();\n    [charge, customer, refunds] = await Promise.all([provider.charges.retrieve(source.chargeId),\n      provider.customers.retrieve(source.customerId), provider.refunds.list({charge: source.chargeId, limit: 100})]);\n  } catch{\n    return {held: 'provider_verification_unavailable'};\n  }\n  const chargeCustomerId = typeof charge.customer === 'string' ? charge.customer : charge.customer?.id;\n  if(charge.id !== source.chargeId || chargeCustomerId !== source.customerId || customer.id !== source.customerId\n    || customer.deleted || !('metadata' in customer) || customer.metadata.userId !== source.userId\n      || charge.paid !== true || charge.captured !== true\n    || charge.status !== 'succeeded' || charge.disputed || charge.livemode !== true\n    || charge.amount !== source.amountMinor || charge.amount_captured !== source.amountMinor\n    || charge.currency.toUpperCase() !== source.currency || !Number.isSafeInteger(charge.created)\n    || charge.created * 1000 > at + 60000 || charge.created * 1000 < source.invoiceIssuedAt) {\n    return {held: 'provider_customer_or_settlement_mismatch'};\n  }\n  if(refunds.has_more || refunds.data.length > 100 || refunds.data.some((refund) =>\n    refund.charge !== charge.id || refund.currency.toUpperCase() !== source.currency || refund.status !== 'succeeded'\n    || !Number.isSafeInteger(refund.amount) || refund.amount <= 0 || !Number.isSafeInteger(refund.created)\n    || refund.created < charge.created || refund.created * 1000 > at + 60000)\n    || new Set(refunds.data.map((refund) => refund.id)).size !== refunds.data.length\n    || refunds.data.reduce((sum, refund) => sum + refund.amount, 0) !== charge.amount_refunded\n    || charge.amount_refunded > charge.amount) {\n    return {held: 'provider_refund_evidence_incomplete'};\n  }\n  const evidence: CrmVerifiedFinancialProviderEvidence = {amountMinor: charge.amount, chargeId: charge.id,\n    currency: source.currency, occurredAt: charge.created * 1000, provider: 'stripe',\n    refunds: refunds.data.map((refund) => ({amountMinor: refund.amount, id: refund.id,\n      occurredAt: refund.created * 1000}))\n      .sort((left, right) => left.id.localeCompare(right.id)), revision: ''};\n  evidence.revision = crmCanonicalDigest(evidence);\n  return {evidence};\n};\n"],"names":["createHash","getStripeClient","crmCanonicalDigest","value","update","JSON","stringify","digest","stages","lost","new","qualified","won","crmCanonicalHistoryEvents","row","at","association","source","status","suppressed","deleted","revision","sourceRevision","canonicalConsent","purpose","Number","isFinite","expiresAt","events","held","incomplete","truncated","history","length","some","event","id","test","isSafeInteger","Object","hasOwn","stage","filter","map","campaignId","eventId","appId","organizationId","projectId","occurredAt","Date","toISOString","productId","type","version","undefined","verifyCrmFinancialProviderEvidence","client","nativePaymentCurrency","currency","chargeId","customerId","settlementReference","nativePaymentChargeId","nativePaymentUserId","userId","nativePaymentAmountMinor","amountMinor","toUpperCase","invoiceStatus","invoiceTotalMinor","invoiceIssuedAt","charge","customer","refunds","provider","Promise","all","charges","retrieve","customers","list","limit","chargeCustomerId","metadata","paid","captured","disputed","livemode","amount","amount_captured","created","has_more","data","refund","Set","size","reduce","sum","amount_refunded","evidence","sort","left","right","localeCompare"],"mappings":"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"}

package/lib/actions/crmCheckoutRecovery.d.ts

@@ -0,0 +1,72 @@
+import { useDb } from '../utils/arangodbUtils.js';
+import { authorizeCrmExecutionGrant } from './crmExecution.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { CrmCheckoutRecoveryBinding } from './crmCheckoutRecoveryPolicy.js';
+type Db = ReturnType<typeof useDb>;
+type Grant = Awaited<ReturnType<typeof authorizeCrmExecutionGrant>>;
+export interface CrmCheckoutRecoveryCandidate {
+    appId: string;
+    campaignId: string;
+    email: string;
+    expiresAt: string;
+    id: string;
+    observedAt: string;
+    organizationId: string;
+    projectId: string;
+    reason: 'verified_unrecovered_checkout';
+    recoveryLinkHash?: string;
+    revision: string;
+    sourceId: string;
+    targetId: string;
+    targetRevision: string;
+}
+interface Candidate extends CrmCheckoutRecoveryCandidate {
+    _key: string;
+    bindingId: string;
+    bindingRevision: string;
+    proofRevision: string;
+}
+/** Only the authenticated customer can record this independent purpose; administrators cannot imply consent. */
+export declare const recordCrmCheckoutRecoveryConsent: (context: ApiContext, input: {
+    appId: string;
+    consent: boolean;
+    expectedUserRevision: string;
+    expiresAt: number;
+}, now?: () => number) => Promise<boolean>;
+/** Registration binds verified existing source identities; it neither grants consent nor sends a message. */
+export declare const registerCrmCheckoutRecoveryBinding: (context: ApiContext, input: {
+    appId: string;
+    associationId: string;
+    checkoutId: string;
+    expectedAssociationRevision: string;
+    expectedUserRevision: string;
+    sourceId: string;
+    userId: string;
+}, now?: () => number, request?: (url: string, params?: any, options?: import("@nlabs/rip-hunter").HunterOptionsType) => Promise<any>) => Promise<{
+    id: string;
+    status: 'registered';
+}>;
+/** Every review and execution repeats protected source and native identity checks. */
+export declare const validateCrmCheckoutRecoveryCandidate: (db: Db, grant: Grant, value: CrmCheckoutRecoveryBinding, now?: () => number, query?: any, request?: (url: string, params?: any, options?: import("@nlabs/rip-hunter").HunterOptionsType) => Promise<any>, receiptId?: string) => Promise<Candidate & {
+    verifiedRecoveryUrl?: string;
+}>;
+export declare const generateCrmCheckoutRecoveryCandidates: (context: ApiContext, input: {
+    appId: string;
+    campaignId: string;
+    limit: number;
+    organizationId: string;
+    projectId: string;
+    sourceId: string;
+}, now?: () => number, request?: (url: string, params?: any, options?: import("@nlabs/rip-hunter").HunterOptionsType) => Promise<any>) => Promise<{
+    appId: string;
+    campaignId: string;
+    candidates: CrmCheckoutRecoveryCandidate[];
+    generatedAt: string;
+    held: Record<string, number>;
+    organizationId: string;
+    projectId: string;
+    schemaVersion: string;
+    sourceId: string;
+    truncated: boolean;
+}>;
+export {};