@nestia/migrate 14.0.0 → 14.0.1

package/src/executable/NestiaMigrateCommander.ts

@@ -76,8 +76,14 @@ export namespace NestiaMigrateCommander {
         );
     await NestiaMigrateFileArchiver.archive({
       mkdir: fs.promises.mkdir,
+      // only TypeScript is formatted: prettier's TypeScript parser also
+      // accepts a `.gitignore` or `.env` line, and rewrites it into code
       writeFile: async (file, content) =>
-        fs.promises.writeFile(file, await beautify(content), "utf-8"),
+        fs.promises.writeFile(
+          file,
+          /\.[cm]?tsx?$/.test(file) ? await beautify(content) : content,
+          "utf-8",
+        ),
       root: options.output,
       files,
     });

package/src/executable/NestiaMigrateInquirer.ts

@@ -74,32 +74,18 @@ export namespace NestiaMigrateInquirer {
       partial.input ??= await input("input")("Swagger file location");
       partial.output ??= await input("output")("Response directory path");
       partial.package ??= await input("package")("Package name");
-      partial.keyword ??=
-        (await select("keyword")("Keyword parameter mode")([
-          "true",
-          "false",
-        ])) === "true";
-
-      if (partial.keyword)
-        partial.keyword = (partial.keyword as any) === "true";
-      else
-        partial.keyword =
-          (await select("keyword")("Keyword parameter mode")([
-            "true",
-            "false",
-          ])) === "true";
-      if (partial.simulate)
-        partial.simulate = (partial.simulate as any) === "true";
-      else
-        partial.simulate =
-          (await select("simulate")("Mokup Simulator")(["true", "false"])) ===
-          "true";
-
-      if (partial.e2e) partial.e2e = (partial.e2e as any) === "true";
-      else
-        partial.e2e =
-          (await select("e2e")("Generate E2E tests")(["true", "false"])) ===
-          "true";
+      // a flag given alone is `true`, and one given a value is its text
+      const flag = (value: unknown): boolean | undefined =>
+        value === undefined ? undefined : value === true || value === "true";
+      const ask = async (name: string, message: string): Promise<boolean> =>
+        (await select(name)(message)(["true", "false"])) === "true";
+      partial.keyword =
+        flag(partial.keyword) ??
+        (await ask("keyword", "Keyword parameter mode"));
+      partial.simulate =
+        flag(partial.simulate) ?? (await ask("simulate", "Mokup Simulator"));
+      partial.e2e =
+        flag(partial.e2e) ?? (await ask("e2e", "Generate E2E tests"));
       return partial as IOutput;
     });
   };

package/src/programmers/NestiaMigrateApiFunctionProgrammer.ts

@@ -7,6 +7,8 @@ import { StatementFactory } from "../factories/StatementFactory";
 import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
+import { RequestBody } from "../utils/RequestBody";
+import { SuccessStatus } from "../utils/SuccessStatus";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
 import { NestiaMigrateSchemaProgrammer } from "./NestiaMigrateSchemaProgrammer";
 
@@ -110,9 +112,7 @@ export namespace NestiaMigrateApiFunctionProgrammer {
               factory.createTypeReferenceNode(
                 `${ctx.route.accessor.at(-1)!}.Body`,
               ),
-              (ctx.route.body.type === "application/json" ||
-                ctx.route.body.type === "text/plain") &&
-                ctx.route.operation().requestBody?.required === false
+              RequestBody.optional(ctx.route)
                 ? factory.createToken(SyntaxKind.QuestionToken)
                 : undefined,
             ),
@@ -208,9 +208,15 @@ export namespace NestiaMigrateApiFunctionProgrammer {
                     getArguments(ctx, false),
                   ),
                 ),
+                // the fetcher reads only 200, 201, and this status as success
                 factory.createPropertyAssignment(
                   "status",
-                  factory.createNull(),
+                  ((status) =>
+                    status === null
+                      ? factory.createNull()
+                      : factory.createNumericLiteral(status))(
+                    SuccessStatus.of(ctx.route),
+                  ),
                 ),
               ],
               true,

package/src/programmers/NestiaMigrateApiNamespaceProgrammer.ts

