@vitrine-kit/vitrine 0.3.0 → 0.4.0

package/kit/templates/backend-payload/files/lib/adapter/db.ts

@@ -0,0 +1,27 @@
+// DB adapter selection for Payload (§18.1). The decision lives in the pure
+// decideDbAdapter; here we only wire up the real adapters and log the choice.
+import { postgresAdapter } from '@payloadcms/db-postgres';
+import { sqliteAdapter } from '@payloadcms/db-sqlite';
+import { decideDbAdapter } from './db-decision.js';
+import { canConnectPostgres } from './db-ping.js';
+
+export async function resolveDbAdapter() {
+  const url = process.env.DATABASE_URL ?? null;
+  const decision = decideDbAdapter({
+    url,
+    isProd: process.env.NODE_ENV === 'production',
+    strict: process.env.VITRINE_DB_STRICT === '1',
+    canConnect: url ? await canConnectPostgres(url) : false,
+  });
+
+  if (decision.kind === 'error') throw new Error(decision.message);
+  if (decision.warn) console.warn(decision.warn);
+
+  if (decision.kind === 'postgres') {
+    console.info('[vitrine] DB: Postgres');
+    return postgresAdapter({ pool: { connectionString: url as string } });
+  }
+
+  console.info('[vitrine] DB: SQLite (.vitrine/dev.sqlite)');
+  return sqliteAdapter({ client: { url: 'file:./.vitrine/dev.sqlite' } });
+}

package/kit/templates/backend-payload/files/lib/adapter/index.ts

@@ -0,0 +1,31 @@
+// Resolver for the storefront's active backend. The catalog is served via the
+// Payload local API; commerce (CommerceBackend) is enabled by the cart/checkout-stripe features.
+import { getPayload } from 'payload';
+import config from '@payload-config';
+import type { CatalogSource, CommerceBackend } from '@vitrine-kit/contracts';
+import { siteConfig } from '@/site.config';
+import { registerPayments } from '@/lib/payments';
+import { PayloadCatalogSource } from './payload-catalog.js';
+import { PayloadCommerceBackend } from './payload-commerce.js';
+
+// Register payment providers of installed features (lib/payments.ts is generated
+// by the CLI). Needed before startCheckout, which resolves the active provider from the registry.
+registerPayments();
+
+let catalog: CatalogSource | null = null;
+let commerce: CommerceBackend | null = null;
+
+export async function getCatalogSource(): Promise<CatalogSource> {
+  if (catalog) return catalog;
+  const payload = await getPayload({ config });
+  catalog = new PayloadCatalogSource(payload, siteConfig.i18n.currency);
+  return catalog;
+}
+
+export async function getCommerceBackend(): Promise<CommerceBackend> {
+  if (commerce) return commerce;
+  const payload = await getPayload({ config });
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL ?? 'http://localhost:3000';
+  commerce = new PayloadCommerceBackend(payload, siteConfig.i18n.currency, baseUrl, siteConfig);
+  return commerce;
+}

package/kit/templates/backend-payload/files/lib/adapter/map.ts

