@wp-typia/project-tools 0.24.3 → 0.24.5

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

@@ -0,0 +1,254 @@
+import path from "node:path";
+import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+function resolveManualRestContractWordPressAuth(auth) {
+    if (auth === "authenticated") {
+        return {
+            mechanism: "rest-nonce",
+        };
+    }
+    if (auth === "public-write-protected") {
+        return {
+            mechanism: "public-signed-token",
+        };
+    }
+    return undefined;
+}
+/**
+ * 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 routePattern = variables.routePattern == null
+        ? `/${variables.slugKebabCase}/item`
+        : variables.routePattern.startsWith("/")
+            ? variables.routePattern
+            : `/${variables.routePattern}`;
+    const itemPath = `/${variables.namespace}${routePattern}`;
+    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",
+        },
+    });
+}
+/**
+ * Build the endpoint manifest for a type-only manual REST contract. Manual
+ * contracts describe routes owned by another integration without generating PHP
+ * route glue in the workspace.
+ *
+ * @param variables Template naming data used for contract names, route path,
+ * and OpenAPI info.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export function buildManualRestContractEndpointManifest(variables) {
+    const contracts = {
+        query: {
+            sourceTypeName: variables.queryTypeName,
+        },
+        response: {
+            sourceTypeName: variables.responseTypeName,
+        },
+    };
+    if (variables.bodyTypeName) {
+        contracts.request = {
+            sourceTypeName: variables.bodyTypeName,
+        };
+    }
+    const wordpressAuth = resolveManualRestContractWordPressAuth(variables.auth);
+    return defineEndpointManifest({
+        contracts,
+        endpoints: [
+            {
+                auth: variables.auth,
+                ...(variables.bodyTypeName ? { bodyContract: "request" } : {}),
+                method: variables.method,
+                operationId: `call${variables.pascalCase}ManualRestContract`,
+                path: `/${variables.namespace}${variables.pathPattern}`,
+                queryContract: "query",
+                responseContract: "response",
+                summary: `Call external ${variables.title} REST route.`,
+                tags: [variables.title],
+                ...(wordpressAuth ? { wordpressAuth } : {}),
+            },
+        ],
+        info: {
+            title: `${variables.title} Manual REST Contract`,
+            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,
+    });
+}
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
+ * type-only manual REST contract.
+ *
+ * @param options Contract file paths and naming variables.
+ * @returns A promise that resolves after every generated artifact has refreshed.
+ */
+export async function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
+    const manifest = buildManualRestContractEndpointManifest(variables);
+    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,
+    });
+}

package/dist/runtime/ai-artifacts.d.ts

@@ -1,39 +1 @@
-import type { ArtifactSyncExecutionOptions } from '@wp-typia/block-runtime/metadata-core';
-import { buildWordPressAiArtifacts, type ProjectedWordPressAbilitiesDocument } from './wordpress-ai.js';
-export { buildWordPressAiArtifacts, buildWordPressAbilitiesDocument, projectWordPressAiSchema, } from './wordpress-ai.js';
-export type { AbilityAnnotationSpec, AbilityCategorySpec, AbilityMcpProjectionSpec, AbilityMetaSpec, AbilitySpec, AbilitySpecCatalog, ProjectedWordPressAbilityDefinition, ProjectedWordPressAbilitiesDocument, WordPressAiInputSchemaTransformContext, } from './wordpress-ai.js';
-type BuildWordPressAiArtifactsParameters = Parameters<typeof buildWordPressAiArtifacts>[0];
-/**
- * Configures where the generated WordPress AI artifacts should be written or
- * verified on disk.
- */
-export interface SyncWordPressAiArtifactsOptions extends ArtifactSyncExecutionOptions, BuildWordPressAiArtifactsParameters {
-    /** Destination path for the generated `*.abilities.json` document. */
-    abilitiesDocumentFile: string;
-    /** Destination path for the generated `*.ai.schema.json` document. */
-    aiSchemaFile: string;
-}
-/**
- * Describes the generated artifact payloads and the file paths they were
- * written to or verified against.
- */
-export interface SyncWordPressAiArtifactsResult {
-    /** Generated abilities document content. */
-    abilitiesDocument: ProjectedWordPressAbilitiesDocument;
-    /** Destination path for the generated abilities document. */
-    abilitiesDocumentPath: string;
-    /** Generated AI response schema content. */
-    aiResponseSchema: Record<string, unknown>;
-    /** Destination path for the generated AI response schema. */
-    aiSchemaPath: string;
-    /** True when files were only verified, false when they were written. */
-    check: boolean;
-}
-/**
- * Builds WordPress AI artifact documents from a manifest-first contract surface
- * and then writes or verifies the generated JSON files on disk.
- *
- * @param options Artifact destinations plus the same manifest/category/schema inputs used by `buildWordPressAiArtifacts()`.
- * @returns Generated documents and the output file paths that were checked or written.
- */
-export declare function syncWordPressAiArtifacts({ abilitiesDocumentFile, aiSchemaFile, check, ...buildOptions }: SyncWordPressAiArtifactsOptions): Promise<SyncWordPressAiArtifactsResult>;
+export * from "./schema/ai-artifacts.js";

