orionplace-react 0.1.0

package/templates/interfaces/orionplace/domains/IDomain.ts

@@ -0,0 +1,13 @@
+import type { ITransformValue } from '../shared/ITransformValue';
+
+export interface IDomain {
+	id: number;
+	domain_extras: IDomainExtras;
+}
+
+export interface IDomainExtras {
+	period_id: number;
+	option_cost_id: number;
+	amount: Record<string, ITransformValue>;
+	days: number;
+}

package/templates/interfaces/orionplace/index.ts

@@ -0,0 +1,30 @@
+export * from './apiBase/TMethod';
+export * from './appBase/IAppLoad';
+export * from './appBase/IAppLoadCommon';
+export * from './appBase/IApploadUserProfile';
+export * from './appBase/IForm';
+export * from './appBase/ISEO';
+export * from './appBase/appLoadCommon/IAppLoadCommonBanner';
+export * from './appBase/appLoadCommon/IAppLoadCommonContact';
+export * from './appBase/appLoadCommon/IAppLoadCommonCurrency';
+export * from './appBase/appLoadCommon/IAppLoadCommonEvents';
+export * from './appBase/appLoadCommon/IAppLoadCommonLocale';
+export * from './appBase/appLoadCommon/IAppLoadCommonLogos';
+export * from './appBase/appLoadCommon/IAppLoadCommonPath';
+export * from './appBase/appLoadCommon/IAppLoadCommonSEO';
+export * from './appBase/appLoadCommon/IAppLoadCommonSocial';
+export * from './appBase/appLoadCommon/IAppLoadCommonTariff';
+export * from './appBase/appLoadCommon/IAppLoadCommonUnit';
+export * from './appBase/appLoadCommon/IAppLoadCommonVariables';
+export * from './appBase/appLoadCommon/IAppLoadCommonVisualSettings';
+export * from './appBase/appLoadCommon/IAppLoadCommonWalletValue';
+export * from './category/ICategory';
+export * from './domains/IDomain';
+export * from './products/IProduct';
+export * from './shared/IGeoCoordinates';
+export * from './shared/ITransformValue';
+export * from './subscribeOptions/ISubscribeOption';
+export * from './subscribeTariff/ISubscribeTariff';
+export * from './subscribes/ISubscribe';
+export * from './transport';
+export * from './state';

package/templates/interfaces/orionplace/products/IProduct.ts

