@jarwizz/create-jarshop 0.1.1 → 0.1.3

package/dist/template/storefront/lib/checkout.ts

@@ -0,0 +1,149 @@
+"use server";
+
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+
+import type { CommerceLocale } from "./commerce";
+import {
+  commerceSessionAuthorization,
+  persistCommerceSession,
+} from "./commerce-session";
+import { PLACE_JARSHOP_ORDER_MUTATION } from "./checkout-contract";
+import { exchangeOrderConfirmation } from "./confirmation";
+
+export interface CheckoutCartSnapshot {
+  currencyCode: string;
+  subtotalWithTax: number;
+  lines: Array<{
+    lineId: string;
+    quantity: number;
+    linePriceWithTax: number;
+  }>;
+}
+
+export type CheckoutShippingMethod = "pickup" | "courier";
+
+type CheckoutResponse = {
+  data?: {
+    placeJarShopOrder: {
+      success: boolean;
+      orderCode: string | null;
+      errorCode: string | null;
+      message: string | null;
+      affectedLineIds: string[];
+      confirmationToken: string | null;
+    };
+  };
+  errors?: Array<{ message: string }>;
+};
+
+export type CheckoutActionState =
+  | { ok: true }
+  | {
+      ok: false;
+      errorCode: string;
+      message: string;
+      affectedLineIds: string[];
+    };
+
+export async function placeOrder(
+  locale: CommerceLocale,
+  attemptId: string,
+  cartSnapshot: CheckoutCartSnapshot | null,
+  _previousState: CheckoutActionState,
+  formData: FormData,
+): Promise<CheckoutActionState> {
+  const store = await cookies();
+  const authorization = commerceSessionAuthorization(store);
+  const endpoint = new URL(
+    process.env.JARSHOP_COMMERCE_ENDPOINT ?? "http://localhost:3000/shop-api",
+  );
+  endpoint.searchParams.set("languageCode", locale);
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(process.env.JARSHOP_CHANNEL_TOKEN
+        ? { "vendure-token": process.env.JARSHOP_CHANNEL_TOKEN }
+        : {}),
+      ...(authorization ? { authorization } : {}),
+    },
+    body: JSON.stringify({
+      query: PLACE_JARSHOP_ORDER_MUTATION,
+      variables: {
+        input: {
+          attemptId,
+          marketCode: "sk",
+          languageCode: locale,
+          currencyCode: "EUR",
+          customer: {
+            emailAddress: String(formData.get("emailAddress") ?? ""),
+            firstName: String(formData.get("firstName") ?? ""),
+            lastName: String(formData.get("lastName") ?? ""),
+            phoneNumber: String(formData.get("phoneNumber") ?? ""),
+          },
+          shippingMethodCode: String(
+            formData.get("shippingMethodCode") ?? "pickup",
+          ),
+          paymentMethodCode: "cod",
+          termsAccepted: formData.get("termsAccepted") === "on",
+          ...(cartSnapshot ? { cartSnapshot } : {}),
+          ...(formData.get("shippingMethodCode") === "courier"
+            ? {
+                shippingAddress: {
+                  streetLine1: String(formData.get("streetLine1") ?? ""),
+                  city: String(formData.get("city") ?? ""),
+                  postalCode: String(formData.get("postalCode") ?? ""),
+                  countryCode: String(formData.get("countryCode") ?? ""),
+                },
+              }
+            : {}),
+        },
+      },
+    }),
+    cache: "no-store",
+  });
+  persistCommerceSession(store, response.headers);
+  if (!response.ok) {
+    return {
+      ok: false,
+      errorCode: "TEMPORARY_FAILURE",
+      message: `Checkout API returned ${response.status}`,
+      affectedLineIds: [],
+    };
+  }
+  const body = (await response.json()) as CheckoutResponse;
+  if (body.errors?.length) {
+    return {
+      ok: false,
+      errorCode: "TEMPORARY_FAILURE",
+      message: body.errors[0]?.message ?? "Checkout failed",
+      affectedLineIds: [],
+    };
+  }
+  const result = body.data?.placeJarShopOrder;
+  if (!result?.success || !result.orderCode || !result.confirmationToken) {
+    return {
+      ok: false,
+      errorCode: result?.errorCode ?? "TEMPORARY_FAILURE",
+      message: result?.message ?? "Order could not be placed",
+      affectedLineIds: result?.affectedLineIds ?? [],
+    };
+  }
+  const confirmation = await exchangeOrderConfirmation(
+    locale,
+    result.confirmationToken,
+  );
+  if (!confirmation || confirmation.orderCode !== result.orderCode) {
+    return {
+      ok: false,
+      errorCode: "ORDER_NOT_FOUND",
+      message: "Order confirmation is not available",
+      affectedLineIds: [],
+    };
+  }
+  redirect(
+    `/${locale}/checkout/success?order=${encodeURIComponent(result.orderCode)}`,
+  );
+  return { ok: true };
+}

