@wp-typia/project-tools 0.13.4 → 0.15.0

package/templates/_shared/persistence/auth/{{slugKebabCase}}.php.mustache

@@ -197,6 +197,105 @@ function {{phpPrefix}}_build_state_response( $post_id, $resource_key, $count ) {
 	);
 }
 
+function {{phpPrefix}}_block_tree_has_resource_key( $blocks, $block_name, $resource_key ) {
+	if ( ! is_array( $blocks ) ) {
+		return false;
+	}
+
+	foreach ( $blocks as $block ) {
+		if ( ! is_array( $block ) ) {
+			continue;
+		}
+
+		if ( (string) ( $block['blockName'] ?? '' ) === $block_name ) {
+			$attributes = isset( $block['attrs'] ) && is_array( $block['attrs'] ) ? $block['attrs'] : array();
+			$candidate_resource_key = array_key_exists( 'resourceKey', $attributes )
+				? (string) $attributes['resourceKey']
+				: 'primary';
+			if ( (string) $resource_key === $candidate_resource_key ) {
+				return true;
+			}
+		}
+
+		if (
+			isset( $block['innerBlocks'] ) &&
+			{{phpPrefix}}_block_tree_has_resource_key( $block['innerBlocks'], $block_name, $resource_key )
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function {{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ) {
+	return 'wpt_pri_' . md5( implode( '|', array( (string) $block_name, (int) $post_id, (string) $resource_key ) ) );
+}
+
+function {{phpPrefix}}_record_rendered_block_instance( $post_id, $block_name, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key || '' === (string) $block_name ) {
+		return;
+	}
+
+	set_transient(
+		{{phpPrefix}}_get_rendered_block_instance_key( $post_id, $block_name, $resource_key ),
+		1,
+		5 * MINUTE_IN_SECONDS
+	);
+}
+
+function {{phpPrefix}}_has_rendered_block_instance( $post_id, $resource_key ) {
+	if ( $post_id <= 0 || '' === (string) $resource_key ) {
+		return false;
+	}
+
+	if (
+		false !== get_transient(
+			{{phpPrefix}}_get_rendered_block_instance_key(
+				$post_id,
+				'{{namespace}}/{{slugKebabCase}}',
+				$resource_key
+			)
+		)
+	) {
+		return true;
+	}
+
+	$post = get_post( $post_id );
+	if ( ! ( $post instanceof WP_Post ) ) {
+		return false;
+	}
+
+	return {{phpPrefix}}_block_tree_has_resource_key(
+		parse_blocks( (string) $post->post_content ),
+		'{{namespace}}/{{slugKebabCase}}',
+		(string) $resource_key
+	);
+}
+
+function {{phpPrefix}}_build_bootstrap_response( $post_id, $resource_key ) {
+	$post          = get_post( $post_id );
+	$can_read_post =
+		$post instanceof WP_Post &&
+		(
+			is_post_publicly_viewable( $post ) ||
+			current_user_can( 'read_post', $post->ID )
+		);
+	$can_write = $post_id > 0 &&
+		is_user_logged_in() &&
+		$can_read_post &&
+		{{phpPrefix}}_has_rendered_block_instance( (int) $post_id, (string) $resource_key );
+	$response  = array(
+		'canWrite' => $can_write,
+	);
+
+	if ( $can_write ) {
+		$response['restNonce'] = wp_create_nonce( 'wp_rest' );
+	}
+
+	return $response;
+}
+
 // Route handlers are the main product-level extension point for request/response shaping.
 function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
@@ -223,6 +322,34 @@ function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
 	);
 }
 
+function {{phpPrefix}}_handle_get_bootstrap( WP_REST_Request $request ) {
+	$payload = {{phpPrefix}}_validate_and_sanitize_request(
+		array(
+			'postId'      => $request->get_param( 'postId' ),
+			'resourceKey' => $request->get_param( 'resourceKey' ),
+		),
+		{{phpPrefix}}_get_rest_build_dir(),
+		'bootstrap-query',
+		'query'
+	);
+
+	if ( is_wp_error( $payload ) ) {
+		return $payload;
+	}
+
+	$response = rest_ensure_response(
+		{{phpPrefix}}_build_bootstrap_response(
+			(int) $payload['postId'],
+			(string) $payload['resourceKey']
+		)
+	);
+
+	$response->header( 'Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, s-maxage=0' );
+	$response->header( 'Pragma', 'no-cache' );
+	$response->header( 'Vary', 'Cookie' );
+	return $response;
+}
+
 function {{phpPrefix}}_handle_write_state( WP_REST_Request $request ) {
 	$payload = {{phpPrefix}}_validate_and_sanitize_request(
 		$request->get_json_params(),
@@ -272,6 +399,18 @@ function {{phpPrefix}}_register_routes() {
 			),
 		)
 	);
+
+	register_rest_route(
+		'{{namespace}}/v1',
+		'/{{slugKebabCase}}/bootstrap',
+		array(
+			array(
+				'methods'             => WP_REST_Server::READABLE,
+				'callback'            => '{{phpPrefix}}_handle_get_bootstrap',
+				'permission_callback' => '__return_true',
+			),
+		)
+	);
 }
 
 function {{phpPrefix}}_register_block() {

package/templates/_shared/persistence/core/scripts/sync-rest-contracts.ts.mustache

@@ -28,9 +28,15 @@ const REST_ENDPOINT_MANIFEST = defineEndpointManifest( {
 		'state-query': {
 			sourceTypeName: '{{pascalCase}}StateQuery',
 		},
+		'bootstrap-query': {
+			sourceTypeName: '{{pascalCase}}BootstrapQuery',
+		},
 		'write-state-request': {
 			sourceTypeName: '{{pascalCase}}WriteStateRequest',
 		},
+		'bootstrap-response': {
+			sourceTypeName: '{{pascalCase}}BootstrapResponse',
+		},
 		'state-response': {
 			sourceTypeName: '{{pascalCase}}StateResponse',
 		},
@@ -59,6 +65,16 @@ const REST_ENDPOINT_MANIFEST = defineEndpointManifest( {
 				mechanism: '{{restWriteAuthMechanism}}',
 			},
 		},
+		{
+			auth: 'public',
+			method: 'GET',
+			operationId: 'get{{pascalCase}}Bootstrap',
+			path: '/{{namespace}}/v1/{{slugKebabCase}}/bootstrap',
+			queryContract: 'bootstrap-query',
+			responseContract: 'bootstrap-response',
+			summary: 'Read fresh session bootstrap state for the current viewer.',
+			tags: [ '{{title}}' ],
+		},
 	],
 	info: {
 		title: '{{title}} REST API',

package/templates/_shared/persistence/core/src/api-types.ts.mustache

@@ -5,6 +5,11 @@ export interface {{pascalCase}}StateQuery {
 	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
 }
 
+export interface {{pascalCase}}BootstrapQuery {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+}
+
 export interface {{pascalCase}}WriteStateRequest {
 	postId: number & tags.Type< 'uint32' >;
 	{{publicWriteRequestIdDeclaration}}
@@ -13,6 +18,11 @@ export interface {{pascalCase}}WriteStateRequest {
 	delta?: number & tags.Minimum< 1 > & tags.Type< 'uint32' > & tags.Default< 1 >;
 }
 
+export interface {{pascalCase}}BootstrapResponse {
+	canWrite: boolean;
+	{{bootstrapCredentialDeclarations}}
+}
+
 export interface {{pascalCase}}StateResponse {
 	postId: number & tags.Type< 'uint32' >;
 	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;

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

@@ -1,68 +1,81 @@
 import {
 	callEndpoint,
-	resolveRestRouteUrl,
 } from '@wp-typia/rest';
 
 import {
+	type {{pascalCase}}BootstrapQuery,
 	type {{pascalCase}}StateQuery,
 	type {{pascalCase}}WriteStateRequest,
 } from './api-types';
 import {
+	get{{pascalCase}}BootstrapEndpoint,
 	get{{pascalCase}}StateEndpoint,
 	write{{pascalCase}}StateEndpoint,
 } from './api-client';
+import {
+	resolveTransportCallOptions,
+	type PersistenceTransportOptions,
+} from './transport';
 
-export function resolveRestNonce( fallback?: string ): string | undefined {
-	if ( typeof fallback === 'string' && fallback.length > 0 ) {
-		return fallback;
-	}
-
-	if ( typeof window === 'undefined' ) {
-		return undefined;
-	}
-
-	const wpApiSettings = ( window as typeof window & {
-		wpApiSettings?: { nonce?: string };
-	} ).wpApiSettings;
-
-	return typeof wpApiSettings?.nonce === 'string' && wpApiSettings.nonce.length > 0
-		? wpApiSettings.nonce
-		: undefined;
-}
+export const bootstrapEndpoint = {
+	...get{{pascalCase}}BootstrapEndpoint,
+};
 
 export const stateEndpoint = {
 	...get{{pascalCase}}StateEndpoint,
-	buildRequestOptions: () => ( {
-		url: resolveRestRouteUrl( get{{pascalCase}}StateEndpoint.path ),
-	} ),
 };
 
 export const writeStateEndpoint = {
 	...write{{pascalCase}}StateEndpoint,
-	buildRequestOptions: () => ( {
-		url: resolveRestRouteUrl( write{{pascalCase}}StateEndpoint.path ),
-	} ),
 };
 
 export function fetchState(
-	request: {{pascalCase}}StateQuery
+	request: {{pascalCase}}StateQuery,
+	options: PersistenceTransportOptions = {}
 ) {
-	return callEndpoint( stateEndpoint, request );
+	return callEndpoint(
+		stateEndpoint,
+		request,
+		resolveTransportCallOptions(
+			options.transportTarget ?? 'frontend',
+			'read',
+			stateEndpoint,
+			request,
+			options
+		)
+	);
+}
+
+export function fetchBootstrap(
+	request: {{pascalCase}}BootstrapQuery,
+	options: PersistenceTransportOptions = {}
+) {
+	return callEndpoint(
+		bootstrapEndpoint,
+		request,
+		resolveTransportCallOptions(
+			options.transportTarget ?? 'frontend',
+			'read',
+			bootstrapEndpoint,
+			request,
+			options
+		)
+	);
 }
 
 export function writeState(
 	request: {{pascalCase}}WriteStateRequest,
-	restNonce?: string
+	options: PersistenceTransportOptions = {}
 ) {
-	const nonce = resolveRestNonce( restNonce );
-
-	return callEndpoint( writeStateEndpoint, request, {
-		requestOptions: nonce
-			? {
-					headers: {
-						'X-WP-Nonce': nonce,
-					},
-				}
-			: undefined,
-	} );
+	return callEndpoint(
+		writeStateEndpoint,
+		request,
+		resolveTransportCallOptions(
+			options.transportTarget ?? 'frontend',
+			'write',
+			writeStateEndpoint,
+			request,
+			options
+		)
+	);
 }

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

@@ -6,31 +6,21 @@ import {
 } from '@wp-typia/rest/react';
 
 import type {
+	{{pascalCase}}BootstrapQuery,
+	{{pascalCase}}BootstrapResponse,
 	{{pascalCase}}StateQuery,
 	{{pascalCase}}StateResponse,
 	{{pascalCase}}WriteStateRequest,
 } from './api-types';
 import {
-	resolveRestNonce,
+	bootstrapEndpoint,
 	stateEndpoint,
 	writeStateEndpoint,
 } from './api';
-
-{{#isAuthenticatedPersistencePolicy}}
-function buildWriteCallOptions( restNonce?: string ) {
-	const nonce = resolveRestNonce( restNonce );
-
-	return nonce
-		? {
-				requestOptions: {
-					headers: {
-						'X-WP-Nonce': nonce,
-					},
-				},
-			}
-		: undefined;
-}
-{{/isAuthenticatedPersistencePolicy}}
+import {
+	resolveTransportCallOptions,
+	type PersistenceTransportTarget,
+} from './transport';
 
 interface WriteStateMutationContext< Context > {
 	previous:
@@ -49,9 +39,22 @@ export interface Use{{pascalCase}}StateQueryOptions<
 	>,
 	'resolveCallOptions'
 > {
-	{{#isAuthenticatedPersistencePolicy}}
 	restNonce?: string;
-	{{/isAuthenticatedPersistencePolicy}}
+	transportTarget?: PersistenceTransportTarget;
+}
+
+export interface Use{{pascalCase}}BootstrapQueryOptions<
+	Selected = {{pascalCase}}BootstrapResponse,
+> extends Omit<
+	UseEndpointQueryOptions<
+		{{pascalCase}}BootstrapQuery,
+		{{pascalCase}}BootstrapResponse,
+		Selected
+	>,
+	'resolveCallOptions'
+> {
+	restNonce?: string;
+	transportTarget?: PersistenceTransportTarget;
 }
 
 export interface UseWrite{{pascalCase}}StateMutationOptions<
@@ -62,7 +65,7 @@ export interface UseWrite{{pascalCase}}StateMutationOptions<
 		{{pascalCase}}StateResponse,
 		WriteStateMutationContext< Context >
 	>,
-	'invalidate' | 'onError' | 'onMutate'{{#isAuthenticatedPersistencePolicy}} | 'resolveCallOptions'{{/isAuthenticatedPersistencePolicy}}
+	'invalidate' | 'onError' | 'onMutate' | 'resolveCallOptions'
 > {
 	onError?: (
 		error: unknown,
@@ -74,9 +77,8 @@ export interface UseWrite{{pascalCase}}StateMutationOptions<
 		request: {{pascalCase}}WriteStateRequest,
 		client: import('@wp-typia/rest/react').EndpointDataClient
 	) => Context | Promise<Context>;
-	{{#isAuthenticatedPersistencePolicy}}
 	restNonce?: string;
-	{{/isAuthenticatedPersistencePolicy}}
+	transportTarget?: PersistenceTransportTarget;
 }
 
 export function use{{pascalCase}}StateQuery<
@@ -85,20 +87,54 @@ export function use{{pascalCase}}StateQuery<
 	request: {{pascalCase}}StateQuery,
 	options: Use{{pascalCase}}StateQueryOptions< Selected > = {}
 ) {
-	{{#isAuthenticatedPersistencePolicy}}
 	const {
 		restNonce,
+		transportTarget = 'editor',
 		...queryOptions
 	} = options;
 
 	return useEndpointQuery( stateEndpoint, request, {
 		...queryOptions,
-		resolveCallOptions: () => buildWriteCallOptions( restNonce ),
+		resolveCallOptions: () =>
+			resolveTransportCallOptions(
+				transportTarget,
+				'read',
+				stateEndpoint,
+				request,
+				{
+					restNonce,
+					transportTarget,
+				}
+			),
+	} );
+}
+
+export function use{{pascalCase}}BootstrapQuery<
+	Selected = {{pascalCase}}BootstrapResponse,
+>(
+	request: {{pascalCase}}BootstrapQuery,
+	options: Use{{pascalCase}}BootstrapQueryOptions< Selected > = {}
+) {
+	const {
+		restNonce,
+		transportTarget = 'editor',
+		...queryOptions
+	} = options;
+
+	return useEndpointQuery( bootstrapEndpoint, request, {
+		...queryOptions,
+		resolveCallOptions: () =>
+			resolveTransportCallOptions(
+				transportTarget,
+				'read',
+				bootstrapEndpoint,
+				request,
+				{
+					restNonce,
+					transportTarget,
+				}
+			),
 	} );
-	{{/isAuthenticatedPersistencePolicy}}
-	{{^isAuthenticatedPersistencePolicy}}
-	return useEndpointQuery( stateEndpoint, request, options );
-	{{/isAuthenticatedPersistencePolicy}}
 }
 
 export function useWrite{{pascalCase}}StateMutation<
@@ -109,9 +145,8 @@ export function useWrite{{pascalCase}}StateMutation<
 	const {
 		onError,
 		onMutate,
-		{{#isAuthenticatedPersistencePolicy}}
 		restNonce,
-		{{/isAuthenticatedPersistencePolicy}}
+		transportTarget = 'editor',
 		...mutationOptions
 	} = options;
 
@@ -185,8 +220,16 @@ export function useWrite{{pascalCase}}StateMutation<
 				userContext,
 			};
 		},
-		{{#isAuthenticatedPersistencePolicy}}
-		resolveCallOptions: () => buildWriteCallOptions( restNonce ),
-		{{/isAuthenticatedPersistencePolicy}}
+		resolveCallOptions: ( request ) =>
+			resolveTransportCallOptions(
+				transportTarget,
+				'write',
+				writeStateEndpoint,
+				request,
+				{
+					restNonce,
+					transportTarget,
+				}
+			),
 	} );
 }