npm - create-wp-reactor - Versions diffs - 0.1.0 - Mend

create-wp-reactor 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/templates/client/apps/webapp/src/env.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import {
+	cacheTimingsFromEnv,
+	createRuntimeEnv,
+	type EnvSource,
+} from "@wp-reactor/headless-core";
+/**
+ * La COQUE possède la lecture de l'env (contrat ADR 0001) : elle construit une
+ * `EnvSource` depuis SON `import.meta.env` / `process.env` et la passe au kernel.
+ * Les packages ne lisent jamais l'env directement.
+ */
+const envSource: EnvSource = {
+	get(key) {
+		// VITE_* est inliné par Vite ; le reste vient de process.env côté serveur.
+		const fromVite = (import.meta.env as Record<string, string | undefined>)[
+			key
+		];
+		if (fromVite !== undefined) return fromVite;
+		return typeof process !== "undefined" ? process.env[key] : undefined;
+	},
+	ssr: import.meta.env.SSR,
+	dev: import.meta.env.DEV,
+};
+export const runtimeEnv = createRuntimeEnv(envSource);
+export const cacheTimings = cacheTimingsFromEnv(envSource);
+export const isSsr = import.meta.env.SSR;
+export const isDev = import.meta.env.DEV;

package/templates/client/apps/webapp/src/renderers/CtaBannerBlock.tsx ADDED Viewed

@@ -0,0 +1,20 @@
+export interface CtaBannerBlockAttributes {
+	heading: string;
+	body: string;
+	inverted: boolean;
+	items: unknown[];
+}
+interface CtaBannerBlockProps {
+	attributes?: CtaBannerBlockAttributes;
+	preview?: boolean;
+}
+export function CtaBannerBlock({ attributes }: CtaBannerBlockProps) {
+	// TODO: implémenter le rendu du bloc "wp-reactor/cta-banner".
+	return (
+		<section data-block="wp-reactor/cta-banner">
+			<pre>{JSON.stringify(attributes, null, 2)}</pre>
+		</section>
+	);
+}

package/templates/client/apps/webapp/src/router.tsx ADDED Viewed

@@ -0,0 +1,42 @@
+import {
+	createGraphQLClient,
+	createGraphQLReadClient,
+	createQueryContext,
+} from "@wp-reactor/headless-core";
+import type { QueryClient } from "@tanstack/react-query";
+import { createRouter } from "@tanstack/react-router";
+import { setupRouterSsrQueryIntegration } from "@tanstack/react-router-ssr-query";
+import type { GraphQLClient } from "graphql-request";
+import { runtimeEnv } from "./env";
+import { routeTree } from "./routeTree.gen";
+// Le contexte du routeur porte les fabriques du kernel, instanciées avec l'env
+// de la coque. Réf : .reference/namaki/apps/webapp/src/router.tsx
+export interface RouterContext {
+	locale: "fr" | "en" | "de";
+	graphqlClient: GraphQLClient;
+	graphqlReadClient: GraphQLClient;
+	queryClient: QueryClient;
+}
+export const getRouter = () => {
+	const graphqlClient = createGraphQLClient(runtimeEnv);
+	const graphqlReadClient = createGraphQLReadClient(runtimeEnv);
+	const { queryClient } = createQueryContext();
+	const router = createRouter({
+		routeTree,
+		context: {
+			locale: "fr",
+			graphqlClient,
+			graphqlReadClient,
+			queryClient,
+		} satisfies RouterContext,
+		defaultPreload: "intent",
+		scrollRestoration: true,
+	});
+	setupRouterSsrQueryIntegration({ router, queryClient });
+	return router;
+};

package/templates/client/apps/webapp/src/routes/__root.tsx ADDED Viewed

@@ -0,0 +1,45 @@
+import { AuthProvider } from "@wp-reactor/auth";
+import { GraphQLClientProvider } from "@wp-reactor/headless-core";
+import {
+	createRootRouteWithContext,
+	HeadContent,
+	Outlet,
+	Scripts,
+} from "@tanstack/react-router";
+import "../styles.css";
+import { authOperations } from "@/authOps";
+import type { RouterContext } from "@/router";
+export const Route = createRootRouteWithContext<RouterContext>()({
+	head: () => ({
+		meta: [
+			{ charSet: "utf-8" },
+			{ name: "viewport", content: "width=device-width, initial-scale=1" },
+			{ title: "WP Reactor" },
+		],
+	}),
+	component: RootComponent,
+});
+function RootComponent() {
+	const { graphqlClient, graphqlReadClient } = Route.useRouteContext();
+	return (
+		<html lang="fr">
+			<head>
+				<HeadContent />
+			</head>
+			<body>
+				{/* Clients GraphQL du kernel + auth à opérations injectées (ADR 0001).
+				    react-query est fourni par setupRouterSsrQueryIntegration. */}
+				<GraphQLClientProvider
+					value={{ client: graphqlClient, readClient: graphqlReadClient }}
+				>
+					<AuthProvider operations={authOperations}>
+						<Outlet />
+					</AuthProvider>
+				</GraphQLClientProvider>
+				<Scripts />
+			</body>
+		</html>
+	);
+}

