@nestia/sdk 3.10.0 → 3.11.0-dev.20240812

package/src/structures/IReflectHttpOperationParameter.ts

@@ -0,0 +1,81 @@
+import { IJsDocTagInfo } from "typia";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
+import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
+
+import { IReflectType } from "./IReflectType";
+
+export type IReflectHttpOperationParameter =
+  | IReflectHttpOperationParameter.IBody
+  | IReflectHttpOperationParameter.IHeaders
+  | IReflectHttpOperationParameter.IParam
+  | IReflectHttpOperationParameter.IQuery;
+export namespace IReflectHttpOperationParameter {
+  export interface IBody extends IBase<"body"> {
+    contentType:
+      | "application/json"
+      | "application/x-www-form-urlencoded"
+      | "multipart/form-data"
+      | "text/plain";
+    encrypted: boolean;
+  }
+  export interface IHeaders extends IBase<"headers"> {
+    field: string | null;
+  }
+  export interface IParam extends IBase<"param"> {
+    field: string;
+  }
+  export interface IQuery extends IBase<"query"> {
+    field: string | null;
+  }
+  interface IBase<Category extends string> {
+    category: Category;
+    name: string;
+    index: number;
+    type: IReflectType;
+    metadata: IMetadata;
+    components: IMetadataComponents;
+    validate: MetadataFactory.Validator;
+    example?: any;
+    examples?: Record<string, any>;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }
+
+  /**
+   * @internal
+   */
+  export type IPreconfigured =
+    | IPreconfigured.IBody
+    | IPreconfigured.IHeaders
+    | IPreconfigured.IParam
+    | IPreconfigured.IQuery;
+
+  /**
+   * @internal
+   */
+  export namespace IPreconfigured {
+    export interface IBody extends IBase<"body"> {
+      field?: string;
+      encrypted?: boolean;
+      contentType:
+        | "application/json"
+        | "application/x-www-form-urlencoded"
+        | "multipart/form-data"
+        | "text/plain";
+    }
+    export interface IHeaders extends IBase<"headers"> {
+      field?: string;
+    }
+    export interface IParam extends IBase<"param"> {
+      field?: string;
+    }
+    export interface IQuery extends IBase<"query"> {
+      field?: string;
+    }
+    interface IBase<Category extends string> {
+      category: Category;
+      index: number;
+    }
+  }
+}

package/src/structures/IReflectHttpOperationSuccess.ts

@@ -0,0 +1,22 @@
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
+import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
+
+import { IReflectType } from "./IReflectType";
+
+export interface IReflectHttpOperationSuccess {
+  type: IReflectType;
+  status: number;
+  contentType:
+    | "application/json"
+    | "text/plain"
+    | "application/x-www-form-urlencoded"
+    | "application/json"
+    | null;
+  encrypted: boolean;
+  components: IMetadataComponents;
+  metadata: IMetadata;
+  validate: MetadataFactory.Validator;
+  example?: any;
+  examples?: Record<string, any>;
+}

package/src/structures/IReflectOperationError.ts

@@ -0,0 +1,26 @@
+import { IComparable } from "tstl";
+
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+
+export interface IReflectOperationError {
+  file: string;
+  class: string;
+  function: string | null;
+  from: string | null;
+  contents: Array<string | IOperationMetadata.IError>;
+}
+export namespace IReflectOperationError {
+  export class Key implements Pick<IComparable<Key>, "less"> {
+    public constructor(public readonly error: IReflectOperationError) {}
+
+    public less(obj: Key): boolean {
+      if (this.error.file !== obj.error.file)
+        return this.error.file < obj.error.file;
+      else if (this.error.class !== obj.error.class)
+        return this.error.class < obj.error.class;
+      else if (this.error.function !== obj.error.function)
+        return (this.error.function ?? "") < (obj.error.function ?? "");
+      return (this.error.from ?? "") < (obj.error.from ?? "");
+    }
+  }
+}

