@hartl-services/medusa-storefront 0.1.0 → 0.3.0

package/dist/server/catalog.js

@@ -1,7 +1,14 @@
+import { cache } from "react";
+import { collectPartnerOnlyCategoryIds, isPartnerOnlyProduct, withoutPartnerOnlyCategories } from "../core/catalog/partner-only.js";
 import { CATEGORY_FIELDS, COLLECTION_FIELDS, PRODUCT_FIELDS } from "../core/fields.js";
 const catalogFetchLimit = 100;
-/** Medusa's half of a catalog: products priced for a country, categories and collections. */
-export function createCatalog(context, region) {
+/**
+ * Medusa's half of a catalog: products priced for a country, categories and
+ * collections. Partner-only products and categories (see
+ * `isPartnerOnlyProduct`) are left out unless `isActivePartner` says the
+ * visitor is an active partner; the backend refuses them at checkout anyway.
+ */
+export function createCatalog(context, region, isActivePartner = async () => false) {
     async function getPricingContext(countryCode) {
         const countryRegion = await region.getRegionForCountry(countryCode);
         if (!countryRegion) {
@@ -13,8 +20,31 @@ export function createCatalog(context, region) {
             region_id: countryRegion.id,
         };
     }
+    // Every top-level category with all descendants, once per request.
+    const loadCategoryTrees = cache(async () => {
+        const sdk = context.createMedusaClient();
+        const { product_categories: productCategories } = await sdk.store.category.list({
+            fields: "id,name,handle,description,metadata,rank,*category_children",
+            include_descendants_tree: true,
+            limit: catalogFetchLimit,
+            parent_category_id: "null",
+        });
+        return productCategories;
+    });
+    /**
+     * Leaves out partner-only products for everyone but an active partner. The
+     * partner check (a backend request) only runs when a partner-only product
+     * is among them, so a shop without any pays nothing for it; the category
+     * trees are only read when a product has categories.
+     */
+    async function visibleProducts(products) {
+        const hasCategories = products.some((product) => (product.categories?.length ?? 0) > 0);
+        const partnerOnlyCategoryIds = hasCategories ? collectPartnerOnlyCategoryIds(await loadCategoryTrees()) : new Set();
+        const visible = products.filter((product) => !isPartnerOnlyProduct(product, partnerOnlyCategoryIds));
+        return visible.length === products.length || !(await isActivePartner()) ? visible : products;
+    }
     return {
-        async listCommerceProducts({ categoryId, collectionId, countryCode, handles }) {
+        async listCommerceProducts({ categoryId, collectionId, countryCode, handles, q }) {
             const pricingContext = await getPricingContext(countryCode);
             if (!pricingContext) {
                 return null;
@@ -25,10 +55,11 @@ export function createCatalog(context, region) {
                 ...(categoryId ? { category_id: [categoryId] } : {}),
                 ...(collectionId ? { collection_id: [collectionId] } : {}),
                 ...(handles?.length ? { handle: handles } : {}),
+                ...(q?.trim() ? { q: q.trim() } : {}),
                 fields: PRODUCT_FIELDS,
                 limit: catalogFetchLimit,
             });
-            return products;
+            return await visibleProducts(products);
         },
         async commerceProductByHandle({ countryCode, handle }) {
             const pricingContext = await getPricingContext(countryCode);
@@ -42,7 +73,20 @@ export function createCatalog(context, region) {
                 handle,
                 limit: 1,
             });
-            return products[0] ?? null;
+            return (await visibleProducts(products))[0] ?? null;
+        },
+        /**
+         * The top-level categories with all descendants (e.g. "Anwendungsbereiche"
+         * and "Inhaltsstoffe" with their entries) - the filter trees of a product
+         * list; filter with `filterProductsByCategories` from /core. Partner-only
+         * categories only for an active partner.
+         */
+        async listCategoryTrees() {
+            const trees = await loadCategoryTrees();
+            if (collectPartnerOnlyCategoryIds(trees).size === 0) {
+                return trees;
+            }
+            return (await isActivePartner()) ? trees : withoutPartnerOnlyCategories(trees);
         },
         async categoryByPath(categoryPath) {
             const sdk = context.createMedusaClient();
@@ -51,7 +95,11 @@ export function createCatalog(context, region) {
                 handle: categoryPath.join("/"),
                 limit: 1,
             });
-            return productCategories[0] ?? null;
+            const category = productCategories[0] ?? null;
+            if (!category || !collectPartnerOnlyCategoryIds(await loadCategoryTrees()).has(category.id)) {
+                return category;
+            }
+            return (await isActivePartner()) ? category : null;
         },
         async collectionByHandle(handle) {
             const sdk = context.createMedusaClient();

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, 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";
@@ -31,6 +32,42 @@ export declare function createCustomer(context: ServerContext, runMedusaAction:
         state: "success";
         sessionToken: string;
     }>>;
+    /**
+     * Registration with name, phone and an optional address (the default
+     * address). The account counts as registered even if only the address
+     * fails (`addressSaved: false`, to add it in the account later) - a retry
+     * would otherwise end in "e-mail exists". While the e-mail is unconfirmed
+     * the address waits in the customer's metadata until the first login.
+     */
+    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<{
         state: "success";

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 } 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;
@@ -14,10 +17,29 @@ function cartCustomerHasAccount(cart) {
 function isVerificationRequired(result) {
     return typeof result === "object" && result !== null && Reflect.get(result, "verification_required") === true && typeof Reflect.get(result, "token") === "string";
 }
+/**
+ * Metadata key of the address a registration could not store yet: Medusa takes
+ * no address with the customer, and while the e-mail is unconfirmed there is
+ * 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);
@@ -71,12 +93,123 @@ export function createCustomer(context, runMedusaAction) {
             return undefined;
         }
     }
-    function completeCustomerSignIn(token, email) {
-        return completeCustomerSignInWith(token, email, {
+    /**
+     * 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 { addressId: null, saved: true };
+        }
+        try {
+            const sdk = createAuthenticatedMedusaClient(token);
+            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 { 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, 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) {
+                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) {
+            context.reportError(error, { area: "customer-auth", context: { step: "pending_registration_address" } });
+        }
+    }
+    async function completeCustomerSignIn(token, email) {
+        const result = await completeCustomerSignInWith(token, email, {
             createAuthenticatedClient: createAuthenticatedMedusaClient,
             storeToken: session.setMedusaAuthToken,
             transferCart: transferActiveCartToCustomer,
         });
+        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);
@@ -144,6 +277,43 @@ export function createCustomer(context, runMedusaAction) {
                 return { state: "success", sessionToken: token };
             }, { endSessionOnUnauthorized: false });
         },
+        /**
+         * Registration with name, phone and an optional address (the default
+         * address). The account counts as registered even if only the address
+         * fails (`addressSaved: false`, to add it in the account later) - a retry
+         * would otherwise end in "e-mail exists". While the e-mail is unconfirmed
+         * the address waits in the customer's metadata until the first login.
+         */
+        async registerCustomerWithProfile(data) {
+            const parsed = customerRegistrationProfileSchema.parse(data);
+            return runMedusaAction(async () => {
+                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 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;
+                }
+                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
         // sends at most one code per address and minute.
         async requestLoginCode(data) {

package/dist/server/index.d.ts

@@ -61,6 +61,27 @@ export declare function createStorefrontServer(config: StorefrontServerConfig):
             state: "success";
             sessionToken: string;
         }>>;
+        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<{
             state: "success";
@@ -100,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;
@@ -236,11 +259,12 @@ export declare function createStorefrontServer(config: StorefrontServerConfig):
         }): Promise<Response>;
     };
     catalog: {
-        listCommerceProducts({ categoryId, collectionId, countryCode, handles }: import("./catalog.js").CommerceProductListInput): Promise<import("@medusajs/types").StoreProduct[] | null>;
+        listCommerceProducts({ categoryId, collectionId, countryCode, handles, q }: import("./catalog.js").CommerceProductListInput): Promise<import("@medusajs/types").StoreProduct[] | null>;
         commerceProductByHandle({ countryCode, handle }: {
             countryCode: string;
             handle: string;
         }): Promise<import("@medusajs/types").StoreProduct | null>;
+        listCategoryTrees(): Promise<import("@medusajs/types").StoreProductCategory[]>;
         categoryByPath(categoryPath: string[]): Promise<import("@medusajs/types").StoreProductCategory | null>;
         collectionByHandle(handle: string): Promise<import("@medusajs/types").StoreCollection | null>;
     };

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.1.0",
+  "version": "0.3.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.2.0",
     "server-only": "^0.0.1"
   },
   "peerDependencies": {