@wp-typia/create 0.1.0

package/dist/runtime/migration-utils.js

@@ -0,0 +1,184 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { formatRunScript } from "./package-managers.js";
+export function cloneJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function getValueAtPath(input, pathLabel) {
+    return String(pathLabel)
+        .split(".")
+        .reduce((value, segment) => value && typeof value === "object" ? value[segment] : undefined, input);
+}
+export function setValueAtPath(input, pathLabel, value) {
+    const segments = String(pathLabel).split(".");
+    let target = input;
+    while (segments.length > 1) {
+        const segment = segments.shift();
+        if (!segment) {
+            continue;
+        }
+        if (!target[segment] || typeof target[segment] !== "object" || Array.isArray(target[segment])) {
+            target[segment] = {};
+        }
+        target = target[segment];
+    }
+    target[segments[0]] = value;
+}
+export function deleteValueAtPath(input, pathLabel) {
+    const segments = String(pathLabel).split(".");
+    let target = input;
+    while (segments.length > 1) {
+        const segment = segments.shift();
+        if (!segment || !target[segment] || typeof target[segment] !== "object") {
+            return;
+        }
+        target = target[segment];
+    }
+    delete target[segments[0]];
+}
+export function createFixtureScalarValue(pathLabel) {
+    const normalized = String(pathLabel).toLowerCase();
+    if (normalized.includes("id")) {
+        return "00000000-0000-4000-8000-000000000000";
+    }
+    if (normalized.includes("count") || normalized.includes("number")) {
+        return 1;
+    }
+    if (normalized.includes("visible") || normalized.startsWith("is")) {
+        return true;
+    }
+    return `legacy:${pathLabel}`;
+}
+export function createTransformFixtureValue(attribute, pathLabel) {
+    switch (attribute?.ts?.kind) {
+        case "number":
+            return "42";
+        case "boolean":
+            return "1";
+        case "union":
+            return { kind: "unknown" };
+        default:
+            return createFixtureScalarValue(pathLabel);
+    }
+}
+export function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+export function renderPhpValue(value, indentLevel) {
+    const indent = "\t".repeat(indentLevel);
+    const nestedIndent = "\t".repeat(indentLevel + 1);
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "[]";
+        }
+        const items = value.map((item) => `${nestedIndent}${renderPhpValue(item, indentLevel + 1)}`);
+        return `[\n${items.join(",\n")}\n${indent}]`;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return "[]";
+        }
+        const items = entries.map(([key, item]) => `${nestedIndent}'${String(key).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}' => ${renderPhpValue(item, indentLevel + 1)}`);
+        return `[\n${items.join(",\n")}\n${indent}]`;
+    }
+    throw new Error(`Unable to encode PHP migration registry value for ${String(value)}`);
+}
+export function copyFile(sourcePath, targetPath) {
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+}
+export function sanitizeSaveSnapshotSource(source) {
+    return source
+        .replace(/^import\s+\{[^}]+\}\s+from\s+['"]\.\/types['"];?\n?/gm, "")
+        .replace(/^interface\s+SaveProps\s*\{[\s\S]*?\}\n?/m, "")
+        .replace(/: SaveProps/g, ": { attributes: any }")
+        .replace(/attributes:\s*[A-Za-z0-9_<>{}\[\]|&,\s]+;/g, "attributes: any;")
+        .replace(/\(\{\s*attributes\s*\}:\s*\{\s*attributes:\s*any\s*\}\)/g, "({ attributes }: { attributes: any })");
+}
+export function sanitizeSnapshotBlockJson(blockJson) {
+    const snapshot = { ...blockJson };
+    for (const key of [
+        "editorScript",
+        "script",
+        "scriptModule",
+        "viewScript",
+        "viewScriptModule",
+        "style",
+        "editorStyle",
+        "render",
+    ]) {
+        delete snapshot[key];
+    }
+    return snapshot;
+}
+export function runProjectScriptIfPresent(projectDir, scriptName) {
+    const packageJson = readJson(path.join(projectDir, "package.json"));
+    if (!packageJson.scripts?.[scriptName]) {
+        return;
+    }
+    const packageManagerId = detectPackageManagerId(projectDir);
+    execSync(formatRunScript(packageManagerId, scriptName), {
+        cwd: projectDir,
+        stdio: "inherit",
+    });
+}
+export function detectPackageManagerId(projectDir) {
+    const packageJson = readJson(path.join(projectDir, "package.json"));
+    const field = String(packageJson.packageManager ?? "");
+    if (field.startsWith("bun@"))
+        return "bun";
+    if (field.startsWith("npm@"))
+        return "npm";
+    if (field.startsWith("pnpm@"))
+        return "pnpm";
+    if (field.startsWith("yarn@"))
+        return "yarn";
+    return "bun";
+}
+export function getLocalTsxBinary(projectDir) {
+    const filename = process.platform === "win32" ? "tsx.cmd" : "tsx";
+    const binaryPath = path.join(projectDir, "node_modules", ".bin", filename);
+    if (!fs.existsSync(binaryPath)) {
+        throw new Error("Local tsx binary was not found. Install project dependencies before running migration verification.");
+    }
+    return binaryPath;
+}
+export function resolveTargetVersion(currentVersion, value) {
+    return value === "current" ? currentVersion : value;
+}
+export function assertSemver(value, label) {
+    if (!/^\d+\.\d+\.\d+$/.test(value)) {
+        throw new Error(`Invalid ${label}: ${value}. Expected x.y.z`);
+    }
+}
+export function compareSemver(left, right) {
+    const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
+    const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+        const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    return 0;
+}
+export function escapeForCode(value) {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+export function renderObjectKey(key) {
+    return JSON.stringify(String(key));
+}
+export function isNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}

package/dist/runtime/migrations.js

@@ -0,0 +1,232 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { GENERATED_DIR, ROOT_BLOCK_JSON, ROOT_MANIFEST, ROOT_PHP_MIGRATION_REGISTRY, ROOT_SAVE_FILE, SNAPSHOT_DIR, } from "./migration-constants.js";
+import { createMigrationDiff } from "./migration-diff.js";
+import { ensureEdgeFixtureFile } from "./migration-fixtures.js";
+import { assertRuleHasNoTodos, discoverMigrationEntries, ensureAdvancedMigrationProject, ensureMigrationDirectories, getProjectPaths, getRuleFilePath, loadMigrationProject, readProjectBlockName, writeInitialMigrationScaffold, writeMigrationConfig, } from "./migration-project.js";
+import { formatDiffReport, renderGeneratedDeprecatedFile, renderMigrationRegistryFile, renderMigrationRuleFile, renderPhpMigrationRegistryFile, renderVerifyFile, } from "./migration-render.js";
+import { assertSemver, compareSemver, copyFile, getLocalTsxBinary, readJson, resolveTargetVersion, runProjectScriptIfPresent, sanitizeSaveSnapshotSource, sanitizeSnapshotBlockJson, } from "./migration-utils.js";
+export function formatMigrationHelpText() {
+    return `Usage:
+  wp-typia migrations init --current-version <semver>
+  wp-typia migrations snapshot --version <semver>
+  wp-typia migrations diff --from <semver> [--to current]
+  wp-typia migrations scaffold --from <semver> [--to current]
+  wp-typia migrations verify [--from <semver>|--all]`;
+}
+export function parseMigrationArgs(argv) {
+    const parsed = {
+        command: undefined,
+        flags: {
+            all: false,
+            currentVersion: undefined,
+            from: undefined,
+            to: "current",
+            version: undefined,
+        },
+    };
+    if (argv.length === 0) {
+        throw new Error(formatMigrationHelpText());
+    }
+    parsed.command = argv[0];
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        if (arg === "--")
+            continue;
+        if (arg === "--all") {
+            parsed.flags.all = true;
+            continue;
+        }
+        if (arg === "--current-version") {
+            parsed.flags.currentVersion = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--current-version=")) {
+            parsed.flags.currentVersion = arg.split("=", 2)[1];
+            continue;
+        }
+        if (arg === "--from") {
+            parsed.flags.from = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--from=")) {
+            parsed.flags.from = arg.split("=", 2)[1];
+            continue;
+        }
+        if (arg === "--to") {
+            parsed.flags.to = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--to=")) {
+            parsed.flags.to = arg.split("=", 2)[1];
+            continue;
+        }
+        if (arg === "--version") {
+            parsed.flags.version = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--version=")) {
+            parsed.flags.version = arg.split("=", 2)[1];
+            continue;
+        }
+        throw new Error(`Unknown migrations flag: ${arg}`);
+    }
+    return parsed;
+}
+export { formatDiffReport };
+export function runMigrationCommand(command, cwd, { renderLine = console.log } = {}) {
+    switch (command.command) {
+        case "init":
+            if (!command.flags.currentVersion) {
+                throw new Error("`migrations init` requires --current-version <semver>.");
+            }
+            return initProjectMigrations(cwd, command.flags.currentVersion, { renderLine });
+        case "snapshot":
+            if (!command.flags.version) {
+                throw new Error("`migrations snapshot` requires --version <semver>.");
+            }
+            return snapshotProjectVersion(cwd, command.flags.version, { renderLine });
+        case "diff":
+            if (!command.flags.from) {
+                throw new Error("`migrations diff` requires --from <semver>.");
+            }
+            return diffProjectMigrations(cwd, {
+                fromVersion: command.flags.from,
+                renderLine,
+                toVersion: command.flags.to ?? "current",
+            });
+        case "scaffold":
+            if (!command.flags.from) {
+                throw new Error("`migrations scaffold` requires --from <semver>.");
+            }
+            return scaffoldProjectMigrations(cwd, {
+                fromVersion: command.flags.from,
+                renderLine,
+                toVersion: command.flags.to ?? "current",
+            });
+        case "verify":
+            return verifyProjectMigrations(cwd, {
+                all: command.flags.all,
+                fromVersion: command.flags.from,
+                renderLine,
+            });
+        default:
+            throw new Error(formatMigrationHelpText());
+    }
+}
+export function initProjectMigrations(projectDir, currentVersion, { renderLine = console.log } = {}) {
+    ensureAdvancedMigrationProject(projectDir);
+    assertSemver(currentVersion, "current version");
+    const blockName = readProjectBlockName(projectDir);
+    ensureMigrationDirectories(projectDir);
+    writeMigrationConfig(projectDir, {
+        blockName,
+        currentVersion,
+        snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
+        supportedVersions: [currentVersion],
+    });
+    writeInitialMigrationScaffold(projectDir, currentVersion);
+    snapshotProjectVersion(projectDir, currentVersion, { renderLine, skipConfigUpdate: true });
+    regenerateGeneratedArtifacts(projectDir);
+    renderLine(`Initialized migrations for ${blockName} at version ${currentVersion}`);
+    return loadMigrationProject(projectDir);
+}
+export function snapshotProjectVersion(projectDir, version, { renderLine = console.log, skipConfigUpdate = false, } = {}) {
+    ensureAdvancedMigrationProject(projectDir);
+    assertSemver(version, "snapshot version");
+    runProjectScriptIfPresent(projectDir, "sync-types");
+    const state = loadMigrationProject(projectDir, { allowMissingConfig: skipConfigUpdate });
+    const snapshotRoot = path.join(projectDir, SNAPSHOT_DIR, version);
+    fs.mkdirSync(snapshotRoot, { recursive: true });
+    fs.writeFileSync(path.join(snapshotRoot, ROOT_BLOCK_JSON), `${JSON.stringify(sanitizeSnapshotBlockJson(readJson(path.join(projectDir, ROOT_BLOCK_JSON))), null, "\t")}\n`, "utf8");
+    copyFile(path.join(projectDir, ROOT_MANIFEST), path.join(snapshotRoot, ROOT_MANIFEST));
+    fs.writeFileSync(path.join(snapshotRoot, "save.tsx"), sanitizeSaveSnapshotSource(fs.readFileSync(path.join(projectDir, ROOT_SAVE_FILE), "utf8")), "utf8");
+    if (!skipConfigUpdate) {
+        const nextSupported = [...new Set([...state.config.supportedVersions, version])].sort(compareSemver);
+        writeMigrationConfig(projectDir, {
+            ...state.config,
+            currentVersion: version,
+            supportedVersions: nextSupported,
+        });
+    }
+    regenerateGeneratedArtifacts(projectDir);
+    renderLine(`Snapshot stored for ${version}`);
+    return loadMigrationProject(projectDir);
+}
+export function diffProjectMigrations(projectDir, { fromVersion, toVersion = "current", renderLine = console.log } = {}) {
+    if (!fromVersion) {
+        throw new Error("`migrations diff` requires --from <semver>.");
+    }
+    const state = loadMigrationProject(projectDir);
+    const targetVersion = resolveTargetVersion(state.config.currentVersion, toVersion);
+    const diff = createMigrationDiff(state, fromVersion, targetVersion);
+    renderLine(formatDiffReport(diff));
+    return diff;
+}
+export function scaffoldProjectMigrations(projectDir, { fromVersion, toVersion = "current", renderLine = console.log } = {}) {
+    if (!fromVersion) {
+        throw new Error("`migrations scaffold` requires --from <semver>.");
+    }
+    ensureMigrationDirectories(projectDir);
+    const state = loadMigrationProject(projectDir);
+    const targetVersion = resolveTargetVersion(state.config.currentVersion, toVersion);
+    const diff = createMigrationDiff(state, fromVersion, targetVersion);
+    const paths = getProjectPaths(projectDir);
+    const rulePath = getRuleFilePath(paths, fromVersion, targetVersion);
+    if (!fs.existsSync(rulePath)) {
+        fs.writeFileSync(rulePath, renderMigrationRuleFile({
+            currentAttributes: state.currentManifest.attributes ?? {},
+            currentTypeName: state.currentManifest.sourceType,
+            diff,
+            fromVersion,
+            targetVersion,
+        }), "utf8");
+    }
+    ensureEdgeFixtureFile(projectDir, fromVersion, targetVersion, diff);
+    regenerateGeneratedArtifacts(projectDir);
+    renderLine(formatDiffReport(diff));
+    renderLine(`Scaffolded ${path.relative(projectDir, rulePath)}`);
+    return { diff, rulePath };
+}
+export function verifyProjectMigrations(projectDir, { all = false, fromVersion, renderLine = console.log } = {}) {
+    const state = loadMigrationProject(projectDir);
+    const verifyScriptPath = path.join(projectDir, GENERATED_DIR, "verify.ts");
+    if (!fs.existsSync(verifyScriptPath)) {
+        throw new Error("Generated verify script is missing. Run `wp-typia migrations scaffold --from <semver>` first.");
+    }
+    const targetVersions = all
+        ? state.config.supportedVersions.filter((version) => version !== state.config.currentVersion)
+        : fromVersion
+            ? [fromVersion]
+            : state.config.supportedVersions.filter((version) => version !== state.config.currentVersion);
+    if (targetVersions.length === 0) {
+        renderLine("No legacy versions configured for verification.");
+        return { verifiedVersions: [] };
+    }
+    for (const version of targetVersions) {
+        assertRuleHasNoTodos(projectDir, version, state.config.currentVersion);
+    }
+    const tsxBinary = getLocalTsxBinary(projectDir);
+    const filteredArgs = all ? ["--all"] : fromVersion ? ["--from", fromVersion] : [];
+    execSync(`"${tsxBinary}" "${verifyScriptPath}" ${filteredArgs.join(" ")}`.trim(), {
+        cwd: projectDir,
+        stdio: "inherit",
+    });
+    renderLine(`Verified migrations for ${targetVersions.join(", ")}`);
+    return { verifiedVersions: targetVersions };
+}
+function regenerateGeneratedArtifacts(projectDir) {
+    const state = loadMigrationProject(projectDir);
+    const entries = discoverMigrationEntries(state);
+    fs.mkdirSync(state.paths.generatedDir, { recursive: true });
+    fs.writeFileSync(path.join(state.paths.generatedDir, "registry.ts"), renderMigrationRegistryFile(state, entries), "utf8");
+    fs.writeFileSync(path.join(state.paths.generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(entries), "utf8");
+    fs.writeFileSync(path.join(state.paths.generatedDir, "verify.ts"), renderVerifyFile(state, entries), "utf8");
+    fs.writeFileSync(path.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, entries), "utf8");
+}

