@nlabs/reaktor 1.18.0 → 1.20.0-reactorbox.1

package/lib/actions/supportChannelSources.js

@@ -0,0 +1,183 @@
+/* eslint-disable no-underscore-dangle -- Native source document revisions. */ import { aql } from 'arangojs';
+import { createHash, randomUUID } from 'node:crypto';
+import { scopeContextToApp } from '../utils/appContext.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { requireCrmAdministrator } from './crm.js';
+import { ensureOwnerExecutionCollection } from './crmExecution.js';
+export const supportChannelCollections = [
+    'supportChannelSources',
+    'supportChannelBindings',
+    'supportChannelEvents',
+    'supportChannelTombstones'
+];
+export const supportChannelHash = (value)=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+export const supportChannelId = (value)=>typeof value === 'string' && /^[\w.-]{1,160}$/.test(value);
+export const validSupportConnectSource = (source, appId, at)=>Boolean(source && source.appId === appId && source.enabled === true && supportChannelId(source.sourceId) && supportChannelId(source._rev) && source.databaseName && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(source.generation) && Number.isSafeInteger(source.expiresAt) && source.expiresAt > at && /^arn:aws(?:-[a-z]+)?:connect:[a-z0-9-]+:\d{12}:instance\/[a-f0-9-]{36}$/.test(source.instanceArn) && /^arn:aws(?:-[a-z]+)?:iam::\d{12}:role\/[\w+=,.@-]{1,64}$/.test(source.allowedCallerRoleArn) && source.instanceArn.split(':')[1] === source.allowedCallerRoleArn.split(':')[1] && source.instanceArn.split(':')[4] === source.allowedCallerRoleArn.split(':')[4]);
+export const readSupportChannelTicket = async (context, appId, ticketId)=>{
+    const scoped = await scopeContextToApp(context, appId);
+    const row = await useDb(scoped.databaseName).query(aql`LET ticket = DOCUMENT('supportTickets', ${ticketId})
+    LET user = ticket ? DOCUMENT('users', ticket.userId) : null
+    RETURN {ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId,
+      deleted: ticket.deleted, userId: ticket.userId, status: ticket.status} : null,
+      user: user ? {_key: user._key, _rev: user._rev, appId: user.appId, deleted: user.deleted} : null}`).then((cursor)=>cursor.next());
+    if (!row?.ticket || !row.user || row.ticket._key !== ticketId || !supportChannelId(row.user._key) || row.ticket.appId !== appId || row.user.appId !== appId || row.ticket.deleted === true || row.user.deleted === true || row.ticket.userId !== row.user._key || !supportChannelId(row.ticket._rev) || !supportChannelId(row.user._rev) || ![
+        'submitted',
+        'open',
+        'in_progress',
+        'waiting_on_customer',
+        'waiting_on_internal'
+    ].includes(row.ticket.status)) {
+        throw new Error('support_channel_ticket_hold');
+    }
+    return {
+        databaseName: scoped.databaseName,
+        ticket: row.ticket,
+        user: row.user
+    };
+};
+const setup = async (context)=>{
+    const db = useDb(context.databaseName);
+    await Promise.all(supportChannelCollections.map((name)=>ensureOwnerExecutionCollection(db, name)));
+    return db;
+};
+/** Administrator-reviewed source declaration. No AWS credentials or automatic intake/send authority. */ export const configureSupportConnectSource = async (context, input, now = Date.now)=>{
+    requireCrmAdministrator(context);
+    if (!input || Object.keys(input).some((key)=>![
+            'allowedCallerRoleArn',
+            'appId',
+            'enabled',
+            'expectedRevision',
+            'expiresAt',
+            'instanceArn',
+            'sourceId'
+        ].includes(key)) || !supportChannelId(input.appId) || !supportChannelId(input.sourceId) || typeof input.enabled !== 'boolean' || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= now() || input.expiresAt - now() > 30 * 86400000 || input.expectedRevision !== undefined && !supportChannelId(input.expectedRevision)) {
+        throw new Error('invalid_support_channel_source');
+    }
+    const scoped = await scopeContextToApp(context, input.appId);
+    const candidate = {
+        ...input,
+        _key: supportChannelHash([
+            input.appId,
+            input.sourceId
+        ]),
+        _rev: 'candidate',
+        databaseName: scoped.databaseName,
+        enabled: true,
+        generation: randomUUID(),
+        modifiedAt: now()
+    };
+    if (!validSupportConnectSource(candidate, input.appId, now())) {
+        throw new Error('invalid_support_channel_source');
+    }
+    const db = await setup(context);
+    const { _rev: _revision, expectedRevision, ...stored } = {
+        ...candidate,
+        enabled: input.enabled
+    };
+    const result = await db.query(expectedRevision ? aql`LET prior = DOCUMENT('supportChannelSources', ${candidate._key})
+    FILTER prior._rev == ${expectedRevision}
+    REPLACE {_key: ${candidate._key}, _rev: ${expectedRevision}} WITH ${stored}
+      IN supportChannelSources OPTIONS {ignoreRevs: false} RETURN NEW` : aql`INSERT ${stored} IN supportChannelSources RETURN NEW`).then((cursor)=>cursor.next());
+    if (!result) {
+        throw new Error('support_channel_source_changed');
+    }
+    return {
+        appId: input.appId,
+        enabled: result.enabled,
+        expiresAt: result.expiresAt,
+        revision: result._rev,
+        sourceId: input.sourceId
+    };
+};
+/** Explicit association; a contact's existence is subsequently checked with Connect, never by email or phone. */ export const bindSupportConnectConversation = async (context, input, now = Date.now)=>{
+    requireCrmAdministrator(context);
+    if (!input || Object.keys(input).sort().join(',') !== 'appId,contactId,expiresAt,sourceId,sourceRevision,ticketId,ticketRevision' || ![
+        input.appId,
+        input.sourceId,
+        input.sourceRevision,
+        input.ticketId,
+        input.ticketRevision
+    ].every(supportChannelId) || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(input.contactId) || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= now()) {
+        throw new Error('invalid_support_channel_binding');
+    }
+    const db = await setup(context);
+    const source = await db.query(aql`RETURN DOCUMENT('supportChannelSources', ${supportChannelHash([
+        input.appId,
+        input.sourceId
+    ])})`).then((cursor)=>cursor.next());
+    const row = await readSupportChannelTicket(context, input.appId, input.ticketId);
+    if (!validSupportConnectSource(source, input.appId, now()) || source._rev !== input.sourceRevision || source.databaseName !== row.databaseName || row.ticket._rev !== input.ticketRevision || input.expiresAt > source.expiresAt) {
+        throw new Error('support_channel_binding_hold');
+    }
+    const tombstoneKey = supportChannelHash([
+        input.appId,
+        input.sourceId,
+        input.contactId
+    ]);
+    const binding = {
+        ...input,
+        _key: supportChannelHash([
+            source.generation,
+            input.contactId
+        ]),
+        generation: source.generation,
+        nativeUserId: row.user._key,
+        nativeUserRevision: row.user._rev,
+        tombstoneKey
+    };
+    const result = await db.query(aql`LET current = DOCUMENT('supportChannelSources', ${source._key})
+    LET tombstone = DOCUMENT('supportChannelTombstones', ${tombstoneKey})
+    LET prior = DOCUMENT('supportChannelBindings', ${binding._key})
+    LET matching = (FOR item IN supportChannelBindings FILTER item.appId == ${input.appId}
+      AND item.sourceId == ${input.sourceId} AND item.generation == ${source.generation}
+      AND item.contactId == ${input.contactId} LIMIT 2 RETURN item._key)
+    FILTER LENGTH(matching) == 0 OR (LENGTH(matching) == 1 AND matching[0] == ${binding._key})
+    FILTER current._rev == ${source._rev} AND current.enabled == true AND current.expiresAt > ${now()}
+      AND tombstone == null AND (prior == null OR prior == MERGE(${binding}, {_id: prior._id, _rev: prior._rev}))
+    UPSERT {_key: ${binding._key}} INSERT ${binding} UPDATE {} IN supportChannelBindings RETURN NEW`).then((cursor)=>cursor.next());
+    if (!result) {
+        throw new Error('support_channel_binding_changed');
+    }
+    return {
+        appId: input.appId,
+        bindingId: result._key,
+        expiresAt: result.expiresAt,
+        revision: result._rev,
+        sourceId: input.sourceId,
+        ticketId: input.ticketId,
+        ticketRevision: input.ticketRevision
+    };
+};
+/** Administrative privacy erasure keeps an opaque tombstone to prevent old contact evidence being recreated. */ export const eraseSupportConnectEvidence = async (context, input, now = Date.now)=>{
+    requireCrmAdministrator(context);
+    if (!input || Object.keys(input).sort().join(',') !== 'appId,bindingId' || !supportChannelId(input.appId) || !/^[a-f0-9]{64}$/.test(input.bindingId)) {
+        throw new Error('invalid_support_channel_erasure');
+    }
+    await scopeContextToApp(context, input.appId);
+    const db = await setup(context);
+    const transaction = await db.beginTransaction({
+        exclusive: [
+            ...supportChannelCollections
+        ]
+    });
+    try {
+        const result = await transaction.step(()=>db.query(aql`LET binding = DOCUMENT('supportChannelBindings', ${input.bindingId})
+      FILTER binding.appId == ${input.appId}
+      LET removed = (FOR event IN supportChannelEvents FILTER event.bindingId == ${input.bindingId}
+        REMOVE event IN supportChannelEvents RETURN OLD._key)
+      UPSERT {_key: binding.tombstoneKey} INSERT {_key: binding.tombstoneKey, appId: ${input.appId}, erasedAt: ${now()}}
+        UPDATE {} IN supportChannelTombstones
+      REPLACE binding WITH {_key: binding._key, appId: binding.appId, erasedAt: ${now()},
+        tombstoneKey: binding.tombstoneKey} IN supportChannelBindings RETURN {erased: true}`)).then((cursor)=>cursor.next());
+        if (!result) {
+            throw new Error('support_channel_binding_hold');
+        }
+        await transaction.commit();
+        return result;
+    } catch (error) {
+        await transaction.abort();
+        throw error;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/supportChannelSources.ts"],"sourcesContent":["/* eslint-disable no-underscore-dangle -- Native source document revisions. */\nimport {aql} from 'arangojs';\nimport {createHash, randomUUID} from 'node:crypto';\n\nimport {scopeContextToApp} from '../utils/appContext.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {requireCrmAdministrator} from './crm.js';\nimport {ensureOwnerExecutionCollection} from './crmExecution.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\n\nexport const supportChannelCollections = ['supportChannelSources', 'supportChannelBindings',\n  'supportChannelEvents', 'supportChannelTombstones'] as const;\nexport const supportChannelHash = (value: unknown): string => createHash('sha256').update(JSON.stringify(value)).digest('hex');\nexport const supportChannelId = (value: unknown): value is string => typeof value === 'string' && /^[\\w.-]{1,160}$/.test(value);\nexport interface SupportConnectSourceInput {\n  allowedCallerRoleArn: string;\n  appId: string;\n  enabled: boolean;\n  expectedRevision?: string;\n  expiresAt: number;\n  instanceArn: string;\n  sourceId: string;\n}\nexport interface SupportConnectSource extends SupportConnectSourceInput {\n  _key: string;\n  _rev: string;\n  databaseName: string;\n  generation: string;\n  modifiedAt: number;\n}\nexport interface SupportConnectBindingInput {\n  appId: string;\n  contactId: string;\n  expiresAt: number;\n  sourceId: string;\n  sourceRevision: string;\n  ticketId: string;\n  ticketRevision: string;\n}\nexport interface SupportConnectBinding extends SupportConnectBindingInput {\n  _key: string;\n  _rev: string;\n  generation: string;\n  nativeUserId: string;\n  nativeUserRevision: string;\n  tombstoneKey: string;\n}\nexport const validSupportConnectSource = (source: SupportConnectSource | undefined, appId: string, at: number)\n: source is SupportConnectSource => Boolean(source && source.appId === appId && source.enabled === true\n  && supportChannelId(source.sourceId) && supportChannelId(source._rev) && source.databaseName\n  && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(source.generation) && Number.isSafeInteger(source.expiresAt) && source.expiresAt > at\n  && /^arn:aws(?:-[a-z]+)?:connect:[a-z0-9-]+:\\d{12}:instance\\/[a-f0-9-]{36}$/.test(source.instanceArn)\n  && /^arn:aws(?:-[a-z]+)?:iam::\\d{12}:role\\/[\\w+=,.@-]{1,64}$/.test(source.allowedCallerRoleArn)\n  && source.instanceArn.split(':')[1] === source.allowedCallerRoleArn.split(':')[1]\n  && source.instanceArn.split(':')[4] === source.allowedCallerRoleArn.split(':')[4]);\nexport const readSupportChannelTicket = async (context: ApiContext, appId: string, ticketId: string) => {\n  const scoped = await scopeContextToApp(context, appId);\n  const row = await useDb(scoped.databaseName).query(aql`LET ticket = DOCUMENT('supportTickets', ${ticketId})\n    LET user = ticket ? DOCUMENT('users', ticket.userId) : null\n    RETURN {ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId,\n      deleted: ticket.deleted, userId: ticket.userId, status: ticket.status} : null,\n      user: user ? {_key: user._key, _rev: user._rev, appId: user.appId, deleted: user.deleted} : null}`)\n    .then((cursor) => cursor.next());\n  if(!row?.ticket || !row.user || row.ticket._key !== ticketId || !supportChannelId(row.user._key)\n    || row.ticket.appId !== appId || row.user.appId !== appId\n    || row.ticket.deleted === true || row.user.deleted === true || row.ticket.userId !== row.user._key\n    || !supportChannelId(row.ticket._rev) || !supportChannelId(row.user._rev)\n    || !['submitted', 'open', 'in_progress', 'waiting_on_customer', 'waiting_on_internal'].includes(row.ticket.status)) {\n    throw new Error('support_channel_ticket_hold');\n  }\n  return {databaseName: scoped.databaseName, ticket: row.ticket, user: row.user};\n};\nconst setup = async (context: ApiContext) => {\n  const db = useDb(context.databaseName);\n  await Promise.all(supportChannelCollections.map((name) => ensureOwnerExecutionCollection(db, name)));\n  return db;\n};\n/** Administrator-reviewed source declaration. No AWS credentials or automatic intake/send authority. */\nexport const configureSupportConnectSource = async (\n  context: ApiContext, input: SupportConnectSourceInput, now = Date.now\n) => {\n  requireCrmAdministrator(context);\n  if(!input || Object.keys(input).some((key) => !['allowedCallerRoleArn', 'appId', 'enabled', 'expectedRevision',\n    'expiresAt', 'instanceArn', 'sourceId'].includes(key)) || !supportChannelId(input.appId)\n    || !supportChannelId(input.sourceId) || typeof input.enabled !== 'boolean'\n    || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= now() || input.expiresAt - now() > 30 * 86400000\n    || (input.expectedRevision !== undefined && !supportChannelId(input.expectedRevision))) {\n    throw new Error('invalid_support_channel_source');\n  }\n  const scoped = await scopeContextToApp(context, input.appId);\n  const candidate = {...input, _key: supportChannelHash([input.appId, input.sourceId]), _rev: 'candidate',\n    databaseName: scoped.databaseName!, enabled: true, generation: randomUUID(), modifiedAt: now()};\n  if(!validSupportConnectSource(candidate, input.appId, now())) {\n    throw new Error('invalid_support_channel_source');\n  }\n  const db = await setup(context);\n  const {_rev: _revision, expectedRevision, ...stored} = {...candidate, enabled: input.enabled};\n  const result = await db.query(expectedRevision ? aql`LET prior = DOCUMENT('supportChannelSources', ${candidate._key})\n    FILTER prior._rev == ${expectedRevision}\n    REPLACE {_key: ${candidate._key}, _rev: ${expectedRevision}} WITH ${stored}\n      IN supportChannelSources OPTIONS {ignoreRevs: false} RETURN NEW`\n    : aql`INSERT ${stored} IN supportChannelSources RETURN NEW`)\n    .then((cursor) => cursor.next());\n  if(!result) {\n    throw new Error('support_channel_source_changed');\n  }\n  return {appId: input.appId, enabled: result.enabled, expiresAt: result.expiresAt,\n    revision: result._rev, sourceId: input.sourceId};\n};\n/** Explicit association; a contact's existence is subsequently checked with Connect, never by email or phone. */\nexport const bindSupportConnectConversation = async (\n  context: ApiContext, input: SupportConnectBindingInput, now = Date.now\n) => {\n  requireCrmAdministrator(context);\n  if(!input || Object.keys(input).sort().join(',') !== 'appId,contactId,expiresAt,sourceId,sourceRevision,ticketId,ticketRevision'\n    || ![input.appId, input.sourceId, input.sourceRevision, input.ticketId, input.ticketRevision]\n      .every(supportChannelId)\n    || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(input.contactId) || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= now()) {\n    throw new Error('invalid_support_channel_binding');\n  }\n  const db = await setup(context);\n  const source = await db.query(aql`RETURN DOCUMENT('supportChannelSources', ${supportChannelHash([input.appId, input.sourceId])})`)\n    .then((cursor) => cursor.next()) as SupportConnectSource | undefined;\n  const row = await readSupportChannelTicket(context, input.appId, input.ticketId);\n  if(!validSupportConnectSource(source, input.appId, now()) || source._rev !== input.sourceRevision\n    || source.databaseName !== row.databaseName || row.ticket._rev !== input.ticketRevision\n    || input.expiresAt > source.expiresAt) {\n    throw new Error('support_channel_binding_hold');\n  }\n  const tombstoneKey = supportChannelHash([input.appId, input.sourceId, input.contactId]);\n  const binding = {...input, _key: supportChannelHash([source.generation, input.contactId]),\n    generation: source.generation, nativeUserId: row.user._key, nativeUserRevision: row.user._rev, tombstoneKey};\n  const result = await db.query(aql`LET current = DOCUMENT('supportChannelSources', ${source._key})\n    LET tombstone = DOCUMENT('supportChannelTombstones', ${tombstoneKey})\n    LET prior = DOCUMENT('supportChannelBindings', ${binding._key})\n    LET matching = (FOR item IN supportChannelBindings FILTER item.appId == ${input.appId}\n      AND item.sourceId == ${input.sourceId} AND item.generation == ${source.generation}\n      AND item.contactId == ${input.contactId} LIMIT 2 RETURN item._key)\n    FILTER LENGTH(matching) == 0 OR (LENGTH(matching) == 1 AND matching[0] == ${binding._key})\n    FILTER current._rev == ${source._rev} AND current.enabled == true AND current.expiresAt > ${now()}\n      AND tombstone == null AND (prior == null OR prior == MERGE(${binding}, {_id: prior._id, _rev: prior._rev}))\n    UPSERT {_key: ${binding._key}} INSERT ${binding} UPDATE {} IN supportChannelBindings RETURN NEW`)\n    .then((cursor) => cursor.next());\n  if(!result) {\n    throw new Error('support_channel_binding_changed');\n  }\n  return {appId: input.appId, bindingId: result._key, expiresAt: result.expiresAt,\n    revision: result._rev, sourceId: input.sourceId, ticketId: input.ticketId, ticketRevision: input.ticketRevision};\n};\n/** Administrative privacy erasure keeps an opaque tombstone to prevent old contact evidence being recreated. */\nexport const eraseSupportConnectEvidence = async (\n  context: ApiContext, input: {appId: string; bindingId: string}, now = Date.now\n) => {\n  requireCrmAdministrator(context);\n  if(!input || Object.keys(input).sort().join(',') !== 'appId,bindingId'\n    || !supportChannelId(input.appId) || !/^[a-f0-9]{64}$/.test(input.bindingId)) {\n    throw new Error('invalid_support_channel_erasure');\n  }\n  await scopeContextToApp(context, input.appId);\n  const db = await setup(context);\n  const transaction = await db.beginTransaction({exclusive: [...supportChannelCollections]});\n  try {\n    const result = await transaction.step(() => db.query(aql`LET binding = DOCUMENT('supportChannelBindings', ${input.bindingId})\n      FILTER binding.appId == ${input.appId}\n      LET removed = (FOR event IN supportChannelEvents FILTER event.bindingId == ${input.bindingId}\n        REMOVE event IN supportChannelEvents RETURN OLD._key)\n      UPSERT {_key: binding.tombstoneKey} INSERT {_key: binding.tombstoneKey, appId: ${input.appId}, erasedAt: ${now()}}\n        UPDATE {} IN supportChannelTombstones\n      REPLACE binding WITH {_key: binding._key, appId: binding.appId, erasedAt: ${now()},\n        tombstoneKey: binding.tombstoneKey} IN supportChannelBindings RETURN {erased: true}`))\n      .then((cursor) => cursor.next());\n    if(!result) {\n      throw new Error('support_channel_binding_hold');\n    }\n    await transaction.commit();\n    return result;\n  } catch(error) {\n    await transaction.abort();\n    throw error;\n  }\n};\n"],"names":["aql","createHash","randomUUID","scopeContextToApp","useDb","requireCrmAdministrator","ensureOwnerExecutionCollection","supportChannelCollections","supportChannelHash","value","update","JSON","stringify","digest","supportChannelId","test","validSupportConnectSource","source","appId","at","Boolean","enabled","sourceId","_rev","databaseName","generation","Number","isSafeInteger","expiresAt","instanceArn","allowedCallerRoleArn","split","readSupportChannelTicket","context","ticketId","scoped","row","query","then","cursor","next","ticket","user","_key","deleted","userId","includes","status","Error","setup","db","Promise","all","map","name","configureSupportConnectSource","input","now","Date","Object","keys","some","key","expectedRevision","undefined","candidate","modifiedAt","_revision","stored","result","revision","bindSupportConnectConversation","sort","join","sourceRevision","ticketRevision","every","contactId","tombstoneKey","binding","nativeUserId","nativeUserRevision","bindingId","eraseSupportConnectEvidence","transaction","beginTransaction","exclusive","step","commit","error","abort"],"mappings":"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"}

package/lib/actions/supportCommerce.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { RequestImplementation } from '@nlabs/rip-hunter/http';
+import type { ApiContext } from '../types/auth.types.js';
+declare const sourceSchema: z.ZodObject<{
+    appId: z.ZodString;
+    bindings: z.ZodArray<z.ZodObject<{
+        nativeOrderId: z.ZodString;
+        shopifyOrderId: z.ZodString;
+    }, z.core.$strict>>;
+    customersAccessApproved: z.ZodLiteral<true>;
+    expiresAt: z.ZodNumber;
+    id: z.ZodString;
+    ordersAccessApproved: z.ZodLiteral<true>;
+    ownerId: z.ZodString;
+    revision: z.ZodString;
+    shop: z.ZodString;
+    shopId: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strict>;
+export type SupportCommerceSource = z.infer<typeof sourceSchema>;
+export interface SupportCommerceInput {
+    appId: string;
+    orderId: string;
+    orderRevision: string;
+    sourceId: string;
+    ticketId: string;
+    ticketRevision: string;
+}
+export interface SupportCommerceObservation {
+    appId: string;
+    bindingRevision: string;
+    generatedAt: number;
+    order: {
+        financialStatus: string;
+        fulfillmentStatus: string;
+        id: string;
+        nativeId: string;
+        updatedAt: string;
+    };
+    providerRevision: string;
+    provenance: 'verified_shopify_native_record_association';
+    schemaVersion: 'support_commerce_v1';
+    shop: {
+        domain: string;
+        id: string;
+    };
+    sourceId: string;
+    sourceRevision: string;
+    ticketId: string;
+    ticketRevision: string;
+    validUntil: number;
+}
+/** Explicit reviewed source/order whitelist. Other purposes do not transfer protected-data approvals. */
+export declare const supportCommerceSources: (raw?: string) => SupportCommerceSource[];
+export declare const SUPPORT_COMMERCE_QUERY = "query SupportCommerceOrder($id: ID!) {\n  shop { id myshopifyDomain }\n  currentAppInstallation { accessScopes { handle } }\n  order(id: $id) { id customer { id } updatedAt displayFinancialStatus displayFulfillmentStatus }\n}";
+/** Read-only native association. No email matching, association mutation or inferred settlement. */
+export declare const readSupportCommerce: (context: ApiContext, input: SupportCommerceInput, options?: {
+    now?: () => number;
+    requestImplementation?: RequestImplementation;
+    sources?: () => readonly SupportCommerceSource[];
+}) => Promise<SupportCommerceObservation>;
+export {};

package/lib/actions/supportCommerce.js

@@ -0,0 +1,252 @@
+/* eslint-disable no-underscore-dangle -- Exact native document and graph revision proofs. */ import { httpRequest, readBinaryResponse } from '@nlabs/rip-hunter/http';
+import { aql } from 'arangojs';
+import { z } from 'zod';
+import { scopeContextToApp } from '../utils/appContext.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { crmCanonicalDigest as digest } from './crmCanonicalPolicy.js';
+import { authorizeCrmExecutionGrant } from './crmExecution.js';
+const id = z.string().regex(/^[\w.-]{1,160}$/);
+const orderId = z.string().regex(/^gid:\/\/shopify\/Order\/\d+$/);
+const shopId = z.string().regex(/^gid:\/\/shopify\/Shop\/\d+$/);
+const sourceSchema = z.object({
+    appId: id,
+    bindings: z.array(z.object({
+        nativeOrderId: id,
+        shopifyOrderId: orderId
+    }).strict()).min(1).max(100),
+    customersAccessApproved: z.literal(true),
+    expiresAt: z.number().int().positive(),
+    id,
+    ordersAccessApproved: z.literal(true),
+    ownerId: id,
+    revision: id,
+    shop: z.string().regex(/^[a-z0-9][a-z0-9-]*\.myshopify\.com$/),
+    shopId,
+    token: z.string().min(1).max(4096)
+}).strict();
+/** Explicit reviewed source/order whitelist. Other purposes do not transfer protected-data approvals. */ export const supportCommerceSources = (raw = process.env.SUPPORT_COMMERCE_SOURCES)=>{
+    if (!raw) {
+        return [];
+    }
+    try {
+        const sources = z.array(sourceSchema).max(100).parse(JSON.parse(raw));
+        if (new Set(sources.map((source)=>source.id)).size !== sources.length || sources.some((source)=>new Set(source.bindings.map((binding)=>binding.nativeOrderId)).size !== source.bindings.length)) {
+            throw new Error('ambiguous');
+        }
+        return sources;
+    } catch  {
+        throw new Error('support_commerce_source_configuration_hold');
+    }
+};
+export const SUPPORT_COMMERCE_QUERY = `query SupportCommerceOrder($id: ID!) {
+  shop { id myshopifyDomain }
+  currentAppInstallation { accessScopes { handle } }
+  order(id: $id) { id customer { id } updatedAt displayFinancialStatus displayFulfillmentStatus }
+}`;
+const providerSchema = z.object({
+    currentAppInstallation: z.object({
+        accessScopes: z.array(z.object({
+            handle: z.string()
+        })).max(100)
+    }),
+    order: z.object({
+        customer: z.object({
+            id: z.string().regex(/^gid:\/\/shopify\/Customer\/\d+$/)
+        }),
+        displayFinancialStatus: z.enum([
+            'AUTHORIZED',
+            'EXPIRED',
+            'PAID',
+            'PARTIALLY_PAID',
+            'PARTIALLY_REFUNDED',
+            'PENDING',
+            'REFUNDED',
+            'VOIDED'
+        ]),
+        displayFulfillmentStatus: z.enum([
+            'FULFILLED',
+            'IN_PROGRESS',
+            'ON_HOLD',
+            'OPEN',
+            'PARTIALLY_FULFILLED',
+            'PENDING_FULFILLMENT',
+            'REQUEST_DECLINED',
+            'RESTOCKED',
+            'SCHEDULED',
+            'UNFULFILLED'
+        ]),
+        id: orderId,
+        updatedAt: z.string().datetime({
+            offset: true
+        })
+    }).strict(),
+    shop: z.object({
+        id: shopId,
+        myshopifyDomain: z.string()
+    }).strict()
+}).strict();
+const external = (value, type)=>{
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    if (/^\d+$/.test(value)) {
+        return `gid://shopify/${type}/${value}`;
+    }
+    return new RegExp(`^gid://shopify/${type}/\\d+$`).test(value) ? value : undefined;
+};
+/** Read-only native association. No email matching, association mutation or inferred settlement. */ export const readSupportCommerce = async (context, input, options = {})=>{
+    if (!z.object({
+        appId: id,
+        orderId: id,
+        orderRevision: id,
+        sourceId: id,
+        ticketId: id,
+        ticketRevision: id
+    }).strict().safeParse(input).success) {
+        throw new Error('invalid_support_commerce_input');
+    }
+    const selection = structuredClone(input);
+    const now = options.now || Date.now;
+    const sources = options.sources || supportCommerceSources;
+    const authority = async ()=>{
+        const grant = await authorizeCrmExecutionGrant(context, selection.appId, 'support:commerce', now());
+        await authorizeCrmExecutionGrant(context, selection.appId, 'support:read', now());
+        const scoped = await scopeContextToApp(context, selection.appId);
+        const matches = sources().filter((source)=>source.id === selection.sourceId);
+        const source = matches[0];
+        const binding = source?.bindings.find((value)=>value.nativeOrderId === selection.orderId);
+        if (matches.length !== 1 || !sourceSchema.safeParse(source).success || source.appId !== selection.appId || source.ownerId !== grant.ownerId || source.expiresAt <= now() || !binding || source.bindings.filter((value)=>value.nativeOrderId === selection.orderId).length !== 1 || scoped.databaseName !== grant.databaseName) {
+            throw new Error('support_commerce_authority_hold');
+        }
+        const db = useDb(grant.databaseName);
+        const row = await db.query(aql`LET ticket = DOCUMENT('supportTickets', ${selection.ticketId})
+      LET user = ticket ? DOCUMENT('users', ticket.userId) : null
+      LET order = DOCUMENT('customerOrders', ${selection.orderId})
+      LET currentConsent = (FOR record IN supportPurposeConsents
+        FILTER record.appId == ${selection.appId} AND record.userId == user._key
+          AND record.purpose == 'support_commerce' LIMIT 2 RETURN record)
+      LET ticketEdges = (FOR edge IN hasSupportTicket FILTER edge._to == CONCAT('supportTickets/', ${selection.ticketId})
+        LIMIT 2 RETURN {from: edge._from, revision: edge._rev})
+      LET orderEdges = (FOR edge IN hasCustomerOrder FILTER edge._to == CONCAT('customerOrders/', ${selection.orderId})
+        LIMIT 2 RETURN {from: edge._from, revision: edge._rev})
+      RETURN {ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId, deleted: ticket.deleted,
+        shopifyOrderId: ticket.shopifyOrderId, status: ticket.status, userId: ticket.userId} : null,
+        user: user ? {_key: user._key, _rev: user._rev, active: user.active, appId: user.appId,
+          crmAnalyticsSuppressed: user.crmAnalyticsSuppressed, deleted: user.deleted,
+          shopifyCustomerId: user.shopifyCustomerId} : null,
+        order: order ? {_key: order._key, _rev: order._rev, appId: order.appId, deleted: order.deleted,
+          shopifyCustomerId: order.shopifyCustomerId, shopifyOrderId: order.shopifyOrderId, userId: order.userId} : null,
+        consents: currentConsent, orderEdges, ticketEdges}`).then((cursor)=>cursor.next());
+        const { ticket, user, order, consents, orderEdges, ticketEdges } = row || {};
+        const active = (record)=>Boolean(record && id.safeParse(record._key).success && id.safeParse(record._rev).success && record.appId === selection.appId && record.deleted !== true);
+        const consent = Array.isArray(consents) && consents.length === 1 ? consents[0] : undefined;
+        if (!active(ticket) || !active(user) || !active(order) || ticket._key !== selection.ticketId || ticket._rev !== selection.ticketRevision || order._key !== selection.orderId || order._rev !== selection.orderRevision || user.active === false || user.crmAnalyticsSuppressed === true || ticket.userId !== user._key || order.userId !== user._key || ![
+            'submitted',
+            'open',
+            'in_progress',
+            'waiting_on_customer',
+            'waiting_on_internal'
+        ].includes(ticket.status) || external(ticket.shopifyOrderId, 'Order') !== binding.shopifyOrderId || external(order.shopifyOrderId, 'Order') !== binding.shopifyOrderId || !external(user.shopifyCustomerId, 'Customer') || external(order.shopifyCustomerId, 'Customer') !== external(user.shopifyCustomerId, 'Customer') || !consent || consent.appId !== selection.appId || consent.userId !== user._key || consent.purpose !== 'support_commerce' || consent._key !== digest([
+            selection.appId,
+            user._key,
+            'support_commerce'
+        ]) || !id.safeParse(consent._rev).success || consent.source !== 'authenticated_customer' || consent.status !== 'active' || !Number.isSafeInteger(consent.at) || consent.at > now() || !Number.isSafeInteger(consent.expiresAt) || consent.expiresAt <= now() || ![
+            orderEdges,
+            ticketEdges
+        ].every((edges)=>Array.isArray(edges) && edges.length === 1 && edges[0].from === `users/${user._key}` && id.safeParse(edges[0].revision).success)) {
+            throw new Error('support_commerce_native_identity_or_consent_hold');
+        }
+        return {
+            binding,
+            consent,
+            grant,
+            identity: digest([
+                grant.id,
+                grant.hash,
+                grant.databaseName,
+                source,
+                row
+            ]),
+            row,
+            source
+        };
+    };
+    const initial = await authority();
+    const deadline = now() + 15000;
+    const current = await authority();
+    if (current.identity !== initial.identity || now() >= deadline) {
+        throw new Error('support_commerce_source_changed');
+    }
+    let data;
+    try {
+        const response = await httpRequest(`https://${initial.source.shop}/admin/api/2026-10/graphql.json`, {
+            body: JSON.stringify({
+                query: SUPPORT_COMMERCE_QUERY,
+                variables: {
+                    id: initial.binding.shopifyOrderId
+                }
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Shopify-Access-Token': initial.source.token
+            },
+            method: 'POST',
+            redirect: 'error',
+            requestImplementation: options.requestImplementation,
+            timeout: Math.max(1, deadline - now())
+        }, async (response)=>{
+            if (response.status !== 200 || response.redirected) {
+                throw new Error('provider');
+            }
+            const bytes = await readBinaryResponse(response, 1048576);
+            const envelope = z.object({
+                data: providerSchema,
+                errors: z.array(z.unknown()).max(100).optional()
+            }).strict().parse(JSON.parse(new TextDecoder().decode(bytes)));
+            if (envelope.errors?.length) {
+                throw new Error('provider');
+            }
+            return envelope.data;
+        });
+        data = response;
+    } catch  {
+        throw new Error('support_commerce_provider_read_hold');
+    }
+    if (data.shop.id !== initial.source.shopId || data.shop.myshopifyDomain !== initial.source.shop || ![
+        'read_orders',
+        'read_customers'
+    ].every((scope)=>data.currentAppInstallation.accessScopes.some((entry)=>entry.handle === scope)) || data.order.id !== initial.binding.shopifyOrderId || data.order.customer.id !== external(initial.row.user.shopifyCustomerId, 'Customer') || Date.parse(data.order.updatedAt) > now()) {
+        throw new Error('support_commerce_provider_identity_hold');
+    }
+    const latest = await authority();
+    if (latest.identity !== initial.identity || now() >= deadline) {
+        throw new Error('support_commerce_source_changed');
+    }
+    const generatedAt = now();
+    return {
+        appId: selection.appId,
+        bindingRevision: digest(initial.row),
+        generatedAt,
+        order: {
+            financialStatus: data.order.displayFinancialStatus,
+            fulfillmentStatus: data.order.displayFulfillmentStatus,
+            id: data.order.id,
+            nativeId: selection.orderId,
+            updatedAt: data.order.updatedAt
+        },
+        provenance: 'verified_shopify_native_record_association',
+        providerRevision: digest(data),
+        schemaVersion: 'support_commerce_v1',
+        shop: {
+            domain: data.shop.myshopifyDomain,
+            id: data.shop.id
+        },
+        sourceId: selection.sourceId,
+        sourceRevision: digest(initial.source),
+        ticketId: selection.ticketId,
+        ticketRevision: selection.ticketRevision,
+        validUntil: Math.min(generatedAt + 300000, latest.grant.expires, latest.consent.expiresAt, latest.source.expiresAt)
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/tmp/reactorbox-support-commerce-freeze-20261008/input/actions/supportCommerce.ts"],"sourcesContent":["/* eslint-disable no-underscore-dangle -- Exact native document and graph revision proofs. */\nimport {httpRequest, readBinaryResponse} from '@nlabs/rip-hunter/http';\nimport {aql} from 'arangojs';\nimport {z} from 'zod';\n\nimport {scopeContextToApp} from '../utils/appContext.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {crmCanonicalDigest as digest} from './crmCanonicalPolicy.js';\nimport {authorizeCrmExecutionGrant} from './crmExecution.js';\n\nimport type {RequestImplementation} from '@nlabs/rip-hunter/http';\nimport type {ApiContext} from '../types/auth.types.js';\n\nconst id = z.string().regex(/^[\\w.-]{1,160}$/);\nconst orderId = z.string().regex(/^gid:\\/\\/shopify\\/Order\\/\\d+$/);\nconst shopId = z.string().regex(/^gid:\\/\\/shopify\\/Shop\\/\\d+$/);\nconst sourceSchema = z.object({appId: id,\n  bindings: z.array(z.object({nativeOrderId: id, shopifyOrderId: orderId}).strict()).min(1).max(100),\n  customersAccessApproved: z.literal(true), expiresAt: z.number().int().positive(), id,\n  ordersAccessApproved: z.literal(true), ownerId: id, revision: id,\n  shop: z.string().regex(/^[a-z0-9][a-z0-9-]*\\.myshopify\\.com$/), shopId,\n  token: z.string().min(1).max(4096)}).strict();\nexport type SupportCommerceSource = z.infer<typeof sourceSchema>;\nexport interface SupportCommerceInput {\n  appId: string; orderId: string; orderRevision: string; sourceId: string; ticketId: string; ticketRevision: string;\n}\nexport interface SupportCommerceObservation {\n  appId: string;\n  bindingRevision: string;\n  generatedAt: number;\n  order: {financialStatus: string; fulfillmentStatus: string; id: string; nativeId: string; updatedAt: string};\n  providerRevision: string;\n  provenance: 'verified_shopify_native_record_association';\n  schemaVersion: 'support_commerce_v1';\n  shop: {domain: string; id: string};\n  sourceId: string;\n  sourceRevision: string;\n  ticketId: string;\n  ticketRevision: string;\n  validUntil: number;\n}\n/** Explicit reviewed source/order whitelist. Other purposes do not transfer protected-data approvals. */\nexport const supportCommerceSources = (raw = process.env.SUPPORT_COMMERCE_SOURCES): SupportCommerceSource[] => {\n  if(!raw) {\n    return [];\n  }\n  try {\n    const sources = z.array(sourceSchema).max(100).parse(JSON.parse(raw));\n    if(new Set(sources.map((source) => source.id)).size !== sources.length\n      || sources.some((source) => new Set(source.bindings.map((binding) => binding.nativeOrderId)).size\n        !== source.bindings.length)) {\n      throw new Error('ambiguous');\n    }\n    return sources;\n  } catch{\n    throw new Error('support_commerce_source_configuration_hold');\n  }\n};\nexport const SUPPORT_COMMERCE_QUERY = `query SupportCommerceOrder($id: ID!) {\n  shop { id myshopifyDomain }\n  currentAppInstallation { accessScopes { handle } }\n  order(id: $id) { id customer { id } updatedAt displayFinancialStatus displayFulfillmentStatus }\n}`;\nconst providerSchema = z.object({currentAppInstallation: z.object({accessScopes:\n  z.array(z.object({handle: z.string()})).max(100)}), order: z.object({customer:\n  z.object({id: z.string().regex(/^gid:\\/\\/shopify\\/Customer\\/\\d+$/)}),\ndisplayFinancialStatus: z.enum(['AUTHORIZED', 'EXPIRED', 'PAID', 'PARTIALLY_PAID', 'PARTIALLY_REFUNDED',\n  'PENDING', 'REFUNDED', 'VOIDED']),\ndisplayFulfillmentStatus: z.enum(['FULFILLED', 'IN_PROGRESS', 'ON_HOLD', 'OPEN', 'PARTIALLY_FULFILLED',\n  'PENDING_FULFILLMENT', 'REQUEST_DECLINED', 'RESTOCKED', 'SCHEDULED', 'UNFULFILLED']),\nid: orderId, updatedAt: z.string().datetime({offset: true})}).strict(),\nshop: z.object({id: shopId, myshopifyDomain: z.string()}).strict()}).strict();\nconst external = (value: unknown, type: 'Customer' | 'Order'): string | undefined => {\n  if(typeof value !== 'string') {\n    return undefined;\n  }\n  if(/^\\d+$/.test(value)) {\n    return `gid://shopify/${type}/${value}`;\n  }\n  return new RegExp(`^gid://shopify/${type}/\\\\d+$`).test(value) ? value : undefined;\n};\n/** Read-only native association. No email matching, association mutation or inferred settlement. */\nexport const readSupportCommerce = async (context: ApiContext, input: SupportCommerceInput, options: {\n  now?: () => number; requestImplementation?: RequestImplementation; sources?: () => readonly SupportCommerceSource[];\n} = {}): Promise<SupportCommerceObservation> => {\n  if(!z.object({appId: id, orderId: id, orderRevision: id, sourceId: id, ticketId: id,\n    ticketRevision: id}).strict().safeParse(input).success) {\n    throw new Error('invalid_support_commerce_input');\n  }\n  const selection = structuredClone(input);\n  const now = options.now || Date.now;\n  const sources = options.sources || supportCommerceSources;\n  const authority = async () => {\n    const grant = await authorizeCrmExecutionGrant(context, selection.appId, 'support:commerce', now());\n    await authorizeCrmExecutionGrant(context, selection.appId, 'support:read', now());\n    const scoped = await scopeContextToApp(context, selection.appId);\n    const matches = sources().filter((source) => source.id === selection.sourceId);\n    const source = matches[0];\n    const binding = source?.bindings.find((value) => value.nativeOrderId === selection.orderId);\n    if(matches.length !== 1 || !sourceSchema.safeParse(source).success || source.appId !== selection.appId\n      || source.ownerId !== grant.ownerId || source.expiresAt <= now() || !binding\n      || source.bindings.filter((value) => value.nativeOrderId === selection.orderId).length !== 1\n      || scoped.databaseName !== grant.databaseName) {\n      throw new Error('support_commerce_authority_hold');\n    }\n    const db = useDb(grant.databaseName);\n    const row = await db.query(aql`LET ticket = DOCUMENT('supportTickets', ${selection.ticketId})\n      LET user = ticket ? DOCUMENT('users', ticket.userId) : null\n      LET order = DOCUMENT('customerOrders', ${selection.orderId})\n      LET currentConsent = (FOR record IN supportPurposeConsents\n        FILTER record.appId == ${selection.appId} AND record.userId == user._key\n          AND record.purpose == 'support_commerce' LIMIT 2 RETURN record)\n      LET ticketEdges = (FOR edge IN hasSupportTicket FILTER edge._to == CONCAT('supportTickets/', ${selection.ticketId})\n        LIMIT 2 RETURN {from: edge._from, revision: edge._rev})\n      LET orderEdges = (FOR edge IN hasCustomerOrder FILTER edge._to == CONCAT('customerOrders/', ${selection.orderId})\n        LIMIT 2 RETURN {from: edge._from, revision: edge._rev})\n      RETURN {ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId, deleted: ticket.deleted,\n        shopifyOrderId: ticket.shopifyOrderId, status: ticket.status, userId: ticket.userId} : null,\n        user: user ? {_key: user._key, _rev: user._rev, active: user.active, appId: user.appId,\n          crmAnalyticsSuppressed: user.crmAnalyticsSuppressed, deleted: user.deleted,\n          shopifyCustomerId: user.shopifyCustomerId} : null,\n        order: order ? {_key: order._key, _rev: order._rev, appId: order.appId, deleted: order.deleted,\n          shopifyCustomerId: order.shopifyCustomerId, shopifyOrderId: order.shopifyOrderId, userId: order.userId} : null,\n        consents: currentConsent, orderEdges, ticketEdges}`).then((cursor) => cursor.next()) as any;\n    const {ticket, user, order, consents, orderEdges, ticketEdges} = row || {};\n    const active = (record: any): boolean => Boolean(record && id.safeParse(record._key).success\n      && id.safeParse(record._rev).success && record.appId === selection.appId && record.deleted !== true);\n    const consent = Array.isArray(consents) && consents.length === 1 ? consents[0] : undefined;\n    if(!active(ticket) || !active(user) || !active(order) || ticket._key !== selection.ticketId\n      || ticket._rev !== selection.ticketRevision || order._key !== selection.orderId\n      || order._rev !== selection.orderRevision || user.active === false || user.crmAnalyticsSuppressed === true\n      || ticket.userId !== user._key || order.userId !== user._key\n      || !['submitted', 'open', 'in_progress', 'waiting_on_customer', 'waiting_on_internal'].includes(ticket.status)\n      || external(ticket.shopifyOrderId, 'Order') !== binding.shopifyOrderId\n      || external(order.shopifyOrderId, 'Order') !== binding.shopifyOrderId\n      || !external(user.shopifyCustomerId, 'Customer')\n      || external(order.shopifyCustomerId, 'Customer') !== external(user.shopifyCustomerId, 'Customer')\n      || !consent || consent.appId !== selection.appId || consent.userId !== user._key\n      || consent.purpose !== 'support_commerce' || consent._key !== digest([selection.appId, user._key, 'support_commerce'])\n      || !id.safeParse(consent._rev).success || consent.source !== 'authenticated_customer'\n      || consent.status !== 'active' || !Number.isSafeInteger(consent.at) || consent.at > now()\n      || !Number.isSafeInteger(consent.expiresAt) || consent.expiresAt <= now()\n      || ![orderEdges, ticketEdges].every((edges) => Array.isArray(edges) && edges.length === 1\n        && edges[0].from === `users/${user._key}` && id.safeParse(edges[0].revision).success)) {\n      throw new Error('support_commerce_native_identity_or_consent_hold');\n    }\n    return {binding, consent, grant, identity: digest([grant.id, grant.hash, grant.databaseName, source, row]),\n      row, source};\n  };\n  const initial = await authority();\n  const deadline = now() + 15000;\n  const current = await authority();\n  if(current.identity !== initial.identity || now() >= deadline) {\n    throw new Error('support_commerce_source_changed');\n  }\n  let data: z.infer<typeof providerSchema>;\n  try {\n    const response = await httpRequest(`https://${initial.source.shop}/admin/api/2026-10/graphql.json`, {\n      body: JSON.stringify({query: SUPPORT_COMMERCE_QUERY, variables: {id: initial.binding.shopifyOrderId}}),\n      headers: {'Content-Type': 'application/json', 'X-Shopify-Access-Token': initial.source.token}, method: 'POST',\n      redirect: 'error', requestImplementation: options.requestImplementation,\n      timeout: Math.max(1, deadline - now())\n    }, async (response) => {\n      if(response.status !== 200 || response.redirected) {\n        throw new Error('provider');\n      }\n      const bytes = await readBinaryResponse(response, 1048576);\n      const envelope = z.object({data: providerSchema, errors: z.array(z.unknown()).max(100).optional()})\n        .strict().parse(JSON.parse(new TextDecoder().decode(bytes)));\n      if(envelope.errors?.length) {\n        throw new Error('provider');\n      }\n      return envelope.data;\n    });\n    data = response;\n  } catch{\n    throw new Error('support_commerce_provider_read_hold');\n  }\n  if(data.shop.id !== initial.source.shopId || data.shop.myshopifyDomain !== initial.source.shop\n    || !['read_orders', 'read_customers'].every((scope) =>\n      data.currentAppInstallation.accessScopes.some((entry) => entry.handle === scope))\n    || data.order.id !== initial.binding.shopifyOrderId\n    || data.order.customer.id !== external(initial.row.user.shopifyCustomerId, 'Customer')\n    || Date.parse(data.order.updatedAt) > now()) {\n    throw new Error('support_commerce_provider_identity_hold');\n  }\n  const latest = await authority();\n  if(latest.identity !== initial.identity || now() >= deadline) {\n    throw new Error('support_commerce_source_changed');\n  }\n  const generatedAt = now();\n  return {appId: selection.appId, bindingRevision: digest(initial.row), generatedAt,\n    order: {financialStatus: data.order.displayFinancialStatus, fulfillmentStatus: data.order.displayFulfillmentStatus,\n      id: data.order.id, nativeId: selection.orderId, updatedAt: data.order.updatedAt},\n    provenance: 'verified_shopify_native_record_association', providerRevision: digest(data),\n    schemaVersion: 'support_commerce_v1', shop: {domain: data.shop.myshopifyDomain, id: data.shop.id},\n    sourceId: selection.sourceId, sourceRevision: digest(initial.source), ticketId: selection.ticketId,\n    ticketRevision: selection.ticketRevision,\n    validUntil: Math.min(generatedAt + 300000, latest.grant.expires, latest.consent.expiresAt,\n      latest.source.expiresAt)};\n};\n"],"names":["httpRequest","readBinaryResponse","aql","z","scopeContextToApp","useDb","crmCanonicalDigest","digest","authorizeCrmExecutionGrant","id","string","regex","orderId","shopId","sourceSchema","object","appId","bindings","array","nativeOrderId","shopifyOrderId","strict","min","max","customersAccessApproved","literal","expiresAt","number","int","positive","ordersAccessApproved","ownerId","revision","shop","token","supportCommerceSources","raw","process","env","SUPPORT_COMMERCE_SOURCES","sources","parse","JSON","Set","map","source","size","length","some","binding","Error","SUPPORT_COMMERCE_QUERY","providerSchema","currentAppInstallation","accessScopes","handle","order","customer","displayFinancialStatus","enum","displayFulfillmentStatus","updatedAt","datetime","offset","myshopifyDomain","external","value","type","undefined","test","RegExp","readSupportCommerce","context","input","options","orderRevision","sourceId","ticketId","ticketRevision","safeParse","success","selection","structuredClone","now","Date","authority","grant","scoped","matches","filter","find","databaseName","db","row","query","then","cursor","next","ticket","user","consents","orderEdges","ticketEdges","active","record","Boolean","_key","_rev","deleted","consent","Array","isArray","crmAnalyticsSuppressed","userId","includes","status","shopifyCustomerId","purpose","Number","isSafeInteger","at","every","edges","from","identity","hash","initial","deadline","current","data","response","body","stringify","variables","headers","method","redirect","requestImplementation","timeout","Math","redirected","bytes","envelope","errors","unknown","optional","TextDecoder","decode","scope","entry","latest","generatedAt","bindingRevision","financialStatus","fulfillmentStatus","nativeId","provenance","providerRevision","schemaVersion","domain","sourceRevision","validUntil","expires"],"mappings":"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"}

package/lib/actions/supportConnect.d.ts

@@ -0,0 +1,39 @@
+import { ConnectClient } from '@aws-sdk/client-connect';
+import type { ApiContext } from '../types/auth.types.js';
+export interface SupportConnectIngressInput {
+    appId: string;
+    bindingId: string;
+    contactId: string;
+    kind: 'contact_observed' | 'contact_ended';
+    sourceId: string;
+}
+export interface SupportConnectReadInput {
+    appId: string;
+    sourceId: string;
+    ticketId: string;
+    ticketRevision: string;
+}
+export interface SupportConnectEvidence {
+    appId: string;
+    channel: 'voice';
+    generatedAt: number;
+    milestones: {
+        kind: SupportConnectIngressInput['kind'];
+        occurredAt: number;
+    }[];
+    provenance: 'aws_connect_contact_metadata';
+    schemaVersion: 'support_connect_metadata_v1';
+    sourceId: string;
+    ticketId: string;
+    ticketRevision: string;
+    validUntil: number;
+}
+/** Host-only ingress. trustedIamPrincipal MUST originate from an AWS_IAM gateway route,
+ * never a body/header/GraphQL argument. */
+export declare const ingestSupportConnectMetadata: (context: ApiContext, input: SupportConnectIngressInput, trustedIamPrincipal: string, now?: () => number, client?: Pick<ConnectClient, 'send'>) => Promise<{
+    duplicate: boolean;
+    kind: SupportConnectIngressInput['kind'];
+    occurredAt: number;
+}>;
+/** Ordinary current read authority; provider contact IDs, principals, identities and raw responses are excluded. */
+export declare const readSupportConnectEvidence: (context: ApiContext, input: SupportConnectReadInput, now?: () => number) => Promise<SupportConnectEvidence>;