@laconius/core 0.1.0

package/src/site-context.ts

@@ -0,0 +1,77 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+
+import type { LaconiusRuntime } from './runtime';
+import { getRuntime, laconiusQueryKey } from './runtime';
+import type { BaseSite, Currency, Language } from './models';
+
+/**
+ * Adapters are plain objects of functions, so overriding one call is a spread and replacing the
+ * whole object is the route to a non-OCC backend.
+ */
+export type SiteContextAdapter = {
+  loadBaseSites(runtime: LaconiusRuntime): Promise<BaseSite[]>;
+  loadLanguages(runtime: LaconiusRuntime): Promise<Language[]>;
+  loadCurrencies(runtime: LaconiusRuntime): Promise<Currency[]>;
+};
+
+type ListResponse<T> = { baseSites?: T[]; languages?: T[]; currencies?: T[] };
+
+export const defaultSiteContextAdapter: SiteContextAdapter = {
+  async loadBaseSites({ client, converters }) {
+    const response = await client.request<ListResponse<unknown>>({
+      endpoint: 'baseSites',
+    });
+    return converters.convertAll<unknown, BaseSite>(response?.baseSites, 'baseSite');
+  },
+  async loadLanguages({ client, converters }) {
+    const response = await client.request<ListResponse<unknown>>({
+      endpoint: 'languages',
+    });
+    return converters.convertAll<unknown, Language>(response?.languages, 'language');
+  },
+  async loadCurrencies({ client, converters }) {
+    const response = await client.request<ListResponse<unknown>>({
+      endpoint: 'currencies',
+    });
+    return converters.convertAll<unknown, Currency>(response?.currencies, 'currency');
+  },
+};
+
+function adapter(runtime: LaconiusRuntime): SiteContextAdapter {
+  return {
+    ...defaultSiteContextAdapter,
+    ...runtime.config.backend.adapters?.siteContext,
+  };
+}
+
+/** `queryOptions` factories, for `prefetchQuery` / `useSuspenseQuery` without forking Laconius. */
+export const siteContextQueries = {
+  baseSites: () =>
+    queryOptions({
+      queryKey: laconiusQueryKey('siteContext', 'baseSites'),
+      queryFn: () => {
+        const runtime = getRuntime();
+        return adapter(runtime).loadBaseSites(runtime);
+      },
+    }),
+  languages: () =>
+    queryOptions({
+      queryKey: laconiusQueryKey('siteContext', 'languages'),
+      queryFn: () => {
+        const runtime = getRuntime();
+        return adapter(runtime).loadLanguages(runtime);
+      },
+    }),
+  currencies: () =>
+    queryOptions({
+      queryKey: laconiusQueryKey('siteContext', 'currencies'),
+      queryFn: () => {
+        const runtime = getRuntime();
+        return adapter(runtime).loadCurrencies(runtime);
+      },
+    }),
+};
+
+export const useBaseSites = () => useQuery(siteContextQueries.baseSites());
+export const useLanguages = () => useQuery(siteContextQueries.languages());
+export const useCurrencies = () => useQuery(siteContextQueries.currencies());

package/src/stores.ts

