@wp-typia/project-tools 0.15.2 → 0.15.4

package/dist/runtime/cli-add.js

@@ -643,8 +643,107 @@ async function renderWorkspacePersistenceServerModule(projectDir, variables) {
     const templateDir = buildServerTemplateRoot(variables.persistencePolicy);
     await copyInterpolatedDirectory(templateDir, targetDir, variables);
 }
-async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables) {
+const COMPOUND_SHARED_SUPPORT_FILES = ["hooks.ts", "validator-toolkit.ts"];
+const LEGACY_ASSERT_PATTERN = /assert:\s*typia\.createAssert</u;
+const LEGACY_MANIFEST_PATTERN = /\r?\n[ \t]*manifest:\s*currentManifest,/u;
+const LEGACY_TOOLKIT_CALL_PATTERN = /createTemplateValidatorToolkit<\s*(?<typeName>[A-Za-z0-9_]+)\s*>\s*\(\s*\{/u;
+const LEGACY_VALIDATOR_TOOLKIT_IMPORT_PATTERN = /from\s*["']\.\.\/\.\.\/validator-toolkit["']/u;
+const TYPIA_IMPORT_PATTERN = /^[\uFEFF \t]*import\s+typia\s+from\s*["']typia["'];?/mu;
+const COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS = [
+    /interface\s+TemplateValidatorFunctions\s*<\s*T\s+extends\s+object\s*>\s*\{/u,
+    /\bassert\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']assert["']\s*\]/u,
+    /\bclone\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']clone["']\s*\]/u,
+    /\bis\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']is["']\s*\]/u,
+    /\bprune\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']prune["']\s*\]/u,
+    /\brandom\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']random["']\s*\]/u,
+    /\bvalidate\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']validate["']\s*\]/u,
+    /createTemplateValidatorToolkit\s*<\s*T\s+extends\s+object\s*>\s*\(\s*\{/u,
+];
+function shouldRefreshCompoundValidatorToolkit(source) {
+    return (source === null ||
+        !COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS.every((pattern) => pattern.test(source)));
+}
+function isLegacyCompoundValidatorSource(source) {
+    return (typeof source === "string" &&
+        LEGACY_VALIDATOR_TOOLKIT_IMPORT_PATTERN.test(source) &&
+        !LEGACY_ASSERT_PATTERN.test(source));
+}
+function hasTypiaImport(source) {
+    return TYPIA_IMPORT_PATTERN.test(source.replace(/\/\*[\s\S]*?\*\//gu, ""));
+}
+function upgradeLegacyCompoundValidatorSource(source) {
+    const typeNameMatch = source.match(LEGACY_TOOLKIT_CALL_PATTERN);
+    const typeName = typeNameMatch?.groups?.typeName;
+    if (!typeName) {
+        throw new Error("Unable to upgrade a legacy compound validator without a generated type import.");
+    }
+    let nextSource = source;
+    if (!hasTypiaImport(nextSource)) {
+        nextSource = `import typia from 'typia';\n${nextSource}`;
+    }
+    nextSource = nextSource.replace(LEGACY_TOOLKIT_CALL_PATTERN, [
+        `createTemplateValidatorToolkit< ${typeName} >( {`,
+        `\tassert: typia.createAssert< ${typeName} >(),`,
+        `\tclone: typia.misc.createClone< ${typeName} >() as (`,
+        `\t\tvalue: ${typeName},`,
+        `\t) => ${typeName},`,
+        `\tis: typia.createIs< ${typeName} >(),`,
+    ].join("\n") + "\n");
+    const replacedManifest = nextSource.replace(LEGACY_MANIFEST_PATTERN, [
+        "",
+        "\tmanifest: currentManifest,",
+        `\tprune: typia.misc.createPrune< ${typeName} >(),`,
+        `\trandom: typia.createRandom< ${typeName} >() as (`,
+        "\t\t...args: unknown[]",
+        `\t) => ${typeName},`,
+        `\tvalidate: typia.createValidate< ${typeName} >(),`,
+    ].join("\n"));
+    if (replacedManifest === nextSource) {
+        throw new Error("Unable to upgrade legacy compound validator: manifest anchor not found.");
+    }
+    return replacedManifest;
+}
+async function collectLegacyCompoundValidatorPaths(projectDir) {
+    const blocksDir = path.join(projectDir, "src", "blocks");
+    if (!fs.existsSync(blocksDir)) {
+        return [];
+    }
+    const blockEntries = await fsp.readdir(blocksDir, { withFileTypes: true });
+    const validatorPaths = await Promise.all(blockEntries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+        const validatorPath = path.join(blocksDir, entry.name, "validators.ts");
+        const validatorSource = await readOptionalFile(validatorPath);
+        return isLegacyCompoundValidatorSource(validatorSource) ? validatorPath : null;
+    }));
+    return validatorPaths.filter((validatorPath) => validatorPath !== null);
+}
+async function ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths) {
+    for (const fileName of COMPOUND_SHARED_SUPPORT_FILES) {
+        const sourcePath = path.join(tempProjectDir, "src", fileName);
+        if (!fs.existsSync(sourcePath)) {
+            continue;
+        }
+        const targetPath = path.join(projectDir, "src", fileName);
+        const currentSource = await readOptionalFile(targetPath);
+        if (fileName === "validator-toolkit.ts"
+            ? shouldRefreshCompoundValidatorToolkit(currentSource)
+            : currentSource === null) {
+            await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+            await fsp.copyFile(sourcePath, targetPath);
+        }
+    }
+    for (const validatorPath of legacyValidatorPaths) {
+        const currentSource = await readOptionalFile(validatorPath);
+        if (!isLegacyCompoundValidatorSource(currentSource)) {
+            continue;
+        }
+        await fsp.writeFile(validatorPath, upgradeLegacyCompoundValidatorSource(currentSource), "utf8");
+    }
+}
+async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables, legacyValidatorPaths = []) {
     if (templateId === "compound") {
+        await ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths);
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path.join(projectDir, "src", "blocks", variables.slugKebabCase));
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
         if (variables.compoundPersistenceEnabled === "true") {
@@ -809,6 +908,12 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
         const migrationConfigSource = await readOptionalFile(migrationConfigPath);
         const migrationConfig = migrationConfigSource === null ? null : parseMigrationConfig(migrationConfigSource);
+        const compoundSupportPaths = resolvedTemplateId === "compound"
+            ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path.join(workspace.projectDir, "src", fileName))
+            : [];
+        const legacyCompoundValidatorPaths = resolvedTemplateId === "compound"
+            ? await collectLegacyCompoundValidatorPaths(workspace.projectDir)
+            : [];
         const result = await scaffoldProject({
             answers: {
                 ...defaults,
@@ -829,14 +934,19 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         });
         assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
         const mutationSnapshot = {
-            fileSources: await snapshotWorkspaceFiles([blockConfigPath, migrationConfigPath]),
+            fileSources: await snapshotWorkspaceFiles([
+                blockConfigPath,
+                migrationConfigPath,
+                ...compoundSupportPaths,
+                ...legacyCompoundValidatorPaths,
+            ]),
             snapshotDirs: migrationConfig === null
                 ? []
                 : buildMigrationBlocks(resolvedTemplateId, result.variables).map((block) => path.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
             targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables),
         };
         try {
-            await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables);
+            await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
             await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
             await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" ||
                 (resolvedTemplateId === "compound" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@wp-typia/api-client": "^0.4.2",
-    "@wp-typia/block-runtime": "^0.4.2",
+    "@wp-typia/block-runtime": "^0.4.3",
     "@wp-typia/rest": "^0.3.5",
     "@wp-typia/block-types": "^0.2.1",
     "mustache": "^4.2.0",

package/templates/_shared/base/src/validator-toolkit.ts.mustache

@@ -1,30 +1,44 @@
-import typia from 'typia';
-
 import type { ManifestDefaultsDocument } from '@wp-typia/block-runtime/defaults';
 import {
 	createScaffoldValidatorToolkit,
 	type ScaffoldValidatorToolkitOptions,
 } from '@wp-typia/block-runtime/validation';
 
-interface TemplateValidatorToolkitOptions< T extends object > {
+interface TemplateValidatorFunctions< T extends object > {
+	assert: ScaffoldValidatorToolkitOptions< T >['assert'];
+	clone: ScaffoldValidatorToolkitOptions< T >['clone'];
+	is: ScaffoldValidatorToolkitOptions< T >['is'];
+	prune: ScaffoldValidatorToolkitOptions< T >['prune'];
+	random: ScaffoldValidatorToolkitOptions< T >['random'];
+	validate: ScaffoldValidatorToolkitOptions< T >['validate'];
+}
+
+interface TemplateValidatorToolkitOptions< T extends object >
+	extends TemplateValidatorFunctions< T > {
 	finalize?: ScaffoldValidatorToolkitOptions< T >['finalize'];
 	manifest: unknown;
 	onValidationError?: ScaffoldValidatorToolkitOptions< T >['onValidationError'];
 }
 
 export function createTemplateValidatorToolkit< T extends object >( {
+	assert,
+	clone,
 	finalize,
+	is,
 	manifest,
 	onValidationError,
+	prune,
+	random,
+	validate,
 }: TemplateValidatorToolkitOptions< T > ) {
 	return createScaffoldValidatorToolkit< T >( {
 		manifest: manifest as ManifestDefaultsDocument,
-		validate: typia.createValidate< T >(),
-		assert: typia.createAssert< T >(),
-		is: typia.createIs< T >(),
-		random: typia.createRandom< T >() as ( ...args: unknown[] ) => T,
-		clone: typia.misc.createClone< T >() as ( value: T ) => T,
-		prune: typia.misc.createPrune< T >(),
+		validate,
+		assert,
+		is,
+		random,
+		clone,
+		prune,
 		finalize,
 		onValidationError,
 	} );

package/templates/_shared/base/webpack.config.js.mustache

@@ -95,5 +95,6 @@ module.exports = async () => {
 		getArtifactEntries,
 		getOptionalModuleEntries: () => optionalModuleEntries,
 		importTypiaWebpackPlugin: () => import("@typia/unplugin/webpack"),
+		projectRoot: process.cwd(),
 	});
 };

package/templates/_shared/compound/core/webpack.config.js.mustache

@@ -137,5 +137,6 @@ module.exports = async () => {
 		importTypiaWebpackPlugin: () => import( '@typia/unplugin/webpack' ),
 		moduleEntriesMode: 'replace',
 		nonModuleEntriesMode: 'replace',
+		projectRoot: process.cwd(),
 	} );
 };

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/validators.ts.mustache

