@vendure-platform/create 0.1.0

package/dist/assets/storefront/src/lib/vendure/actions.ts

@@ -0,0 +1,96 @@
+import {client} from './api';
+import {GetActiveCustomerQuery, GetCompanyAccountQuery, GetMyCompaniesQuery, type CompanyUserCompany} from './queries';
+import {getActiveChannelCached} from './cached';
+import {cache} from "react";
+import {readFragment, ResultOf} from "@/graphql";
+import {
+    ActiveCustomerFragment,
+    CompanyBusinessUnitFragment,
+    CompanyFragment,
+    CompanyPermissionFragment,
+    CompanyRoleFragment,
+    CompanyUserFragment,
+} from "@/lib/vendure/fragments";
+
+type CompanyRoleData = Omit<ResultOf<typeof CompanyRoleFragment>, 'permissions'> & {
+    permissions: ResultOf<typeof CompanyPermissionFragment>[];
+};
+
+type CompanyUserData = Omit<ResultOf<typeof CompanyUserFragment>, 'companyRoles' | 'businessUnits'> & {
+    companyRoles: CompanyRoleData[];
+    businessUnits: ResultOf<typeof CompanyBusinessUnitFragment>[];
+};
+
+export interface CompanyAccount {
+    company: ResultOf<typeof CompanyFragment>;
+    companyUser: CompanyUserData;
+    activeBusinessUnit: ResultOf<typeof CompanyBusinessUnitFragment> | null;
+    permissions: string[];
+}
+
+export const getActiveCustomer = cache(async () => {
+    const [result, error] = await client.query(GetActiveCustomerQuery);
+    if (error) {
+        return null;
+    }
+    return readFragment(ActiveCustomerFragment, result.data.activeCustomer);
+})
+
+export const getCompanyAccount = cache(async (): Promise<CompanyAccount | null> => {
+    const [result, error] = await client.query(GetCompanyAccountQuery);
+    if (error) {
+        return null;
+    }
+    const account = result.data.companyAccount;
+    if (!account) return null;
+
+    const company = readFragment(CompanyFragment, account.company);
+    const rawUser = readFragment(CompanyUserFragment, account.companyUser);
+    const activeBusinessUnit = account.activeBusinessUnit
+        ? readFragment(CompanyBusinessUnitFragment, account.activeBusinessUnit)
+        : null;
+
+    const companyUser: CompanyUserData = {
+        ...rawUser,
+        companyRoles: rawUser.companyRoles.map(r => {
+            const role = readFragment(CompanyRoleFragment, r);
+            return {
+                ...role,
+                permissions: role.permissions.map(p => readFragment(CompanyPermissionFragment, p)),
+            };
+        }),
+        businessUnits: rawUser.businessUnits.map(bu => readFragment(CompanyBusinessUnitFragment, bu)),
+    };
+
+    return {
+        company,
+        companyUser,
+        activeBusinessUnit,
+        permissions: [...account.permissions],
+    };
+});
+
+export const getMyCompanies = cache(async (): Promise<CompanyUserCompany[]> => {
+    const [result, error] = await client.query(GetMyCompaniesQuery);
+    if (error) return [];
+    const customer = result.data.activeCustomer;
+    if (!customer) return [];
+    return customer.companyUsers
+        .filter(cu => cu.state === 'Active')
+        .map(cu => ({ id: cu.company.id, name: cu.company.name, state: cu.company.state }));
+});
+
+/**
+ * Returns true if the current user belongs to any company (active or pending).
+ * Uses getCompanyAccount (which requires Active company state) with a fallback
+ * to getMyCompanies (which includes pending companies via CompanyUser state).
+ */
+export const getHasCompany = cache(async (): Promise<boolean> => {
+    const [companyAccount, companies] = await Promise.all([
+        getCompanyAccount(),
+        getMyCompanies(),
+    ]);
+    return !!companyAccount || companies.length > 0;
+});
+
+export const getActiveChannel = getActiveChannelCached;

package/dist/assets/storefront/src/lib/vendure/api.ts

