@nestia/migrate 11.2.1 → 11.3.1

package/src/factories/IdentifierFactory.ts

@@ -0,0 +1,69 @@
+import {
+  type Expression,
+  type Identifier,
+  type ParameterDeclaration,
+  type StringLiteral,
+  SyntaxKind,
+  type Token,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
+import { NamingConvention } from "@typia/utils";
+
+import { TypeFactory } from "./TypeFactory";
+
+/**
+ * Identifier / property-access / parameter helpers, mirroring `@typia/core`'s
+ * `IdentifierFactory`, built on `@ttsc/factory` so no `typescript` runtime is
+ * bundled.
+ */
+export namespace IdentifierFactory {
+  export const identifier = (name: string): Identifier | StringLiteral =>
+    NamingConvention.variable(name)
+      ? factory.createIdentifier(name)
+      : factory.createStringLiteral(name);
+
+  export const access = (
+    input: Expression,
+    key: string,
+    chain?: boolean,
+  ): Expression => {
+    const postfix: Identifier | StringLiteral = identifier(key);
+    return postfix.kind === "StringLiteral"
+      ? chain === true
+        ? factory.createElementAccessChain(
+            input,
+            factory.createToken(SyntaxKind.QuestionDotToken),
+            postfix,
+          )
+        : factory.createElementAccessExpression(input, postfix)
+      : chain === true
+        ? factory.createPropertyAccessChain(
+            input,
+            factory.createToken(SyntaxKind.QuestionDotToken),
+            postfix,
+          )
+        : factory.createPropertyAccessExpression(input, postfix);
+  };
+
+  export const parameter = (
+    name: string | Identifier,
+    type?: TypeNode,
+    init?: Expression | Token,
+  ): ParameterDeclaration => {
+    // a question token passed as `init` marks the parameter optional (`x?:`),
+    // mirroring `@typia/core`'s IdentifierFactory.parameter
+    const optional: boolean =
+      init !== undefined &&
+      init.kind === "Token" &&
+      init.token === SyntaxKind.QuestionToken;
+    return factory.createParameterDeclaration(
+      undefined,
+      undefined,
+      name,
+      optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
+      type ?? TypeFactory.keyword("any"),
+      optional ? undefined : (init as Expression | undefined),
+    );
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -0,0 +1,61 @@
+import {
+  type ArrayLiteralExpression,
+  type Expression,
+  type ObjectLiteralExpression,
+  factory,
+} from "@ttsc/factory";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { IdentifierFactory } from "./IdentifierFactory";
+
+/**
+ * JS value → AST expression helper, mirroring `@typia/core`'s
+ * `LiteralFactory.write`, built on `@ttsc/factory` so no `typescript` runtime
+ * is bundled.
+ */
+export namespace LiteralFactory {
+  export const write = (input: any): Expression => {
+    if (input === null) return factory.createNull();
+    else if (isFactoryNode(input)) return input;
+    else if (input instanceof Array) return writeArray(input);
+    else if (typeof input === "object") return writeObject(input);
+    else if (typeof input === "boolean")
+      return input ? factory.createTrue() : factory.createFalse();
+    else if (typeof input === "bigint") return ExpressionFactory.bigint(input);
+    else if (typeof input === "number") return ExpressionFactory.number(input);
+    else if (typeof input === "string")
+      return factory.createStringLiteral(input);
+    // unreachable code
+    else if (typeof input === "function")
+      return factory.createIdentifier("undefined");
+    else throw new TypeError("Error on LiteralFactory.write(): unknown type.");
+  };
+
+  /** Pass already-built expression nodes (arrow / call / identifier) through. */
+  const PASSTHROUGH: ReadonlySet<string> = new Set([
+    "ArrowFunction",
+    "CallExpression",
+    "Identifier",
+  ]);
+  const isFactoryNode = (input: any): input is Expression =>
+    typeof input === "object" &&
+    input !== null &&
+    typeof (input as { kind?: unknown }).kind === "string" &&
+    PASSTHROUGH.has((input as { kind: string }).kind);
+
+  const writeObject = (obj: object): ObjectLiteralExpression =>
+    factory.createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) =>
+          factory.createPropertyAssignment(
+            IdentifierFactory.identifier(key),
+            write(value),
+          ),
+        ),
+      true,
+    );
+
+  const writeArray = (array: any[]): ArrayLiteralExpression =>
+    factory.createArrayLiteralExpression(array.map(write), true);
+}

