@sixtyninecommerce/admin 0.6.0 → 0.8.0

package/dist/customers/index.js

@@ -0,0 +1,279 @@
+import { errorFromErrorResult, isErrorResult, pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+/**
+ * Customers — the commerce master record (headless spec §6.5).
+ *
+ * Commerce owns customer identity and addresses; a vertical stores a
+ * `platformCustomerId` and asks here. The two things worth knowing before
+ * reading further are both traps this module exists to close:
+ *
+ * 1. **`create` wraps `createChannelCustomer`, never core `createCustomer`.**
+ *    Vendure's own mutation silently SHARES a customer across channels when the
+ *    email already exists anywhere on the platform (ADR-016): it finds that
+ *    customer and pushes the new channel onto them. On a multi-tenant platform
+ *    that is a cross-tenant data leak wearing the clothes of a convenience.
+ *    There is no way to reach the leaking path through this SDK.
+ * 2. **`erase` is a scrub, not a delete.** It removes the person and keeps the
+ *    record, the orders and the documents. It is the only destructive customer
+ *    operation the platform has.
+ */
+export const CUSTOMER_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  title
+  firstName
+  lastName
+  emailAddress
+  phoneNumber
+  groups {
+    id
+    name
+  }
+`;
+export const CUSTOMER_ADDRESS_FIELDS = /* GraphQL */ `
+  id
+  fullName
+  company
+  streetLine1
+  streetLine2
+  city
+  province
+  postalCode
+  country {
+    code
+    name
+  }
+  phoneNumber
+  defaultShippingAddress
+  defaultBillingAddress
+`;
+export const LIST_QUERY = /* GraphQL */ `
+  query Customers($options: CustomerListOptions) {
+    customers(options: $options) {
+      items { ${CUSTOMER_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const GET_QUERY = /* GraphQL */ `
+  query CustomerById($id: ID!) {
+    customer(id: $id) { ${CUSTOMER_FIELDS} }
+  }
+`;
+export const ADDRESSES_QUERY = /* GraphQL */ `
+  query CustomerAddresses($id: ID!) {
+    customer(id: $id) {
+      id
+      addresses { ${CUSTOMER_ADDRESS_FIELDS} }
+    }
+  }
+`;
+/**
+ * The CHANNEL-SCOPED creation mutation. See the module docblock — core
+ * `createCustomer` is not an option, and this SDK exposes no path to it.
+ */
+export const CREATE_MUTATION = /* GraphQL */ `
+  mutation CreateChannelCustomer($input: CreateCustomerInput!, $password: String) {
+    createChannelCustomer(input: $input, password: $password) {
+      id
+      emailAddress
+      createdNew
+    }
+  }
+`;
+export const UPDATE_MUTATION = /* GraphQL */ `
+  mutation UpdateCustomer($input: UpdateCustomerInput!) {
+    updateCustomer(input: $input) {
+      ... on Customer { ${CUSTOMER_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+export const INVITE_MUTATION = /* GraphQL */ `
+  mutation InviteCustomer($customerId: ID!, $mode: CustomerInviteMode) {
+    inviteCustomer(customerId: $customerId, mode: $mode) {
+      customerId
+      emailAddress
+      mode
+      sentAt
+    }
+  }
+`;
+export const RESEND_INVITE_MUTATION = /* GraphQL */ `
+  mutation ResendCustomerInvitation($customerId: ID!, $mode: CustomerInviteMode) {
+    resendCustomerInvitation(customerId: $customerId, mode: $mode) {
+      customerId
+      emailAddress
+      mode
+      sentAt
+    }
+  }
+`;
+export const ERASE_MUTATION = /* GraphQL */ `
+  mutation EraseCustomer(
+    $customerId: ID!
+    $reason: String!
+    $force: Boolean
+    $idempotencyKey: String
+  ) {
+    eraseCustomer(
+      customerId: $customerId
+      reason: $reason
+      force: $force
+      idempotencyKey: $idempotencyKey
+    ) {
+      customerId
+      erasedAt
+      ordersRetained
+      documentsRetained
+      forced
+      reason
+    }
+  }
+`;
+export const ERASURE_QUERY = /* GraphQL */ `
+  query CustomerErasure($customerId: ID!) {
+    customerErasure(customerId: $customerId) {
+      customerId
+      erasedAt
+      ordersRetained
+      documentsRetained
+      forced
+      reason
+    }
+  }
+`;
+export const ADD_TO_GROUP_MUTATION = /* GraphQL */ `
+  mutation AddCustomersToGroup($customerGroupId: ID!, $customerIds: [ID!]!) {
+    addCustomersToGroup(customerGroupId: $customerGroupId, customerIds: $customerIds) {
+      id
+      name
+    }
+  }
+`;
+export const REMOVE_FROM_GROUP_MUTATION = /* GraphQL */ `
+  mutation RemoveCustomersFromGroup($customerGroupId: ID!, $customerIds: [ID!]!) {
+    removeCustomersFromGroup(customerGroupId: $customerGroupId, customerIds: $customerIds) {
+      id
+      name
+    }
+  }
+`;
+export const CREATE_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation CreateCustomerAddress($customerId: ID!, $input: CreateAddressInput!) {
+    createCustomerAddress(customerId: $customerId, input: $input) {
+      ${CUSTOMER_ADDRESS_FIELDS}
+    }
+  }
+`;
+export const UPDATE_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation UpdateCustomerAddress($input: UpdateAddressInput!) {
+    updateCustomerAddress(input: $input) { ${CUSTOMER_ADDRESS_FIELDS} }
+  }
+`;
+export const DELETE_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation DeleteCustomerAddress($id: ID!) {
+    deleteCustomerAddress(id: $id) { success }
+  }
+`;
+const DEFAULT_PAGE_SIZE = 25;
+export function createCustomersModule(transport) {
+    const listPage = async (skip, take, options) => {
+        const data = await transport.graphql({ api: 'admin', query: LIST_QUERY, variables: { options: { skip, take } } }, options);
+        return pageFromVendureList(data.customers, skip, take, (cursor) => listPage(readOffsetCursor(cursor), take, options));
+    };
+    return {
+        list(options) {
+            // The Admin API is offset-paged; the offset hides inside the cursor so a
+            // consumer only ever sees `Page<T>` (spec §9.3).
+            const take = options?.limit ?? DEFAULT_PAGE_SIZE;
+            const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return listPage(skip, take, options);
+        },
+        async get(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: GET_QUERY, variables: { id } }, options);
+            return data.customer;
+        },
+        async create(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: CREATE_MUTATION,
+                variables: { input, password: options?.password ?? null },
+            }, options);
+            return data.createChannelCustomer;
+        },
+        async update(id, input, options) {
+            const data = await transport.graphql({ api: 'admin', query: UPDATE_MUTATION, variables: { input: { id, ...input } } }, options);
+            // `updateCustomer` is a UNION — `Customer | EmailAddressConflictError` —
+            // delivered at HTTP 200, so the transport never throws for it. Returned
+            // unchecked, a rename onto an address already taken on the channel
+            // resolved "successfully" with an error object, and the caller saw a
+            // `Customer` whose `id` was undefined.
+            if (isErrorResult(data.updateCustomer))
+                throw errorFromErrorResult(data.updateCustomer);
+            return data.updateCustomer;
+        },
+        async invite(id, options) {
+            // `resend` picks the SEPARATE mutation rather than a flag on one: the two
+            // behave identically on the server and exist apart only so a dashboard
+            // can label the repeat honestly. A still-valid set-password token is
+            // reused rather than rotated, so a link already in the customer's inbox
+            // keeps working.
+            const query = options?.resend === true ? RESEND_INVITE_MUTATION : INVITE_MUTATION;
+            const data = await transport.graphql({ api: 'admin', query, variables: { customerId: id, mode: options?.mode ?? null } }, options);
+            return (data.inviteCustomer ?? data.resendCustomerInvitation);
+        },
+        async erase(id, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: ERASE_MUTATION,
+                variables: {
+                    customerId: id,
+                    reason: options.reason,
+                    force: options.force ?? null,
+                    idempotencyKey: options.idempotencyKey ?? null,
+                },
+            }, options);
+            return data.eraseCustomer;
+        },
+        async erasure(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: ERASURE_QUERY, variables: { customerId: id } }, options);
+            return data.customerErasure;
+        },
+        groups: {
+            async add(groupId, customerIds, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: ADD_TO_GROUP_MUTATION,
+                    variables: { customerGroupId: groupId, customerIds },
+                }, options);
+                return data.addCustomersToGroup;
+            },
+            async remove(groupId, customerIds, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: REMOVE_FROM_GROUP_MUTATION,
+                    variables: { customerGroupId: groupId, customerIds },
+                }, options);
+                return data.removeCustomersFromGroup;
+            },
+        },
+        addresses: {
+            async list(customerId, options) {
+                const data = await transport.graphql({ api: 'admin', query: ADDRESSES_QUERY, variables: { id: customerId } }, options);
+                return data.customer?.addresses ?? [];
+            },
+            async create(customerId, input, options) {
+                const data = await transport.graphql({ api: 'admin', query: CREATE_ADDRESS_MUTATION, variables: { customerId, input } }, options);
+                return data.createCustomerAddress;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({ api: 'admin', query: UPDATE_ADDRESS_MUTATION, variables: { input } }, options);
+                return data.updateCustomerAddress;
+            },
+            async delete(id, options) {
+                await transport.graphql({ api: 'admin', query: DELETE_ADDRESS_MUTATION, variables: { id } }, options);
+            },
+        },
+    };
+}