@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/migration-maintenance.js

@@ -1,2 +1 @@
-export * from './migration-maintenance-verify.js';
-export * from './migration-maintenance-fixtures.js';
+export * from "./migration/migration-maintenance.js";

package/dist/runtime/migration-manifest.d.ts

@@ -1,19 +1 @@
-import type { FlattenedAttributeDescriptor, JsonValue, ManifestAttribute, ManifestDocument, ManifestSummary, UnionBranchSummary } from "./migration-types.js";
-interface FlattenContext {
-    rootPath: string;
-    unionBranch: string | null;
-    unionDiscriminator: string | null;
-    unionRoot: string | null;
-}
-type ManifestDefaultValue = ManifestAttribute["typia"]["defaultValue"] | JsonValue[] | Record<string, JsonValue>;
-export declare function flattenManifestLeafAttributes(attributes: Record<string, ManifestAttribute>): FlattenedAttributeDescriptor[];
-export declare function flattenManifestAttribute(attribute: ManifestAttribute | undefined | null, currentPath: string, sourcePath: string, context: FlattenContext): FlattenedAttributeDescriptor[];
-export declare function getAttributeByCurrentPath(attributes: Record<string, ManifestAttribute>, currentPath: string): ManifestAttribute | null;
-export declare function hasManifestDefault(attribute: ManifestAttribute | undefined | null): boolean;
-export declare function getManifestDefaultValue(attribute: ManifestAttribute | undefined | null): string | number | boolean | JsonValue[] | {
-    [key: string]: JsonValue;
-} | null;
-export declare function summarizeManifest(manifest: ManifestDocument): ManifestSummary;
-export declare function summarizeUnionBranches(manifestSummary: ManifestSummary): UnionBranchSummary[];
-export declare function defaultValueForManifestAttribute(attribute: ManifestAttribute): ManifestDefaultValue | null;
-export {};
+export * from "./migration/migration-manifest.js";

package/dist/runtime/migration-manifest.js

