@nestia/core 11.2.0 → 12.0.0-dev.20260520.1

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,103 +0,0 @@
-import {
-  IProgrammerProps,
-  JsonAssertStringifyProgrammer,
-  JsonIsStringifyProgrammer,
-  JsonMetadataFactory,
-  JsonStringifyProgrammer,
-  JsonValidateStringifyProgrammer,
-  LlmParametersProgrammer,
-} from "@typia/core";
-import ts from "typescript";
-
-import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // VALIDATE TYPE
-    if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm | true =
-        props.context.options.llm;
-      JsonMetadataFactory.analyze({
-        method: "@nestia.core.TypedRoute",
-        checker: props.context.checker,
-        transformer: props.context.transformer,
-        type: props.type,
-        validate: (next) => {
-          if (next.metadata.size() === 0) return [];
-          return LlmParametersProgrammer.validate({
-            config: {
-              strict: llm === true ? false : (llm.strict ?? false),
-            },
-            metadata: next.metadata,
-            explore: next.explore,
-          });
-        },
-      });
-    }
-
-    // GENERATE STRINGIFY PLAN
-    const parameter = (next: {
-      type: string;
-      key: string;
-      programmer: (next: IProgrammerProps) => ts.Expression;
-    }) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(next.type),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(next.key),
-          next.programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter({
-        type: "is",
-        key: "is",
-        programmer: JsonIsStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate")
-      return parameter({
-        type: "validate",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "stringify")
-      return parameter({
-        type: "stringify",
-        key: "stringify",
-        programmer: JsonStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate.log")
-      return parameter({
-        type: "validate.log",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter({
-      type: "assert",
-      key: "assert",
-      programmer: JsonAssertStringifyProgrammer.write,
-    });
-  };
-}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,74 +0,0 @@
-import {
-  AssertProgrammer,
-  ITypiaContext,
-  IdentifierFactory,
-  StatementFactory,
-} from "@typia/core";
-import ts from "typescript";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpAssertQuerifyProgrammer {
-  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: "assert",
-          value: AssertProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            config: {
-              equals: false,
-              guard: false,
-            },
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("stringify"),
-            undefined,
-            [
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ],
-          ),
-        ),
-      ]),
-    );
-}

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -1,77 +0,0 @@
-import {
-  ITypiaContext,
-  IdentifierFactory,
-  IsProgrammer,
-  StatementFactory,
-} from "@typia/core";
-import ts from "typescript";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpIsQuerifyProgrammer {
-  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: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("is"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ]),
-    );
-}

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -1,110 +0,0 @@
-import {
-  FunctionProgrammer,
-  HttpQueryProgrammer,
-  ITypiaContext,
-  IdentifierFactory,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataObject,
-  MetadataSchema,
-  StatementFactory,
-  TransformerError,
-} from "@typia/core";
-import ts from "typescript";
-
-export namespace HttpQuerifyProgrammer {
-  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 storage: 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,
-      },
-      type: props.type,
-      components: storage,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: 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(
-        [
-          ...functor.declare(),
-          StatementFactory.constant({
-            name: "output",
-            value: ts.factory.createNewExpression(
-              ts.factory.createIdentifier("URLSearchParams"),
-              undefined,
-              [],
-            ),
-          }),
-          ...object.type.properties.map((p) =>
-            ts.factory.createExpressionStatement(
-              decode(p.key.constants[0]!.values[0]!.value as string)(p.value),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  const decode =
-    (key: string) =>
-    (value: MetadataSchema): ts.CallExpression =>
-      !!value.arrays.length
-        ? ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              IdentifierFactory.access(
-                ts.factory.createIdentifier("input"),
-                key,
-              ),
-              "forEach",
-            ),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("elem")],
-                undefined,
-                undefined,
-                append(key)(ts.factory.createIdentifier("elem")),
-              ),
-            ],
-          )
-        : append(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"),
-      undefined,
-      [ts.factory.createStringLiteral(key), elem],
-    );
-}

package/src/programmers/http/HttpValidateQuerifyProgrammer.ts

@@ -1,78 +0,0 @@
-import {
-  ITypiaContext,
-  IdentifierFactory,
-  StatementFactory,
-  ValidateProgrammer,
-} from "@typia/core";
-import ts from "typescript";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpValidateQuerifyProgrammer {
-  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: {
-                ...props.context.options,
-                functional: false,
-                numeric: true,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "query",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "output",
-          value: ts.factory.createCallExpression(
-            ts.factory.createIdentifier("query"),
-            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"),
-          ),
-        ),
-      ]),
-    );
-}

package/src/programmers/internal/CoreMetadataUtil.ts

@@ -1,21 +0,0 @@
-import { MetadataSchema } from "@typia/core";
-
-export namespace CoreMetadataUtil {
-  export const atomics = (
-    meta: MetadataSchema,
-  ): 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: MetadataSchema): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}

package/src/transformers/FileTransformer.ts

@@ -1,109 +0,0 @@
-import { ImportProgrammer, TransformerError } from "@typia/core";
-import ts from "typescript";
-
-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 +0,0 @@
-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 +0,0 @@
-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;
-}