@nestia/migrate 13.0.4 → 14.0.1

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;
+}

package/src/utils/SuccessStatus.ts

@@ -0,0 +1,29 @@
+import { IHttpMigrateRoute } from "@typia/interface";
+
+export namespace SuccessStatus {
+  /**
+   * The route's success status code, or null when the document declares only a
+   * range (`2XX`) or a `default` response.
+   *
+   * The success response is the one typia's route composer selects: 200, then
+   * 201, then the lowest other 2xx. A bodiless one, such as a 204 No Content,
+   * leaves `route.success` null, so its status is read from the responses.
+   */
+  export const of = (route: IHttpMigrateRoute): number | null => {
+    const status: string | undefined =
+      route.success?.status ??
+      Object.keys(route.operation().responses ?? {})
+        .filter((key) => /^2\d\d$/.test(key))
+        .sort((x, y) => priority(x) - priority(y))[0];
+    return status !== undefined && /^\d{3}$/.test(status)
+      ? Number(status)
+      : null;
+  };
+
+  /** The status NestJS answers without `@HttpCode()`. */
+  export const nest = (route: IHttpMigrateRoute): number =>
+    route.method === "post" ? 201 : 200;
+
+  const priority = (status: string): number =>
+    status === "200" ? 0 : status === "201" ? 1 : Number(status);
+}