@hartl-services/medusa-storefront 0.2.0 → 0.4.0

package/dist/server/customer.d.ts

@@ -1,6 +1,7 @@
 import type { LoginWithCodeRequest, RequestLoginCodeRequest } from "@hartl-services/medusa-contracts/types/customer-auth-store";
-import type { CheckoutAddressValues, CustomerAddressValues, CustomerAuthValues, CustomerProfileValues, CustomerRegistrationProfileValues, VerificationResendValues } from "../core/form-values.js";
+import type { CheckoutAddressValues, CustomerAddressValues, CustomerAuthValues, CustomerProfileValues, CustomerRegistrationProfileValues, PartnerRegistrationProfileValues, VerificationResendValues } from "../core/form-values.js";
 import type { ServerContext } from "./context.js";
+import type { ServerPluginFeatures } from "./plugin-features.js";
 import type { RunMedusaAction } from "./run-medusa-action.js";
 export interface UpdateCustomerAddressInput {
     addressId: string;
@@ -10,7 +11,7 @@ export interface UpdateCustomerAddressInput {
         metadata?: Record<string, unknown>;
     };
 }
-export declare function createCustomer(context: ServerContext, runMedusaAction: RunMedusaAction): {
+export declare function createCustomer(context: ServerContext, runMedusaAction: RunMedusaAction, pluginFeatures: ServerPluginFeatures): {
     retrieveCustomer(): Promise<import("@medusajs/types").StoreCustomerResponse | null>;
     loginCustomer(data: CustomerAuthValues): Promise<import("../core/action-result.js").MedusaActionResult<{
         state: "success";
@@ -40,12 +41,32 @@ export declare function createCustomer(context: ServerContext, runMedusaAction:
      */
     registerCustomerWithProfile(data: CustomerRegistrationProfileValues): Promise<import("../core/action-result.js").MedusaActionResult<{
         state: "verification_required";
+        addressId?: undefined;
         addressSaved?: undefined;
         sessionToken?: undefined;
     } | {
         addressSaved: boolean;
+        sessionToken: string;
         state: "success";
+    }>>;
+    /**
+     * Partner (e.g. therapist) registration: the account with its company
+     * address as default address, then the partner application from that
+     * address. Like the plain registration it counts as registered even if a
+     * later step fails (`addressSaved` / `applicationSubmitted` false). While
+     * the e-mail is unconfirmed, address and application wait until the
+     * first login. Refused up front while the partner portal is off.
+     */
+    registerPartnerWithProfile(data: PartnerRegistrationProfileValues): Promise<import("../core/action-result.js").MedusaActionResult<{
+        state: "verification_required";
+        addressId?: undefined;
+        addressSaved?: undefined;
+        sessionToken?: undefined;
+    } | {
+        addressSaved: boolean;
+        applicationSubmitted: boolean;
         sessionToken: string;
+        state: "success";
     }>>;
     requestLoginCode(data: RequestLoginCodeRequest): Promise<import("../core/action-result.js").MedusaActionResult<void>>;
     loginWithCode(data: LoginWithCodeRequest): Promise<import("../core/action-result.js").MedusaActionResult<{

package/dist/server/customer.js

@@ -1,12 +1,15 @@
 import { customerAuthStorePaths } from "@hartl-services/medusa-contracts/paths/customer-auth";
 import { EMAIL_OTP_AUTH_PROVIDER, LoginWithCodeSchema, RequestLoginCodeSchema, normalizeLoginEmail } from "@hartl-services/medusa-contracts/schemas/customer-auth";
 import { customerVerificationStorePaths } from "@hartl-services/medusa-contracts/paths/customer-verification";
+import { affiliateStorePaths } from "@hartl-services/medusa-contracts/paths/affiliate";
+import { TAX_COMPLIANCE_FEATURES, TAX_COMPLIANCE_PLUGIN_KEY, taxCompliancePaths } from "@hartl-services/medusa-contracts/paths/tax-compliance";
 import { vatNumberMetadataPatch } from "../core/addresses.js";
 import { completeCustomerSignIn as completeCustomerSignInWith, loginWithEmailpass } from "../core/auth/customer-sign-in.js";
 import { toCustomerAddressesFromCheckout } from "../core/checkout/checkout-address-draft.js";
 import { StorefrontError } from "../core/errors.js";
 import { CART_OWNER_FIELDS, CUSTOMER_FIELDS } from "../core/fields.js";
-import { createCheckoutAddressSchema, createVerificationResendSchema, customerAddressSchema, customerAuthSchema, customerProfileSchema, customerRegistrationProfileSchema, registrationAddressSchema } from "../core/form-values.js";
+import { createCheckoutAddressSchema, createVerificationResendSchema, customerAddressSchema, customerAuthSchema, customerProfileSchema, customerRegistrationProfileSchema, partnerRegistrationProfileSchema, registrationAddressSchema } from "../core/form-values.js";
+import { isPluginFeatureEnabled } from "../core/plugin-features.js";
 function cartCustomerHasAccount(cart) {
     const customer = Reflect.get(cart, "customer");
     return typeof customer === "object" && customer !== null && Reflect.get(customer, "has_account") === true;
@@ -20,10 +23,23 @@ function isVerificationRequired(result) {
  * no token to add one, so it waits here until the first login.
  */
 const PENDING_REGISTRATION_ADDRESS_KEY = "pending_registration_address";
+/**
+ * Metadata key of a partner application that waits for its company address
+ * (the registration address): submitted right after the address is stored.
+ */
+const PENDING_PARTNER_APPLICATION_KEY = "pending_partner_application";
+function toPendingPartnerApplication(value) {
+    return typeof value === "object" && value !== null ? { confirmed_without_vat_number: Reflect.get(value, "confirmed_without_vat_number") === true } : null;
+}
+/** The registration address the customer create took last (Medusa answers with the whole customer). */
+function findDefaultAddressId(customer) {
+    const addresses = customer.addresses ?? [];
+    return (addresses.find(({ is_default_billing }) => is_default_billing) ?? addresses[0])?.id ?? null;
+}
 function getAuthenticationToken(result) {
     return typeof result === "string" ? result : null;
 }
-export function createCustomer(context, runMedusaAction) {
+export function createCustomer(context, runMedusaAction, pluginFeatures) {
     const { createAuthenticatedMedusaClient, createMedusaClient, session } = context;
     async function requestCustomerVerification(email, token) {
         const sdk = createAuthenticatedMedusaClient(token);
@@ -78,40 +94,80 @@ export function createCustomer(context, runMedusaAction) {
         }
     }
     /**
-     * Stores the registration address as the customer's default address. True
-     * when stored (or nothing to store); never throws - a failing address must
-     * not turn a registration or login into a failure.
+     * Stores the registration address as the customer's default address.
+     * `saved` is true when stored (or nothing to store); never throws - a
+     * failing address must not turn a registration or login into a failure.
      */
     async function storeRegistrationAddress(token, profile, address) {
         const parsed = registrationAddressSchema.safeParse(address);
         if (!parsed.success) {
-            return true;
+            return { addressId: null, saved: true };
         }
         try {
             const sdk = createAuthenticatedMedusaClient(token);
-            await sdk.store.customer.createAddress({
-                ...parsed.data,
+            const { vat_number: vatNumber, ...addressValues } = parsed.data;
+            const { customer } = await sdk.store.customer.createAddress({
+                ...addressValues,
                 first_name: profile.first_name ?? undefined,
                 is_default_billing: true,
                 is_default_shipping: true,
                 last_name: profile.last_name ?? undefined,
                 phone: profile.phone || undefined,
-            });
+                ...(vatNumber ? { metadata: vatNumberMetadataPatch(vatNumber) } : {}),
+            }, { fields: "*addresses" });
             await sdk.store.customer.update({ metadata: { [PENDING_REGISTRATION_ADDRESS_KEY]: null } });
-            return true;
+            return { addressId: findDefaultAddressId(customer), saved: true };
         }
         catch (error) {
             context.reportError(error, { area: "customer-auth", context: { step: "registration_address" } });
+            return { addressId: null, saved: false };
+        }
+    }
+    /**
+     * Submits a registration's partner application with its company address:
+     * a UID is checked first (the application takes it only once checked; an
+     * unreachable check counts too), and the pending marker is cleared either
+     * way. True when submitted; never throws - the account stays registered.
+     */
+    async function submitPartnerApplication(token, addressId, hasVatNumber, application) {
+        const sdk = createAuthenticatedMedusaClient(token);
+        try {
+            if (hasVatNumber && isPluginFeatureEnabled(await pluginFeatures.loadPluginFeatures(), TAX_COMPLIANCE_PLUGIN_KEY, TAX_COMPLIANCE_FEATURES.vatValidation)) {
+                await sdk.client.fetch(taxCompliancePaths.store.customers.addressTaxIdentification(addressId), { method: "POST" });
+            }
+            await sdk.client.fetch(affiliateStorePaths.post.register, {
+                body: { confirmed_without_vat_number: application.confirmed_without_vat_number, customer_address_id: addressId },
+                method: "POST",
+            });
+            return true;
+        }
+        catch (error) {
+            context.reportError(error, { area: "affiliate", context: { step: "registration_application" } });
             return false;
         }
+        finally {
+            try {
+                await sdk.store.customer.update({ metadata: { [PENDING_PARTNER_APPLICATION_KEY]: null } });
+            }
+            catch (error) {
+                context.reportError(error, { area: "affiliate", context: { step: "registration_application_cleanup" } });
+            }
+        }
     }
-    /** After a login: adds a registration address that waited for the e-mail confirmation. */
+    /**
+     * After a login: adds a registration address that waited for the e-mail
+     * confirmation, then the partner application that waited for it.
+     */
     async function applyPendingRegistrationAddress(token) {
         try {
             const { customer } = await createAuthenticatedMedusaClient(token).store.customer.retrieve({ fields: "first_name,last_name,phone,metadata,*addresses" });
             const pending = customer.metadata?.[PENDING_REGISTRATION_ADDRESS_KEY];
             if (pending && (customer.addresses?.length ?? 0) === 0) {
-                await storeRegistrationAddress(token, customer, pending);
+                const { addressId } = await storeRegistrationAddress(token, customer, pending);
+                const application = toPendingPartnerApplication(customer.metadata?.[PENDING_PARTNER_APPLICATION_KEY]);
+                if (addressId && application) {
+                    await submitPartnerApplication(token, addressId, Boolean(registrationAddressSchema.safeParse(pending).data?.vat_number), application);
+                }
             }
         }
         catch (error) {
@@ -127,6 +183,34 @@ export function createCustomer(context, runMedusaAction) {
         await applyPendingRegistrationAddress(result.sessionToken);
         return result;
     }
+    async function registerWithProfile(parsed, metadata = {}) {
+        const credentials = { email: parsed.email, password: parsed.password };
+        const registrationSdk = createMedusaClient();
+        const registrationToken = await registrationSdk.auth.register("customer", "emailpass", credentials);
+        const customerSdk = createAuthenticatedMedusaClient(registrationToken);
+        const pendingMetadata = { ...(parsed.address ? { [PENDING_REGISTRATION_ADDRESS_KEY]: parsed.address } : {}), ...metadata };
+        const { customer } = await customerSdk.store.customer.create({
+            email: parsed.email,
+            first_name: parsed.first_name,
+            last_name: parsed.last_name,
+            ...(parsed.phone ? { phone: parsed.phone } : {}),
+            ...(Object.keys(pendingMetadata).length > 0 ? { metadata: pendingMetadata } : {}),
+        });
+        const loginSdk = createMedusaClient();
+        const result = await loginSdk.auth.login("customer", "emailpass", credentials);
+        if (isVerificationRequired(result)) {
+            await requestCustomerVerification(parsed.email, result.token);
+            return { state: "verification_required" };
+        }
+        const token = getAuthenticationToken(result);
+        if (!token) {
+            throw new StorefrontError("auth.registration_unsupported_step");
+        }
+        await transferActiveCartToCustomer(createAuthenticatedMedusaClient(token), { id: customer.id, email: parsed.email });
+        await session.setMedusaAuthToken(token);
+        const { addressId, saved } = parsed.address ? await storeRegistrationAddress(token, parsed, parsed.address) : { addressId: null, saved: true };
+        return { addressId, addressSaved: saved, state: "success", sessionToken: token };
+    }
     async function signInCustomer(data, { requestVerificationMail }) {
         const parsed = customerAuthSchema.parse(data);
         return runMedusaAction(async () => {
@@ -202,32 +286,32 @@ export function createCustomer(context, runMedusaAction) {
          */
         async registerCustomerWithProfile(data) {
             const parsed = customerRegistrationProfileSchema.parse(data);
-            const credentials = { email: parsed.email, password: parsed.password };
             return runMedusaAction(async () => {
-                const registrationSdk = createMedusaClient();
-                const registrationToken = await registrationSdk.auth.register("customer", "emailpass", credentials);
-                const customerSdk = createAuthenticatedMedusaClient(registrationToken);
-                const { customer } = await customerSdk.store.customer.create({
-                    email: parsed.email,
-                    first_name: parsed.first_name,
-                    last_name: parsed.last_name,
-                    ...(parsed.phone ? { phone: parsed.phone } : {}),
-                    ...(parsed.address ? { metadata: { [PENDING_REGISTRATION_ADDRESS_KEY]: parsed.address } } : {}),
-                });
-                const loginSdk = createMedusaClient();
-                const result = await loginSdk.auth.login("customer", "emailpass", credentials);
-                if (isVerificationRequired(result)) {
-                    await requestCustomerVerification(parsed.email, result.token);
-                    return { state: "verification_required" };
+                const result = await registerWithProfile(parsed);
+                return result.state === "success" ? { addressSaved: result.addressSaved, sessionToken: result.sessionToken, state: result.state } : result;
+            }, { endSessionOnUnauthorized: false });
+        },
+        /**
+         * Partner (e.g. therapist) registration: the account with its company
+         * address as default address, then the partner application from that
+         * address. Like the plain registration it counts as registered even if a
+         * later step fails (`addressSaved` / `applicationSubmitted` false). While
+         * the e-mail is unconfirmed, address and application wait until the
+         * first login. Refused up front while the partner portal is off.
+         */
+        async registerPartnerWithProfile(data) {
+            const parsed = partnerRegistrationProfileSchema.parse(data);
+            return runMedusaAction(async () => {
+                if (!isPluginFeatureEnabled(await pluginFeatures.loadPluginFeatures(), "affiliate", "partner_portal")) {
+                    throw new StorefrontError("partner_registration.unavailable");
                 }
-                const token = getAuthenticationToken(result);
-                if (!token) {
-                    throw new StorefrontError("auth.registration_unsupported_step");
+                const application = { confirmed_without_vat_number: parsed.confirmed_without_vat_number };
+                const result = await registerWithProfile(parsed, { [PENDING_PARTNER_APPLICATION_KEY]: application });
+                if (result.state !== "success") {
+                    return result;
                 }
-                await transferActiveCartToCustomer(createAuthenticatedMedusaClient(token), { id: customer.id, email: parsed.email });
-                await session.setMedusaAuthToken(token);
-                const addressSaved = parsed.address ? await storeRegistrationAddress(token, parsed, parsed.address) : true;
-                return { addressSaved, state: "success", sessionToken: token };
+                const applicationSubmitted = result.addressId ? await submitPartnerApplication(result.sessionToken, result.addressId, Boolean(parsed.address.vat_number), application) : false;
+                return { addressSaved: result.addressSaved, applicationSubmitted, sessionToken: result.sessionToken, state: result.state };
             }, { endSessionOnUnauthorized: false });
         },
         // The backend answers 202 for every address (no account enumeration) and

package/dist/server/index.d.ts

@@ -63,12 +63,24 @@ export declare function createStorefrontServer(config: StorefrontServerConfig):
         }>>;
         registerCustomerWithProfile(data: import("../core/form-values.js").CustomerRegistrationProfileValues): Promise<import("../core/action-result.js").MedusaActionResult<{
             state: "verification_required";
+            addressId?: undefined;
             addressSaved?: undefined;
             sessionToken?: undefined;
         } | {
             addressSaved: boolean;
+            sessionToken: string;
             state: "success";
+        }>>;
+        registerPartnerWithProfile(data: import("../core/form-values.js").PartnerRegistrationProfileValues): Promise<import("../core/action-result.js").MedusaActionResult<{
+            state: "verification_required";
+            addressId?: undefined;
+            addressSaved?: undefined;
+            sessionToken?: undefined;
+        } | {
+            addressSaved: boolean;
+            applicationSubmitted: boolean;
             sessionToken: string;
+            state: "success";
         }>>;
         requestLoginCode(data: import("@hartl-services/medusa-contracts/types/customer-auth-store").RequestLoginCodeRequest): Promise<import("../core/action-result.js").MedusaActionResult<void>>;
         loginWithCode(data: import("@hartl-services/medusa-contracts/types/customer-auth-store").LoginWithCodeRequest): Promise<import("../core/action-result.js").MedusaActionResult<{
@@ -109,6 +121,8 @@ export declare function createStorefrontServer(config: StorefrontServerConfig):
         verifyCustomerAddressTaxIdentification(addressId: string): Promise<import("../core/action-result.js").MedusaActionResult<import("@hartl-services/medusa-contracts/types/tax-compliance-store").SubmitCustomerAddressTaxIdentificationResponse>>;
     };
     affiliate: {
+        loadPartnerPortalState: () => Promise<import("@hartl-services/medusa-contracts/types/affiliate-store").StoreAffiliatePortalContextResponse["portal_state"] | null>;
+        isActivePartner(): Promise<boolean>;
         submitAffiliateApplication(data: import("@hartl-services/medusa-contracts/types/affiliate-store").SubmitAffiliateApplicationRequest): Promise<import("../core/action-result.js").MedusaActionResult<{
             application: {
                 id: string;
@@ -202,6 +216,10 @@ export declare function createStorefrontServer(config: StorefrontServerConfig):
                     resolved_unit_price: number | null;
                     discounted_line_total: number | null;
                     currency_code: string | null;
+                    product_title: string | null;
+                    variant_title: string | null;
+                    batch_name: string | null;
+                    batch_expiry_date: string | null;
                 }[];
             };
             draft_order: {

package/dist/server/index.js

@@ -26,6 +26,7 @@ export function createStorefrontServer(config) {
     const runMedusaAction = createRunMedusaAction(context);
     const pluginFeatures = createPluginFeatures(context);
     const region = createRegion(context);
+    const affiliate = createAffiliate(context, pluginFeatures, runMedusaAction);
     return {
         session: context.session,
         createMedusaClient: context.createMedusaClient,
@@ -34,12 +35,12 @@ export function createStorefrontServer(config) {
         pluginFeatures,
         region,
         cart: createCart(context, pluginFeatures),
-        customer: createCustomer(context, runMedusaAction),
+        customer: createCustomer(context, runMedusaAction, pluginFeatures),
         checkout: createCheckout(context),
         taxCompliance: createTaxCompliance(context, pluginFeatures, runMedusaAction),
-        affiliate: createAffiliate(context, pluginFeatures, runMedusaAction),
+        affiliate,
         orders: createOrders(context),
         documents: createDocuments(context),
-        catalog: createCatalog(context, region),
+        catalog: createCatalog(context, region, affiliate.isActivePartner),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hartl-services/medusa-storefront",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Headless Medusa storefront logic, Next.js server/browser adapters and React hooks for shops built from the @hartl-services/medusa-* plugins.",
   "type": "module",
   "sideEffects": false,
@@ -45,7 +45,7 @@
     }
   },
   "dependencies": {
-    "@hartl-services/medusa-contracts": "^1.1.0",
+    "@hartl-services/medusa-contracts": "^1.3.0",
     "server-only": "^0.0.1"
   },
   "peerDependencies": {