package/src/structures/IReflectType.ts

@@ -0,0 +1,4 @@
+export interface IReflectType {
+  name: string;
+  typeArguments?: IReflectType[];
+}

package/src/structures/IReflectTypeImport.ts

@@ -0,0 +1,4 @@
+export interface IReflectTypeImport {
+  file: string;
+  instances: string[];
+}

package/src/structures/IReflectWebSocketOperation.ts

@@ -1,17 +1,17 @@
 import { VERSION_NEUTRAL } from "@nestjs/common";
+import ts from "typescript";
+
+import { IReflectTypeImport } from "./IReflectTypeImport";
+import { IReflectWebSocketOperationParameter } from "./IReflectWebSocketOperationParameter";
 
 export interface IReflectWebSocketOperation {
   protocol: "websocket";
-  target: Function;
   name: string;
   paths: string[];
+  function: Function;
   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;
-  }
+  parameters: IReflectWebSocketOperationParameter[];
+  imports: IReflectTypeImport[];
+  description: string | null;
+  jsDocTags: ts.JSDocTagInfo[];
 }

package/src/structures/IReflectWebSocketOperationParameter.ts

@@ -0,0 +1,38 @@
+import { IJsDocTagInfo } from "typia";
+
+import { IReflectType } from "./IReflectType";
+import { IReflectTypeImport } from "./IReflectTypeImport";
+
+export type IReflectWebSocketOperationParameter =
+  | IReflectWebSocketOperationParameter.IAcceptor
+  | IReflectWebSocketOperationParameter.IDriver
+  | IReflectWebSocketOperationParameter.IHeader
+  | IReflectWebSocketOperationParameter.IParam
+  | IReflectWebSocketOperationParameter.IQuery;
+export namespace IReflectWebSocketOperationParameter {
+  export type IAcceptor = IBase<"acceptor">;
+  export type IDriver = IBase<"driver">;
+  export type IHeader = IBase<"header">;
+  export type IQuery = IBase<"query">;
+  export interface IParam extends IBase<"param"> {
+    field: string;
+  }
+  interface IBase<Category extends string> {
+    category: Category;
+    name: string;
+    index: number;
+    type: IReflectType;
+    imports: IReflectTypeImport[];
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }
+
+  /**
+   * @internal
+   */
+  export interface IPreconfigured {
+    category: "acceptor" | "driver" | "header" | "param" | "query";
+    index: number;
+    field?: string;
+  }
+}

package/src/structures/ITypedApplication.ts

@@ -0,0 +1,8 @@
+import { INestiaProject } from "./INestiaProject";
+import { ITypedHttpRoute } from "./ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "./ITypedWebSocketRoute";
+
+export interface ITypedApplication {
+  project: INestiaProject;
+  routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>;
+}

package/src/structures/ITypedHttpRoute.ts

@@ -1,59 +1,29 @@
-import ts from "typescript";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { IJsDocTagInfo } from "typia";
 
 import { IReflectController } from "./IReflectController";