package/dist/template/storefront/lib/commerce-session.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  COMMERCE_SESSION_COOKIE,
+  type CommerceSessionStore,
+  createCommerceSessionStore,
+  commerceSessionAuthorization,
+  commerceSessionToken,
+  persistCommerceSession,
+  VENDURE_AUTH_TOKEN_HEADER,
+} from "./commerce-session";
+
+function createStore() {
+  const values = new Map<string, string>();
+  const options = new Map<string, Parameters<CommerceSessionStore["set"]>[2]>();
+  return {
+    get(name: string) {
+      const value = values.get(name);
+      return value === undefined ? undefined : { value };
+    },
+    set(
+      name: string,
+      value: string,
+      cookieOptions: Parameters<CommerceSessionStore["set"]>[2],
+    ) {
+      values.set(name, value);
+      options.set(name, cookieOptions);
+    },
+    delete(name: string) {
+      values.delete(name);
+      options.delete(name);
+    },
+    options,
+  };
+}
+
+describe("commerce session adapter", () => {
+  it("persists a Vendure response token and forwards it as bearer auth", () => {
+    const store = createStore();
+    const headers = new Headers();
+    headers.set(VENDURE_AUTH_TOKEN_HEADER, "session-value");
+
+    persistCommerceSession(store, headers);
+
+    expect(commerceSessionToken(store)).toBe("session-value");
+    expect(commerceSessionAuthorization(store)).toBe("Bearer session-value");
+    expect(store.get(COMMERCE_SESSION_COOKIE)).toEqual({
+      value: "session-value",
+    });
+    expect(store.options.get(COMMERCE_SESSION_COOKIE)).toMatchObject({
+      httpOnly: true,
+      maxAge: 60 * 60 * 24 * 30,
+      path: "/",
+      sameSite: "lax",
+    });
+  });
+
+  it("does not create a storefront session without a Shop API token", () => {
+    const store = createStore();
+
+    persistCommerceSession(store, new Headers());
+
+    expect(commerceSessionToken(store)).toBeUndefined();
+    expect(commerceSessionAuthorization(store)).toBeUndefined();
+  });
+
+  it("adapts the SDK session store to an HttpOnly storefront cookie", () => {
+    const store = createStore();
+    const session = createCommerceSessionStore(store);
+
+    session.set("new-session");
+    expect(commerceSessionToken(store)).toBe("new-session");
+
+    session.set(undefined);
+    expect(commerceSessionToken(store)).toBeUndefined();
+  });
+});

package/dist/template/storefront/lib/commerce-session.ts

@@ -0,0 +1,85 @@
+import type { SessionStore } from "@jarwizz/commerce-sdk/types";
+
+export const COMMERCE_SESSION_COOKIE = "jarshop-storefront-session";
+export const VENDURE_AUTH_TOKEN_HEADER = "vendure-auth-token";
+
+interface CookieValue {
+  readonly value: string;
+}
+
+export interface CommerceSessionStore {
+  get(name: string): CookieValue | undefined;
+  set(
+    name: string,
+    value: string,
+    options: {
+      httpOnly: boolean;
+      maxAge: number;
+      path: string;
+      sameSite: "lax";
+      secure: boolean;
+    },
+  ): void;
+  delete(name: string): void;
+}
+
+const storefrontCookieOptions = {
+  httpOnly: true,
+  maxAge: 60 * 60 * 24 * 30,
+  path: "/",
+  sameSite: "lax" as const,
+  secure: process.env.NODE_ENV === "production",
+};
+
+/**
+ * Reads the opaque Shop API session only in a server-side facade call.
+ * Browser JavaScript cannot access the HttpOnly cookie.
+ */
+export function commerceSessionToken(
+  store: Pick<CommerceSessionStore, "get">,
+): string | undefined {
+  return store.get(COMMERCE_SESSION_COOKIE)?.value;
+}
+
+/**
+ * Vendure returns a newly-created session in `vendure-auth-token`, but accepts
+ * a later bearer session only through the standard Authorization header.
+ */
+export function commerceSessionAuthorization(
+  store: Pick<CommerceSessionStore, "get">,
+): string | undefined {
+  const token = commerceSessionToken(store);
+  return token ? `Bearer ${token}` : undefined;
+}
+
+/**
+ * Captures Vendure's bearer session from an internal API response and stores it
+ * under the storefront origin. The browser never receives a Shop API header.
+ */
+export function persistCommerceSession(
+  store: Pick<CommerceSessionStore, "set">,
+  headers: Headers,
+): void {
+  const token = headers.get(VENDURE_AUTH_TOKEN_HEADER);
+  if (!token) return;
+  store.set(COMMERCE_SESSION_COOKIE, token, storefrontCookieOptions);
+}
+
+/**
+ * Binds the framework-neutral SDK session contract to the storefront's
+ * HttpOnly cookie. Browser code never receives the opaque token.
+ */
+export function createCommerceSessionStore(
+  store: CommerceSessionStore,
+): SessionStore {
+  return {
+    get: () => commerceSessionToken(store),
+    set: (token) => {
+      if (token) {
+        store.set(COMMERCE_SESSION_COOKIE, token, storefrontCookieOptions);
+      } else {
+        store.delete(COMMERCE_SESSION_COOKIE);
+      }
+    },
+  };
+}