@@ -0,0 +1,112 @@
+// Pure mappers from Payload document → contract type. They depend only on
+// @vitrine-kit/contracts and local structural types — so they typecheck and are
+// covered by tests without Payload installed. This is the critical portability
+// seam (the same contract on Payload and Vendure).
+import type { Category, Money, Product, ProductImage, Variant } from '@vitrine-kit/contracts';
+import type { CategoryDoc, Id, MediaDoc, ProductDoc, VariantDoc } from './payload-types.js';
+
+const asId = (v: Id): string => String(v);
+
+const relId = (v: Id | { id: Id }): string => (typeof v === 'object' ? asId(v.id) : asId(v));
+
+/** Known base product fields — everything else goes into Product.extensions. */
+const BASE_PRODUCT_KEYS = new Set([
+  'id', 'slug', 'title', 'description', 'categories', 'images', 'seo',
+  'createdAt', 'updatedAt', '_status',
+]);
+
+export function mapCategory(doc: CategoryDoc): Category {
+  return {
+    id: asId(doc.id),
+    slug: doc.slug,
+    title: doc.title,
+    description: doc.description ?? undefined,
+    parentId: doc.parent == null ? null : relId(doc.parent),
+  };
+}
+
+export function mapVariant(doc: VariantDoc, currency: string): Variant {
+  return {
+    id: asId(doc.id),
+    sku: doc.sku,
+    price: doc.price as Money,
+    currency,
+    stock: doc.stock ?? null,
+    options: doc.options ?? undefined,
+  };
+}
+
+function mapImage(m: Id | MediaDoc): ProductImage | null {
+  // depth did not expand the relation (an id arrived) or there's no url — skip.
+  if (typeof m !== 'object' || !m.url) return null;
+  return {
+    url: m.url,
+    alt: m.alt ?? undefined,
+    width: m.width ?? undefined,
+    height: m.height ?? undefined,
+  };
+}
+
+/** Lexical richText (or string) → plain text. No HTML — for cards/SEO. */
+export function richTextToPlain(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  if (typeof value === 'string') return value || undefined;
+
+  const out: string[] = [];
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return;
+    const n = node as { text?: unknown; children?: unknown; root?: unknown };
+    if (typeof n.text === 'string') out.push(n.text);
+    if (n.root) walk(n.root);
+    if (Array.isArray(n.children)) for (const child of n.children) walk(child);
+  };
+  walk(value);
+  const text = out.join(' ').replace(/\s+/g, ' ').trim();
+  return text || undefined;
+}
+
+function collectExtensions(doc: ProductDoc): Record<string, unknown> | undefined {
+  const ext: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(doc)) {
+    if (!BASE_PRODUCT_KEYS.has(key) && val !== undefined) ext[key] = val;
+  }
+  return Object.keys(ext).length > 0 ? ext : undefined;
+}
+
+export function mapProduct(doc: ProductDoc, variants: VariantDoc[], currency: string): Product {
+  const mappedVariants = variants.map((v) => mapVariant(v, currency));
+  const images = (doc.images ?? [])
+    .map(mapImage)
+    .filter((x): x is ProductImage => x !== null);
+  const categoryIds = (doc.categories ?? []).map(relId);
+
+  const prices = mappedVariants.map((v) => v.price);
+  const priceRange =
+    prices.length > 0
+      ? { min: Math.min(...prices), max: Math.max(...prices), currency }
+      : undefined;
+
+  const seoImage =
+    doc.seo?.image && typeof doc.seo.image === 'object' ? doc.seo.image.url ?? undefined : undefined;
+  const seo =
+    doc.seo?.title || doc.seo?.description || seoImage
+      ? {
+          title: doc.seo?.title ?? undefined,
+          description: doc.seo?.description ?? undefined,
+          image: seoImage,
+        }
+      : undefined;
+
+  return {
+    id: asId(doc.id),
+    slug: doc.slug,
+    title: doc.title,
+    description: richTextToPlain(doc.description),
+    categoryIds,
+    images,
+    variants: mappedVariants,
+    priceRange,
+    seo,
+    extensions: collectExtensions(doc),
+  };
+}

package/kit/templates/backend-payload/files/lib/adapter/payload-catalog.ts

