@nestia/sdk 3.10.0 → 3.11.0-dev.20240813

package/src/analyses/ReflectWebSocketOperationAnalyzer.ts

@@ -1,96 +1,161 @@
 import { ranges } from "tstl";
 
-import { IErrorReport } from "../structures/IErrorReport";
 import { INestiaProject } from "../structures/INestiaProject";
 import { IReflectController } from "../structures/IReflectController";
+import { IReflectTypeImport } from "../structures/IReflectTypeImport";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
+import { IReflectWebSocketOperationParameter } from "../structures/IReflectWebSocketOperationParameter";
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { StringUtil } from "../utils/StringUtil";
+import { ImportAnalyzer } from "./ImportAnalyzer";
 import { PathAnalyzer } from "./PathAnalyzer";
 import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
 
 export namespace ReflectWebSocketOperationAnalyzer {
-  export const analyze =
-    (project: INestiaProject) =>
-    (props: {
-      controller: IReflectController;
-      function: Function;
-      name: string;
-    }): IReflectWebSocketOperation | null => {
-      const route: { paths: string[] } | undefined = Reflect.getMetadata(
-        "nestia/WebSocketRoute",
-        props.function,
-      );
-      if (route === undefined) return null;
+  export interface IProps {
+    project: INestiaProject;
+    controller: IReflectController;
+    function: Function;
+    name: string;
+    metadata: IOperationMetadata;
+  }
+  export const analyze = (ctx: IProps): IReflectWebSocketOperation | null => {
+    const route: { paths: string[] } | undefined = Reflect.getMetadata(
+      "nestia/WebSocketRoute",
+      ctx.function,
+    );
+    if (route === undefined) return null;
 
-      const errors: IErrorReport[] = [];
-      const parameters: IReflectWebSocketOperation.IParameter[] = (
+    // @todo -> detailing is required
+    const errors: string[] = [];
+    const preconfigured: IReflectWebSocketOperationParameter.IPreconfigured[] =
+      (
         (Reflect.getMetadata(
           "nestia/WebSocketRoute/Parameters",
-          props.controller.prototype,
-          props.name,
-        ) ?? []) as IReflectWebSocketOperation.IParameter[]
+          ctx.controller.class.prototype,
+          ctx.name,
+        ) ?? []) as IReflectWebSocketOperationParameter[]
       ).sort((a, b) => a.index - b.index);
-      if (parameters.find((p) => (p.category === "acceptor") === undefined))
-        errors.push({
-          file: props.controller.file,
-          controller: props.controller.name,
-          function: props.name,
-          message: "@WebSocketRoute.Acceptor() is essentially required",
-        });
-      if (parameters.length !== props.function.length)
-        errors.push({
-          file: props.controller.file,
-          controller: props.controller.name,
-          function: props.name,
-          message: [
-            "Every parameters must be one of below:",
-            "  - @WebSocketRoute.Acceptor()",
-            "  - @WebSocketRoute.Driver()",
-            "  - @WebSocketRoute.Header()",
-            "  - @WebSocketRoute.Param()",
-            "  - @WebSocketRoute.Query()",
-          ].join("\n"),
-        });
+    if (preconfigured.find((p) => (p.category === "acceptor") === undefined))
+      errors.push("@WebSocketRoute.Acceptor() is essentially required");
+    if (preconfigured.length !== ctx.function.length)
+      errors.push(
+        [
+          "Every parameters must be one of below:",
+          "  - @WebSocketRoute.Acceptor()",
+          "  - @WebSocketRoute.Driver()",
+          "  - @WebSocketRoute.Header()",
+          "  - @WebSocketRoute.Param()",
+          "  - @WebSocketRoute.Query()",
+        ].join("\n"),
+      );
+
+    const imports: IReflectTypeImport[] = [];
+    const parameters: IReflectWebSocketOperationParameter[] = preconfigured
+      .map((p) => {
+        // METADATA INFO
+        const matched: IOperationMetadata.IParameter | undefined =
+          ctx.metadata.parameters.find((m) => p.index === m.index);
+
+        // VALIDATE PARAMETER
+        if (matched === undefined)
+          return errors.push(
+            `Unable to find parameter type of the ${p.index} (th).`,
+          );
+        else if (matched.type === null)
+          return errors.push(
+            `Failed to analyze the parameter type of the ${JSON.stringify(matched.name)}.`,
+          );
+        else if (
+          p.category === "param" &&
+          !(p as IReflectWebSocketOperationParameter.IParam).field?.length
+        )
+          return errors.push(`@WebSocketRoute.Param() must have a field name.`);
+        else if (
+          p.category === "acceptor" &&
+          matched.type?.typeArguments?.length !== 3
+        )
+          return `@WebSocketRoute.Acceptor() must have three type arguments.`;
+        else if (
+          p.category === "driver" &&
+          matched.type?.typeArguments?.length !== 1
+        )
+          return errors.push(
+            `@WebSocketRoute.Driver() must have one type argument.`,
+          );
+
+        // COMPLETE COMPOSITION
+        imports.push(...matched.imports);
+        if (
+          p.category === "acceptor" ||
+          p.category === "driver" ||
+          p.category === "query"
+        )
+          return {
+            ...p,
+            name: matched.name,
+            type: matched.type,
+          };
+        else if (p.category === "param")
+          return {
+            ...p,
+            category: "param",
+            field: p.field!,
+            name: matched.name,
+            type: matched.type,
+            imports: matched.imports,
+            description: matched.description,
+            jsDocTags: matched.jsDocTags,
+          } satisfies IReflectWebSocketOperationParameter.IParam;
+
+        // UNKNOWN TYPE, MAYBE NEW FEATURE
+        console.log(p);
+        return errors.push(
+          `@WebSocketRoute.${StringUtil.capitalize(p.category)}() has not been supported yet. How about upgrading the nestia packages?`,
+        );
+      })
+      .filter((p): p is IReflectWebSocketOperationParameter => !!p);
 
-      const fields: string[] = parameters
-        .filter((p) => p.category === "param")
-        .map((p) => p.field)
-        .sort();
-      for (const cLoc of props.controller.paths)
-        for (const mLoc of route.paths) {
-          const location: string = PathAnalyzer.join(cLoc, mLoc);
-          if (location.includes("*")) continue;
+    const fields: string[] = preconfigured
+      .filter((p) => p.category === "param")
+      .map((p) => p.field ?? "")
+      .filter((field): field is string => !!field?.length)
+      .sort();
+    for (const cLoc of ctx.controller.paths)
+      for (const mLoc of route.paths) {
+        const location: string = PathAnalyzer.join(cLoc, mLoc);
+        if (location.includes("*")) continue;
 
-          const binded: string[] | null = PathAnalyzer.parameters(location);
-          if (binded === null) {
-            errors.push({
-              file: props.controller.file,
-              controller: props.controller.name,
-              function: props.name,
-              message: `invalid path (${JSON.stringify(location)})`,
-            });
-            continue;
-          }
-          if (ranges.equal(binded.sort(), fields) === false)
-            errors.push({
-              file: props.controller.file,
-              controller: props.controller.name,
-              function: props.name,
-              message: `binded arguments in the "path" between function's decorator and parameters' decorators are different (function: [${binded.join(
-                ", ",
-              )}], parameters: [${fields.join(", ")}]).`,
-            });
-        }
-      if (errors.length) {
-        project.errors.push(...errors);
-        return null;
+        const binded: string[] | null = PathAnalyzer.parameters(location);
+        if (binded === null)
+          errors.push(`invalid path (${JSON.stringify(location)})`);
+        else if (ranges.equal(binded.sort(), fields) === false)
+          errors.push(
+            `binded arguments in the "path" between function's decorator and parameters' decorators are different (function: [${binded.join(
+              ", ",
+            )}], parameters: [${fields.join(", ")}]).`,
+          );
       }
-      return {
-        protocol: "websocket",
-        target: props.function,
-        name: props.name,
-        paths: route.paths,
-        versions: ReflectMetadataAnalyzer.versions(props.function),
-        parameters,
-      };
+    if (errors.length) {
+      ctx.project.errors.push({
+        file: ctx.controller.file,
+        class: ctx.controller.class.name,
+        function: ctx.function.name,
+        from: ctx.name,
+        contents: errors,
+      });
+      return null;
+    }
+    return {
+      protocol: "websocket",
+      name: ctx.name,
+      paths: route.paths,
+      function: ctx.function,
+      versions: ReflectMetadataAnalyzer.versions(ctx.function),
+      parameters,
+      imports: ImportAnalyzer.unique(imports),
+      description: ctx.metadata.description ?? null,
+      jsDocTags: ctx.metadata.jsDocTags,
     };
+  };
 }

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -0,0 +1,178 @@
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
+import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
+import { IMetadataDictionary } from "typia/lib/schemas/metadata/IMetadataDictionary";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataComponents } from "typia/lib/schemas/metadata/MetadataComponents";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
+import { IReflectOperationError } from "../structures/IReflectOperationError";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+import { ITypedHttpRouteException } from "../structures/ITypedHttpRouteException";
+import { ITypedHttpRouteParameter } from "../structures/ITypedHttpRouteParameter";
+import { ITypedHttpRouteSuccess } from "../structures/ITypedHttpRouteSuccess";
+import { PathUtil } from "../utils/PathUtil";
+
+export namespace TypedHttpRouteAnalyzer {
+  export const dictionary = (
+    controllers: IReflectController[],
+  ): IMetadataDictionary => {
+    const individual: IMetadataComponents[] = [];
+    for (const c of controllers)
+      for (const o of c.operations) {
+        if (o.protocol !== "http") continue;
+        if (o.success) individual.push(o.success.components);
+        for (const p of o.parameters) individual.push(p.components);
+        for (const e of Object.values(o.exceptions))
+          individual.push(e.components);
+      }
+    const components: MetadataComponents = MetadataComponents.from({
+      objects: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.objects.map((o) => [o.name, o])).flat(),
+        ),
+      ),
+      arrays: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.arrays.map((a) => [a.name, a])).flat(),
+        ),
+      ),
+      tuples: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.tuples.map((t) => [t.name, t])).flat(),
+        ),
+      ),
+      aliases: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.aliases.map((a) => [a.name, a])).flat(),
+        ),
+      ),
+    });
+    return components.dictionary;
+  };
+
+  export const analyze = (props: {
+    controller: IReflectController;
+    errors: IReflectOperationError[];
+    dictionary: IMetadataDictionary;
+    operation: IReflectHttpOperation;
+    paths: string[];
+  }): ITypedHttpRoute[] => {
+    const errors: IReflectOperationError[] = [];
+    const cast = (
+      next: {
+        metadata: IMetadata;
+        validate: MetadataFactory.Validator;
+      },
+      from: string,
+      escape: boolean,
+    ): Metadata => {
+      const metadata: Metadata = Metadata.from(next.metadata, props.dictionary);
+      const metaErrors: MetadataFactory.IError[] = MetadataFactory.validate()({
+        escape,
+        constant: true,
+        absorb: true,
+        validate: next.validate,
+      })(next.validate)(metadata);
+      if (metaErrors.length)
+        errors.push({
+          file: props.controller.file,
+          class: props.controller.class.name,
+          function: props.operation.name,
+          from,
+          contents: metaErrors.map((e) => ({
+            name: e.name,
+            accessor:
+              e.explore.object !== null
+                ? join({
+                    object: e.explore.object,
+                    key: e.explore.property,
+                  })
+                : null,
+            messages: e.messages,
+          })),
+        });
+      return metadata;
+    };
+    const exceptions: Record<
+      number | "2XX" | "3XX" | "4XX" | "5XX",
+      ITypedHttpRouteException
+    > = Object.fromEntries(
+      Object.entries(props.operation.exceptions).map(([key, value]) => [
+        key as any,
+        {
+          status: value.status,
+          description: value.description,
+          example: value.example,
+          examples: value.examples,
+          type: value.type,
+          metadata: cast(value, `exception (status: ${key})`, true),
+        },
+      ]),
+    );
+    const parameters: ITypedHttpRouteParameter[] =
+      props.operation.parameters.map((p) => ({
+        ...p,
+        metadata: cast(
+          p,
+          `parameter (name: ${JSON.stringify(p.name)})`,
+          p.category === "body" &&
+            (p.contentType === "application/json" || p.encrypted === true),
+        ),
+      }));
+    const success: ITypedHttpRouteSuccess = {
+      ...props.operation.success,
+      metadata: cast(
+        props.operation.success,
+        "success",
+        props.operation.success.encrypted ||
+          props.operation.success.contentType === "application/json",
+      ),
+      setHeaders: props.operation.jsDocTags
+        .filter(
+          (t) =>
+            t.text?.length &&
+            t.text[0].text &&
+            (t.name === "setHeader" || t.name === "assignHeaders"),
+        )
+        .map((t) =>
+          t.name === "setHeader"
+            ? {
+                type: "setter",
+                source: t.text![0].text.split(" ")[0].trim(),
+                target: t.text![0].text.split(" ")[1]?.trim(),
+              }
+            : {
+                type: "assigner",
+                source: t.text![0].text,
+              },
+        ),
+    };
+    if (errors.length) return [];
+    return props.paths.map((path) => ({
+      ...props.operation,
+      controller: props.controller,
+      path,
+      accessors: [...PathUtil.accessors(path), props.operation.name],
+      exceptions,
+      parameters,
+      success,
+    }));
+  };
+}
+
+const join = ({
+  object,
+  key,
+}: {
+  object: MetadataObject;
+  key: string | object | null;
+}) => {
+  if (key === null) return object.name;
+  else if (typeof key === "object") return `${object.name}[key]`;
+  else if (Escaper.variable(key)) return `${object.name}.${key}`;
+  return `${object.name}[${JSON.stringify(key)}]`;
+};

