@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@nestia/sdk",
-  "version": "11.2.1",
+  "version": "12.0.0-dev.20260521.1",
   "description": "Nestia SDK and Swagger generator",
+  "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "exports": {
     ".": {
@@ -45,37 +46,36 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@typia/core": "12.1.0",
-    "@typia/interface": "12.1.0",
-    "@typia/utils": "12.1.0",
-    "cli": "^1.0.1",
+    "@typia/interface": "13.0.0-dev.20260521.1",
+    "@typia/utils": "13.0.0-dev.20260521.1",
     "get-function-location": "^2.0.0",
     "glob": "^11.0.3",
     "path-to-regexp": "^6.2.1",
     "prettier": "^3.8.1",
-    "ts-node": ">=10.6.0",
-    "tsconfck": "^2.1.2",
-    "tsconfig-paths": "^4.1.1",
+    "ttsc": "^0.12.3",
     "tstl": "^3.0.0",
-    "typia": "12.1.0",
-    "@nestia/core": "^11.2.1",
-    "@nestia/fetcher": "^11.2.1"
+    "typia": "13.0.0-dev.20260521.1",
+    "@nestia/core": "^12.0.0-dev.20260521.1",
+    "@nestia/factory": "^12.0.0-dev.20260521.1",
+    "@nestia/fetcher": "^12.0.0-dev.20260521.1"
   },
   "peerDependencies": {
-    "@nestia/core": "^11.2.1"
+    "@nestia/core": "^12.0.0-dev.20260521.1"
   },
   "devDependencies": {
     "@nestjs/common": "^11.1.6",
     "@nestjs/core": "^11.1.6",
-    "@types/cli": "^0.11.21",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "@types/express": "^4.17.15",
     "@types/node": "^25.3.3",
-    "rimraf": "^6.1.3",
-    "typescript": "~6.0.3"
+    "rimraf": "^6.1.3"
   },
   "files": [
     "assets",
     "lib",
+    "native/go.mod",
+    "native/go.sum",
+    "native/sdk",
     "src",
     "README.md",
     "LICENSE",
@@ -85,8 +85,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc",
-    "dev": "rimraf lib && tsc --watch"
-  },
-  "types": "lib/index.d.ts"
+    "build": "rimraf lib && ttsc",
+    "dev": "ttsc --watch",
+    "test:go": "cd test && go test ./..."
+  }
 }

package/src/NestiaSdkApplication.ts

@@ -1,4 +1,4 @@
-import { IMetadataDictionary } from "@typia/core";
+import { IMetadataDictionary } from "./internal/legacy";
 import fs from "fs";
 import path from "path";
 import { HashSet, Pair, TreeMap } from "tstl";
@@ -19,7 +19,7 @@ import { IReflectOperationError } from "./structures/IReflectOperationError";
 import { ITypedApplication } from "./structures/ITypedApplication";
 import { ITypedHttpRoute } from "./structures/ITypedHttpRoute";
 import { ITypedWebSocketRoute } from "./structures/ITypedWebSocketRoute";
-import { IOperationMetadata } from "./transformers/IOperationMetadata";
+import { IOperationMetadata } from "./structures/IOperationMetadata";
 import { StringUtil } from "./utils/StringUtil";
 import { VersioningStrategy } from "./utils/VersioningStrategy";
 
