@wp-typia/project-tools 0.23.0 → 0.23.1

package/dist/runtime/workspace-inventory-parser.js

@@ -1,585 +1,7 @@
 import ts from "typescript";
-import { MANUAL_REST_CONTRACT_AUTH_IDS, MANUAL_REST_CONTRACT_HTTP_METHOD_IDS, REST_RESOURCE_METHOD_IDS, } from "./cli-add-shared.js";
-import { getPropertyNameText } from "./ts-property-names.js";
-import { ABILITY_CONFIG_ENTRY_MARKER, ABILITIES_CONST_SECTION, ABILITIES_INTERFACE_SECTION, ADMIN_VIEW_CONFIG_ENTRY_MARKER, ADMIN_VIEWS_CONST_SECTION, ADMIN_VIEWS_INTERFACE_SECTION, AI_FEATURES_CONST_SECTION, AI_FEATURES_INTERFACE_SECTION, AI_FEATURE_CONFIG_ENTRY_MARKER, BINDING_SOURCES_CONST_SECTION, BINDING_SOURCES_INTERFACE_SECTION, BINDING_SOURCE_CONFIG_ENTRY_MARKER, CONTRACTS_CONST_SECTION, CONTRACTS_INTERFACE_SECTION, CONTRACT_CONFIG_ENTRY_MARKER, BLOCK_CONFIG_ENTRY_MARKER, BLOCK_STYLES_CONST_SECTION, BLOCK_STYLES_INTERFACE_SECTION, BLOCK_STYLE_CONFIG_ENTRY_MARKER, BLOCK_TRANSFORMS_CONST_SECTION, BLOCK_TRANSFORMS_INTERFACE_SECTION, BLOCK_TRANSFORM_CONFIG_ENTRY_MARKER, EDITOR_PLUGINS_CONST_SECTION, EDITOR_PLUGINS_INTERFACE_SECTION, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, PATTERNS_CONST_SECTION, PATTERNS_INTERFACE_SECTION, PATTERN_CONFIG_ENTRY_MARKER, POST_META_CONFIG_ENTRY_MARKER, POST_META_CONST_SECTION, POST_META_INTERFACE_SECTION, REST_RESOURCES_CONST_SECTION, REST_RESOURCES_INTERFACE_SECTION, REST_RESOURCE_CONFIG_ENTRY_MARKER, VARIATIONS_CONST_SECTION, VARIATIONS_INTERFACE_SECTION, VARIATION_CONFIG_ENTRY_MARKER, } from "./workspace-inventory-templates.js";
-function defineInventoryEntryParser() {
-    return (descriptor) => descriptor;
-}
-export const BLOCK_INVENTORY_SECTION = {
-    append: {
-        marker: BLOCK_CONFIG_ENTRY_MARKER,
-        optionKey: "blockEntries",
-    },
-    parse: {
-        entriesKey: "blocks",
-        entry: defineInventoryEntryParser()({
-            entryName: "BLOCKS",
-            fields: [
-                { key: "apiTypesFile" },
-                { key: "attributeTypeName" },
-                { key: "openApiFile" },
-                { key: "slug", required: true },
-                { key: "typesFile", required: true },
-            ],
-        }),
-        exportName: "BLOCKS",
-        required: true,
-    },
-};
-export const INVENTORY_SECTIONS = [
-    {
-        append: {
-            marker: VARIATION_CONFIG_ENTRY_MARKER,
-            optionKey: "variationEntries",
-        },
-        interface: {
-            name: "WorkspaceVariationConfig",
-            section: VARIATIONS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "variations",
-            entry: defineInventoryEntryParser()({
-                entryName: "VARIATIONS",
-                fields: [
-                    { key: "block", required: true },
-                    { key: "file", required: true },
-                    { key: "slug", required: true },
-                ],
-            }),
-            hasSectionKey: "hasVariationsSection",
-        },
-        value: {
-            name: "VARIATIONS",
-            section: VARIATIONS_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: BLOCK_STYLE_CONFIG_ENTRY_MARKER,
-            optionKey: "blockStyleEntries",
-        },
-        interface: {
-            name: "WorkspaceBlockStyleConfig",
-            section: BLOCK_STYLES_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "blockStyles",
-            entry: defineInventoryEntryParser()({
-                entryName: "BLOCK_STYLES",
-                fields: [
-                    { key: "block", required: true },
-                    { key: "file", required: true },
-                    { key: "slug", required: true },
-                ],
-            }),
-            hasSectionKey: "hasBlockStylesSection",
-        },
-        value: {
-            name: "BLOCK_STYLES",
-            section: BLOCK_STYLES_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: BLOCK_TRANSFORM_CONFIG_ENTRY_MARKER,
-            optionKey: "blockTransformEntries",
-        },
-        interface: {
-            name: "WorkspaceBlockTransformConfig",
-            section: BLOCK_TRANSFORMS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "blockTransforms",
-            entry: defineInventoryEntryParser()({
-                entryName: "BLOCK_TRANSFORMS",
-                fields: [
-                    { key: "block", required: true },
-                    { key: "file", required: true },
-                    { key: "from", required: true },
-                    { key: "slug", required: true },
-                    { key: "to", required: true },
-                ],
-            }),
-            hasSectionKey: "hasBlockTransformsSection",
-        },
-        value: {
-            name: "BLOCK_TRANSFORMS",
-            section: BLOCK_TRANSFORMS_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: PATTERN_CONFIG_ENTRY_MARKER,
-            optionKey: "patternEntries",
-        },
-        interface: {
-            name: "WorkspacePatternConfig",
-            section: PATTERNS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "patterns",
-            entry: defineInventoryEntryParser()({
-                entryName: "PATTERNS",
-                fields: [
-                    { key: "file", required: true },
-                    { key: "slug", required: true },
-                ],
-            }),
-            hasSectionKey: "hasPatternsSection",
-        },
-        value: {
-            name: "PATTERNS",
-            section: PATTERNS_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: BINDING_SOURCE_CONFIG_ENTRY_MARKER,
-            optionKey: "bindingSourceEntries",
-        },
-        interface: {
-            name: "WorkspaceBindingSourceConfig",
-            section: BINDING_SOURCES_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "bindingSources",
-            entry: defineInventoryEntryParser()({
-                entryName: "BINDING_SOURCES",
-                fields: [
-                    { key: "attribute" },
-                    { key: "block" },
-                    { key: "editorFile", required: true },
-                    { key: "serverFile", required: true },
-                    { key: "slug", required: true },
-                ],
-            }),
-            hasSectionKey: "hasBindingSourcesSection",
-        },
-        value: {
-            name: "BINDING_SOURCES",
-            section: BINDING_SOURCES_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: CONTRACT_CONFIG_ENTRY_MARKER,
-            optionKey: "contractEntries",
-        },
-        interface: {
-            name: "WorkspaceContractConfig",
-            section: CONTRACTS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "contracts",
-            entry: defineInventoryEntryParser()({
-                entryName: "CONTRACTS",
-                fields: [
-                    { key: "schemaFile", required: true },
-                    { key: "slug", required: true },
-                    { key: "sourceTypeName", required: true },
-                    { key: "typesFile", required: true },
-                ],
-            }),
-            hasSectionKey: "hasContractsSection",
-        },
-        value: {
-            name: "CONTRACTS",
-            section: CONTRACTS_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: REST_RESOURCE_CONFIG_ENTRY_MARKER,
-            optionKey: "restResourceEntries",
-        },
-        interface: {
-            name: "WorkspaceRestResourceConfig",
-            section: REST_RESOURCES_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "restResources",
-            entry: defineInventoryEntryParser()({
-                entryName: "REST_RESOURCES",
-                fields: [
-                    { key: "apiFile", required: true },
-                    {
-                        key: "auth",
-                        validate: (value, context) => {
-                            if (typeof value === "string" &&
-                                !MANUAL_REST_CONTRACT_AUTH_IDS.includes(value)) {
-                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} must be one of: ${MANUAL_REST_CONTRACT_AUTH_IDS.join(", ")}.`);
-                            }
-                        },
-                    },
-                    { key: "bodyTypeName" },
-                    { key: "clientFile", required: true },
-                    { key: "controllerClass" },
-                    { key: "controllerExtends" },
-                    { key: "dataFile" },
-                    {
-                        key: "method",
-                        validate: (value, context) => {
-                            if (typeof value === "string" &&
-                                !MANUAL_REST_CONTRACT_HTTP_METHOD_IDS.includes(value)) {
-                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} must be one of: ${MANUAL_REST_CONTRACT_HTTP_METHOD_IDS.join(", ")}.`);
-                            }
-                        },
-                    },
-                    {
-                        key: "methods",
-                        kind: "stringArray",
-                        required: true,
-                        validate: (value, context) => {
-                            const methods = Array.isArray(value) ? value : [];
-                            const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
-                            if (invalidMethods.length > 0) {
-                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} includes unsupported values: ${invalidMethods.join(", ")}.`);
-                            }
-                        },
-                    },
-                    {
-                        key: "mode",
-                        validate: (value, context) => {
-                            if (typeof value === "string" &&
-                                value !== "generated" &&
-                                value !== "manual") {
-                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} must be generated or manual.`);
-                            }
-                        },
-                    },
-                    { key: "namespace", required: true },
-                    { key: "openApiFile", required: true },
-                    { key: "pathPattern" },
-                    { key: "permissionCallback" },
-                    { key: "phpFile" },
-                    { key: "queryTypeName" },
-                    { key: "responseTypeName" },
-                    { key: "routePattern" },
-                    { key: "secretFieldName" },
-                    { key: "secretStateFieldName" },
-                    { key: "slug", required: true },
-                    { key: "typesFile", required: true },
-                    { key: "validatorsFile", required: true },
-                ],
-            }),
-            hasSectionKey: "hasRestResourcesSection",
-        },
-        value: {
-            name: "REST_RESOURCES",
-            section: REST_RESOURCES_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: POST_META_CONFIG_ENTRY_MARKER,
-            optionKey: "postMetaEntries",
-        },
-        interface: {
-            name: "WorkspacePostMetaConfig",
-            section: POST_META_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "postMeta",
-            entry: defineInventoryEntryParser()({
-                entryName: "POST_META",
-                fields: [
-                    { key: "metaKey", required: true },
-                    { key: "phpFile", required: true },
-                    { key: "postType", required: true },
-                    { key: "schemaFile", required: true },
-                    { key: "showInRest", kind: "boolean", required: true },
-                    { key: "slug", required: true },
-                    { key: "sourceTypeName", required: true },
-                    { key: "typesFile", required: true },
-                ],
-            }),
-            hasSectionKey: "hasPostMetaSection",
-        },
-        value: {
-            name: "POST_META",
-            section: POST_META_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: ABILITY_CONFIG_ENTRY_MARKER,
-            optionKey: "abilityEntries",
-        },
-        interface: {
-            name: "WorkspaceAbilityConfig",
-            section: ABILITIES_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "abilities",
-            entry: defineInventoryEntryParser()({
-                entryName: "ABILITIES",
-                fields: [
-                    { key: "clientFile", required: true },
-                    { key: "configFile", required: true },
-                    { key: "dataFile", required: true },
-                    { key: "inputSchemaFile", required: true },
-                    { key: "inputTypeName", required: true },
-                    { key: "outputSchemaFile", required: true },
-                    { key: "outputTypeName", required: true },
-                    { key: "phpFile", required: true },
-                    { key: "slug", required: true },
-                    { key: "typesFile", required: true },
-                ],
-            }),
-            hasSectionKey: "hasAbilitiesSection",
-        },
-        value: {
-            name: "ABILITIES",
-            section: ABILITIES_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: AI_FEATURE_CONFIG_ENTRY_MARKER,
-            optionKey: "aiFeatureEntries",
-        },
-        interface: {
-            name: "WorkspaceAiFeatureConfig",
-            section: AI_FEATURES_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "aiFeatures",
-            entry: defineInventoryEntryParser()({
-                entryName: "AI_FEATURES",
-                fields: [
-                    { key: "aiSchemaFile", required: true },
-                    { key: "apiFile", required: true },
-                    { key: "clientFile", required: true },
-                    { key: "dataFile", required: true },
-                    { key: "namespace", required: true },
-                    { key: "openApiFile", required: true },
-                    { key: "phpFile", required: true },
-                    { key: "slug", required: true },
-                    { key: "typesFile", required: true },
-                    { key: "validatorsFile", required: true },
-                ],
-            }),
-            hasSectionKey: "hasAiFeaturesSection",
-        },
-        value: {
-            name: "AI_FEATURES",
-            section: AI_FEATURES_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: ADMIN_VIEW_CONFIG_ENTRY_MARKER,
-            optionKey: "adminViewEntries",
-        },
-        interface: {
-            name: "WorkspaceAdminViewConfig",
-            section: ADMIN_VIEWS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "adminViews",
-            entry: defineInventoryEntryParser()({
-                entryName: "ADMIN_VIEWS",
-                fields: [
-                    { key: "file", required: true },
-                    { key: "phpFile", required: true },
-                    { key: "slug", required: true },
-                    { key: "source" },
-                ],
-            }),
-            hasSectionKey: "hasAdminViewsSection",
-        },
-        value: {
-            name: "ADMIN_VIEWS",
-            section: ADMIN_VIEWS_CONST_SECTION,
-        },
-    },
-    {
-        append: {
-            marker: EDITOR_PLUGIN_CONFIG_ENTRY_MARKER,
-            optionKey: "editorPluginEntries",
-        },
-        interface: {
-            name: "WorkspaceEditorPluginConfig",
-            section: EDITOR_PLUGINS_INTERFACE_SECTION,
-        },
-        parse: {
-            entriesKey: "editorPlugins",
-            entry: defineInventoryEntryParser()({
-                entryName: "EDITOR_PLUGINS",
-                fields: [
-                    { key: "file", required: true },
-                    { key: "slug", required: true },
-                    { key: "slot", required: true },
-                ],
-            }),
-            hasSectionKey: "hasEditorPluginsSection",
-        },
-        value: {
-            name: "EDITOR_PLUGINS",
-            section: EDITOR_PLUGINS_CONST_SECTION,
-        },
-    },
-];
-function findExportedArrayLiteral(sourceFile, exportName) {
-    for (const statement of sourceFile.statements) {
-        if (!ts.isVariableStatement(statement)) {
-            continue;
-        }
-        if (!statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-            continue;
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            if (!ts.isIdentifier(declaration.name) ||
-                declaration.name.text !== exportName) {
-                continue;
-            }
-            if (declaration.initializer &&
-                ts.isArrayLiteralExpression(declaration.initializer)) {
-                return {
-                    array: declaration.initializer,
-                    found: true,
-                };
-            }
-            return {
-                array: null,
-                found: true,
-            };
-        }
-    }
-    return {
-        array: null,
-        found: false,
-    };
-}
-function getOptionalStringProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (ts.isStringLiteralLike(property.initializer)) {
-            return property.initializer.text;
-        }
-        throw new Error(`${entryName}[${elementIndex}] must use a string literal for "${key}" in scripts/block-config.ts.`);
-    }
-    return undefined;
-}
-function getOptionalStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (!ts.isArrayLiteralExpression(property.initializer)) {
-            throw new Error(`${entryName}[${elementIndex}] must use an array literal for "${key}" in scripts/block-config.ts.`);
-        }
-        return property.initializer.elements.map((element, itemIndex) => {
-            if (!ts.isStringLiteralLike(element)) {
-                throw new Error(`${entryName}[${elementIndex}].${key}[${itemIndex}] must use a string literal in scripts/block-config.ts.`);
-            }
-            return element.text;
-        });
-    }
-    return undefined;
-}
-function getOptionalBooleanProperty(entryName, elementIndex, objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
-        }
-        const propertyName = getPropertyNameText(property.name);
-        if (propertyName !== key) {
-            continue;
-        }
-        if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-            return true;
-        }
-        if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
-            return false;
-        }
-        throw new Error(`${entryName}[${elementIndex}] must use a boolean literal for "${key}" in scripts/block-config.ts.`);
-    }
-    return undefined;
-}
-function isMissingRequiredInventoryValue(value) {
-    return (value === undefined || (typeof value === "string" && value.length === 0));
-}
-function formatMissingRequiredInventoryFields(keys) {
-    return keys.length === 1
-        ? `required "${keys[0]}"`
-        : `required fields ${keys.map((key) => `"${key}"`).join(", ")}`;
-}
-function assertParsedInventoryEntry(entry, descriptor, elementIndex) {
-    const missingRequiredKeys = descriptor.fields
-        .filter((field) => field.required === true &&
-        isMissingRequiredInventoryValue(entry[field.key]))
-        .map((field) => field.key);
-    if (missingRequiredKeys.length > 0) {
-        throw new Error(`${descriptor.entryName}[${elementIndex}] is missing ${formatMissingRequiredInventoryFields(missingRequiredKeys)} in scripts/block-config.ts.`);
-    }
-}
-function parseInventoryEntries(arrayLiteral, descriptor) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`${descriptor.entryName}[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        const entry = {};
-        for (const field of descriptor.fields) {
-            const kind = field.kind ?? "string";
-            const value = kind === "stringArray"
-                ? getOptionalStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
-                : kind === "boolean"
-                    ? getOptionalBooleanProperty(descriptor.entryName, elementIndex, element, field.key)
-                    : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
-            field.validate?.(value, {
-                elementIndex,
-                entryName: descriptor.entryName,
-                key: field.key,
-            });
-            entry[field.key] = value;
-        }
-        assertParsedInventoryEntry(entry, descriptor, elementIndex);
-        return entry;
-    });
-}
-function parseInventorySection(sourceFile, descriptor) {
-    if (!descriptor.parse) {
-        return {
-            entries: [],
-            found: false,
-        };
-    }
-    const exportName = descriptor.parse.exportName ?? descriptor.value?.name;
-    if (!exportName) {
-        throw new Error("Inventory parser descriptor is missing an export name.");
-    }
-    const exportedArray = findExportedArrayLiteral(sourceFile, exportName);
-    if (!exportedArray.found) {
-        if (descriptor.parse.required) {
-            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
-        }
-        return {
-            entries: [],
-            found: false,
-        };
-    }
-    if (!exportedArray.array) {
-        if (descriptor.parse.required) {
-            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
-        }
-        throw new Error(`scripts/block-config.ts must export ${exportName} as an array literal.`);
-    }
-    return {
-        entries: parseInventoryEntries(exportedArray.array, descriptor.parse.entry),
-        found: true,
-    };
-}
+import { parseInventorySection } from "./workspace-inventory-parser-entries.js";
+import { BLOCK_INVENTORY_SECTION, INVENTORY_SECTIONS, } from "./workspace-inventory-section-descriptors.js";
+export { BLOCK_INVENTORY_SECTION, INVENTORY_SECTIONS, } from "./workspace-inventory-section-descriptors.js";
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *

package/dist/runtime/workspace-inventory-section-descriptors.d.ts

@@ -0,0 +1,19 @@
+import { type InventorySectionDescriptor } from "./workspace-inventory-parser-validation.js";
+/**
+ * Descriptor for the required `BLOCKS` inventory section.
+ *
+ * Runtime readers use its `parse` contract to require the exported `BLOCKS`
+ * array and validate required block entry fields; mutation helpers use its
+ * `append` marker to insert generated block entries without duplicating section
+ * knowledge.
+ */
+export declare const BLOCK_INVENTORY_SECTION: InventorySectionDescriptor;
+/**
+ * Descriptors for optional workspace inventory sections beyond `BLOCKS`.
+ *
+ * Each descriptor centralizes append markers, exported interface/value repair
+ * sections, parser entry metadata such as `entriesKey` and `entryName`, and
+ * optional section flags so add, doctor, read, and mutation flows share one
+ * runtime contract when adding new inventory domains.
+ */
+export declare const INVENTORY_SECTIONS: readonly InventorySectionDescriptor[];