@@ -0,0 +1,79 @@
+// CatalogSource contract implementation on top of the Payload local API.
+// All domain normalization lives in the pure mappers (map.ts). Here — only queries.
+import type { Payload } from 'payload';
+import type {
+  CatalogSource,
+  Category,
+  Product,
+  ProductQuery,
+  ProductSort,
+} from '@vitrine-kit/contracts';
+import { mapCategory, mapProduct } from './map.js';
+import type { ProductDoc, VariantDoc } from './payload-types.js';
+
+function sortExpr(sort?: ProductSort): string {
+  switch (sort) {
+    case 'price-asc':
+      return 'createdAt'; // price lives in the variants collection — price sorting is provided by the filters feature
+    case 'price-desc':
+      return '-createdAt';
+    default: // newest and unspecified sort
+      return '-createdAt';
+  }
+}
+
+export class PayloadCatalogSource implements CatalogSource {
+  constructor(
+    private readonly payload: Payload,
+    private readonly currency: string,
+  ) {}
+
+  private async withVariants(doc: ProductDoc): Promise<Product> {
+    const variants = await this.payload.find({
+      collection: 'variants',
+      where: { product: { equals: doc.id } },
+      depth: 0,
+      limit: 200,
+    });
+    return mapProduct(doc, variants.docs as unknown as VariantDoc[], this.currency);
+  }
+
+  async listProducts(query: ProductQuery = {}): Promise<Product[]> {
+    const where = query.category ? { 'categories.slug': { equals: query.category } } : {};
+    const res = await this.payload.find({
+      collection: 'products',
+      where,
+      depth: 1,
+      limit: query.perPage ?? 24,
+      page: query.page ?? 1,
+      sort: sortExpr(query.sort),
+    });
+    return Promise.all(res.docs.map((d) => this.withVariants(d as unknown as ProductDoc)));
+  }
+
+  async getProduct(slug: string): Promise<Product | null> {
+    const res = await this.payload.find({
+      collection: 'products',
+      where: { slug: { equals: slug } },
+      depth: 1,
+      limit: 1,
+    });
+    const doc = res.docs[0];
+    return doc ? this.withVariants(doc as unknown as ProductDoc) : null;
+  }
+
+  async listCategories(): Promise<Category[]> {
+    const res = await this.payload.find({ collection: 'categories', depth: 0, limit: 200 });
+    return res.docs.map((d) => mapCategory(d as unknown as never));
+  }
+
+  async search(term: string): Promise<Product[]> {
+    const res = await this.payload.find({
+      collection: 'products',
+      where: { title: { like: term } },
+      depth: 1,
+      limit: 24,
+    });
+    return Promise.all(res.docs.map((d) => this.withVariants(d as unknown as ProductDoc)));
+  }
+}

package/kit/templates/backend-payload/files/lib/adapter/payload-commerce.ts

