@nestia/core 3.17.0 → 4.0.0-dev.20241010-2

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -2,61 +2,74 @@ import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
 import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
 import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
 
 export namespace HttpIsQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "is",
-            IsProgrammer.write({
-              ...project,
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "is",
+          value: IsProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: false,
               },
-            })(modulo)(false)(type),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            HttpQuerifyProgrammer.write({
-              ...project,
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: false,
               },
-            })(modulo)(type),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createConditionalExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("is"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("is"),
               undefined,
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("stringify"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
               undefined,
-              ts.factory.createNull(),
+              [ts.factory.createIdentifier("input")],
             ),
+            undefined,
+            ts.factory.createNull(),
           ),
-        ]),
-      );
+        ),
+      ]),
+    );
 }

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -3,63 +3,73 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+import { FunctionProgrammer } from "typia/lib/programmers/helpers/FunctionProgrammer";
 import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 import { TransformerError } from "typia/lib/transformers/TransformerError";
 
 export namespace HttpQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ArrowFunction => {
-      // GET OBJECT TYPE
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const collection: MetadataCollection = new MetadataCollection();
-      const result = MetadataFactory.analyze(project.checker)({
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction => {
+    // GET OBJECT TYPE
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const collection: MetadataCollection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
         escape: false,
         constant: true,
         absorb: true,
         validate: HttpQueryProgrammer.validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(
-          `nestia.core.TypedQuery.${importer.method}`,
-        )(result.errors);
+      },
+      type: props.type,
+      collection,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: `nestia.core.TypedQuery.${functor.method}`,
+        errors: result.errors,
+      });
 
-      const object: MetadataObject = result.data.objects[0]!;
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...importer.declare(modulo),
-            StatementFactory.constant(
-              "output",
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
-                undefined,
-                [],
-              ),
-            ),
-            ...object.properties.map((p) =>
-              ts.factory.createExpressionStatement(
-                decode(p.key.constants[0]!.values[0].value as string)(p.value),
-              ),
+    const object: MetadataObject = result.data.objects[0]!;
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock(
+        [
+          ...functor.declare(),
+          StatementFactory.constant({
+            name: "output",
+            value: ts.factory.createNewExpression(
+              ts.factory.createIdentifier("URLSearchParams"),
+              undefined,
+              [],
             ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("output"),
+          }),
+          ...object.properties.map((p) =>
+            ts.factory.createExpressionStatement(
+              decode(p.key.constants[0]!.values[0].value as string)(p.value),
             ),
-          ],
-          true,
-        ),
-      );
-    };
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
 
   const decode =
     (key: string) =>
@@ -67,10 +77,12 @@ export namespace HttpQuerifyProgrammer {
       !!value.arrays.length
         ? ts.factory.createCallExpression(
             IdentifierFactory.access(
-              IdentifierFactory.access(ts.factory.createIdentifier("input"))(
+              IdentifierFactory.access(
+                ts.factory.createIdentifier("input"),
                 key,
               ),
-            )("forEach"),
+              "forEach",
+            ),
             undefined,
             [
               ts.factory.createArrowFunction(
@@ -84,12 +96,12 @@ export namespace HttpQuerifyProgrammer {
             ],
           )
         : append(key)(
-            IdentifierFactory.access(ts.factory.createIdentifier("input"))(key),
+            IdentifierFactory.access(ts.factory.createIdentifier("input"), key),
           );
 
   const append = (key: string) => (elem: ts.Expression) =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("output"))("append"),
+      IdentifierFactory.access(ts.factory.createIdentifier("output"), "append"),
       undefined,
       [ts.factory.createStringLiteral(key), elem],
     );

package/src/programmers/http/HttpValidateQuerifyProgrammer.ts

@@ -2,62 +2,75 @@ import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
 import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
 import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
 
 export namespace HttpValidateQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "validate",
+          value: ValidateProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: true,
               },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "query",
-            HttpQuerifyProgrammer.write({
-              ...project,
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "query",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: false,
               },
-            })(modulo)(type),
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "output",
+          value: ts.factory.createCallExpression(
+            ts.factory.createIdentifier("query"),
+            undefined,
+            [ts.factory.createIdentifier("input")],
           ),