@@ -0,0 +1,164 @@
+import {createClient} from '@vendure-platform/storefront-client';
+import type {RequestMiddleware} from '@vendure-platform/storefront-client';
+
+const DRAFT_MODE_SECRET = process.env.DRAFT_MODE_SECRET;
+
+/**
+ * Middleware that appends ?draftMode=<secret> to the Vendure API URL
+ * when Next.js draft mode is enabled, so the content-versioning plugin
+ * returns unpublished draft content.
+ */
+const draftModeMiddleware: RequestMiddleware = async (req, next) => {
+    if (DRAFT_MODE_SECRET) {
+        try {
+            const {draftMode} = await import('next/headers');
+            const draft = await draftMode();
+            if (draft.isEnabled) {
+                const url = new URL(req.url);
+                url.searchParams.set('draftMode', DRAFT_MODE_SECRET);
+                req.url = url.toString();
+            }
+        } catch {
+            // draftMode() not available (e.g. during build or in 'use cache' blocks)
+        }
+    }
+    return next(req);
+};
+
+const VENDURE_API_URL = process.env.VENDURE_SHOP_API_URL || process.env.NEXT_PUBLIC_VENDURE_SHOP_API_URL;
+const VENDURE_CHANNEL_TOKEN = process.env.VENDURE_CHANNEL_TOKEN || process.env.NEXT_PUBLIC_VENDURE_CHANNEL_TOKEN;
+const VENDURE_AUTH_TOKEN_HEADER = process.env.VENDURE_AUTH_TOKEN_HEADER || 'vendure-auth-token';
+const VENDURE_CHANNEL_TOKEN_HEADER = process.env.VENDURE_CHANNEL_TOKEN_HEADER || 'vendure-token';
+
+if (!VENDURE_API_URL) {
+    throw new Error('VENDURE_SHOP_API_URL or NEXT_PUBLIC_VENDURE_SHOP_API_URL environment variable is not set');
+}
+
+// Dynamic imports to avoid Next.js static analysis marking this module as dynamic.
+// cookies() is only available in request context — providers gracefully return undefined otherwise.
+async function safeGetAuthToken(): Promise<string | undefined> {
+    try {
+        const {getAuthToken} = await import('@/lib/auth');
+        return await getAuthToken();
+    } catch { return undefined; }
+}
+
+async function safeGetCompanyId(): Promise<string | undefined> {
+    try {
+        const {getCompanyId} = await import('@/lib/company-context');
+        return await getCompanyId();
+    } catch { return undefined; }
+}
+
+async function safeGetBusinessUnitId(): Promise<string | undefined> {
+    try {
+        const {getBusinessUnitId} = await import('@/lib/company-context');
+        return await getBusinessUnitId();
+    } catch { return undefined; }
+}
+
+/**
+ * Provider for the `client`'s dynamic channel token (layer 3 in storefront-client precedence).
+ * Precedence: per-request option (layer 1) > client state (layer 2) > provider (layer 3) > config (layer 4).
+ * When this returns a token, it overrides `sharedConfig.channelToken` (the env var default at layer 4).
+ * When it returns undefined (build time, 'use cache' blocks), the env var default is used.
+ */
+async function safeGetChannelToken(): Promise<string | undefined> {
+    try {
+        const {getActiveChannelToken} = await import('@/lib/channel-server');
+        return await getActiveChannelToken();
+    } catch { return undefined; }
+}
+
+async function safeGetLanguageCode(): Promise<string | undefined> {
+    try {
+        const {getLocale} = await import('next-intl/server');
+        return await getLocale();
+    } catch { return undefined; }
+}
+
+const sharedConfig = {
+    apiUrl: VENDURE_API_URL,
+    channelToken: VENDURE_CHANNEL_TOKEN,
+    headerNames: {
+        authToken: VENDURE_AUTH_TOKEN_HEADER,
+        channelToken: VENDURE_CHANNEL_TOKEN_HEADER,
+    },
+} as const;
+
+/**
+ * Middleware that sets the currencyCode query parameter from the user's
+ * currency cookie, so Vendure returns prices in the selected currency.
+ */
+const currencyMiddleware: RequestMiddleware = async (req, next) => {
+    try {
+        const {getActiveCurrencyCode} = await import('@/lib/currency-server');
+        const currency = await getActiveCurrencyCode();
+        const url = new URL(req.url);
+        url.searchParams.set('currencyCode', currency);
+        req.url = url.toString();
+    } catch {
+        // cookies() not available (e.g. during build or in 'use cache' blocks)
+    }
+    return next(req);
+};
+
+const middleware = [draftModeMiddleware, currencyMiddleware];
+
+export const client = createClient({
+    ...sharedConfig,
+    middleware,
+    providers: {
+        authToken: safeGetAuthToken,
+        channelToken: safeGetChannelToken,
+        companyId: safeGetCompanyId,
+        businessUnitId: safeGetBusinessUnitId,
+        // languageCode is NOT included here because with cacheComponents: true,
+        // every server component is an implicit cache scope where getLocale()
+        // triggers headers() which is forbidden. Instead, languageCode is passed
+        // explicitly via VendureContext or query options.
+    },
+});
+
+/**
+ * Client without providers or middleware — for 'use cache' functions that fetch public data.
+ * Next.js 'use cache' forbids Dynamic APIs (cookies/headers), so this client must not
+ * access cookies, headers, or draftMode. Pass languageCode and currencyCode explicitly
+ * as query options from the calling function.
+ */
+export const publicClient = createClient({...sharedConfig});
+
+/**
+ * Pre-resolved context for use at cache boundaries where cookies() is not available.
+ */
+export interface VendureContext {
+    authToken?: string;
+    channelToken?: string;
+    companyId?: string;
+    businessUnitId?: string;
+    locale: string;
+    currencyCode?: string;
+}
+
+/**
+ * Resolves auth token and company context from cookies.
+ * Use this at cache boundaries ('use cache') where providers can't access cookies().
+ */
+export async function getVendureContext(): Promise<VendureContext> {
+    const {getAuthToken} = await import('@/lib/auth');
+    const authToken = await getAuthToken();
+    let companyId: string | undefined;
+    let businessUnitId: string | undefined;
+    try {
+        const {getCompanyId, getBusinessUnitId} = await import('@/lib/company-context');
+        companyId = await getCompanyId();
+        businessUnitId = await getBusinessUnitId();
+    } catch {}
+    const {getActiveChannelToken} = await import('@/lib/channel-server');
+    const channelToken = await getActiveChannelToken();
+    const {getRouteLocale} = await import('@/i18n/server');
+    const locale = await getRouteLocale();
+    const {getActiveCurrencyCode} = await import('@/lib/currency-server');
+    const currencyCode = await getActiveCurrencyCode();
+    return {authToken, channelToken, companyId, businessUnitId, locale, currencyCode};
+}

