@nestia/core 4.4.1 → 4.4.2-dev.20241217

package/src/programmers/internal/CoreMetadataUtil.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-export namespace CoreMetadataUtil {
-  export const atomics = (
-    meta: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export namespace CoreMetadataUtil {
+  export const atomics = (
+    meta: Metadata,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...meta.atomics.map((a) => a.type),
+      ...meta.constants.map((c) => c.type),
+      ...(meta.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (meta: Metadata): boolean =>
+    atomics(meta).size +
+      meta.arrays.length +
+      meta.tuples.length +
+      meta.natives.length +
+      meta.maps.length +
+      meta.objects.length >
+    1;
+}

package/src/transform.ts

@@ -1,35 +1,35 @@
-import ts from "typescript";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
-import { FileTransformer } from "./transformers/FileTransformer";
-
-export const transform = (
-  program: ts.Program,
-  options: INestiaTransformOptions | undefined,
-  extras: ITypiaContext["extras"],
-): ts.TransformerFactory<ts.SourceFile> => {
-  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
-  const strict: boolean =
-    compilerOptions.strictNullChecks !== undefined
-      ? !!compilerOptions.strictNullChecks
-      : !!compilerOptions.strict;
-  if (strict === false)
-    extras.addDiagnostic({
-      category: ts.DiagnosticCategory.Error,
-      code: "(@nestia/core)" as any,
-      file: undefined,
-      start: undefined,
-      length: undefined,
-      messageText: "strict mode is required.",
-    });
-  return FileTransformer.transform({
-    program,
-    compilerOptions,
-    checker: program.getTypeChecker(),
-    printer: ts.createPrinter(),
-    options: options ?? {},
-    extras,
-  });
-};
-export default transform;
+import ts from "typescript";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
+import { FileTransformer } from "./transformers/FileTransformer";
+
+export const transform = (
+  program: ts.Program,
+  options: INestiaTransformOptions | undefined,
+  extras: ITypiaContext["extras"],
+): ts.TransformerFactory<ts.SourceFile> => {
+  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
+  const strict: boolean =
+    compilerOptions.strictNullChecks !== undefined
+      ? !!compilerOptions.strictNullChecks
+      : !!compilerOptions.strict;
+  if (strict === false)
+    extras.addDiagnostic({
+      category: ts.DiagnosticCategory.Error,
+      code: "(@nestia/core)" as any,
+      file: undefined,
+      start: undefined,
+      length: undefined,
+      messageText: "strict mode is required.",
+    });
+  return FileTransformer.transform({
+    program,
+    compilerOptions,
+    checker: program.getTypeChecker(),
+    printer: ts.createPrinter(),
+    options: options ?? {},
+    extras,
+  });
+};
+export default transform;

package/src/transformers/FileTransformer.ts

@@ -1,110 +1,110 @@
-import ts from "typescript";
-import { ImportProgrammer } from "typia/lib/programmers/ImportProgrammer";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { NodeTransformer } from "./NodeTransformer";
-
-export namespace FileTransformer {
-  export const transform =
-    (context: Omit<INestiaTransformContext, "importer" | "transformer">) =>
-    (transformer: ts.TransformationContext) =>
-    (file: ts.SourceFile): ts.SourceFile => {
-      if (file.isDeclarationFile) return file;
-      const importer = new ImportProgrammer({
-        internalPrefix: "nestia_core_transform",
-      });
-      file = ts.visitEachChild(
-        file,
-        (node) =>
-          iterate_node({
-            context: {
-              ...context,
-              transformer,
-              importer,
-            },
-            file,
-            node,
-          }),
-        transformer,
-      );
-      const index: number = find_import_injection_index(file);
-      return ts.factory.updateSourceFile(
-        file,
-        [
-          ...file.statements.slice(0, index),
-          ...importer.toStatements(),
-          ...file.statements.slice(index),
-        ],
-        false,
-        file.referencedFiles,
-        file.typeReferenceDirectives,
-        file.hasNoDefaultLib,
-        file.libReferenceDirectives,
-      );
-    };
-
-  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,
-    );
-
-  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;
-
-      // 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 find_import_injection_index = (file: ts.SourceFile): number => {
-    let i: number = 0;
-    for (; i < file.statements.length; ++i) {
-      const stmt: ts.Statement = file.statements[i]!;
-      if (
-        ts.isExpressionStatement(stmt) &&
-        ts.isStringLiteralLike(stmt.expression) &&
-        stmt.expression.text.startsWith("use ")
-      )
-        continue;
-      break;
-    }
-    return i;
-  };
-}
-
-const isTransformerError = (error: any): error is TransformerError =>
-  typeof error === "object" &&
-  error !== null &&
-  error.constructor.name === "TransformerError" &&
-  typeof error.code === "string" &&
-  typeof error.message === "string";
+import ts from "typescript";
+import { ImportProgrammer } from "typia/lib/programmers/ImportProgrammer";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+  export const transform =
+    (context: Omit<INestiaTransformContext, "importer" | "transformer">) =>
+    (transformer: ts.TransformationContext) =>
+    (file: ts.SourceFile): ts.SourceFile => {
+      if (file.isDeclarationFile) return file;
+      const importer = new ImportProgrammer({
+        internalPrefix: "nestia_core_transform",
+      });
+      file = ts.visitEachChild(
+        file,
+        (node) =>
+          iterate_node({
+            context: {
+              ...context,
+              transformer,
+              importer,
+            },
+            file,
+            node,
+          }),
+        transformer,
+      );
+      const index: number = find_import_injection_index(file);
+      return ts.factory.updateSourceFile(
+        file,
+        [
+          ...file.statements.slice(0, index),
+          ...importer.toStatements(),
+          ...file.statements.slice(index),
+        ],
+        false,
+        file.referencedFiles,
+        file.typeReferenceDirectives,
+        file.hasNoDefaultLib,
+        file.libReferenceDirectives,
+      );
+    };
+
+  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,
+    );
+
+  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;
+
+      // 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 find_import_injection_index = (file: ts.SourceFile): number => {
+    let i: number = 0;
+    for (; i < file.statements.length; ++i) {
+      const stmt: ts.Statement = file.statements[i]!;
+      if (
+        ts.isExpressionStatement(stmt) &&
+        ts.isStringLiteralLike(stmt.expression) &&
+        stmt.expression.text.startsWith("use ")
+      )
+        continue;
+      break;
+    }
+    return i;
+  };
+}
+
+const isTransformerError = (error: any): error is TransformerError =>
+  typeof error === "object" &&
+  error !== null &&
+  error.constructor.name === "TransformerError" &&
+  typeof error.code === "string" &&
+  typeof error.message === "string";