package/templates/client/apps/webapp/src/routes/index.tsx ADDED Viewed

@@ -0,0 +1,51 @@
+import { EditorBlocks, type EditorBlock } from "@wp-reactor/editorial";
+import { createFileRoute } from "@tanstack/react-router";
+import { blockRegistry } from "@/blocks";
+import { useCart } from "@/cart";
+import { isDev } from "@/env";
+// En vrai, ces blocs viennent de WordPress via `nodeByUri` (GraphQL). Ici, un
+// échantillon statique pour démontrer le dispatch du moteur de blocs.
+const demoBlocks: EditorBlock[] = [
+	{
+		name: "wp-reactor/hero",
+		clientId: "demo-1",
+		attributes: { title: "WP Reactor — starter headless" },
+	},
+];
+export const Route = createFileRoute("/")({
+	component: Home,
+});
+function Home() {
+	const { itemCount, addToCart, isAddingToCart } = useCart();
+	return (
+		<main>
+			<EditorBlocks blocks={demoBlocks} registry={blockRegistry} dev={isDev} />
+			<section className="mx-auto max-w-2xl p-12">
+				<div className="mb-6 flex items-center gap-3">
+					<button
+						type="button"
+						disabled={isAddingToCart}
+						onClick={() =>
+							addToCart({
+								productId: 1,
+								optimistic: { name: "Démo", price: "9,90 €" },
+							})
+						}
+						className="rounded bg-neutral-900 px-4 py-2 text-white disabled:opacity-50"
+					>
+						Ajouter au panier (démo)
+					</button>
+					<span className="text-neutral-600">Panier : {itemCount}</span>
+				</div>
+				<p className="text-neutral-600">
+					Brancher WordPress via <code>@wp-reactor/headless-core</code>, rendre
+					les blocs avec <code>@wp-reactor/editorial</code>, panier/compte via{" "}
+					<code>@wp-reactor/commerce</code> et <code>@wp-reactor/auth</code>.
+				</p>
+			</section>
+		</main>
+	);
+}

package/templates/client/apps/webapp/src/routes/preview.tsx ADDED Viewed

@@ -0,0 +1,32 @@
+import {
+	parsePreviewData,
+	PreviewBlockHost,
+	type PreviewBlockSearch,
+	validatePreviewBlockSearch,
+} from "@wp-reactor/editorial";
+import { createFileRoute } from "@tanstack/react-router";
+import { blockRegistry } from "@/blocks";
+// Route iframe du live-preview. L'éditeur Gutenberg (FrontPreviewFrame de
+// @wp-reactor/block-editor) pointe ici ; PreviewBlockHost gère tout le protocole
+// postMessage avec le registre de blocs du client.
+export const Route = createFileRoute("/preview")({
+	validateSearch: (search): PreviewBlockSearch =>
+		validatePreviewBlockSearch(search),
+	component: PreviewPage,
+});
+function PreviewPage() {
+	const search = Route.useSearch();
+	const block = search.block ?? "wp-reactor/hero";
+	return (
+		<PreviewBlockHost
+			key={`${search.frame ?? "no-frame"}-${block}`}
+			registry={blockRegistry}
+			block={block}
+			frame={search.frame}
+			editorOrigin={search.editorOrigin}
+			initialData={parsePreviewData(search.data)}
+		/>
+	);
+}

package/templates/client/apps/webapp/src/server/auth.ts ADDED Viewed