package/dist/assets/storefront/src/lib/vendure/approval-utils.ts

@@ -0,0 +1,21 @@
+import {client} from '@/lib/vendure/api';
+import type {VendureContext} from '@/lib/vendure/api';
+import {GetApprovalHistoryForEntityQuery} from '@/lib/vendure/queries';
+
+export async function getLatestApprovalForOrder(orderId: string, ctx?: VendureContext) {
+    const queryArgs = { entityType: 'Order', entityId: orderId } as const;
+    const [result] = ctx
+        ? await client.query(GetApprovalHistoryForEntityQuery, queryArgs, ctx)
+        : await client.query(GetApprovalHistoryForEntityQuery, queryArgs);
+    const history = [...(result?.data?.approvalHistoryForEntity ?? [])]
+        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const latestApproval = history[0] ?? null;
+    const changesRequested = latestApproval?.status === 'CHANGES_REQUESTED';
+    const changesComment = changesRequested
+        ? latestApproval.decisions
+            ?.filter((d: any) => d.decision === 'CHANGES_REQUESTED' && d.comment)
+            .map((d: any) => d.comment)
+            .at(-1) ?? null
+        : null;
+    return { latestApproval, changesRequested, changesComment };
+}

package/dist/assets/storefront/src/lib/vendure/cached.ts

