@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/cli-add-workspace-rest-manual-source-emitters.js

@@ -1,238 +1 @@
-import { quoteTsString, } from "./cli-add-shared.js";
-import { formatResolveRestNonceSource, indentMultiline, } from "./cli-add-workspace-rest-source-utils.js";
-import { buildManualRestContractEndpointManifest } from "./rest-resource-artifacts.js";
-import { toPascalCase, toTitleCase } from "./string-case.js";
-/**
- * Build the `REST_RESOURCES` config entry appended for a manual REST contract.
- *
- * @param options Manual contract file, route, type, and auth metadata.
- * @param options.auth Auth intent stored in the endpoint manifest.
- * @param options.bodyTypeName Optional exported body type name.
- * @param options.method Uppercase HTTP method for the external route.
- * @param options.namespace REST namespace such as `vendor/v1`.
- * @param options.pathPattern Route pattern relative to the namespace.
- * @param options.queryTypeName Exported query type name.
- * @param options.responseTypeName Exported response type name.
- * @param options.restResourceSlug Normalized workspace REST contract slug.
- * @returns A TypeScript object literal string for `scripts/block-config.ts`.
- */
-export function buildManualRestContractConfigEntry(options) {
-    const pascalCase = toPascalCase(options.restResourceSlug);
-    const title = toTitleCase(options.restResourceSlug);
-    const manifest = buildManualRestContractEndpointManifest({
-        auth: options.auth,
-        ...(options.bodyTypeName ? { bodyTypeName: options.bodyTypeName } : {}),
-        method: options.method,
-        namespace: options.namespace,
-        pascalCase,
-        pathPattern: options.pathPattern,
-        queryTypeName: options.queryTypeName,
-        responseTypeName: options.responseTypeName,
-        slugKebabCase: options.restResourceSlug,
-        title,
-    });
-    return [
-        "\t{",
-        `\t\tapiFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api.ts`)},`,
-        `\t\tauth: ${quoteTsString(options.auth)},`,
-        ...(options.bodyTypeName
-            ? [`\t\tbodyTypeName: ${quoteTsString(options.bodyTypeName)},`]
-            : []),
-        `\t\tclientFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api-client.ts`)},`,
-        ...(options.controllerClass
-            ? [`\t\tcontrollerClass: ${quoteTsString(options.controllerClass)},`]
-            : []),
-        ...(options.controllerExtends
-            ? [`\t\tcontrollerExtends: ${quoteTsString(options.controllerExtends)},`]
-            : []),
-        `\t\tmethod: ${quoteTsString(options.method)},`,
-        "\t\tmethods: [],",
-        "\t\tmode: 'manual',",
-        `\t\tnamespace: ${quoteTsString(options.namespace)},`,
-        `\t\topenApiFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api.openapi.json`)},`,
-        `\t\tpathPattern: ${quoteTsString(options.pathPattern)},`,
-        ...(options.permissionCallback
-            ? [`\t\tpermissionCallback: ${quoteTsString(options.permissionCallback)},`]
-            : []),
-        `\t\tqueryTypeName: ${quoteTsString(options.queryTypeName)},`,
-        "\t\trestManifest: defineEndpointManifest(",
-        indentMultiline(JSON.stringify(manifest, null, "\t"), "\t\t\t"),
-        "\t\t),",
-        `\t\tresponseTypeName: ${quoteTsString(options.responseTypeName)},`,
-        ...(options.secretFieldName
-            ? [`\t\tsecretFieldName: ${quoteTsString(options.secretFieldName)},`]
-            : []),
-        ...(options.secretPreserveOnEmpty !== undefined
-            ? [`\t\tsecretPreserveOnEmpty: ${options.secretPreserveOnEmpty},`]
-            : []),
-        ...(options.secretStateFieldName
-            ? [`\t\tsecretStateFieldName: ${quoteTsString(options.secretStateFieldName)},`]
-            : []),
-        `\t\tslug: ${quoteTsString(options.restResourceSlug)},`,
-        `\t\ttypesFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api-types.ts`)},`,
-        `\t\tvalidatorsFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api-validators.ts`)},`,
-        "\t},",
-    ].join("\n");
-}
-/**
- * Build the editable TypeScript type source for a manual REST contract.
- *
- * @param options Manual contract type naming metadata.
- * @param options.bodyTypeName Optional exported body type name.
- * @param options.pathParameterNames Route named captures that should be present
- * in the starter query type so generated clients can fill provider paths.
- * @param options.queryTypeName Exported query type name.
- * @param options.responseTypeName Exported response type name.
- * @param options.restResourceSlug Normalized workspace REST contract slug.
- * @param options.secretFieldName Optional raw secret field included only in the request body.
- * @param options.secretStateFieldName Optional masked response boolean field.
- * @returns TypeScript source for `api-types.ts`.
- */
-export function buildManualRestContractTypesSource(options) {
-    const title = toTitleCase(options.restResourceSlug);
-    const pathParameterNames = Array.from(new Set(options.pathParameterNames ?? []));
-    const queryFields = pathParameterNames.length > 0
-        ? pathParameterNames.map((parameterName) => `\t${parameterName}: string & tags.MinLength< 1 >;`)
-        : ["\tid?: string & tags.MinLength< 1 >;"];
-    const lines = [
-        "import type { tags } from '@wp-typia/block-runtime/typia-tags';",
-        "",
-        `export interface ${options.queryTypeName} {`,
-        ...queryFields,
-        ...(pathParameterNames.includes("preview") ? [] : ["\tpreview?: boolean;"]),
-        "}",
-    ];
-    if (options.bodyTypeName) {
-        const secretPreserveOnEmpty = options.secretPreserveOnEmpty ?? true;
-        const secretLines = options.secretFieldName && options.secretStateFieldName
-            ? [
-                `\t${options.secretFieldName}?: string${secretPreserveOnEmpty ? " & tags.MinLength< 1 >" : ""} & tags.MaxLength< 4096 > & tags.Secret< ${quoteTsString(options.secretStateFieldName)} >${secretPreserveOnEmpty ? " & tags.PreserveOnEmpty< true >" : ""};`,
-                secretPreserveOnEmpty
-                    ? `\t// ${options.secretFieldName} is write-only: omit or submit an empty value to preserve the stored secret, and expose ${options.secretStateFieldName} in responses instead of returning the raw value.`
-                    : `\t// ${options.secretFieldName} is write-only: persist it server-side and expose ${options.secretStateFieldName} in responses instead of returning the raw value.`,
-            ]
-            : [];
-        lines.push("", `export interface ${options.bodyTypeName} {`, ...secretLines, "\tpayload: string & tags.MinLength< 1 >;", "\tcomment?: string & tags.MaxLength< 500 >;", "}");
-    }
-    lines.push("", `export interface ${options.responseTypeName} {`, ...(options.secretStateFieldName
-        ? [
-            `\t${options.secretStateFieldName}: boolean;`,
-            `\t// Raw secret fields such as ${options.secretFieldName ?? "the request secret"} must never be returned in this response.`,
-        ]
-        : []), "\tid: string & tags.MinLength< 1 >;", "\tstatus: 'ok' | 'error';", "\tmessage?: string;", "\tupdatedAt?: string;", "}", "", `// ${title} is a manual REST contract: edit these types to match the external route owner.`);
-    return `${lines.join("\n")}\n`;
-}
-/**
- * Build Typia validator source for a manual REST contract.
- *
- * @param options Manual contract type names to validate.
- * @param options.bodyTypeName Optional exported body type name.
- * @param options.queryTypeName Exported query type name.
- * @param options.responseTypeName Exported response type name.
- * @returns TypeScript source for `api-validators.ts`.
- */
-export function buildManualRestContractValidatorsSource(options) {
-    const importedTypes = [
-        options.queryTypeName,
-        ...(options.bodyTypeName ? [options.bodyTypeName] : []),
-        options.responseTypeName,
-    ].sort();
-    const validatorDeclarations = [
-        `const validateQuery = typia.createValidate< ${options.queryTypeName} >();`,
-        ...(options.bodyTypeName
-            ? [`const validateRequest = typia.createValidate< ${options.bodyTypeName} >();`]
-            : []),
-        `const validateResponse = typia.createValidate< ${options.responseTypeName} >();`,
-    ];
-    const validatorEntries = [
-        `\tquery: ( input: unknown ) => toValidationResult< ${options.queryTypeName} >( validateQuery( input ) ),`,
-        ...(options.bodyTypeName
-            ? [
-                `\trequest: ( input: unknown ) => toValidationResult< ${options.bodyTypeName} >( validateRequest( input ) ),`,
-            ]
-            : []),
-        `\tresponse: ( input: unknown ) => toValidationResult< ${options.responseTypeName} >( validateResponse( input ) ),`,
-    ];
-    return `import typia from 'typia';
-
-import { toValidationResult } from '@wp-typia/rest';
-import type {
-\t${importedTypes.join(",\n\t")},
-} from './api-types';
-
-${validatorDeclarations.join("\n")}
-
-export const apiValidators = {
-${validatorEntries.join("\n")}
-};
-`;
-}
-/**
- * Build the public API shim for a manual REST contract.
- *
- * @param options Manual REST contract operation and request type metadata.
- * @returns TypeScript source that re-exports the generated endpoint client.
- */
-export function buildManualRestContractApiSource(options) {
-    const pascalCase = toPascalCase(options.restResourceSlug);
-    const operationId = `call${pascalCase}ManualRestContract`;
-    const requestTypeName = options.bodyTypeName
-        ? `${pascalCase}ManualRestContractRequest`
-        : options.queryTypeName;
-    const requestTypeSource = options.bodyTypeName
-        ? `export interface ${requestTypeName} {
-\tbody: ${options.bodyTypeName};
-\tquery: ${options.queryTypeName};
-}
-
-`
-        : "";
-    const typeImports = options.bodyTypeName
-        ? [options.bodyTypeName, options.queryTypeName]
-        : [options.queryTypeName];
-    return `import {
-\tcallEndpoint,
-\tresolveRestRouteUrl,
-} from '@wp-typia/rest';
-
-import type {
-\t${typeImports.sort().join(",\n\t")},
-} from './api-types';
-import { ${operationId}Endpoint } from './api-client';
-
-export * from './api-client';
-
-${requestTypeSource}${formatResolveRestNonceSource("compact")}
-
-function resolveEndpointRouteOptions(request: ${requestTypeName}) {
-\tconst requestOptions = ${operationId}Endpoint.buildRequestOptions?.(request) ?? {};
-\tconst nonce = resolveRestNonce();
-\tconst requestHeaders = (
-\t\trequestOptions as { headers?: Record<string, string> }
-\t).headers;
-
-\treturn {
-\t\t...requestOptions,
-\t\theaders: nonce
-\t\t\t? {
-\t\t\t\t\t...(requestHeaders ?? {}),
-\t\t\t\t\t'X-WP-Nonce': nonce,
-\t\t\t\t}
-\t\t\t: requestHeaders,
-\t\tpath: undefined,
-\t\turl:
-\t\t\trequestOptions.url ??
-\t\t\tresolveRestRouteUrl(requestOptions.path ?? ${operationId}Endpoint.path),
-\t};
-}
-
-export const manualRestContractEndpoint = {
-\t...${operationId}Endpoint,
-\tbuildRequestOptions: resolveEndpointRouteOptions,
-};
-
-export function callManualRestContract(request: ${requestTypeName}) {
-\treturn callEndpoint(manualRestContractEndpoint, request);
-}
-`;
-}
+export * from "./add/cli-add-workspace-rest-manual-source-emitters.js";

