@nestia/sdk 3.0.5 → 3.1.0-dev.20240429

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -0,0 +1,248 @@
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+import { SdkWebSocketNamespaceProgrammer } from "./SdkWebSocketNamespaceProgrammer";
+
+export namespace SdkWebSocketRouteProgrammer {
+  export const write =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedWebSocketRoute): ts.Statement[] => [
+      writeFunction(project)(importer)(route),
+      SdkWebSocketNamespaceProgrammer.write(project)(importer)(route),
+    ];
+
+  const writeFunction =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedWebSocketRoute): ts.FunctionDeclaration =>
+      ts.factory.createFunctionDeclaration(
+        [
+          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+          ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+        ],
+        undefined,
+        route.name,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "connection",
+            ts.factory.createTypeReferenceNode(
+              SdkImportWizard.IConnection(importer),
+              [ts.factory.createTypeReferenceNode(`${route.name}.Header`)],
+            ),
+          ),
+          ...route.parameters
+            .filter((p) => p.category === "param" || p.category === "query")
+            .map((p) =>
+              IdentifierFactory.parameter(
+                p.name,
+                p.category === "param"
+                  ? getPathParameterType(project)(importer)(p)
+                  : ts.factory.createTypeReferenceNode(`${route.name}.Query`),
+              ),
+            ),
+          IdentifierFactory.parameter(
+            "provider",
+            ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode("Promise", [
+          ts.factory.createTypeReferenceNode(`${route.name}.Output`),
+        ]),
+        ts.factory.createBlock(writeFunctionBody(importer)(route), true),
+      );
+
+  const writeFunctionBody =
+    (importer: ImportDictionary) =>
+    (route: ITypedWebSocketRoute): ts.Statement[] => [
+      local("connector")(
+        ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: false,
+            library: "tgrid",
+            instance: "WebConnector",
+          }),
+          [
+            ts.factory.createTypeReferenceNode(`${route.name}.Header`),
+            ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
+            ts.factory.createTypeReferenceNode(`${route.name}.Listener`),
+          ],
+        ),
+      )(
+        ts.factory.createNewExpression(
+          ts.factory.createIdentifier(
+            importer.external({
+              type: false,
+              library: "tgrid",
+              instance: "WebConnector",
+            }),
+          ),
+          undefined,
+          [
+            ts.factory.createAsExpression(
+              ts.factory.createBinaryExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("connection"),
+                  "headers",
+                ),
+                ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+                ts.factory.createObjectLiteralExpression([], false),
+              ),
+              ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+            ),
+            ts.factory.createIdentifier("provider"),
+          ],
+        ),
+      ),
+      ts.factory.createExpressionStatement(
+        ts.factory.createAwaitExpression(
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("connector"),
+              "connect",
+            ),
+            undefined,
+            [
+              joinPath(
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(route.name),
+                    "path",
+                  ),
+                  [],
+                  route.parameters
+                    .filter(
+                      (p) => p.category === "param" || p.category === "query",
+                    )
+                    .map((x) => ts.factory.createIdentifier(x.name)),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+      local("driver")(
+        ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier(
+            importer.external({
+              type: true,
+              library: "tgrid",
+              instance: "Driver",
+            }),
+          ),
+          [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
+        ),
+      )(
+        ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createIdentifier("connector"),
+            "getDriver",
+          ),
+          undefined,
+          undefined,
+        ),
+      ),
+      ts.factory.createReturnStatement(
+        ts.factory.createObjectLiteralExpression(
+          [
+            ts.factory.createShorthandPropertyAssignment("connector"),
+            ts.factory.createShorthandPropertyAssignment("driver"),
+          ],
+          true,
+        ),
+      ),
+    ];
+}
+
+const local =
+  (name: string) => (type: ts.TypeNode) => (expression: ts.Expression) =>
+    ts.factory.createVariableStatement(
+      [],
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            name,
+            undefined,
+            type,
+            expression,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+
+const joinPath = (caller: ts.Expression) =>
+  ts.factory.createCallExpression(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createTemplateExpression(
+                ts.factory.createTemplateHead("", ""),
+                [
+                  ts.factory.createTemplateSpan(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("connection"),
+                      ts.factory.createIdentifier("host"),
+                    ),
+                    ts.factory.createTemplateMiddle("/", "/"),
+                  ),
+                  ts.factory.createTemplateSpan(
+                    caller,
+                    ts.factory.createTemplateTail("", ""),
+                  ),
+                ],
+              ),
+              ts.factory.createIdentifier("split"),
+            ),
+            undefined,
+            [ts.factory.createStringLiteral("/")],
+          ),
+          ts.factory.createIdentifier("filter"),
+        ),
+        undefined,
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [
+              ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                ts.factory.createIdentifier("str"),
+                undefined,
+                undefined,
+                undefined,
+              ),
+            ],
+            undefined,
+            ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+            ts.factory.createPrefixUnaryExpression(
+              ts.SyntaxKind.ExclamationToken,
+              ts.factory.createPrefixUnaryExpression(
+                ts.SyntaxKind.ExclamationToken,
+                ts.factory.createIdentifier("str"),
+              ),
+            ),
+          ),
+        ],
+      ),
+      ts.factory.createIdentifier("join"),
+    ),
+    undefined,
+    [ts.factory.createStringLiteral("/")],
+  );
+const getPathParameterType =
+  (project: INestiaProject) =>
+  (importer: ImportDictionary) =>
+  (p: ITypedWebSocketRoute.IPathParameter) =>
+    p.metadata
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SwaggerSchemaGenerator.ts