@@ -1,129 +1 @@
-export function flattenManifestLeafAttributes(attributes) {
-    return Object.entries(attributes).flatMap(([key, attribute]) => flattenManifestAttribute(attribute, key, key, {
-        rootPath: key,
-        unionBranch: null,
-        unionDiscriminator: null,
-        unionRoot: null,
-    }));
-}
-export function flattenManifestAttribute(attribute, currentPath, sourcePath, context) {
-    if (!attribute) {
-        return [];
-    }
-    if (attribute.ts.kind === "object") {
-        const properties = Object.entries(attribute.ts.properties ?? {});
-        if (properties.length === 0) {
-            return [{ ...context, attribute, currentPath, sourcePath }];
-        }
-        return properties.flatMap(([key, property]) => flattenManifestAttribute(property, `${currentPath}.${key}`, `${sourcePath}.${key}`, {
-            ...context,
-        }));
-    }
-    if (attribute.ts.kind === "union" && attribute.ts.union) {
-        const unionMetadata = attribute.ts.union;
-        return Object.entries(attribute.ts.union.branches ?? {}).flatMap(([branchKey, branchAttribute]) => Object.entries(branchAttribute.ts.properties ?? {})
-            .filter(([key]) => key !== unionMetadata.discriminator)
-            .flatMap(([key, property]) => flattenManifestAttribute(property, `${currentPath}.${branchKey}.${key}`, `${sourcePath}.${key}`, {
-            rootPath: context.rootPath,
-            unionBranch: branchKey,
-            unionDiscriminator: unionMetadata.discriminator,
-            unionRoot: currentPath,
-        })));
-    }
-    return [{ ...context, attribute, currentPath, sourcePath }];
-}
-export function getAttributeByCurrentPath(attributes, currentPath) {
-    const segments = String(currentPath).split(".");
-    const rootKey = segments.shift();
-    if (!rootKey) {
-        return null;
-    }
-    let attribute = attributes[rootKey] ?? null;
-    while (attribute && segments.length > 0) {
-        if (attribute.ts.kind === "union" && attribute.ts.union) {
-            const branchKey = segments.shift();
-            if (!branchKey || !(branchKey in attribute.ts.union.branches)) {
-                return null;
-            }
-            attribute = attribute.ts.union.branches[branchKey];
-            continue;
-        }
-        if (attribute.ts.kind === "object" && attribute.ts.properties) {
-            const propertyKey = segments.shift();
-            if (!propertyKey || !(propertyKey in attribute.ts.properties)) {
-                return null;
-            }
-            attribute = attribute.ts.properties[propertyKey];
-            continue;
-        }
-        return null;
-    }
-    return attribute;
-}
-export function hasManifestDefault(attribute) {
-    return attribute?.typia?.hasDefault === true;
-}
-export function getManifestDefaultValue(attribute) {
-    return attribute?.typia?.defaultValue ?? null;
-}
-export function summarizeManifest(manifest) {
-    return {
-        attributes: Object.fromEntries(Object.entries(manifest.attributes ?? {}).map(([name, attribute]) => [
-            name,
-            {
-                constraints: attribute.typia?.constraints ?? {},
-                defaultValue: attribute.typia?.defaultValue ?? null,
-                hasDefault: attribute.typia?.hasDefault ?? false,
-                enum: attribute.wp?.enum ?? null,
-                kind: attribute.ts?.kind ?? null,
-                required: attribute.ts?.required ?? false,
-                union: attribute.ts?.union ?? null,
-            },
-        ])),
-        manifestVersion: manifest.manifestVersion ?? null,
-        sourceType: manifest.sourceType ?? null,
-    };
-}
-export function summarizeUnionBranches(manifestSummary) {
-    if (!manifestSummary?.attributes) {
-        return [];
-    }
-    return Object.entries(manifestSummary.attributes)
-        .filter(([, attribute]) => attribute.kind === "union" && attribute.union)
-        .map(([field, attribute]) => ({
-        branches: Object.keys(attribute.union?.branches ?? {}),
-        discriminator: attribute.union?.discriminator ?? null,
-        field,
-    }));
-}
-export function defaultValueForManifestAttribute(attribute) {
-    if (attribute.typia?.hasDefault) {
-        return attribute.typia.defaultValue;
-    }
-    if (attribute.wp?.enum && attribute.wp.enum.length > 0) {
-        return attribute.wp.enum[0] ?? null;
-    }
-    switch (attribute.ts.kind) {
-        case "string":
-            return "";
-        case "number":
-            return 0;
-        case "boolean":
-            return false;
-        case "array":
-            return [];
-        case "object": {
-            const result = {};
-            for (const [key, property] of Object.entries(attribute.ts.properties ?? {})) {
-                result[key] = defaultValueForManifestAttribute(property);
-            }
-            return result;
-        }
-        case "union": {
-            const firstBranch = Object.values(attribute.ts.union?.branches ?? {})[0];
-            return firstBranch ? defaultValueForManifestAttribute(firstBranch) : null;
-        }
-        default:
-            return null;
-    }
-}
+export * from "./migration/migration-manifest.js";

package/dist/runtime/migration-planning.d.ts

@@ -1,23 +1 @@
-import type { MigrationProjectState } from "./migration-types.js";
-export declare function hasSnapshotForVersion(state: MigrationProjectState, block: MigrationProjectState["blocks"][number], version: string): boolean;
-export declare function listConfiguredLegacyVersions(state: MigrationProjectState): string[];
-export declare function listPreviewableLegacyVersions(state: MigrationProjectState): string[];
-export declare function resolveLegacyVersions(state: MigrationProjectState, { all, availableVersions, fromMigrationVersion, }: {
-    all?: boolean;
-    availableVersions?: string[];
-    fromMigrationVersion?: string;
-}): string[];
-export declare function isSnapshotOptionalForBlockVersion(state: MigrationProjectState, block: MigrationProjectState["blocks"][number], version: string): boolean;
-export declare function isLegacySingleBlockProject(state: MigrationProjectState): boolean;
-export declare function getSelectedEntriesByBlock(state: MigrationProjectState, targetVersions: string[], command: "fuzz" | "verify"): Record<string, import("./migration-types.js").MigrationEntry[]>;
-export declare function assertDistinctMigrationEdge(command: "diff" | "plan" | "scaffold", fromVersion: string, toVersion: string): void;
-export declare function createMigrationPlanNextSteps(fromVersion: string, targetVersion: string, currentVersion: string): string[];
-export declare function formatEdgeCommand(command: "fixtures" | "scaffold", fromVersion: string, targetVersion: string, currentVersion: string): string;
-export declare function createMissingProjectSnapshotMessage(state: MigrationProjectState, fromVersion: string): string;
-export declare function formatScaffoldCommand(versions: string[]): string;
-export declare function collectFixtureTargets(state: MigrationProjectState, targetVersions: string[], targetVersion: string): {
-    block: import("./migration-types.js").ResolvedMigrationBlockTarget;
-    fixturePath: string;
-    scopedLabel: string;
-    version: string;
-}[];
+export * from "./migration/migration-planning.js";