-import { IReflectHttpOperation } from "./IReflectHttpOperation";
+import { IReflectTypeImport } from "./IReflectTypeImport";
+import { ITypedHttpRouteException } from "./ITypedHttpRouteException";
+import { ITypedHttpRouteParameter } from "./ITypedHttpRouteParameter";
+import { ITypedHttpRouteSuccess } from "./ITypedHttpRouteSuccess";
 
 export interface ITypedHttpRoute {
   protocol: "http";
-  controller: IReflectController;
   function: Function;
+  controller: IReflectController;
   name: string;
   method: string;
   path: string;
-  encrypted: boolean;
-  status?: number;
-
   accessors: string[];
-  parameters: ITypedHttpRoute.IParameter[];
-  imports: [string, string[]][];
-  output: ITypedHttpRoute.IOutput;
-
-  location: string;
-  description?: string;
-  operationId?: string;
-  jsDocTags: ts.JSDocTagInfo[];
-  setHeaders: Array<
-    | { type: "setter"; source: string; target?: string }
-    | { type: "assigner"; source: string }
-  >;
-  security: Record<string, string[]>[];
+  parameters: ITypedHttpRouteParameter[];
+  success: ITypedHttpRouteSuccess;
   exceptions: Record<
     number | "2XX" | "3XX" | "4XX" | "5XX",
-    ITypedHttpRoute.IOutput
+    ITypedHttpRouteException
   >;
-  example?: any;
-  examples?: Record<string, any>;
-  swaggerTags: string[];
-}
-
-export namespace ITypedHttpRoute {
-  export type IParameter = IReflectHttpOperation.IParameter & {
-    optional: boolean;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-    description?: string;
-    jsDocTags: ts.JSDocTagInfo[];
-  };
-  export interface IOutput {
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-    description?: string;
-    contentType:
-      | "application/x-www-form-urlencoded"
-      | "application/json"
-      | "text/plain";
-  }
+  security: Record<string, string[]>[];
+  tags: string[];
+  imports: IReflectTypeImport[];
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+  operationId: string | undefined;
 }

package/src/structures/ITypedHttpRouteException.ts

@@ -0,0 +1,15 @@
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IReflectType } from "./IReflectType";
+
+export interface ITypedHttpRouteException {
+  // BASIC PROPERTIES
+  status: number | "2XX" | "3XX" | "4XX" | "5XX";
+  description: string | null;
+  example: any;
+  examples: Record<string, any>;
+
+  // REFLECTED PROPERTIES
+  type: IReflectType;
+  metadata: Metadata;
+}

package/src/structures/ITypedHttpRouteParameter.ts

@@ -0,0 +1,41 @@
+import { IJsDocTagInfo } from "typia";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IReflectType } from "./IReflectType";
+
+export type ITypedHttpRouteParameter =
+  | ITypedHttpRouteParameter.IBody
+  | ITypedHttpRouteParameter.IHeaders
+  | ITypedHttpRouteParameter.IParam
+  | ITypedHttpRouteParameter.IQuery;
+export namespace ITypedHttpRouteParameter {
+  export interface IBody extends IBase<"body"> {
+    contentType:
+      | "application/json"
+      | "application/x-www-form-urlencoded"
+      | "multipart/form-data"
+      | "text/plain";
+    encrypted: boolean;
+  }
+  export interface IHeaders extends IBase<"headers"> {
+    field: string | null;
+  }
+  export interface IParam extends IBase<"param"> {
+    field: string;
+  }
+  export interface IQuery extends IBase<"query"> {
+    field: string | null;
+  }
+
+  interface IBase<Category extends string> {
+    category: Category;
+    name: string;
+    index: number;
+    type: IReflectType;
+    metadata: Metadata;
+    example?: any;
+    examples?: Record<string, any>;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }
+}

package/src/structures/ITypedHttpRouteSuccess.ts

@@ -0,0 +1,22 @@
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IReflectType } from "./IReflectType";
+
+export interface ITypedHttpRouteSuccess {
+  type: IReflectType;
+  status: number | null;
+  contentType:
+    | "application/json"
+    | "text/plain"
+    | "application/x-www-form-urlencoded"
+    | "application/json"
+    | null;
+  encrypted: boolean;
+  metadata: Metadata;
+  example?: any;
+  examples?: Record<string, any>;
+  setHeaders: Array<
+    | { type: "setter"; source: string; target?: string }
+    | { type: "assigner"; source: string }
+  >;
+}

package/src/structures/ITypedWebSocketRoute.ts

@@ -1,68 +1,20 @@
+import { VERSION_NEUTRAL } from "@nestjs/common";
 import ts from "typescript";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
 import { IReflectController } from "./IReflectController";