@@ -1,3 +1,4 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type {
 	{{pascalCase}}Attributes,
@@ -7,7 +8,16 @@ import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
 	finalize: ( normalized ) => ( {
 		...normalized,
 		resourceKey:
@@ -15,6 +25,7 @@ const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attribu
 				? normalized.resourceKey
 				: generateResourceKey( '{{slugKebabCase}}' ),
 	} ),
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validators = scaffoldValidators.validators;

package/templates/_shared/persistence/core/src/validators.ts.mustache

@@ -1,3 +1,4 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type {
 	{{pascalCase}}Attributes,
@@ -7,7 +8,16 @@ import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
 import { createTemplateValidatorToolkit } from './validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
 	finalize: ( normalized ) => ( {
 		...normalized,
 		resourceKey:
@@ -15,6 +25,7 @@ const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attribu
 				? normalized.resourceKey
 				: generateResourceKey( '{{slugKebabCase}}' ),
 	} ),
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validators = scaffoldValidators.validators;

package/templates/basic/src/validators.ts.mustache

@@ -1,14 +1,25 @@
+import typia from 'typia';
 import currentManifest from "./typia.manifest.json";
 import { {{pascalCase}}Attributes, {{pascalCase}}ValidationResult } from "./types";
 import { generateBlockId } from "@wp-typia/block-runtime/identifiers";
 import { createTemplateValidatorToolkit } from "./validator-toolkit";
 
 const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attributes>({
+  assert: typia.createAssert<{{pascalCase}}Attributes>(),
+  clone: typia.misc.createClone<{{pascalCase}}Attributes>() as (
+    value: {{pascalCase}}Attributes,
+  ) => {{pascalCase}}Attributes,
+  is: typia.createIs<{{pascalCase}}Attributes>(),
   manifest: currentManifest,
+  prune: typia.misc.createPrune<{{pascalCase}}Attributes>(),
+  random: typia.createRandom<{{pascalCase}}Attributes>() as (
+    ...args: unknown[]
+  ) => {{pascalCase}}Attributes,
   finalize: (normalized) => ({
     ...normalized,
     id: normalized.id && normalized.id.length > 0 ? normalized.id : generateBlockId(),
   }),
+  validate: typia.createValidate<{{pascalCase}}Attributes>(),
 });
 
 export const validate{{pascalCase}}Attributes =

package/templates/compound/src/blocks/{{slugKebabCase}}/validators.ts.mustache

@@ -1,9 +1,20 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type { {{pascalCase}}Attributes } from './types';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validate{{pascalCase}}Attributes =

package/templates/compound/src/blocks/{{slugKebabCase}}-item/validators.ts.mustache

@@ -1,9 +1,20 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type { {{pascalCase}}ItemAttributes } from './types';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}ItemAttributes >( {
+	assert: typia.createAssert< {{pascalCase}}ItemAttributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}ItemAttributes >() as (
+		value: {{pascalCase}}ItemAttributes,
+	) => {{pascalCase}}ItemAttributes,
+	is: typia.createIs< {{pascalCase}}ItemAttributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}ItemAttributes >(),
+	random: typia.createRandom< {{pascalCase}}ItemAttributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}ItemAttributes,
+	validate: typia.createValidate< {{pascalCase}}ItemAttributes >(),
 } );
 
 export const validate{{pascalCase}}ItemAttributes =