@@ -0,0 +1,154 @@
+// CommerceBackend contract implementation on top of Payload (carts/orders collections).
+// Money arithmetic and the order come from @vitrine-kit/core (critical logic); here — only
+// persistence. Creating the payment is delegated to the active payment provider
+// (payments.resolve by site.config), so this module pulls in no payment SDK
+// and loads at any layer (including catalog).
+import type { Payload } from 'payload';
+import type { Cart, CommerceBackend, Order, SiteConfig } from '@vitrine-kit/contracts';
+import {
+  addCartLine,
+  emptyCart,
+  payments,
+  recalcCart,
+  removeCartLine,
+  setCartLineQty,
+} from '@vitrine-kit/core';
+import type { ProductDoc, VariantDoc } from './payload-types.js';
+
+interface CartDoc {
+  id: string | number;
+  lines?: Cart['lines'];
+  currency?: string;
+  subtotal?: number;
+  discountTotal?: number;
+  total?: number;
+}
+
+export class PayloadCommerceBackend implements CommerceBackend {
+  constructor(
+    private readonly payload: Payload,
+    private readonly currency: string,
+    private readonly baseUrl: string,
+    private readonly siteConfig: SiteConfig,
+  ) {}
+
+  private toCart(doc: CartDoc): Cart {
+    return {
+      id: String(doc.id),
+      lines: doc.lines ?? [],
+      currency: doc.currency ?? this.currency,
+      subtotal: doc.subtotal ?? 0,
+      discountTotal: doc.discountTotal,
+      total: doc.total ?? 0,
+    };
+  }
+
+  private async persist(cart: Cart): Promise<Cart> {
+    await this.payload.update({
+      collection: 'carts',
+      id: cart.id,
+      data: { lines: cart.lines, subtotal: cart.subtotal, discountTotal: cart.discountTotal, total: cart.total },
+    });
+    return cart;
+  }
+
+  async createCart(): Promise<Cart> {
+    const doc = await this.payload.create({
+      collection: 'carts',
+      data: { lines: [], currency: this.currency, subtotal: 0, total: 0, status: 'active' },
+    });
+    return { ...emptyCart('', this.currency), id: String(doc.id) };
+  }
+
+  async getCart(cartId: string): Promise<Cart | null> {
+    const doc = await this.payload.findByID({ collection: 'carts', id: cartId }).catch(() => null);
+    return doc ? this.toCart(doc as unknown as CartDoc) : null;
+  }
+
+  async addItem(cartId: string, variantId: string, qty: number): Promise<Cart> {
+    const cart = (await this.getCart(cartId)) ?? emptyCart(cartId, this.currency);
+    const variant = (await this.payload.findByID({
+      collection: 'variants',
+      id: variantId,
+      depth: 1,
+    })) as unknown as VariantDoc;
+    const product = variant.product && typeof variant.product === 'object' ? (variant.product as ProductDoc) : null;
+    const firstImage =
+      product?.images && product.images.length > 0 && typeof product.images[0] === 'object'
+        ? ((product.images[0] as { url?: string }).url ?? undefined)
+        : undefined;
+
+    const next = addCartLine(cart, {
+      id: `${variantId}-${Date.now()}`,
+      variantId: String(variant.id),
+      productId: product ? String(product.id) : '',
+      title: product?.title ?? variant.sku,
+      unitPrice: variant.price,
+      quantity: qty,
+      image: firstImage,
+    });
+    return this.persist(next);
+  }
+
+  async updateItem(cartId: string, lineId: string, qty: number): Promise<Cart> {
+    const cart = await this.getCart(cartId);
+    if (!cart) throw new Error('[vitrine] cart not found');
+    return this.persist(setCartLineQty(cart, lineId, qty));
+  }
+
+  async removeItem(cartId: string, lineId: string): Promise<Cart> {
+    const cart = await this.getCart(cartId);
+    if (!cart) throw new Error('[vitrine] cart not found');
+    return this.persist(removeCartLine(cart, lineId));
+  }
+
+  /** Re-checks line prices against current variants (anti-stale). The price source
+   *  is the DB, not the value saved in the cart at add time. */
+  private async reprice(cart: Cart): Promise<Cart> {
+    const lines = await Promise.all(
+      cart.lines.map(async (l) => {
+        const variant = (await this.payload
+          .findByID({ collection: 'variants', id: l.variantId })
+          .catch(() => null)) as unknown as VariantDoc | null;
+        return variant && typeof variant.price === 'number' ? { ...l, unitPrice: variant.price } : l;
+      }),
+    );
+    return this.persist(recalcCart({ ...cart, lines })); // recalc recomputes lineTotal/totals
+  }
+
+  async startCheckout(cartId: string): Promise<{ redirectUrl: string }> {
+    const current = await this.getCart(cartId);
+    if (!current || current.lines.length === 0) throw new Error('[vitrine] cart is empty');
+    const cart = await this.reprice(current);
+    // The active provider (Stripe/Paddle/YooKassa) is resolved by integrations.payments;
+    // its checkout-<provider> feature registered it in the registry via lib/payments.ts.
+    return payments.resolve(this.siteConfig).createCheckout({ cart, baseUrl: this.baseUrl });
+  }
+
+  async getOrder(id: string): Promise<Order | null> {
+    const doc = await this.payload.findByID({ collection: 'orders', id }).catch(() => null);
+    if (!doc) return null;
+    const o = doc as unknown as {
+      id: string | number;
+      status: Order['status'];
+      lines?: Order['lines'];
+      currency?: string;
+      subtotal?: number;
+      discountTotal?: number;
+      total?: number;
+      email?: string;
+      createdAt?: string;
+    };
+    return {
+      id: String(o.id),
+      status: o.status,
+      lines: o.lines ?? [],
+      currency: o.currency ?? this.currency,
+      subtotal: o.subtotal ?? 0,
+      discountTotal: o.discountTotal,
+      total: o.total ?? 0,
+      email: o.email,
+      createdAt: o.createdAt ?? new Date().toISOString(),
+    };
+  }
+}

package/kit/templates/backend-payload/files/lib/adapter/payload-types.ts

