@vendure-platform/create 0.4.0 → 0.5.1

package/dist/assets/storefront/src/app/[locale]/account/shared-carts/actions.ts

@@ -0,0 +1,305 @@
+'use server';
+
+import { roleAtLeast } from '@/components/commerce/shared-cart-role';
+import { readFragment, type ResultOf } from '@/graphql';
+import { getActiveCustomer } from '@/lib/vendure/actions';
+import { client } from '@/lib/vendure/api';
+import { CompanyUserFragment } from '@/lib/vendure/fragments';
+import {
+    AddItemToSharedCartMutation,
+    AddSharedCartMemberMutation,
+    AdjustSharedCartLineMutation,
+    CreateSharedCartMutation,
+    DeleteSharedCartMutation,
+    InitiateSharedCartCheckoutMutation,
+    RemoveSharedCartLineMutation,
+    RemoveSharedCartMemberMutation,
+    SetSharedCartMemberRoleMutation,
+    TransferSharedCartOwnershipMutation,
+    UpdateSharedCartMutation,
+} from '@/lib/vendure/mutations';
+import {
+    GetMySharedCartsQuery,
+    GetSharedCartQuery,
+    GetShopCompanyUsersQuery,
+    SearchVariantsQuery,
+} from '@/lib/vendure/queries';
+import { revalidatePath, updateTag } from 'next/cache';
+
+export type SharedCartRole = 'view' | 'edit' | 'checkout';
+type ActionResult = { success: boolean; message?: string; id?: string };
+
+function invalidateCart() {
+    updateTag('cart');
+    updateTag('active-order');
+}
+
+function revalidateCart(id: string) {
+    revalidatePath(`/account/shared-carts/${id}`);
+    revalidatePath('/account/shared-carts');
+}
+
+// --- Read (server-action wrapper for the client poll) ----------------------
+
+export type SharedCartData = NonNullable<ResultOf<typeof GetSharedCartQuery>['sharedCart']>;
+
+export async function fetchSharedCart(id: string): Promise<SharedCartData | null> {
+    const [result, error] = await client.query(GetSharedCartQuery, { id });
+    if (error) return null;
+    return result.data.sharedCart ?? null;
+}
+
+// --- Lifecycle -------------------------------------------------------------
+
+export async function createSharedCart(name: string, description?: string): Promise<ActionResult> {
+    const [result, error] = await client.mutate(CreateSharedCartMutation, {
+        input: { name, description: description || undefined },
+    });
+    if (error) return { success: false, message: error.message };
+    revalidatePath('/account/shared-carts');
+    return { success: true, id: result.data.createSharedCart.id };
+}
+
+/**
+ * "Share my cart": create a blank shared cart, then copy the active order's
+ * lines into it. Non-atomic by design for v1 — if a line fails to copy we keep
+ * the cart and surface which step failed, so the user lands on a usable cart
+ * rather than losing the whole action.
+ */
+export async function shareMyCart(
+    name: string,
+    description: string | undefined,
+    lines: Array<{ productVariantId: string; quantity: number }>,
+): Promise<ActionResult> {
+    const created = await createSharedCart(name, description);
+    if (!created.success || !created.id) return created;
+    for (const line of lines) {
+        const [, err] = await client.mutate(AddItemToSharedCartMutation, {
+            sharedCartId: created.id,
+            productVariantId: line.productVariantId,
+            quantity: line.quantity,
+        });
+        if (err) {
+            return {
+                success: false,
+                message: `Cart created, but an item couldn't be copied: ${err.message}`,
+                id: created.id,
+            };
+        }
+    }
+    revalidatePath('/account/shared-carts');
+    return { success: true, id: created.id };
+}
+
+export async function renameSharedCart(
+    id: string,
+    name: string,
+    description?: string,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(UpdateSharedCartMutation, {
+        input: { id, name, description: description || undefined },
+    });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(id);
+    return { success: true };
+}
+
+export async function deleteSharedCart(id: string): Promise<ActionResult> {
+    const [, error] = await client.mutate(DeleteSharedCartMutation, { id });
+    if (error) return { success: false, message: error.message };
+    revalidatePath('/account/shared-carts');
+    return { success: true };
+}
+
+// --- Lines (role >= edit; server enforces) ---------------------------------
+
+export async function addItemToSharedCart(
+    sharedCartId: string,
+    productVariantId: string,
+    quantity: number,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(AddItemToSharedCartMutation, {
+        sharedCartId,
+        productVariantId,
+        quantity,
+    });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+/**
+ * Add several lines at once — powers the "Add to shared cart" picker when it
+ * carries a whole cart (the /cart page) rather than a single product. Non-atomic
+ * like {@link shareMyCart}: if a line fails we stop and report which step broke,
+ * leaving the earlier lines in place rather than rolling the cart back.
+ */
+export async function addItemsToSharedCart(
+    sharedCartId: string,
+    lines: Array<{ productVariantId: string; quantity: number }>,
+): Promise<ActionResult> {
+    for (const line of lines) {
+        const [, error] = await client.mutate(AddItemToSharedCartMutation, {
+            sharedCartId,
+            productVariantId: line.productVariantId,
+            quantity: line.quantity,
+        });
+        if (error) return { success: false, message: error.message };
+    }
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export async function adjustSharedCartLine(
+    sharedCartId: string,
+    lineId: string,
+    quantity: number,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(AdjustSharedCartLineMutation, { sharedCartId, lineId, quantity });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export async function removeSharedCartLine(sharedCartId: string, lineId: string): Promise<ActionResult> {
+    const [, error] = await client.mutate(RemoveSharedCartLineMutation, { sharedCartId, lineId });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export type EditableSharedCart = { id: string; name: string };
+
+/**
+ * Open carts the viewer can add items to (owner, or member with role >= edit).
+ * Powers the product-page "Add to shared cart" picker.
+ */
+export async function fetchEditableOpenSharedCarts(): Promise<EditableSharedCart[]> {
+    const [customer, [result, error]] = await Promise.all([
+        getActiveCustomer(),
+        client.query(GetMySharedCartsQuery, { options: { take: 100, filter: { status: { eq: 'Open' } } } }),
+    ]);
+    if (!customer || error) return [];
+    return result.data.mySharedCarts.items
+        .filter((cart) => {
+            if (cart.owner.id === customer.id) return true;
+            return roleAtLeast(cart.members.find((m) => m.customer.id === customer.id)?.role, 'edit');
+        })
+        .map((cart) => ({ id: cart.id, name: cart.name }));
+}
+
+export type VariantSearchResult = {
+    productVariantId: string;
+    productName: string;
+    variantName: string;
+    sku: string;
+    imageUrl?: string;
+    price: number;
+    currencyCode: string;
+    inStock: boolean;
+};
+
+export async function searchVariantsForSharedCart(term: string): Promise<VariantSearchResult[]> {
+    const [result, error] = await client.query(SearchVariantsQuery, {
+        input: { term: term.trim(), take: 10, groupByProduct: false },
+    });
+    if (error) return [];
+    return result.data.search.items
+        .filter((item) => item.price.__typename === 'SinglePrice')
+        .map((item) => ({
+            productVariantId: item.productVariantId,
+            productName: item.productName,
+            variantName: item.productVariantName,
+            sku: item.sku,
+            imageUrl: item.productAsset?.preview ?? undefined,
+            price: (item.price as { __typename: 'SinglePrice'; value: number }).value,
+            currencyCode: item.currencyCode,
+            inStock: item.inStock,
+        }));
+}
+
+// --- Members & governance (owner OR company-admin; server enforces) --------
+
+export type CompanyMemberOption = {
+    customerId: string;
+    firstName: string;
+    lastName: string;
+    emailAddress: string;
+};
+
+export async function fetchCompanyMembers(): Promise<CompanyMemberOption[]> {
+    const [result, error] = await client.query(GetShopCompanyUsersQuery, {});
+    if (error) return [];
+    return result.data.shopCompanyUsers
+        .map((user) => readFragment(CompanyUserFragment, user))
+        .map((user) => ({
+            customerId: user.customer.id,
+            firstName: user.customer.firstName,
+            lastName: user.customer.lastName,
+            emailAddress: user.customer.emailAddress,
+        }));
+}
+
+export async function addSharedCartMember(
+    sharedCartId: string,
+    customerId: string,
+    role: SharedCartRole,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(AddSharedCartMemberMutation, {
+        input: { sharedCartId, customerId, role },
+    });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export async function removeSharedCartMember(
+    sharedCartId: string,
+    customerId: string,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(RemoveSharedCartMemberMutation, { sharedCartId, customerId });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export async function setSharedCartMemberRole(
+    sharedCartId: string,
+    customerId: string,
+    role: SharedCartRole,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(SetSharedCartMemberRoleMutation, {
+        input: { sharedCartId, customerId, role },
+    });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+export async function transferSharedCartOwnership(
+    sharedCartId: string,
+    newOwnerCustomerId: string,
+): Promise<ActionResult> {
+    const [, error] = await client.mutate(TransferSharedCartOwnershipMutation, {
+        sharedCartId,
+        newOwnerCustomerId,
+    });
+    if (error) return { success: false, message: error.message };
+    revalidateCart(sharedCartId);
+    return { success: true };
+}
+
+// --- Checkout hand-off (role >= checkout; server enforces) -----------------
+
+/**
+ * Lock the shared cart and adopt its order as the viewer's active order. The
+ * caller then sends the buyer to the normal /checkout flow; approval, if the
+ * company requires it, runs through the existing approval UI.
+ */
+export async function initiateSharedCartCheckout(sharedCartId: string): Promise<ActionResult> {
+    const [, error] = await client.mutate(InitiateSharedCartCheckoutMutation, { sharedCartId });
+    if (error) return { success: false, message: error.message };
+    invalidateCart();
+    revalidateCart(sharedCartId);
+    return { success: true };
+}

package/dist/assets/storefront/src/app/[locale]/account/shared-carts/new/new-shared-cart-form.tsx

@@ -0,0 +1,84 @@
+'use client';
+
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { useRouter } from '@/i18n/navigation';
+import { Loader2 } from 'lucide-react';
+import { useState, useTransition } from 'react';
+import { toast } from 'sonner';
+import { createSharedCart } from '../actions';
+
+interface NewSharedCartFormProps {
+    defaultName: string;
+}
+
+export function NewSharedCartForm({ defaultName }: NewSharedCartFormProps) {
+    const router = useRouter();
+    const [name, setName] = useState(defaultName);
+    const [description, setDescription] = useState('');
+    const [isPending, startTransition] = useTransition();
+
+    const trimmed = name.trim();
+
+    function handleSubmit(e: React.FormEvent) {
+        e.preventDefault();
+        if (!trimmed) return;
+        startTransition(async () => {
+            const result = await createSharedCart(trimmed, description.trim() || undefined);
+            if (!result.success || !result.id) {
+                toast.error(result.message ?? 'Could not create the shared cart.');
+                return;
+            }
+            router.push(`/account/shared-carts/${result.id}`);
+        });
+    }
+
+    return (
+        <form onSubmit={handleSubmit} className="max-w-xl space-y-6">
+            <div className="space-y-2">
+                <Label htmlFor="shared-cart-name">Name</Label>
+                <Input
+                    id="shared-cart-name"
+                    value={name}
+                    onChange={(e) => setName(e.target.value)}
+                    placeholder="e.g. Q3 office supplies"
+                    autoFocus
+                    maxLength={255}
+                    required
+                />
+                <p className="text-xs text-muted-foreground">
+                    Give the cart a name your colleagues will recognise.
+                </p>
+            </div>
+
+            <div className="space-y-2">
+                <Label htmlFor="shared-cart-description">Description (optional)</Label>
+                <Textarea
+                    id="shared-cart-description"
+                    value={description}
+                    onChange={(e) => setDescription(e.target.value)}
+                    placeholder="What is this cart for?"
+                    rows={3}
+                    maxLength={1000}
+                />
+            </div>
+
+            <div className="flex items-center gap-3">
+                <Button type="submit" disabled={!trimmed || isPending}>
+                    {isPending && <Loader2 className="h-4 w-4 mr-2 animate-spin" />}
+                    Create shared cart
+                </Button>
+                <Button
+                    type="button"
+                    variant="ghost"
+                    onClick={() => router.push('/account/shared-carts')}
+                    disabled={isPending}
+                >
+                    Cancel
+                </Button>
+            </div>
+        </form>
+    );
+}

package/dist/assets/storefront/src/app/[locale]/account/shared-carts/new/page.tsx

@@ -0,0 +1,47 @@
+import { canCreateSharedCarts } from '@/components/commerce/shared-cart-role';
+import { readFragment } from '@/graphql';
+import { Link, redirect } from '@/i18n/navigation';
+import { getCompanyAccount } from '@/lib/vendure/actions';
+import { client } from '@/lib/vendure/api';
+import { ActiveCustomerFragment } from '@/lib/vendure/fragments';
+import { GetActiveCustomerQuery } from '@/lib/vendure/queries';
+import { ArrowLeft } from 'lucide-react';
+import type { Metadata } from 'next';
+import { NewSharedCartForm } from './new-shared-cart-form';
+
+export const metadata: Metadata = {
+    title: 'New Shared Cart',
+};
+
+export default async function NewSharedCartPage() {
+    const [[customerResult, customerError], companyAccount] = await Promise.all([
+        client.query(GetActiveCustomerQuery, {}),
+        getCompanyAccount(),
+    ]);
+    if (customerError || !customerResult.data.activeCustomer) {
+        return await redirect('/sign-in');
+    }
+
+    if (!canCreateSharedCarts(companyAccount?.permissions)) {
+        return await redirect('/account/shared-carts');
+    }
+    const customer = readFragment(ActiveCustomerFragment, customerResult.data.activeCustomer);
+    const defaultName = `${customer.firstName}'s shared cart`;
+
+    return (
+        <div>
+            <Link
+                href="/account/shared-carts"
+                className="inline-flex items-center gap-1 text-sm text-muted-foreground hover:text-foreground mb-4"
+            >
+                <ArrowLeft className="h-4 w-4" />
+                Shared carts
+            </Link>
+            <h1 className="text-3xl font-bold mb-1">New shared cart</h1>
+            <p className="text-sm text-muted-foreground mb-6">
+                Create an empty cart, then invite colleagues and add items.
+            </p>
+            <NewSharedCartForm defaultName={defaultName} />
+        </div>
+    );
+}