package/templates/interactivity/src/validators.ts.mustache

@@ -1,10 +1,20 @@
+import typia from 'typia';
 import currentManifest from "./typia.manifest.json";
 import { {{pascalCase}}Attributes, {{pascalCase}}ValidationResult } from "./types";
 import { generateScopedClientId } from "@wp-typia/block-runtime/identifiers";
 import { createTemplateValidatorToolkit } from "./validator-toolkit";
 
 const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attributes>({
+  assert: typia.createAssert<{{pascalCase}}Attributes>(),
+  clone: typia.misc.createClone<{{pascalCase}}Attributes>() as (
+    value: {{pascalCase}}Attributes,
+  ) => {{pascalCase}}Attributes,
+  is: typia.createIs<{{pascalCase}}Attributes>(),
   manifest: currentManifest,
+  prune: typia.misc.createPrune<{{pascalCase}}Attributes>(),
+  random: typia.createRandom<{{pascalCase}}Attributes>() as (
+    ...args: unknown[]
+  ) => {{pascalCase}}Attributes,
   finalize: (normalized) => ({
     ...normalized,
     uniqueId:
@@ -12,6 +22,7 @@ const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attribut
         ? normalized.uniqueId
         : generateScopedClientId("{{slugKebabCase}}"),
   }),
+  validate: typia.createValidate<{{pascalCase}}Attributes>(),
 });
 
 export const validate{{pascalCase}}Attributes =