@@ -0,0 +1,50 @@
+// Structural shapes of Payload documents as the local API returns them (with
+// depth ≥ 1 relations expand into objects). Intentionally loose and do NOT import
+// the generated payload-types — so that map.ts stays pure (contracts only)
+// and testable without Payload.
+
+export type Id = string | number;
+
+export interface MediaDoc {
+  id: Id;
+  url?: string | null;
+  alt?: string | null;
+  width?: number | null;
+  height?: number | null;
+}
+
+export interface CategoryDoc {
+  id: Id;
+  slug: string;
+  title: string;
+  description?: string | null;
+  parent?: Id | CategoryDoc | null;
+}
+
+export interface VariantDoc {
+  id: Id;
+  sku: string;
+  price: number;
+  stock?: number | null;
+  options?: Record<string, string> | null;
+  product?: Id | ProductDoc | null;
+}
+
+export interface ProductSeoGroup {
+  title?: string | null;
+  description?: string | null;
+  image?: Id | MediaDoc | null;
+}
+
+export interface ProductDoc {
+  id: Id;
+  slug: string;
+  title: string;
+  /** Lexical richText (or string). Mapped to plain text. */
+  description?: unknown;
+  categories?: Array<Id | CategoryDoc> | null;
+  images?: Array<Id | MediaDoc> | null;
+  seo?: ProductSeoGroup | null;
+  /** Fields added by features via blueprint extend() → Product.extensions. */
+  [key: string]: unknown;
+}

package/kit/templates/backend-payload/files/lib/seed/admin.ts

@@ -0,0 +1,23 @@
+// Dev admin (§18.3): dev only + empty users collection. Password from
+// DEV_ADMIN_PASSWORD, otherwise random (no well-known default), printed
+// to the console once.
+import { randomBytes } from 'node:crypto';
+import type { Payload } from 'payload';
+import { shouldRunDevTask } from './guards.js';
+
+function randomPassword(length = 16): string {
+  return randomBytes(length).toString('base64url').slice(0, length);
+}
+
+export async function ensureDevAdmin(payload: Payload): Promise<void> {
+  const isProd = process.env.NODE_ENV === 'production';
+  const { totalDocs } = await payload.count({ collection: 'users' });
+  if (!shouldRunDevTask({ isProd, existingCount: totalDocs })) return;
+
+  const email = process.env.DEV_ADMIN_EMAIL ?? 'admin@dev.local';
+  const password = process.env.DEV_ADMIN_PASSWORD ?? randomPassword();
+  await payload.create({ collection: 'users', data: { email, password } });
+  payload.logger.warn(
+    `[vitrine] DEV ADMIN ${email} / ${password} — development only, change before deploying`,
+  );
+}

package/kit/templates/backend-payload/files/lib/seed/demo.ts

@@ -0,0 +1,79 @@
+// Demo data for zero-config dev (§18.2): 5 products + 2 categories + local
+// placeholder images (seed-assets/). Prices are in minor units (e.g. cents):
+// 199000 = 1990.00. Pure data — covered by an invariants test.
+
+export interface DemoCategory {
+  slug: string;
+  title: string;
+}
+
+export interface DemoVariant {
+  sku: string;
+  /** Minor units (e.g. cents). */
+  price: number;
+  stock: number;
+}
+
+export interface DemoProduct {
+  slug: string;
+  title: string;
+  category: string;
+  description: string;
+  /** File name in seed-assets/. */
+  image: string;
+  seo: { title: string; description: string };
+  variants: DemoVariant[];
+}
+
+export const demoCategories: DemoCategory[] = [
+  { slug: 'apparel', title: 'Apparel' },
+  { slug: 'accessories', title: 'Accessories' },
+];
+
+export const demoProducts: DemoProduct[] = [
+  {
+    slug: 'classic-tee',
+    title: 'Classic T-Shirt',
+    category: 'apparel',
+    description: 'A straight-cut cotton T-shirt.',
+    image: 'placeholder-1.svg',
+    seo: { title: 'Classic T-Shirt', description: 'A basic cotton T-shirt.' },
+    variants: [{ sku: 'TEE-001', price: 199000, stock: 25 }],
+  },
+  {
+    slug: 'zip-hoodie',
+    title: 'Zip Hoodie',
+    category: 'apparel',
+    description: 'A warm hooded sweatshirt.',
+    image: 'placeholder-2.svg',
+    seo: { title: 'Zip Hoodie', description: 'An insulated hoodie.' },
+    variants: [{ sku: 'HOD-001', price: 459000, stock: 12 }],
+  },
+  {
+    slug: 'logo-cap',
+    title: 'Logo Cap',
+    category: 'accessories',
+    description: 'An adjustable cap.',
+    image: 'placeholder-3.svg',
+    seo: { title: 'Cap', description: 'A cap with a logo.' },
+    variants: [{ sku: 'CAP-001', price: 129000, stock: 40 }],
+  },
+  {
+    slug: 'tote-bag',
+    title: 'Tote Bag',
+    category: 'accessories',
+    description: 'A sturdy cotton tote.',
+    image: 'placeholder-4.svg',
+    seo: { title: 'Tote', description: 'A cotton tote bag.' },
+    variants: [{ sku: 'TOT-001', price: 99000, stock: 60 }],
+  },
+  {
+    slug: 'crew-socks',
+    title: 'Socks, 3 Pairs',
+    category: 'apparel',
+    description: 'A set of three pairs.',
+    image: 'placeholder-5.svg',
+    seo: { title: 'Socks', description: 'A pack of socks, 3 pairs.' },
+    variants: [{ sku: 'SOC-001', price: 79000, stock: 100 }],
+  },
+];