package/src/transformers/MethodTransformer.ts

@@ -1,103 +1,103 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { TypedRouteTransformer } from "./TypedRouteTransformer";
-import { WebSocketRouteTransformer } from "./WebSocketRouteTransformer";
-
-export namespace MethodTransformer {
-  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 =
-      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 (type === undefined) return props.method;
-
-    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 =
-  (checker: ts.TypeChecker) =>
-  (type: ts.Type): ts.Type => {
-    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
-    return symbol && get_name(symbol) === "Promise"
-      ? escape_promise(checker)(type)
-      : type;
-  };
-
-const escape_promise =
-  (checker: ts.TypeChecker) =>
-  (type: ts.Type): ts.Type => {
-    const generic: readonly ts.Type[] = checker.getTypeArguments(
-      type as ts.TypeReference,
-    );
-    if (generic.length !== 1)
-      throw new Error(
-        "Error on ImportAnalyzer.analyze(): invalid promise type.",
-      );
-    return generic[0];
-  };
-
-const get_name = (symbol: ts.Symbol): string =>
-  explore_name(symbol.getDeclarations()![0].parent)(
-    symbol.escapedName.toString(),
-  );
-
-const explore_name =
-  (decl: ts.Node) =>
-  (name: string): string =>
-    ts.isModuleBlock(decl)
-      ? explore_name(decl.parent.parent)(
-          `${decl.parent.name.getFullText().trim()}.${name}`,
-        )
-      : name;
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { TypedRouteTransformer } from "./TypedRouteTransformer";
+import { WebSocketRouteTransformer } from "./WebSocketRouteTransformer";
+
+export namespace MethodTransformer {
+  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 =
+      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 (type === undefined) return props.method;
+
+    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 =
+  (checker: ts.TypeChecker) =>
+  (type: ts.Type): ts.Type => {
+    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
+    return symbol && get_name(symbol) === "Promise"
+      ? escape_promise(checker)(type)
+      : type;
+  };
+
+const escape_promise =
+  (checker: ts.TypeChecker) =>
+  (type: ts.Type): ts.Type => {
+    const generic: readonly ts.Type[] = checker.getTypeArguments(
+      type as ts.TypeReference,
+    );
+    if (generic.length !== 1)
+      throw new Error(
+        "Error on ImportAnalyzer.analyze(): invalid promise type.",
+      );
+    return generic[0];
+  };
+
+const get_name = (symbol: ts.Symbol): string =>
+  explore_name(symbol.getDeclarations()![0].parent)(
+    symbol.escapedName.toString(),
+  );
+
+const explore_name =
+  (decl: ts.Node) =>
+  (name: string): string =>
+    ts.isModuleBlock(decl)
+      ? explore_name(decl.parent.parent)(
+          `${decl.parent.name.getFullText().trim()}.${name}`,
+        )
+      : name;

package/src/transformers/NodeTransformer.ts

@@ -1,23 +1,23 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { MethodTransformer } from "./MethodTransformer";
-import { ParameterTransformer } from "./ParameterTransformer";
-
-export namespace NodeTransformer {
-  export const transform = (props: {
-    context: INestiaTransformContext;
-    node: ts.Node;
-  }): ts.Node =>
-    ts.isMethodDeclaration(props.node)
-      ? MethodTransformer.transform({
-          context: props.context,
-          method: props.node,
-        })
-      : ts.isParameter(props.node)
-        ? ParameterTransformer.transform({
-            context: props.context,
-            param: props.node,
-          })
-        : props.node;
-}
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { MethodTransformer } from "./MethodTransformer";
+import { ParameterTransformer } from "./ParameterTransformer";
+
+export namespace NodeTransformer {
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.isMethodDeclaration(props.node)
+      ? MethodTransformer.transform({
+          context: props.context,
+          method: props.node,
+        })
+      : ts.isParameter(props.node)
+        ? ParameterTransformer.transform({
+            context: props.context,
+            param: props.node,
+          })
+        : props.node;
+}