package/dist/template/storefront/lib/commerce.ts

@@ -1,7 +1,23 @@
 import { createCommerceClient } from "@jarwizz/commerce-sdk/server";
 import type {
+  AccountSession,
+  AccountSummary,
+  AccountAddress,
+  AccountAddressInput,
+  AccountProfile,
+  AccountOrdersOptions,
+  CatalogPage,
+  ChangePasswordInput,
   CommerceResult,
+  LoginInput,
+  ProductDetail,
+  ProductListOptions,
   ProductSummary,
+  RegisterAccountInput,
+  ResetPasswordInput,
+  SessionStore,
+  UpdateAccountProfileInput,
+  UpdateAccountAddressInput,
 } from "@jarwizz/commerce-sdk/types";
 
 export type CommerceLocale = "sk" | "en";
@@ -14,22 +30,131 @@ function endpointFor(locale: CommerceLocale): string {
   return endpoint.toString();
 }
 
-function client(locale: CommerceLocale) {
+function client(locale: CommerceLocale, sessionStore?: SessionStore) {
   return createCommerceClient({
     endpoint: endpointFor(locale),
     channelToken: process.env.JARSHOP_CHANNEL_TOKEN,
+    sessionStore,
   });
 }
 
 export function getCatalog(
   locale: CommerceLocale,
-): Promise<CommerceResult<ProductSummary[]>> {
-  return client(locale).listProducts();
+  options?: ProductListOptions,
+): Promise<CommerceResult<CatalogPage<ProductSummary>>> {
+  return client(locale).listProducts(options);
 }
 
 export function getProduct(
   slug: string,
   locale: CommerceLocale,
-): Promise<CommerceResult<ProductSummary | null>> {
+): Promise<CommerceResult<ProductDetail | null>> {
   return client(locale).getProductBySlug(slug);
 }
+
+export function loginAccount(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: LoginInput,
+): Promise<CommerceResult<AccountSession>> {
+  return client(locale, sessionStore).login(input);
+}
+
+export function logoutAccount(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+): Promise<CommerceResult<void>> {
+  return client(locale, sessionStore).logout();
+}
+
+export function getActiveAccount(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+): Promise<CommerceResult<AccountSummary | null>> {
+  return client(locale, sessionStore).getActiveAccount();
+}
+
+export function registerAccount(
+  locale: CommerceLocale,
+  input: RegisterAccountInput,
+): Promise<CommerceResult<void>> {
+  return client(locale).register(input);
+}
+
+export function refreshAccountRegistration(
+  locale: CommerceLocale,
+  emailAddress: string,
+): Promise<CommerceResult<void>> {
+  return client(locale).refreshRegistration(emailAddress);
+}
+
+export function verifyAccountRegistration(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  token: string,
+): Promise<CommerceResult<AccountSession>> {
+  return client(locale, sessionStore).verifyRegistration(token);
+}
+
+export function requestAccountPasswordReset(
+  locale: CommerceLocale,
+  emailAddress: string,
+): Promise<CommerceResult<void>> {
+  return client(locale).requestPasswordReset(emailAddress);
+}
+
+export function resetAccountPassword(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: ResetPasswordInput,
+): Promise<CommerceResult<AccountSession>> {
+  return client(locale, sessionStore).resetPassword(input);
+}
+
+export function getAccountProfile(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  options?: AccountOrdersOptions,
+): Promise<CommerceResult<AccountProfile | null>> {
+  return client(locale, sessionStore).getAccountProfile(options);
+}
+
+export function updateAccountProfile(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: UpdateAccountProfileInput,
+): Promise<CommerceResult<AccountSummary>> {
+  return client(locale, sessionStore).updateProfile(input);
+}
+
+export function createAccountAddress(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: AccountAddressInput,
+): Promise<CommerceResult<AccountAddress>> {
+  return client(locale, sessionStore).createAddress(input);
+}
+
+export function deleteAccountAddress(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  id: string,
+): Promise<CommerceResult<void>> {
+  return client(locale, sessionStore).deleteAddress(id);
+}
+
+export function updateAccountAddress(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: UpdateAccountAddressInput,
+): Promise<CommerceResult<AccountAddress>> {
+  return client(locale, sessionStore).updateAddress(input);
+}
+
+export function changeAccountPassword(
+  locale: CommerceLocale,
+  sessionStore: SessionStore,
+  input: ChangePasswordInput,
+): Promise<CommerceResult<void>> {
+  return client(locale, sessionStore).changePassword(input);
+}

package/dist/template/storefront/lib/confirmation-cookie.ts

@@ -0,0 +1,9 @@
+export const CONFIRMATION_COOKIE_NAME = "jarshop-confirmation";
+
+export const confirmationCookieOptions = {
+  httpOnly: true,
+  secure: process.env.NODE_ENV === "production",
+  sameSite: "lax" as const,
+  path: "/",
+  maxAge: 60 * 60 * 2,
+};

package/dist/template/storefront/lib/confirmation.ts

@@ -0,0 +1,95 @@
+"use server";
+
+import { cookies } from "next/headers";
+
+import type { CommerceLocale } from "./commerce";
+import {
+  confirmationCookieOptions,
+  CONFIRMATION_COOKIE_NAME,
+} from "./confirmation-cookie";
+
+export interface OrderConfirmationView {
+  orderId: string;
+  orderCode: string;
+  state: string;
+  totalWithTax: number;
+  currencyCode: string;
+}
+
+interface ConfirmationExchange {
+  credential: string;
+  confirmation: OrderConfirmationView;
+}
+
+function endpointFor(locale: CommerceLocale): string {
+  const endpoint = new URL(
+    process.env.JARSHOP_COMMERCE_ENDPOINT ?? "http://localhost:3000/shop-api",
+  );
+  endpoint.searchParams.set("languageCode", locale);
+  return endpoint.toString();
+}
+
+function commerceHeaders(cookie?: string): HeadersInit {
+  return {
+    "content-type": "application/json",
+    ...(process.env.JARSHOP_CHANNEL_TOKEN
+      ? { "vendure-token": process.env.JARSHOP_CHANNEL_TOKEN }
+      : {}),
+    ...(cookie ? { cookie } : {}),
+  };
+}
+
+export async function exchangeOrderConfirmation(
+  locale: CommerceLocale,
+  token: string,
+): Promise<OrderConfirmationView | null> {
+  const store = await cookies();
+  const response = await fetch(endpointFor(locale), {
+    method: "POST",
+    headers: commerceHeaders(),
+    body: JSON.stringify({
+      query: `mutation ExchangeConfirmation($token: String!) { exchangeJarShopOrderConfirmation(token: $token) { credential confirmation { orderId orderCode state totalWithTax currencyCode } } }`,
+      variables: { token },
+    }),
+    cache: "no-store",
+  });
+  if (!response.ok) return null;
+  const body = (await response.json()) as {
+    data?: { exchangeJarShopOrderConfirmation: ConfirmationExchange | null };
+    errors?: Array<{ message: string }>;
+  };
+  const exchange = body.data?.exchangeJarShopOrderConfirmation;
+  if (!exchange) return null;
+  store.set(
+    CONFIRMATION_COOKIE_NAME,
+    exchange.credential,
+    confirmationCookieOptions,
+  );
+  return exchange.confirmation;
+}
+
+export async function getOrderConfirmation(
+  locale: CommerceLocale,
+  orderCode: string,
+): Promise<OrderConfirmationView | null> {
+  const store = await cookies();
+  const credential = store.get(CONFIRMATION_COOKIE_NAME)?.value;
+  if (!credential) return null;
+  const response = await fetch(endpointFor(locale), {
+    method: "POST",
+    headers: commerceHeaders(
+      `${CONFIRMATION_COOKIE_NAME}=${encodeURIComponent(credential)}`,
+    ),
+    body: JSON.stringify({
+      query: `query ProtectedConfirmation($orderCode: String!) { jarShopProtectedOrderConfirmation(orderCode: $orderCode) { orderId orderCode state totalWithTax currencyCode } }`,
+      variables: { orderCode },
+    }),
+    cache: "no-store",
+  });
+  if (!response.ok) return null;
+  const body = (await response.json()) as {
+    data?: { jarShopProtectedOrderConfirmation: OrderConfirmationView | null };
+    errors?: Array<{ message: string }>;
+  };
+  return body.data?.jarShopProtectedOrderConfirmation ?? null;
+}

package/dist/template/storefront/lib/form-values.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+
+import { formPassword, formText } from "./form-values";
+
+describe("account form values", () => {
+  it("trims ordinary text but preserves password bytes", () => {
+    const form = new FormData();
+    form.set("name", "  Ada  ");
+    form.set("password", "  correct horse  ");
+
+    expect(formText(form, "name")).toBe("Ada");
+    expect(formPassword(form, "password")).toBe("  correct horse  ");
+  });
+});

package/dist/template/storefront/lib/form-values.ts

@@ -0,0 +1,7 @@
+export function formText(formData: FormData, name: string): string {
+  return String(formData.get(name) ?? "").trim();
+}
+
+export function formPassword(formData: FormData, name: string): string {
+  return String(formData.get(name) ?? "");
+}

package/dist/template/storefront/lib/i18n.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import {
+  createTranslator,
+  formatMessage,
+  isSupportedLocale,
+  messages,
+  parseLocale,
+  supportedLocales,
+} from "./i18n";
+
+describe("JarShop storefront i18n contract", () => {
+  it("keeps every supported locale aligned with the typed message keys", () => {
+    const keys = Object.keys(messages.sk).sort();
+
+    for (const locale of supportedLocales) {
+      expect(Object.keys(messages[locale]).sort()).toEqual(keys);
+    }
+  });
+
+  it("loads catalogues from the conventional locale JSON resources", () => {
+    expect(messages.sk["catalog.title"]).toBe("Produkty");
+    expect(messages.en["catalog.title"]).toBe("Products");
+  });
+
+  it("normalizes regional tags and falls back safely to Slovak", () => {
+    expect(parseLocale("en-US")).toBe("en");
+    expect(parseLocale("sk-SK")).toBe("sk");
+    expect(parseLocale("de")).toBe("sk");
+    expect(parseLocale(undefined)).toBe("sk");
+    expect(isSupportedLocale("en")).toBe(true);
+    expect(isSupportedLocale("en-US")).toBe(false);
+  });
+
+  it("returns localized UI copy without changing commerce locale semantics", () => {
+    expect(createTranslator("sk")("checkout.submitPickup")).toBe(
+      "Objednať osobný odber na dobierku",
+    );
+    expect(createTranslator("en")("checkout.submitCourier")).toBe(
+      "Place courier COD order",
+    );
+    expect(createTranslator("en")("checkout.submitPickup")).toBe(
+      "Place pickup COD order",
+    );
+  });
+
+  it("formats localized navigation variables without exposing a locale branch to UI callers", () => {
+    expect(formatMessage("sk", "nav.cartItems", { count: 2 })).toBe("2 ks");
+    expect(formatMessage("en", "nav.cartItems", { count: 2 })).toBe("2 items");
+  });
+});

package/dist/template/storefront/lib/i18n.ts

@@ -0,0 +1,44 @@
+import englishMessages from "../messages/en.json";
+import slovakMessages from "../messages/sk.json";
+
+export const supportedLocales = ["sk", "en"] as const;
+
+export type SupportedLocale = (typeof supportedLocales)[number];
+export type MessageKey = keyof typeof slovakMessages;
+export type MessageCatalog = Record<MessageKey, string>;
+
+const typedEnglishMessages = englishMessages satisfies MessageCatalog;
+
+export const messages = {
+  sk: slovakMessages,
+  en: typedEnglishMessages,
+} satisfies Record<SupportedLocale, MessageCatalog>;
+
+export function isSupportedLocale(
+  value: string | undefined,
+): value is SupportedLocale {
+  return value === "sk" || value === "en";
+}
+
+export function parseLocale(value: string | undefined): SupportedLocale {
+  const language = value?.toLowerCase().split("-")[0];
+  return language === "en" ? "en" : "sk";
+}
+
+export type Translator = (key: MessageKey) => string;
+
+export function createTranslator(value: string | SupportedLocale): Translator {
+  const locale = parseLocale(value);
+  return (key) => messages[locale][key] ?? messages.sk[key];
+}
+
+export function formatMessage(
+  value: string | SupportedLocale,
+  key: MessageKey,
+  variables: Readonly<Record<string, string | number>>,
+): string {
+  return createTranslator(value)(key).replace(
+    /\{(\w+)\}/gu,
+    (_, name: string) => String(variables[name] ?? `{${name}}`),
+  );
+}