@@ -9,6 +9,8 @@ import { TypeFactory } from "../factories/TypeFactory";
 import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
+import { PathTemplate } from "../utils/PathTemplate";
+import { RequestBody } from "../utils/RequestBody";
 import { NestiaMigrateApiSimulationProgrammer } from "./NestiaMigrateApiSimulationProgrammer";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
 import { NestiaMigrateSchemaProgrammer } from "./NestiaMigrateSchemaProgrammer";
@@ -116,7 +118,9 @@ export namespace NestiaMigrateApiNamespaceProgrammer {
             required: [
               ...ctx.route.parameters.map((p) => p.key),
               ...(ctx.route.query ? [ctx.route.query.key] : []),
-              ...(ctx.route.body ? [ctx.route.body.key] : []),
+              ...(ctx.route.body && RequestBody.optional(ctx.route) === false
+                ? [ctx.route.body.key]
+                : []),
             ],
           },
         }),
@@ -280,32 +284,49 @@ export namespace NestiaMigrateApiNamespaceProgrammer {
         ),
       );
     const template = () => {
-      const path: string = getPath(ctx.route);
-      const split: string[] = path.split(":");
-      if (split.length === 1) return factory.createStringLiteral(path);
+      // the document's template delimits each parameter; the emended path's
+      // `:id.json` would not tell the name from the literal after it
+      const segments: PathTemplate.ISegment[] = PathTemplate.segments(
+        ctx.route,
+      );
+      if (segments.every((segment) => segment.type === "literal"))
+        return factory.createStringLiteral(getPath(ctx.route));
+      const literals: string[] = [""];
+      const parameters: IHttpMigrateRoute.IParameter[] = [];
+      for (const segment of segments)
+        if (segment.type === "literal")
+          literals[literals.length - 1] += segment.value;
+        else {
+          parameters.push(segment.parameter);
+          literals.push("");
+        }
       return factory.createTemplateExpression(
-        factory.createTemplateHead(split[0]!),
-        split.slice(1).map((s, i, arr) => {
-          const name: string = s.split("/")[0]!;
-          return factory.createTemplateSpan(
+        factory.createTemplateHead(literals[0]!),
+        parameters.map((parameter, i) =>
+          factory.createTemplateSpan(
+            // URI-encoded, "null" when nullish, and a dot segment refused
             factory.createCallExpression(
-              factory.createIdentifier("encodeURIComponent"),
+              IdentifierFactory.access(
+                factory.createIdentifier(
+                  ctx.importer.external({
+                    type: "instance",
+                    library: "@nestia/fetcher",
+                    name: "PathParameter",
+                  }),
+                ),
+                "encode",
+              ),
               undefined,
               [
-                factory.createBinaryExpression(
-                  property(
-                    ctx.route.parameters.find((p) => p.name === name)!.key,
-                  ),
-                  factory.createToken(SyntaxKind.QuestionQuestionToken),
-                  factory.createStringLiteral("null"),
-                ),
+                factory.createStringLiteral(parameter.key),
+                property(parameter.key),
               ],
             ),
-            (i !== arr.length - 1
+            (i !== parameters.length - 1
               ? factory.createTemplateMiddle
-              : factory.createTemplateTail)(s.substring(name.length)),
-          );
-        }),
+              : factory.createTemplateTail)(literals[i + 1]!),
+          ),
+        ),
       );
     };
     if (!ctx.route.query) return out(template());

package/src/programmers/NestiaMigrateApiSimulationProgrammer.ts

@@ -70,7 +70,8 @@ export namespace NestiaMigrateApiSimulationProgrammer {
           ctx,
           ctx.route.parameters.length === 0 &&
             ctx.route.query === null &&
-            ctx.route.body === null
+            ctx.route.body === null &&
+            ctx.route.headers === null
             ? "_connection"
             : undefined,
         ),
@@ -127,6 +128,20 @@ export namespace NestiaMigrateApiSimulationProgrammer {
             },
           ]
         : []),
+      // the headers travel in the connection, validated as the server does
+      ...(ctx.route.headers
+        ? [
+            {
+              category: "headers",
+              name: ctx.route.headers.key,
+              schema: NestiaMigrateSchemaProgrammer.write({
+                components: ctx.components,
+                importer: ctx.importer,
+                schema: ctx.route.headers.schema,
+              }),
+            },
+          ]
+        : []),
     ];
     if (parameters.length === 0) return [];
 