package/src/factories/StatementFactory.ts

@@ -0,0 +1,40 @@
+import {
+  type Expression,
+  type Identifier,
+  NodeFlags,
+  type TypeNode,
+  type VariableStatement,
+  factory,
+} from "@ttsc/factory";
+
+import { TypeFactory } from "./TypeFactory";
+
+/**
+ * Variable-statement helpers, mirroring `@typia/core`'s `StatementFactory`,
+ * built on `@ttsc/factory` so no `typescript` runtime is bundled.
+ */
+export namespace StatementFactory {
+  export const constant = (props: {
+    name: string | Identifier;
+    type?: TypeNode;
+    value?: Expression;
+  }): VariableStatement =>
+    factory.createVariableStatement(
+      undefined,
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.value === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.value,
+          ),
+        ],
+        NodeFlags.Const,
+      ),
+    );
+}

package/src/factories/TypeFactory.ts

@@ -0,0 +1,33 @@
+import { type KeywordTypeNode, SyntaxKind, factory } from "@ttsc/factory";
+
+/**
+ * Keyword type-node helper, mirroring `@typia/core`'s `TypeFactory.keyword`,
+ * but built on `@ttsc/factory` so no `typescript` runtime is bundled.
+ */
+export namespace TypeFactory {
+  export const keyword = (
+    type:
+      | "void"
+      | "any"
+      | "unknown"
+      | "boolean"
+      | "number"
+      | "bigint"
+      | "string",
+  ): KeywordTypeNode =>
+    factory.createKeywordTypeNode(
+      type === "void"
+        ? SyntaxKind.VoidKeyword
+        : type === "any"
+          ? SyntaxKind.AnyKeyword
+          : type === "unknown"
+            ? SyntaxKind.UnknownKeyword
+            : type === "boolean"
+              ? SyntaxKind.BooleanKeyword
+              : type === "number"
+                ? SyntaxKind.NumberKeyword
+                : type === "bigint"
+                  ? SyntaxKind.BigIntKeyword
+                  : SyntaxKind.StringKeyword,
+    );
+}

package/src/factories/TypeLiteralFactory.ts

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

package/src/factories/index.ts

@@ -0,0 +1,5 @@
+export * from "./ExpressionFactory";
+export * from "./IdentifierFactory";
+export * from "./LiteralFactory";
+export * from "./StatementFactory";
+export * from "./TypeFactory";

package/src/programmers/NestiaMigrateApiFileProgrammer.ts

@@ -1,5 +1,5 @@
+import { type Statement, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute, OpenApi } from "@typia/interface";
-import ts from "typescript";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -16,10 +16,10 @@ export namespace NestiaMigrateApiFileProgrammer {
     children: Set<string>;
   }
 
