@nestia/sdk 3.1.0-dev.20240426 → 3.1.0-dev.20240430

package/src/generates/internal/SdkImportWizard.ts

@@ -1,55 +1,55 @@
-import { ImportDictionary } from "./ImportDictionary";
-
-export namespace SdkImportWizard {
-  export const Fetcher = (encrypted: boolean) =>
-    encrypted ? EncryptedFetcher : PlainFetcher;
-
-  export const HttpError = (importer: ImportDictionary) =>
-    importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "HttpError",
-    });
-
-  export const IConnection = (importer: ImportDictionary) =>
-    importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "IConnection",
-    });
-
-  export const Primitive = (importer: ImportDictionary) =>
-    importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "Primitive",
-    });
-
-  export const Resolved = (importer: ImportDictionary) =>
-    importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "Resolved",
-    });
-
-  export const typia = (importer: ImportDictionary) =>
-    importer.external({
-      type: false,
-      library: "typia",
-      instance: null,
-    });
-}
-
-const PlainFetcher = (importer: ImportDictionary) =>
-  importer.external({
-    type: false,
-    library: "@nestia/fetcher/lib/PlainFetcher",
-    instance: "PlainFetcher",
-  });
-
-const EncryptedFetcher = (importer: ImportDictionary) =>
-  importer.external({
-    type: false,
-    library: "@nestia/fetcher/lib/EncryptedFetcher",
-    instance: "EncryptedFetcher",
-  });
+import { ImportDictionary } from "./ImportDictionary";
+
+export namespace SdkImportWizard {
+  export const Fetcher = (encrypted: boolean) =>
+    encrypted ? EncryptedFetcher : PlainFetcher;
+
+  export const HttpError = (importer: ImportDictionary) =>
+    importer.external({
+      type: true,
+      library: "@nestia/fetcher",
+      instance: "HttpError",
+    });
+
+  export const IConnection = (importer: ImportDictionary) =>
+    importer.external({
+      type: true,
+      library: "@nestia/fetcher",
+      instance: "IConnection",
+    });
+
+  export const Primitive = (importer: ImportDictionary) =>
+    importer.external({
+      type: true,
+      library: "@nestia/fetcher",
+      instance: "Primitive",
+    });
+
+  export const Resolved = (importer: ImportDictionary) =>
+    importer.external({
+      type: true,
+      library: "@nestia/fetcher",
+      instance: "Resolved",
+    });
+
+  export const typia = (importer: ImportDictionary) =>
+    importer.external({
+      type: false,
+      library: "typia",
+      instance: null,
+    });
+}
+
+const PlainFetcher = (importer: ImportDictionary) =>
+  importer.external({
+    type: false,
+    library: "@nestia/fetcher/lib/PlainFetcher",
+    instance: "PlainFetcher",
+  });
+
+const EncryptedFetcher = (importer: ImportDictionary) =>
+  importer.external({
+    type: false,
+    library: "@nestia/fetcher/lib/EncryptedFetcher",
+    instance: "EncryptedFetcher",
+  });

package/src/generates/internal/SdkRouteDirectory.ts

@@ -1,18 +1,18 @@
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
-
-export class SdkRouteDirectory {
-  public readonly module: string;
-  public readonly children: Map<string, SdkRouteDirectory>;
-  public readonly routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>;
-
-  public constructor(
-    readonly parent: SdkRouteDirectory | null,
-    readonly name: string,
-  ) {
-    this.children = new Map();
-    this.routes = [];
-    this.module =
-      this.parent !== null ? `${this.parent.module}.${name}` : `api.${name}`;
-  }
-}
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+
+export class SdkRouteDirectory {
+  public readonly module: string;
+  public readonly children: Map<string, SdkRouteDirectory>;
+  public readonly routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>;
+
+  public constructor(
+    readonly parent: SdkRouteDirectory | null,
+    readonly name: string,
+  ) {
+    this.children = new Map();
+    this.routes = [];
+    this.module =
+      this.parent !== null ? `${this.parent.module}.${name}` : `api.${name}`;
+  }
+}

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -1,8 +1,10 @@
 import ts from "typescript";
