@wp-typia/create-workspace-template 0.13.1 → 0.15.0

package/README.md.mustache

@@ -25,11 +25,13 @@ Variations and patterns can also be added after the first block exists:
 ```bash
 wp-typia add variation hero-card --block counter-card
 wp-typia add pattern hero-layout
+wp-typia add rest-resource snapshots --namespace {{namespace}}/v1 --methods list,read,create
 ```
 
 ## Development
 
 ```bash
+bun run sync
 bun run build
 bun run typecheck
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/create-workspace-template",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "description": "Official empty wp-typia workspace template package",
   "packageManager": "bun@1.3.11",
   "type": "module",

package/package.json.mustache

@@ -6,12 +6,13 @@
   "author": "{{author}}",
   "license": "GPL-2.0-or-later",
   "scripts": {
+    "sync": "tsx scripts/sync-project.ts",
     "sync-types": "tsx scripts/sync-types-to-block-json.ts",
     "sync-rest": "tsx scripts/sync-rest-contracts.ts",
-    "build": "bun run sync-types --check && bun run sync-rest --check && node scripts/build-workspace.mjs build",
-    "start": "bun run sync-types && bun run sync-rest && node scripts/build-workspace.mjs start",
+    "build": "bun run sync --check && node scripts/build-workspace.mjs build",
+    "start": "bun run sync && node scripts/build-workspace.mjs start",
     "dev": "bun run start",
-    "typecheck": "bun run sync-types --check && bun run sync-rest --check && tsc --noEmit",
+    "typecheck": "bun run sync --check && tsc --noEmit",
     "lint:js": "wp-scripts lint-js",
     "lint:css": "wp-scripts lint-style",
     "lint": "bun run lint:js && bun run lint:css",
@@ -46,8 +47,10 @@
     "@wordpress/block-editor": "^15.2.0",
     "@wordpress/blocks": "^15.2.0",
     "@wordpress/components": "^30.2.0",
+    "@wordpress/editor": "^14.44.0",
     "@wordpress/element": "^6.29.0",
     "@wordpress/i18n": "^6.2.0",
-    "@wordpress/interactivity": "^6.29.0"
+    "@wordpress/interactivity": "^6.29.0",
+    "@wordpress/plugins": "^7.44.0"
   }
 }

package/scripts/block-config.ts.mustache

@@ -26,6 +26,28 @@ export interface WorkspaceBindingSourceConfig {
 	slug: string;
 }
 
+export interface WorkspaceRestResourceConfig {
+	apiFile: string;
+	clientFile: string;
+	dataFile: string;
+	methods: Array< 'list' | 'read' | 'create' | 'update' | 'delete' >;
+	namespace: string;
+	openApiFile: string;
+	phpFile: string;
+	restManifest?: ReturnType<
+		typeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+	>;
+	slug: string;
+	typesFile: string;
+	validatorsFile: string;
+}
+
+export interface WorkspaceEditorPluginConfig {
+	file: string;
+	slug: string;
+	slot: string;
+}
+
 export const BLOCKS: WorkspaceBlockConfig[] = [
 	// wp-typia add block entries
 ];
@@ -41,3 +63,11 @@ export const PATTERNS: WorkspacePatternConfig[] = [
 export const BINDING_SOURCES: WorkspaceBindingSourceConfig[] = [
 	// wp-typia add binding-source entries
 ];
+
+export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
+	// wp-typia add rest-resource entries
+];
+
+export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
+	// wp-typia add editor-plugin entries
+];

package/scripts/build-workspace.mjs.mustache

@@ -22,7 +22,12 @@ function getBlockSlugs() {
 }
 
 function hasSharedEditorEntries() {
-	for ( const relativePath of [ 'src/bindings/index.ts', 'src/bindings/index.js' ] ) {
+	for ( const relativePath of [
+		'src/bindings/index.ts',
+		'src/bindings/index.js',
+		'src/editor-plugins/index.ts',
+		'src/editor-plugins/index.js',
+	] ) {
 		if ( fs.existsSync( path.join( process.cwd(), relativePath ) ) ) {
 			return true;
 		}

package/scripts/sync-project.ts.mustache

@@ -0,0 +1,103 @@
+/* eslint-disable no-console */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+interface SyncCliOptions {
+	check: boolean;
+}
+
+function parseCliOptions( argv: string[] ): SyncCliOptions {
+	const options: SyncCliOptions = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( `Unknown sync flag: ${ argument }` );
+	}
+
+	return options;
+}
+
+function getSyncScriptEnv() {
+	const binaryDirectory = path.join( process.cwd(), 'node_modules', '.bin' );
+	const inheritedPath =
+		process.env.PATH ??
+		process.env.Path ??
+		Object.entries( process.env ).find(
+			( [ key ] ) => key.toLowerCase() === 'path'
+		)?.[ 1 ] ??
+		'';
+	const nextPath = fs.existsSync( binaryDirectory )
+		? `${ binaryDirectory }${ path.delimiter }${ inheritedPath }`
+		: inheritedPath;
+	const env: NodeJS.ProcessEnv = {
+		...process.env,
+	};
+
+	for ( const key of Object.keys( env ) ) {
+		if ( key.toLowerCase() === 'path' ) {
+			delete env[ key ];
+		}
+	}
+
+	env.PATH = nextPath;
+
+	return env;
+}
+
+function runSyncScript( scriptPath: string, options: SyncCliOptions ) {
+	const args = [ scriptPath ];
+	if ( options.check ) {
+		args.push( '--check' );
+	}
+
+	const result = spawnSync( 'tsx', args, {
+		cwd: process.cwd(),
+		env: getSyncScriptEnv(),
+		shell: process.platform === 'win32',
+		stdio: 'inherit',
+	} );
+
+	if ( result.error ) {
+		if ( ( result.error as NodeJS.ErrnoException ).code === 'ENOENT' ) {
+			throw new Error(
+				'Unable to resolve `tsx` for project sync. Install project dependencies or rerun the command through your package manager.'
+			);
+		}
+
+		throw result.error;
+	}
+
+	if ( result.status !== 0 ) {
+		throw new Error( `Sync script failed: ${ scriptPath }` );
+	}
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const syncTypesScriptPath = path.join( 'scripts', 'sync-types-to-block-json.ts' );
+	const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );
+
+	runSyncScript( syncTypesScriptPath, options );
+
+	if ( fs.existsSync( path.resolve( process.cwd(), syncRestScriptPath ) ) ) {
+		runSyncScript( syncRestScriptPath, options );
+	}
+
+	console.log(
+		options.check
+			? '✅ Generated project metadata and REST artifacts are already synchronized.'
+			: '✅ Generated project metadata and REST artifacts were synchronized.'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '❌ Project sync failed:', error );
+	process.exit( 1 );
+} );

package/scripts/sync-rest-contracts.ts.mustache

@@ -2,12 +2,18 @@
 import path from 'node:path';
 
 import {
+	runSyncBlockMetadata,
 	syncEndpointClient,
 	syncRestOpenApi,
 	syncTypeSchemas,
 } from '@wp-typia/block-runtime/metadata-core';
 
-import { BLOCKS, type WorkspaceBlockConfig } from './block-config';
+import {
+	BLOCKS,
+	REST_RESOURCES,
+	type WorkspaceBlockConfig,
+	type WorkspaceRestResourceConfig,
+} from './block-config';
 
 function parseCliOptions( argv: string[] ) {
 	const options = {
@@ -41,20 +47,70 @@ function isRestEnabledBlock(
 	);
 }
 
+function isWorkspaceRestResource(
+	resource: WorkspaceRestResourceConfig
+): resource is WorkspaceRestResourceConfig & {
+	clientFile: string;
+	openApiFile: string;
+	restManifest: NonNullable< WorkspaceRestResourceConfig[ 'restManifest' ] >;
+	typesFile: string;
+	validatorsFile: string;
+} {
+	return (
+		typeof resource.clientFile === 'string' &&
+		typeof resource.openApiFile === 'string' &&
+		typeof resource.typesFile === 'string' &&
+		typeof resource.validatorsFile === 'string' &&
+		typeof resource.restManifest === 'object' &&
+		resource.restManifest !== null
+	);
+}
+
+async function assertTypeArtifactsCurrent( block: WorkspaceBlockConfig ) {
+	const report = await runSyncBlockMetadata(
+		{
+			blockJsonFile: path.join( 'src', 'blocks', block.slug, 'block.json' ),
+			jsonSchemaFile: path.join( 'src', 'blocks', block.slug, 'typia.schema.json' ),
+			manifestFile: path.join( 'src', 'blocks', block.slug, 'typia.manifest.json' ),
+			openApiFile: path.join( 'src', 'blocks', block.slug, 'typia.openapi.json' ),
+			sourceTypeName: block.attributeTypeName,
+			typesFile: block.typesFile,
+		},
+		{
+			check: true,
+		}
+	);
+
+	if ( report.failure?.code === 'stale-generated-artifact' ) {
+		throw new Error(
+			`${ block.slug }: ${ report.failure.message }\nRun \`sync\` or \`sync-types\` first to refresh type-derived artifacts before rerunning \`sync-rest\`.`
+		);
+	}
+
+	if ( report.failure ) {
+		throw new Error(
+			`${ block.slug }: type-derived artifact preflight failed before sync-rest.\n${ report.failure.message }`
+		);
+	}
+}
+
 async function main() {
 	const options = parseCliOptions( process.argv.slice( 2 ) );
 	const restBlocks = BLOCKS.filter( isRestEnabledBlock );
+	const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );
 