@@ -0,0 +1,235 @@
+import type { ITransformValue } from '../shared/ITransformValue';
+
+export interface IProduct {
+	id: number;
+	product_group_id: number;
+	whishlist_id?: number | null;
+	main_category?: number | null;
+	subscription_id?: number | null;
+	is_digital?: boolean;
+	locale: Record<string, Partial<IProductLocale>>;
+	discount: number;
+	cart_counts?: IProductCartCounts | null;
+	base_price_dict: Record<string, ITransformValue>;
+	product_price_dict: Record<string, ITransformValue>;
+	images?: IProductImages | null;
+	weight_dict: Record<string, ITransformValue>;
+	length_dict: IProductDimensions;
+	variants: IProductVariants;
+	flags: IProductFlags;
+	seller: IProductSeller;
+	status: IProductStatus;
+	c_real_left: number;
+	feedback_stat: IProductFeedbackStat;
+	related?: IProductRelated | null;
+	secondary_variants?: IProductSecondaryVariants;
+	feedback_allowed?: boolean;
+	attributes?: IProductAttribute[] | Record<string, IProductAttribute>;
+	videos?: IProductVideo[];
+	manufacture?: IProductManufacture | null;
+	refunds?: IProductRefunds | null;
+	feedbacks?: IProductFeedbacks | null;
+	promo?: IProductPromo | null;
+
+}
+
+export interface IProductAttribute {
+	id: number;
+	names: IProductAttributeName[];
+	locales: Record<string, string>;
+}
+
+export interface IProductAttributeName {
+	id: number;
+	locale: Record<string, Record<string, string>>;
+}
+
+export interface IProductVideo {
+	id: number;
+	product_video: string;
+	product: number;
+	preview: string;
+}
+
+export interface IProductManufacture {
+	id: number;
+	name: string;
+	image: string;
+	small_image: string;
+}
+
+export interface IProductRefunds {
+	customer_max_refund_days: number;
+	max_refund_days_with_defect: number;
+}
+
+export interface IProductPromo {
+	id: number;
+	locale: Record<string, string | { promo_name?: string; name?: string }>;
+	promo_value: number | Record<string, ITransformValue>;
+	promo_type: 'FREE_SHIPPING' | 'FIXED' | 'PERCENTAGE';
+}
+
+export interface IProductFeedbacks {
+	feedbacks?: {
+		data: IProductFeedback[];
+		rpag?: IProductPagination;
+	};
+	stats?: Record<string, number>;
+	c_feedback_images?: number;
+	image_row?: { data: unknown[]; rpag?: IProductPagination };
+	our_feedback_id?: number | null;
+}
+
+export interface IProductFeedback {
+	id: number;
+	rating?: number;
+	text?: string;
+	created_at?: string;
+	date_created?: string;
+	user?: { id?: number; name?: string; avatar?: string };
+	customer?: { id?: number; name?: string; avatar?: string };
+	images?: Array<string | { image?: string; url?: string }>;
+	[key: string]: unknown;
+}
+
+export interface IProductPagination {
+	has_next?: boolean;
+	has_previous?: boolean;
+	page?: number;
+	pages?: number;
+	total_count?: number;
+	selected_count?: number;
+}
+
+export interface IProductFeedbackStat {
+	c_feedbacks: number;
+	avg_raiting: number | string;
+}
+
+export interface IProductStatus {
+	status: EProductStatus;
+	status_display: string;
+}
+
+export const EProductStatus = {
+	PUBLISHED: 2,
+	PUBLISHED_AS_OPTION: 1,
+	UNPUBLISHED: 0,
+	TEMPORARY_STOPPED: -1,
+	LOW_SALE_STOCK: -2,
+	LOW_STOCK: -3,
+	INCOMPLETE: -4,
+	ON_MODERATION: -5,
+} as const;
+export type EProductStatus =
+	(typeof EProductStatus)[keyof typeof EProductStatus];
+
+export interface IProductSeller {
+	id: number;
+	name: string;
+	raiting: number | string;
+	avatar?: string;
+}
+
+export interface IProductFlags {
+	flag_is_new?: boolean;
+	flag_is_soon_be_out?: boolean;
+	flag_is_popular?: boolean;
+	flag_is_good_deal?: boolean;
+}
+
+export interface IProductVariants {
+	main_variant?: IProductVariant;
+}
+
+export interface IProductVariant {
+	id: number;
+	value: IProductVariantValue[];
+	locale: Record<string, string>;
+	is_color: boolean;
+	second_exists: boolean;
+}
+
+export interface IProductVariantValue {
+	id: number;
+	color: string;
+	locale: Record<string, string>;
+	c_published: number;
+	reload_product?: number | null;
+}
+
+export interface IProductDimensions {
+	length: Record<string, ITransformValue>;
+	width: Record<string, ITransformValue>;
+	height: Record<string, ITransformValue>;
+}
+
+export interface IProductImages {
+	small: string[];
+	full: string[];
+}
+
+export interface IProductCartCounts {
+	modal_quantity?: number;
+	cart_id?: number;
+	cart_item_price_no_discount?: Record<string, ITransformValue>;
+	cart_item_price_after_promo?: Record<string, ITransformValue>;
+}
+
+export interface IProductRelated {
+	data: IProduct[];
+}
+
+export interface IProductSecondaryVariants {
+	secondary: IProductSecondaryVariantInfo;
+	variants: IProductSecondaryVariant[];
+}
+
+export interface IProductSecondaryVariantInfo {
+	id: number;
+	is_color: boolean;
+	locale: Record<string, string>;
+	value: null;
+}
+
+export interface IProductSecondaryVariant {
+	product: IProduct;
+	value: IProductSecondaryVariantValue;
+}
+
+export interface IProductSecondaryVariantValue {
+	id: number;
+	locale: Record<string, string>;
+	color: string;
+}
+
+export interface IProductLocale {
+	id?: number;
+	product_name?: string;
+	product_title?: string;
+	product_slug?: string;
+	meta_description?: string;
+	meta_keywords?: string;
+	product_description?: string;
+	short_description?: string;
+}
+
+export type IProductsListNames =
+	| 'main'
+	| 'new'
+	| 'featured'
+	| 'seller'
+	| 'manufacturer'
+	| 'productAlerts'
+	| 'productAlertsRelated'
+	| 'cart'
+	| 'cartPreview'
+	| 'cartUndeliverable'
+	| 'orders'
+	| 'feedbacks';
+
+export interface IProcessingProduct {
+	id: number;
+	listName: IProductsListNames;
+}

