@wp-typia/project-tools 0.17.0 → 0.19.0

package/dist/runtime/cli-validation.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Normalize one optional CLI string flag by trimming whitespace and collapsing
+ * empty strings to `undefined`.
+ *
+ * @param value Raw CLI value before normalization.
+ * @returns The trimmed string when present, otherwise `undefined`.
+ */
+export function normalizeOptionalCliString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function looksLikeLocalCliPath(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith("./") ||
+        value.startsWith("../") ||
+        value.startsWith(".\\") ||
+        value.startsWith("..\\"));
+}
+/**
+ * Resolve one CLI path flag relative to the caller when it is expressed as a
+ * local filesystem path.
+ *
+ * Non-local values such as npm package specs or `github:` locators pass
+ * through unchanged. Local relative and absolute paths are resolved against the
+ * provided `cwd` and must exist on disk.
+ *
+ * @param options Path resolution inputs for one CLI flag.
+ * @param options.cwd Caller working directory used for relative path
+ * resolution.
+ * @param options.label Human-readable option label used in thrown errors.
+ * @param options.value Raw CLI value before trimming and path resolution.
+ * @returns The normalized string, or `undefined` when the option was omitted.
+ * @throws When a local-looking path resolves to a missing filesystem entry.
+ */
+export function resolveLocalCliPathOption(options) {
+    const normalizedValue = normalizeOptionalCliString(options.value);
+    if (!normalizedValue || !looksLikeLocalCliPath(normalizedValue)) {
+        return normalizedValue;
+    }
+    const resolvedPath = path.resolve(options.cwd, normalizedValue);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
+    }
+    return resolvedPath;
+}
+/**
+ * Validate the built-in template composition rule for external layers.
+ *
+ * @param options External layer CLI options after normalization.
+ * @param options.externalLayerId Optional selected layer id.
+ * @param options.externalLayerSource Optional layer source locator or path.
+ * @throws When `externalLayerId` is provided without `externalLayerSource`.
+ */
+export function assertExternalLayerCompositionOptions(options) {
+    if (options.externalLayerId && !options.externalLayerSource) {
+        throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
+    }
+}
+/**
+ * Build the shared error message used when a built-in template receives a
+ * `--variant` override.
+ *
+ * @param options Built-in template context.
+ * @param options.templateId Built-in template id that rejected the variant.
+ * @param options.variant User-supplied variant override.
+ * @returns The canonical user-facing error message.
+ */
+export function createBuiltInVariantErrorMessage(options) {
+    return `--variant is only supported for official external template configs. Received variant "${options.variant}" for built-in template "${options.templateId}".`;
+}
+/**
+ * Reject unsupported `--variant` usage for built-in templates.
+ *
+ * @param options Built-in template validation context.
+ * @param options.templateId Built-in template id being scaffolded.
+ * @param options.variant Optional variant override from CLI flags.
+ * @throws When a built-in template receives any explicit `--variant` value.
+ */
+export function assertBuiltInTemplateVariantAllowed(options) {
+    if (!options.variant) {
+        return;
+    }
+    throw new Error(createBuiltInVariantErrorMessage({
+        templateId: options.templateId,
+        variant: options.variant,
+    }));
+}

