@wp-typia/project-tools 0.11.1

package/templates/_shared/persistence/core/src/data.ts.mustache

@@ -0,0 +1,192 @@
+import {
+	useEndpointMutation,
+	useEndpointQuery,
+	type UseEndpointMutationOptions,
+	type UseEndpointQueryOptions,
+} from '@wp-typia/rest/react';
+
+import type {
+	{{pascalCase}}StateQuery,
+	{{pascalCase}}StateResponse,
+	{{pascalCase}}WriteStateRequest,
+} from './api-types';
+import {
+	resolveRestNonce,
+	stateEndpoint,
+	writeStateEndpoint,
+} from './api';
+
+{{#isAuthenticatedPersistencePolicy}}
+function buildWriteCallOptions( restNonce?: string ) {
+	const nonce = resolveRestNonce( restNonce );
+
+	return nonce
+		? {
+				requestOptions: {
+					headers: {
+						'X-WP-Nonce': nonce,
+					},
+				},
+			}
+		: undefined;
+}
+{{/isAuthenticatedPersistencePolicy}}
+
+interface WriteStateMutationContext< Context > {
+	previous:
+		| {{pascalCase}}StateResponse
+		| undefined;
+	userContext: Context | undefined;
+}
+
+export interface Use{{pascalCase}}StateQueryOptions<
+	Selected = {{pascalCase}}StateResponse,
+> extends Omit<
+	UseEndpointQueryOptions<
+		{{pascalCase}}StateQuery,
+		{{pascalCase}}StateResponse,
+		Selected
+	>,
+	'resolveCallOptions'
+> {
+	{{#isAuthenticatedPersistencePolicy}}
+	restNonce?: string;
+	{{/isAuthenticatedPersistencePolicy}}
+}
+
+export interface UseWrite{{pascalCase}}StateMutationOptions<
+	Context = unknown,
+> extends Omit<
+	UseEndpointMutationOptions<
+		{{pascalCase}}WriteStateRequest,
+		{{pascalCase}}StateResponse,
+		WriteStateMutationContext< Context >
+	>,
+	'invalidate' | 'onError' | 'onMutate'{{#isAuthenticatedPersistencePolicy}} | 'resolveCallOptions'{{/isAuthenticatedPersistencePolicy}}
+> {
+	onError?: (
+		error: unknown,
+		request: {{pascalCase}}WriteStateRequest,
+		client: import('@wp-typia/rest/react').EndpointDataClient,
+		context: Context | undefined
+	) => void | Promise<void>;
+	onMutate?: (
+		request: {{pascalCase}}WriteStateRequest,
+		client: import('@wp-typia/rest/react').EndpointDataClient
+	) => Context | Promise<Context>;
+	{{#isAuthenticatedPersistencePolicy}}
+	restNonce?: string;
+	{{/isAuthenticatedPersistencePolicy}}
+}
+
+export function use{{pascalCase}}StateQuery<
+	Selected = {{pascalCase}}StateResponse,
+>(
+	request: {{pascalCase}}StateQuery,
+	options: Use{{pascalCase}}StateQueryOptions< Selected > = {}
+) {
+	{{#isAuthenticatedPersistencePolicy}}
+	const {
+		restNonce,
+		...queryOptions
+	} = options;
+
+	return useEndpointQuery( stateEndpoint, request, {
+		...queryOptions,
+		resolveCallOptions: () => buildWriteCallOptions( restNonce ),
+	} );
+	{{/isAuthenticatedPersistencePolicy}}
+	{{^isAuthenticatedPersistencePolicy}}
+	return useEndpointQuery( stateEndpoint, request, options );
+	{{/isAuthenticatedPersistencePolicy}}
+}
+
+export function useWrite{{pascalCase}}StateMutation<
+	Context = unknown,
+>(
+	options: UseWrite{{pascalCase}}StateMutationOptions< Context > = {}
+) {
+	const {
+		onError,
+		onMutate,
+		{{#isAuthenticatedPersistencePolicy}}
+		restNonce,
+		{{/isAuthenticatedPersistencePolicy}}
+		...mutationOptions
+	} = options;
+
+	return useEndpointMutation( writeStateEndpoint, {
+		...mutationOptions,
+		invalidate: ( _data, request ) => ( {
+			endpoint: stateEndpoint,
+			request: {
+				postId: request.postId,
+				resourceKey: request.resourceKey,
+			},
+		} ),
+		onError: async ( error, request, client, context ) => {
+			if ( context?.previous ) {
+				client.setData(
+					stateEndpoint,
+					{
+						postId: request.postId,
+						resourceKey: request.resourceKey,
+					},
+					context.previous
+				);
+			}
+
+			await onError?.( error, request, client, context?.userContext );
+		},
+		onMutate: async ( request, client ) => {
+			const queryRequest = {
+				postId: request.postId,
+				resourceKey: request.resourceKey,
+			} satisfies {{pascalCase}}StateQuery;
+			const previous = client.getData(
+				stateEndpoint,
+				queryRequest
+			);
+
+			if ( previous !== undefined ) {
+				client.setData(
+					stateEndpoint,
+					queryRequest,
+					( current ) => {
+						if ( ! current ) {
+							return current;
+						}
+
+						return {
+							...current,
+							count: Math.max(
+								0,
+								current.count + ( request.delta ?? 1 )
+							),
+						};
+					}
+				);
+			}
+
+			let userContext: Context | undefined;
+			try {
+				userContext = onMutate
+					? await onMutate( request, client )
+					: undefined;
+			} catch ( error ) {
+				if ( previous !== undefined ) {
+					client.setData( stateEndpoint, queryRequest, previous );
+				}
+				throw error;
+			}
+
+			return {
+				previous,
+				userContext,
+			};
+		},
+		{{#isAuthenticatedPersistencePolicy}}
+		resolveCallOptions: () => buildWriteCallOptions( restNonce ),
+		{{/isAuthenticatedPersistencePolicy}}
+	} );
+}

package/templates/_shared/persistence/core/src/index.tsx.mustache

@@ -0,0 +1,25 @@
+import { registerBlockType } from '@wordpress/blocks';
+import type { BlockConfiguration } from '@wordpress/blocks';
+import {
+	buildScaffoldBlockRegistration,
+	type ScaffoldBlockMetadata,
+} from '@wp-typia/block-runtime/blocks';
+
+import Edit from './edit';
+import Save from './save';
+import metadata from './block.json';
+import './style.scss';
+
+import type { {{pascalCase}}Attributes } from './types';
+
+const registration = buildScaffoldBlockRegistration<
+	BlockConfiguration< {{pascalCase}}Attributes >
+>( metadata as ScaffoldBlockMetadata, {
+	edit: Edit,
+	save: Save,
+} );
+
+registerBlockType< {{pascalCase}}Attributes >(
+	registration.name,
+	registration.settings
+);

package/templates/_shared/persistence/core/src/interactivity.ts.mustache

@@ -0,0 +1,134 @@
+import { getContext, store } from '@wordpress/interactivity';
+import { generatePublicWriteRequestId } from '@wp-typia/block-runtime/identifiers';
+
+import { fetchState, writeState } from './api';
+import type { {{pascalCase}}Context, {{pascalCase}}State } from './types';
+
+function hasExpiredPublicWriteToken(
+	context: {{pascalCase}}Context
+): boolean {
+	return (
+		context.persistencePolicy === 'public' &&
+		typeof context.publicWriteExpiresAt === 'number' &&
+		context.publicWriteExpiresAt > 0 &&
+		Date.now() >= context.publicWriteExpiresAt * 1000
+	);
+}
+
+function getWriteBlockedMessage(
+	context: {{pascalCase}}Context
+): string {
+	return context.persistencePolicy === 'authenticated'
+		? 'Sign in to persist this counter.'
+		: 'Reload the page to refresh this write token.';
+}
+
+const { actions, state } = store( '{{slugKebabCase}}', {
+	state: {
+		canWrite: false,
+		count: 0,
+		error: undefined,
+		isHydrated: false,
+		isLoading: false,
+		isSaving: false,
+		isVisible: true,
+	} as {{pascalCase}}State,
+
+	actions: {
+		async loadCounter() {
+			const context = getContext< {{pascalCase}}Context >();
+			if ( context.postId <= 0 || ! context.resourceKey ) {
+				return;
+			}
+
+			state.isLoading = true;
+			state.error = undefined;
+
+			try {
+				const result = await fetchState( {
+					postId: context.postId,
+					resourceKey: context.resourceKey,
+				} );
+				if ( ! result.isValid || ! result.data ) {
+					state.error = result.errors[ 0 ]?.expected ?? 'Unable to load counter';
+					return;
+				}
+				context.count = result.data.count;
+				context.storage = result.data.storage;
+				state.count = result.data.count;
+			} catch ( error ) {
+				state.error =
+					error instanceof Error ? error.message : 'Unknown loading error';
+			} finally {
+				state.isLoading = false;
+			}
+		},
+		async increment() {
+			const context = getContext< {{pascalCase}}Context >();
+			if ( context.postId <= 0 || ! context.resourceKey ) {
+				return;
+			}
+			if ( hasExpiredPublicWriteToken( context ) ) {
+				context.canWrite = false;
+				state.canWrite = false;
+				state.error = getWriteBlockedMessage( context );
+				return;
+			}
+			if ( ! context.canWrite || ! state.canWrite ) {
+				state.error = getWriteBlockedMessage( context );
+				return;
+			}
+
+			state.isSaving = true;
+			state.error = undefined;
+
+			try {
+				const result = await writeState( {
+					delta: 1,
+					postId: context.postId,
+					publicWriteRequestId:
+						context.persistencePolicy === 'public'
+							? generatePublicWriteRequestId()
+							: undefined,
+					publicWriteToken:
+						context.persistencePolicy === 'public' &&
+						typeof context.publicWriteToken === 'string' &&
+						context.publicWriteToken.length > 0
+							? context.publicWriteToken
+							: undefined,
+					resourceKey: context.resourceKey,
+				}, context.restNonce );
+				if ( ! result.isValid || ! result.data ) {
+					state.error = result.errors[ 0 ]?.expected ?? 'Unable to update counter';
+					return;
+				}
+				context.count = result.data.count;
+				context.storage = result.data.storage;
+				state.count = result.data.count;
+			} catch ( error ) {
+				state.error =
+					error instanceof Error ? error.message : 'Unknown update error';
+			} finally {
+				state.isSaving = false;
+			}
+		},
+	},
+
+	callbacks: {
+		init() {
+			const context = getContext< {{pascalCase}}Context >();
+			context.canWrite =
+				context.canWrite && ! hasExpiredPublicWriteToken( context );
+			state.canWrite = context.canWrite;
+			state.isVisible = context.isVisible;
+			state.count = context.count;
+		},
+		mounted() {
+			state.isHydrated = true;
+			if ( typeof document !== 'undefined' ) {
+				document.documentElement.dataset[ '{{slugCamelCase}}Hydrated' ] = 'true';
+			}
+			void actions.loadCounter();
+		},
+	},
+} );

package/templates/_shared/persistence/core/src/save.tsx.mustache

@@ -0,0 +1,5 @@
+export default function Save() {
+	// This block is intentionally server-rendered. PHP bootstraps post context,
+	// storage-backed state, and write-policy data before the frontend hydrates.
+	return null;
+}

package/templates/_shared/persistence/core/src/validators.ts.mustache

@@ -0,0 +1,32 @@
+import currentManifest from './typia.manifest.json';
+import type {
+	{{pascalCase}}Attributes,
+	{{pascalCase}}ValidationResult,
+} from './types';
+import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
+import { createTemplateValidatorToolkit } from './validator-toolkit';
+
+const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	manifest: currentManifest,
+	finalize: ( normalized ) => ( {
+		...normalized,
+		resourceKey:
+			normalized.resourceKey && normalized.resourceKey.length > 0
+				? normalized.resourceKey
+				: generateResourceKey( '{{slugKebabCase}}' ),
+	} ),
+} );
+
+export const validators = scaffoldValidators.validators;
+
+export const validate{{pascalCase}}Attributes =
+	scaffoldValidators.validateAttributes as (
+		attributes: unknown
+	) => {{pascalCase}}ValidationResult;
+
+export const sanitize{{pascalCase}}Attributes =
+	scaffoldValidators.sanitizeAttributes as (
+		attributes: Partial< {{pascalCase}}Attributes >
+	) => {{pascalCase}}Attributes;
+
+export const createAttributeUpdater = scaffoldValidators.createAttributeUpdater;