orionplace-react 0.1.0

package/templates/stores/orionplace.ts

@@ -0,0 +1,119 @@
+import { createStore } from 'zustand/vanilla';
+import type {
+  AppLoadFailure, AppLoadLoader, AppLoadResult, AppLoadStatus,
+  IAppLoad, IAppLoadCommon, IAppLoadCommonCurrency, IAppLoadCommonLocale, IAppLoadCommonTariff,
+  IAppLoadPath, IAppLoadPathObject, IApploadUserProfile, ICategory, IProduct,
+} from '../interfaces/orionplace';
+import { appLoadFailure } from '../lib/orionplace/appLoadResult';
+
+/** Shared empty values keep selector results referentially stable between renders. */
+const EMPTY_RECORD = Object.freeze({}) as Record<string, never>;
+const EMPTY_LIST   = Object.freeze([]) as readonly never[];
+const EMPTY_PATHS  = Object.freeze({}) as IAppLoadPathObject;
+
+export interface OrionplaceSnapshot {
+  result: AppLoadResult | null;
+  status: AppLoadStatus;
+  failure: AppLoadFailure | null;
+  endpoints: IAppLoadPathObject;
+}
+
+export interface OrionplaceState extends OrionplaceSnapshot {
+  load: (loader: AppLoadLoader, force?: boolean) => Promise<void>;
+  reset: () => void;
+}
+
+export type OrionplaceStore = ReturnType<typeof createOrionplaceStore>;
+
+/** Public and authenticated discovery are merged once per snapshot, without mutating the response. */
+function mergeEndpoints(result: AppLoadResult | null): IAppLoadPathObject {
+  const page = result?.response.page_data;
+  if (!page) return EMPTY_PATHS;
+  const groups: IAppLoadPathObject[] = [page.unauth.paths];
+  if (page.init.is_authenticated && page.auth) groups.push(page.auth.paths);
+  const merged: IAppLoadPathObject   = {};
+  for (const group of groups) {
+    for (const [section, paths] of Object.entries(group)) merged[section] = { ...merged[section], ...paths };
+  }
+  return merged;
+}
+
+/** Builds the hydration snapshot from a server render, without repeating the request. */
+export function initialSnapshot(
+  result: AppLoadResult | null = null,
+  failure: AppLoadFailure | null = null,
+): OrionplaceSnapshot {
+  return {
+    result: failure ? null : result,
+    status: failure ? 'error' : result ? 'success' : 'idle',
+    failure,
+    endpoints: failure ? EMPTY_PATHS : mergeEndpoints(result),
+  };
+}
+
+/**
+ * One store instance per server render and one per browser session.
+ * Creating the store never starts a request; the loaders are passed to `load`.
+ */
+export function createOrionplaceStore(snapshot: OrionplaceSnapshot = initialSnapshot()) {
+  // These belong to this store instance, never serialized state or a module-level cache.
+  let pending: Promise<void> | null      = null;
+  let controller: AbortController | null = null;
+  let generation                         = 0;
+
+  return createStore<OrionplaceState>()((set, get) => ({
+    ...snapshot,
+
+    reset() {
+      generation++;
+      controller?.abort();
+      controller = null;
+      pending    = null;
+      set({ result: null, failure: null, status: 'idle', endpoints: EMPTY_PATHS });
+    },
+
+    load(loader: AppLoadLoader, force = false): Promise<void> {
+      if (pending) return pending;
+      // Reuse both server success and failure after hydration or navigation; retry is explicit.
+      if (!force && get().status !== 'idle') return Promise.resolve();
+      const current = ++generation;
+      controller    = new AbortController();
+      const signal  = controller.signal;
+      set({ result: null, failure: null, status: 'pending', endpoints: EMPTY_PATHS });
+      pending       = Promise.resolve().then(() => loader(signal)).then(result => {
+        if (current !== generation) return;
+        set({ result, status: 'success', endpoints: mergeEndpoints(result) });
+      }).catch((error: unknown) => {
+        if (current !== generation) return;
+        set({ failure: appLoadFailure(error), status: 'error' });
+      }).finally(() => {
+        if (current !== generation) return;
+        pending    = null;
+        controller = null;
+      });
+      return pending;
+    },
+  }));
+}
+
+export const selectIsReady             = (state: OrionplaceSnapshot): boolean => state.status === 'success' && state.result !== null;
+export const selectStatus              = (state: OrionplaceSnapshot): AppLoadStatus => state.status;
+export const selectFailure             = (state: OrionplaceSnapshot): AppLoadFailure | null => state.failure;
+export const selectResult              = (state: OrionplaceSnapshot): AppLoadResult | null => state.result;
+export const selectData                = (state: OrionplaceSnapshot): IAppLoad | null => state.result?.response.page_data ?? null;
+export const selectInit                = (state: OrionplaceSnapshot): IAppLoadCommon | null => selectData(state)?.init ?? null;
+export const selectProfile             = (state: OrionplaceSnapshot): IApploadUserProfile | null => selectData(state)?.user ?? null;
+export const selectIsAuthenticated     = (state: OrionplaceSnapshot): boolean => selectInit(state)?.is_authenticated ?? false;
+export const selectLocales             = (state: OrionplaceSnapshot): Record<string, IAppLoadCommonLocale> => selectInit(state)?.locale ?? EMPTY_RECORD;
+export const selectCurrencies          = (state: OrionplaceSnapshot): Record<string, IAppLoadCommonCurrency> => selectInit(state)?.currencies ?? EMPTY_RECORD;
+export const selectCatalog             = (state: OrionplaceSnapshot): readonly ICategory[] => selectInit(state)?.catalog ?? EMPTY_LIST;
+export const selectProducts            = (state: OrionplaceSnapshot): readonly IProduct[] => selectInit(state)?.products ?? EMPTY_LIST;
+export const selectTariffs             = (state: OrionplaceSnapshot): IAppLoadCommonTariff | null => selectInit(state)?.tariffs ?? null;
+export const selectPublicEndpoints     = (state: OrionplaceSnapshot): IAppLoadPathObject => selectData(state)?.unauth.paths ?? EMPTY_PATHS;
+export const selectEndpoints           = (state: OrionplaceSnapshot): IAppLoadPathObject => state.endpoints;
+export const selectAuthenticatedEndpoints = (state: OrionplaceSnapshot): IAppLoadPathObject =>
+  selectIsAuthenticated(state) ? selectData(state)?.auth?.paths ?? EMPTY_PATHS : EMPTY_PATHS;
+
+/** Live discovery describes availability; the backend still checks permissions on every call. */
+export const selectEndpoint = (section: string, name: string) =>
+  (state: OrionplaceSnapshot): IAppLoadPath | undefined => state.endpoints[section]?.[name];