@nestia/migrate 11.2.0 → 12.0.0-dev.20260520.1

package/src/executable/bundle.js

@@ -8,7 +8,7 @@ const TYPIA = require("js-yaml").load(
   fs.readFileSync(`${__dirname}/../../../../pnpm-lock.yaml`, "utf8"),
 ).catalogs.samchon;
 
-const update = (content) => {
+const update = (content, options = {}) => {
   const parsed = JSON.parse(content);
   for (const record of [
     parsed.dependencies ?? {},
@@ -18,9 +18,210 @@ const update = (content) => {
       if (key.startsWith("@nestia/") || key === "nestia")
         record[key] = `^${version}`;
       else if (TYPIA[key]) record[key] = TYPIA[key].specifier;
+  migratePackageJson(parsed);
+  if (options.sdkAggregate) {
+    parsed.devDependencies ??= {};
+    parsed.devDependencies["@nestia/core"] = `^${version}`;
+  }
   return JSON.stringify(parsed, null, 2);
 };
 
+const migratePackageJson = (parsed) => {
+  if (parsed.scripts)
+    for (const [key, value] of Object.entries(parsed.scripts))
+      if (typeof value === "string")
+        parsed.scripts[key] = normalizeScript(value);
+
+  if (typeof parsed.scripts?.prepare === "string") {
+    const prepare = parsed.scripts.prepare
+      .split("&&")
+      .map((str) => str.trim())
+      .filter((str) => str !== "ts-patch install" && str !== "typia patch")
+      .join(" && ");
+    if (prepare.length === 0) delete parsed.scripts.prepare;
+    else parsed.scripts.prepare = prepare;
+  }
+
+  const devDependencies = parsed.devDependencies;
+  if (devDependencies) {
+    const usesTypeScript = typeof devDependencies.typescript === "string";
+    delete devDependencies["ts-patch"];
+    delete devDependencies["typescript-transform-paths"];
+    if (usesTypeScript) devDependencies.ttsc ??= "^0.10.2";
+  }
+};
+
+const trimTemplateDependencies = (parsed) => {
+  if (parsed.dependencies) {
+    delete parsed.dependencies.commander;
+    delete parsed.dependencies.inquirer;
+  }
+  if (parsed.devDependencies) {
+    delete parsed.devDependencies["@types/inquirer"];
+    delete parsed.devDependencies.commander;
+    delete parsed.devDependencies.inquirer;
+  }
+};
+
+const normalizeScript = (script) =>
+  script.replace(/(^|[^A-Za-z0-9_-])tsc(?=$|[^A-Za-z0-9_-])/g, "$1ttsc");
+
+const TYPIA_PLUGIN = `{ "transform": "typia/lib/transform", "enabled": false }`;
+const SDK_PLUGIN = `{ "transform": "@nestia/sdk/lib/transform" }`;
+const CORE_PLUGIN = `{ "transform": "@nestia/core/native/transform.cjs" }`;
+
+const ARGUMENT_PARSER = `import { createInterface } from "node:readline/promises";
+
+export namespace ArgumentParser {
+  export interface Command {
+    option: (flags: string, description?: string) => Command;
+  }
+
+  export interface Prompt {
+    select: (
+      name: string,
+    ) => (
+      message: string,
+    ) => <Choice extends string>(choices: Choice[]) => Promise<Choice>;
+    boolean: (name: string) => (message: string) => Promise<boolean>;
+    number: (name: string) => (message: string) => Promise<number>;
+  }
+
+  export const parse = async <T>(
+    inquiry: (
+      command: Command,
+      prompt: Prompt,
+      action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>,
+  ): Promise<T> => {
+    const command: Command = {
+      option: (_flags: string, _description?: string): Command => command,
+    };
+    const action = (closure: (options: Partial<T>) => Promise<T>) =>
+      closure(parseArguments() as Partial<T>);
+    return inquiry(
+      command,
+      { select, boolean, number },
+      action,
+    );
+  };
+
+  const select =
+    (_name: string) =>
+    (message: string) =>
+    async <Choice extends string>(choices: Choice[]): Promise<Choice> => {
+      const answer: string = await ask(\`\${message} (\${choices.join("/")})\`);
+      return (choices.find((choice) => choice === answer) ?? choices[0])!;
+    };
+
+  const boolean = (_name: string) => async (message: string) =>
+    /^(true|t|yes|y|1)$/i.test(await ask(\`\${message} [y/N]\`));
+
+  const number = (_name: string) => async (message: string) =>
+    Number(await ask(message));
+
+  const ask = async (message: string): Promise<string> => {
+    const reader = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    try {
+      return (await reader.question(\`\${message}: \`)).trim();
+    } finally {
+      reader.close();
+    }
+  };
+
+  const parseArguments = (): Record<string, string | string[] | boolean> => {
+    const output: Record<string, string | string[] | boolean> = {};
+    const args: string[] = process.argv.slice(2);
+    for (let i = 0; i < args.length; ++i) {
+      const raw: string = args[i]!;
+      if (raw.startsWith("--") === false) continue;
+
+      const equal: number = raw.indexOf("=");
+      const name: string = toCamelCase(
+        raw.slice(2, equal === -1 ? undefined : equal),
+      );
+      if (equal !== -1) {
+        assign(output, name, raw.slice(equal + 1));
+        continue;
+      }
+
+      const values: string[] = [];
+      while (i + 1 < args.length && args[i + 1]!.startsWith("--") === false)
+        values.push(args[++i]!);
+      assign(
+        output,
+        name,
+        values.length === 0 ? true : values.length === 1 ? values[0]! : values,
+      );
+    }
+    return output;
+  };
+
+  const assign = (
+    output: Record<string, string | string[] | boolean>,
+    name: string,
+    value: string | string[] | boolean,
+  ): void => {
+    const current: string | string[] | boolean | undefined = output[name];
+    if (current === undefined) output[name] = value;
+    else
+      output[name] = [
+        ...(Array.isArray(current) ? current : [String(current)]),
+        ...(Array.isArray(value) ? value : [String(value)]),
+      ];
+  };
+
+  const toCamelCase = (str: string): string =>
+    str.replace(/-([a-z])/g, (_matched, letter: string) =>
+      letter.toUpperCase(),
+    );
+}
+`;
+
+const updateTsConfig = (content, options = {}) => {
+  content = content.replace(
+    /^\s*\{\s*"transform":\s*"typescript-transform-paths"\s*\},\n/gm,
+    "",
+  );
+  if (options.disableTypia)
+    content = content.replace(
+      /\{\s*"transform":\s*"typia\/lib\/transform"\s*\}/g,
+      TYPIA_PLUGIN,
+    );
+  if (options.useNestiaAggregate)
+    content = content.replace(
+      /\{\s*"transform":\s*"@nestia\/core\/lib\/transform"\s*\}/g,
+      CORE_PLUGIN,
+    );
+  if (
+    options.useNestiaSdk &&
+    content.includes(`"@nestia/sdk/lib/transform"`) === false
+  )
+    content = content.replace(
+      /\{\s*"transform":\s*"@nestia\/core\/native\/transform\.cjs"\s*\}/g,
+      `${SDK_PLUGIN},\n      ${CORE_PLUGIN}`,
+    );
+  if (
+    options.useNestiaAggregate &&
+    content.includes(`"@nestia/core/native/transform.cjs"`) === false
+  )
+    content = content.replace(
+      /\{\s*"transform":\s*"typia\/lib\/transform",\s*"enabled":\s*false\s*\},/g,
+      options.useNestiaSdk
+        ? `${TYPIA_PLUGIN},\n      ${SDK_PLUGIN},\n      ${CORE_PLUGIN},`
+        : `${TYPIA_PLUGIN},\n      ${CORE_PLUGIN},`,
+    );
+  if (options.useNestiaSdk)
+    content = content.replace(
+      /\{\s*"transform":\s*"@nestia\/core\/native\/transform\.cjs"\s*\},\n\s*\{\s*"transform":\s*"@nestia\/sdk\/lib\/transform"\s*\},/g,
+      `${SDK_PLUGIN},\n      ${CORE_PLUGIN},`,
+    );
+  return content;
+};
+
 const bundle = async ({ mode, repository, exceptions, transform }) => {
   const root = `${__dirname}/../..`;
   const assets = `${root}/assets`;
@@ -82,10 +283,19 @@ const bundle = async ({ mode, repository, exceptions, transform }) => {
   await iterate(collection)(template);
   if (transform)
     for (const [key, value] of Object.entries(collection))
-      collection[key] = transform(key, value);
+      collection[key] = await writeTransformedAsset(
+        template,
+        key,
+        transform(key, value),
+      );
   await archive(collection);
 };
 
+const writeTransformedAsset = async (template, key, value) => {
+  await fs.promises.writeFile(`${template}/${key}`, value, "utf8");
+  return value;
+};
+
 const main = async () => {
   await bundle({
     mode: "nest",
@@ -101,7 +311,18 @@ const main = async () => {
       "test/features",
     ],
     transform: (key, value) => {
-      if (key.endsWith("package.json")) return update(value);
+      if (key.endsWith("package.json")) {
+        const parsed = JSON.parse(update(value));
+        trimTemplateDependencies(parsed);
+        return JSON.stringify(parsed, null, 2);
+      }
+      if (key === "test/helpers/ArgumentParser.ts") return ARGUMENT_PARSER;
+      if (key.endsWith("tsconfig.json"))
+        return updateTsConfig(value, {
+          disableTypia: true,
+          useNestiaAggregate: key === "tsconfig.json",
+          useNestiaSdk: key === "tsconfig.json",
+        });
       return value;
     },
   });
@@ -118,7 +339,19 @@ const main = async () => {
       "test/features",
     ],
     transform: (key, value) => {
-      if (key.endsWith("package.json")) return update(value);
+      if (key.endsWith("package.json")) {
+        const parsed = JSON.parse(
+          update(value, { sdkAggregate: key === "package.json" }),
+        );
+        trimTemplateDependencies(parsed);
+        return JSON.stringify(parsed, null, 2);
+      }
+      if (key === "test/utils/ArgumentParser.ts") return ARGUMENT_PARSER;
+      if (key.endsWith("tsconfig.json"))
+        return updateTsConfig(value, {
+          disableTypia: true,
+          useNestiaAggregate: true,
+        });
       return value;
     },
   });

package/src/factories/TypeLiteralFactory.ts

@@ -1,5 +1,9 @@
-import { NamingConvention } from "@typia/utils";
-import ts from "typescript";
+import { TypeScriptFactory } from "@nestia/factory";
+import * as typiaUtils from "@typia/utils";
+import ts from "../internal/ts";
+
+const { NamingConvention } =
+  (typiaUtils as { default?: typeof typiaUtils }).default ?? typiaUtils;
 
 export namespace TypeLiteralFactory {
   export const generate = (value: any): ts.TypeNode =>
@@ -15,40 +19,42 @@ export namespace TypeLiteralFactory {
               : Array.isArray(value)
                 ? generateTuple(value)
                 : generateObject(value)
-            : ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
+            : TypeScriptFactory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
 
   const generatestring = (str: string) =>
-    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(str));
+    TypeScriptFactory.createLiteralTypeNode(
+      TypeScriptFactory.createStringLiteral(str),
+    );
 
   const generateNumber = (num: number) =>
-    ts.factory.createLiteralTypeNode(
+    TypeScriptFactory.createLiteralTypeNode(
       num < 0
-        ? ts.factory.createPrefixUnaryExpression(
+        ? TypeScriptFactory.createPrefixUnaryExpression(
             ts.SyntaxKind.MinusToken,
-            ts.factory.createNumericLiteral(-num),
+            TypeScriptFactory.createNumericLiteral(-num),
           )
-        : ts.factory.createNumericLiteral(num),
+        : TypeScriptFactory.createNumericLiteral(num),
     );
 
   const generateBoolean = (bool: boolean) =>
-    ts.factory.createLiteralTypeNode(
-      bool ? ts.factory.createTrue() : ts.factory.createFalse(),
+    TypeScriptFactory.createLiteralTypeNode(
+      bool ? TypeScriptFactory.createTrue() : TypeScriptFactory.createFalse(),
     );
 
   const generateNull = () =>
-    ts.factory.createLiteralTypeNode(ts.factory.createNull());
+    TypeScriptFactory.createLiteralTypeNode(TypeScriptFactory.createNull());
 
   const generateTuple = (items: any[]) =>
-    ts.factory.createTupleTypeNode(items.map(generate));
+    TypeScriptFactory.createTupleTypeNode(items.map(generate));
 
   const generateObject = (obj: object) =>
-    ts.factory.createTypeLiteralNode(
+    TypeScriptFactory.createTypeLiteralNode(
       Object.entries(obj).map(([key, value]) =>
-        ts.factory.createPropertySignature(
+        TypeScriptFactory.createPropertySignature(
           undefined,
           NamingConvention.variable(key)
-            ? ts.factory.createIdentifier(key)
-            : ts.factory.createStringLiteral(key),
+            ? TypeScriptFactory.createIdentifier(key)
+            : TypeScriptFactory.createStringLiteral(key),
           undefined,
           generate(value),
         ),

package/src/internal/ts.ts

@@ -0,0 +1,94 @@
+// Compatibility shim that replaces `import ts from "./ts"`. The values
+// (`ts.factory`, `ts.SyntaxKind`, `ts.NodeFlags`) are routed to @nestia/factory
+// so the migration generators run without a `typescript` dependency, while the
+// type aliases (`ts.Expression`, `ts.ParameterDeclaration`, …) collapse to the
+// shared @nestia/factory `Node` so existing annotations type-check unchanged.
+//
+// Every alias is intentionally `Node`; the migrate package treats AST nodes as
+// opaque tokens it composes and prints — it never inspects them with
+// TypeScript-Compiler-API guards that would need the original brands.
+
+import {
+  NodeFlags,
+  SyntaxKind,
+  TypeScriptFactory,
+  type Node,
+} from "@nestia/factory";
+
+interface MutableEmitNode {
+  leadingComments?: Array<{
+    kind: number;
+    text: string;
+    hasTrailingNewLine?: boolean;
+  }>;
+}
+
+interface TsValue {
+  factory: typeof TypeScriptFactory;
+  NodeFlags: typeof NodeFlags;
+  SyntaxKind: typeof SyntaxKind;
+  addSyntheticLeadingComment(
+    node: Node,
+    kind: number,
+    text: string,
+    hasTrailingNewLine?: boolean,
+  ): Node;
+  isUnionTypeNode(node: Node | undefined): node is Node;
+  isTypeReferenceNode(node: Node | undefined): node is Node;
+  isIdentifier(node: Node | undefined): node is Node;
+}
+
+const ts: TsValue = {
+  factory: TypeScriptFactory,
+  NodeFlags,
+  SyntaxKind,
+  // Pushes a synthetic leading comment onto the node's emit metadata, matching
+  // the surface of the TypeScript-Compiler-API helper of the same name. The
+  // @nestia/factory printer reads `emitNode.leadingComments` and emits them
+  // before the node body.
+  addSyntheticLeadingComment: (
+    node: Node,
+    kind: number,
+    text: string,
+    hasTrailingNewLine?: boolean,
+  ): Node => {
+    const mutable = node as Node & { emitNode?: MutableEmitNode };
+    const emitNode = (mutable.emitNode ??= {});
+    (emitNode.leadingComments ??= []).push({
+      kind,
+      text,
+      hasTrailingNewLine,
+    });
+    return node;
+  },
+  isUnionTypeNode: (node: Node | undefined): node is Node =>
+    !!node && node.kind === SyntaxKind.UnionType,
+  isTypeReferenceNode: (node: Node | undefined): node is Node =>
+    !!node && node.kind === SyntaxKind.TypeReference,
+  isIdentifier: (node: Node | undefined): node is Node =>
+    !!node && node.kind === SyntaxKind.Identifier,
+};
+
+type _Node = Node;
+
+declare namespace ts {
+  export type Node = _Node;
+  export type CallExpression = Node;
+  export type ConciseBody = Node;
+  export type Decorator = Node;
+  export type Expression = Node;
+  export type FunctionDeclaration = Node;
+  export type Identifier = Node;
+  export type KeywordTypeNode = Node;
+  export type MethodDeclaration = Node;
+  export type ModuleDeclaration = Node;
+  export type ParameterDeclaration = Node;
+  export type Statement = Node;
+  export type TypeAliasDeclaration = Node;
+  export type TypeNode = Node;
+  export type TypeReferenceNode = Node;
+  export type UnionTypeNode = Node;
+  export type VariableStatement = Node;
+}
+
+export default ts;

package/src/programmers/NestiaMigrateApiFileProgrammer.ts

@@ -1,5 +1,6 @@
+import { TypeScriptFactory } from "@nestia/factory";
 import { IHttpMigrateRoute, OpenApi } from "@typia/interface";
-import ts from "typescript";
+import ts from "../internal/ts";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -41,11 +42,13 @@ export namespace NestiaMigrateApiFileProgrammer {
         (ref) => `../${"../".repeat(props.namespace.length)}structures/${ref}`,
       ),
       ...[...props.children].map((child) =>
-        ts.factory.createExportDeclaration(
+        TypeScriptFactory.createExportDeclaration(
           undefined,
           false,
-          ts.factory.createNamespaceExport(ts.factory.createIdentifier(child)),
-          ts.factory.createStringLiteral(`./${child}/index`),
+          TypeScriptFactory.createNamespaceExport(
+            TypeScriptFactory.createIdentifier(child),
+          ),
+          TypeScriptFactory.createStringLiteral(`./${child}/index`),
           undefined,
         ),
       ),