@@ -206,7 +221,9 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                   ),
                   "assert",
                 ),
-                undefined,
+                // `connection.headers` is typed optional with optional
+                // members, so the headers name their own type to be checked
+                p.category === "headers" ? [p.schema] : undefined,
                 [
                   p.category === "headers"
                     ? factory.createIdentifier("connection.headers")
@@ -218,78 +235,11 @@ export namespace NestiaMigrateApiSimulationProgrammer {
         ),
       )
       .map(factory.createExpressionStatement) as ts.Statement[];
-    return [validator, tryAndCatch(ctx.importer, individual)];
+    // the SDK fetches without propagation, so an invalid simulated request
+    // throws its HttpError as the real one does, instead of answering a
+    // propagation object in place of the response
+    return [validator, ...individual];
   };
-
-  const tryAndCatch = (
-    importer: NestiaMigrateImportProgrammer,
-    individual: ts.Statement[],
-  ) =>
-    factory.createTryStatement(
-      factory.createBlock(individual, true),
-      factory.createCatchClause(
-        "exp",
-        factory.createBlock(
-          [
-            factory.createIfStatement(
-              factory.createLogicalNot(
-                factory.createCallExpression(
-                  IdentifierFactory.access(
-                    factory.createIdentifier(
-                      importer.external({
-                        type: "default",
-                        library: "typia",
-                        name: "typia",
-                      }),
-                    ),
-                    "is",
-                  ),
-                  [
-                    factory.createTypeReferenceNode(
-                      importer.external({
-                        type: "instance",
-                        library: "@nestia/fetcher",
-                        name: "HttpError",
-                      }),
-                    ),
-                  ],
-                  [factory.createIdentifier("exp")],
-                ),
-              ),
-              factory.createThrowStatement(factory.createIdentifier("exp")),
-            ),
-            factory.createReturnStatement(
-              factory.createAsExpression(
-                factory.createObjectLiteralExpression(
-                  [
-                    factory.createPropertyAssignment(
-                      "success",
-                      factory.createFalse(),
-                    ),
-                    factory.createPropertyAssignment(
-                      "status",
-                      factory.createIdentifier("exp.status"),
-                    ),
-                    factory.createPropertyAssignment(
-                      "headers",
-                      factory.createIdentifier("exp.headers"),
-                    ),
-                    factory.createPropertyAssignment(
-                      "data",
-                      factory.createIdentifier("exp.toJSON().message"),
-                    ),
-                  ],
-                  true,
-                ),
-                TypeFactory.keyword("any"),
-              ),
-            ),
-          ],
-          true,
-        ),
-      ),
-      undefined,
-    );
 }
 
 const constant = (name: string, expression: ts.Expression) =>

package/src/programmers/NestiaMigrateE2eFileProgrammer.ts

@@ -91,14 +91,6 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       factory.createIdentifier("api.functional"),
       factory.createIdentifier(ctx.route.accessor.join(".")),
     );
