@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/payments/ar.js

@@ -0,0 +1,223 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { arPageWindow } from '../documents/ar.js';
+const PAYMENT_FIELDS = /* GraphQL */ `
+  id
+  customerId
+  amount
+  currencyCode
+  method
+  receivedOn
+  reference
+  notes
+  allocations {
+    id
+    invoiceId
+    amount
+  }
+  createdAt
+`;
+const ATTEMPT_FIELDS = /* GraphQL */ `
+  id
+  invoiceId
+  customerId
+  attemptNumber
+  amount
+  currencyCode
+  status
+  provider
+  providerPaymentId
+  failureCode
+  failureReason
+  settledAt
+  reversedAt
+  orderSettlementState
+  lastCheckedAt
+  createdAt
+`;
+const DIRECT_DEBIT_SETTINGS_FIELDS = /* GraphQL */ `
+  customerId
+  enabled
+  suspendedReason
+  hasValidMandate
+  mandateId
+  providerMandateId
+  available
+`;
+export const AR_PAYMENTS_QUERY = /* GraphQL */ `
+  query ArPayments($options: ArListOptions) {
+    arPayments(options: $options) {
+      items { ${PAYMENT_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const AR_LEDGER_QUERY = /* GraphQL */ `
+  query ArLedgerEntries($customerId: ID!, $options: ArListOptions) {
+    arLedgerEntries(customerId: $customerId, options: $options) {
+      items {
+        id
+        entryType
+        amount
+        currencyCode
+        sourceType
+        sourceId
+        occurredOn
+        metadata
+        createdAt
+      }
+      totalItems
+    }
+  }
+`;
+export const RECORD_AR_PAYMENT_MUTATION = /* GraphQL */ `
+  mutation RecordArPayment($input: RecordArPaymentInput!, $idempotencyKey: String) {
+    recordArPayment(input: $input, idempotencyKey: $idempotencyKey) { ${PAYMENT_FIELDS} }
+  }
+`;
+export const AR_ORDER_PREPAID_DRAWDOWN_QUERY = /* GraphQL */ `
+  query ArOrderPrepaidDrawdown($orderId: ID!) {
+    arOrderPrepaidDrawdown(orderId: $orderId) {
+      entryId
+      orderId
+      amount
+      currencyCode
+      occurredOn
+    }
+  }
+`;
+export const RECORD_AR_PREPAID_DRAWDOWN_MUTATION = /* GraphQL */ `
+  mutation RecordArPrepaidDrawdown($input: RecordArPrepaidDrawdownInput!, $idempotencyKey: String) {
+    recordArPrepaidDrawdown(input: $input, idempotencyKey: $idempotencyKey) {
+      entryId
+      customerId
+      amount
+      currencyCode
+      occurredOn
+      balanceAfter
+      alreadyRecorded
+    }
+  }
+`;
+export const AR_DIRECT_DEBIT_SETTINGS_QUERY = /* GraphQL */ `
+  query ArDirectDebitSettings($customerId: ID!) {
+    arDirectDebitSettings(customerId: $customerId) { ${DIRECT_DEBIT_SETTINGS_FIELDS} }
+  }
+`;
+export const UPDATE_AR_DIRECT_DEBIT_SETTINGS_MUTATION = /* GraphQL */ `
+  mutation UpdateArDirectDebitSettings($customerId: ID!, $input: UpdateArDirectDebitSettingsInput!) {
+    updateArDirectDebitSettings(customerId: $customerId, input: $input) {
+      ${DIRECT_DEBIT_SETTINGS_FIELDS}
+    }
+  }
+`;
+export const AR_COLLECTION_ATTEMPTS_QUERY = /* GraphQL */ `
+  query ArCollectionAttempts($invoiceId: ID!) {
+    arCollectionAttempts(invoiceId: $invoiceId) { ${ATTEMPT_FIELDS} }
+  }
+`;
+export const AR_LATEST_COLLECTION_ATTEMPTS_QUERY = /* GraphQL */ `
+  query ArLatestCollectionAttempts($invoiceIds: [ID!]!) {
+    arLatestCollectionAttempts(invoiceIds: $invoiceIds) { ${ATTEMPT_FIELDS} }
+  }
+`;
+export const SEND_AR_PRE_NOTIFICATION_MUTATION = /* GraphQL */ `
+  mutation SendArDirectDebitPreNotification($invoiceId: ID!) {
+    sendArDirectDebitPreNotification(invoiceId: $invoiceId) {
+      invoiceId
+      collectOn
+      amount
+      noticeTitle
+      noticeBody
+    }
+  }
+`;
+export const COLLECT_AR_INVOICE_NOW_MUTATION = /* GraphQL */ `
+  mutation CollectArInvoiceNow($invoiceId: ID!, $idempotencyKey: String) {
+    collectArInvoiceNow(invoiceId: $invoiceId, idempotencyKey: $idempotencyKey) {
+      result
+      refusal
+      message
+      attempt { ${ATTEMPT_FIELDS} }
+    }
+  }
+`;
+/** `undefined`, never null: `JSON.stringify` drops it, so an omitted key stays off the wire. */
+const keyOf = (options) => options?.idempotencyKey;
+export function createArPaymentsModule(transport) {
+    const paymentsPage = async (customerId, skip, take, options) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: AR_PAYMENTS_QUERY,
+            variables: { options: { customerId, skip, take } },
+        }, options);
+        return pageFromVendureList(data.arPayments, skip, take, (cursor) => paymentsPage(customerId, readOffsetCursor(cursor), take, options));
+    };
+    const ledgerPage = async (customerId, skip, take, options) => {
+        const data = await transport.graphql({ api: 'admin', query: AR_LEDGER_QUERY, variables: { customerId, options: { skip, take } } }, options);
+        return pageFromVendureList(data.arLedgerEntries, skip, take, (cursor) => ledgerPage(customerId, readOffsetCursor(cursor), take, options));
+    };
+    return {
+        payments(options) {
+            const { skip, take } = arPageWindow(options);
+            return paymentsPage(options?.customerId, skip, take, options);
+        },
+        ledger(customerId, options) {
+            const { skip, take } = arPageWindow(options);
+            return ledgerPage(customerId, skip, take, options);
+        },
+        async recordPayment(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: RECORD_AR_PAYMENT_MUTATION,
+                variables: { input, idempotencyKey: keyOf(options) },
+            }, options);
+            return data.recordArPayment;
+        },
+        async prepaidDrawdown(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: AR_ORDER_PREPAID_DRAWDOWN_QUERY, variables: { orderId } }, options);
+            return data.arOrderPrepaidDrawdown;
+        },
+        async recordPrepaidDrawdown(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: RECORD_AR_PREPAID_DRAWDOWN_MUTATION,
+                variables: { input, idempotencyKey: keyOf(options) },
+            }, options);
+            return data.recordArPrepaidDrawdown;
+        },
+        directDebit: {
+            async settings(customerId, options) {
+                const data = await transport.graphql({ api: 'admin', query: AR_DIRECT_DEBIT_SETTINGS_QUERY, variables: { customerId } }, options);
+                return data.arDirectDebitSettings;
+            },
+            async update(customerId, input, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: UPDATE_AR_DIRECT_DEBIT_SETTINGS_MUTATION,
+                    variables: { customerId, input },
+                }, options);
+                return data.updateArDirectDebitSettings;
+            },
+            async attempts(invoiceId, options) {
+                const data = await transport.graphql({ api: 'admin', query: AR_COLLECTION_ATTEMPTS_QUERY, variables: { invoiceId } }, options);
+                return data.arCollectionAttempts;
+            },
+            async latestAttempts(invoiceIds, options) {
+                const data = await transport.graphql({ api: 'admin', query: AR_LATEST_COLLECTION_ATTEMPTS_QUERY, variables: { invoiceIds } }, options);
+                return data.arLatestCollectionAttempts;
+            },
+            async sendPreNotification(invoiceId, options) {
+                const data = await transport.graphql({ api: 'admin', query: SEND_AR_PRE_NOTIFICATION_MUTATION, variables: { invoiceId } }, options);
+                return data.sendArDirectDebitPreNotification;
+            },
+            async collectNow(invoiceId, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: COLLECT_AR_INVOICE_NOW_MUTATION,
+                    variables: { invoiceId, idempotencyKey: keyOf(options) },
+                }, options);
+                return data.collectArInvoiceNow;
+            },
+        },
+    };
+}

package/dist/payments/connected-account.d.ts

@@ -0,0 +1,47 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * The Stripe Connect account saved for the legal entity (the seller) of the store the client is
+ * on. Every store of that legal entity shares it.
+ */
+export interface StripeConnectedAccount {
+    /** The engine's id of the store's seller (its legal entity). */
+    sellerId: string;
+    /** The saved Stripe account id (`acct_…`), or null when none is saved. */
+    accountId: string | null;
+}
+/**
+ * The store's Stripe Connect account id, saved on its legal entity (the seller).
+ *
+ * **Saved, not yet used.** The engine keeps the id, but charges route to it only once Stripe
+ * Connect routing is switched on (decision B0c); until then a Stripe payment runs on the
+ * account of the method's own API key (`payments.methods.providerKeys`).
+ *
+ * The engine does not check the value's format: what is sent is stored. A head that wants the
+ * `acct_…` shape checks it itself until the engine does.
+ */
+export interface ConnectedAccountModule {
+    /**
+     * The account saved for the store's legal entity. Any signed-in caller of the store may read
+     * it (the id is not a secret).
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<StripeConnectedAccount>;
+    /**
+     * Save the account id (`null` removes it) on the store's legal entity, and answer what it then
+     * holds. Every store of that legal entity is changed with it, so the caller needs
+     * `UpdateSeller` on each of them: one they may not change refuses the whole call
+     * `SHARED_SELLER_NOT_ALLOWED` (`PermissionDeniedError`, 403), and without `UpdateSeller`
+     * here it is `FORBIDDEN` (403). `SELLER_REQUIRED` (`BusinessRuleError`, 422): the store has no
+     * seller to save it on. An empty string is refused before sending
+     * (`INVALID_CONNECTED_ACCOUNT_INPUT`, 400): `null` removes the account.
+     *
+     * @effect write
+     * @permission UpdateSeller
+     */
+    set(accountId: string | null, options?: Call): Promise<StripeConnectedAccount>;
+}
+export declare const STRIPE_CONNECTED_ACCOUNT_QUERY = "\n  query StripeConnectedAccount {\n    activeChannel {\n      id\n      seller {\n        id\n        customFields {\n          stripeConnectedAccountId\n        }\n      }\n    }\n  }\n";
+export declare const SET_STRIPE_CONNECTED_ACCOUNT_MUTATION = "\n  mutation SetStripeConnectedAccount($input: UpdateSellerInput!) {\n    updateSeller(input: $input) {\n      id\n      customFields {\n        stripeConnectedAccountId\n      }\n    }\n  }\n";
+export declare function createConnectedAccountModule(transport: Transport): ConnectedAccountModule;

package/dist/payments/connected-account.js

@@ -0,0 +1,61 @@
+import { BusinessRuleError, ValidationError } from '@sixtyninecommerce/core';
+import { fieldOf } from '../catalog/types.js';
+export const STRIPE_CONNECTED_ACCOUNT_QUERY = /* GraphQL */ `
+  query StripeConnectedAccount {
+    activeChannel {
+      id
+      seller {
+        id
+        customFields {
+          stripeConnectedAccountId
+        }
+      }
+    }
+  }
+`;
+export const SET_STRIPE_CONNECTED_ACCOUNT_MUTATION = /* GraphQL */ `
+  mutation SetStripeConnectedAccount($input: UpdateSellerInput!) {
+    updateSeller(input: $input) {
+      id
+      customFields {
+        stripeConnectedAccountId
+      }
+    }
+  }
+`;
+const toAccount = (seller) => ({
+    sellerId: seller.id,
+    accountId: seller.customFields?.stripeConnectedAccountId ?? null,
+});
+export function createConnectedAccountModule(transport) {
+    // Hoisted, as `createProvidersModule`'s functions are: a destructured method keeps working.
+    const read = async (options) => {
+        const channel = await fieldOf(transport, STRIPE_CONNECTED_ACCOUNT_QUERY, 'activeChannel', {}, options);
+        if (!channel.seller) {
+            throw new BusinessRuleError({
+                code: 'SELLER_REQUIRED',
+                message: 'This store has no seller (legal entity) to hold a Stripe account.',
+                status: 422,
+                service: 'vendure',
+            });
+        }
+        return toAccount(channel.seller);
+    };
+    return {
+        get: read,
+        async set(accountId, options) {
+            if (accountId !== null && (typeof accountId !== 'string' || accountId === '')) {
+                throw new ValidationError({
+                    code: 'INVALID_CONNECTED_ACCOUNT_INPUT',
+                    message: 'accountId must be a Stripe account id, or null to remove it.',
+                    status: 400,
+                    service: 'vendure',
+                });
+            }
+            // The seller is the store's own, read in the same tenant as the write: the id is never
+            // the caller's to name, so a head cannot save onto another legal entity by mistake.
+            const { sellerId } = await read(options);
+            return toAccount(await fieldOf(transport, SET_STRIPE_CONNECTED_ACCOUNT_MUTATION, 'updateSeller', { input: { id: sellerId, customFields: { stripeConnectedAccountId: accountId } } }, options));
+        },
+    };
+}

package/dist/payments/credit-noted-fields.d.ts

@@ -0,0 +1,19 @@
+import type { Transport } from '@sixtyninecommerce/core';
+/**
+ * `document` without the fields above: what an engine before them accepts. `payable` is newer
+ * still (`payableAware`), so an engine without the credit fields lacks it too and it goes with them.
+ */
+export declare function withoutCreditNotedFields(document: string): string;
+/**
+ * The transport, sending a document that names the credit fields once more without them when the
+ * engine refused it as unknown. Safe for a mutation too: a refused document never ran. A refusal
+ * at HTTP 400 does not name the field, so a document that also carries the older store-credit
+ * fields goes through `storeCreditAware(creditNotedAware(transport))`: the newest fields fall away
+ * first (one resend on an engine that has store credit and not these), and both on an engine
+ * that knows neither (four sends at most).
+ */
+export declare function creditNotedAware(transport: Pick<Transport, 'graphql'>): Pick<Transport, 'graphql'>;
+/** `document` without `payable`: what an engine before it accepts. */
+export declare function withoutPayableField(document: string): string;
+/** The transport, sending a document that names `payable` once more without it when refused. */
+export declare function payableAware(transport: Pick<Transport, 'graphql'>): Pick<Transport, 'graphql'>;

package/dist/payments/credit-noted-fields.js

@@ -0,0 +1,69 @@
+import { isUnknownFieldRejection } from './store-credit-fields.js';
+/**
+ * The payment position's credit fields (branch `murat/order-outstanding-ignores-credit-refunds`):
+ * `creditNoted`, what an invoiced order's credit notes took off its bill, and `owed`, what the
+ * customer still owes after them. An engine before them refuses a document naming either as a
+ * whole, before it runs; the same document without them reads as it did then (both absent: nothing
+ * credited, the customer owes `outstanding`). So the position reads keep working on an older
+ * engine, as `storeCreditAware` keeps the "credit the customer" answers working.
+ */
+const CREDIT_NOTED_FIELDS = [/\bcreditNoted\b/g, /\bowed\b/g, /\bpayable\b/g];
+/**
+ * `document` without the fields above: what an engine before them accepts. `payable` is newer
+ * still (`payableAware`), so an engine without the credit fields lacks it too and it goes with them.
+ */
+export function withoutCreditNotedFields(document) {
+    return CREDIT_NOTED_FIELDS.reduce((text, field) => text.replace(field, ''), document);
+}
+/**
+ * The transport, sending a document that names the credit fields once more without them when the
+ * engine refused it as unknown. Safe for a mutation too: a refused document never ran. A refusal
+ * at HTTP 400 does not name the field, so a document that also carries the older store-credit
+ * fields goes through `storeCreditAware(creditNotedAware(transport))`: the newest fields fall away
+ * first (one resend on an engine that has store credit and not these), and both on an engine
+ * that knows neither (four sends at most).
+ */
+export function creditNotedAware(transport) {
+    return {
+        async graphql(call, options) {
+            try {
+                return await transport.graphql(call, options);
+            }
+            catch (error) {
+                const legacy = withoutCreditNotedFields(call.query);
+                if (legacy === call.query || !isUnknownFieldRejection(error))
+                    throw error;
+                return transport.graphql({ ...call, query: legacy }, options);
+            }
+        },
+    };
+}
+/**
+ * The payment position's `payable` (branch `murat/order-paid-measures-credit-notes`): what the
+ * order's settled money must reach before it counts as paid, its total less what a live invoice's
+ * credit notes took off. Newer than `creditNoted` and `owed`, so it falls away FIRST:
+ * `creditNotedAware(payableAware(transport))` resends without `payable` on an engine that has the
+ * credit fields and not this one (two sends), and without all three on an engine before them
+ * (three sends: the credit fallback drops `payable` too). Absent, it reads as `total`.
+ */
+const PAYABLE_FIELD = /\bpayable\b/g;
+/** `document` without `payable`: what an engine before it accepts. */
+export function withoutPayableField(document) {
+    return document.replace(PAYABLE_FIELD, '');
+}
+/** The transport, sending a document that names `payable` once more without it when refused. */
+export function payableAware(transport) {
+    return {
+        async graphql(call, options) {
+            try {
+                return await transport.graphql(call, options);
+            }
+            catch (error) {
+                const legacy = withoutPayableField(call.query);
+                if (legacy === call.query || !isUnknownFieldRejection(error))
+                    throw error;
+                return transport.graphql({ ...call, query: legacy }, options);
+            }
+        },
+    };
+}

package/dist/payments/customer-consent.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The customer's answer to store credit (incentives sprint 8, ruling Q4): on a door where staff
+ * choose to credit the customer instead of refunding them, whether the customer EXPRESSLY agreed
+ * to store credit instead of a refund to their payment (EU consumer law, CRD art. 13(1)). In a
+ * store whose book is store credit the move records it on its ledger entries
+ * (`StoredValueEntry.customerAgreed`); in an AR store, on a refund, or when nothing moves it is
+ * accepted and recorded nowhere. It is a record, never a condition: no door refuses for it.
+ *
+ * Sent only when stated. Left out, nothing of it reaches the wire, so a call that does not state
+ * it is the request it always was, and an engine before the field still takes it. A call that
+ * DOES state it needs an engine that knows the field (incentives sprint 8 PR 6a): an older one
+ * refuses the document before it runs, and that refusal is surfaced, never retried without the
+ * answer.
+ */
+/** `value` as a variable: `true` or `false` when stated, else `undefined` (off the wire). */
+export declare function customerAgreedVariable(value: unknown): boolean | undefined;
+/** `{ customerAgreed }` when stated, else nothing: spread into an input object. */
+export declare function statedCustomerAgreed(value: unknown): {
+    customerAgreed?: boolean;
+};
+/**
+ * `document` with `$customerAgreed: Boolean` declared after the line `declaration` and passed as
+ * `customerAgreed: $customerAgreed` after the line `argument` (each matched whole, trimmed), in
+ * the same indentation. Built from the document a call without the answer sends, so the two never
+ * drift; it throws at load when either line is missing.
+ */
+export declare function withCustomerAgreed(document: string, anchor: {
+    declaration: string;
+    argument: string;
+}): string;

package/dist/payments/customer-consent.js

@@ -0,0 +1,49 @@
+/**
+ * The customer's answer to store credit (incentives sprint 8, ruling Q4): on a door where staff
+ * choose to credit the customer instead of refunding them, whether the customer EXPRESSLY agreed
+ * to store credit instead of a refund to their payment (EU consumer law, CRD art. 13(1)). In a
+ * store whose book is store credit the move records it on its ledger entries
+ * (`StoredValueEntry.customerAgreed`); in an AR store, on a refund, or when nothing moves it is
+ * accepted and recorded nowhere. It is a record, never a condition: no door refuses for it.
+ *
+ * Sent only when stated. Left out, nothing of it reaches the wire, so a call that does not state
+ * it is the request it always was, and an engine before the field still takes it. A call that
+ * DOES state it needs an engine that knows the field (incentives sprint 8 PR 6a): an older one
+ * refuses the document before it runs, and that refusal is surfaced, never retried without the
+ * answer.
+ */
+/** `value` as a variable: `true` or `false` when stated, else `undefined` (off the wire). */
+export function customerAgreedVariable(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+/** `{ customerAgreed }` when stated, else nothing: spread into an input object. */
+export function statedCustomerAgreed(value) {
+    const stated = customerAgreedVariable(value);
+    return stated === undefined ? {} : { customerAgreed: stated };
+}
+/**
+ * `document` with `$customerAgreed: Boolean` declared after the line `declaration` and passed as
+ * `customerAgreed: $customerAgreed` after the line `argument` (each matched whole, trimmed), in
+ * the same indentation. Built from the document a call without the answer sends, so the two never
+ * drift; it throws at load when either line is missing.
+ */
+export function withCustomerAgreed(document, anchor) {
+    let declared = false;
+    let passed = false;
+    const lines = document.split('\n').flatMap((line) => {
+        const indent = /^\s*/.exec(line)?.[0] ?? '';
+        if (!declared && line.trim() === anchor.declaration) {
+            declared = true;
+            return [line, `${indent}$customerAgreed: Boolean`];
+        }
+        if (declared && !passed && line.trim() === anchor.argument) {
+            passed = true;
+            return [line, `${indent}customerAgreed: $customerAgreed`];
+        }
+        return [line];
+    });
+    if (!declared || !passed) {
+        throw new Error(`withCustomerAgreed: "${anchor.declaration}" or "${anchor.argument}" is not a line of the document`);
+    }
+    return lines.join('\n');
+}