@@ -0,0 +1,66 @@
+import {
+	type AuthUser,
+	LOGIN_MUTATION,
+	normalizeAuthTokens,
+} from "@wp-reactor/auth";
+import { WOO_SESSION_COOKIE } from "@wp-reactor/commerce";
+import { createServerGraphQLClient } from "@wp-reactor/headless-core";
+import { createServerFn } from "@tanstack/react-start";
+import { getCookie, setCookie } from "@tanstack/react-start/server";
+import { runtimeEnv } from "../env";
+import { authMiddleware } from "./authMiddleware";
+import { useAppSession } from "./session";
+// Wrappers serverFn MINCES autour des contrats du package @wp-reactor/auth
+// (Option B). POST obligatoire : réponses personnalisées par la session, jamais
+// cachables en edge.
+async function establishSession(
+	username: string,
+	password: string,
+): Promise<AuthUser> {
+	const client = createServerGraphQLClient(runtimeEnv);
+	// Transfert du panier invité → compte : on présente le woo-session guest.
+	const guestSession = getCookie(WOO_SESSION_COOKIE);
+	if (guestSession) {
+		client.setHeader("woocommerce-session", `Session ${guestSession}`);
+	}
+	const res = await client.request(LOGIN_MUTATION, { username, password });
+	if (!res?.login) throw new Error("Login failed");
+	const { user, ...tokens } = res.login;
+	const session = await useAppSession();
+	await session.update({ ...normalizeAuthTokens(tokens), user });
+	// Panier rattaché au compte (Bearer) → cookie invité obsolète.
+	if (guestSession) {
+		setCookie(WOO_SESSION_COOKIE, "", { path: "/", maxAge: 0 });
+	}
+	return user;
+}
+export const getCurrentUserServerFn = createServerFn({ method: "POST" })
+	.middleware([authMiddleware])
+	.handler(({ context }) => ({
+		user: context.user,
+		isAuthenticated: context.isAuthenticated,
+	}));
+export const loginServerFn = createServerFn({ method: "POST" })
+	.inputValidator((data: { username: string; password: string }) => ({
+		username: String(data.username),
+		password: String(data.password),
+	}))
+	.handler(async ({ data }) => ({
+		user: await establishSession(data.username, data.password),
+	}));
+export const logoutServerFn = createServerFn({ method: "POST" }).handler(
+	async () => {
+		const session = await useAppSession();
+		await session.clear();
+		return { ok: true };
+	},
+);

package/templates/client/apps/webapp/src/server/authMiddleware.ts ADDED Viewed

@@ -0,0 +1,79 @@
+import {
+	type AuthUser,
+	REFRESH_TOKEN_MUTATION,
+	resolveSessionAction,
+} from "@wp-reactor/auth";
+import { createServerGraphQLClient } from "@wp-reactor/headless-core";
+import { createMiddleware } from "@tanstack/react-start";
+import { runtimeEnv } from "../env";
+import { useAppSession } from "./session";
+export interface AuthContext {
+	isAuthenticated: boolean;
+	user: AuthUser | null;
+	authToken: string;
+}
+/**
+ * Coque (Option B) : lit la session scellée, décide via `resolveSessionAction`
+ * (helper PUR du package), rafraîchit/purge le JWT, et expose `{ isAuthenticated,
+ * user, authToken }` aux serverFns. Aucun token ne transite vers le client.
+ */
+export const authMiddleware = createMiddleware().server(async ({ next }) => {
+	const session = await useAppSession();
+	const data = session.data;
+	const tokens = {
+		authToken: data.authToken ?? "",
+		refreshToken: data.refreshToken ?? "",
+		authTokenExpiration: data.authTokenExpiration ?? 0,
+		refreshTokenExpiration: data.refreshTokenExpiration ?? 0,
+	};
+	let authToken = tokens.authToken;
+	let user: AuthUser | null = data.user ?? null;
+	let isAuthenticated = false;
+	switch (resolveSessionAction(tokens)) {
+		case "authenticated":
+			isAuthenticated = true;
+			break;
+		case "refresh": {
+			// Même X-Forwarded-Host que login/panier (claim `iss` du JWT).
+			const client = createServerGraphQLClient(runtimeEnv);
+			try {
+				const res = await client.request(REFRESH_TOKEN_MUTATION, {
+					token: tokens.refreshToken,
+				});
+				if (res?.refreshToken?.success) {
+					authToken = res.refreshToken.authToken;
+					await session.update({
+						authToken,
+						authTokenExpiration: res.refreshToken.authTokenExpiration,
+					});
+					isAuthenticated = true;
+				} else {
+					await session.clear();
+					user = null;
+				}
+			} catch {
+				await session.clear();
+				user = null;
+			}
+			break;
+		}
+		case "clear":
+			await session.clear();
+			user = null;
+			break;
+		case "anonymous":
+			break;
+	}
+	return next({
+		context: {
+			isAuthenticated,
+			user: isAuthenticated ? user : null,
+			authToken: isAuthenticated ? authToken : "",
+		} satisfies AuthContext,
+	});
+});