package/dist/runtime/migration-planning.js

@@ -1,131 +1 @@
-import fs from "node:fs";
-import { discoverMigrationEntries, getAvailableSnapshotVersionsForBlock, getFixtureFilePath, getSnapshotManifestPath, } from "./migration-project.js";
-import { compareMigrationVersionLabels } from "./migration-utils.js";
-export function hasSnapshotForVersion(state, block, version) {
-    return fs.existsSync(getSnapshotManifestPath(state.projectDir, block, version));
-}
-export function listConfiguredLegacyVersions(state) {
-    return state.config.supportedMigrationVersions
-        .filter((version) => version !== state.config.currentMigrationVersion)
-        .sort(compareMigrationVersionLabels);
-}
-export function listPreviewableLegacyVersions(state) {
-    return [
-        ...new Set(state.blocks.flatMap((block) => getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block))),
-    ]
-        .filter((version) => version !== state.config.currentMigrationVersion)
-        .sort(compareMigrationVersionLabels);
-}
-export function resolveLegacyVersions(state, { all = false, availableVersions, fromMigrationVersion, }) {
-    const configuredLegacyVersions = listConfiguredLegacyVersions(state);
-    const legacyVersions = availableVersions ?? configuredLegacyVersions;
-    if (fromMigrationVersion) {
-        if (!legacyVersions.includes(fromMigrationVersion)) {
-            throw new Error(legacyVersions.length === 0
-                ? availableVersions && configuredLegacyVersions.length > 0
-                    ? `Unsupported migration version: ${fromMigrationVersion}. No previewable legacy migration versions are available yet because none currently have snapshot coverage. ` +
-                        `Restore or recapture the missing snapshots first.`
-                    : `Unsupported migration version: ${fromMigrationVersion}. No legacy migration versions are configured yet. ` +
-                        `Capture an older schema release with \`wp-typia migrate snapshot --migration-version <label>\` first.`
-                : `Unsupported migration version: ${fromMigrationVersion}. Available legacy migration versions: ${legacyVersions.join(", ")}.`);
-        }
-        return [fromMigrationVersion];
-    }
-    if (all) {
-        return legacyVersions;
-    }
-    return legacyVersions.slice(0, 1);
-}
-export function isSnapshotOptionalForBlockVersion(state, block, version) {
-    if (block.layout !== "multi") {
-        return false;
-    }
-    const introducedVersions = [...new Set(state.config.supportedMigrationVersions)]
-        .filter((candidateVersion) => hasSnapshotForVersion(state, block, candidateVersion))
-        .sort(compareMigrationVersionLabels);
-    const firstIntroducedVersion = introducedVersions[0];
-    if (!firstIntroducedVersion) {
-        return false;
-    }
-    return compareMigrationVersionLabels(version, firstIntroducedVersion) < 0;
-}
-export function isLegacySingleBlockProject(state) {
-    return state.blocks.length === 1 && state.blocks[0]?.layout === "legacy";
-}
-export function getSelectedEntriesByBlock(state, targetVersions, command) {
-    const discoveredEntries = discoverMigrationEntries(state);
-    const discoveredEntryKeys = new Set(discoveredEntries.map((entry) => `${entry.block.key}:${entry.fromVersion}`));
-    const missingEntries = targetVersions.flatMap((version) => state.blocks
-        .filter((block) => hasSnapshotForVersion(state, block, version))
-        .filter((block) => !discoveredEntryKeys.has(`${block.key}:${version}`))
-        .map((block) => ({ block, version })));
-    if (missingEntries.length > 0) {
-        const missingLabels = missingEntries
-            .map(({ block, version }) => `${block.blockName} @ ${version}`)
-            .join(", ");
-        const missingVersions = [...new Set(missingEntries.map(({ version }) => version))].sort(compareMigrationVersionLabels);
-        throw new Error(`Missing migration ${command} inputs for ${missingLabels}. ` +
-            `Run \`${formatScaffoldCommand(missingVersions)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
-    }
-    return groupEntriesByBlock(discoveredEntries.filter((entry) => targetVersions.includes(entry.fromVersion)));
-}
-export function assertDistinctMigrationEdge(command, fromVersion, toVersion) {
-    if (fromVersion === toVersion) {
-        throw new Error(`\`migrate ${command}\` requires different source and target migration versions, but both resolved to ${fromVersion}. ` +
-            `Choose an older snapshot with \`--from-migration-version <label>\` or capture a newer schema release with \`wp-typia migrate snapshot --migration-version <label>\` first.`);
-    }
-}
-export function createMigrationPlanNextSteps(fromVersion, targetVersion, currentVersion) {
-    if (targetVersion !== currentVersion) {
-        return [
-            formatEdgeCommand("scaffold", fromVersion, targetVersion, currentVersion),
-        ];
-    }
-    return [
-        formatEdgeCommand("scaffold", fromVersion, targetVersion, currentVersion),
-        `wp-typia migrate doctor --from-migration-version ${fromVersion}`,
-        `wp-typia migrate verify --from-migration-version ${fromVersion}`,
-        `wp-typia migrate fuzz --from-migration-version ${fromVersion}`,
-    ];
-}
-export function formatEdgeCommand(command, fromVersion, targetVersion, currentVersion) {
-    return targetVersion === currentVersion
-        ? `wp-typia migrate ${command} --from-migration-version ${fromVersion}`
-        : `wp-typia migrate ${command} --from-migration-version ${fromVersion} --to-migration-version ${targetVersion}`;
-}
-export function createMissingProjectSnapshotMessage(state, fromVersion) {
-    const snapshotVersions = [
-        ...new Set(state.blocks.flatMap((block) => getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block))),
-    ].sort(compareMigrationVersionLabels);
-    return snapshotVersions.length === 0
-        ? `No migration block targets have a snapshot for ${fromVersion}. No snapshots exist yet in this project. ` +
-            `Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first if you want to preserve that schema state.`
-        : `No migration block targets have a snapshot for ${fromVersion}. ` +
-            `Available snapshot versions in this project: ${snapshotVersions.join(", ")}. ` +
-            `Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first if you want to preserve that schema state.`;
-}
-export function formatScaffoldCommand(versions) {
-    const uniqueVersions = [...new Set(versions)].sort(compareMigrationVersionLabels);
-    return uniqueVersions.length === 1
-        ? `wp-typia migrate scaffold --from-migration-version ${uniqueVersions[0]}`
-        : "wp-typia migrate scaffold --from-migration-version <label>";
-}
-export function collectFixtureTargets(state, targetVersions, targetVersion) {
-    return targetVersions.flatMap((version) => state.blocks
-        .filter((block) => hasSnapshotForVersion(state, block, version))
-        .map((block) => ({
-        block,
-        fixturePath: getFixtureFilePath(state.paths, block, version, targetVersion),
-        scopedLabel: `${block.key}@${version}`,
-        version,
-    })));
-}
-function groupEntriesByBlock(entries) {
-    return entries.reduce((accumulator, entry) => {
-        if (!accumulator[entry.block.key]) {
-            accumulator[entry.block.key] = [];
-        }
-        accumulator[entry.block.key].push(entry);
-        return accumulator;
-    }, {});
-}
+export * from "./migration/migration-planning.js";

package/dist/runtime/migration-project-config-source.d.ts

@@ -1,6 +1 @@
-import type { MigrationConfig } from "./migration-types.js";
-export declare function normalizeRelativePath(value: string): string;
-export declare function ensureRelativePath(projectDir: string, filePath: string): string;
-export declare function hasLegacyConfigKeys(source: string): boolean;
-export declare function createLegacyMigrationWorkspaceResetError(reason: string): Error;
-export declare function parseMigrationConfig(source: string): MigrationConfig;
+export * from "./migration/migration-project-config-source.js";