-    const connection = factory.createIdentifier("connection");
-    if (
-      ctx.route.parameters.length === 0 &&
-      ctx.route.query === null &&
-      ctx.route.body === null
-    )
-      return factory.createCallExpression(fetch, undefined, [connection]);
-
     const random = factory.createPropertyAccessExpression(
       factory.createIdentifier(
         ctx.importer.external({
@@ -109,6 +101,47 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       ),
       "random",
     );
+    // the route's headers travel in the connection, as the server requires
+    const connection: ts.Expression = ctx.route.headers
+      ? factory.createObjectLiteralExpression(
+          [
+            factory.createSpreadAssignment(
+              factory.createIdentifier("connection"),
+            ),
+            factory.createPropertyAssignment(
+              "headers",
+              factory.createObjectLiteralExpression(
+                [
+                  factory.createSpreadAssignment(
+                    factory.createIdentifier("connection.headers"),
+                  ),
+                  factory.createSpreadAssignment(
+                    factory.createCallExpression(
+                      random,
+                      [
+                        NestiaMigrateSchemaProgrammer.write({
+                          components: ctx.components,
+                          importer: ctx.importer,
+                          schema: ctx.route.headers.schema,
+                        }),
+                      ],
+                      undefined,
+                    ),
+                  ),
+                ],
+                true,
+              ),
+            ),
+          ],
+          true,
+        )
+      : factory.createIdentifier("connection");
+    if (
+      ctx.route.parameters.length === 0 &&
+      ctx.route.query === null &&
+      ctx.route.body === null
+    )
+      return factory.createCallExpression(fetch, undefined, [connection]);
     if (ctx.config.keyword === true)
       return factory.createCallExpression(fetch, undefined, [
         connection,

package/src/programmers/NestiaMigrateNestMethodProgrammer.ts

@@ -2,6 +2,7 @@ import { SyntaxKind, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
 import { OpenApi } from "typia";
 
+import { NestiaMigrateControllerAnalyzer } from "../analyzers/NestiaMigrateControllerAnalyzer";
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { LiteralFactory } from "../factories/LiteralFactory";
@@ -10,7 +11,9 @@ import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
+import { RequestBody } from "../utils/RequestBody";
 import { StringUtil } from "../utils/StringUtil";
+import { SuccessStatus } from "../utils/SuccessStatus";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
 import { NestiaMigrateSchemaProgrammer } from "./NestiaMigrateSchemaProgrammer";
 
@@ -121,7 +124,9 @@ export namespace NestiaMigrateNestMethodProgrammer {
       );
 
     // ROUTER
-    const localPath: string = ctx.route.emendedPath
+    const localPath: string = NestiaMigrateControllerAnalyzer.routePath(
+      ctx.route,
+    )
       .slice(ctx.controller.path.length)
       .split("/")
       .filter((str) => !!str.length)
@@ -139,35 +144,43 @@ export namespace NestiaMigrateNestMethodProgrammer {
             : undefined,
         ),
       );
+    // a vanilla NestJS method decorator, relative to the controller like the
+    // nestia ones: the document's full path would be joined onto the
+    // controller's again
+    const nest = (method: string) =>
+      factory.createDecorator(
+        factory.createCallExpression(
+          external("@nestjs/common", method),
+          [],
+          localPath.length
+            ? [factory.createStringLiteral(localPath)]
+            : undefined,
+        ),
+      );
     if (ctx.route.success?.["x-nestia-encrypted"])
       decorators.push(router("EncryptedRoute"));
     else if (ctx.route.success?.type === "text/plain")
-      decorators.push(
-        factory.createDecorator(
-          factory.createCallExpression(
-            external("@nestjs/common", StringUtil.capitalize(ctx.route.method)),
-            [],
-            [factory.createStringLiteral(ctx.route.path)],
-          ),
-        ),
-      );
+      decorators.push(nest(StringUtil.capitalize(ctx.route.method)));
     else if (ctx.route.success?.type === "application/x-www-form-urlencoded")
       decorators.push(router("TypedQuery"));
-    else if (ctx.route.method === "head")
+    else if (ctx.route.method === "head") decorators.push(nest("Head"));
+    else if (
+      ctx.route.success === null ||
+      ctx.route.success?.type === "application/json"
+    )
+      decorators.push(router("TypedRoute"));
+    // NestJS answers 201 for POST and 200 otherwise
+    const status: number | null = SuccessStatus.of(ctx.route);
+    if (status !== null && status !== SuccessStatus.nest(ctx.route))
       decorators.push(
         factory.createDecorator(
           factory.createCallExpression(
-            external("@nestjs/common", "Head"),
-            [],
-            [factory.createStringLiteral(ctx.route.path)],
+            external("@nestjs/common", "HttpCode"),
+            undefined,
+            [ExpressionFactory.number(status)],
           ),
         ),
       );
-    else if (
-      ctx.route.success === null ||
-      ctx.route.success?.type === "application/json"
-    )
-      decorators.push(router("TypedRoute"));
     for (const [key, value] of Object.entries(ctx.route.exceptions ?? {}))
       decorators.push(
         factory.createDecorator(
@@ -291,11 +304,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
                 : [],
           })(ctx.components)(ctx.importer)({
             schema: ctx.route.body.schema,
-            required: !(
-              (ctx.route.body.type === "application/json" ||
-                ctx.route.body.type === "text/plain") &&
-              ctx.route.operation().requestBody?.required === false
-            ),
+            required: RequestBody.optional(ctx.route) === false,
             example: ctx.route.body.media().example,
             examples: ctx.route.body.media().examples,
           }),
@@ -380,8 +389,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
             ),
           ]
         : []),
-      ...Object.entries(media.examples ?? {}).map(([key, value]) =>
-        factory.createDecorator(
+      ...Object.entries(media.examples ?? {}).flatMap(([key, example]) => {
+        const value: { value: unknown } | null = exampleValue(example);
+        if (value === null) return [];
+        return factory.createDecorator(
           factory.createCallExpression(
             IdentifierFactory.access(
               factory.createIdentifier(
@@ -394,9 +405,57 @@ export namespace NestiaMigrateNestMethodProgrammer {
               kind,
             ),
             [],
-            [factory.createStringLiteral(key), LiteralFactory.write(value)],
+            [
+              factory.createStringLiteral(key),
+              LiteralFactory.write(value.value),
+            ],
           ),
-        ),
-      ),
+        );
+      }),
     ];
 }
+
+/**
+ * The value a named example stands for, or `null` when it names none.
+ *
+ * OpenAPI names examples with Example Objects, whose `value` (or, since 3.2,
+ * `dataValue`) holds the value, and a `$ref` to one arrives resolved. Documents
+ * from earlier nestia versions held the values themselves, so an object is read
+ * as an Example Object only when it is one: it has one of the value fields, and
+ * every other key is an Example Object field or an extension. A raw value of
+ * exactly that shape is ambiguous and is read as an Example Object, as a
+ * conforming document means it. An Example Object that only points at its value
+ * (`externalValue`) or only serializes it (`serializedValue`) gives
+ * `SwaggerExample` nothing to hold.
+ */
+const exampleValue = (example: unknown): { value: unknown } | null => {
+  if (isExampleObject(example) === false) return { value: example };
+  const record = example as Record<string, unknown>;
+  if (Object.prototype.hasOwnProperty.call(record, "value"))
+    return { value: record.value };
+  if (Object.prototype.hasOwnProperty.call(record, "dataValue"))
+    return { value: record.dataValue };
+  return null;
+};
+
+const isExampleObject = (example: unknown): boolean =>
+  typeof example === "object" &&
+  example !== null &&
+  Array.isArray(example) === false &&
+  VALUE_KEYS.some((key) =>
+    Object.prototype.hasOwnProperty.call(example, key),
+  ) &&
+  Object.keys(example).every(
+    (key) =>
+      VALUE_KEYS.includes(key) ||
+      key === "summary" ||
+      key === "description" ||
+      key.startsWith("x-"),
+  );
+
+const VALUE_KEYS: string[] = [
+  "value",
+  "dataValue",
+  "serializedValue",
+  "externalValue",
+];

package/src/programmers/NestiaMigrateSchemaProgrammer.ts

@@ -123,12 +123,29 @@ export namespace NestiaMigrateSchemaProgrammer {
     writeNumeric({
       factory: () => [
         TypeFactory.keyword("number"),
-        props.importer.tag("Type", "int32"),
+        props.importer.tag("Type", integerType(props.schema)),
       ],
       importer: props.importer,
       schema: props.schema,
     });
 
+  /**
+   * The typia integer type admitting what the schema admits: its own `format`
+   * when it names one typia has, else `int64`, as an integer schema without a
+   * format admits any integer.
+   */
+  const integerType = (
+    schema: OpenApi.IJsonSchema.IInteger,
+  ): "int32" | "uint32" | "int64" | "uint64" => {
+    const format: unknown = (schema as { format?: unknown }).format;
+    return format === "int32" ||
+      format === "uint32" ||
+      format === "int64" ||
+      format === "uint64"
+      ? format
+      : "int64";
+  };
+
   const writeNumber = (props: {
     importer: NestiaMigrateImportProgrammer;
     schema: OpenApi.IJsonSchema.INumber;
@@ -147,19 +164,19 @@ export namespace NestiaMigrateSchemaProgrammer {
     const intersection: ts.TypeNode[] = props.factory();
     if (props.schema.default !== undefined)
       intersection.push(props.importer.tag("Default", props.schema.default));
+    // the emended schema holds each bound as a number, as OpenAPI 3.1 does;
+    // an OpenAPI 3.0 boolean `exclusiveMinimum` is converted into that form
     if (props.schema.minimum !== undefined)
+      intersection.push(props.importer.tag("Minimum", props.schema.minimum));
+    if (typeof props.schema.exclusiveMinimum === "number")
       intersection.push(
-        props.importer.tag(
-          props.schema.exclusiveMinimum ? "ExclusiveMinimum" : "Minimum",
-          props.schema.minimum,
-        ),
+        props.importer.tag("ExclusiveMinimum", props.schema.exclusiveMinimum),
       );
     if (props.schema.maximum !== undefined)
+      intersection.push(props.importer.tag("Maximum", props.schema.maximum));
+    if (typeof props.schema.exclusiveMaximum === "number")
       intersection.push(
-        props.importer.tag(
-          props.schema.exclusiveMaximum ? "ExclusiveMaximum" : "Maximum",
-          props.schema.maximum,
-        ),
+        props.importer.tag("ExclusiveMaximum", props.schema.exclusiveMaximum),
       );
     if (props.schema.multipleOf !== undefined)
       intersection.push(
@@ -299,7 +316,8 @@ export namespace NestiaMigrateSchemaProgrammer {
           schema: props.schema.additionalProperties as OpenApi.IJsonSchema,
         }),
       ]);
-    return !!props.schema.properties?.length &&
+    // `properties` is a record, which has no length
+    return Object.keys(props.schema.properties ?? {}).length !== 0 &&
       typeof props.schema.additionalProperties === "object"
       ? factory.createIntersectionTypeNode([regular(), dynamic()])
       : typeof props.schema.additionalProperties === "object"

package/src/utils/PathTemplate.ts

@@ -0,0 +1,39 @@
+import { IHttpMigrateRoute } from "@typia/interface";
+
+export namespace PathTemplate {
+  export type ISegment =
+    | { type: "literal"; value: string }
+    | { type: "param"; parameter: IHttpMigrateRoute.IParameter };
+
+  /**
+   * The route's path as literal text and path parameters, in order, read from
+   * the document's own template (`/files/{id}.json`), whose braces delimit each
+   * parameter name. The emended path (`/files/:id.json`) cannot be split back:
+   * its `:id.json` could name `id` or `id.json`, and a name such as `item-id`
+   * would read as `item` followed by `-id`. It always starts with `/`, as the
+   * emended path does.
+   */
+  export const segments = (route: IHttpMigrateRoute): ISegment[] => {
+    const path: string = route.path.startsWith("/")
+      ? route.path
+      : `/${route.path}`;
+    const output: ISegment[] = [];
+    const literal = (value: string): void => {
+      if (value.length === 0) return;
+      const last: ISegment | undefined = output[output.length - 1];
+      if (last?.type === "literal") last.value += value;
+      else output.push({ type: "literal", value });
+    };
+    let cursor: number = 0;
+    for (const match of path.matchAll(/\{([^{}]+)\}/g)) {
+      literal(path.slice(cursor, match.index));
+      cursor = match.index! + match[0].length;
+      const parameter: IHttpMigrateRoute.IParameter | undefined =
+        route.parameters.find((p) => p.name === match[1]);
+      if (parameter === undefined) literal(match[0]);
+      else output.push({ type: "param", parameter });
+    }
+    literal(path.slice(cursor));
+    return output;
+  };
+}

package/src/utils/RequestBody.ts

@@ -0,0 +1,14 @@
+import { IHttpMigrateRoute } from "@typia/interface";
+
+export namespace RequestBody {
+  /**
+   * Whether the route's body may be omitted: a JSON or text body the document
+   * does not require. The SDK's positional and keyword functions and the Nest
+   * controller all read this one rule.
+   */
+  export const optional = (route: IHttpMigrateRoute): boolean =>
+    route.body !== null &&
+    (route.body.type === "application/json" ||
+      route.body.type === "text/plain") &&
+    route.operation().requestBody?.required === false;
+}