package/templates/client/apps/webapp/src/server/cart.ts ADDED Viewed

@@ -0,0 +1,68 @@
+import { createCartHandlers } from "@wp-reactor/commerce";
+import { createServerFn } from "@tanstack/react-start";
+import { cartMiddleware } from "./cartMiddleware";
+// Wrappers serverFn MINCES autour de `createCartHandlers` (Option B). Le timing
+// Woo est injecté depuis l'env de la coque.
+const timing = process.env.WOO_TIMING === "1";
+export const getCart = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.handler(({ context }) => createCartHandlers({ ...context, timing }).getCart());
+export const addCartItem = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.inputValidator(
+		(data: { productId: number; quantity?: number; variationId?: number }) => ({
+			productId: Number(data.productId),
+			quantity: data.quantity != null ? Number(data.quantity) : undefined,
+			variationId:
+				data.variationId != null ? Number(data.variationId) : undefined,
+		}),
+	)
+	.handler(({ context, data }) =>
+		createCartHandlers({ ...context, timing }).addCartItem(data),
+	);
+export const removeCartItems = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.inputValidator((data: { keys: string[] }) => ({
+		keys: data.keys.map((k) => String(k)),
+	}))
+	.handler(({ context, data }) =>
+		createCartHandlers({ ...context, timing }).removeCartItems(data.keys),
+	);
+export const updateCartItemQuantities = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.inputValidator((data: { items: Array<{ key: string; quantity: number }> }) => ({
+		items: data.items.map((i) => ({
+			key: String(i.key),
+			quantity: Number(i.quantity),
+		})),
+	}))
+	.handler(({ context, data }) =>
+		createCartHandlers({ ...context, timing }).updateCartItemQuantities(data.items),
+	);
+export const applyCoupon = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.inputValidator((data: { code: string }) => ({ code: String(data.code) }))
+	.handler(({ context, data }) =>
+		createCartHandlers({ ...context, timing }).applyCoupon(data.code),
+	);
+export const removeCoupons = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.inputValidator((data: { codes: string[] }) => ({
+		codes: data.codes.map((c) => String(c)),
+	}))
+	.handler(({ context, data }) =>
+		createCartHandlers({ ...context, timing }).removeCoupons(data.codes),
+	);
+export const getCheckoutUrl = createServerFn({ method: "POST" })
+	.middleware([cartMiddleware])
+	.handler(({ context }) =>
+		createCartHandlers({ ...context, timing }).getCheckoutUrl(),
+	);

package/templates/client/apps/webapp/src/server/cartMiddleware.ts ADDED Viewed

@@ -0,0 +1,60 @@
+import {
+	normalizeWooSessionToken,
+	WOO_SESSION_COOKIE,
+	WOO_SESSION_MAX_AGE,
+} from "@wp-reactor/commerce";
+import { ssrForwardedHeaders } from "@wp-reactor/headless-core";
+import { createMiddleware } from "@tanstack/react-start";
+import { getCookie, setCookie } from "@tanstack/react-start/server";
+import { GraphQLClient } from "graphql-request";
+import { runtimeEnv } from "../env";
+import { authMiddleware } from "./authMiddleware";
+/**
+ * Coque (Option B) : construit le client GraphQL panier — Bearer si connecté,
+ * sinon token woo-session invité (et réécrit le token roté dans le cookie). Le
+ * contexte est consommé par `createCartHandlers` (@wp-reactor/commerce).
+ */
+export const cartMiddleware = createMiddleware()
+	.middleware([authMiddleware])
+	.server(async ({ next, context }) => {
+		const headers: Record<string, string> = ssrForwardedHeaders(
+			runtimeEnv.wordpressHost,
+		);
+		const isGuest = !context.authToken;
+		const wooSessionToken = isGuest ? getCookie(WOO_SESSION_COOKIE) : null;
+		if (context.authToken) {
+			headers.Authorization = `Bearer ${context.authToken}`;
+		} else if (wooSessionToken) {
+			headers["woocommerce-session"] = `Session ${wooSessionToken}`;
+		}
+		const graphqlClient = new GraphQLClient(runtimeEnv.endpoint, {
+			credentials: "omit",
+			headers,
+			responseMiddleware: (response) => {
+				if (!isGuest) return;
+				if (response instanceof Error) return;
+				const rotated = response.headers?.get?.("woocommerce-session");
+				if (!rotated) return;
+				const normalized = normalizeWooSessionToken(rotated);
+				if (!normalized) return;
+				setCookie(WOO_SESSION_COOKIE, normalized, {
+					httpOnly: true,
+					secure: process.env.NODE_ENV === "production",
+					sameSite: "lax",
+					path: "/",
+					maxAge: WOO_SESSION_MAX_AGE,
+				});
+			},
+		});
+		return next({
+			context: {
+				graphqlClient,
+				isAuthenticated: context.isAuthenticated,
+				hasWooSession: !!wooSessionToken,
+			},
+		});
+	});