-  export const write = (props: IProps): ts.Statement[] => {
+  export const write = (props: IProps): Statement[] => {
     const importer: NestiaMigrateImportProgrammer =
       new NestiaMigrateImportProgrammer();
-    const statements: ts.Statement[] = props.routes
+    const statements: Statement[] = props.routes
       .map((route) => [
         FilePrinter.newLine(),
         NestiaMigrateApiFunctionProgrammer.write({
@@ -41,12 +41,11 @@ export namespace NestiaMigrateApiFileProgrammer {
         (ref) => `../${"../".repeat(props.namespace.length)}structures/${ref}`,
       ),
       ...[...props.children].map((child) =>
-        ts.factory.createExportDeclaration(
+        factory.createExportDeclaration(
           undefined,
           false,
-          ts.factory.createNamespaceExport(ts.factory.createIdentifier(child)),
-          ts.factory.createStringLiteral(`./${child}/index`),
-          undefined,
+          factory.createNamespaceExport(factory.createIdentifier(child)),
+          factory.createStringLiteral(`./${child}/index`),
         ),
       ),
       ...statements,

package/src/programmers/NestiaMigrateApiFunctionProgrammer.ts

@@ -1,8 +1,15 @@
-import { IdentifierFactory, StatementFactory } from "@typia/core";
+import {
+  type Expression,
+  type FunctionDeclaration,
+  type ParameterDeclaration,
+  type Statement,
+  SyntaxKind,
+  factory,
+} from "@ttsc/factory";
 import { IHttpMigrateRoute, OpenApi } from "@typia/interface";
 import { NamingConvention } from "@typia/utils";
-import ts from "typescript";
 
+import { IdentifierFactory, StatementFactory } from "../factories";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
@@ -16,25 +23,25 @@ export namespace NestiaMigrateApiFunctionProgrammer {
     route: IHttpMigrateRoute;
   }
 
-  export const write = (ctx: IContext): ts.FunctionDeclaration =>
+  export const write = (ctx: IContext): FunctionDeclaration =>
     FilePrinter.description(
-      ts.factory.createFunctionDeclaration(
+      factory.createFunctionDeclaration(
         [
-          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-          ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+          factory.createModifier(SyntaxKind.ExportKeyword),
+          factory.createModifier(SyntaxKind.AsyncKeyword),
         ],
         undefined,
         ctx.route.accessor.at(-1)!,
         undefined,
         writeParameterDeclarations(ctx),
-        ts.factory.createTypeReferenceNode("Promise", [
-          ts.factory.createTypeReferenceNode(
+        factory.createTypeReferenceNode("Promise", [
+          factory.createTypeReferenceNode(
             ctx.route.success === null
               ? "void"
               : `${ctx.route.accessor.at(-1)!}.Response`,
           ),
         ]),
-        ts.factory.createBlock(writeBody(ctx), true),
+        factory.createBlock(writeBody(ctx), true),
       ),
       writeDescription(ctx.config, ctx.route),
     );
@@ -42,10 +49,10 @@ export namespace NestiaMigrateApiFunctionProgrammer {
   export const writeParameterDeclarations = (
     ctx: IContext,
     connectionName?: string,
-  ): ts.ParameterDeclaration[] => {
-    const connection: ts.ParameterDeclaration = IdentifierFactory.parameter(
+  ): ParameterDeclaration[] => {
+    const connection: ParameterDeclaration = IdentifierFactory.parameter(
       connectionName ?? "connection",
-      ts.factory.createTypeReferenceNode(
+      factory.createTypeReferenceNode(
         ctx.importer.external({
           type: "instance",
           library: "@nestia/fetcher",
@@ -53,7 +60,7 @@ export namespace NestiaMigrateApiFunctionProgrammer {
         }),
         ctx.route.headers
           ? [
-              ts.factory.createTypeReferenceNode(
+              factory.createTypeReferenceNode(
                 `${ctx.route.accessor.at(-1)!}.Headers`,
               ),
             ]
@@ -68,12 +75,12 @@ export namespace NestiaMigrateApiFunctionProgrammer {
       if (isProps === false) return [connection];
       return [
         connection,
-        ts.factory.createParameterDeclaration(
+        factory.createParameterDeclaration(
           undefined,
           undefined,
           "props",
           undefined,
-          ts.factory.createTypeReferenceNode(
+          factory.createTypeReferenceNode(
             `${ctx.route.accessor.at(-1)!}.Props`,
           ),
         ),
@@ -95,7 +102,7 @@ export namespace NestiaMigrateApiFunctionProgrammer {
         ? [
             IdentifierFactory.parameter(
               ctx.route.query.key,
-              ts.factory.createTypeReferenceNode(
+              factory.createTypeReferenceNode(
                 `${ctx.route.accessor.at(-1)!}.Query`,
               ),
             ),
@@ -105,13 +112,13 @@ export namespace NestiaMigrateApiFunctionProgrammer {
         ? [
             IdentifierFactory.parameter(
               ctx.route.body.key,
-              ts.factory.createTypeReferenceNode(
+              factory.createTypeReferenceNode(
                 `${ctx.route.accessor.at(-1)!}.Body`,
               ),
               (ctx.route.body.type === "application/json" ||
                 ctx.route.body.type === "text/plain") &&
                 ctx.route.operation().requestBody?.required === false
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                ? factory.createToken(SyntaxKind.QuestionToken)
                 : undefined,
             ),
           ]
@@ -134,19 +141,19 @@ export namespace NestiaMigrateApiFunctionProgrammer {
     ].join("\n");
   };
 
-  const writeBody = (ctx: IContext): ts.Statement[] => {
+  const writeBody = (ctx: IContext): Statement[] => {
     const encrypted: boolean = !!ctx.route.success?.["x-nestia-encrypted"];
     const contentType: string = ctx.route.body?.type ?? "application/json";
 
-    const property = (key: string): ts.Expression =>
+    const property = (key: string): Expression =>
       ctx.config.keyword === true
-        ? IdentifierFactory.access(ts.factory.createIdentifier("props"), key)
-        : ts.factory.createIdentifier(key);
+        ? IdentifierFactory.access(factory.createIdentifier("props"), key)
+        : factory.createIdentifier(key);
     const fetch = () =>
-      ts.factory.createAwaitExpression(
-        ts.factory.createCallExpression(
+      factory.createAwaitExpression(
+        factory.createCallExpression(
           IdentifierFactory.access(
-            ts.factory.createIdentifier(
+            factory.createIdentifier(
               ctx.importer.external({
                 type: "instance",
                 library: encrypted
@@ -160,24 +167,24 @@ export namespace NestiaMigrateApiFunctionProgrammer {
           undefined,
           [
             contentType && contentType !== "multipart/form-data"
-              ? ts.factory.createObjectLiteralExpression(
+              ? factory.createObjectLiteralExpression(
                   [
-                    ts.factory.createSpreadAssignment(
-                      ts.factory.createIdentifier("connection"),
+                    factory.createSpreadAssignment(
+                      factory.createIdentifier("connection"),
                     ),
-                    ts.factory.createPropertyAssignment(
+                    factory.createPropertyAssignment(
                       "headers",
-                      ts.factory.createObjectLiteralExpression(
+                      factory.createObjectLiteralExpression(
                         [
-                          ts.factory.createSpreadAssignment(
+                          factory.createSpreadAssignment(
                             IdentifierFactory.access(
-                              ts.factory.createIdentifier("connection"),
+                              factory.createIdentifier("connection"),
                               "headers",
                             ),
                           ),
-                          ts.factory.createPropertyAssignment(
-                            ts.factory.createStringLiteral("Content-Type"),
-                            ts.factory.createStringLiteral(contentType),
+                          factory.createPropertyAssignment(
+                            factory.createStringLiteral("Content-Type"),
+                            factory.createStringLiteral(contentType),
                           ),
                         ],
                         true,
@@ -186,29 +193,29 @@ export namespace NestiaMigrateApiFunctionProgrammer {
                   ],
                   true,
                 )
-              : ts.factory.createIdentifier("connection"),
-            ts.factory.createObjectLiteralExpression(
+              : factory.createIdentifier("connection"),
+            factory.createObjectLiteralExpression(
               [
-                ts.factory.createSpreadAssignment(
+                factory.createSpreadAssignment(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(ctx.route.accessor.at(-1)!),
+                    factory.createIdentifier(ctx.route.accessor.at(-1)!),
                     "METADATA",
                   ),
                 ),
-                ts.factory.createPropertyAssignment(
+                factory.createPropertyAssignment(
                   "path",
-                  ts.factory.createCallExpression(
+                  factory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createIdentifier(ctx.route.accessor.at(-1)!),
+                      factory.createIdentifier(ctx.route.accessor.at(-1)!),
                       "path",
                     ),
                     undefined,
                     getArguments(ctx, false),
                   ),
                 ),
-                ts.factory.createPropertyAssignment(
+                factory.createPropertyAssignment(
                   "status",
-                  ts.factory.createNull(),
+                  factory.createNull(),
                 ),
               ],
               true,
@@ -218,22 +225,22 @@ export namespace NestiaMigrateApiFunctionProgrammer {
         ),
       );
 
-    const value: ts.Expression =
+    const value: Expression =
       ctx.config.simulate !== true
         ? fetch()
-        : ts.factory.createConditionalExpression(
-            ts.factory.createStrictEquality(
-              ts.factory.createTrue(),
-              ts.factory.createIdentifier("connection.simulate"),
+        : factory.createConditionalExpression(
+            factory.createStrictEquality(
+              factory.createTrue(),
+              factory.createIdentifier("connection.simulate"),
             ),
             undefined,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
+            factory.createCallExpression(
+              factory.createIdentifier(
                 `${ctx.route.accessor.at(-1)!}.simulate`,
               ),
               [],
               [
-                ts.factory.createIdentifier("connection"),
+                factory.createIdentifier("connection"),
                 ...getArguments(ctx, true),
               ],
             ),
@@ -243,51 +250,51 @@ export namespace NestiaMigrateApiFunctionProgrammer {
     const headers: Array<IAssignHeader | ISetHeader> = getHeaders(
       ctx.route.comment(),
     );
-    if (headers.length === 0) return [ts.factory.createReturnStatement(value)];
+    if (headers.length === 0) return [factory.createReturnStatement(value)];
     return [
       StatementFactory.constant({
         name: "output",
-        type: ts.factory.createTypeReferenceNode(
+        type: factory.createTypeReferenceNode(
           `${ctx.route.accessor.at(-1)!}.Response`,
         ),
         value,
       }),
-      ts.factory.createExpressionStatement(
-        ts.factory.createBinaryExpression(
-          ts.factory.createIdentifier("connection.headers"),
-          ts.factory.createToken(ts.SyntaxKind.QuestionQuestionEqualsToken),
-          ts.factory.createObjectLiteralExpression([]),
+      factory.createExpressionStatement(
+        factory.createBinaryExpression(
+          factory.createIdentifier("connection.headers"),
+          factory.createToken(SyntaxKind.QuestionQuestionEqualsToken),
+          factory.createObjectLiteralExpression([]),
         ),
       ),
       ...headers.map((h) =>
-        ts.factory.createExpressionStatement(
+        factory.createExpressionStatement(
           h.type === "assign"
-            ? ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.assign"),
+            ? factory.createCallExpression(
+                factory.createIdentifier("Object.assign"),
                 undefined,
                 [
-                  ts.factory.createIdentifier("connection.headers"),
-                  ts.factory.createIdentifier(`output.${h.accessor}`),
+                  factory.createIdentifier("connection.headers"),
+                  factory.createIdentifier(`output.${h.accessor}`),
                 ],
               )
-            : ts.factory.createBinaryExpression(
-                ts.factory.createIdentifier(
+            : factory.createBinaryExpression(
+                factory.createIdentifier(
                   `connection.headers${
                     NamingConvention.variable(h.property)
                       ? `.${h.property}`
                       : `[${JSON.stringify(h.property)}]`
                   }`,
                 ),
-                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                ts.factory.createIdentifier(`output.${h.accessor}`),
+                factory.createToken(SyntaxKind.EqualsToken),
+                factory.createIdentifier(`output.${h.accessor}`),
               ),
         ),
       ),
-      ts.factory.createReturnStatement(ts.factory.createIdentifier("output")),
+      factory.createReturnStatement(factory.createIdentifier("output")),
     ];
   };
 
-  const getArguments = (ctx: IContext, body: boolean): ts.Expression[] => {
+  const getArguments = (ctx: IContext, body: boolean): Expression[] => {
     if (
       ctx.route.parameters.length === 0 &&
       ctx.route.query === null &&
@@ -295,14 +302,14 @@ export namespace NestiaMigrateApiFunctionProgrammer {
     )
       return [];
     else if (ctx.config.keyword === true)
-      return [ts.factory.createIdentifier("props")];
+      return [factory.createIdentifier("props")];
     return [
-      ...ctx.route.parameters.map((p) => ts.factory.createIdentifier(p.key)),
+      ...ctx.route.parameters.map((p) => factory.createIdentifier(p.key)),
       ...(ctx.route.query
-        ? [ts.factory.createIdentifier(ctx.route.query.key)]
+        ? [factory.createIdentifier(ctx.route.query.key)]
         : []),
       ...(body && ctx.route.body
-        ? [ts.factory.createIdentifier(ctx.route.body.key)]
+        ? [factory.createIdentifier(ctx.route.body.key)]
         : []),
     ];
   };