@wp-typia/create 0.1.0

package/templates/advanced/src/migrations/examples/rename-transform-union/fixture.example.json.mustache

@@ -0,0 +1,36 @@
+{
+	"fromVersion": "1.0.0",
+	"toVersion": "2.0.0",
+	"cases": [
+		{
+			"name": "rename-and-transform",
+			"input": {
+				"headline": "Legacy title",
+				"count": "42",
+				"settings": {
+					"title": "Legacy label"
+				},
+				"linkTarget": {
+					"kind": "url",
+					"href": "https://example.com"
+				}
+			}
+		},
+		{
+			"name": "union-branch-review",
+			"input": {
+				"headline": "Needs branch migration",
+				"settings": {
+					"title": "Legacy label"
+				},
+				"cta": {
+					"href": "https://example.com/cta"
+				},
+				"linkTarget": {
+					"kind": "post",
+					"postId": 12
+				}
+			}
+		}
+	]
+}

package/templates/advanced/src/migrations/examples/rename-transform-union/rule.example.ts.mustache

@@ -0,0 +1,47 @@
+import type { {{titleCase}}Attributes } from "../../../types";
+import currentManifest from "../../../../typia.manifest.json";
+import {
+	type RenameMap,
+	type TransformMap,
+	resolveMigrationAttribute,
+} from "../../helpers";
+
+export const renameMap: RenameMap = {
+	"content": "headline",
+	"settings.label": "settings.title",
+};
+
+export const transforms: TransformMap = {
+	"count": (legacyValue) => {
+		const numericValue =
+			typeof legacyValue === "number" ? legacyValue : Number(legacyValue ?? 0);
+		return Number.isNaN(numericValue) ? undefined : numericValue;
+	},
+	// Branch changes still need human review. The generated scaffold will keep this unresolved
+	// until you decide how to map the legacy branch contract.
+	"linkTarget.url.href": (legacyValue, legacyInput) => {
+		if (typeof legacyValue === "string") {
+			return legacyValue;
+		}
+
+		const fallbackHref =
+			typeof legacyInput.cta === "object" && legacyInput.cta && "href" in legacyInput.cta
+				? legacyInput.cta.href
+				: undefined;
+
+		return typeof fallbackHref === "string" ? fallbackHref : undefined;
+	},
+};
+
+export const unresolved = [
+	"linkTarget: union-branch-removal (branch post was removed)",
+] as const;
+
+export function migrate(input: Record<string, unknown>): {{titleCase}}Attributes {
+	return {
+		content: resolveMigrationAttribute(currentManifest.attributes.content, "content", "content", input, renameMap, transforms),
+		settings: resolveMigrationAttribute(currentManifest.attributes.settings, "settings", "settings", input, renameMap, transforms),
+		count: resolveMigrationAttribute(currentManifest.attributes.count, "count", "count", input, renameMap, transforms),
+		linkTarget: resolveMigrationAttribute(currentManifest.attributes.linkTarget, "linkTarget", "linkTarget", input, renameMap, transforms),
+	} as {{titleCase}}Attributes;
+}

package/templates/advanced/src/migrations/fixtures/README.md.mustache

@@ -0,0 +1,3 @@
+# Migration Fixtures
+
+Generated fixtures are used by `wp-typia migrations verify`.

package/templates/advanced/src/migrations/generated/deprecated.ts.mustache

@@ -0,0 +1,3 @@
+import type { BlockConfiguration } from "@wordpress/blocks";
+
+export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [];

package/templates/advanced/src/migrations/generated/registry.ts.mustache

@@ -0,0 +1,9 @@
+import currentManifest from "../../../typia.manifest.json";
+
+export const migrationRegistry = {
+	currentVersion: "1.0.0",
+	currentManifest,
+	entries: [],
+} as const;
+
+export default migrationRegistry;

package/templates/advanced/src/migrations/generated/verify.ts.mustache