package/templates/client/apps/webapp/src/server/session.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import {
+	DEFAULT_SESSION_MAX_AGE,
+	DEFAULT_SESSION_NAME,
+	SESSION_SECRET_MIN_LENGTH,
+	type SessionData,
+} from "@wp-reactor/auth";
+import { useSession } from "@tanstack/react-start/server";
+// I/O de la session scellée — server-only, vit dans la COQUE (Option B, ADR 0001).
+// Le package @wp-reactor/auth fournit le contrat (SessionData) + les constantes.
+function getSessionSecret(): string {
+	const secret = process.env.SESSION_SECRET;
+	if (!secret || secret.length < SESSION_SECRET_MIN_LENGTH) {
+		throw new Error(
+			"[auth] SESSION_SECRET must be set (>= 32 chars). Generate one with `openssl rand -base64 48`.",
+		);
+	}
+	return secret;
+}
+export function useAppSession() {
+	return useSession<SessionData>({
+		password: getSessionSecret(),
+		name: DEFAULT_SESSION_NAME,
+		maxAge: DEFAULT_SESSION_MAX_AGE,
+		cookie: {
+			httpOnly: true,
+			secure: process.env.NODE_ENV === "production",
+			sameSite: "lax",
+			path: "/",
+		},
+	});
+}

package/templates/client/apps/webapp/src/start.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { createCacheControlMiddleware } from "@wp-reactor/headless-core";
+import { createCsrfMiddleware, createStart } from "@tanstack/react-start";
+// Définir un startInstance REMPLACE le defaultCsrfMiddleware injecté par le
+// framework. On le ré-ajoute, sinon les serverFns ne sont plus protégés cross-site.
+// Réf : .reference/namaki/apps/webapp/src/start.ts
+const csrfMiddleware = createCsrfMiddleware({
+	filter: (ctx) => ctx.handlerType === "serverFn",
+});
+// Edge-cache du HTML SSR — factory du kernel, paramétrée par l'env de la coque.
+const cacheControlMiddleware = createCacheControlMiddleware({
+	sharedMaxAge: Number(process.env.HTML_EDGE_MAX_AGE ?? 600),
+	staleWhileRevalidate: Number(process.env.HTML_EDGE_SWR ?? 86_400),
+});
+export const startInstance = createStart(() => ({
+	requestMiddleware: [csrfMiddleware, cacheControlMiddleware],
+}));

package/templates/client/apps/webapp/src/styles.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ @import "tailwindcss";

package/templates/client/apps/webapp/tsconfig.json ADDED Viewed

@@ -0,0 +1,12 @@
+{
+	"extends": "@wp-reactor/config-tsconfig/react-lib.json",
+	"include": ["**/*.ts", "**/*.tsx"],
+	"//": "blocks/ = fichiers éditeur Gutenberg (territoire du thème WP, toolchain @wordpress/*), hors compilation webapp.",
+	"exclude": ["node_modules", "blocks"],
+	"compilerOptions": {
+		"types": ["vite/client", "react", "react-dom"],
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	}
+}

package/templates/client/apps/webapp/vite.config.ts ADDED Viewed

