@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/stored-value/index.js

@@ -1,3 +1,4 @@
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
 const ACCOUNT_FIELDS = `
   id
   createdAt
@@ -34,7 +35,8 @@ export const STORED_VALUE_STATEMENT_QUERY = /* GraphQL */ `
       totalItems
       entries {
         id createdAt occurredAt entryType amount balanceAfter unit sourceType sourceId paymentId
-        orderId locationId actorType actorId onBehalfOfRef deviceRef reason
+        orderId locationId actorType actorId onBehalfOfRef deviceRef reason origin originRef lotId
+        customerAgreed
       }
     }
   }
@@ -42,10 +44,28 @@ export const STORED_VALUE_STATEMENT_QUERY = /* GraphQL */ `
 export const STORED_VALUE_LIABILITY_QUERY = /* GraphQL */ `
   query StoredValueLiability($at: DateTime, $kind: String, $locationId: ID) {
     storedValueLiability(at: $at, kind: $kind, locationId: $locationId) {
-      unit kind accounts issued redeemed reversed adjusted expired forfeited outstanding
+      unit kind accounts issued issuedGoodwill issuedFromOrders issuedFromReturns redeemed
+      reversed adjusted expired forfeited paidOut outstanding
     }
   }
 `;
+/**
+ * The statement's and the liability's fields from incentives sprint 8 (the wallet's origins and
+ * split, PR 1; the payout's `lotId` and `paidOut`, PR 5; the customer's consent, PR 6a). An engine
+ * before them refuses a document naming one as a whole, before it runs; the same document without
+ * them reads as it did then.
+ */
+const WALLET_FIELDS = /\b(?:origin|originRef|lotId|customerAgreed|issuedGoodwill|issuedFromOrders|issuedFromReturns|paidOut)\b/g;
+/** `document` without the fields above: what an engine before them accepts. */
+export function withoutWalletFields(document) {
+    return document.replace(WALLET_FIELDS, '');
+}
+/** The newest of them, the customer's consent (PR 6a): an engine with the others lacks only it. */
+const CONSENT_FIELD = /\bcustomerAgreed\b/g;
+/** `document` without the consent field: what an engine of sprint 8 before PR 6a accepts. */
+export function withoutConsentField(document) {
+    return document.replace(CONSENT_FIELD, '');
+}
 export const ISSUE_STORED_VALUE_MUTATION = /* GraphQL */ `
   mutation IssueStoredValue($input: IssueStoredValueInput!, $idempotencyKey: String) {
     issueStoredValue(input: $input, idempotencyKey: $idempotencyKey) { ${ACCOUNT_FIELDS} }
@@ -81,6 +101,18 @@ export const SET_STORED_VALUE_EXPIRY_MUTATION = /* GraphQL */ `
     ) { ${ACCOUNT_FIELDS} }
   }
 `;
+export const PAY_OUT_STORE_CREDIT_MUTATION = /* GraphQL */ `
+  mutation PayOutStoreCredit($input: PayOutStoreCreditInput!, $idempotencyKey: String) {
+    payOutStoreCredit(input: $input, idempotencyKey: $idempotencyKey) {
+      id
+      total
+      state
+      method
+      transactionId
+      reason
+    }
+  }
+`;
 export const REDEEM_STORED_VALUE_MUTATION = /* GraphQL */ `
   mutation RedeemStoredValue($input: RedeemStoredValueInput!, $idempotencyKey: String) {
     redeemStoredValue(input: $input, idempotencyKey: $idempotencyKey) {
@@ -91,8 +123,132 @@ export const REDEEM_STORED_VALUE_MUTATION = /* GraphQL */ `
     }
   }
 `;
+const STORE_CREDIT_SETTINGS_FIELDS = `
+  refundToCredit
+  book
+  available
+  code
+  message
+`;
+export const STORE_CREDIT_SETTINGS_QUERY = /* GraphQL */ `
+  query StoreCreditSettings {
+    storeCreditSettings { ${STORE_CREDIT_SETTINGS_FIELDS} }
+  }
+`;
+export const UPDATE_STORE_CREDIT_SETTINGS_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreCreditSettings($input: UpdateStoreCreditSettingsInput!) {
+    updateStoreCreditSettings(input: $input) { ${STORE_CREDIT_SETTINGS_FIELDS} }
+  }
+`;
+const GIFT_CARD_FIELDS = `
+  id
+  createdAt
+  account { ${ACCOUNT_FIELDS} }
+  origin
+  orderId
+  orderLineId
+  unitIndex
+  productVariantId
+  faceValue
+  maskedCode
+  voided
+`;
+export const GIFT_CARDS_QUERY = /* GraphQL */ `
+  query GiftCards($orderId: ID, $origin: String, $take: Int, $skip: Int) {
+    giftCards(orderId: $orderId, origin: $origin, take: $take, skip: $skip) {
+      items { ${GIFT_CARD_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const GIFT_CARD_QUERY = /* GraphQL */ `
+  query GiftCard($id: ID!) {
+    giftCard(id: $id) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const GIFT_CARD_BY_CODE_QUERY = /* GraphQL */ `
+  query GiftCardByCode($code: String!) {
+    giftCardByCode(code: $code) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const GIFT_CARD_VARIANTS_QUERY = /* GraphQL */ `
+  query GiftCardVariants($productVariantIds: [ID!]!) {
+    giftCardVariants(productVariantIds: $productVariantIds) {
+      productVariantId
+      validityMonths
+      createdAt
+    }
+  }
+`;
+export const GIFT_CARD_VARIANT_UNPAID_ORDERS_QUERY = /* GraphQL */ `
+  query GiftCardVariantUnpaidOrders($productVariantIds: [ID!]!) {
+    giftCardVariants(productVariantIds: $productVariantIds) {
+      productVariantId
+      unpaidOrders
+    }
+  }
+`;
+export const SET_GIFT_CARD_VARIANT_MUTATION = /* GraphQL */ `
+  mutation SetGiftCardVariant($productVariantId: ID!, $enabled: Boolean!, $validityMonths: Int) {
+    setGiftCardVariant(
+      productVariantId: $productVariantId
+      enabled: $enabled
+      validityMonths: $validityMonths
+    ) {
+      productVariantId
+      validityMonths
+      createdAt
+    }
+  }
+`;
+export const VOID_GIFT_CARD_MUTATION = /* GraphQL */ `
+  mutation VoidGiftCard($id: ID!, $reason: String!, $idempotencyKey: String) {
+    voidGiftCard(id: $id, reason: $reason, idempotencyKey: $idempotencyKey) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const REISSUE_GIFT_CARD_CODE_MUTATION = /* GraphQL */ `
+  mutation ReissueGiftCardCode(
+    $id: ID!
+    $reason: String!
+    $notify: Boolean!
+    $idempotencyKey: String
+  ) {
+    reissueGiftCardCode(
+      id: $id
+      reason: $reason
+      notify: $notify
+      idempotencyKey: $idempotencyKey
+    ) {
+      giftCard { ${GIFT_CARD_FIELDS} }
+      code
+    }
+  }
+`;
+export const ISSUE_GIFT_CARD_MUTATION = /* GraphQL */ `
+  mutation IssueGiftCard($input: IssueGiftCardInput!, $idempotencyKey: String) {
+    issueGiftCard(input: $input, idempotencyKey: $idempotencyKey) {
+      giftCard { ${GIFT_CARD_FIELDS} }
+      code
+    }
+  }
+`;
 export function createStoredValueModule(transport) {
     const read = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    // A read naming the sprint-8 fields, sent again to an engine that refuses one as unknown: first
+    // without the consent field alone (an engine with the rest of sprint 8), then without any of them.
+    const readWallet = async (query, variables, options) => {
+        const documents = [...new Set([query, withoutConsentField(query), withoutWalletFields(query)])];
+        for (const [index, document] of documents.entries()) {
+            try {
+                return await read(document, variables, options);
+            }
+            catch (error) {
+                if (index === documents.length - 1 || !isUnknownFieldRejection(error))
+                    throw error;
+            }
+        }
+        throw new Error('unreachable: the last document either answers or throws');
+    };
     // The key is an ARGUMENT on the Admin API; `undefined` keeps an omitted key off the wire.
     const write = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables: { ...variables, idempotencyKey: options?.idempotencyKey } }, options);
     return {
@@ -103,10 +259,27 @@ export function createStoredValueModule(transport) {
             return (await read(STORED_VALUE_ACCOUNT_QUERY, { id }, options)).storedValueAccount;
         },
         async statement(accountId, window = {}, options) {
-            return (await read(STORED_VALUE_STATEMENT_QUERY, { accountId, ...window }, options)).storedValueStatement;
+            const statement = (await readWallet(STORED_VALUE_STATEMENT_QUERY, { accountId, ...window }, options)).storedValueStatement;
+            return {
+                ...statement,
+                entries: statement.entries.map((entry) => ({
+                    ...entry,
+                    origin: entry.origin ?? null,
+                    originRef: entry.originRef ?? null,
+                    lotId: entry.lotId ?? null,
+                    customerAgreed: entry.customerAgreed ?? null,
+                })),
+            };
         },
         async liability(filter = {}, options) {
-            return (await read(STORED_VALUE_LIABILITY_QUERY, filter, options)).storedValueLiability;
+            const rows = (await readWallet(STORED_VALUE_LIABILITY_QUERY, filter, options)).storedValueLiability;
+            return rows.map((row) => ({
+                ...row,
+                issuedGoodwill: row.issuedGoodwill ?? null,
+                issuedFromOrders: row.issuedFromOrders ?? null,
+                issuedFromReturns: row.issuedFromReturns ?? null,
+                paidOut: row.paidOut ?? null,
+            }));
         },
         async issue(input, options) {
             return (await write(ISSUE_STORED_VALUE_MUTATION, { input }, options)).issueStoredValue;
@@ -126,5 +299,51 @@ export function createStoredValueModule(transport) {
         async redeem(input, options) {
             return (await write(REDEEM_STORED_VALUE_MUTATION, { input }, options)).redeemStoredValue;
         },
+        async payOut(input, options) {
+            return (await write(PAY_OUT_STORE_CREDIT_MUTATION, { input }, options)).payOutStoreCredit;
+        },
+        async storeCreditSettings(options) {
+            return (await read(STORE_CREDIT_SETTINGS_QUERY, {}, options)).storeCreditSettings;
+        },
+        async updateStoreCreditSettings(input, options) {
+            return (await read(UPDATE_STORE_CREDIT_SETTINGS_MUTATION, { input: { refundToCredit: input.refundToCredit } }, options)).updateStoreCreditSettings;
+        },
+        giftCards: {
+            async list(filter = {}, options) {
+                return (await read(GIFT_CARDS_QUERY, filter, options)).giftCards;
+            },
+            async get(id, options) {
+                return (await read(GIFT_CARD_QUERY, { id }, options))
+                    .giftCard;
+            },
+            // A GraphQL call is always a POST body: the code never reaches a URL (the engine refuses a
+            // GET lookup, `STORED_VALUE_GIFT_CARD_LOOKUP_POST_ONLY`).
+            async byCode(code, options) {
+                return (await read(GIFT_CARD_BY_CODE_QUERY, { code }, options)).giftCardByCode;
+            },
+            async variants(productVariantIds, options) {
+                return (await read(GIFT_CARD_VARIANTS_QUERY, { productVariantIds }, options)).giftCardVariants;
+            },
+            async variantUnpaidOrders(productVariantId, options) {
+                const [variant] = (await read(GIFT_CARD_VARIANT_UNPAID_ORDERS_QUERY, { productVariantIds: [productVariantId] }, options)).giftCardVariants;
+                return variant ? variant.unpaidOrders : null;
+            },
+            async setVariant(productVariantId, enabled, validityMonths, options) {
+                return (await read(SET_GIFT_CARD_VARIANT_MUTATION, {
+                    productVariantId,
+                    enabled,
+                    ...(validityMonths === undefined ? {} : { validityMonths }),
+                }, options)).setGiftCardVariant;
+            },
+            async void(id, reason, options) {
+                return (await write(VOID_GIFT_CARD_MUTATION, { id, reason }, options)).voidGiftCard;
+            },
+            async reissueCode(id, input, options) {
+                return (await write(REISSUE_GIFT_CARD_CODE_MUTATION, { id, reason: input.reason, notify: input.notify }, options)).reissueGiftCardCode;
+            },
+            async issue(input, options) {
+                return (await write(ISSUE_GIFT_CARD_MUTATION, { input }, options)).issueGiftCard;
+            },
+        },
     };
 }