package/src/analyses/TypedWebSocketRouteAnalyzer.ts

@@ -0,0 +1,18 @@
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
+import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
+import { PathUtil } from "../utils/PathUtil";
+
+export namespace TypedWebSocketRouteAnalyzer {
+  export const analyze = (props: {
+    controller: IReflectController;
+    operation: IReflectWebSocketOperation;
+    paths: string[];
+  }): ITypedWebSocketRoute[] =>
+    props.paths.map((path) => ({
+      ...props.operation,
+      controller: props.controller,
+      path,
+      accessors: [...PathUtil.accessors(path), props.operation.name],
+    }));
+}

package/src/decorators/OperationMetadata.ts

@@ -0,0 +1,15 @@
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+
+export function OperationMetadata(
+  metadata: IOperationMetadata,
+): MethodDecorator {
+  return function OperationMetadata(target, propertyKey, descriptor) {
+    Reflect.defineMetadata(
+      "nestia/OperationMetadata",
+      metadata,
+      target,
+      propertyKey,
+    );
+    return descriptor;
+  };
+}

package/src/executable/internal/NestiaConfigLoader.ts

@@ -1,3 +1,4 @@
+import { NoTransformConfigureError } from "@nestia/core/lib/decorators/internal/NoTransformConfigureError";
 import fs from "fs";
 import path from "path";
 import { register } from "ts-node";