package/templates/interfaces/orionplace/shared/IGeoCoordinates.ts

@@ -0,0 +1,4 @@
+export interface IGeoCoordinates {
+	long: number | string;
+	lat: number | string;
+}

package/templates/interfaces/orionplace/shared/ITransformValue.ts

@@ -0,0 +1,3 @@
+export interface ITransformValue {
+	transform_value: number;
+}

package/templates/interfaces/orionplace/state.ts

@@ -0,0 +1,4 @@
+import type { AppLoadResult } from './transport';
+
+export type AppLoadStatus = 'idle' | 'pending' | 'success' | 'error';
+export type AppLoadLoader = (signal: AbortSignal) => Promise<AppLoadResult>;

package/templates/interfaces/orionplace/subscribeOptions/ISubscribeOption.ts

@@ -0,0 +1,9 @@
+export interface ISubscribeOption {
+	id: number;
+	locale: Record<string, ISubscribeOptionLocale>;
+}
+
+export interface ISubscribeOptionLocale {
+	option_name?: string;
+	option_description?: string;
+}

package/templates/interfaces/orionplace/subscribeTariff/ISubscribeTariff.ts

@@ -0,0 +1,46 @@
+import type { JsonValue } from '../transport';
+import type { ITransformValue } from '../shared/ITransformValue';
+import type { ISubscribeOptionLocale } from '../subscribeOptions/ISubscribeOption';
+import type { IDomainExtras } from '../domains/IDomain';
+
+export interface ISubscribeTariff {
+	id: number;
+	locales: Record<string, ISubscribeTariffLocales>;
+	tariff_variables_json: Record<string, JsonValue>;
+	trial_days: number;
+	prices: ISubscribeTariffPrice[];
+	subscription: number;
+	tariff_image: ISubscribeTariffImages | null;
+	options: ISubscribeTariffOption[];
+}
+
+export interface ISubscribeTariffOption {
+	id: number;
+	locale: Record<string, ISubscribeOptionLocale>;
+	image: string | null;
+	eligiable_for_trial: boolean;
+	domain_extras: IDomainExtras[];
+}
+
+export interface ISubscribeTariffImages {
+	small: string[];
+	full: string[];
+}
+
+export interface ISubscribeTariffPrice {
+	period_id: number;
+	tariff_cost_id: number;
+	amount: Record<string, ITransformValue>;
+	days: number;
+}
+
+export interface ISubscribeTariffLocales {
+	id?: number;
+	tariff_name?: string;
+	tariff_title?: string;
+	tariff_slug?: string;
+	tariff_meta_description?: string;
+	tariff_meta_keywords?: string;
+	tariff_description?: string;
+	tariff_short_description?: string;
+}

package/templates/interfaces/orionplace/subscribes/ISubscribe.ts

@@ -0,0 +1,28 @@
+import type { JsonValue } from '../transport';
+export interface ISubscribe {
+	id: number;
+	locale: Record<string, ISubscribeLocale>;
+	is_new_subs_allowed: boolean;
+	only_admin_can_subscribe: boolean;
+	translations: Record<string, JsonValue>;
+	user_data: Record<string, JsonValue>;
+}
+
+export interface ISubscribeUserData {
+	headings: Record<string, ISubscribeUserDataValue>;
+	hosts?: ISubscribeUserDataValue;
+}
+
+export interface ISubscribeUserDataValue {
+	tabs: string[];
+}
+
+export interface ISubscribeTranslations {
+	id: number;
+	trans: Record<string, string>;
+}
+
+export interface ISubscribeLocale {
+	subscription_name?: string;
+	subscription_description?: string;
+}