-import { IReflectWebSocketOperation } from "./IReflectWebSocketOperation";
-import { ITypeTuple } from "./ITypeTuple";
+import { IReflectTypeImport } from "./IReflectTypeImport";
+import { ITypedWebSocketRouteParameter } from "./ITypedWebSocketRouteParameter";
 
 export interface ITypedWebSocketRoute {
   protocol: "websocket";
   controller: IReflectController;
   name: string;
   path: string;
-
   accessors: string[];
-  parameters: ITypedWebSocketRoute.IParameter[];
-  imports: [string, string[]][];
-
-  location: string;
-  description?: string;
+  function: Function;
+  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
+  parameters: ITypedWebSocketRouteParameter[];
+  imports: IReflectTypeImport[];
+  description: string | null;
   jsDocTags: ts.JSDocTagInfo[];
 }
-export namespace ITypedWebSocketRoute {
-  export type IParameter =
-    | IAcceptorParameter
-    | IDriverParameter
-    | IHeaderParameter
-    | IPathParameter
-    | IQueryParameter;
-  export interface IAcceptorParameter
-    extends Omit<IReflectWebSocketOperation.IParameter, "category"> {
-    category: "acceptor";
-    name: string;
-    header: ITypeTuple;
-    provider: ITypeTuple;
-    listener: ITypeTuple;
-  }
-  export interface IDriverParameter
-    extends Omit<IReflectWebSocketOperation.IParameter, "category"> {
-    category: "driver";
-    name: string;
-    type: ts.Type;
-    typeName: string;
-  }
-  export interface IHeaderParameter
-    extends Omit<IReflectWebSocketOperation.IParameter, "header"> {
-    category: "header";
-    name: string;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-  }
-  export interface IPathParameter
-    extends Omit<IReflectWebSocketOperation.IParameter, "path"> {
-    category: "param";
-    name: string;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-  }
-  export interface IQueryParameter
-    extends Omit<IReflectWebSocketOperation.IParameter, "query"> {
-    category: "query";
-    name: string;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-  }
-}

package/src/structures/ITypedWebSocketRouteParameter.ts

@@ -0,0 +1,3 @@
+import { IReflectWebSocketOperationParameter } from "./IReflectWebSocketOperationParameter";
+
+export import ITypedWebSocketRouteParameter = IReflectWebSocketOperationParameter;

package/src/transform.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+
+import { SdkTransformer } from "./transformers/SdkTransformer";
+
+export const transform = (
+  program: ts.Program,
+): ts.TransformerFactory<ts.SourceFile> =>
+  SdkTransformer.transformFile(program.getTypeChecker());
+export default transform;

package/src/transformers/IOperationMetadata.ts

@@ -0,0 +1,38 @@
+import { IJsDocTagInfo } from "typia";
+import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
+import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
+import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
+
+import { IReflectType } from "../structures/IReflectType";
+import { IReflectTypeImport } from "../structures/IReflectTypeImport";
+
+export interface IOperationMetadata {
+  parameters: IOperationMetadata.IParameter[];
+  success: IOperationMetadata.IResponse;
+  exceptions: Record<string, IOperationMetadata.IResponse>;
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+}
+export namespace IOperationMetadata {
+  export interface IParameter extends IResponse {
+    name: string;
+    index: number;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }
+  export interface IResponse {
+    type: IReflectType | null;
+    imports: IReflectTypeImport[];
+    primitive: ValidationPipe<ISchema, IError>;
+    resolved: ValidationPipe<ISchema, IError>;
+  }
+  export interface ISchema {
+    components: IMetadataComponents;
+    metadata: IMetadata;
+  }
+  export interface IError {
+    name: string;
+    accessor: string | null;
+    messages: string[];
+  }
+}

package/src/transformers/ISdkTransformerContext.ts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+
+export interface ISdkTransformerContext {
+  checker: ts.TypeChecker;
+  api: ts.TransformationContext;
+  collection: MetadataCollection;
+}