@@ -0,0 +1,94 @@
+import AsyncStorage from 'expo-sqlite/kv-store';
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+export type SessionState = {
+  /** Memory only — never persisted. */
+  accessToken?: string;
+  /** Mirror of the value in secure storage, kept for the refresh call. */
+  refreshToken?: string;
+  /** Epoch milliseconds. */
+  expiresAt?: number;
+  setSession: (
+    session: Pick<SessionState, 'accessToken' | 'refreshToken' | 'expiresAt'>,
+  ) => void;
+  clearSession: () => void;
+};
+
+/** Not persisted: [ADR-0003](docs/adr/0003-refresh-token-in-the-keychain.md). */
+export const useSessionStore = create<SessionState>((set) => ({
+  setSession: ({ accessToken, refreshToken, expiresAt }) =>
+    set({ accessToken, refreshToken, expiresAt }),
+  clearSession: () =>
+    set({
+      accessToken: undefined,
+      refreshToken: undefined,
+      expiresAt: undefined,
+    }),
+}));
+
+/** Derived, never stored. Spartacus needs a `UserIdService`; Zustand does not. */
+export function selectUserId(state: {
+  accessToken?: string;
+}): 'current' | 'anonymous' {
+  return state.accessToken ? 'current' : 'anonymous';
+}
+
+export type SiteContextState = {
+  language?: string;
+  currency?: string;
+  setLanguage: (language: string) => void;
+  setCurrency: (currency: string) => void;
+};
+
+/**
+ * Base site is immutable config; language and currency are runtime state. Both are part of every
+ * query key and drive translation lookup, so a switch retranslates and refetches in one move.
+ */
+export const useSiteContextStore = create<SiteContextState>()(
+  persist(
+    (set) => ({
+      setLanguage: (language) => set({ language }),
+      setCurrency: (currency) => set({ currency }),
+    }),
+    {
+      name: 'laconius.siteContext',
+      storage: createJSONStorage(() => AsyncStorage),
+      partialize: (state) => ({
+        language: state.language,
+        currency: state.currency,
+      }),
+    },
+  ),
+);
+
+/**
+ * A persisted value outlives the config that produced it: drop the base store's last currency and
+ * the app restores it on every cold start, and every OCC call answers `UnsupportedCurrencyError`
+ * with no way back. So a stored value counts only while the config still offers it.
+ */
+function stored(value: string | undefined, allowed: string[]): string | undefined {
+  return value !== undefined && allowed.includes(value) ? value : undefined;
+}
+
+/** Active language, falling back to config: the store starts empty until the app picks one. */
+export function resolveLanguage(config: {
+  context: { languages: string[]; defaultLanguage?: string };
+}): string | undefined {
+  return (
+    stored(useSiteContextStore.getState().language, config.context.languages) ??
+    config.context.defaultLanguage ??
+    config.context.languages[0]
+  );
+}
+
+/** Active currency, falling back to config. */
+export function resolveCurrency(config: {
+  context: { currencies: string[]; defaultCurrency?: string };
+}): string | undefined {
+  return (
+    stored(useSiteContextStore.getState().currency, config.context.currencies) ??
+    config.context.defaultCurrency ??
+    config.context.currencies[0]
+  );
+}

package/src/translations.ts

@@ -0,0 +1,40 @@
+/**
+ * English error strings, ported from Spartacus'
+ * `core-libs/assets/src/translations/en/common.json` (`httpHandlers.*`), minus the checkout and
+ * payment validation keys. Other languages are the app's: Spartacus ships 17 under
+ * `core-libs/assets/src/translations/<lang>/` and is Apache-2.0.
+ */
+export const defaultCoreTranslations = {
+  en: {
+    common: {
+      retry: 'Retry',
+      cancel: 'Cancel',
+      close: 'Close',
+      loading: 'Loading…',
+    },
+    errors: {
+      http: {
+        badRequest: 'The request could not be processed. Please check your input.',
+        unauthorized: 'Your session has expired. Please login again.',
+        forbidden:
+          'You are not authorized to perform this action. Please contact your administrator if you think this is a mistake.',
+        notFound: 'Item not found.',
+        conflict: 'Already exists.',
+        serverError: 'A server error occurred. Please try again later.',
+        offline: 'No connection. Please check your network and try again.',
+        unknown: 'An unknown error occurred.',
+      },
+      occ: {
+        InsufficientStockError: 'Not enough stock for this product.',
+        CartError: 'Cart errors occurred.',
+        CartEntryError: 'This cart entry could not be updated.',
+        UnknownIdentifierError: 'Item not found.',
+        CMSItemNotFoundError: 'This page is not available.',
+        ValidationError: 'Some of the information entered is not valid.',
+        DuplicateUidError: 'An account with this email address already exists.',
+        PasswordMismatchError: 'Old password incorrect.',
+        InvalidTokenError: 'Invalid code provided.',
+      },
+    },
+  },
+};