@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,107 +0,0 @@
-import {
-  HttpQueryProgrammer,
-  ITypiaContext,
-  LlmParametersProgrammer,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-  TransformerError,
-} from "@typia/core";
-import { ValidationPipe } from "@typia/interface";
-import ts from "typescript";
-
-import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
-import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
-import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
-import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
-
-export namespace TypedQueryRouteProgrammer {
-  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;
-      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            escape: false,
-            constant: true,
-            absorb: true,
-            validate: (next) => {
-              const errors: string[] = HttpQueryProgrammer.validate({
-                metadata: next.metadata,
-                explore: next.explore,
-                allowOptional: true,
-              });
-              if (next.metadata.size() !== 0)
-                errors.push(
-                  ...LlmParametersProgrammer.validate({
-                    config: {
-                      strict: llm === true ? false : (llm.strict ?? false),
-                    },
-                    metadata: next.metadata,
-                    explore: next.explore,
-                  }),
-                );
-              return errors;
-            },
-          },
-          components: new MetadataCollection(),
-          type: props.type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: props.modulo.getText(),
-          errors: result.errors,
-        });
-    }
-
-    // GENERATE STRINGIFY PLAN
-    const parameter = (
-      key: string,
-      programmer: (next: {
-        context: ITypiaContext;
-        modulo: ts.LeftHandSideExpression;
-        type: ts.Type;
-      }) => ts.ArrowFunction,
-    ) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(key),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(key),
-          programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter("is", HttpIsQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "validate")
-      return parameter("validate", HttpValidateQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "stringify")
-      return parameter("stringify", HttpQuerifyProgrammer.write);
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter("assert", HttpAssertQuerifyProgrammer.write);
-  };
-}

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";