package/dist/runtime/package-managers.js

@@ -0,0 +1,135 @@
+const PACKAGE_MANAGER_DATA = [
+    {
+        id: "bun",
+        label: "Bun",
+        packageManagerField: "bun@1.3.10",
+        installCommand: "bun install",
+        frozenInstallCommand: "bun install --frozen-lockfile",
+    },
+    {
+        id: "npm",
+        label: "npm",
+        packageManagerField: "npm@11.6.1",
+        installCommand: "npm install",
+        frozenInstallCommand: "npm ci",
+    },
+    {
+        id: "pnpm",
+        label: "pnpm",
+        packageManagerField: "pnpm@8.3.1",
+        installCommand: "pnpm install",
+        frozenInstallCommand: "pnpm install --frozen-lockfile",
+    },
+    {
+        id: "yarn",
+        label: "Yarn",
+        packageManagerField: "yarn@3.2.4",
+        installCommand: "yarn install",
+        frozenInstallCommand: "yarn install --frozen-lockfile",
+    },
+];
+export const PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_DATA.map((manager) => manager.id);
+export const PACKAGE_MANAGERS = Object.freeze(Object.fromEntries(PACKAGE_MANAGER_DATA.map((manager) => [manager.id, manager])));
+const DEV_INSTALL_FLAGS = {
+    bun: "add -d",
+    npm: "install --save-dev",
+    pnpm: "add -D",
+    yarn: "add -D",
+};
+const STOP_CHARS = new Set(["\n", "\r", "`", "\"", "'", ")", "]", "}", "!", ",", "."]);
+export function getPackageManager(id) {
+    const manager = PACKAGE_MANAGERS[id];
+    if (!manager) {
+        throw new Error(`Unknown package manager "${id}". Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}`);
+    }
+    return manager;
+}
+export function getPackageManagerSelectOptions() {
+    return PACKAGE_MANAGER_DATA.map((manager) => ({
+        label: manager.label,
+        value: manager.id,
+        hint: manager.installCommand,
+    }));
+}
+export function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
+    const args = extraArgs.trim();
+    if (packageManagerId === "bun") {
+        return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
+    }
+    if (packageManagerId === "npm") {
+        return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
+    }
+    if (packageManagerId === "pnpm") {
+        return args ? `pnpm run ${scriptName} -- ${args}` : `pnpm run ${scriptName}`;
+    }
+    return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
+}
+export function formatInstallCommand(packageManagerId) {
+    return getPackageManager(packageManagerId).installCommand;
+}
+function consumeCommandArguments(content, startIndex) {
+    let cursor = startIndex;
+    let args = "";
+    while (cursor < content.length) {
+        const current = content[cursor];
+        if (STOP_CHARS.has(current) ||
+            content.startsWith("&&", cursor) ||
+            content.startsWith("||", cursor) ||
+            current === ";") {
+            break;
+        }
+        args += current;
+        cursor += 1;
+    }
+    return {
+        args: args.trim(),
+        cursor,
+    };
+}
+function replaceBunRunCommands(content, packageManagerId) {
+    const marker = "bun run ";
+    let result = "";
+    let cursor = 0;
+    while (cursor < content.length) {
+        const index = content.indexOf(marker, cursor);
+        if (index === -1) {
+            result += content.slice(cursor);
+            break;
+        }
+        if (index > 0 && /[A-Za-z0-9_-]/.test(content[index - 1])) {
+            result += content.slice(cursor, index + marker.length);
+            cursor = index + marker.length;
+            continue;
+        }
+        result += content.slice(cursor, index);
+        const scriptNameStart = index + marker.length;
+        const scriptNameMatch = /^[A-Za-z0-9:_-]+/.exec(content.slice(scriptNameStart));
+        if (!scriptNameMatch) {
+            result += marker;
+            cursor = scriptNameStart;
+            continue;
+        }
+        const scriptName = scriptNameMatch[0];
+        const argsStart = scriptNameStart + scriptName.length;
+        const { args, cursor: nextCursor } = consumeCommandArguments(content, argsStart);
+        result += formatRunScript(packageManagerId, scriptName, args);
+        cursor = nextCursor;
+    }
+    return result;
+}
+function replaceDevDependencyInstalls(content, packageManagerId) {
+    return content.replace(/\bbun add -d ([^\s&|;`"'()]+)\b/g, (_, packageName) => {
+        if (packageManagerId === "bun") {
+            return `bun add -d ${packageName}`;
+        }
+        return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packageName}`;
+    });
+}
+export function transformPackageManagerText(content, packageManagerId) {
+    const manager = getPackageManager(packageManagerId);
+    return replaceDevDependencyInstalls(replaceBunRunCommands(content
+        .replace(/\bbun install --frozen-lockfile\b/g, manager.frozenInstallCommand)
+        .replace(/\bbun install\b/g, manager.installCommand), packageManagerId), packageManagerId)
+        .replace(/\s*&&\s*/g, " && ")
+        .replace(/\s*\|\|\s*/g, " || ");
+}