package/dist/runtime/compound-inner-blocks.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Stable preset ids exposed to scaffold and UI consumers for compound
+ * InnerBlocks authoring behavior.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_IDS: readonly ["freeform", "ordered", "horizontal", "locked-structure"];
+export type CompoundInnerBlocksPresetId = (typeof COMPOUND_INNER_BLOCKS_PRESET_IDS)[number];
+/**
+ * Default preset applied when callers do not provide an explicit compound
+ * InnerBlocks mode.
+ */
+export declare const DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID: CompoundInnerBlocksPresetId;
+export type CompoundInnerBlocksOrientation = "horizontal" | "vertical";
+export type CompoundInnerBlocksTemplateLock = false | "insert" | "all";
+/**
+ * Runtime-facing description of one compound InnerBlocks preset.
+ */
+export interface CompoundInnerBlocksPresetDefinition {
+    description: string;
+    directInsert: boolean;
+    label: string;
+    orientation?: CompoundInnerBlocksOrientation;
+    templateLock: CompoundInnerBlocksTemplateLock;
+}
+/**
+ * Canonical preset registry used by the CLI, generated scaffolds, and TUI
+ * forms.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_REGISTRY: {
+    readonly freeform: {
+        readonly description: "Unlocked nested authoring with the default inserter and starter child template.";
+        readonly directInsert: false;
+        readonly label: "freeform";
+        readonly orientation: "vertical";
+        readonly templateLock: false;
+    };
+    readonly ordered: {
+        readonly description: "Vertical ordered flow that keeps starter structure fixed while allowing new sibling inserts.";
+        readonly directInsert: true;
+        readonly label: "ordered";
+        readonly orientation: "vertical";
+        readonly templateLock: "insert";
+    };
+    readonly horizontal: {
+        readonly description: "Horizontal nested layout with one-click direct inserts for row or tab style containers.";
+        readonly directInsert: true;
+        readonly label: "horizontal";
+        readonly orientation: "horizontal";
+        readonly templateLock: false;
+    };
+    readonly "locked-structure": {
+        readonly description: "Locked starter structure for guided document shells where authors should only edit seeded children.";
+        readonly directInsert: false;
+        readonly label: "locked-structure";
+        readonly orientation: "vertical";
+        readonly templateLock: "all";
+    };
+};
+/**
+ * Returns whether a string matches one of the supported compound preset ids.
+ */
+export declare function isCompoundInnerBlocksPresetId(value: string): value is CompoundInnerBlocksPresetId;
+/**
+ * Parses a raw CLI or config value into a supported preset id.
+ *
+ * Returns `undefined` for non-string or empty input, and throws when the input
+ * is a non-empty unsupported preset id.
+ */
+export declare function parseCompoundInnerBlocksPreset(value?: string): CompoundInnerBlocksPresetId | undefined;
+/**
+ * Resolves an optional preset id to a concrete preset, defaulting to
+ * `DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID`.
+ */
+export declare function resolveCompoundInnerBlocksPreset(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetId;
+/**
+ * Looks up the preset definition for the provided preset id, applying the
+ * default preset when the input is omitted.
+ */
+export declare function getCompoundInnerBlocksPresetDefinition(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetDefinition;

package/dist/runtime/compound-inner-blocks.js

@@ -0,0 +1,88 @@
+/**
+ * Stable preset ids exposed to scaffold and UI consumers for compound
+ * InnerBlocks authoring behavior.
+ */
+export const COMPOUND_INNER_BLOCKS_PRESET_IDS = [
+    "freeform",
+    "ordered",
+    "horizontal",
+    "locked-structure",
+];
+/**
+ * Default preset applied when callers do not provide an explicit compound
+ * InnerBlocks mode.
+ */
+export const DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID = "freeform";
+/**
+ * Canonical preset registry used by the CLI, generated scaffolds, and TUI
+ * forms.
+ */
+export const COMPOUND_INNER_BLOCKS_PRESET_REGISTRY = {
+    freeform: {
+        description: "Unlocked nested authoring with the default inserter and starter child template.",
+        directInsert: false,
+        label: "freeform",
+        orientation: "vertical",
+        templateLock: false,
+    },
+    ordered: {
+        description: "Vertical ordered flow that keeps starter structure fixed while allowing new sibling inserts.",
+        directInsert: true,
+        label: "ordered",
+        orientation: "vertical",
+        templateLock: "insert",
+    },
+    horizontal: {
+        description: "Horizontal nested layout with one-click direct inserts for row or tab style containers.",
+        directInsert: true,
+        label: "horizontal",
+        orientation: "horizontal",
+        templateLock: false,
+    },
+    "locked-structure": {
+        description: "Locked starter structure for guided document shells where authors should only edit seeded children.",
+        directInsert: false,
+        label: "locked-structure",
+        orientation: "vertical",
+        templateLock: "all",
+    },
+};
+/**
+ * Returns whether a string matches one of the supported compound preset ids.
+ */
+export function isCompoundInnerBlocksPresetId(value) {
+    return COMPOUND_INNER_BLOCKS_PRESET_IDS.includes(value);
+}
+/**
+ * Parses a raw CLI or config value into a supported preset id.
+ *
+ * Returns `undefined` for non-string or empty input, and throws when the input
+ * is a non-empty unsupported preset id.
+ */
+export function parseCompoundInnerBlocksPreset(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalizedValue = value.trim();
+    if (normalizedValue.length === 0) {
+        return undefined;
+    }
+    if (!isCompoundInnerBlocksPresetId(normalizedValue)) {
+        throw new Error(`Unsupported InnerBlocks preset "${value}". Expected one of: ${COMPOUND_INNER_BLOCKS_PRESET_IDS.join(", ")}.`);
+    }
+    return normalizedValue;
+}
+/**
+ * Resolves an optional preset id to a concrete preset, defaulting to
+ * `DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID`.
+ */
+export function resolveCompoundInnerBlocksPreset(value) {
+    return value ?? DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID;
+}
+/**
+ * Looks up the preset definition for the provided preset id, applying the
+ * default preset when the input is omitted.
+ */
+export function getCompoundInnerBlocksPresetDefinition(value) {
+    return COMPOUND_INNER_BLOCKS_PRESET_REGISTRY[resolveCompoundInnerBlocksPreset(value)];
+}

package/dist/runtime/index.d.ts

@@ -6,9 +6,12 @@
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
  * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
- * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `runAddBindingSourceCommand`, `runAddEditorPluginCommand`,
+ * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
+export { COMPOUND_INNER_BLOCKS_PRESET_IDS, DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, isCompoundInnerBlocksPresetId, parseCompoundInnerBlocksPreset, resolveCompoundInnerBlocksPreset, } from "./compound-inner-blocks.js";
+export type { CompoundInnerBlocksPresetDefinition, CompoundInnerBlocksPresetId, CompoundInnerBlocksTemplateLock, } from "./compound-inner-blocks.js";
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { BlockGeneratorService } from "./block-generator-service.js";
 export type { ApplyBlockInput, BlockGenerationTarget, BlockSpec, PlanBlockInput, PlanBlockResult, RenderBlockInput, RenderBlockResult, ValidateBlockInput, ValidateBlockResult, } from "./block-generator-service.js";
@@ -21,5 +24,5 @@ export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, str
 export type { EndpointAuthIntent, EndpointOpenApiAuthMode, EndpointOpenApiContractDocument, EndpointOpenApiDocumentOptions, EndpointOpenApiEndpointDefinition, EndpointOpenApiMethod, EndpointWordPressAuthDefinition, EndpointWordPressAuthMechanism, JsonSchemaDocument, JsonSchemaProjectionProfile, JsonSchemaObject, NormalizedEndpointAuthDefinition, OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiSecurityScheme, } from "./schema-core.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
-export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
-export type { CliDiagnosticMessage, DoctorCheck, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export type { CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -6,9 +6,11 @@
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
  * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
- * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `runAddBindingSourceCommand`, `runAddEditorPluginCommand`,
+ * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
+export { COMPOUND_INNER_BLOCKS_PRESET_IDS, DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, isCompoundInnerBlocksPresetId, parseCompoundInnerBlocksPreset, resolveCompoundInnerBlocksPreset, } from "./compound-inner-blocks.js";
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { BlockGeneratorService } from "./block-generator-service.js";
 export { BLOCK_GENERATION_TOOL_CONTRACT_VERSION, inspectBlockGeneration, } from "./block-generator-tool-contract.js";
@@ -18,4 +20,4 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
-export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/local-dev-presets.js

@@ -8,7 +8,7 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { formatRunScript, } from "./package-managers.js";
-import { SHARED_TEST_PRESET_TEMPLATE_ROOT, SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, } from "./template-registry.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, SHARED_TEST_PRESET_TEMPLATE_ROOT, SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, } from "./template-registry.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 function templateHasPersistenceSync(templateId, compoundPersistenceEnabled) {
     return templateId === "persistence" || (templateId === "compound" && compoundPersistenceEnabled);
@@ -19,6 +19,11 @@ function templateSupportsGeneratedSyncWatchers(templateId) {
         templateId === "persistence" ||
         templateId === "compound");
 }
+function templateUsesDevAsPrimaryEntrypoint(templateId) {
+    return (templateSupportsGeneratedSyncWatchers(templateId) ||
+        templateId === "query-loop" ||
+        templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE);
+}
 function getWatchSyncTypesScript(packageManager, templateId) {
     if (templateId === "compound") {
         return `chokidar "src/blocks/**/types.ts" "scripts/block-config.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-types")}"`;
@@ -138,5 +143,5 @@ export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEn
  * scaffolded template.
  */
 export function getPrimaryDevelopmentScript(templateId) {
-    return templateSupportsGeneratedSyncWatchers(templateId) ? "dev" : "start";
+    return templateUsesDevAsPrimaryEntrypoint(templateId) ? "dev" : "start";
 }

package/dist/runtime/migration-command-surface.js

@@ -19,6 +19,8 @@ export function formatMigrationHelpText() {
 
 Notes:
   \`migrate init\` auto-detects supported single-block and \`src/blocks/*\` multi-block layouts.
+  \`migrate init\` only retrofits migration support into projects that already match those layouts.
+  A broader project-level \`wp-typia init\` path remains future work.
   Migration versions use strict schema labels like \`v1\`, \`v2\`, and \`v3\`.
   \`migrate wizard\` is TTY-only and helps you choose one legacy migration version to preview.
   \`migrate plan\` and \`migrate wizard\` are read-only previews; they do not scaffold rules or fixtures.

package/dist/runtime/package-versions.d.ts

@@ -4,6 +4,7 @@ interface PackageVersions {
     blockTypesPackageVersion: string;
     projectToolsPackageVersion: string;
     restPackageVersion: string;
+    wpTypiaPackageExactVersion: string;
     wpTypiaPackageVersion: string;
 }
 export declare function getPackageVersions(): PackageVersions;

package/dist/runtime/package-versions.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
 const require = createRequire(import.meta.url);
 const DEFAULT_VERSION_RANGE = "^0.0.0";
+const DEFAULT_EXACT_VERSION = "0.0.0";
 let cachedPackageVersions = null;
 function getErrorCode(error) {
     return typeof error === "object" && error !== null && "code" in error
@@ -20,6 +21,16 @@ function normalizeVersionRange(value) {
     }
     return /^[~^<>=]/.test(trimmed) ? trimmed : `^${trimmed}`;
 }
+function normalizeExactVersion(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return DEFAULT_EXACT_VERSION;
+    }
+    if (trimmed.startsWith("workspace:")) {
+        return DEFAULT_EXACT_VERSION;
+    }
+    return trimmed.replace(/^[~^<>=]+/, "");
+}
 function readPackageManifest(packageJsonPath) {
     try {
         return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
@@ -67,6 +78,7 @@ export function getPackageVersions() {
         projectToolsPackageVersion: normalizeVersionRange(createManifest.version),
         restPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/rest"] ??
             resolveInstalledPackageManifest("@wp-typia/rest")?.version),
+        wpTypiaPackageExactVersion: normalizeExactVersion(wpTypiaManifest.version),
         wpTypiaPackageVersion: normalizeVersionRange(wpTypiaManifest.version),
     };
     return cachedPackageVersions;

package/dist/runtime/rest-resource-artifacts.d.ts

@@ -0,0 +1,35 @@
+import type { RestResourceMethodId } from "./cli-add-shared.js";
+interface RestResourceTemplateVariablesLike {
+    namespace: string;
+    pascalCase: string;
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncRestResourceArtifactsOptions {
+    clientFile: string;
+    methods: RestResourceMethodId[];
+    outputDir: string;
+    projectDir: string;
+    typesFile: string;
+    validatorsFile: string;
+    variables: RestResourceTemplateVariablesLike;
+}
+/**
+ * Build the endpoint manifest for a workspace-level REST resource scaffold.
+ *
+ * @param variables Template naming data used for contract names, routes, and OpenAPI info.
+ * @param methods Enabled REST methods for the generated resource.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export declare function buildRestResourceEndpointManifest(variables: RestResourceTemplateVariablesLike, methods: RestResourceMethodId[]): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
+    sourceTypeName: string;
+}>, import("@wp-typia/block-runtime/schema-core").EndpointOpenApiEndpointDefinition[]>;
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for
+ * a workspace-level REST resource scaffold.
+ *
+ * @param options Resource file paths, enabled methods, and naming variables.
+ * @returns A promise that resolves after every generated REST artifact has been refreshed.
+ */
+export declare function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncRestResourceArtifactsOptions): Promise<void>;
+export {};

package/dist/runtime/rest-resource-artifacts.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+/**
+ * Build the endpoint manifest for a workspace-level REST resource scaffold.
+ *
+ * @param variables Template naming data used for contract names, routes, and OpenAPI info.
+ * @param methods Enabled REST methods for the generated resource.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export function buildRestResourceEndpointManifest(variables, methods) {
+    const basePath = `/${variables.namespace}/${variables.slugKebabCase}`;
+    const itemPath = `${basePath}/item`;
+    const contracts = {};
+    const endpoints = [];
+    if (methods.includes("list")) {
+        contracts["list-query"] = {
+            sourceTypeName: `${variables.pascalCase}ListQuery`,
+        };
+        contracts["list-response"] = {
+            sourceTypeName: `${variables.pascalCase}ListResponse`,
+        };
+        endpoints.push({
+            auth: "public",
+            method: "GET",
+            operationId: `list${variables.pascalCase}Resources`,
+            path: basePath,
+            queryContract: "list-query",
+            responseContract: "list-response",
+            summary: `List ${variables.title} resources.`,
+            tags: [variables.title],
+        });
+    }
+    if (methods.includes("read")) {
+        contracts["read-query"] = {
+            sourceTypeName: `${variables.pascalCase}ReadQuery`,
+        };
+        contracts["read-response"] = {
+            sourceTypeName: `${variables.pascalCase}ReadResponse`,
+        };
+        endpoints.push({
+            auth: "public",
+            method: "GET",
+            operationId: `read${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "read-query",
+            responseContract: "read-response",
+            summary: `Read one ${variables.title} resource.`,
+            tags: [variables.title],
+        });
+    }
+    if (methods.includes("create")) {
+        contracts["create-request"] = {
+            sourceTypeName: `${variables.pascalCase}CreateRequest`,
+        };
+        contracts["create-response"] = {
+            sourceTypeName: `${variables.pascalCase}CreateResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            bodyContract: "create-request",
+            method: "POST",
+            operationId: `create${variables.pascalCase}Resource`,
+            path: basePath,
+            responseContract: "create-response",
+            summary: `Create one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    if (methods.includes("update")) {
+        contracts["update-query"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateQuery`,
+        };
+        contracts["update-request"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateRequest`,
+        };
+        contracts["update-response"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            bodyContract: "update-request",
+            method: "POST",
+            operationId: `update${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "update-query",
+            responseContract: "update-response",
+            summary: `Update one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    if (methods.includes("delete")) {
+        contracts["delete-query"] = {
+            sourceTypeName: `${variables.pascalCase}DeleteQuery`,
+        };
+        contracts["delete-response"] = {
+            sourceTypeName: `${variables.pascalCase}DeleteResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            method: "DELETE",
+            operationId: `delete${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "delete-query",
+            responseContract: "delete-response",
+            summary: `Delete one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    return defineEndpointManifest({
+        contracts,
+        endpoints,
+        info: {
+            title: `${variables.title} REST API`,
+            version: "1.0.0",
+        },
+    });
+}
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for
+ * a workspace-level REST resource scaffold.
+ *
+ * @param options Resource file paths, enabled methods, and naming variables.
+ * @returns A promise that resolves after every generated REST artifact has been refreshed.
+ */
+export async function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
+    const manifest = buildRestResourceEndpointManifest(variables, methods);
+    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+        await syncTypeSchemas({
+            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+            projectRoot: projectDir,
+            sourceTypeName: contract.sourceTypeName,
+            typesFile,
+        });
+    }
+    await syncRestOpenApi({
+        manifest,
+        openApiFile: path.join(outputDir, "api.openapi.json"),
+        projectRoot: projectDir,
+        typesFile,
+    });
+    await syncEndpointClient({
+        clientFile,
+        manifest,
+        projectRoot: projectDir,
+        typesFile,
+        validatorsFile,
+    });
+}