package/dist/runtime/ai-artifacts.js

@@ -1,67 +1 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { buildWordPressAiArtifacts, } from './wordpress-ai.js';
-import { getOptionalNodeErrorCode, isFileNotFoundError, } from './fs-async.js';
-export { buildWordPressAiArtifacts, buildWordPressAbilitiesDocument, projectWordPressAiSchema, } from './wordpress-ai.js';
-function normalizeGeneratedArtifactContent(content) {
-    return content.replace(/\r\n?/g, '\n');
-}
-async function reconcileGeneratedAiArtifacts(artifacts, check) {
-    if (!check) {
-        for (const artifact of artifacts) {
-            await mkdir(path.dirname(artifact.filePath), {
-                recursive: true,
-            });
-            await writeFile(artifact.filePath, artifact.content, 'utf8');
-        }
-        return;
-    }
-    const issues = [];
-    for (const artifact of artifacts) {
-        try {
-            const current = normalizeGeneratedArtifactContent(await readFile(artifact.filePath, 'utf8'));
-            const expected = normalizeGeneratedArtifactContent(artifact.content);
-            if (current !== expected) {
-                issues.push(`- ${artifact.filePath} (stale)`);
-            }
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                issues.push(`- ${artifact.filePath} (missing)`);
-                continue;
-            }
-            const code = getOptionalNodeErrorCode(error);
-            issues.push(`- ${artifact.filePath} (unreadable: ${error instanceof Error ? error.message : code ?? 'unknown'})`);
-        }
-    }
-    if (issues.length > 0) {
-        throw new Error(`Generated WordPress AI artifacts are missing or stale:\n${issues.join('\n')}`);
-    }
-}
-/**
- * Builds WordPress AI artifact documents from a manifest-first contract surface
- * and then writes or verifies the generated JSON files on disk.
- *
- * @param options Artifact destinations plus the same manifest/category/schema inputs used by `buildWordPressAiArtifacts()`.
- * @returns Generated documents and the output file paths that were checked or written.
- */
-export async function syncWordPressAiArtifacts({ abilitiesDocumentFile, aiSchemaFile, check = false, ...buildOptions }) {
-    const { abilitiesDocument, aiResponseSchema } = await buildWordPressAiArtifacts(buildOptions);
-    await reconcileGeneratedAiArtifacts([
-        {
-            content: `${JSON.stringify(aiResponseSchema, null, 2)}\n`,
-            filePath: aiSchemaFile,
-        },
-        {
-            content: `${JSON.stringify(abilitiesDocument, null, 2)}\n`,
-            filePath: abilitiesDocumentFile,
-        },
-    ], check);
-    return {
-        abilitiesDocument,
-        abilitiesDocumentPath: abilitiesDocumentFile,
-        aiResponseSchema,
-        aiSchemaPath: aiSchemaFile,
-        check,
-    };
-}
+export * from "./schema/ai-artifacts.js";

package/dist/runtime/ai-feature-artifacts.d.ts