@@ -0,0 +1 @@
+console.log("Run `wp-typia migrations scaffold --from <semver>` before verify.");

package/templates/advanced/src/migrations/helpers.ts.mustache

@@ -0,0 +1,354 @@
+export interface ManifestUnion {
+	branches: Record<string, ManifestAttribute>;
+	discriminator: string;
+}
+
+export interface ManifestAttribute {
+	typia: {
+		constraints: {
+			format: string | null;
+			maxLength: number | null;
+			maximum: number | null;
+			minLength: number | null;
+			minimum: number | null;
+			pattern: string | null;
+			typeTag: string | null;
+		};
+		defaultValue: unknown;
+		hasDefault: boolean;
+	};
+	ts: {
+		items: ManifestAttribute | null;
+		kind: "string" | "number" | "boolean" | "array" | "object" | "union";
+		properties: Record<string, ManifestAttribute> | null;
+		required: boolean;
+		union: ManifestUnion | null;
+	};
+	wp: {
+		defaultValue: unknown;
+		enum: Array<string | number | boolean> | null;
+		hasDefault: boolean;
+		type: "string" | "number" | "boolean" | "array" | "object";
+	};
+}
+
+export interface ManifestDocument {
+	attributes: Record<string, ManifestAttribute>;
+	manifestVersion: 2;
+	sourceType: string;
+}
+
+export type RenameMap = Record<string, string>;
+export type TransformMap = Record<
+	string,
+	(legacyValue: unknown, legacyInput: Record<string, unknown>) => unknown
+>;
+
+function getSourcePath(currentPath: string, fallbackPath: string, renameMap: RenameMap): string {
+	return renameMap[currentPath] ?? fallbackPath;
+}
+
+export function createDefaultValue(attribute: ManifestAttribute): unknown {
+	if (attribute.typia.hasDefault) {
+		return attribute.typia.defaultValue;
+	}
+	if (attribute.wp.enum && attribute.wp.enum.length > 0) {
+		return attribute.wp.enum[0];
+	}
+
+	switch (attribute.ts.kind) {
+		case "string":
+			return "";
+		case "number":
+			return 0;
+		case "boolean":
+			return false;
+		case "array":
+			return [];
+		case "object": {
+			const result: Record<string, unknown> = {};
+			for (const [key, property] of Object.entries(attribute.ts.properties ?? {})) {
+				result[key] = createDefaultValue(property);
+			}
+			return result;
+		}
+		case "union": {
+			const firstBranch = Object.values(attribute.ts.union?.branches ?? {})[0];
+			return firstBranch ? createDefaultValue(firstBranch) : null;
+		}
+		default:
+			return null;
+	}
+}
+
+export function getValueAtPath(input: Record<string, unknown>, path: string): unknown {
+	if (!path) {
+		return undefined;
+	}
+
+	return path.split(".").reduce<unknown>((value, segment) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			return undefined;
+		}
+		return (value as Record<string, unknown>)[segment];
+	}, input);
+}
+
+export function resolveMigrationValue(
+	attribute: ManifestAttribute,
+	currentKey: string,
+	fallbackPath: string,
+	input: Record<string, unknown>,
+	renameMap: RenameMap,
+	transforms: TransformMap,
+): unknown {
+	const sourcePath = getSourcePath(currentKey, fallbackPath, renameMap);
+	const legacyValue = getValueAtPath(input, sourcePath);
+	const transformedValue = transforms[currentKey]
+		? transforms[currentKey](legacyValue, input)
+		: legacyValue;
+
+	return coerceValueFromManifest(attribute, transformedValue);
+}
+
+export function resolveMigrationAttribute(
+	attribute: ManifestAttribute,
+	currentPath: string,
+	fallbackPath: string,
+	input: Record<string, unknown>,
+	renameMap: RenameMap,
+	transforms: TransformMap,
+): unknown {
+	const sourcePath = getSourcePath(currentPath, fallbackPath, renameMap);
+
+	switch (attribute.ts.kind) {
+		case "object": {
+			const nextInput = Object.fromEntries(
+				Object.entries(attribute.ts.properties ?? {}).map(([key, property]) => [
+					key,
+					resolveMigrationAttribute(
+						property,
+						`${currentPath}.${key}`,
+						`${sourcePath}.${key}`,
+						input,
+						renameMap,
+						transforms,
+					),
+				]),
+			);
+
+			return coerceValueFromManifest(attribute, nextInput);
+		}
+		case "union": {
+			const legacyValue = getValueAtPath(input, sourcePath);
+			if (!isPlainObject(legacyValue) || !attribute.ts.union) {
+				return createDefaultValue(attribute);
+			}
+
+			const { discriminator, branches } = attribute.ts.union;
+			const branchKey = legacyValue[discriminator];
+			if (typeof branchKey !== "string" || !(branchKey in branches)) {
+				return createDefaultValue(attribute);
+			}
+
+			const branchAttribute = branches[branchKey];
+			const properties = branchAttribute.ts.properties ?? {};
+			const nextInput = Object.fromEntries(
+				Object.entries(properties)
+					.filter(([key]) => key !== discriminator)
+					.map(([key, property]) => [
+						key,
+						resolveMigrationAttribute(
+							property,
+							`${currentPath}.${branchKey}.${key}`,
+							`${sourcePath}.${key}`,
+							input,
+							renameMap,
+							transforms,
+						),
+					]),
+			);
+
+			return coerceValueFromManifest(attribute, {
+				...nextInput,
+				[discriminator]: branchKey,
+			});
+		}
+		default:
+			return resolveMigrationValue(attribute, currentPath, sourcePath, input, renameMap, transforms);
+	}
+}
+
+export function coerceValueFromManifest(attribute: ManifestAttribute, value: unknown): unknown {
+	if (value === undefined || value === null) {
+		return createDefaultValue(attribute);
+	}
+
+	switch (attribute.ts.kind) {
+		case "string":
+			return isValidString(attribute, value) ? value : createDefaultValue(attribute);
+		case "number":
+			return isValidNumber(attribute, value) ? value : createDefaultValue(attribute);
+		case "boolean":
+			return typeof value === "boolean" ? value : createDefaultValue(attribute);
+		case "array":
+			if (!Array.isArray(value) || !attribute.ts.items) {
+				return createDefaultValue(attribute);
+			}
+			return value.map((item) => coerceValueFromManifest(attribute.ts.items as ManifestAttribute, item));
+		case "object":
+			if (!isPlainObject(value)) {
+				return createDefaultValue(attribute);
+			}
+			return Object.fromEntries(
+				Object.entries(attribute.ts.properties ?? {}).map(([key, property]) => [
+					key,
+					coerceValueFromManifest(property, (value as Record<string, unknown>)[key]),
+				]),
+			);
+		case "union":
+			return coerceUnionValue(attribute, value);
+		default:
+			return createDefaultValue(attribute);
+	}
+}
+
+export function manifestMatchesDocument(manifest: ManifestDocument, attributes: Record<string, unknown>): boolean {
+	for (const [key, attribute] of Object.entries(manifest.attributes)) {
+		const value = attributes[key];
+		if ((value === undefined || value === null) && (!attribute.ts.required || attribute.typia.hasDefault)) {
+			continue;
+		}
+		if (!manifestMatchesAttribute(attribute, value)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+export function summarizeVersionDelta(
+	legacyManifest: ManifestDocument,
+	currentManifest: ManifestDocument,
+): { added: string[]; removed: string[]; changed: string[] } {
+	const added = Object.keys(currentManifest.attributes).filter((key) => !(key in legacyManifest.attributes));
+	const removed = Object.keys(legacyManifest.attributes).filter((key) => !(key in currentManifest.attributes));
+	const changed = Object.keys(currentManifest.attributes).filter((key) => {
+		if (!(key in legacyManifest.attributes)) {
+			return false;
+		}
+		return JSON.stringify(currentManifest.attributes[key]) !== JSON.stringify(legacyManifest.attributes[key]);
+	});
+
+	return { added, changed, removed };
+}
+
+function manifestMatchesAttribute(attribute: ManifestAttribute, value: unknown): boolean {
+	if ((value === undefined || value === null) && (!attribute.ts.required || attribute.typia.hasDefault)) {
+		return true;
+	}
+
+	switch (attribute.ts.kind) {
+		case "string":
+			return isValidString(attribute, value);
+		case "number":
+			return isValidNumber(attribute, value);
+		case "boolean":
+			return typeof value === "boolean";
+		case "array":
+			return Array.isArray(value)
+				&& Boolean(attribute.ts.items)
+				&& value.every((item) => manifestMatchesAttribute(attribute.ts.items as ManifestAttribute, item));
+		case "object":
+			return isPlainObject(value)
+				&& Object.entries(attribute.ts.properties ?? {}).every(([key, property]) =>
+					manifestMatchesAttribute(property, (value as Record<string, unknown>)[key]),
+				);
+		case "union":
+			return matchesUnionAttribute(attribute, value);
+		default:
+			return false;
+	}
+}
+
+function matchesUnionAttribute(attribute: ManifestAttribute, value: unknown): boolean {
+	if (!isPlainObject(value) || !attribute.ts.union) {
+		return false;
+	}
+
+	const { discriminator, branches } = attribute.ts.union;
+	const branchKey = (value as Record<string, unknown>)[discriminator];
+
+	return typeof branchKey === "string"
+		&& branchKey in branches
+		&& manifestMatchesAttribute(branches[branchKey], value);
+}
+
+function coerceUnionValue(attribute: ManifestAttribute, value: unknown): unknown {
+	if (!isPlainObject(value) || !attribute.ts.union) {
+		return createDefaultValue(attribute);
+	}
+
+	const { discriminator, branches } = attribute.ts.union;
+	const branchKey = (value as Record<string, unknown>)[discriminator];
+	if (typeof branchKey !== "string" || !(branchKey in branches)) {
+		return createDefaultValue(attribute);
+	}
+
+	return coerceValueFromManifest(branches[branchKey], value);
+}
+
+function isValidString(attribute: ManifestAttribute, value: unknown): value is string {
+	if (typeof value !== "string") {
+		return false;
+	}
+
+	const { enum: enumValues } = attribute.wp;
+	const { format, maxLength, minLength, pattern } = attribute.typia.constraints;
+
+	if (enumValues && !enumValues.includes(value)) {
+		return false;
+	}
+	if (typeof minLength === "number" && value.length < minLength) {
+		return false;
+	}
+	if (typeof maxLength === "number" && value.length > maxLength) {
+		return false;
+	}
+	if (pattern && !(new RegExp(pattern).test(value))) {
+		return false;
+	}
+	if (format === "uuid" && !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+		return false;
+	}
+
+	return true;
+}
+
+function isValidNumber(attribute: ManifestAttribute, value: unknown): value is number {
+	if (typeof value !== "number" || Number.isNaN(value)) {
+		return false;
+	}
+
+	const { enum: enumValues } = attribute.wp;
+	const { maximum, minimum, typeTag } = attribute.typia.constraints;
+
+	if (enumValues && !enumValues.includes(value)) {
+		return false;
+	}
+	if (typeof minimum === "number" && value < minimum) {
+		return false;
+	}
+	if (typeof maximum === "number" && value > maximum) {
+		return false;
+	}
+	if (typeTag === "uint32" && (!Number.isInteger(value) || value < 0 || value > 4294967295)) {
+		return false;
+	}
+
+	return true;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}