@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/add/cli-add-workspace-post-meta-anchors.js

@@ -0,0 +1,244 @@
+import path from "node:path";
+import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
+import { hasPhpFunctionDefinition } from "../shared/php-utils.js";
+const POST_META_SERVER_GLOB = "/inc/post-meta/*.php";
+const NO_RESOURCES_GUARD_PATTERN = /if \(\s*restBlocks\.length === 0(?:\s*&&\s*standaloneContracts\.length === 0)?(?:\s*&&\s*postMetaContracts\.length === 0)?(?:\s*&&\s*restResources\.length === 0)?(?:\s*&&\s*aiFeatures\.length === 0)?\s*\) \{[\s\S]*?\n\t\treturn;\n\t\}/u;
+/**
+ * Ensure the workspace bootstrap loads generated post-meta PHP modules.
+ *
+ * Inserts the generated loader function, appends its `init` hook, and rejects
+ * incompatible existing loader functions that omit the generated post-meta glob.
+ *
+ * @param workspace Resolved official workspace metadata and paths.
+ * @returns A promise that resolves after the bootstrap has been patched.
+ * @throws {Error} When the bootstrap cannot be read, written, or safely patched.
+ */
+export async function ensurePostMetaBootstrapAnchors(workspace) {
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    await patchFile(bootstrapPath, (source) => {
+        let nextSource = source;
+        const registerFunctionName = `${workspace.workspace.phpPrefix}_register_post_meta_contracts`;
+        const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+        const registerFunction = `
+
+function ${registerFunctionName}() {
+\tforeach ( glob( __DIR__ . '${POST_META_SERVER_GLOB}' ) ?: array() as $post_meta_module ) {
+\t\trequire_once $post_meta_module;
+\t}
+}
+`;
+        if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, registerFunction);
+        }
+        else if (!nextSource.includes(POST_META_SERVER_GLOB)) {
+            throw new Error([
+                `Unable to patch ${path.basename(bootstrapPath)} in ensurePostMetaBootstrapAnchors.`,
+                `The existing ${registerFunctionName}() definition does not include ${POST_META_SERVER_GLOB}.`,
+                "Restore the generated bootstrap shape or wire the post-meta loader manually before retrying.",
+            ].join(" "));
+        }
+        if (!nextSource.includes(registerHook)) {
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, registerHook);
+        }
+        return nextSource;
+    });
+}
+function getSyncRestPatchErrorMessage(syncRestScriptPath, anchorDescription) {
+    return [
+        `ensurePostMetaSyncScriptAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+        `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
+        "Restore the generated template or add the POST_META wiring manually before retrying.",
+    ].join(" ");
+}
+function replaceBlockConfigImportForPostMeta(nextSource, syncRestScriptPath) {
+    const importPatterns = [
+        /^import\s*\{\n(?:\t[^\n]*\n)+\} from ["']\.\/block-config["'];?$/mu,
+        /^import\s*\{[^\n]*\}\s*from\s*["']\.\/block-config["'];?$/mu,
+    ];
+    const importMatch = importPatterns.map((pattern) => pattern.exec(nextSource)).find(Boolean) ??
+        null;
+    if (!importMatch) {
+        throw new Error(getSyncRestPatchErrorMessage(syncRestScriptPath, "block-config import"));
+    }
+    const importSource = importMatch[0];
+    if (importSource.includes("POST_META") &&
+        importSource.includes("WorkspacePostMetaConfig")) {
+        return nextSource;
+    }
+    if (!importSource.includes("BLOCKS") ||
+        !importSource.includes("WorkspaceBlockConfig")) {
+        throw new Error(getSyncRestPatchErrorMessage(syncRestScriptPath, "BLOCKS import"));
+    }
+    const hasAiFeatures = importSource.includes("AI_FEATURES");
+    const hasAiFeatureConfig = importSource.includes("WorkspaceAiFeatureConfig");
+    const hasContracts = importSource.includes("CONTRACTS");
+    const hasContractConfig = importSource.includes("WorkspaceContractConfig");
+    const hasRestResources = importSource.includes("REST_RESOURCES");
+    const hasRestResourceConfig = importSource.includes("WorkspaceRestResourceConfig");
+    const replacement = [
+        "import {",
+        ...(hasAiFeatures ? ["\tAI_FEATURES,"] : []),
+        "\tBLOCKS,",
+        ...(hasContracts ? ["\tCONTRACTS,"] : []),
+        "\tPOST_META,",
+        ...(hasRestResources ? ["\tREST_RESOURCES,"] : []),
+        ...(hasAiFeatureConfig ? ["\ttype WorkspaceAiFeatureConfig,"] : []),
+        "\ttype WorkspaceBlockConfig,",
+        ...(hasContractConfig ? ["\ttype WorkspaceContractConfig,"] : []),
+        "\ttype WorkspacePostMetaConfig,",
+        ...(hasRestResourceConfig ? ["\ttype WorkspaceRestResourceConfig,"] : []),
+        "} from './block-config';",
+    ].join("\n");
+    return nextSource.replace(importSource, replacement);
+}
+function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement, anchorDescription, syncRestScriptPath) {
+    if (nextSource.includes(target)) {
+        return nextSource;
+    }
+    const hasAnchor = typeof anchor === "string" ? nextSource.includes(anchor) : anchor.test(nextSource);
+    if (!hasAnchor) {
+        throw new Error(getSyncRestPatchErrorMessage(syncRestScriptPath, anchorDescription));
+    }
+    return nextSource.replace(anchor, replacement);
+}
+function replaceAllOccurrences(source, searchValue, replacement) {
+    return source.split(searchValue).join(replacement);
+}
+function buildPostMetaNoResourcesGuard({ hasAiFeatures, hasRestResources, }) {
+    const condition = [
+        "restBlocks.length === 0 &&",
+        "standaloneContracts.length === 0 &&",
+        "postMetaContracts.length === 0",
+    ];
+    if (hasRestResources) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("restResources.length === 0");
+    }
+    if (hasAiFeatures) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("aiFeatures.length === 0");
+    }
+    const noResourcesSubject = [
+        "REST-enabled workspace blocks",
+        "standalone contracts",
+        "post meta contracts",
+        ...(hasRestResources ? ["plugin-level REST resources"] : []),
+        ...(hasAiFeatures ? ["AI features"] : []),
+    ].join(", ");
+    return [
+        "if (",
+        ...condition.map((line) => `\t\t${line}`),
+        "\t) {",
+        "\t\tconsole.log(",
+        "\t\t\toptions.check",
+        `\t\t\t\t? 'ℹ️ No ${noResourcesSubject} are registered yet. \`sync-rest --check\` is already clean.'`,
+        `\t\t\t\t: 'ℹ️ No ${noResourcesSubject} are registered yet.'`,
+        "\t\t);",
+        "\t\treturn;",
+        "\t}",
+    ].join("\n");
+}
+function replaceNoResourcesGuard(nextSource, replacement, syncRestScriptPath) {
+    if (!NO_RESOURCES_GUARD_PATTERN.test(nextSource)) {
+        throw new Error(getSyncRestPatchErrorMessage(syncRestScriptPath, "no-resources guard"));
+    }
+    return nextSource.replace(NO_RESOURCES_GUARD_PATTERN, replacement);
+}
+function insertPostMetaFilter(nextSource, syncRestScriptPath) {
+    if (nextSource.includes("const postMetaContracts = POST_META.filter")) {
+        return nextSource;
+    }
+    const restResourcesFilter = "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );";
+    if (nextSource.includes(restResourcesFilter)) {
+        return nextSource.replace(restResourcesFilter, [
+            "const postMetaContracts = POST_META.filter( isWorkspacePostMetaContract );",
+            restResourcesFilter,
+        ].join("\n\t"));
+    }
+    const standaloneContractsFilter = "const standaloneContracts = CONTRACTS.filter( isWorkspaceStandaloneContract );";
+    return replaceRequiredSyncRestSource(nextSource, "const postMetaContracts = POST_META.filter", standaloneContractsFilter, [
+        standaloneContractsFilter,
+        "const postMetaContracts = POST_META.filter( isWorkspacePostMetaContract );",
+    ].join("\n\t"), "standaloneContracts filter", syncRestScriptPath);
+}
+function insertPostMetaNoResourcesGuard(nextSource, syncRestScriptPath) {
+    const hasRestResources = nextSource.includes("const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );");
+    const hasAiFeatures = nextSource.includes("const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );");
+    return replaceNoResourcesGuard(nextSource, buildPostMetaNoResourcesGuard({
+        hasAiFeatures,
+        hasRestResources,
+    }), syncRestScriptPath);
+}
+function insertPostMetaSyncLoop(nextSource, syncRestScriptPath) {
+    if (nextSource.includes("for ( const postMeta of postMetaContracts )")) {
+        return nextSource;
+    }
+    const loopSource = [
+        "\tfor ( const postMeta of postMetaContracts ) {",
+        "\t\tawait syncTypeSchemas(",
+        "\t\t\t{",
+        "\t\t\t\tjsonSchemaFile: postMeta.schemaFile,",
+        "\t\t\t\tsourceTypeName: postMeta.sourceTypeName,",
+        "\t\t\t\ttypesFile: postMeta.typesFile,",
+        "\t\t\t},",
+        "\t\t\t{",
+        "\t\t\t\tcheck: options.check,",
+        "\t\t\t}",
+        "\t\t);",
+        "\t}",
+    ].join("\n");
+    const resourceLoopAnchor = "\n\tfor ( const resource of restResources ) {";
+    if (nextSource.includes(resourceLoopAnchor)) {
+        return nextSource.replace(resourceLoopAnchor, `\n${loopSource}\n${resourceLoopAnchor}`);
+    }
+    const consoleLogPattern = /\n\tconsole\.log\(\n\t\toptions\.check/u;
+    return replaceRequiredSyncRestSource(nextSource, "for ( const postMeta of postMetaContracts )", consoleLogPattern, [
+        "",
+        loopSource,
+        "",
+        "\tconsole.log(",
+        "\t\toptions.check",
+    ].join("\n"), "success log insertion point", syncRestScriptPath);
+}
+/**
+ * Ensure `scripts/sync-rest-contracts.ts` handles post-meta schema contracts.
+ *
+ * Patches inventory imports, type guards, no-resource checks, sync loops, and
+ * success copy so generated post-meta schemas participate in REST contract sync.
+ *
+ * @param workspace Resolved official workspace metadata and paths.
+ * @returns A promise that resolves after the sync script has been patched.
+ * @throws {Error} When expected anchors are missing or file IO fails.
+ */
+export async function ensurePostMetaSyncScriptAnchors(workspace) {
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    await patchFile(syncRestScriptPath, (source) => {
+        let nextSource = replaceBlockConfigImportForPostMeta(source, syncRestScriptPath);
+        const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
+        nextSource = replaceRequiredSyncRestSource(nextSource, "function isWorkspacePostMetaContract(", helperInsertionAnchor, [
+            "function isWorkspacePostMetaContract(",
+            "\tpostMeta: WorkspacePostMetaConfig",
+            "): postMeta is WorkspacePostMetaConfig & {",
+            "\tschemaFile: string;",
+            "\tsourceTypeName: string;",
+            "\ttypesFile: string;",
+            "} {",
+            "\treturn (",
+            "\t\ttypeof postMeta.schemaFile === 'string' &&",
+            "\t\ttypeof postMeta.sourceTypeName === 'string' &&",
+            "\t\ttypeof postMeta.typesFile === 'string'",
+            "\t);",
+            "}",
+            "",
+            "async function assertTypeArtifactsCurrent",
+        ].join("\n"), "type artifact assertion helper", syncRestScriptPath);
+        nextSource = insertPostMetaFilter(nextSource, syncRestScriptPath);
+        nextSource = insertPostMetaNoResourcesGuard(nextSource, syncRestScriptPath);
+        nextSource = insertPostMetaSyncLoop(nextSource, syncRestScriptPath);
+        nextSource = replaceAllOccurrences(nextSource, "REST contract schemas, standalone schemas, portable API clients, and endpoint-aware OpenAPI documents", "REST contract schemas, standalone schemas, post meta schemas, portable API clients, and endpoint-aware OpenAPI documents");
+        nextSource = replaceAllOccurrences(nextSource, "workspace blocks, standalone contracts, and plugin-level resources", "workspace blocks, standalone contracts, post meta contracts, and plugin-level resources");
+        nextSource = replaceAllOccurrences(nextSource, "workspace blocks, standalone contracts, or plugin-level REST resources", "workspace blocks, standalone contracts, post meta contracts, or plugin-level REST resources");
+        return nextSource;
+    });
+}

package/dist/runtime/add/cli-add-workspace-post-meta-source-emitters.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Render one `POST_META` inventory entry for `scripts/block-config.ts`.
+ *
+ * @param options Metadata used to render the inventory entry.
+ * @param options.metaKey WordPress meta key registered by the generated PHP.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.showInRest Whether the meta key is exposed to REST/editor APIs.
+ * @param options.sourceTypeName Exported TypeScript interface name.
+ * @returns Formatted TypeScript object literal for the `POST_META` array.
+ */
+export declare function buildPostMetaConfigEntry(options: {
+    metaKey: string;
+    postMetaSlug: string;
+    postType: string;
+    showInRest: boolean;
+    sourceTypeName: string;
+}): string;
+/**
+ * Render a starter TypeScript post-meta contract.
+ *
+ * @param postMetaSlug Stable post-meta contract slug used to build the title.
+ * @param sourceTypeName Exported TypeScript interface name to emit.
+ * @returns Generated TypeScript source for the post-meta contract.
+ */
+export declare function buildPostMetaTypesSource(postMetaSlug: string, sourceTypeName: string): string;
+/**
+ * Render smoke-test guidance beside the generated TypeScript contract.
+ *
+ * @param options Metadata used to render the README content.
+ * @param options.metaKey WordPress meta key registered by the generated PHP.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.sourceTypeName Exported TypeScript interface name.
+ * @returns Generated README content for the post-meta contract directory.
+ */
+export declare function buildPostMetaReadmeSource(options: {
+    metaKey: string;
+    postMetaSlug: string;
+    postType: string;
+    sourceTypeName: string;
+}): string;
+/**
+ * Render the PHP module loaded by the workspace bootstrap to register the post
+ * meta key with the schema generated from TypeScript.
+ *
+ * @param options Metadata used to render the PHP module.
+ * @param options.metaKey WordPress meta key to register.
+ * @param options.phpPrefix Workspace PHP function prefix.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.showInRest Whether `register_post_meta()` exposes REST schema.
+ * @param options.textDomain Workspace text domain used for descriptions.
+ * @returns Generated PHP source for registering the post-meta contract.
+ */
+export declare function buildPostMetaPhpSource(options: {
+    metaKey: string;
+    phpPrefix: string;
+    postMetaSlug: string;
+    postType: string;
+    showInRest: boolean;
+    textDomain: string;
+}): string;

package/dist/runtime/add/cli-add-workspace-post-meta-source-emitters.js

@@ -0,0 +1,179 @@
+import { quoteTsString } from "./cli-add-shared.js";
+import { quotePhpString } from "../shared/php-utils.js";
+import { toTitleCase } from "../shared/string-case.js";
+/**
+ * Render one `POST_META` inventory entry for `scripts/block-config.ts`.
+ *
+ * @param options Metadata used to render the inventory entry.
+ * @param options.metaKey WordPress meta key registered by the generated PHP.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.showInRest Whether the meta key is exposed to REST/editor APIs.
+ * @param options.sourceTypeName Exported TypeScript interface name.
+ * @returns Formatted TypeScript object literal for the `POST_META` array.
+ */
+export function buildPostMetaConfigEntry(options) {
+    return [
+        "\t{",
+        `\t\tmetaKey: ${quoteTsString(options.metaKey)},`,
+        `\t\tphpFile: ${quoteTsString(`inc/post-meta/${options.postMetaSlug}.php`)},`,
+        `\t\tpostType: ${quoteTsString(options.postType)},`,
+        `\t\tschemaFile: ${quoteTsString(`src/post-meta/${options.postMetaSlug}/meta.schema.json`)},`,
+        `\t\tshowInRest: ${options.showInRest ? "true" : "false"},`,
+        `\t\tslug: ${quoteTsString(options.postMetaSlug)},`,
+        `\t\tsourceTypeName: ${quoteTsString(options.sourceTypeName)},`,
+        `\t\ttypesFile: ${quoteTsString(`src/post-meta/${options.postMetaSlug}/types.ts`)},`,
+        "\t},",
+    ].join("\n");
+}
+/**
+ * Render a starter TypeScript post-meta contract.
+ *
+ * @param postMetaSlug Stable post-meta contract slug used to build the title.
+ * @param sourceTypeName Exported TypeScript interface name to emit.
+ * @returns Generated TypeScript source for the post-meta contract.
+ */
+export function buildPostMetaTypesSource(postMetaSlug, sourceTypeName) {
+    const title = toTitleCase(postMetaSlug);
+    return `/**
+ * ${title} is the source of truth for a generated WordPress post meta contract.
+ *
+ * Edit this interface, then run \`wp-typia sync-rest --check\` to verify the
+ * JSON Schema artifact and PHP registration stay aligned.
+ */
+export interface ${sourceTypeName} {
+\tenabled: boolean;
+\tstatus: 'draft' | 'ready';
+\tupdatedAt: string;
+\tnotes?: string;
+}
+`;
+}
+/**
+ * Render smoke-test guidance beside the generated TypeScript contract.
+ *
+ * @param options Metadata used to render the README content.
+ * @param options.metaKey WordPress meta key registered by the generated PHP.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.sourceTypeName Exported TypeScript interface name.
+ * @returns Generated README content for the post-meta contract directory.
+ */
+export function buildPostMetaReadmeSource(options) {
+    const title = toTitleCase(options.postMetaSlug);
+    return `# ${title} Post Meta Contract
+
+\`${options.sourceTypeName}\` in \`types.ts\` defines the shape for
+\`${options.metaKey}\` on the \`${options.postType}\` post type.
+
+After editing the TypeScript interface, run:
+
+\`\`\`bash
+wp-typia sync-rest --check
+\`\`\`
+
+If the check reports stale artifacts, run \`wp-typia sync-rest\` and commit the
+updated \`meta.schema.json\`. For an end-to-end smoke test in WordPress, create
+or update a \`${options.postType}\` post and confirm the REST response exposes
+the meta key only when \`showInRest\` is enabled in \`scripts/block-config.ts\`.
+`;
+}
+/**
+ * Render the PHP module loaded by the workspace bootstrap to register the post
+ * meta key with the schema generated from TypeScript.
+ *
+ * @param options Metadata used to render the PHP module.
+ * @param options.metaKey WordPress meta key to register.
+ * @param options.phpPrefix Workspace PHP function prefix.
+ * @param options.postMetaSlug Stable post-meta contract slug.
+ * @param options.postType WordPress post type scoped to the meta key.
+ * @param options.showInRest Whether `register_post_meta()` exposes REST schema.
+ * @param options.textDomain Workspace text domain used for descriptions.
+ * @returns Generated PHP source for registering the post-meta contract.
+ */
+export function buildPostMetaPhpSource(options) {
+    const postMetaTitle = toTitleCase(options.postMetaSlug);
+    const postMetaPhpId = options.postMetaSlug.replace(/-/gu, "_");
+    const functionPrefix = `${options.phpPrefix}_${postMetaPhpId}`;
+    const loadSchemaFunctionName = `${functionPrefix}_load_post_meta_schema`;
+    const normalizeSchemaFunctionName = `${functionPrefix}_normalize_post_meta_schema`;
+    const authFunctionName = `${functionPrefix}_can_edit_post_meta`;
+    const registerFunctionName = `${functionPrefix}_register_post_meta`;
+    const showInRestSource = options.showInRest
+        ? `array(
+\t\t\t'schema' => ${loadSchemaFunctionName}(),
+\t\t)`
+        : "false";
+    return `<?php
+/**
+ * Registers the ${postMetaTitle} post meta contract.
+ *
+ * The REST schema is generated from src/post-meta/${options.postMetaSlug}/types.ts.
+ *
+ * @package ${options.phpPrefix}
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+\texit;
+}
+
+if ( ! function_exists( '${normalizeSchemaFunctionName}' ) ) {
+\tfunction ${normalizeSchemaFunctionName}( $schema ) {
+\t\tif ( ! is_array( $schema ) ) {
+\t\t\treturn array(
+\t\t\t\t'type'       => 'object',
+\t\t\t\t'properties' => array(),
+\t\t\t);
+\t\t}
+
+\t\tunset( $schema['$schema'], $schema['$id'], $schema['title'] );
+
+\t\tif ( empty( $schema['type'] ) ) {
+\t\t\t$schema['type'] = 'object';
+\t\t}
+
+\t\treturn $schema;
+\t}
+}
+
+if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
+\tfunction ${loadSchemaFunctionName}() {
+\t\t$schema_file = dirname( __DIR__, 2 ) . '/src/post-meta/${options.postMetaSlug}/meta.schema.json';
+
+\t\tif ( ! file_exists( $schema_file ) ) {
+\t\t\treturn ${normalizeSchemaFunctionName}( array() );
+\t\t}
+
+\t\t$schema = json_decode( (string) file_get_contents( $schema_file ), true );
+
+\t\treturn ${normalizeSchemaFunctionName}( $schema );
+\t}
+}
+
+if ( ! function_exists( '${authFunctionName}' ) ) {
+\tfunction ${authFunctionName}( $allowed, $meta_key, $post_id, $user_id, $cap, $caps ) {
+\t\tunset( $allowed, $meta_key, $cap, $caps );
+
+\t\treturn user_can( $user_id, 'edit_post', $post_id );
+\t}
+}
+
+if ( ! function_exists( '${registerFunctionName}' ) ) {
+\tfunction ${registerFunctionName}() {
+\t\tregister_post_meta(
+\t\t\t${quotePhpString(options.postType)},
+\t\t\t${quotePhpString(options.metaKey)},
+\t\t\tarray(
+\t\t\t\t'auth_callback' => ${quotePhpString(authFunctionName)},
+\t\t\t\t'description'   => __( ${quotePhpString(`${postMetaTitle} typed post meta contract.`)}, ${quotePhpString(options.textDomain)} ),
+\t\t\t\t'show_in_rest'  => ${showInRestSource},
+\t\t\t\t'single'        => true,
+\t\t\t\t'type'          => 'object',
+\t\t\t)
+\t\t);
+\t}
+}
+
+${registerFunctionName}();
+`;
+}

package/dist/runtime/add/cli-add-workspace-post-meta.d.ts

@@ -0,0 +1,15 @@
+import { type RunAddPostMetaCommandOptions } from "./cli-add-shared.js";
+/**
+ * Scaffold a typed WordPress post-meta contract and matching PHP registration.
+ */
+export declare function runAddPostMetaCommand({ cwd, hideFromRest, metaKey, postMetaName, postType, typeName, }: RunAddPostMetaCommandOptions): Promise<{
+    metaKey: string;
+    phpFile: string;
+    postMetaSlug: string;
+    postType: string;
+    projectDir: string;
+    schemaFile: string;
+    showInRest: boolean;
+    sourceTypeName: string;
+    typesFile: string;
+}>;

package/dist/runtime/add/cli-add-workspace-post-meta.js

@@ -0,0 +1,107 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { pathExists } from "../shared/fs-async.js";
+import { assertPostMetaDoesNotExist, assertValidGeneratedSlug, assertValidPostMetaPostType, assertValidTypeScriptIdentifier, getWorkspaceBootstrapPath, normalizeBlockSlug, resolvePostMetaKey, } from "./cli-add-shared.js";
+import { ensureContractSyncScriptAnchors, } from "./cli-add-workspace-rest-contract-sync-anchors.js";
+import { ensurePostMetaBootstrapAnchors, ensurePostMetaSyncScriptAnchors, } from "./cli-add-workspace-post-meta-anchors.js";
+import { buildPostMetaConfigEntry, buildPostMetaPhpSource, buildPostMetaReadmeSource, buildPostMetaTypesSource, } from "./cli-add-workspace-post-meta-source-emitters.js";
+import { executeWorkspaceMutationPlan } from "./cli-add-workspace-mutation.js";
+import { syncStandaloneContractArtifacts } from "./contract-artifacts.js";
+import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "../workspace/workspace-inventory.js";
+import { resolveWorkspaceProject } from "../workspace/workspace-project.js";
+import { toPascalCase } from "../shared/string-case.js";
+const ADD_POST_META_USAGE = "wp-typia add post-meta <name> --post-type <post-type> [--type <ExportedTypeName>] [--meta-key <meta-key>] [--hide-from-rest]";
+/**
+ * Scaffold a typed WordPress post-meta contract and matching PHP registration.
+ */
+export async function runAddPostMetaCommand({ cwd = process.cwd(), hideFromRest, metaKey, postMetaName, postType, typeName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const postMetaSlug = assertValidGeneratedSlug("Post meta name", normalizeBlockSlug(postMetaName), ADD_POST_META_USAGE);
+    const sourceTypeName = assertValidTypeScriptIdentifier("Post meta type", typeName ?? `${toPascalCase(postMetaSlug)}Meta`, ADD_POST_META_USAGE);
+    const resolvedPostType = assertValidPostMetaPostType(postType);
+    const resolvedMetaKey = resolvePostMetaKey({
+        metaKey,
+        phpPrefix: workspace.workspace.phpPrefix,
+        slug: postMetaSlug,
+    });
+    const showInRest = !hideFromRest;
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+    assertPostMetaDoesNotExist(workspace.projectDir, postMetaSlug, resolvedPostType, resolvedMetaKey, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    const postMetaRoot = path.join(workspace.projectDir, "src", "post-meta");
+    const postMetaDir = path.join(postMetaRoot, postMetaSlug);
+    const postMetaIncRoot = path.join(workspace.projectDir, "inc", "post-meta");
+    const typesFile = `src/post-meta/${postMetaSlug}/types.ts`;
+    const schemaFile = `src/post-meta/${postMetaSlug}/meta.schema.json`;
+    const phpFile = `inc/post-meta/${postMetaSlug}.php`;
+    const readmeFile = `src/post-meta/${postMetaSlug}/README.md`;
+    const typesFilePath = path.join(workspace.projectDir, typesFile);
+    const schemaFilePath = path.join(workspace.projectDir, schemaFile);
+    const phpFilePath = path.join(workspace.projectDir, phpFile);
+    const readmeFilePath = path.join(workspace.projectDir, readmeFile);
+    const postMetaRootExisted = await pathExists(postMetaRoot);
+    const postMetaIncRootExisted = await pathExists(postMetaIncRoot);
+    return executeWorkspaceMutationPlan({
+        filePaths: [blockConfigPath, bootstrapPath, syncRestScriptPath],
+        targetPaths: [
+            typesFilePath,
+            schemaFilePath,
+            phpFilePath,
+            readmeFilePath,
+            ...(postMetaRootExisted ? [] : [postMetaRoot]),
+            ...(postMetaIncRootExisted ? [] : [postMetaIncRoot]),
+        ],
+        run: async () => {
+            await fsp.mkdir(postMetaDir, { recursive: true });
+            await fsp.mkdir(postMetaIncRoot, { recursive: true });
+            await ensureContractSyncScriptAnchors(workspace);
+            await ensurePostMetaSyncScriptAnchors(workspace);
+            await ensurePostMetaBootstrapAnchors(workspace);
+            await fsp.writeFile(typesFilePath, buildPostMetaTypesSource(postMetaSlug, sourceTypeName), "utf8");
+            await syncStandaloneContractArtifacts({
+                projectDir: workspace.projectDir,
+                schemaFile,
+                sourceTypeName,
+                typesFile,
+            });
+            await fsp.writeFile(phpFilePath, buildPostMetaPhpSource({
+                metaKey: resolvedMetaKey,
+                phpPrefix: workspace.workspace.phpPrefix,
+                postMetaSlug,
+                postType: resolvedPostType,
+                showInRest,
+                textDomain: workspace.workspace.textDomain,
+            }), "utf8");
+            await fsp.writeFile(readmeFilePath, buildPostMetaReadmeSource({
+                metaKey: resolvedMetaKey,
+                postMetaSlug,
+                postType: resolvedPostType,
+                sourceTypeName,
+            }), "utf8");
+            await appendWorkspaceInventoryEntries(workspace.projectDir, {
+                postMetaEntries: [
+                    buildPostMetaConfigEntry({
+                        metaKey: resolvedMetaKey,
+                        postMetaSlug,
+                        postType: resolvedPostType,
+                        showInRest,
+                        sourceTypeName,
+                    }),
+                ],
+            });
+            return {
+                metaKey: resolvedMetaKey,
+                phpFile,
+                postMetaSlug,
+                postType: resolvedPostType,
+                projectDir: workspace.projectDir,
+                schemaFile,
+                showInRest,
+                sourceTypeName,
+                typesFile,
+            };
+        },
+    });
+}

package/dist/runtime/add/cli-add-workspace-registration-hooks.d.ts

@@ -0,0 +1,50 @@
+import { type SourceRange } from "../shared/ts-source-masking.js";
+/**
+ * Find the first executable call expression for a named function in source code.
+ *
+ * @param source TypeScript or JavaScript source text to scan.
+ * @param callName Function identifier to locate.
+ * @returns The source range for the first matching executable call, or
+ * `undefined` when the identifier is absent, commented, string-literal-only, or
+ * not followed by a call expression.
+ */
+export declare function findExecutableCallRange(source: string, callName: string): SourceRange | undefined;
+/**
+ * Ensure a block entrypoint imports and calls a workspace registration helper.
+ *
+ * @param options Entrypoint patch options.
+ * @param options.blockIndexPath Absolute path to the block entrypoint file.
+ * @param options.callLine Call expression line to insert when missing.
+ * @param options.callPattern Executable pattern used to detect an existing call.
+ * @param options.importLine Import line to prepend when missing.
+ * @param options.importPattern Uncommented import pattern used to avoid duplicates.
+ * @returns A promise that resolves after the entrypoint has been patched.
+ * @throws {Error} When the call cannot be injected or verified.
+ */
+export declare function ensureWorkspaceEntrypointCall({ blockIndexPath, callLine, callPattern, importLine, importPattern, }: {
+    blockIndexPath: string;
+    callLine: string;
+    callPattern: RegExp;
+    importLine: string;
+    importPattern: RegExp;
+}): Promise<void>;
+/**
+ * Ensure a scaffold block registration settings hook is imported and called.
+ *
+ * @param options Registration settings patch options.
+ * @param options.blockIndexPath Absolute path to the block entrypoint file.
+ * @param options.callLine Settings mutation call to insert before registration.
+ * @param options.callPattern Executable pattern used to detect an existing call.
+ * @param options.importLine Import line to prepend when missing.
+ * @param options.importPattern Uncommented import pattern used to avoid duplicates.
+ * @returns A promise that resolves after the entrypoint has been patched.
+ * @throws {Error} When the entrypoint does not expose the expected
+ * `registerScaffoldBlockType(registration.name, registration.settings)` call.
+ */
+export declare function ensureWorkspaceRegistrationSettingsCall({ blockIndexPath, callLine, callPattern, importLine, importPattern, }: {
+    blockIndexPath: string;
+    callLine: string;
+    callPattern: RegExp;
+    importLine: string;
+    importPattern: RegExp;
+}): Promise<void>;