package/templates/interfaces/orionplace/transport.ts

@@ -0,0 +1,30 @@
+import type { IAppLoad } from './appBase/IAppLoad';
+
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+export interface AppLoadRequest {
+  detalize_mode: 'full' | 'light';
+  ignore_cache: boolean;
+}
+export interface ApiFormError { message: string; code: string }
+export interface AppLoadResponse {
+  form_errors: Record<string, ApiFormError[]> | null;
+  success_message: string | null;
+  page_data: IAppLoad | null;
+  locale?: string;
+  url_name?: string;
+  exc_stack?: JsonValue;
+  debug?: JsonValue;
+  user_groups?: JsonValue;
+  user_perms?: JsonValue;
+  spent?: number;
+}
+export interface AppLoadResult {
+  response: AppLoadResponse & { page_data: IAppLoad };
+  httpStatus: number;
+  loadedAt: string;
+}
+export interface AppLoadFailure {
+  kind: 'http' | 'validation' | 'invalid-response' | 'network';
+  httpStatus: number | null;
+  fields: string[];
+}

package/templates/lib/orionplace/appLoadClient.ts

@@ -0,0 +1,33 @@
+import { AppLoadError, appLoadResult, inspectAppLoad } from './appLoadResult';
+import type { AppLoadRequest, AppLoadResult } from '../../interfaces/orionplace/transport';
+
+function withTimeout(signal: AbortSignal, milliseconds: number): AbortSignal {
+  if (typeof AbortSignal.any !== 'function') return signal;
+  return AbortSignal.any([signal, AbortSignal.timeout(milliseconds)]);
+}
+
+/**
+ * Browser transport for explicit initialize and refresh actions. The browser
+ * sends and stores session cookies itself through the same-origin gateway.
+ */
+export async function requestBrowserAppLoad(signal: AbortSignal): Promise<AppLoadResult> {
+  let response: Response;
+  try {
+    response = await fetch('/api/appload', {
+      method: 'POST',
+      headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
+      body: JSON.stringify({ detalize_mode: 'light', ignore_cache: true } satisfies AppLoadRequest),
+      credentials: 'same-origin',
+      cache: 'no-store',
+      signal: withTimeout(signal, 35_000),
+    });
+  } catch {
+    throw new AppLoadError('Could not reach the marketplace API.', { kind: 'network', httpStatus: null, fields: [] });
+  }
+  let body: unknown = null;
+  try { body = await response.json(); }
+  catch { body = null; }
+  const failure = inspectAppLoad(body, response.status);
+  if (failure) throw new AppLoadError('Marketplace initialization failed.', failure);
+  return appLoadResult(body, response.status);
+}

package/templates/lib/orionplace/appLoadResult.ts