+import { IJsDocTagInfo } from "typia";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
@@ -13,10 +15,49 @@ export namespace SdkWebSocketRouteProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedWebSocketRoute): ts.Statement[] => [
-      writeFunction(project)(importer)(route),
+      FilePrinter.description(
+        writeFunction(project)(importer)(route),
+        writeDescription(route),
+      ),
       SdkWebSocketNamespaceProgrammer.write(project)(importer)(route),
     ];
 
+  const writeDescription = (route: ITypedWebSocketRoute): string => {
+    // MAIN DESCRIPTION
+    const comments: string[] = route.description
+      ? route.description.split("\n")
+      : [];
+
+    // COMMENT TAGS
+    const tags: IJsDocTagInfo[] = route.jsDocTags.filter(
+      (tag) =>
+        tag.name !== "return" &&
+        tag.name !== "returns" &&
+        (tag.name !== "param" ||
+          route.parameters
+            .filter((p) => p.category === "param" || p.category === "query")
+            .some((p) => p.name === tag.text?.[0]?.text)),
+    );
+    if (tags.length !== 0) {
+      const content: string[] = tags.map((t) =>
+        t.text?.length
+          ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
+          : `@${t.name}`,
+      );
+      comments.push("", ...new Set(content));
+    }
+    comments.push("@returns Pair of connector and driver");
+
+    // POSTFIX
+    if (!!comments.length) comments.push("");
+    comments.push(
+      `@controller ${route.controller.name}.${route.name}`,
+      `@path ${route.path}`,
+      `@nestia Generated by Nestia - https://github.com/samchon/nestia`,
+    );
+    return comments.join("\n");
+  };
+
   const writeFunction =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>

package/src/generates/internal/SwaggerSchemaValidator.ts