package/dist/runtime/cli-add-workspace-rest-manual.d.ts

@@ -1,8 +1 @@
-import { type ManualRestContractScaffoldOptions, type RunAddRestResourceCommandResult } from "./cli-add-workspace-rest-types.js";
-/**
- * Scaffold a type-only external REST contract for workspace consumers.
- *
- * @param options Resolved workspace and raw manual-mode command options.
- * @returns Resolved scaffold metadata for the manual REST contract.
- */
-export declare function scaffoldManualRestContract({ auth, bodyTypeName, controllerClass, controllerExtends, method, namespace, pathPattern, permissionCallback, queryTypeName, responseTypeName, restResourceSlug, routePattern, secretFieldName, secretHasValueFieldName, secretMaskedResponseFieldName, secretPreserveOnEmpty, secretStateFieldName, workspace, }: ManualRestContractScaffoldOptions): Promise<RunAddRestResourceCommandResult>;
+export * from "./add/cli-add-workspace-rest-manual.js";

package/dist/runtime/cli-add-workspace-rest-manual.js

@@ -1,266 +1 @@
-import { promises as fsp } from "node:fs";
-import path from "node:path";
-import { ensureBlockConfigCanAddRestManifests } from "./cli-add-block-legacy-validator.js";
-import { assertValidManualRestContractAuth, assertValidManualRestContractHttpMethod, assertValidTypeScriptIdentifier, collectRestRouteNamedCaptureNames, resolveOptionalPhpCallbackReference, resolveOptionalPhpClassReference, resolveManualRestContractPathPattern, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
-import { ensureRestResourceSyncScriptAnchors, } from "./cli-add-workspace-rest-resource-sync-anchors.js";
-import { buildManualRestContractApiSource, buildManualRestContractConfigEntry, buildManualRestContractTypesSource, buildManualRestContractValidatorsSource, } from "./cli-add-workspace-rest-manual-source-emitters.js";
-import { syncManualRestContractArtifacts } from "./rest-resource-artifacts.js";
-import { toPascalCase, toTitleCase } from "./string-case.js";
-import { appendWorkspaceInventoryEntries } from "./workspace-inventory.js";
-const MANUAL_REST_REQUEST_BODY_FIELD_NAMES = new Set(["payload", "comment"]);
-const MANUAL_REST_RESPONSE_FIELD_NAMES = new Set([
-    "id",
-    "status",
-    "message",
-    "updatedAt",
-]);
-function resolveManualRestSecretPreserveOnEmpty(value) {
-    return value ?? true;
-}
-function resolveManualRestSecretStateFieldCandidate(options) {
-    const candidates = [
-        options.secretStateFieldName,
-        options.secretHasValueFieldName,
-        options.secretMaskedResponseFieldName,
-    ].filter((value) => typeof value === "string");
-    const distinct = Array.from(new Set(candidates));
-    if (distinct.length > 1) {
-        throw new Error("Manual REST contract secret state, has-value, and masked response field flags must match when combined.");
-    }
-    return distinct[0];
-}
-function resolveManualRestRoutePathPattern(options) {
-    const trimmedPathPattern = typeof options.pathPattern === "string"
-        ? options.pathPattern.trim()
-        : undefined;
-    const trimmedRoutePattern = typeof options.routePattern === "string"
-        ? options.routePattern.trim()
-        : undefined;
-    if (trimmedPathPattern &&
-        trimmedRoutePattern &&
-        trimmedPathPattern !== trimmedRoutePattern) {
-        throw new Error("Manual REST contract --path and --route-pattern must match when both are provided. Use one route pattern flag for provider routes.");
-    }
-    return resolveManualRestContractPathPattern(options.restResourceSlug, options.pathPattern ?? options.routePattern);
-}
-/**
- * Scaffold a type-only external REST contract for workspace consumers.
- *
- * @param options Resolved workspace and raw manual-mode command options.
- * @returns Resolved scaffold metadata for the manual REST contract.
- */
-export async function scaffoldManualRestContract({ auth, bodyTypeName, controllerClass, controllerExtends, method, namespace, pathPattern, permissionCallback, queryTypeName, responseTypeName, restResourceSlug, routePattern, secretFieldName, secretHasValueFieldName, secretMaskedResponseFieldName, secretPreserveOnEmpty, secretStateFieldName, workspace, }) {
-    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
-    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-    const restResourceDir = path.join(workspace.projectDir, "src", "rest", restResourceSlug);
-    const typesFilePath = path.join(restResourceDir, "api-types.ts");
-    const validatorsFilePath = path.join(restResourceDir, "api-validators.ts");
-    const apiFilePath = path.join(restResourceDir, "api.ts");
-    const pascalCase = toPascalCase(restResourceSlug);
-    const resolvedAuth = assertValidManualRestContractAuth(auth);
-    const resolvedMethod = assertValidManualRestContractHttpMethod(method);
-    const resolvedPathPattern = resolveManualRestRoutePathPattern({
-        pathPattern,
-        restResourceSlug,
-        routePattern,
-    });
-    const pathParameterNames = collectRestRouteNamedCaptureNames(resolvedPathPattern);
-    const resolvedPermissionCallback = resolveOptionalPhpCallbackReference("Manual REST contract permission callback", permissionCallback);
-    const resolvedControllerClass = resolveOptionalPhpClassReference("Manual REST contract controller class", controllerClass);
-    const resolvedControllerExtends = resolveOptionalPhpClassReference("Manual REST contract controller base class", controllerExtends);
-    if (resolvedControllerExtends && !resolvedControllerClass) {
-        throw new Error("Manual REST contract controller base class requires --controller-class.");
-    }
-    const resolvedQueryTypeName = assertValidTypeScriptIdentifier("Manual REST contract query type", queryTypeName ?? `${pascalCase}Query`, "wp-typia add rest-resource <name> --manual [--query-type <ExportedQueryType>]");
-    const resolvedResponseTypeName = assertValidTypeScriptIdentifier("Manual REST contract response type", responseTypeName ?? `${pascalCase}Response`, "wp-typia add rest-resource <name> --manual [--response-type <ExportedResponseType>]");
-    const defaultsToBody = bodyTypeName == null && ["PATCH", "POST", "PUT"].includes(resolvedMethod);
-    const resolvedBodyTypeName = bodyTypeName != null || defaultsToBody
-        ? assertValidTypeScriptIdentifier("Manual REST contract body type", bodyTypeName ?? `${pascalCase}Request`, "wp-typia add rest-resource <name> --manual [--body-type <ExportedBodyType>]")
-        : undefined;
-    if (resolvedMethod === "GET" && resolvedBodyTypeName) {
-        throw new Error("Manual REST contract GET routes cannot define a body type. Remove --body-type or use POST, PUT, or PATCH.");
-    }
-    const secretStateFieldCandidate = resolveManualRestSecretStateFieldCandidate({
-        secretHasValueFieldName,
-        secretMaskedResponseFieldName,
-        secretStateFieldName,
-    });
-    if (secretPreserveOnEmpty !== undefined && !secretFieldName) {
-        throw new Error("Manual REST contract --secret-preserve-on-empty requires --secret-field.");
-    }
-    if (secretStateFieldCandidate !== undefined && !secretFieldName) {
-        throw new Error("Manual REST contract secret state, has-value, and masked response field flags require --secret-field.");
-    }
-    if (secretFieldName && !resolvedBodyTypeName) {
-        throw new Error("Manual REST contract secret fields require a request body. Use POST, PUT, or PATCH so a request body is generated.");
-    }
-    const resolvedSecretFieldName = secretFieldName
-        ? assertValidTypeScriptIdentifier("Manual REST contract secret field", secretFieldName, "wp-typia add rest-resource <name> --manual --method POST --secret-field <field>")
-        : undefined;
-    const resolvedSecretPreserveOnEmpty = resolvedSecretFieldName
-        ? resolveManualRestSecretPreserveOnEmpty(secretPreserveOnEmpty)
-        : undefined;
-    const resolvedSecretStateFieldName = resolvedSecretFieldName
-        ? assertValidTypeScriptIdentifier("Manual REST contract secret state field", secretStateFieldCandidate ??
-            `has${toPascalCase(resolvedSecretFieldName)}`, "wp-typia add rest-resource <name> --manual --method POST --secret-state-field <field>")
-        : undefined;
-    if (resolvedSecretFieldName &&
-        MANUAL_REST_REQUEST_BODY_FIELD_NAMES.has(resolvedSecretFieldName)) {
-        throw new Error(`Manual REST contract secret field must not reuse scaffolded request body fields: ${Array.from(MANUAL_REST_REQUEST_BODY_FIELD_NAMES).join(", ")}.`);
-    }
-    if (resolvedSecretStateFieldName &&
-        MANUAL_REST_RESPONSE_FIELD_NAMES.has(resolvedSecretStateFieldName)) {
-        throw new Error(`Manual REST contract secret state field must not reuse scaffolded response fields: ${Array.from(MANUAL_REST_RESPONSE_FIELD_NAMES).join(", ")}.`);
-    }
-    if (resolvedSecretFieldName &&
-        resolvedSecretStateFieldName &&
-        resolvedSecretFieldName === resolvedSecretStateFieldName) {
-        throw new Error("Manual REST contract secret state field must be different from the raw secret field.");
-    }
-    const manualTypeNames = [
-        resolvedQueryTypeName,
-        resolvedResponseTypeName,
-        resolvedBodyTypeName,
-    ].filter((value) => value != null);
-    const duplicateManualTypeNames = manualTypeNames.filter((name, index) => manualTypeNames.indexOf(name) !== index);
-    if (duplicateManualTypeNames.length > 0) {
-        throw new Error(`Manual REST contract type names must be unique: ${Array.from(new Set(duplicateManualTypeNames)).join(", ")}. Use distinct --query-type, --body-type, and --response-type values.`);
-    }
-    const mutationSnapshot = {
-        fileSources: await snapshotWorkspaceFiles([
-            blockConfigPath,
-            syncRestScriptPath,
-        ]),
-        snapshotDirs: [],
-        targetPaths: [restResourceDir],
-    };
-    try {
-        await fsp.mkdir(restResourceDir, { recursive: true });
-        await ensureRestResourceSyncScriptAnchors(workspace);
-        await fsp.writeFile(typesFilePath, buildManualRestContractTypesSource({
-            ...(resolvedBodyTypeName
-                ? { bodyTypeName: resolvedBodyTypeName }
-                : {}),
-            pathParameterNames,
-            queryTypeName: resolvedQueryTypeName,
-            responseTypeName: resolvedResponseTypeName,
-            restResourceSlug,
-            ...(resolvedSecretFieldName
-                ? { secretFieldName: resolvedSecretFieldName }
-                : {}),
-            ...(resolvedSecretPreserveOnEmpty !== undefined
-                ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty }
-                : {}),
-            ...(resolvedSecretStateFieldName
-                ? { secretStateFieldName: resolvedSecretStateFieldName }
-                : {}),
-        }), "utf8");
-        await fsp.writeFile(validatorsFilePath, buildManualRestContractValidatorsSource({
-            ...(resolvedBodyTypeName
-                ? { bodyTypeName: resolvedBodyTypeName }
-                : {}),
-            queryTypeName: resolvedQueryTypeName,
-            responseTypeName: resolvedResponseTypeName,
-        }), "utf8");
-        await fsp.writeFile(apiFilePath, buildManualRestContractApiSource({
-            ...(resolvedBodyTypeName
-                ? { bodyTypeName: resolvedBodyTypeName }
-                : {}),
-            queryTypeName: resolvedQueryTypeName,
-            restResourceSlug,
-        }), "utf8");
-        await syncManualRestContractArtifacts({
-            clientFile: `src/rest/${restResourceSlug}/api-client.ts`,
-            outputDir: restResourceDir,
-            projectDir: workspace.projectDir,
-            typesFile: `src/rest/${restResourceSlug}/api-types.ts`,
-            validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
-            variables: {
-                auth: resolvedAuth,
-                ...(resolvedBodyTypeName
-                    ? { bodyTypeName: resolvedBodyTypeName }
-                    : {}),
-                method: resolvedMethod,
-                namespace,
-                pascalCase,
-                pathPattern: resolvedPathPattern,
-                queryTypeName: resolvedQueryTypeName,
-                responseTypeName: resolvedResponseTypeName,
-                slugKebabCase: restResourceSlug,
-                title: toTitleCase(restResourceSlug),
-            },
-        });
-        await appendWorkspaceInventoryEntries(workspace.projectDir, {
-            restResourceEntries: [
-                buildManualRestContractConfigEntry({
-                    auth: resolvedAuth,
-                    ...(resolvedBodyTypeName
-                        ? { bodyTypeName: resolvedBodyTypeName }
-                        : {}),
-                    ...(resolvedControllerClass
-                        ? { controllerClass: resolvedControllerClass }
-                        : {}),
-                    ...(resolvedControllerExtends
-                        ? { controllerExtends: resolvedControllerExtends }
-                        : {}),
-                    method: resolvedMethod,
-                    namespace,
-                    pathPattern: resolvedPathPattern,
-                    ...(resolvedPermissionCallback
-                        ? { permissionCallback: resolvedPermissionCallback }
-                        : {}),
-                    queryTypeName: resolvedQueryTypeName,
-                    responseTypeName: resolvedResponseTypeName,
-                    restResourceSlug,
-                    ...(resolvedSecretFieldName
-                        ? { secretFieldName: resolvedSecretFieldName }
-                        : {}),
-                    ...(resolvedSecretPreserveOnEmpty !== undefined
-                        ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty }
-                        : {}),
-                    ...(resolvedSecretStateFieldName
-                        ? { secretStateFieldName: resolvedSecretStateFieldName }
-                        : {}),
-                }),
-            ],
-            transformSource: ensureBlockConfigCanAddRestManifests,
-        });
-        return {
-            auth: resolvedAuth,
-            ...(resolvedBodyTypeName
-                ? { bodyTypeName: resolvedBodyTypeName }
-                : {}),
-            ...(resolvedControllerClass
-                ? { controllerClass: resolvedControllerClass }
-                : {}),
-            ...(resolvedControllerExtends
-                ? { controllerExtends: resolvedControllerExtends }
-                : {}),
-            method: resolvedMethod,
-            methods: [],
-            mode: "manual",
-            namespace,
-            pathPattern: resolvedPathPattern,
-            ...(resolvedPermissionCallback
-                ? { permissionCallback: resolvedPermissionCallback }
-                : {}),
-            projectDir: workspace.projectDir,
-            queryTypeName: resolvedQueryTypeName,
-            restResourceSlug,
-            responseTypeName: resolvedResponseTypeName,
-            ...(resolvedSecretFieldName
-                ? { secretFieldName: resolvedSecretFieldName }
-                : {}),
-            ...(resolvedSecretPreserveOnEmpty !== undefined
-                ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty }
-                : {}),
-            ...(resolvedSecretStateFieldName
-                ? { secretStateFieldName: resolvedSecretStateFieldName }
-                : {}),
-        };
-    }
-    catch (error) {
-        await rollbackWorkspaceMutation(mutationSnapshot);
-        throw error;
-    }
-}
+export * from "./add/cli-add-workspace-rest-manual.js";

package/dist/runtime/cli-add-workspace-rest-php-templates.d.ts

@@ -1,18 +1 @@
-import { type RestResourceMethodId } from "./cli-add-shared.js";
-export { buildWorkspaceRestSchemaHelperPhpSource, } from "./cli-add-workspace-rest-schema-helper-php-template.js";
-/**
- * Build the PHP route/controller glue for generated workspace REST resources.
- *
- * @param restResourceSlug Normalized REST resource slug.
- * @param namespace WordPress REST namespace, such as `vendor/v1`.
- * @param phpPrefix Plugin PHP function prefix.
- * @param methods REST operations to expose.
- * @param options Optional generated route and controller customizations.
- * @returns A complete PHP source file for the generated REST resource.
- */
-export declare function buildRestResourcePhpSource(restResourceSlug: string, namespace: string, phpPrefix: string, methods: RestResourceMethodId[], options: {
-    controllerClass?: string;
-    controllerExtends?: string;
-    permissionCallback?: string;
-    routePattern: string;
-}): string;
+export * from "./add/cli-add-workspace-rest-php-templates.js";