@@ -0,0 +1,71 @@
+import {cacheLife, cacheTag} from 'next/cache';
+import {publicClient} from './api';
+import {GetActiveChannelQuery, GetAvailableCountriesQuery, GetTopCollectionsQuery} from './queries';
+
+/**
+ * Get the active channel with caching enabled.
+ * Channel configuration rarely changes, so we cache it for 1 hour.
+ * Not locale-dependent — channel config is the same for all locales.
+ *
+ * @param channelToken - When provided, queries this specific channel instead of the static default.
+ *   Used by multi-channel scenarios (e.g. b2b-wholesale) where the channel varies per-request.
+ *   The token is included in the cache key automatically (function argument in 'use cache').
+ */
+export async function getActiveChannelCached(channelToken?: string) {
+    'use cache';
+    cacheLife('hours');
+    if (channelToken) cacheTag(`channel-${channelToken}`);
+
+    const [result, error] = await publicClient.query(
+        GetActiveChannelQuery,
+        undefined,
+        channelToken ? {channelToken} : undefined,
+    );
+    if (error) {
+        // Vendure API unavailable during build
+        return { id: '', code: '', defaultLanguageCode: 'en' as const, availableLanguageCodes: [], defaultCurrencyCode: 'USD' as const, availableCurrencyCodes: [] };
+    }
+    return result.data.activeChannel;
+}
+
+/**
+ * Get available countries with caching enabled.
+ * Country names are locale-dependent (translated by Vendure).
+ * Countries may differ per channel (different shipping zones).
+ */
+export async function getAvailableCountriesCached(locale: string, channelToken?: string) {
+    'use cache';
+    cacheLife('max');
+    cacheTag(`countries-${locale}${channelToken ? `-${channelToken}` : ''}`);
+
+    const [result, error] = await publicClient.query(
+        GetAvailableCountriesQuery,
+        undefined,
+        {languageCode: locale, ...(channelToken ? {channelToken} : {})},
+    );
+    if (error) {
+        return [];
+    }
+    return result.data.availableCountries || [];
+}
+
+/**
+ * Get top-level collections with caching enabled.
+ * Collection names/descriptions are locale-dependent (translated by Vendure).
+ * Collections may differ per channel (e.g. DE excludes Trockenbau).
+ */
+export async function getTopCollections(locale: string, channelToken?: string) {
+    'use cache';
+    cacheLife('days');
+    cacheTag(`collections-${locale}${channelToken ? `-${channelToken}` : ''}`);
+
+    const [result, error] = await publicClient.query(
+        GetTopCollectionsQuery,
+        undefined,
+        {languageCode: locale, ...(channelToken ? {channelToken} : {})},
+    );
+    if (error) {
+        return [];
+    }
+    return result.data.collections.items;
+}

package/dist/assets/storefront/src/lib/vendure/fragments.ts

@@ -0,0 +1,213 @@
+import { graphql } from '@/graphql';
+
+export const ProductCardFragment = graphql(`
+    fragment ProductCard on SearchResult {
+        productId
+        productName
+        slug
+        sku
+        inStock
+        productAsset {
+            id
+            preview
+        }
+        price {
+            __typename
+            ... on PriceRange {
+                min
+                max
+            }
+            ... on SinglePrice {
+                value
+            }
+        }
+        priceWithTax {
+            __typename
+            ... on PriceRange {
+                min
+                max
+            }
+            ... on SinglePrice {
+                value
+            }
+        }
+        currencyCode
+        highlights {
+            field
+            matchedTokens
+        }
+    }
+`);
+
+export const ActiveCustomerFragment = graphql(`
+    fragment ActiveCustomer on Customer {
+        id
+        firstName
+        lastName
+        emailAddress
+    }
+`);
+
+export const ShoppingListFragment = graphql(`
+    fragment ShoppingListFields on ShoppingList {
+        id
+        createdAt
+        updatedAt
+        name
+        description
+        isDefault
+        isPublic
+        publicCode
+        customer {
+            id
+            firstName
+            lastName
+        }
+    }
+`);
+
+export const ShoppingListItemFragment = graphql(`
+    fragment ShoppingListItemFields on ShoppingListItem {
+        id
+        createdAt
+        updatedAt
+        productVariantId
+        purchased
+        lastPurchasedAt
+        note
+        quantity
+        sortOrder
+        productVariant {
+            id
+            name
+            sku
+            priceWithTax
+            stockLevel
+            product {
+                id
+                name
+                slug
+                featuredAsset {
+                    id
+                    preview
+                }
+            }
+        }
+    }
+`);
+export const CompanyPermissionFragment = graphql(`
+    fragment CompanyPermission on CompanyPermission {
+        id
+        name
+        description
+        isBuiltIn
+    }
+`);
+
+export const CompanyRoleFragment = graphql(
+    `
+        fragment CompanyRole on CompanyRole {
+            id
+            name
+            isDefault
+            permissions {
+                ...CompanyPermission
+            }
+        }
+    `,
+    [CompanyPermissionFragment],
+);
+
+export const CompanyBusinessUnitFragment = graphql(`
+    fragment CompanyBusinessUnit on CompanyBusinessUnit {
+        id
+        name
+        email
+        phone
+        parent {
+            id
+            name
+        }
+        children {
+            id
+            name
+        }
+    }
+`);
+
+export const CompanyAddressFragment = graphql(`
+    fragment CompanyAddress on CompanyAddress {
+        id
+        fullName
+        streetLine1
+        streetLine2
+        province
+        country {
+            id
+            code
+            name
+        }
+        city
+        postalCode
+        phoneNumber
+        defaultShippingAddress
+        defaultBillingAddress
+        businessUnit {
+            id
+            name
+        }
+    }
+`);
+
+export const CompanyPaymentMethodFragment = graphql(`
+    fragment CompanyPaymentMethod on CompanyPaymentMethod {
+        id
+        name
+        description
+        terms
+    }
+`);
+
+export const CompanyUserFragment = graphql(
+    `
+        fragment CompanyUser on CompanyUser {
+            id
+            state
+            customer {
+                id
+                firstName
+                lastName
+                emailAddress
+            }
+            companyRoles {
+                ...CompanyRole
+            }
+            businessUnits {
+                ...CompanyBusinessUnit
+            }
+        }
+    `,
+    [CompanyRoleFragment, CompanyBusinessUnitFragment],
+);
+
+export const CompanyFragment = graphql(`
+    fragment Company on Company {
+        id
+        name
+        state
+    }
+`);
+
+export const TaxIdFragment = graphql(`
+    fragment TaxIdFields on TaxId {
+        id
+        createdAt
+        updatedAt
+        number
+        type
+        countryCode
+        validationStatus
+        validatedAt
+        isDefault
+    }
+`);