@@ -1,198 +1,198 @@
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
-
-export namespace SwaggerSchemaValidator {
-  export const path = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = CoreMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-
-  export const query = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
-        insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("query parameters cannot be null.");
-      if (meta.isRequired() === false)
-        insert("query parameters cannot be undefined.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArray
-    ) {
-      const atomics = CoreMetadataUtil.atomics(meta);
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-      if (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.nullable) insert("nullable type is not allowed in array.");
-      if (meta.isRequired() === false)
-        insert("optional type is not allowed in array.");
-      if (meta.size() !== expected)
-        insert("only atomic or constant types are allowed in array.");
-    } else if (explore.object && explore.property !== null) {
-      //----
-      // COMMON
-      //----
-      // PROPERTY MUST BE SOLE
-      if (typeof explore.property === "object")
-        insert("dynamic property is not allowed.");
-      // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
-      // DO NOT ALLOW UNION TYPE
-      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
-      // DO NOT ALLOW NESTED OBJECT
-      if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
-      )
-        insert("nested object type is not allowed.");
-
-      //----
-      // ARRAY CASES
-      //----
-      const isArray: boolean = meta.arrays.length > 1 || meta.tuples.length > 1;
-      // ARRAY TYPE MUST BE REQUIRED
-      if (isArray && meta.isRequired() === false)
-        insert("optional type is not allowed when array.");
-      // SET-COOKIE MUST BE ARRAY
-      if (explore.property === "set-cookie" && !isArray)
-        insert("set-cookie property must be array.");
-    }
-    return errors;
-  };
-
-  export const headers = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
-        insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("headers cannot be null.");
-      if (meta.isRequired() === false) insert("headers cannot be null.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArray
-    ) {
-      const atomics = CoreMetadataUtil.atomics(meta);
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-      if (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.nullable) insert("nullable type is not allowed in array.");
-      if (meta.isRequired() === false) insert("optional type is not allowed.");
-      if (meta.size() !== expected)
-        insert("only atomic or constant types are allowed in array.");
-    } else if (explore.object && explore.property !== null) {
-      //----
-      // COMMON
-      //----
-      // PROPERTY MUST BE SOLE
-      if (typeof explore.property === "object")
-        insert("dynamic property is not allowed.");
-      // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
-      // DO NOT ALLOW UNION TYPE
-      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
-      // DO NOT ALLOW NESTED OBJECT
-      if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
-      )
-        insert("nested object type is not allowed.");
-      // DO NOT ALLOW NULLABLE
-      if (meta.nullable) insert("nullable type is not allowed.");
-
-      //----
-      // ARRAY CASES
-      //----
-      const isArray: boolean = meta.arrays.length > 1;
-      // ARRAY TYPE MUST BE REQUIRED
-      if (isArray && meta.isRequired() === false)
-        insert("optional type is not allowed when array.");
-      // SET-COOKIE MUST BE ARRAY
-      if (explore.property === "set-cookie" && !isArray)
-        insert("set-cookie property must be array.");
-      // MUST BE SINGULAR CASE
-      if (
-        typeof explore.property === "string" &&
-        SINGULAR.has(explore.property) &&
-        isArray
-      )
-        insert("property cannot be array.");
-    }
-    return errors;
-  };
-}
-
-namespace CoreMetadataUtil {
-  export const atomics = (
-    meta: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}
-
-const SINGULAR: Set<string> = new Set([
-  "age",
-  "authorization",
-  "content-length",
-  "content-type",
-  "etag",
-  "expires",
-  "from",
-  "host",
-  "if-modified-since",
-  "if-unmodified-since",
-  "last-modified",
-  "location",
-  "max-forwards",
-  "proxy-authorization",
-  "referer",
-  "retry-after",
-  "server",
-  "user-agent",
-]);
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
+
+export namespace SwaggerSchemaValidator {
+  export const path = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = CoreMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+
+  export const query = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      // TOP MUST BE ONLY OBJECT
+      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+        insert("only one object type is allowed.");
+      if (meta.nullable === true) insert("query parameters cannot be null.");
+      if (meta.isRequired() === false)
+        insert("query parameters cannot be undefined.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArray
+    ) {
+      const atomics = CoreMetadataUtil.atomics(meta);
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+      if (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.nullable) insert("nullable type is not allowed in array.");
+      if (meta.isRequired() === false)
+        insert("optional type is not allowed in array.");
+      if (meta.size() !== expected)
+        insert("only atomic or constant types are allowed in array.");
+    } else if (explore.object && explore.property !== null) {
+      //----
+      // COMMON
+      //----
+      // PROPERTY MUST BE SOLE
+      if (typeof explore.property === "object")
+        insert("dynamic property is not allowed.");
+      // DO NOT ALLOW TUPLE TYPE
+      if (meta.tuples.length) insert("tuple type is not allowed.");
+      // DO NOT ALLOW UNION TYPE
+      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      // DO NOT ALLOW NESTED OBJECT
+      if (
+        meta.objects.length ||
+        meta.sets.length ||
+        meta.maps.length ||
+        meta.natives.length
+      )
+        insert("nested object type is not allowed.");
+
+      //----
+      // ARRAY CASES
+      //----
+      const isArray: boolean = meta.arrays.length > 1 || meta.tuples.length > 1;
+      // ARRAY TYPE MUST BE REQUIRED
+      if (isArray && meta.isRequired() === false)
+        insert("optional type is not allowed when array.");
+      // SET-COOKIE MUST BE ARRAY
+      if (explore.property === "set-cookie" && !isArray)
+        insert("set-cookie property must be array.");
+    }
+    return errors;
+  };
+
+  export const headers = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      // TOP MUST BE ONLY OBJECT
+      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+        insert("only one object type is allowed.");
+      if (meta.nullable === true) insert("headers cannot be null.");
+      if (meta.isRequired() === false) insert("headers cannot be null.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArray
+    ) {
+      const atomics = CoreMetadataUtil.atomics(meta);
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+      if (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.nullable) insert("nullable type is not allowed in array.");
+      if (meta.isRequired() === false) insert("optional type is not allowed.");
+      if (meta.size() !== expected)
+        insert("only atomic or constant types are allowed in array.");
+    } else if (explore.object && explore.property !== null) {
+      //----
+      // COMMON
+      //----
+      // PROPERTY MUST BE SOLE
+      if (typeof explore.property === "object")
+        insert("dynamic property is not allowed.");
+      // DO NOT ALLOW TUPLE TYPE
+      if (meta.tuples.length) insert("tuple type is not allowed.");
+      // DO NOT ALLOW UNION TYPE
+      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      // DO NOT ALLOW NESTED OBJECT
+      if (
+        meta.objects.length ||
+        meta.sets.length ||
+        meta.maps.length ||
+        meta.natives.length
+      )
+        insert("nested object type is not allowed.");
+      // DO NOT ALLOW NULLABLE
+      if (meta.nullable) insert("nullable type is not allowed.");
+
+      //----
+      // ARRAY CASES
+      //----
+      const isArray: boolean = meta.arrays.length > 1;
+      // ARRAY TYPE MUST BE REQUIRED
+      if (isArray && meta.isRequired() === false)
+        insert("optional type is not allowed when array.");
+      // SET-COOKIE MUST BE ARRAY
+      if (explore.property === "set-cookie" && !isArray)
+        insert("set-cookie property must be array.");
+      // MUST BE SINGULAR CASE
+      if (
+        typeof explore.property === "string" &&
+        SINGULAR.has(explore.property) &&
+        isArray
+      )
+        insert("property cannot be array.");
+    }
+    return errors;
+  };
+}
+
+namespace CoreMetadataUtil {
+  export const atomics = (
+    meta: Metadata,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...meta.atomics.map((a) => a.type),
+      ...meta.constants.map((c) => c.type),
+      ...(meta.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (meta: Metadata): boolean =>
+    atomics(meta).size +
+      meta.arrays.length +
+      meta.tuples.length +
+      meta.natives.length +
+      meta.maps.length +
+      meta.objects.length >
+    1;
+}
+
+const SINGULAR: Set<string> = new Set([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "server",
+  "user-agent",
+]);

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as nestia from "./module";
-
-export * from "./module";
-export default nestia;
+import * as nestia from "./module";
+
+export * from "./module";
+export default nestia;

package/src/module.ts

@@ -1,2 +1,2 @@
-export * from "./INestiaConfig";
-export * from "./NestiaSdkApplication";
+export * from "./INestiaConfig";
+export * from "./NestiaSdkApplication";

package/src/structures/IErrorReport.ts

@@ -1,6 +1,6 @@
-export interface IErrorReport {
-  file: string;
-  controller: string;
-  function: string | null;
-  message: string;
-}
+export interface IErrorReport {
+  file: string;
+  controller: string;
+  function: string | null;
+  message: string;
+}

package/src/structures/INestiaProject.ts

@@ -1,13 +1,13 @@
-import ts from "typescript";
-
-import { INestiaConfig } from "../INestiaConfig";
-import { IErrorReport } from "./IErrorReport";
-import { INormalizedInput } from "./INormalizedInput";
-
-export interface INestiaProject {
-  config: INestiaConfig;
-  input: INormalizedInput;
-  checker: ts.TypeChecker;
-  errors: IErrorReport[];
-  warnings: IErrorReport[];
-}
+import ts from "typescript";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { IErrorReport } from "./IErrorReport";
+import { INormalizedInput } from "./INormalizedInput";
+
+export interface INestiaProject {
+  config: INestiaConfig;
+  input: INormalizedInput;
+  checker: ts.TypeChecker;
+  errors: IErrorReport[];
+  warnings: IErrorReport[];
+}