package/kit/templates/backend-payload/files/lib/seed/guards.ts

@@ -0,0 +1,5 @@
+// Pure guards for zero-config dev procedures (§18). The seed and dev admin run
+// ONLY in dev AND when the collection is empty — idempotent and never in prod.
+export function shouldRunDevTask(opts: { isProd: boolean; existingCount: number }): boolean {
+  return !opts.isProd && opts.existingCount === 0;
+}

package/kit/templates/backend-payload/files/lib/seed/richtext.ts

@@ -0,0 +1,26 @@
+// Minimal Lexical richText value from plain text — for the description of
+// demo products during seeding.
+export function plainToRichText(text: string): unknown {
+  return {
+    root: {
+      type: 'root',
+      format: '',
+      indent: 0,
+      version: 1,
+      direction: 'ltr',
+      children: [
+        {
+          type: 'paragraph',
+          format: '',
+          indent: 0,
+          version: 1,
+          direction: 'ltr',
+          textFormat: 0,
+          children: [
+            { type: 'text', text, format: 0, style: '', mode: 'normal', detail: 0, version: 1 },
+          ],
+        },
+      ],
+    },
+  };
+}

package/kit/templates/backend-payload/files/lib/seed/run.ts

@@ -0,0 +1,51 @@
+// Demo seed (§18.2): runs from Payload's onInit. Idempotent (guarded by
+// shouldRunDevTask: dev only + empty collection). Images are local
+// placeholders from seed-assets/ (no network).
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Payload } from 'payload';
+import { demoCategories, demoProducts } from './demo.js';
+import { shouldRunDevTask } from './guards.js';
+import { plainToRichText } from './richtext.js';
+
+const seedAssets = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../seed-assets');
+
+export async function seedDemo(payload: Payload): Promise<void> {
+  const isProd = process.env.NODE_ENV === 'production';
+  const { totalDocs } = await payload.count({ collection: 'products' });
+  if (!shouldRunDevTask({ isProd, existingCount: totalDocs })) return;
+
+  const categoryId = new Map<string, string | number>();
+  for (const c of demoCategories) {
+    const doc = await payload.create({ collection: 'categories', data: { slug: c.slug, title: c.title } });
+    categoryId.set(c.slug, doc.id);
+  }
+
+  for (const p of demoProducts) {
+    const media = await payload.create({
+      collection: 'media',
+      data: { alt: p.title },
+      filePath: path.join(seedAssets, p.image),
+    });
+    const catId = categoryId.get(p.category);
+    const product = await payload.create({
+      collection: 'products',
+      data: {
+        slug: p.slug,
+        title: p.title,
+        description: plainToRichText(p.description),
+        categories: catId ? [catId] : [],
+        images: [media.id],
+        seo: { title: p.seo.title, description: p.seo.description, image: media.id },
+      },
+    });
+    for (const v of p.variants) {
+      await payload.create({
+        collection: 'variants',
+        data: { sku: v.sku, price: v.price, stock: v.stock, product: product.id },
+      });
+    }
+  }
+
+  payload.logger.info('[vitrine] demo seed: created 5 products');
+}

package/kit/templates/backend-payload/files/next.config.mjs

@@ -0,0 +1,10 @@
+// backend-payload: wrap the Next config in withPayload (mounts the Payload admin and
+// API into Next). output: 'standalone' — for the Docker image (VPS).
+import { withPayload } from '@payloadcms/next/withPayload';
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+};
+
+export default withPayload(nextConfig);