-	if ( restBlocks.length === 0 ) {
+	if ( restBlocks.length === 0 && restResources.length === 0 ) {
 		console.log(
 			options.check
-				? 'ℹ️ No REST-enabled workspace blocks are registered yet. `sync-rest --check` is already clean.'
-				: 'ℹ️ No REST-enabled workspace blocks are registered yet.'
+				? 'ℹ️ No REST-enabled workspace blocks or plugin-level REST resources are registered yet. `sync-rest --check` is already clean.'
+				: 'ℹ️ No REST-enabled workspace blocks or plugin-level REST resources are registered yet.'
 		);
 		return;
 	}
 
 	for ( const block of restBlocks ) {
+		await assertTypeArtifactsCurrent( block );
+
 		const contracts = block.restManifest.contracts;
 
 		for ( const [ baseName, contract ] of Object.entries( contracts ) ) {
@@ -111,10 +167,59 @@ async function main() {
 		);
 	}
 
+	for ( const resource of restResources ) {
+		const contracts = resource.restManifest.contracts;
+
+		for ( const [ baseName, contract ] of Object.entries( contracts ) ) {
+			await syncTypeSchemas(
+				{
+					jsonSchemaFile: path.join(
+						path.dirname( resource.typesFile ),
+						'api-schemas',
+						`${ baseName }.schema.json`
+					),
+					openApiFile: path.join(
+						path.dirname( resource.typesFile ),
+						'api-schemas',
+						`${ baseName }.openapi.json`
+					),
+					sourceTypeName: contract.sourceTypeName,
+					typesFile: resource.typesFile,
+				},
+				{
+					check: options.check,
+				}
+			);
+		}
+
+		await syncRestOpenApi(
+			{
+				manifest: resource.restManifest,
+				openApiFile: resource.openApiFile,
+				typesFile: resource.typesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+
+		await syncEndpointClient(
+			{
+				clientFile: resource.clientFile,
+				manifest: resource.restManifest,
+				typesFile: resource.typesFile,
+				validatorsFile: resource.validatorsFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+	}
+
 	console.log(
 		options.check
-			? '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date with the TypeScript types!'
-			: '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents generated from TypeScript types!'
+			? '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date for workspace blocks and plugin-level resources!'
+			: '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents generated for workspace blocks and plugin-level resources!'
 	);
 }
 

package/src/editor-plugins/.gitkeep

@@ -0,0 +1 @@
+

package/webpack.config.js.mustache

@@ -189,14 +189,25 @@ function getEditorEntries() {
 function getSharedEditorEntries() {
 	const entries = [];
 
-	for ( const relativePath of [ 'src/bindings/index.ts', 'src/bindings/index.js' ] ) {
-		const entryPath = path.resolve( process.cwd(), relativePath );
-		if ( ! fs.existsSync( entryPath ) ) {
-			continue;
-		}
+	for ( const [ entryName, candidates ] of [
+		[
+			'bindings/index',
+			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
+		],
+		[
+			'editor-plugins/index',
+			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
+		],
+	] ) {
+		for ( const relativePath of candidates ) {
+			const entryPath = path.resolve( process.cwd(), relativePath );
+			if ( ! fs.existsSync( entryPath ) ) {
+				continue;
+			}
 
-		entries.push( [ 'bindings/index', entryPath ] );
-		break;
+			entries.push( [ entryName, entryPath ] );
+			break;
+		}
 	}
 
 	return Object.fromEntries( entries );

package/{{slugKebabCase}}.php.mustache

@@ -117,6 +117,42 @@ function {{phpPrefix}}_enqueue_binding_sources_editor() {
 	);
 }
 
+function {{phpPrefix}}_enqueue_editor_plugins_editor() {
+	$script_path = __DIR__ . '/build/editor-plugins/index.js';
+	$asset_path  = __DIR__ . '/build/editor-plugins/index.asset.php';
+	$style_path  = __DIR__ . '/build/editor-plugins/style-index.css';
+	$style_rtl_path = __DIR__ . '/build/editor-plugins/style-index-rtl.css';
+
+	if ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+		return;
+	}
+
+	$asset = require $asset_path;
+	if ( ! is_array( $asset ) ) {
+		$asset = array();
+	}
+
+	wp_enqueue_script(
+		'{{slugKebabCase}}-editor-plugins',
+		plugins_url( 'build/editor-plugins/index.js', __FILE__ ),
+		isset( $asset['dependencies'] ) && is_array( $asset['dependencies'] ) ? $asset['dependencies'] : array(),
+		isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+		true
+	);
+
+	if ( file_exists( $style_path ) ) {
+		wp_enqueue_style(
+			'{{slugKebabCase}}-editor-plugins',
+			plugins_url( 'build/editor-plugins/style-index.css', __FILE__ ),
+			array(),
+			isset( $asset['version'] ) ? $asset['version'] : filemtime( $style_path )
+		);
+		if ( file_exists( $style_rtl_path ) ) {
+			wp_style_add_data( '{{slugKebabCase}}-editor-plugins', 'rtl', 'replace' );
+		}
+	}
+}
+
 function {{phpPrefix}}_register_pattern_category() {
 	if ( function_exists( 'register_block_pattern_category' ) ) {
 		register_block_pattern_category(
@@ -143,3 +179,4 @@ add_action( 'init', '{{phpPrefix}}_register_binding_sources', 20 );
 add_action( 'init', '{{phpPrefix}}_register_pattern_category' );
 add_action( 'init', '{{phpPrefix}}_register_patterns', 20 );
 add_action( 'enqueue_block_editor_assets', '{{phpPrefix}}_enqueue_binding_sources_editor' );
+add_action( 'enqueue_block_editor_assets', '{{phpPrefix}}_enqueue_editor_plugins_editor' );