@@ -0,0 +1,56 @@
+import type { AppLoadFailure, AppLoadResponse, AppLoadResult } from '../../interfaces/orionplace/transport';
+
+const record = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/** Validate the bootstrap boundary. Interfaces describe nested data, not a runtime schema. */
+export function inspectAppLoad(body: unknown, httpStatus: number): AppLoadFailure | null {
+  if (httpStatus < 200 || httpStatus >= 300) return { kind: 'http', httpStatus, fields: [] };
+  if (record(body) && record(body.form_errors) && Object.keys(body.form_errors).length) {
+    return { kind: 'validation', httpStatus, fields: Object.keys(body.form_errors) };
+  }
+  const page   = record(body) && body.page_data;
+  const init   = record(page) && page.init;
+  const unauth = record(page) && page.unauth;
+  if (!record(body) || !('form_errors' in body) || (body.form_errors !== null && !record(body.form_errors)) ||
+      !record(init) || typeof init.is_authenticated !== 'boolean' ||
+      !record(init.locale) || !record(init.currencies) || !record(unauth) || !record(unauth.paths) ||
+      Object.values(unauth.paths).some(group => !record(group) || Object.values(group).some(endpoint =>
+        !record(endpoint) || typeof endpoint.target !== 'string' || !Array.isArray(endpoint.methods)))) {
+    return { kind: 'invalid-response', httpStatus, fields: [] };
+  }
+  return null;
+}
+
+export function appLoadResult(body: unknown, httpStatus: number): AppLoadResult {
+  const failure = inspectAppLoad(body, httpStatus);
+  if (failure) throw new Error(`AppLoad: ${failure.kind}`);
+  return {
+    response: body as AppLoadResponse & { page_data: NonNullable<AppLoadResponse['page_data']> },
+    httpStatus,
+    loadedAt: new Date().toISOString(),
+  };
+}
+
+/** Transport and envelope failures reach the store as this sanitized shape. */
+export function appLoadFailure(error: unknown): AppLoadFailure {
+  const detail = error && typeof error === 'object' && 'data' in error ? (error as { data: unknown }).data : null;
+  const known  = record(detail) && 'kind' in detail &&
+    ['http', 'validation', 'invalid-response', 'network'].includes(String(detail.kind));
+  if (!known || !record(detail)) return { kind: 'network', httpStatus: null, fields: [] };
+  return {
+    kind: detail.kind as AppLoadFailure['kind'],
+    httpStatus: typeof detail.httpStatus === 'number' ? detail.httpStatus : null,
+    fields: Array.isArray(detail.fields) ? detail.fields.filter((field): field is string => typeof field === 'string') : [],
+  };
+}
+
+/** Carries a sanitized failure from the transport to the store without a stack or response body. */
+export class AppLoadError extends Error {
+  readonly data: AppLoadFailure;
+  constructor(message: string, data: AppLoadFailure) {
+    super(message);
+    this.name = 'AppLoadError';
+    this.data = data;
+  }
+}

package/templates/lib/orionplace/appLoadServer.ts

@@ -0,0 +1,72 @@
+import { cache } from 'react';
+import { headers } from 'next/headers';
+import { forwardMarketplace } from '__ORIONPLACE_RUNTIME__';
+import { appLoadResult, inspectAppLoad } from './appLoadResult';
+import type { AppLoadFailure, AppLoadRequest, AppLoadResult } from '../../interfaces/orionplace/transport';
+
+/** Server-side bootstrap. Never import this module from a client component. */
+export interface ServerAppLoad {
+  result: AppLoadResult | null;
+  failure: AppLoadFailure | null;
+  /** Raw backend `Set-Cookie` headers; only a route handler or server action may relay them. */
+  cookies: string[];
+}
+
+/** Headers a server render forwards to the marketplace gateway. */
+const FORWARDED = [
+  'cookie', 'x-front-domain', 'x-forwarded-host', 'x-forwarded-proto', 'host',
+  'accept-language', 'user-agent', 'x-init-ip', 'x-real-ip', 'x-forwarded-for', 'x-tz',
+];
+
+async function buildRequest(signal: AbortSignal): Promise<Request> {
+  const incoming = await headers();
+  const host     = incoming.get('x-forwarded-host') || incoming.get('host') || 'localhost';
+  const protocol = incoming.get('x-forwarded-proto')?.split(',')[0]?.trim() || 'https';
+  const url      = new URL('/api/appload', `${protocol}://${host}`);
+  const forward  = new Headers();
+  for (const name of FORWARDED) {
+    const value = incoming.get(name);
+    if (value) forward.set(name, value);
+  }
+  forward.set('accept', 'application/json');
+  forward.set('content-type', 'application/json');
+  // Same-origin server request: the gateway rejects cross-site mutations by Origin.
+  forward.set('origin', url.origin);
+  return new Request(url, {
+    method: 'POST',
+    headers: forward,
+    body: JSON.stringify({ detalize_mode: 'light', ignore_cache: true } satisfies AppLoadRequest),
+    signal,
+  });
+}
+
+/**
+ * Calls the same gateway the browser uses, in process, with this request's domain
+ * and session. It never throws: the failure is stored for the interface to handle.
+ */
+export async function requestAppLoad(signal?: AbortSignal): Promise<ServerAppLoad> {
+  const timeout  = AbortSignal.timeout(35_000);
+  const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  let response: Response;
+  try {
+    response = await forwardMarketplace(await buildRequest(combined), {
+      mimicFrontDomain: process.env.MIMIC_FRONT_DOMAIN ?? '',
+    });
+  } catch {
+    return { result: null, failure: { kind: 'network', httpStatus: null, fields: [] }, cookies: [] };
+  }
+  const cookies = response.headers.getSetCookie();
+  let body: unknown = null;
+  try { body = await response.json(); }
+  catch { body = null; }
+  const failure = inspectAppLoad(body, response.status);
+  if (failure) return { result: null, failure, cookies };
+  return { result: appLoadResult(body, response.status), failure: null, cookies };
+}
+
+/**
+ * One request per server render, shared by the layout and any server component
+ * that awaits it. Reading it in a layout initializes the marketplace before the
+ * page renders; it never opens an authentication prompt.
+ */
+export const getOrionplaceAppLoad = cache((): Promise<ServerAppLoad> => requestAppLoad());

