@nestia/sdk 13.0.4 → 14.0.1

package/src/analyses/ReflectHttpOperationParameterAnalyzer.ts

@@ -2,20 +2,14 @@ import { SwaggerExample } from "@nestia/core";
 import { ROUTE_ARGS_METADATA } from "@nestjs/common/constants";
 import { RouteParamtypes } from "@nestjs/common/enums/route-paramtypes.enum";
 
-import {
-  HttpFormDataProgrammer,
-  HttpHeadersProgrammer,
-  HttpParameterProgrammer,
-  HttpQueryProgrammer,
-  JsonMetadataFactory,
-} from "../internal/legacy";
+import { JsonMetadataFactory } from "../internal/legacy";
 import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { HttpHeadersValidator } from "../validators/HttpHeadersValidator";
-import { HttpQueryValidator } from "../validators/HttpQueryValidator";
 import { TextPlainValidator } from "../validators/TextPlainValidator";
+import { ParameterNameAnalyzer } from "./ParameterNameAnalyzer";
+import { SwaggerExampleAnalyzer } from "./SwaggerExampleAnalyzer";
 
 export namespace ReflectHttpOperationParameterAnalyzer {
   export interface IContext {
@@ -89,7 +83,9 @@ export namespace ReflectHttpOperationParameterAnalyzer {
         preconfigured
           .filter((x) => x.category === "headers")
           .map((x) => x.field)
-          .filter((field) => field !== undefined),
+          .filter((field) => field !== undefined)
+          // NestJS reads `req.headers[name.toLowerCase()]`
+          .map((field) => field.toLowerCase()),
       ) === false
     )
       contradict(`Duplicated field names of headers are not allowed.`);
@@ -105,7 +101,7 @@ export namespace ReflectHttpOperationParameterAnalyzer {
     //----
     // COMPOSE PARAMETERS
     //----
-    const parameters: IReflectHttpOperationParameter[] = preconfigured
+    const declared: IReflectHttpOperationParameter[] = preconfigured
       .map((p): IReflectHttpOperationParameter | null => {
         // METADATA INFO
         const pErrorContents: Array<string | IOperationMetadata.IError> = [];
@@ -116,7 +112,8 @@ export namespace ReflectHttpOperationParameterAnalyzer {
             file: ctx.controller.file,
             class: ctx.controller.class.name,
             function: ctx.functionName,
-            from: `parameter ${matched ? JSON.stringify(matched.name) : `of ${p.index} th`}`,
+            // a destructured parameter has no name to report
+            from: `parameter ${matched?.name ? JSON.stringify(matched.name) : `of ${p.index} th`}`,
             contents: pErrorContents,
           });
           return null;
@@ -129,20 +126,31 @@ export namespace ReflectHttpOperationParameterAnalyzer {
           pErrorContents.push(`Failed to get the type info.`);
 
         // CONSIDER KIND
-        const schema: IOperationMetadata.ISchema | null = (() => {
+        const pipe = (() => {
           if (matched === undefined) return null;
-          const result =
-            p.category === "body" &&
+          return p.category === "body" &&
             (p.contentType === "application/json" || p.encrypted === true)
-              ? matched.primitive
-              : matched.resolved;
-          return result.success ? result.data : null;
+            ? matched.primitive
+            : matched.resolved;
         })();
+        const schema: IOperationMetadata.ISchema | null =
+          pipe?.success === true ? pipe.data : null;
+        // A type the metadata analysis could not read has no SDK or Swagger
+        // form; dropping the parameter would leave a function that cannot
+        // send what the route requires.
+        if (pipe?.success === false) pErrorContents.push(...pipe.errors);
         if (p.category === "body" && p.field !== undefined)
           pErrorContents.push(`@Body() must not have a field name.`);
         else if (p.category === "param" && p.field === undefined)
           pErrorContents.push(`@Param() must have a field name.`);
 
+        // The wire rules of the parameter's HTTP input: a type they reject
+        // cannot be carried as a query string, headers, a path segment, or a
+        // form, so the SDK would send garbage and the document would lie.
+        const rule: keyof IOperationMetadata.IHttpRules | null = httpRuleOf(p);
+        if (rule !== null && schema !== null)
+          pErrorContents.push(...(schema.http?.[rule] ?? []));
+
         if (pErrorContents.length) return report();
         else if (
           matched === undefined ||
@@ -150,6 +158,7 @@ export namespace ReflectHttpOperationParameterAnalyzer {
           schema === null
         )
           return null; // unreachable
+        const { http: _http, ...shape } = schema;
 
         const example: SwaggerExample.IData<any> | undefined = (
           Reflect.getMetadata(
@@ -167,12 +176,11 @@ export namespace ReflectHttpOperationParameterAnalyzer {
             field: p.field!,
             name: matched.name,
             type: matched.type,
-            validate: HttpParameterProgrammer.validate,
             description: matched.description,
             jsDocTags: matched.jsDocTags,
             example: example?.example,
-            examples: example?.examples,
-            ...schema,
+            examples: SwaggerExampleAnalyzer.examples(example),
+            ...shape,
           };
         else if (p.category === "query")
           return {
@@ -181,14 +189,11 @@ export namespace ReflectHttpOperationParameterAnalyzer {
             field: p.field ?? null,
             name: matched.name,
             type: matched.type,
-            validate: p.field
-              ? HttpQueryValidator.validate
-              : HttpQueryProgrammer.validate,
             description: matched.description,
             jsDocTags: matched.jsDocTags,
             example: example?.example,
-            examples: example?.examples,
-            ...schema,
+            examples: SwaggerExampleAnalyzer.examples(example),
+            ...shape,
           };
         else if (p.category === "headers")
           return {
@@ -197,14 +202,11 @@ export namespace ReflectHttpOperationParameterAnalyzer {
             field: p.field ?? null,
             name: matched.name,
             type: matched.type,
-            validate: p.field
-              ? HttpHeadersValidator.validate
-              : HttpHeadersProgrammer.validate,
             description: matched.description,
             jsDocTags: matched.jsDocTags,
             example: example?.example,
-            examples: example?.examples,
-            ...schema,
+            examples: SwaggerExampleAnalyzer.examples(example),
+            ...shape,
           };
         else if (p.category === "body")
           return {
@@ -217,16 +219,14 @@ export namespace ReflectHttpOperationParameterAnalyzer {
             validate:
               p.contentType === "application/json" || p.encrypted === true
                 ? JsonMetadataFactory.validate
-                : p.contentType === "application/x-www-form-urlencoded"
-                  ? HttpQueryProgrammer.validate
-                  : p.contentType === "multipart/form-data"
-                    ? HttpFormDataProgrammer.validate
-                    : TextPlainValidator.validate,
+                : p.contentType === "text/plain"
+                  ? TextPlainValidator.validate
+                  : undefined,
             description: matched.description,
             jsDocTags: matched.jsDocTags,
             example: example?.example,
-            examples: example?.examples,
-            ...schema,
+            examples: SwaggerExampleAnalyzer.examples(example),
+            ...shape,
           };
         else {
           pErrorContents.push(`Unknown kind of the parameter.`);
@@ -234,11 +234,93 @@ export namespace ReflectHttpOperationParameterAnalyzer {
         }
       })
       .filter((x): x is IReflectHttpOperationParameter => x !== null);
+    // a destructured parameter declares no name, so it is given one
+    const parameters: IReflectHttpOperationParameter[] =
+      ParameterNameAnalyzer.name(declared);
 
+    const duplicated: string[] = findDuplicatedKeys(parameters);
+    if (duplicated.length)
+      errors.push({
+        file: ctx.controller.file,
+        class: ctx.controller.class.name,
+        function: ctx.functionName,
+        from: "",
+        contents: duplicated,
+      });
     if (errors.length) ctx.errors.push(...errors);
     return parameters;
   };
 
+  /**
+   * The HTTP input rules a parameter's type must satisfy, or `null` for a JSON
+   * or text body, whose policies are checked on the TypeScript side.
+   *
+   * The rules are typia's, baked per parameter by the SDK transform (see
+   * `nestiaSDKHttpRules`), because only this analyzer knows the decorator. A
+   * typed decorator was already held to them by the core transform, so the
+   * verdict is only news for a vanilla `@Query()`, `@Headers()`, or `@Param()`,
+   * which no transform touches.
+   */
+  const httpRuleOf = (
+    p: IReflectHttpOperationParameter.IPreconfigured,
+  ): keyof IOperationMetadata.IHttpRules | null => {
+    if (p.category === "param") return "param";
+    else if (p.category === "query")
+      return p.field !== undefined ? "field" : "query";
+    else if (p.category === "headers")
+      return p.field !== undefined ? "field" : "headers";
+    else if (p.contentType === "application/x-www-form-urlencoded")
+      return "query";
+    else if (p.contentType === "multipart/form-data") return "formData";
+    return null;
+  };
+
+  /**
+   * Reports a query key or header both a field parameter and the object
+   * parameter of its category declare.
+   *
+   * On the wire they are one key: NestJS hands both parameters the same
+   * `req.query.keyword`, and header names match case-insensitively, as NestJS
+   * lowercases the name a `@Headers("X-Tenant")` reads. Documenting both lists
+   * one `name` + `in` pair twice, which OpenAPI forbids, and the SDK would ask
+   * its caller for the same key twice and send one of the two values. Like two
+   * field parameters of the same name, the declaration is contradictory.
+   */
+  const findDuplicatedKeys = (
+    parameters: IReflectHttpOperationParameter[],
+  ): string[] => {
+    const messages: string[] = [];
+    for (const [category, normalize, noun] of [
+      ["query", (key: string) => key, "Query key"],
+      ["headers", (key: string) => key.toLowerCase(), "Header"],
+    ] as const) {
+      const fields: Map<string, string> = new Map();
+      for (const p of parameters)
+        if (p.category === category && p.field !== null)
+          fields.set(normalize(p.field), p.field);
+      for (const p of parameters) {
+        if (p.category !== category || p.field !== null) continue;
+        for (const key of objectKeys(p)) {
+          const field: string | undefined = fields.get(normalize(key));
+          if (field !== undefined)
+            messages.push(
+              `${noun} ${JSON.stringify(field)} is declared both by a field parameter and by the ${category} object.`,
+            );
+        }
+      }
+    }
+    return messages;
+  };
+
+  /** Literal property keys of an object parameter's object type. */
+  const objectKeys = (p: IReflectHttpOperationParameter): string[] => {
+    const name: string | undefined = p.metadata.objects[0]?.name;
+    const object = p.components.objects.find((o) => o.name === name);
+    return (object?.properties ?? [])
+      .map((property) => property.key.constants[0]?.values[0]?.value)
+      .filter((key): key is string => typeof key === "string");
+  };
+
   const analyzePreconfigured = (
     props: IContext,
   ): IReflectHttpOperationParameter.IPreconfigured[] => {
@@ -263,9 +345,10 @@ export namespace ReflectHttpOperationParameterAnalyzer {
     const symbol: string = key.split(":")[0]!;
     if (symbol.indexOf("__custom") !== -1) return analyzeCustomParameter(param);
 
+    // the whole number: `RAW_BODY` is 12, which the first digit misread as 1
     const category:
       | IReflectHttpOperationParameter.IPreconfigured["category"]
-      | null = getNestParamType(Number(symbol[0]) as RouteParamtypes);
+      | null = getNestParamType(Number(symbol) as RouteParamtypes);
     if (category === null) return null;
     if (category === "body")
       return {

package/src/analyses/ReflectHttpOperationResponseAnalyzer.ts

@@ -5,17 +5,14 @@ import {
   INTERCEPTORS_METADATA,
 } from "@nestjs/common/constants";
 
-import {
-  HttpQueryProgrammer,
-  JsonMetadataFactory,
-  sizeOf,
-} from "../internal/legacy";
+import { JsonMetadataFactory, sizeOf } from "../internal/legacy";
 import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
 import { HttpResponseContentTypeUtil } from "../utils/HttpResponseContentTypeUtil";
 import { TextPlainValidator } from "../validators/TextPlainValidator";
+import { SwaggerExampleAnalyzer } from "./SwaggerExampleAnalyzer";
 
 export namespace ReflectHttpOperationResponseAnalyzer {
   export interface IContext {
@@ -102,7 +99,9 @@ export namespace ReflectHttpOperationResponseAnalyzer {
           : contentType === "application/json" || encrypted === true
             ? JsonMetadataFactory.validate
             : contentType === "application/x-www-form-urlencoded"
-              ? HttpQueryProgrammer.validate
+              ? // a typed query response, held to typia's query rules by the
+                // core transform
+                undefined
               : contentType === "text/plain"
                 ? TextPlainValidator.validate
                 : (next) =>
@@ -110,7 +109,7 @@ export namespace ReflectHttpOperationResponseAnalyzer {
                       ? ["HEAD method must not have any return value."]
                       : [],
       example: example?.example,
-      examples: example?.examples,
+      examples: SwaggerExampleAnalyzer.examples(example),
     };
   };
 

package/src/analyses/ReflectMcpOperationAnalyzer.ts

@@ -7,6 +7,7 @@ import { IReflectImport } from "../structures/IReflectImport";
 import { IReflectMcpOperation } from "../structures/IReflectMcpOperation";
 import { IReflectMcpOperationParameter } from "../structures/IReflectMcpOperationParameter";
 import { ImportAnalyzer } from "./ImportAnalyzer";
+import { ParameterNameAnalyzer } from "./ParameterNameAnalyzer";
 
 export namespace ReflectMcpOperationAnalyzer {
   export interface IProps {
@@ -60,7 +61,7 @@ export namespace ReflectMcpOperationAnalyzer {
       );
 
     const imports: IReflectImport[] = [];
-    const parameters: IReflectMcpOperationParameter[] = preconfigured
+    const declared: IReflectMcpOperationParameter[] = preconfigured
       .map((p) => {
         const matched: IOperationMetadata.IParameter | undefined =
           ctx.metadata.parameters.find(
@@ -74,7 +75,7 @@ export namespace ReflectMcpOperationAnalyzer {
         }
         if (matched.type === null) {
           errors.push(
-            `Failed to analyze the parameter type of ${JSON.stringify(matched.name)}.`,
+            `Failed to analyze the parameter type of ${matched.name ? JSON.stringify(matched.name) : `the ${p.index} (th) argument`}.`,
           );
           return null;
         }
@@ -90,6 +91,9 @@ export namespace ReflectMcpOperationAnalyzer {
         };
       })
       .filter((p): p is IReflectMcpOperationParameter => !!p);
+    // a destructured parameter declares no name, so it is given one
+    const parameters: IReflectMcpOperationParameter[] =
+      ParameterNameAnalyzer.name(declared);
 
     if (ctx.metadata.success?.imports?.length)
       imports.push(...ctx.metadata.success.imports);

package/src/analyses/ReflectWebSocketOperationAnalyzer.ts

@@ -8,6 +8,7 @@ import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOpera
 import { IReflectWebSocketOperationParameter } from "../structures/IReflectWebSocketOperationParameter";
 import { StringUtil } from "../utils/StringUtil";
 import { ImportAnalyzer } from "./ImportAnalyzer";
+import { ParameterNameAnalyzer } from "./ParameterNameAnalyzer";
 import { PathAnalyzer } from "./PathAnalyzer";
 import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
 
@@ -51,7 +52,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
       );
 
     const imports: IReflectImport[] = [];
-    const parameters: IReflectWebSocketOperationParameter[] = preconfigured
+    const declared: IReflectWebSocketOperationParameter[] = preconfigured
       .map((p) => {
         const reject = (message: string): null => {
           errors.push(message);
@@ -69,7 +70,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
           );
         else if (matched.type === null)
           return reject(
-            `Failed to analyze the parameter type of the ${JSON.stringify(matched.name)}.`,
+            `Failed to analyze the parameter type of the ${matched.name ? JSON.stringify(matched.name) : `${p.index} th parameter`}.`,
           );
         else if (
           p.category === "param" &&
@@ -133,6 +134,9 @@ export namespace ReflectWebSocketOperationAnalyzer {
         }
       })
       .filter((p): p is IReflectWebSocketOperationParameter => !!p);
+    // a destructured parameter declares no name, so it is given one
+    const parameters: IReflectWebSocketOperationParameter[] =
+      ParameterNameAnalyzer.name(declared);
 
     const fields: string[] = preconfigured
       .filter((p) => p.category === "param")
@@ -142,7 +146,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
     for (const cLoc of ctx.controller.paths)
       for (const mLoc of route.paths) {
         const location: string = PathAnalyzer.join(cLoc, mLoc);
-        if (location.includes("*")) continue;
+        if (PathAnalyzer.wildcard(location)) continue;
 
         const binded: string[] | null = PathAnalyzer.parameters(location);
         if (binded === null)

package/src/analyses/SecurityAnalyzer.ts

@@ -1,25 +1,35 @@
-import { MapUtil } from "../utils/MapUtil";
-
 export namespace SecurityAnalyzer {
-  export const merge = (...entire: Record<string, string[]>[]) => {
-    const dict: Map<string | typeof none, Set<string>> = new Map();
-    for (const obj of entire) {
-      const entries = Object.entries(obj);
-      for (const [key, value] of entries) {
-        const set = MapUtil.take(dict, key, () => new Set());
-        for (const val of value) set.add(val);
-      }
-      if (entries.length === 0) MapUtil.take(dict, none, () => new Set());
-    }
+  /**
+   * Joins lists of security requirements into one, as OpenAPI reads them.
+   *
+   * Each requirement is an alternative, any one of which suffices, and every
+   * scheme of one requirement must hold, so each is kept as declared. Merging
+   * them by scheme name turned `{ a, b }` (both) into `a` or `b`, and the
+   * `read` or `write` scope alternatives of one scheme into both scopes. Only a
+   * requirement repeating an earlier one, such as a controller's restated on
+   * its method, is dropped; an empty one, anonymous access, is kept.
+   */
+  export const merge = (
+    ...entire: Record<string, string[]>[]
+  ): Record<string, string[]>[] => {
     const output: Record<string, string[]>[] = [];
-    for (const [key, set] of dict)
-      key === none
-        ? output.push({})
-        : output.push({
-            [key]: [...set],
-          });
+    const visited: Set<string> = new Set();
+    for (const requirement of entire) {
+      const normalized: Record<string, string[]> = Object.fromEntries(
+        Object.entries(requirement).map(([name, scopes]) => [
+          name,
+          [...new Set(scopes)],
+        ]),
+      );
+      const key: string = JSON.stringify(
+        Object.entries(normalized)
+          .map(([name, scopes]) => [name, [...scopes].sort()] as const)
+          .sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0)),
+      );
+      if (visited.has(key)) continue;
+      visited.add(key);
+      output.push(normalized);
+    }
     return output;
   };
-
-  const none = Symbol("none");
 }

package/src/analyses/SwaggerExampleAnalyzer.ts

@@ -0,0 +1,23 @@
+import { SwaggerExample } from "@nestia/core";
+import { OpenApi } from "@typia/interface";
+
+export namespace SwaggerExampleAnalyzer {
+  /**
+   * The named examples `@SwaggerExample` attached, as the Example Objects an
+   * OpenAPI `examples` map holds.
+   *
+   * The decorator stores each named example as its value, and documents used to
+   * carry the value itself. OpenAPI 3.x names examples with Example Objects,
+   * whose `value` holds the value, so a tool read the raw value as an Example
+   * Object and found no example in it (#1649). `@TypedException()` examples are
+   * declared as Example Objects already.
+   */
+  export const examples = (
+    data: SwaggerExample.IData<any> | undefined,
+  ): Record<string, OpenApi.IExample> | undefined =>
+    data?.examples === undefined
+      ? undefined
+      : Object.fromEntries(
+          Object.entries(data.examples).map(([key, value]) => [key, { value }]),
+        );
+}

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -54,7 +54,7 @@ export namespace TypedHttpRouteAnalyzer {
       next: {
         metadata: IMetadataSchema;
         components: IMetadataComponents;
-        validate: MetadataFactory.Validator;
+        validate?: MetadataFactory.Validator;
       },
       from: string,
       escape: boolean,
@@ -66,16 +66,19 @@ export namespace TypedHttpRouteAnalyzer {
         next.metadata,
         components.dictionary,
       );
-      const metaErrors: MetadataFactory.IError[] = MetadataFactory.validate({
-        options: {
-          escape,
-          constant: true,
-          absorb: true,
-          validate: next.validate, // @todo -> CHECK IN TYPIA
-        },
-        functor: next.validate, // @todo -> CHECK IN TYPIA
-        metadata,
-      });
+      const metaErrors: MetadataFactory.IError[] =
+        next.validate === undefined
+          ? []
+          : MetadataFactory.validate({
+              options: {
+                escape,
+                constant: true,
+                absorb: true,
+                validate: next.validate,
+              },
+              functor: next.validate,
+              metadata,
+            });
       if (metaErrors.length)
         errors.push({
           file: props.controller.file,
@@ -137,18 +140,23 @@ export namespace TypedHttpRouteAnalyzer {
             t.text[0]!.text &&
             (t.name === "setHeader" || t.name === "assignHeaders"),
         )
-        .map((t) =>
-          t.name === "setHeader"
+        .map((t) => {
+          // the words of the first line; the next lines only describe
+          const words: string[] = t
+            .text![0]!.text.split("\n")[0]!
+            .trim()
+            .split(/\s+/);
+          return t.name === "setHeader"
             ? {
-                type: "setter",
-                source: t.text![0]!.text.split(" ")[0]!.trim(),
-                target: t.text![0]!.text.split(" ")[1]?.trim(),
+                type: "setter" as const,
+                source: words[0]!,
+                target: words[1],
               }
             : {
-                type: "assigner",
-                source: t.text![0]!.text,
-              },
-        ),
+                type: "assigner" as const,
+                source: words[0]!,
+              };
+        }),
     };
     if (errors.length) {
       props.errors.push(...errors);
@@ -159,6 +167,7 @@ export namespace TypedHttpRouteAnalyzer {
         ({
           ...props.operation,
           controller: props.controller,
+          key: props.operation.name,
           path,
           accessor: [...PathUtil.accessors(path), props.operation.name],
           exceptions,

package/src/analyses/TypedWebSocketRouteAnalyzer.ts

@@ -12,6 +12,7 @@ export namespace TypedWebSocketRouteAnalyzer {
     props.paths.map((path) => ({
       ...props.operation,
       controller: props.controller,
+      key: props.operation.name,
       path,
       accessor: [...PathUtil.accessors(path), props.operation.name],
       header:

package/src/executable/internal/NestiaSdkWatcher.ts

@@ -1,8 +1,8 @@
 import fs from "fs";
-import { glob } from "glob";
 import path from "path";
 
 import { INestiaConfig } from "../../INestiaConfig";
+import { SourceFinder } from "../../utils/SourceFinder";
 
 export namespace NestiaSdkWatcher {
   export interface IProps {
@@ -202,7 +202,7 @@ const patternTargets = async (pattern: string): Promise<string[]> => {
   if (hasGlobMagic(pattern)) {
     const root: string = staticRoot(pattern);
     if (fs.existsSync(root)) output.add(root);
-    for (const match of await glob(pattern)) output.add(path.resolve(match));
+    for (const match of await SourceFinder.expand(pattern)) output.add(match);
   }
   return [...output];
 };

package/src/executable/sdk.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import cp from "child_process";
 import fs from "fs";
+import path from "path";
 import process from "process";
 
 import { CommandParser } from "./internal/CommandParser";
@@ -31,13 +32,35 @@ function dependencies(argv: string[]): void {
   const module = options.manager ?? options.module ?? "npm";
   const prefix: string = module === "yarn" ? "yarn add" : `${module} install`;
 
-  for (const lib of ["@nestia/e2e", "@nestia/fetcher", "typia"]) {
+  // typia is the release the Nestia transform links, saved exactly: its latest
+  // may be another, which @nestia/core refuses
+  for (const lib of [
+    "@nestia/e2e",
+    "@nestia/fetcher",
+    `typia@${linkedTypiaVersion()} -E`,
+  ]) {
     const command: string = `${prefix} ${lib}`;
     console.log(`\n$ ${command}`);
     cp.execSync(command, { stdio: "inherit" });
   }
 }
 
+/**
+ * The typia release the Nestia transform links: the one `@nestia/core`
+ * resolves, which its exact dependency holds at that release.
+ */
+function linkedTypiaVersion(): string {
+  const core: string = path.dirname(
+    require.resolve("@nestia/core/package.json"),
+  );
+  return JSON.parse(
+    fs.readFileSync(
+      require.resolve("typia/package.json", { paths: [core] }),
+      "utf8",
+    ),
+  ).version;
+}
+
 async function initialize(): Promise<void> {
   if (fs.existsSync("nestia.config.ts") === true)
     halt(

package/src/factories/ExpressionFactory.ts

@@ -9,6 +9,9 @@ import {
  * Numeric-literal helper that handles negative values via a leading
  * `MinusToken` prefix unary, matching how the TypeScript factory itself emits
  * negative numeric literals.
+ *
+ * Infinity is written `1e999`, the literal that evaluates to it and the only
+ * spelling that is also a literal type; `Infinity` names a value, not a type.
  */
 export namespace ExpressionFactory {
   export const number = (
@@ -17,7 +20,10 @@ export namespace ExpressionFactory {
     value < 0
       ? factory.createPrefixUnaryExpression(
           SyntaxKind.MinusToken,
-          factory.createNumericLiteral(Math.abs(value)),
+          literal(-value),
         )
-      : factory.createNumericLiteral(value);
+      : literal(value);
+
+  const literal = (value: number): NumericLiteral =>
+    factory.createNumericLiteral(value === Infinity ? "1e999" : value);
 }