@@ -135,7 +135,6 @@ export class NestiaSdkApplication {
     const project: INestiaProject = {
       config: this.config,
       input: await ConfigAnalyzer.input(this.config),
-      checker: null!,
       errors: [],
       warnings: [],
     };
@@ -191,7 +190,7 @@ export class NestiaSdkApplication {
     console.log("Analyzing source codes");
 
     // METADATA COMPONENTS
-    const collection: IMetadataDictionary =
+    const sourceCollection: IMetadataDictionary =
       TypedHttpRouteAnalyzer.dictionary(controllers);
 
     // CONVERT TO TYPED OPERATIONS
@@ -216,7 +215,7 @@ export class NestiaSdkApplication {
             ...TypedHttpRouteAnalyzer.analyze({
               controller: c,
               errors: project.errors,
-              dictionary: collection,
+              dictionary: sourceCollection,
               operation: o,
               paths: Array.from(pathList),
             }),
@@ -232,6 +231,11 @@ export class NestiaSdkApplication {
       }
     AccessorAnalyzer.analyze(routes);
 
+    const collection: IMetadataDictionary =
+      TypedHttpRouteAnalyzer.routeDictionary(
+        routes.filter((r): r is ITypedHttpRoute => r.protocol === "http"),
+      );
+
     if (props.validate !== undefined)
       project.errors.push(
         ...props.validate({

package/src/NestiaSwaggerComposer.ts

@@ -1,5 +1,5 @@
 import { INestApplication } from "@nestjs/common";
-import { IMetadataDictionary } from "@typia/core";
+import { IMetadataDictionary } from "./internal/legacy";
 import { OpenApiV3, OpenApiV3_1, SwaggerV2 } from "@typia/interface";
 import { OpenApiConverter } from "@typia/utils";
 import path from "path";
@@ -18,7 +18,7 @@ import { INestiaSdkInput } from "./structures/INestiaSdkInput";
 import { IReflectController } from "./structures/IReflectController";
 import { IReflectOperationError } from "./structures/IReflectOperationError";
 import { ITypedHttpRoute } from "./structures/ITypedHttpRoute";
-import { IOperationMetadata } from "./transformers/IOperationMetadata";
+import { IOperationMetadata } from "./structures/IOperationMetadata";
 import { VersioningStrategy } from "./utils/VersioningStrategy";
 
 export namespace NestiaSwaggerComposer {
@@ -47,7 +47,6 @@ export namespace NestiaSwaggerComposer {
     const unique: WeakSet<any> = new WeakSet();
     const project: Omit<INestiaProject, "config"> = {
       input,
-      checker: null!,
       errors: [],
       warnings: [],
     };

package/src/analyses/ConfigAnalyzer.ts

@@ -14,6 +14,8 @@ import { INestiaSdkInput } from "../structures/INestiaSdkInput";
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { MapUtil } from "../utils/MapUtil";
 import { SourceFinder } from "../utils/SourceFinder";
+import { TsConfigReader } from "../utils/TsConfigReader";
+import { TtscExecutor } from "../utils/TtscExecutor";
 
 export namespace ConfigAnalyzer {
   export const input = async (
@@ -35,9 +37,10 @@ export namespace ConfigAnalyzer {
             : [],
         filter: filter(config),
       });
+      const runtime: RuntimeCompiler = await RuntimeCompiler.compile(sources);
       const controllers: INestiaSdkInput.IController[] = [];
       for (const file of sources) {
-        const external: any[] = await import(file);
+        const external: any[] = await import(runtime.output(file));
         for (const key in external) {
           const instance: Function = external[key];
           if (Reflect.getMetadata("path", instance) !== undefined)
@@ -113,6 +116,177 @@ export namespace ConfigAnalyzer {
   };
 }
 const memory = new Map<INestiaConfig, Promise<INestiaSdkInput>>();
+class RuntimeCompiler {
+  private constructor(
+    private readonly cwd: string,
+    private readonly outDir: string,
+  ) {}
+
+  public static async compile(sources: string[]): Promise<RuntimeCompiler> {
+    const cwd: string = process.cwd();
+    const runtimeRoot: string = path.join(
+      cwd,
+      "node_modules",
+      ".nestia",
+      "runtime",
+    );
+    await fs.promises.mkdir(runtimeRoot, { recursive: true });
+    ensureRuntimeCleanup(runtimeRoot);
+    const outDir: string = await fs.promises.mkdtemp(
+      path.join(runtimeRoot, "run-"),
+    );
+    const project: string = path.join(
+      cwd,
+      `.nestia.runtime.${process.pid}.${Date.now()}.json`,
+    );
+    const relative = (file: string): string =>
+      path.relative(cwd, file).split("\\").join("/");
+    await fs.promises.writeFile(
+      project,
+      JSON.stringify(
+        {
+          extends: normalizeProjectPath(process.env.NESTIA_PROJECT),
+          compilerOptions: {
+            noEmit: false,
+            noUnusedLocals: false,
+            noUnusedParameters: false,
+            outDir,
+            plugins: await runtimePlugins(cwd),
+            rootDir: ".",
+          },
+          include: sources.map(relative),
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+    try {
+      TtscExecutor.run({
+        cwd,
+        project,
+      });
+    } catch (error) {
+      const output =
+        error instanceof Error && "stderr" in error
+          ? String((error as Error & { stderr?: Buffer }).stderr ?? "")
+          : "";
+      throw new Error(output || `Failed to compile Nestia runtime inputs.`);
+    } finally {
+      await fs.promises.rm(project, { force: true });
+    }
+    return new RuntimeCompiler(cwd, outDir);
+  }
+
+  public output(source: string): string {
+    const relative: string = path.relative(this.cwd, source);
+    const emitted: string = path.join(
+      this.outDir,
+      replaceExtension(relative, ".js"),
+    );
+    return emitted;
+  }
+}
+
+const RUNTIME_ROOTS: Set<string> = new Set();
+let RUNTIME_CLEANUP_REGISTERED: boolean = false;
+
+const ensureRuntimeCleanup = (runtimeRoot: string): void => {
+  RUNTIME_ROOTS.add(runtimeRoot);
+  if (RUNTIME_CLEANUP_REGISTERED === true) return;
+  RUNTIME_CLEANUP_REGISTERED = true;
+  const sweep = (): void => {
+    for (const location of RUNTIME_ROOTS)
+      fs.rmSync(location, { force: true, recursive: true });
+  };
+  process.once("exit", sweep);
+  // process.once("exit", …) does not fire on SIGINT/SIGTERM. Without these
+  // handlers a Ctrl-C during codegen leaves `run-*` mkdtemp directories
+  // behind under node_modules/.nestia/runtime/ until a subsequent clean exit.
+  // The module-level RUNTIME_CLEANUP_REGISTERED flag above guards against
+  // re-entrancy within this module; we deliberately do NOT gate on
+  // `process.listenerCount(signal) > 0` because NestiaConfigLoader's parallel
+  // sweep registers first, and that gate would skip our registration —
+  // leaving RUNTIME_ROOTS unswept on Ctrl-C while config-loader cleans up.
+  // Windows note: `process.kill(pid, "SIGINT")` calls TerminateProcess
+  // rather than re-raising through the listener queue, so the handler
+  // cascade documented above only holds on POSIX. On Windows, whichever
+  // module registers FIRST runs its sweep and the second is skipped —
+  // RUNTIME_ROOTS cleanup is best-effort there. SIGHUP is a no-op for
+  // most common code paths on Windows (Node fires it on console-close
+  // and exits within seconds).
+  const onSignal = (signal: NodeJS.Signals): void => {
+    sweep();
+    process.kill(process.pid, signal);
+  };
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+    process.once(signal, onSignal);
+  }
+};
+
+type RuntimePlugin = Record<string, unknown> & { transform?: unknown };
+
+const runtimePlugins = async (cwd: string): Promise<RuntimePlugin[]> => {
+  const plugins: RuntimePlugin[] = await readProjectPlugins(cwd);
+  const typia: RuntimePlugin | undefined = plugins.find((p) =>
+    isTransform(p, "typia"),
+  );
+  const sdk: RuntimePlugin | undefined = plugins.find((p) =>
+    isTransform(p, "@nestia/sdk"),
+  );
+  const core: RuntimePlugin | undefined = plugins.find((p) =>
+    isTransform(p, "@nestia/core"),
+  );
+  return [
+    {
+      ...(typia ?? {}),
+      transform: "typia/lib/transform",
+      enabled: false,
+    },
+    normalizeRuntimePlugin({
+      ...(sdk ?? {}),
+      transform: "@nestia/sdk/lib/transform",
+    }),
+    normalizeRuntimePlugin({
+      ...(core ?? {}),
+      transform: "@nestia/core/native/transform.cjs",
+    }),
+  ];
+};
+
+const readProjectPlugins = async (cwd: string): Promise<RuntimePlugin[]> => {
+  const project: string = normalizeProjectPath(process.env.NESTIA_PROJECT);
+  const file: string = path.isAbsolute(project)
+    ? project
+    : path.join(cwd, project);
+  const config = await TsConfigReader.read(file);
+  const options = config.compilerOptions as
+    | { plugins?: RuntimePlugin[] }
+    | undefined;
+  return Array.isArray(options?.plugins)
+    ? options.plugins
+        .filter((p) => typeof p === "object" && p !== null)
+        .map((p) => ({ ...(p as unknown as RuntimePlugin) }))
+    : [];
+};
+
+const normalizeRuntimePlugin = (plugin: RuntimePlugin): RuntimePlugin => {
+  const output: RuntimePlugin = { ...plugin };
+  if (output.enabled === false) delete output.enabled;
+  return output;
+};
+
+const isTransform = (plugin: RuntimePlugin, name: string): boolean =>
+  typeof plugin.transform === "string" && plugin.transform.includes(name);
+
+const replaceExtension = (file: string, extension: string): string =>
+  file.replace(/\.[cm]?tsx?$/i, extension);
+
+const normalizeProjectPath = (project: string | undefined): string => {
+  const next: string = project ?? "tsconfig.json";
+  return path.isAbsolute(next) || next.startsWith(".") ? next : `./${next}`;
+};
+
 const normalize_file = (str: string) =>
   str.substring(
     str.startsWith("file:///")

package/src/analyses/ImportAnalyzer.ts

@@ -1,46 +1,22 @@
-import path from "path";
-import ts from "typescript";
-
 import { IReflectImport } from "../structures/IReflectImport";
 import { MapUtil } from "../utils/MapUtil";
 
 export namespace ImportAnalyzer {
-  export const analyze = (file: ts.SourceFile): IReflectImport[] =>
-    file.statements
-      .filter(ts.isImportDeclaration)
-      .map((imp) => {
-        const clause: ts.ImportClause | undefined = imp.importClause;
-        if (clause === undefined) return null;
-        try {
-          // no real position
-          // import statement generated by transformer like typia
-          imp.moduleSpecifier.getText();
-        } catch {
-          return null;
-        }
-
-        const reflect: IReflectImport = {
-          file: normalizePath(
-            path.dirname(file.fileName),
-            ts.isStringLiteral(imp.moduleSpecifier)
-              ? imp.moduleSpecifier.text
-              : escapeQuotes(imp.moduleSpecifier.getText()),
-          ),
-          elements: [],
-          default: null,
-          asterisk: null,
-        };
-        if (clause.name) reflect.default = clause.name.getText();
-        if (clause.namedBindings === undefined) return reflect;
-        else if (ts.isNamedImports(clause.namedBindings))
-          reflect.elements = clause.namedBindings.elements.map((e) =>
-            e.name.getText(),
-          );
-        else if (ts.isNamespaceImport(clause.namedBindings))
-          reflect.asterisk = clause.namedBindings.name.getText();
-        return reflect;
-      })
-      .filter((r) => r !== null);
+  /**
+   * @deprecated Removed in the Go-migration cycle. Import metadata is now
+   * attached by the native transformer in `packages/core/native/cmd/ttsc-nestia`
+   * and consumed via `IOperationMetadata.imports`. Call sites that previously
+   * walked a `ts.SourceFile` to derive imports should read the metadata
+   * delivered through `Reflect.getMetadata("nestia/OperationMetadata", …)`
+   * instead. See `packages/core/MIGRATION.md`.
+   */
+  export const analyze = (): never => {
+    throw new Error(
+      "ImportAnalyzer.analyze was removed in @nestia/sdk@next. " +
+        "Imports are now attached by the native transformer; read them from " +
+        "IOperationMetadata.imports (see packages/core/MIGRATION.md).",
+    );
+  };
 
   export const merge = (imports: IReflectImport[]): IReflectImport[] => {
     // group by files
@@ -113,14 +89,4 @@ export namespace ImportAnalyzer {
     return [...allStarImports, ...defaultImports];
   }
 
-  function escapeQuotes(str: string): string {
-    if (str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
-    else if (str.startsWith('"') && str.endsWith('"')) return str.slice(1, -1);
-    return str;
-  }
-
-  function normalizePath(root: string, str: string): string {
-    if (str.startsWith(".")) return path.resolve(root, str);
-    return `node_modules/${str}`;
-  }
 }

package/src/analyses/ReflectControllerAnalyzer.ts

@@ -9,7 +9,7 @@ import { INestiaSdkInput } from "../structures/INestiaSdkInput";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { ReflectHttpOperationAnalyzer } from "./ReflectHttpOperationAnalyzer";
 import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";

package/src/analyses/ReflectHttpOperationAnalyzer.ts

@@ -7,7 +7,7 @@ import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
 import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
 import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { ImportAnalyzer } from "./ImportAnalyzer";
 import { PathAnalyzer } from "./PathAnalyzer";

package/src/analyses/ReflectHttpOperationExceptionAnalyzer.ts

@@ -1,10 +1,10 @@
 import { TypedException } from "@nestia/core";
-import { JsonMetadataFactory } from "@typia/core";
+import { JsonMetadataFactory } from "../internal/legacy";
 
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationException } from "../structures/IReflectHttpOperationException";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 
 export namespace ReflectHttpOperationExceptionAnalyzer {
   export interface IContext {
@@ -18,6 +18,12 @@ export namespace ReflectHttpOperationExceptionAnalyzer {
   export const analyze = (
     ctx: IContext,
   ): Record<string, IReflectHttpOperationException> => {
+    // TypeScript applies decorators bottom-up, so Reflect's metadata array
+    // is the reverse of declaration order. Reverse it once here so the
+    // resulting status-code → exception map iterates in declaration order
+    // and lines up with the Go transformer's metadata.exceptions[], which
+    // is emitted in AST/declaration order (see
+    // packages/core/native/cmd/ttsc-nestia/sdk_transform.go).
     const preconfigured: TypedException.IProps<any>[] = analyzePreconfigured(
       ctx.function,
     )
@@ -26,10 +32,9 @@ export namespace ReflectHttpOperationExceptionAnalyzer {
     const errors: IReflectOperationError[] = [];
     const exceptions: IReflectHttpOperationException[] = preconfigured
       .map((pre, i) => {
-        const matched: IOperationMetadata.IException | null =
-          ctx.metadata.exceptions[i]!;
+        const matched: IOperationMetadata.IResponse | undefined =
+          ctx.metadata.exceptions[i];
         if (matched === undefined) {
-          if (ctx.functionName === "getOauthProfile") console.log(ctx.metadata);
           errors.push({
             file: ctx.controller.file,
             class: ctx.controller.class.name,
@@ -51,7 +56,20 @@ export namespace ReflectHttpOperationExceptionAnalyzer {
           .success
           ? matched.primitive.data
           : null;
-        if (schema === null || matched.type === null) return null; // unreachable
+        if (matched.primitive.success === false) {
+          errors.push({
+            file: ctx.controller.file,
+            class: ctx.controller.class.name,
+            function: ctx.functionName,
+            from: `exception (status: ${pre.status})`,
+            contents: matched.primitive.errors.map((e) => ({
+              name: e.name,
+              accessor: e.accessor,
+              messages: e.messages,
+            })),
+          });
+        }
+        if (schema === null || matched.type === null) return null;
         return {
           status: pre.status,
           description: pre.description ?? null,

package/src/analyses/ReflectHttpOperationParameterAnalyzer.ts

@@ -7,13 +7,13 @@ import {
   HttpParameterProgrammer,
   HttpQueryProgrammer,
   JsonMetadataFactory,
-} from "@typia/core";
+} from "../internal/legacy";
 
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-import { TextPlainValidator } from "../transformers/TextPlainValidator";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
+import { TextPlainValidator } from "../validators/TextPlainValidator";
 import { HttpHeadersValidator } from "../validators/HttpHeadersValidator";
 import { HttpQueryValidator } from "../validators/HttpQueryValidator";
 

package/src/analyses/ReflectHttpOperationResponseAnalyzer.ts

@@ -4,14 +4,13 @@ import {
   HTTP_CODE_METADATA,
   INTERCEPTORS_METADATA,
 } from "@nestjs/common/constants";
-import { HttpQueryProgrammer, JsonMetadataFactory } from "@typia/core";
-import typia from "typia";
+import { HttpQueryProgrammer, JsonMetadataFactory, sizeOf } from "../internal/legacy";
 
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-import { TextPlainValidator } from "../transformers/TextPlainValidator";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
+import { TextPlainValidator } from "../validators/TextPlainValidator";
 
 export namespace ReflectHttpOperationResponseAnalyzer {
   export interface IContext {
@@ -65,10 +64,7 @@ export namespace ReflectHttpOperationResponseAnalyzer {
     if (schema.success === false) errors.push(...schema.errors);
     if (ctx.httpMethod === "HEAD" && contentType !== null)
       errors.push(`HEAD method must not have a content type.`);
-    if (
-      typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType) ===
-      false
-    )
+    if (isContentType(contentType) === false)
       errors.push(
         `@nestia/sdk does not support ${JSON.stringify(contentType)} content type.`,
       );
@@ -77,7 +73,7 @@ export namespace ReflectHttpOperationResponseAnalyzer {
     else if (
       ctx.metadata.success.type === null ||
       schema.success === false ||
-      !typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType)
+      !isContentType(contentType)
     )
       return null;
 
@@ -100,7 +96,7 @@ export namespace ReflectHttpOperationResponseAnalyzer {
             : contentType === "text/plain"
               ? TextPlainValidator.validate
               : (next) =>
-                  next.metadata.size() !== 0
+                  sizeOf(next.metadata) !== 0
                     ? ["HEAD method must not have any return value."]
                     : [],
       example: example?.example,
@@ -123,4 +119,12 @@ export namespace ReflectHttpOperationResponseAnalyzer {
     if (Array.isArray(meta) === false) return false;
     return meta.some((elem) => elem?.constructor?.name === props.name);
   };
+
+  const isContentType = (
+    input: string | null,
+  ): input is IReflectHttpOperationSuccess["contentType"] =>
+    input === null ||
+    input === "application/json" ||
+    input === "text/plain" ||
+    input === "application/x-www-form-urlencoded";
 }

package/src/analyses/ReflectWebSocketOperationAnalyzer.ts

@@ -5,7 +5,7 @@ import { IReflectController } from "../structures/IReflectController";
 import { IReflectImport } from "../structures/IReflectImport";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
 import { IReflectWebSocketOperationParameter } from "../structures/IReflectWebSocketOperationParameter";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { StringUtil } from "../utils/StringUtil";
 import { ImportAnalyzer } from "./ImportAnalyzer";
 import { PathAnalyzer } from "./PathAnalyzer";
@@ -36,7 +36,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
           ctx.name,
         ) ?? []) as IReflectWebSocketOperationParameter[]
       ).sort((a, b) => a.index - b.index);
-    if (preconfigured.find((p) => (p.category === "acceptor") === undefined))
+    if (preconfigured.find((p) => p.category === "acceptor") === undefined)
       errors.push("@WebSocketRoute.Acceptor() is essentially required");
     if (preconfigured.length !== ctx.function.length)
       errors.push(