@@ -1,85 +1 @@
-import { type ArtifactSyncExecutionOptions } from "@wp-typia/block-runtime/metadata-core";
-import type { JsonSchemaDocument } from "./schema-core.js";
-interface AiFeatureTemplateVariablesLike {
-    namespace: string;
-    pascalCase: string;
-    slugKebabCase: string;
-    title: string;
-}
-interface SyncAiFeatureRestArtifactsOptions {
-    clientFile: string;
-    executionOptions?: ArtifactSyncExecutionOptions;
-    outputDir: string;
-    projectDir: string;
-    typesFile: string;
-    validatorsFile: string;
-    variables: AiFeatureTemplateVariablesLike;
-}
-/**
- * Configures the AI-safe schema projection for one scaffolded AI feature.
- */
-export interface SyncAiFeatureSchemaArtifactOptions extends ArtifactSyncExecutionOptions {
-    aiSchemaFile: string;
-    outputDir: string;
-    projectDir: string;
-}
-/**
- * Carries the generated AI schema document and the file paths touched on disk.
- */
-export interface SyncAiFeatureSchemaArtifactResult {
-    aiSchema: JsonSchemaDocument & Record<string, unknown>;
-    aiSchemaPath: string;
-    check: boolean;
-    sourceSchemaPath: string;
-}
-/**
- * Build the endpoint manifest for a workspace-level AI feature scaffold.
- *
- * The endpoint response wraps a typed AI result payload together with provider,
- * model, and token-usage telemetry. The nested `feature-result` contract is
- * also kept in the manifest so `sync-rest` can emit the canonical JSON Schema
- * that `sync-ai` later projects into the AI structured-output profile.
- *
- * @param variables Template naming data used for type names, routes, and docs.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export declare function buildAiFeatureEndpointManifest(variables: AiFeatureTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<{
-    readonly "feature-request": {
-        readonly sourceTypeName: `${string}AiFeatureRequest`;
-    };
-    readonly "feature-response": {
-        readonly sourceTypeName: `${string}AiFeatureResponse`;
-    };
-    readonly "feature-result": {
-        readonly sourceTypeName: `${string}AiFeatureResult`;
-    };
-}, readonly [{
-    readonly auth: "authenticated";
-    readonly bodyContract: "feature-request";
-    readonly method: "POST";
-    readonly operationId: `run${string}AiFeature`;
-    readonly path: `/${string}/ai/${string}`;
-    readonly responseContract: "feature-response";
-    readonly summary: `Run the ${string} AI feature endpoint.`;
-    readonly tags: readonly [`${string} AI`];
-    readonly wordpressAuth: {
-        readonly mechanism: "rest-nonce";
-    };
-}]>;
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for
- * a workspace-level AI feature scaffold.
- *
- * @param options Feature file paths and naming variables.
- * @returns A promise that resolves after every generated REST artifact has been refreshed.
- */
-export declare function syncAiFeatureRestArtifacts({ clientFile, executionOptions, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncAiFeatureRestArtifactsOptions): Promise<void>;
-/**
- * Project the canonical AI result contract for one scaffolded feature into the
- * AI structured-output schema profile consumed by `wp_ai_client_prompt()`.
- *
- * @param options Artifact destination plus the feature output directory.
- * @returns The projected AI schema and the source schema path it derived from.
- */
-export declare function syncAiFeatureSchemaArtifact({ aiSchemaFile, check, outputDir, projectDir, }: SyncAiFeatureSchemaArtifactOptions): Promise<SyncAiFeatureSchemaArtifactResult>;
-export {};
+export * from "./add/ai-feature-artifacts.js";

package/dist/runtime/ai-feature-artifacts.js

@@ -1,140 +1 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
-import { projectWordPressAiSchema } from "./ai-artifacts.js";
-import { isFileNotFoundError } from "./fs-async.js";
-import { readJsonFile } from "./json-utils.js";
-function normalizeGeneratedArtifactContent(content) {
-    return content.replace(/\r\n?/g, "\n");
-}
-async function reconcileGeneratedArtifact(options) {
-    if (!options.check) {
-        await mkdir(path.dirname(options.filePath), {
-            recursive: true,
-        });
-        await writeFile(options.filePath, options.content, "utf8");
-        return;
-    }
-    try {
-        const current = normalizeGeneratedArtifactContent(await readFile(options.filePath, "utf8"));
-        const expected = normalizeGeneratedArtifactContent(options.content);
-        if (current !== expected) {
-            throw new Error(`Generated AI feature artifact is stale: ${options.label} (${options.filePath}).`);
-        }
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            throw new Error(`Generated AI feature artifact is missing: ${options.label} (${options.filePath}).`);
-        }
-        throw error;
-    }
-}
-function assertJsonObject(value, label) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`Expected ${label} to decode to a JSON object.`);
-    }
-    return value;
-}
-/**
- * Build the endpoint manifest for a workspace-level AI feature scaffold.
- *
- * The endpoint response wraps a typed AI result payload together with provider,
- * model, and token-usage telemetry. The nested `feature-result` contract is
- * also kept in the manifest so `sync-rest` can emit the canonical JSON Schema
- * that `sync-ai` later projects into the AI structured-output profile.
- *
- * @param variables Template naming data used for type names, routes, and docs.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export function buildAiFeatureEndpointManifest(variables) {
-    return defineEndpointManifest({
-        contracts: {
-            "feature-request": {
-                sourceTypeName: `${variables.pascalCase}AiFeatureRequest`,
-            },
-            "feature-response": {
-                sourceTypeName: `${variables.pascalCase}AiFeatureResponse`,
-            },
-            "feature-result": {
-                sourceTypeName: `${variables.pascalCase}AiFeatureResult`,
-            },
-        },
-        endpoints: [
-            {
-                auth: "authenticated",
-                bodyContract: "feature-request",
-                method: "POST",
-                operationId: `run${variables.pascalCase}AiFeature`,
-                path: `/${variables.namespace}/ai/${variables.slugKebabCase}`,
-                responseContract: "feature-response",
-                summary: `Run the ${variables.title} AI feature endpoint.`,
-                tags: [`${variables.title} AI`],
-                wordpressAuth: {
-                    mechanism: "rest-nonce",
-                },
-            },
-        ],
-        info: {
-            title: `${variables.title} AI Feature API`,
-            version: "1.0.0",
-        },
-    });
-}
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for
- * a workspace-level AI feature scaffold.
- *
- * @param options Feature file paths and naming variables.
- * @returns A promise that resolves after every generated REST artifact has been refreshed.
- */
-export async function syncAiFeatureRestArtifacts({ clientFile, executionOptions, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
-    const manifest = buildAiFeatureEndpointManifest(variables);
-    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,
-        }, executionOptions);
-    }
-    await syncRestOpenApi({
-        manifest,
-        openApiFile: path.join(outputDir, "api.openapi.json"),
-        projectRoot: projectDir,
-        typesFile,
-    }, executionOptions);
-    await syncEndpointClient({
-        clientFile,
-        manifest,
-        projectRoot: projectDir,
-        typesFile,
-        validatorsFile,
-    }, executionOptions);
-}
-/**
- * Project the canonical AI result contract for one scaffolded feature into the
- * AI structured-output schema profile consumed by `wp_ai_client_prompt()`.
- *
- * @param options Artifact destination plus the feature output directory.
- * @returns The projected AI schema and the source schema path it derived from.
- */
-export async function syncAiFeatureSchemaArtifact({ aiSchemaFile, check = false, outputDir, projectDir, }) {
-    const sourceSchemaPath = path.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
-    const responseSchema = assertJsonObject(await readJsonFile(sourceSchemaPath, {
-        context: "AI feature response schema",
-    }), sourceSchemaPath);
-    const aiSchema = projectWordPressAiSchema(responseSchema);
-    await reconcileGeneratedArtifact({
-        check,
-        content: `${JSON.stringify(aiSchema, null, 2)}\n`,
-        filePath: path.join(projectDir, aiSchemaFile),
-        label: "AI feature schema",
-    });
-    return {
-        aiSchema,
-        aiSchemaPath: path.join(projectDir, aiSchemaFile),
-        check,
-        sourceSchemaPath,
-    };
-}
+export * from "./add/ai-feature-artifacts.js";