package/dist/assets/storefront/src/lib/vendure/instant-search-action.ts

@@ -0,0 +1,104 @@
+'use server';
+
+import { client } from './api';
+import { CollectionSearchQuery, InstantSearchQuery } from './queries';
+
+export interface InstantSearchProduct {
+    productId: string;
+    productName: string;
+    slug: string;
+    sku: string;
+    inStock: boolean;
+    imageUrl?: string;
+    price: { type: 'single'; value: number } | { type: 'range'; min: number; max: number };
+    currencyCode: string;
+}
+
+export interface InstantSearchCollection {
+    id: string;
+    name: string;
+    slug: string;
+    score: number;
+}
+
+export interface InstantSearchResult {
+    products: InstantSearchProduct[];
+    collections: InstantSearchCollection[];
+    totalItems: number;
+}
+
+export async function instantSearch(term: string): Promise<InstantSearchResult> {
+    if (!term || term.trim().length < 2) {
+        return { products: [], collections: [], totalItems: 0 };
+    }
+
+    const trimmed = term.trim();
+
+    // Fire product search and collection search in parallel
+    const [productResult, collectionResult] = await Promise.all([
+        client.query(InstantSearchQuery, {
+            input: {
+                term: trimmed,
+                take: 6,
+                skip: 0,
+                groupByProduct: true,
+                prefixMode: true,
+            },
+        }),
+        client.query(CollectionSearchQuery, {
+            input: {
+                term: trimmed,
+                take: 3,
+                prefixMode: true,
+            },
+        }),
+    ]);
+
+    const [prodRes, prodError] = productResult;
+    if (prodError) throw prodError;
+
+    const data = prodRes.data.search;
+
+    // Deduplicate products by productId
+    const seenProductIds = new Set<string>();
+    const products: InstantSearchProduct[] = [];
+    for (const item of data.items) {
+        if (seenProductIds.has(item.productId)) continue;
+        seenProductIds.add(item.productId);
+
+        let price: InstantSearchProduct['price'];
+        if (item.price.__typename === 'PriceRange') {
+            price = { type: 'range', min: item.price.min, max: item.price.max };
+        } else {
+            price = { type: 'single', value: item.price.value };
+        }
+
+        products.push({
+            productId: item.productId,
+            productName: item.productName,
+            slug: item.slug,
+            sku: item.sku,
+            inStock: item.inStock,
+            imageUrl: item.productAsset?.preview,
+            price,
+            currencyCode: item.currencyCode,
+        });
+    }
+
+    const [collRes, collError] = collectionResult;
+    if (collError) {
+        console.error('[instantSearch] Collection search failed:', collError);
+    }
+    const collections: InstantSearchCollection[] = [];
+    if (!collError) {
+        for (const c of collRes.data.searchCollections?.items ?? []) {
+            collections.push({ id: c.id, name: c.name, slug: c.slug, score: c.score });
+        }
+    }
+
+    return {
+        products,
+        collections,
+        totalItems: data.totalItems,
+    };
+}