-          StatementFactory.constant(
-            "output",
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createAsExpression(
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
+              ts.factory.createIdentifier("validate"),
               undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("output")],
-              ),
-              ts.factory.createTypeReferenceNode("any"),
+              [ts.factory.createIdentifier("output")],
             ),
+            ts.factory.createTypeReferenceNode("any"),
           ),
-        ]),
-      );
+        ),
+      ]),
+    );
 }

package/src/transform.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
 import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
 import { FileTransformer } from "./transformers/FileTransformer";
@@ -7,7 +7,7 @@ import { FileTransformer } from "./transformers/FileTransformer";
 export const transform = (
   program: ts.Program,
   options: INestiaTransformOptions | undefined,
-  extras: IProject["extras"],
+  extras: ITypiaContext["extras"],
 ): ts.TransformerFactory<ts.SourceFile> => {
   const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
   const strict: boolean =

package/src/transformers/FileTransformer.ts

@@ -1,61 +1,83 @@
 import ts from "typescript";
+import { ImportProgrammer } from "typia/lib/programmers/ImportProgrammer";
 import { TransformerError } from "typia/lib/transformers/TransformerError";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { NodeTransformer } from "./NodeTransformer";
 
 export namespace FileTransformer {
   export const transform =
-    (project: Omit<INestiaTransformProject, "context">) =>
-    (context: ts.TransformationContext) =>
-    (file: ts.SourceFile): ts.SourceFile =>
-      file.isDeclarationFile
-        ? file
-        : ts.visitEachChild(
+    (context: Omit<INestiaTransformContext, "importer" | "transformer">) =>
+    (transformer: ts.TransformationContext) =>
+    (file: ts.SourceFile): ts.SourceFile => {
+      if (file.isDeclarationFile) return file;
+      const importer = new ImportProgrammer();
+      file = ts.visitEachChild(
+        file,
+        (node) =>
+          iterate_node({
+            context: {
+              ...context,
+              transformer,
+              importer,
+            },
             file,
-            (node) =>
-              iterate_node({
-                ...project,
-                context,
-              })(context)(file)(node),
-            context,
-          );
-
-  const iterate_node =
-    (project: INestiaTransformProject) =>
-    (context: ts.TransformationContext) =>
-    (file: ts.SourceFile) =>
-    (node: ts.Node): ts.Node =>
-      ts.visitEachChild(
-        try_transform_node(project)(file)(node) ?? node,
-        (child) => iterate_node(project)(context)(file)(child),
-        context,
+            node,
+          }),
+        transformer,
+      );
+      return ts.factory.updateSourceFile(
+        file,
+        [...importer.toStatements(), ...file.statements],
+        false,
+        file.referencedFiles,
+        file.typeReferenceDirectives,
+        file.hasNoDefaultLib,
+        file.libReferenceDirectives,
       );
+    };
 
-  const try_transform_node =
-    (project: INestiaTransformProject) =>
-    (file: ts.SourceFile) =>
-    (node: ts.Node): ts.Node | null => {
-      try {
-        return NodeTransformer.transform(project)(node);
-      } catch (exp) {
-        // ONLY ACCEPT TRANSFORMER-ERROR
-        if (!isTransformerError(exp)) throw exp;
+  const iterate_node = (props: {
+    context: INestiaTransformContext;
+    file: ts.SourceFile;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.visitEachChild(
+      try_transform_node(props) ?? props.node,
+      (child) =>
+        iterate_node({
+          context: props.context,
+          file: props.file,
+          node: child,
+        }),
+      props.context.transformer,
+    );
 
-        // AVOID SPECIAL BUG OF TYPESCRIPT COMPILER API
-        (node as any).parent ??= file;
+  const try_transform_node = (props: {
+    context: INestiaTransformContext;
+    file: ts.SourceFile;
+    node: ts.Node;
+  }): ts.Node | null => {
+    try {
+      return NodeTransformer.transform(props);
+    } catch (exp) {
+      // ONLY ACCEPT TRANSFORMER-ERROR
+      if (!isTransformerError(exp)) throw exp;
 
-        // REPORT DIAGNOSTIC
-        const diagnostic = (ts as any).createDiagnosticForNode(node, {
-          key: exp.code,
-          category: ts.DiagnosticCategory.Error,
-          message: exp.message,
-          code: `(${exp.code})` as any,
-        });
-        project.extras.addDiagnostic(diagnostic);
-        return null;
-      }
-    };
+      // AVOID SPECIAL BUG OF TYPESCRIPT COMPILER API
+      (props.node as any).parent ??= props.file;
+
+      // REPORT DIAGNOSTIC
+      const diagnostic = (ts as any).createDiagnosticForNode(props.node, {
+        key: exp.code,
+        category: ts.DiagnosticCategory.Error,
+        message: exp.message,
+        code: `(${exp.code})` as any,
+      });
+      props.context.extras.addDiagnostic(diagnostic);
+      return null;
+    }
+  };
 }
 
 const isTransformerError = (error: any): error is TransformerError =>

package/src/transformers/MethodTransformer.ts

@@ -1,64 +1,69 @@
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { TypedRouteTransformer } from "./TypedRouteTransformer";
 import { WebSocketRouteTransformer } from "./WebSocketRouteTransformer";
 
 export namespace MethodTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (method: ts.MethodDeclaration): ts.MethodDeclaration => {
-      const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-        ? ts.getDecorators(method)
-        : (method as any).decorators;
-      if (!decorators?.length) return method;
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    method: ts.MethodDeclaration;
+  }): ts.MethodDeclaration => {
+    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+      ? ts.getDecorators(props.method)
+      : (props.method as any).decorators;
+    if (!decorators?.length) return props.method;
 
-      const signature: ts.Signature | undefined =
-        project.checker.getSignatureFromDeclaration(method);
-      const original: ts.Type | undefined =
-        signature && project.checker.getReturnTypeOfSignature(signature);
-      const escaped: ts.Type | undefined =
-        original && get_escaped_type(project.checker)(original);
+    const signature: ts.Signature | undefined =
+      props.context.checker.getSignatureFromDeclaration(props.method);
+    const original: ts.Type | undefined =
+      signature && props.context.checker.getReturnTypeOfSignature(signature);
+    const type: ts.Type | undefined =
+      original && get_escaped_type(props.context.checker)(original);
 
-      if (escaped === undefined) return method;
+    if (type === undefined) return props.method;
 
-      const operator = (decorator: ts.Decorator): ts.Decorator => {
-        decorator =
-          TypedRouteTransformer.transform(project)(escaped)(decorator);
-        decorator = WebSocketRouteTransformer.validate(project)(
-          decorator,
-          method,
-        );
-        return decorator;
-      };
-      if (ts.getDecorators !== undefined)
-        return ts.factory.updateMethodDeclaration(
-          method,
-          (method.modifiers || []).map((mod) =>
-            ts.isDecorator(mod) ? operator(mod) : mod,
-          ),
-          method.asteriskToken,
-          method.name,
-          method.questionToken,
-          method.typeParameters,
-          method.parameters,
-          method.type,
-          method.body,
-        );
-      // eslint-disable-next-line
-      return (ts.factory.updateMethodDeclaration as any)(
-        method,
-        decorators.map(operator),
-        (method as any).modifiers,
-        method.asteriskToken,
-        method.name,
-        method.questionToken,
-        method.typeParameters,
-        method.parameters,
-        method.type,
-        method.body,
-      );
+    const operator = (decorator: ts.Decorator): ts.Decorator => {
+      decorator = TypedRouteTransformer.transform({
+        context: props.context,
+        decorator,
+        type,
+      });
+      decorator = WebSocketRouteTransformer.validate({
+        context: props.context,
+        method: props.method,
+        decorator,
+      });
+      return decorator;
     };
+    if (ts.getDecorators !== undefined)
+      return ts.factory.updateMethodDeclaration(
+        props.method,
+        (props.method.modifiers || []).map((mod) =>
+          ts.isDecorator(mod) ? operator(mod) : mod,
+        ),
+        props.method.asteriskToken,
+        props.method.name,
+        props.method.questionToken,
+        props.method.typeParameters,
+        props.method.parameters,
+        props.method.type,
+        props.method.body,
+      );
+    // eslint-disable-next-line
+    return (ts.factory.updateMethodDeclaration as any)(
+      props.method,
+      decorators.map(operator),
+      (props.method as any).modifiers,
+      props.method.asteriskToken,
+      props.method.name,
+      props.method.questionToken,
+      props.method.typeParameters,
+      props.method.parameters,
+      props.method.type,
+      props.method.body,
+    );
+  };
 }
 
 const get_escaped_type =