@@ -0,0 +1,49 @@
+import { fileURLToPath, URL } from "node:url";
+import tailwindcss from "@tailwindcss/vite";
+import { tanstackStart } from "@tanstack/react-start/plugin/vite";
+import viteReact from "@vitejs/plugin-react";
+import { nitro } from "nitro/vite";
+import { defineConfig } from "vite";
+// En dev, les packages @wp-reactor/* sont consommés en source via le workspace.
+// Aliases explicites pour les packages présentiels/runtime résolus en `src/index.ts`.
+const pkg = (name: string) =>
+	fileURLToPath(new URL(`../packages/${name}/src/index.ts`, import.meta.url));
+export default defineConfig(({ command }) => ({
+	// Les .env vivent à la racine du repo client (mono-source d'env).
+	envDir: "..",
+	...(command !== "build"
+		? {}
+		: {
+				ssr: {
+					noExternal: true,
+					resolve: {
+						conditions: ["import", "module", "default"],
+					},
+				},
+			}),
+	resolve: {
+		alias: {
+			"@": fileURLToPath(new URL("./src", import.meta.url)),
+			"@wp-reactor/ui": pkg("ui"),
+			"@wp-reactor/headless-core": pkg("headless-core"),
+			"@wp-reactor/editorial": pkg("editorial"),
+			"@wp-reactor/commerce": pkg("commerce"),
+			"@wp-reactor/auth": pkg("auth"),
+		},
+	},
+	server: {
+		allowedHosts: process.env.VITE_ALLOWED_HOST
+			? [process.env.VITE_ALLOWED_HOST]
+			: [],
+		watch: {
+			usePolling: process.env.CHOKIDAR_USEPOLLING === "true",
+			interval: 300,
+		},
+		fs: {
+			allow: [fileURLToPath(new URL("..", import.meta.url))],
+		},
+	},
+	plugins: [nitro(), tailwindcss(), tanstackStart(), viteReact()],
+}));

package/templates/client/apps/webapp/wp-reactor.config.json ADDED Viewed

@@ -0,0 +1,13 @@
+{
+	"namespace": "wp-reactor",
+	"schemasDir": "schemas",
+	"theme": {
+		"blocksDir": "blocks"
+	},
+	"webapp": {
+		"renderersDir": "src/renderers",
+		"registryFile": "src/blocks.tsx",
+		"registryMarker": "// @gen:block:block-registry",
+		"renderersImportBase": "./renderers"
+	}
+}

package/templates/client/apps/wordpress/Dockerfile ADDED Viewed

@@ -0,0 +1,11 @@
+# syntax=docker/dockerfile:1.7
+# Image WordPress client __PROJECT_TITLE__ : part de l'image base du framework
+# (WordPress + thème parent wp-reactor-base + plugin) et overlaye le thème enfant.
+FROM ghcr.io/wp-reactor/wordpress-base:latest
+COPY apps/wordpress/theme-__PROJECT_NAME__ /opt/__PROJECT_NAME__/theme
+COPY apps/wordpress/docker/child-entrypoint.sh /usr/local/bin/__PROJECT_NAME__-entrypoint.sh
+RUN chmod +x /usr/local/bin/__PROJECT_NAME__-entrypoint.sh
+ENTRYPOINT ["__PROJECT_NAME__-entrypoint.sh"]
+CMD ["apache2-foreground"]

package/templates/client/apps/wordpress/docker/child-entrypoint.sh ADDED Viewed

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -euo pipefail
+# Overlay le thème ENFANT baké, puis délègue à l'entrypoint base WP Reactor
+# (qui overlaye le thème parent + plugin et lance WordPress).
+WP_CONTENT="${WP_CONTENT_DIR:-/var/www/html/wp-content}"
+if [ -d /opt/__PROJECT_NAME__/theme ]; then
+	echo "[__PROJECT_NAME__-entrypoint] overlay thème enfant -> $WP_CONTENT/themes/__PROJECT_NAME__"
+	rm -rf "$WP_CONTENT/themes/__PROJECT_NAME__"
+	mkdir -p "$WP_CONTENT/themes"
+	cp -a /opt/__PROJECT_NAME__/theme "$WP_CONTENT/themes/__PROJECT_NAME__"
+	chown -R www-data:www-data "$WP_CONTENT/themes/__PROJECT_NAME__" 2>/dev/null || true
+fi
+exec wp-reactor-entrypoint.sh "$@"

package/templates/client/apps/wordpress/theme-__PROJECT_NAME__/functions.php ADDED Viewed

@@ -0,0 +1,12 @@
+<?php
+// Thème enfant __PROJECT_TITLE__. Le parent wp-reactor-base (image GHCR base)
+// porte la logique commune ; ici : branding + enregistrement des blocs propres.
+if (!defined('ABSPATH')) {
+	exit;
+}
+add_action('wp_enqueue_scripts', function () {
+	wp_enqueue_style('wp-reactor-base', get_template_directory_uri() . '/style.css');
+	wp_enqueue_style('__PROJECT_NAME__', get_stylesheet_uri(), ['wp-reactor-base']);
+});