@@ -1,3 +1,4 @@
+import { OpenApi } from "@samchon/openapi";
 import { Singleton, VariadicSingleton } from "tstl";
 import ts from "typescript";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
@@ -7,12 +8,11 @@ import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
 
 import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { SwaggerSchemaValidator } from "./SwaggerSchemaValidator";
-import { OpenApi } from "@samchon/openapi";
 import { ISwaggerError } from "../../structures/ISwaggerError";
 import { ISwaggerLazyProperty } from "../../structures/ISwaggerLazyProperty";
 import { ISwaggerLazySchema } from "../../structures/ISwaggerLazySchema";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { SwaggerSchemaValidator } from "./SwaggerSchemaValidator";
 
 export namespace SwaggerSchemaGenerator {
   export interface IProps {
@@ -26,7 +26,7 @@ export namespace SwaggerSchemaGenerator {
 
   export const response =
     (props: IProps) =>
-    (route: IRoute): Record<string, OpenApi.IOperation.IResponse> => {
+    (route: ITypedHttpRoute): Record<string, OpenApi.IOperation.IResponse> => {
       const output: Record<string, OpenApi.IOperation.IResponse> = {};
 
       //----
@@ -159,8 +159,8 @@ export namespace SwaggerSchemaGenerator {
 
   export const body =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter): OpenApi.IOperation.IRequestBody => {
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter): OpenApi.IOperation.IRequestBody => {
       // ANALZE TYPE WITH VALIDATION
       const result = MetadataFactory.analyze(props.checker)({
         escape: true,
@@ -221,8 +221,8 @@ export namespace SwaggerSchemaGenerator {
 
   export const parameter =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter): OpenApi.IOperation.IParameter[] =>
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter): OpenApi.IOperation.IParameter[] =>
       param.category === "headers"
         ? headers(props)(route)(param)
         : param.category === "param"
@@ -231,8 +231,8 @@ export namespace SwaggerSchemaGenerator {
 
   const path =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter): OpenApi.IOperation.IParameter => {
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter): OpenApi.IOperation.IParameter => {
       // ANALZE TYPE WITH VALIDATION
       const result = MetadataFactory.analyze(props.checker)({
         escape: false,
@@ -255,8 +255,8 @@ export namespace SwaggerSchemaGenerator {
 
   const headers =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter): OpenApi.IOperation.IParameter[] =>
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter): OpenApi.IOperation.IParameter[] =>
       decomposible(props)(route)(param)(
         MetadataFactory.analyze(props.checker)({
           escape: false,
@@ -268,8 +268,8 @@ export namespace SwaggerSchemaGenerator {
 
   const query =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter): OpenApi.IOperation.IParameter[] =>
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter): OpenApi.IOperation.IParameter[] =>
       decomposible(props)(route)(param)(
         MetadataFactory.analyze(props.checker)({
           escape: false,
@@ -281,8 +281,8 @@ export namespace SwaggerSchemaGenerator {
 
   const decomposible =
     (props: IProps) =>
-    (route: IRoute) =>
-    (param: IRoute.IParameter) =>
+    (route: ITypedHttpRoute) =>
+    (param: ITypedHttpRoute.IParameter) =>
     (
       result: ValidationPipe<Metadata, MetadataFactory.IError>,
     ): OpenApi.IOperation.IParameter[] => {
@@ -316,7 +316,10 @@ export namespace SwaggerSchemaGenerator {
           });
           return {
             name: p.key.constants[0].values[0].value as string,
-            in: param.category === "headers" ? "header" : param.category as "path",
+            in:
+              param.category === "headers"
+                ? "header"
+                : (param.category as "path"),
             schema,
             description: p.description ?? undefined,
             required: p.value.isRequired(),
@@ -326,9 +329,9 @@ export namespace SwaggerSchemaGenerator {
 
   const lazy =
     (props: IProps) =>
-    (route: IRoute) =>
+    (route: ITypedHttpRoute) =>
     (
-      param: IRoute.IParameter,
+      param: ITypedHttpRoute.IParameter,
       result: ValidationPipe<Metadata, MetadataFactory.IError>,
     ): OpenApi.IOperation.IParameter => {
       const schema: OpenApi.IJsonSchema = coalesce(props)(result);
@@ -348,7 +351,9 @@ export namespace SwaggerSchemaGenerator {
 
   const coalesce =
     (props: IProps) =>
-    (result: ValidationPipe<Metadata, MetadataFactory.IError>): OpenApi.IJsonSchema => {
+    (
+      result: ValidationPipe<Metadata, MetadataFactory.IError>,
+    ): OpenApi.IJsonSchema => {
       const schema: OpenApi.IJsonSchema = {} as any;
       props.lazySchemas.push({
         metadata: result.success ? result.data : any.get(),
@@ -358,7 +363,7 @@ export namespace SwaggerSchemaGenerator {
     };
 
   const describe = (
-    route: IRoute,
+    route: ITypedHttpRoute,
     tagName: string,
     parameterName?: string,
   ): string | undefined => {

package/src/structures/IReflectController.ts

@@ -0,0 +1,17 @@
+import type { VERSION_NEUTRAL } from "@nestjs/common/interfaces";
+
+import { IReflectHttpOperation } from "./IReflectHttpOperation";
+import { IReflectWebSocketOperation } from "./IReflectWebSocketOperation";
+
+export interface IReflectController {
+  constructor: Function;
+  prototype: any;
+  file: string;
+  name: string;
+  prefixes: string[];
+  paths: string[];
+  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
+  operations: Array<IReflectHttpOperation | IReflectWebSocketOperation>;
+  security: Record<string, string[]>[];
+  swaggerTgas: string[];
+}

package/src/structures/{IController.ts → IReflectHttpOperation.ts}

@@ -1,94 +1,78 @@
-import type { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
-
-import type { ParamCategory } from "./ParamCategory";
-
-export interface IController {
-  target: Function;
-  file: string;
-  name: string;
-  prefixes: string[];
-  paths: string[];
-  versions:
-    | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>
-    | undefined;
-  functions: IController.IFunction[];
-  security: Record<string, string[]>[];
-  swaggerTgas: string[];
-}
-
-export namespace IController {
-  export interface IFunction {
-    target: Function;
-    name: string;
-    method: string;
-    paths: string[];
-    versions:
-      | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>
-      | undefined;
-    encrypted: boolean;
-    parameters: IParameter[];
-    status?: number;
-    type?: string;
-    contentType: "application/json" | "text/plain";
-    security: Record<string, string[]>[];
-    exceptions: Record<
-      number | "2XX" | "3XX" | "4XX" | "5XX",
-      IController.IException
-    >;
-    swaggerTags: string[];
-  }
-
-  export type IParameter =
-    | ICommonParameter
-    | IQueryParameter
-    | IHeadersParameter
-    | IBodyParameter
-    | IPathParameter;
-  export interface ICommonParameter {
-    custom: false;
-    category: ParamCategory;
-    index: number;
-    name: string;
-    field: string | undefined;
-  }
-  export interface IHeadersParameter {
-    custom: true;
-    category: "headers";
-    index: number;
-    name: string;
-    field: string | undefined;
-  }
-  export interface IQueryParameter {
-    custom: true;
-    category: "query";
-    index: number;
-    name: string;
-    field: string | undefined;
-  }
-  export interface IBodyParameter {
-    custom: true;
-    category: "body";
-    index: number;
-    name: string;
-    field: string | undefined;
-    encrypted: boolean;
-    contentType:
-      | "application/json"
-      | "application/x-www-form-urlencoded"
-      | "multipart/form-data"
-      | "text/plain";
-  }
-  export interface IPathParameter {
-    custom: true;
-    category: "param";
-    index: number;
-    name: string;
-    field: string | undefined;
-  }
-
-  export interface IException {
-    type: string;
-    status: number | "2XX" | "3XX" | "4XX" | "5XX";
-    description: string | undefined;
-  }
-}
+import { VERSION_NEUTRAL } from "@nestjs/common/interfaces";
+
+import { ParamCategory } from "./ParamCategory";
+
+export interface IReflectHttpOperation {
+  protocol: "http";
+  function: Function;
+  name: string;
+  method: string;
+  paths: string[];
+  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
+  encrypted: boolean;
+  parameters: IReflectHttpOperation.IParameter[];
+  status?: number;
+  type?: string;
+  contentType: "application/json" | "text/plain";
+  security: Record<string, string[]>[];
+  exceptions: Record<
+    number | "2XX" | "3XX" | "4XX" | "5XX",
+    IReflectHttpOperation.IException
+  >;
+  swaggerTags: string[];
+}
+export namespace IReflectHttpOperation {
+  export type IParameter =
+    | ICommonParameter
+    | IQueryParameter
+    | IHeadersParameter
+    | IBodyParameter
+    | IPathParameter;
+  export interface ICommonParameter {
+    custom: false;
+    category: ParamCategory;
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IHeadersParameter {
+    custom: true;
+    category: "headers";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IQueryParameter {
+    custom: true;
+    category: "query";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IBodyParameter {
+    custom: true;
+    category: "body";
+    index: number;
+    name: string;
+    field: string | undefined;
+    encrypted: boolean;
+    contentType:
+      | "application/json"
+      | "application/x-www-form-urlencoded"
+      | "multipart/form-data"
+      | "text/plain";
+  }
+  export interface IPathParameter {
+    custom: true;
+    category: "param";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+
+  export interface IException {
+    type: string;
+    status: number | "2XX" | "3XX" | "4XX" | "5XX";
+    description: string | undefined;
+  }
+}

package/src/structures/IReflectWebSocketOperation.ts

@@ -0,0 +1,17 @@
+import { VERSION_NEUTRAL } from "@nestjs/common";
+
+export interface IReflectWebSocketOperation {
+  protocol: "websocket";
+  target: Function;
+  name: string;
+  paths: string[];
+  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
+  parameters: IReflectWebSocketOperation.IParameter[];
+}
+export namespace IReflectWebSocketOperation {
+  export interface IParameter {
+    category: "acceptor" | "driver" | "header" | "param" | "query";
+    field: string;
+    index: number;
+  }
+}

package/src/structures/ISwaggerError.ts

@@ -1,8 +1,8 @@
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
 
-import { IRoute } from "./IRoute";
+import { ITypedHttpRoute } from "./ITypedHttpRoute";
 
 export interface ISwaggerError extends MetadataFactory.IError {
-  route: IRoute;
+  route: ITypedHttpRoute;
   from: string;
 }

package/src/structures/{IRoute.ts → ITypedHttpRoute.ts}

@@ -1,10 +1,13 @@
 import ts from "typescript";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
-import { IController } from "./IController";
+import { IReflectController } from "./IReflectController";
+import { IReflectHttpOperation } from "./IReflectHttpOperation";
 
-export interface IRoute {
-  controller: Function;
+export interface ITypedHttpRoute {
+  protocol: "http";
+  controller: IReflectController;
+  function: Function;
   name: string;
   method: string;
   path: string;
@@ -12,15 +15,11 @@ export interface IRoute {
   status?: number;
 
   accessors: string[];
-  parameters: IRoute.IParameter[];
+  parameters: ITypedHttpRoute.IParameter[];
   imports: [string, string[]][];
-  output: IRoute.IOutput;
+  output: ITypedHttpRoute.IOutput;
 
   location: string;
-  target: {
-    class: Function;
-    function: Function;
-  };
   description?: string;
   operationId?: string;
   jsDocTags: ts.JSDocTagInfo[];
@@ -29,12 +28,15 @@ export interface IRoute {
     | { type: "assigner"; source: string }
   >;
   security: Record<string, string[]>[];
-  exceptions: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>;
+  exceptions: Record<
+    number | "2XX" | "3XX" | "4XX" | "5XX",
+    ITypedHttpRoute.IOutput
+  >;
   swaggerTags: string[];
 }
 
-export namespace IRoute {
-  export type IParameter = IController.IParameter & {
+export namespace ITypedHttpRoute {
+  export type IParameter = IReflectHttpOperation.IParameter & {
     optional: boolean;
     type: ts.Type;
     typeName: string;