package/templates/lib/orionplace/domain.ts

@@ -0,0 +1,16 @@
+import { headers } from 'next/headers';
+import { resolveFrontDomain } from '__ORIONPLACE_RUNTIME__';
+
+/**
+ * The storefront domain selected for this request: `X-Front-Domain`,
+ * `X-Forwarded-Host` or `Host`, and `MIMIC_FRONT_DOMAIN` on localhost.
+ * Use it for canonical URLs and page metadata; it is never a fixed site URL.
+ */
+export async function getStorefrontDomain(): Promise<string | null> {
+  const incoming = await headers();
+  const forward  = new Headers();
+  for (const [name, value] of incoming.entries()) forward.set(name, value);
+  const host     = forward.get('x-forwarded-host') || forward.get('host') || 'localhost';
+  return resolveFrontDomain(new Request(`https://${host}/`, { headers: forward }),
+    process.env.MIMIC_FRONT_DOMAIN ?? '');
+}

package/templates/providers/OrionplaceProvider.tsx

@@ -0,0 +1,39 @@
+'use client';
+
+import { createContext, useContext, useRef, type ReactNode } from 'react';
+import { useStore } from 'zustand';
+import {
+  createOrionplaceStore, initialSnapshot,
+  type OrionplaceState, type OrionplaceStore,
+} from '../stores/orionplace';
+import type { AppLoadFailure, AppLoadResult } from '../interfaces/orionplace';
+
+const OrionplaceContext = createContext<OrionplaceStore | null>(null);
+
+export interface OrionplaceProviderProps {
+  /** The server render's snapshot. Hydration reuses it instead of loading again. */
+  result?: AppLoadResult | null;
+  failure?: AppLoadFailure | null;
+  children: ReactNode;
+}
+
+/** Creates one store for this browser session and keeps it across re-renders. */
+export function OrionplaceProvider({ result = null, failure = null, children }: OrionplaceProviderProps) {
+  const store = useRef<OrionplaceStore>(null);
+  store.current ??= createOrionplaceStore(initialSnapshot(result, failure));
+  return <OrionplaceContext.Provider value={store.current}>{children}</OrionplaceContext.Provider>;
+}
+
+function useStoreApi(): OrionplaceStore {
+  const store = useContext(OrionplaceContext);
+  if (!store) throw new Error('Render this component inside <OrionplaceProvider>.');
+  return store;
+}
+
+/** Subscribes to one selected part of the marketplace state. */
+export function useOrionplace<T>(selector: (state: OrionplaceState) => T): T {
+  return useStore(useStoreApi(), selector);
+}
+
+/** The store itself, for actions and one-off reads outside render. */
+export const useOrionplaceStore = useStoreApi;

package/templates/proxy.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+
+/**
+ * Personalized pages are never shared between visitors or storefront domains.
+ * Next.js manages its own `Vary` header for pages; the API gateway sets the
+ * storefront-domain `Vary` on its own responses.
+ */
+export function proxy() {
+  const response = NextResponse.next();
+  response.headers.set('Cache-Control', 'private, no-store');
+  return response;
+}
+
+// The gateway sets its own headers for /api; static assets keep their caching.
+export const config = {
+  matcher: ['/((?!api/|_next/static|_next/image|favicon.ico).*)'],
+};