@@ -32,15 +33,29 @@ export namespace NestiaConfigLoader {
 
   export const config = async (
     file: string,
-    rawCompilerOptions: Record<string, any>,
+    compilerOptions: Record<string, any>,
   ): Promise<INestiaConfig> => {
     if (fs.existsSync(path.resolve(file)) === false)
       throw new Error(`Unable to find "${file}" file.`);
 
+    (NoTransformConfigureError as any).throws = false;
+    const plugins: any[] = [
+      ...typia
+        .assert<object[]>(compilerOptions.plugins ?? [])
+        .filter(
+          (x: any) =>
+            x.transform !== "@nestia/core/lib/transform" &&
+            x.transform !== "@nestia/sdk/lib/transform",
+        ),
+      { transform: "@nestia/sdk/lib/transform" },
+    ];
     register({
       emit: false,
-      compilerOptions: rawCompilerOptions,
-      require: rawCompilerOptions.baseUrl
+      compilerOptions: {
+        ...compilerOptions,
+        plugins,
+      },
+      require: compilerOptions.baseUrl
         ? ["tsconfig-paths/register"]
         : undefined,
     });

package/src/executable/internal/NestiaSdkCommand.ts

@@ -34,10 +34,7 @@ export namespace NestiaSdkCommand {
     );
 
     // GENERATE
-    const app: NestiaSdkApplication = new NestiaSdkApplication(
-      config,
-      command.options,
-    );
+    const app: NestiaSdkApplication = new NestiaSdkApplication(config);
     await task(app);
   };
 

package/src/generates/CloneGenerator.ts

@@ -1,64 +1,65 @@
-import fs from "fs";
-import ts from "typescript";
+// import fs from "fs";
+// import ts from "typescript";
 
-import { INestiaProject } from "../structures/INestiaProject";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { FilePrinter } from "./internal/FilePrinter";
-import { ImportDictionary } from "./internal/ImportDictionary";
-import { SdkHttpCloneProgrammer } from "./internal/SdkHttpCloneProgrammer";
+// import { INestiaProject } from "../structures/INestiaProject";
+// import { ITypedApplication } from "../structures/ITypedApplication";
+// import { FilePrinter } from "./internal/FilePrinter";
+// import { ImportDictionary } from "./internal/ImportDictionary";
+// // import { SdkHttpCloneProgrammer } from "./internal/SdkHttpCloneProgrammer";
 
-export namespace CloneGenerator {
-  export const write =
-    (project: INestiaProject) =>
-    async (routes: ITypedHttpRoute[]): Promise<void> => {
-      const dict: Map<string, SdkHttpCloneProgrammer.IModule> =
-        SdkHttpCloneProgrammer.write(project)(routes);
-      if (dict.size === 0) return;
-      try {
-        await fs.promises.mkdir(`${project.config.output}/structures`);
-      } catch {}
-      for (const [key, value] of dict) await writeDtoFile(project)(key, value);
-    };
+// export namespace CloneGenerator {
+//   export const write = async (app: ITypedApplication): Promise<void> => {
+//     // const dict: Map<string, SdkHttpCloneProgrammer.IModule> =
+//     //   SdkHttpCloneProgrammer.write(app.project)(
+//     //     app.routes.filter((r) => r.protocol === "http"),
+//     //   );
+//     if (dict.size === 0) return;
+//     try {
+//       await fs.promises.mkdir(`${app.project.config.output}/structures`);
+//     } catch {}
+//     for (const [key, value] of dict)
+//       await writeDtoFile(app.project)(key, value);
+//   };
 
-  const writeDtoFile =
-    (project: INestiaProject) =>
-    async (
-      key: string,
-      value: SdkHttpCloneProgrammer.IModule,
-    ): Promise<void> => {
-      const location: string = `${project.config.output}/structures/${key}.ts`;
-      const importer: ImportDictionary = new ImportDictionary(location);
-      const statements: ts.Statement[] = iterate(importer)(value);
-      if (statements.length === 0) return;
+//   const writeDtoFile =
+//     (project: INestiaProject) =>
+//     async (
+//       key: string,
+//       value: SdkHttpCloneProgrammer.IModule,
+//     ): Promise<void> => {
+//       const location: string = `${project.config.output}/structures/${key}.ts`;
+//       const importer: ImportDictionary = new ImportDictionary(location);
+//       const statements: ts.Statement[] = iterate(importer)(value);
+//       if (statements.length === 0) return;
 
-      await FilePrinter.write({
-        location,
-        statements: [
-          ...importer.toStatements(`${project.config.output}/structures`),
-          ...(importer.empty() ? [] : [FilePrinter.enter()]),
-          ...statements,
-        ],
-      });
-    };
+//       await FilePrinter.write({
+//         location,
+//         statements: [
+//           ...importer.toStatements(`${project.config.output}/structures`),
+//           ...(importer.empty() ? [] : [FilePrinter.enter()]),
+//           ...statements,
+//         ],
+//       });
+//     };
 
-  const iterate =
-    (importer: ImportDictionary) =>
-    (modulo: SdkHttpCloneProgrammer.IModule): ts.Statement[] => {
-      const output: ts.Statement[] = [];
-      if (modulo.programmer !== null) output.push(modulo.programmer(importer));
-      if (modulo.children.size) {
-        const internal: ts.Statement[] = [];
-        for (const child of modulo.children.values())
-          internal.push(...iterate(importer)(child));
-        output.push(
-          ts.factory.createModuleDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            ts.factory.createIdentifier(modulo.name),
-            ts.factory.createModuleBlock(internal),
-            ts.NodeFlags.Namespace,
-          ),
-        );
-      }
-      return output;
-    };
-}
+//   const iterate =
+//     (importer: ImportDictionary) =>
+//     (modulo: SdkHttpCloneProgrammer.IModule): ts.Statement[] => {
+//       const output: ts.Statement[] = [];
+//       if (modulo.programmer !== null) output.push(modulo.programmer(importer));
+//       if (modulo.children.size) {
+//         const internal: ts.Statement[] = [];
+//         for (const child of modulo.children.values())
+//           internal.push(...iterate(importer)(child));
+//         output.push(
+//           ts.factory.createModuleDeclaration(
+//             [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+//             ts.factory.createIdentifier(modulo.name),
+//             ts.factory.createModuleBlock(internal),
+//             ts.NodeFlags.Namespace,
+//           ),
+//         );
+//       }
+//       return output;
+//     };
+// }