@nestia/sdk 6.0.6 → 7.0.0-dev.20250605

package/src/transformers/SdkOperationTransformer.ts

@@ -1,253 +1,253 @@
-import path from "path";
-import { HashSet, Singleton, hash } from "tstl";
-import ts from "typescript";
-import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
-
-import { GenericAnalyzer } from "../analyses/GenericAnalyzer";
-import { IOperationMetadata } from "./IOperationMetadata";
-import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
-import { SdkOperationProgrammer } from "./SdkOperationProgrammer";
-
-export namespace SdkOperationTransformer {
-  export const iterateFile =
-    (checker: ts.TypeChecker) => (api: ts.TransformationContext) => {
-      const context: ISdkOperationTransformerContext = {
-        checker,
-        transformer: api,
-        collection: collection.get(),
-      };
-      return (file: ts.SourceFile): ts.SourceFile => {
-        if (file.isDeclarationFile === true) return file;
-        const visitor: IVisitor = {
-          done: false,
-          visited: new HashSet(),
-        };
-        file = ts.visitEachChild(
-          file,
-          (node) =>
-            iterateNode({
-              context,
-              visitor,
-              node,
-            }),
-          api,
-        );
-        if (visitor.done === false) return file;
-        return ts.factory.updateSourceFile(file, [
-          ts.factory.createImportDeclaration(
-            undefined,
-            ts.factory.createImportClause(
-              false,
-              undefined,
-              ts.factory.createNamespaceImport(
-                ts.factory.createIdentifier("__OperationMetadata"),
-              ),
-            ),
-            ts.factory.createStringLiteral(
-              "@nestia/sdk/lib/decorators/OperationMetadata",
-            ),
-            undefined,
-          ),
-          ...file.statements,
-        ]);
-      };
-    };
-
-  interface IVisitor {
-    done: boolean;
-    visited: HashSet<MethodKey>;
-  }
-
-  const iterateNode = (props: {
-    context: ISdkOperationTransformerContext;
-    visitor: IVisitor;
-    node: ts.Node;
-  }): ts.Node =>
-    ts.visitEachChild(
-      transformNode(props),
-      (child) =>
-        iterateNode({
-          ...props,
-          node: child,
-        }),
-      props.context.transformer,
-    );
-
-  const transformNode = (props: {
-    context: ISdkOperationTransformerContext;
-    visitor: IVisitor;
-    node: ts.Node;
-  }): ts.Node => {
-    return ts.isClassDeclaration(props.node)
-      ? transformClass({
-          ...props,
-          node: props.node,
-        })
-      : props.node;
-  };
-
-  const transformClass = (props: {
-    context: ISdkOperationTransformerContext;
-    visitor: IVisitor;
-    node: ts.ClassDeclaration;
-  }): ts.ClassDeclaration => {
-    const generics: WeakMap<ts.Type, ts.Type> = GenericAnalyzer.analyze(
-      props.context.checker,
-      props.node,
-    );
-
-    // TO AVOID COMMENT COMPILATION BUG
-    const symbolDict: Map<string, ts.Symbol> = new Map();
-    const classType: ts.InterfaceType = props.context.checker.getTypeAtLocation(
-      props.node,
-    ) as ts.InterfaceType;
-    for (const symbol of classType.getProperties()) {
-      const declaration: ts.Declaration | undefined = (symbol.declarations ||
-        [])[0];
-      if (!declaration || !ts.isMethodDeclaration(declaration)) continue;
-      const identifier = declaration.name;
-      if (!ts.isIdentifier(identifier)) continue;
-      symbolDict.set(identifier.escapedText.toString(), symbol);
-    }
-    return ts.factory.updateClassDeclaration(
-      props.node,
-      props.node.modifiers,
-      props.node.name,
-      props.node.typeParameters,
-      props.node.heritageClauses,
-      props.node.members.map((m) =>
-        ts.isMethodDeclaration(m)
-          ? transformMethod({
-              ...props,
-              generics,
-              class: props.node,
-              node: m,
-              symbol: symbolDict.get(m.name.getText()),
-            })
-          : m,
-      ),
-    );
-  };
-
-  const transformMethod = (props: {
-    context: ISdkOperationTransformerContext;
-    visitor: IVisitor;
-    class: ts.ClassDeclaration;
-    generics: WeakMap<ts.Type, ts.Type>;
-    node: ts.MethodDeclaration;
-    symbol: ts.Symbol | undefined;
-  }): ts.MethodDeclaration => {
-    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-      ? ts.getDecorators(props.node)
-      : (props.node as any).decorators;
-    if (!decorators?.length) return props.node;
-
-    const key: MethodKey = new MethodKey(
-      props.class.name?.getText() ?? "",
-      props.node.name.getText(),
-    );
-    props.visitor.done ||= true;
-    if (props.visitor.visited.has(key)) return props.node;
-    else props.visitor.visited.insert(key);
-
-    const metadata: IOperationMetadata = SdkOperationProgrammer.write({
-      ...props,
-      exceptions: getExceptionTypes({
-        checker: props.context.checker,
-        decorators,
-      }),
-    });
-    return ts.factory.updateMethodDeclaration(
-      props.node,
-      [
-        ...(props.node.modifiers ?? []),
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              "__OperationMetadata.OperationMetadata",
-            ),
-            undefined,
-            [
-              ts.factory.createAsExpression(
-                LiteralFactory.write(metadata),
-                TypeFactory.keyword("any"),
-              ),
-            ],
-          ),
-        ),
-      ],
-      props.node.asteriskToken,
-      props.node.name,
-      props.node.questionToken,
-      props.node.typeParameters,
-      props.node.parameters,
-      props.node.type,
-      props.node.body,
-    );
-  };
-
-  const getExceptionTypes = (props: {
-    checker: ts.TypeChecker;
-    decorators: readonly ts.Decorator[];
-  }) =>
-    props.decorators
-      .map((deco) => {
-        if (false === ts.isCallExpression(deco.expression)) return null;
-
-        const signature: ts.Signature | undefined =
-          props.checker.getResolvedSignature(deco.expression);
-        if (signature === undefined) return null;
-        else if (!signature.declaration) return null;
-
-        const location: string = path.resolve(
-          signature.declaration.getSourceFile()?.fileName ?? "",
-        );
-        if (
-          location.includes(TYPED_EXCEPTION_LIB_PATH) === false &&
-          location.includes(TYPED_EXCEPTION_MONO_PATH) === false
-        )
-          return null;
-        else if (deco.expression.typeArguments?.length !== 1) return null;
-        return deco.expression.typeArguments[0];
-      })
-      .filter((t) => t !== null);
-}
-
-class MethodKey {
-  public constructor(
-    public readonly className: string,
-    public readonly methodName: string,
-  ) {}
-
-  public equals(o: MethodKey): boolean {
-    return this.className === o.className && this.methodName === o.methodName;
-  }
-
-  public hashCode(): number {
-    return hash(this.className, this.methodName);
-  }
-}
-
-const TYPED_EXCEPTION_LIB_PATH = path.join(
-  "@nestia",
-  "core",
-  "lib",
-  "decorators",
-  `TypedException.d.ts`,
-);
-const TYPED_EXCEPTION_MONO_PATH = path.join(
-  "packages",
-  "core",
-  "lib",
-  "decorators",
-  `TypedException.d.ts`,
-);
-
-const collection = new Singleton(
-  () =>
-    new MetadataCollection({
-      replace: MetadataCollection.replace,
-    }),
-);
+import path from "path";
+import { HashSet, Singleton, hash } from "tstl";
+import ts from "typescript";
+import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+
+import { GenericAnalyzer } from "../analyses/GenericAnalyzer";
+import { IOperationMetadata } from "./IOperationMetadata";
+import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
+import { SdkOperationProgrammer } from "./SdkOperationProgrammer";
+
+export namespace SdkOperationTransformer {
+  export const iterateFile =
+    (checker: ts.TypeChecker) => (api: ts.TransformationContext) => {
+      const context: ISdkOperationTransformerContext = {
+        checker,
+        transformer: api,
+        collection: collection.get(),
+      };
+      return (file: ts.SourceFile): ts.SourceFile => {
+        if (file.isDeclarationFile === true) return file;
+        const visitor: IVisitor = {
+          done: false,
+          visited: new HashSet(),
+        };
+        file = ts.visitEachChild(
+          file,
+          (node) =>
+            iterateNode({
+              context,
+              visitor,
+              node,
+            }),
+          api,
+        );
+        if (visitor.done === false) return file;
+        return ts.factory.updateSourceFile(file, [
+          ts.factory.createImportDeclaration(
+            undefined,
+            ts.factory.createImportClause(
+              false,
+              undefined,
+              ts.factory.createNamespaceImport(
+                ts.factory.createIdentifier("__OperationMetadata"),
+              ),
+            ),
+            ts.factory.createStringLiteral(
+              "@nestia/sdk/lib/decorators/OperationMetadata",
+            ),
+            undefined,
+          ),
+          ...file.statements,
+        ]);
+      };
+    };
+
+  interface IVisitor {
+    done: boolean;
+    visited: HashSet<MethodKey>;
+  }
+
+  const iterateNode = (props: {
+    context: ISdkOperationTransformerContext;
+    visitor: IVisitor;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.visitEachChild(
+      transformNode(props),
+      (child) =>
+        iterateNode({
+          ...props,
+          node: child,
+        }),
+      props.context.transformer,
+    );
+
+  const transformNode = (props: {
+    context: ISdkOperationTransformerContext;
+    visitor: IVisitor;
+    node: ts.Node;
+  }): ts.Node => {
+    return ts.isClassDeclaration(props.node)
+      ? transformClass({
+          ...props,
+          node: props.node,
+        })
+      : props.node;
+  };
+
+  const transformClass = (props: {
+    context: ISdkOperationTransformerContext;
+    visitor: IVisitor;
+    node: ts.ClassDeclaration;
+  }): ts.ClassDeclaration => {
+    const generics: WeakMap<ts.Type, ts.Type> = GenericAnalyzer.analyze(
+      props.context.checker,
+      props.node,
+    );
+
+    // TO AVOID COMMENT COMPILATION BUG
+    const symbolDict: Map<string, ts.Symbol> = new Map();
+    const classType: ts.InterfaceType = props.context.checker.getTypeAtLocation(
+      props.node,
+    ) as ts.InterfaceType;
+    for (const symbol of classType.getProperties()) {
+      const declaration: ts.Declaration | undefined = (symbol.declarations ||
+        [])[0];
+      if (!declaration || !ts.isMethodDeclaration(declaration)) continue;
+      const identifier = declaration.name;
+      if (!ts.isIdentifier(identifier)) continue;
+      symbolDict.set(identifier.escapedText.toString(), symbol);
+    }
+    return ts.factory.updateClassDeclaration(
+      props.node,
+      props.node.modifiers,
+      props.node.name,
+      props.node.typeParameters,
+      props.node.heritageClauses,
+      props.node.members.map((m) =>
+        ts.isMethodDeclaration(m)
+          ? transformMethod({
+              ...props,
+              generics,
+              class: props.node,
+              node: m,
+              symbol: symbolDict.get(m.name.getText()),
+            })
+          : m,
+      ),
+    );
+  };
+
+  const transformMethod = (props: {
+    context: ISdkOperationTransformerContext;
+    visitor: IVisitor;
+    class: ts.ClassDeclaration;
+    generics: WeakMap<ts.Type, ts.Type>;
+    node: ts.MethodDeclaration;
+    symbol: ts.Symbol | undefined;
+  }): ts.MethodDeclaration => {
+    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+      ? ts.getDecorators(props.node)
+      : (props.node as any).decorators;
+    if (!decorators?.length) return props.node;
+
+    const key: MethodKey = new MethodKey(
+      props.class.name?.getText() ?? "",
+      props.node.name.getText(),
+    );
+    props.visitor.done ||= true;
+    if (props.visitor.visited.has(key)) return props.node;
+    else props.visitor.visited.insert(key);
+
+    const metadata: IOperationMetadata = SdkOperationProgrammer.write({
+      ...props,
+      exceptions: getExceptionTypes({
+        checker: props.context.checker,
+        decorators,
+      }),
+    });
+    return ts.factory.updateMethodDeclaration(
+      props.node,
+      [
+        ...(props.node.modifiers ?? []),
+        ts.factory.createDecorator(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+              "__OperationMetadata.OperationMetadata",
+            ),
+            undefined,
+            [
+              ts.factory.createAsExpression(
+                LiteralFactory.write(metadata),
+                TypeFactory.keyword("any"),
+              ),
+            ],
+          ),
+        ),
+      ],
+      props.node.asteriskToken,
+      props.node.name,
+      props.node.questionToken,
+      props.node.typeParameters,
+      props.node.parameters,
+      props.node.type,
+      props.node.body,
+    );
+  };
+
+  const getExceptionTypes = (props: {
+    checker: ts.TypeChecker;
+    decorators: readonly ts.Decorator[];
+  }) =>
+    props.decorators
+      .map((deco) => {
+        if (false === ts.isCallExpression(deco.expression)) return null;
+
+        const signature: ts.Signature | undefined =
+          props.checker.getResolvedSignature(deco.expression);
+        if (signature === undefined) return null;
+        else if (!signature.declaration) return null;
+
+        const location: string = path.resolve(
+          signature.declaration.getSourceFile()?.fileName ?? "",
+        );
+        if (
+          location.includes(TYPED_EXCEPTION_LIB_PATH) === false &&
+          location.includes(TYPED_EXCEPTION_MONO_PATH) === false
+        )
+          return null;
+        else if (deco.expression.typeArguments?.length !== 1) return null;
+        return deco.expression.typeArguments[0];
+      })
+      .filter((t) => t !== null);
+}
+
+class MethodKey {
+  public constructor(
+    public readonly className: string,
+    public readonly methodName: string,
+  ) {}
+
+  public equals(o: MethodKey): boolean {
+    return this.className === o.className && this.methodName === o.methodName;
+  }
+
+  public hashCode(): number {
+    return hash(this.className, this.methodName);
+  }
+}
+
+const TYPED_EXCEPTION_LIB_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `TypedException.d.ts`,
+);
+const TYPED_EXCEPTION_MONO_PATH = path.join(
+  "packages",
+  "core",
+  "lib",
+  "decorators",
+  `TypedException.d.ts`,
+);
+
+const collection = new Singleton(
+  () =>
+    new MetadataCollection({
+      replace: MetadataCollection.replace,
+    }),
+);

package/src/transformers/TextPlainValidator.ts

@@ -1,17 +1,17 @@
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-export namespace TextPlainValidator {
-  export const validate = (metadata: Metadata): string[] => {
-    const expected: number =
-      metadata.atomics.filter((a) => a.type === "string").length +
-      metadata.constants
-        .filter((c) => c.type === "string")
-        .map((c) => c.values.length)
-        .reduce((a, b) => a + b, 0) +
-      metadata.templates.length +
-      metadata.natives.filter((n) => n.name === "String").length;
-    if (metadata.size() === 0 || metadata.size() !== expected)
-      return [`Only string type is allowed in the "text/plain" content type.`];
-    return [];
-  };
-}
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export namespace TextPlainValidator {
+  export const validate = (metadata: Metadata): string[] => {
+    const expected: number =
+      metadata.atomics.filter((a) => a.type === "string").length +
+      metadata.constants
+        .filter((c) => c.type === "string")
+        .map((c) => c.values.length)
+        .reduce((a, b) => a + b, 0) +
+      metadata.templates.length +
+      metadata.natives.filter((n) => n.name === "String").length;
+    if (metadata.size() === 0 || metadata.size() !== expected)
+      return [`Only string type is allowed in the "text/plain" content type.`];
+    return [];
+  };
+}

package/src/typings/get-function-location.d.ts

@@ -1,7 +1,7 @@
-declare module "get-function-location" {
-  export default function (func: any): Promise<{
-    source: string;
-    line: number;
-    column: number;
-  }>;
-}
+declare module "get-function-location" {
+  export default function (func: any): Promise<{
+    source: string;
+    line: number;
+    column: number;
+  }>;
+}

package/src/utils/ArrayUtil.ts

@@ -1,26 +1,26 @@
-export namespace ArrayUtil {
-  export function has<T>(array: T[], ...items: T[]): boolean {
-    return items.every(
-      (elem) => array.find((org) => org === elem) !== undefined,
-    );
-  }
-
-  export async function asyncMap<Input, Output>(
-    array: Input[],
-    closure: (input: Input) => Promise<Output>,
-  ): Promise<Output[]> {
-    const ret: Output[] = [];
-    for (const elem of array) ret.push(await closure(elem));
-    return ret;
-  }
-
-  export async function asyncFilter<Input>(
-    array: Input[],
-    closure: (input: Input) => Promise<boolean>,
-  ): Promise<Input[]> {
-    const ret: Input[] = [];
-    for (const elem of array)
-      if ((await closure(elem)) === true) ret.push(elem);
-    return ret;
-  }
-}
+export namespace ArrayUtil {
+  export function has<T>(array: T[], ...items: T[]): boolean {
+    return items.every(
+      (elem) => array.find((org) => org === elem) !== undefined,
+    );
+  }
+
+  export async function asyncMap<X, Y>(
+    array: X[],
+    closure: (input: X) => Promise<Y>,
+  ): Promise<Y[]> {
+    const ret: Y[] = [];
+    for (const elem of array) ret.push(await closure(elem));
+    return ret;
+  }
+
+  export async function asyncFilter<T>(
+    array: T[],
+    closure: (input: T) => Promise<boolean>,
+  ): Promise<T[]> {
+    const ret: T[] = [];
+    for (const elem of array)
+      if ((await closure(elem)) === true) ret.push(elem);
+    return ret;
+  }
+}

package/src/utils/FileRetriever.ts

@@ -1,22 +1,22 @@
-import fs from "fs";
-import path from "path";
-
-export namespace FileRetriever {
-  export const directory =
-    (name: string) =>
-    (dir: string, depth: number = 0): string | null => {
-      const location: string = path.join(dir, name);
-      if (fs.existsSync(location)) return dir;
-      else if (depth > 2) return null;
-      return directory(name)(path.join(dir, ".."), depth + 1);
-    };
-
-  export const file =
-    (name: string) =>
-    (directory: string, depth: number = 0): string | null => {
-      const location: string = path.join(directory, name);
-      if (fs.existsSync(location)) return location;
-      else if (depth > 2) return null;
-      return file(name)(path.join(directory, ".."), depth + 1);
-    };
-}
+import fs from "fs";
+import path from "path";
+
+export namespace FileRetriever {
+  export const directory =
+    (name: string) =>
+    (dir: string, depth: number = 0): string | null => {
+      const location: string = path.join(dir, name);
+      if (fs.existsSync(location)) return dir;
+      else if (depth > 2) return null;
+      return directory(name)(path.join(dir, ".."), depth + 1);
+    };
+
+  export const file =
+    (name: string) =>
+    (directory: string, depth: number = 0): string | null => {
+      const location: string = path.join(directory, name);
+      if (fs.existsSync(location)) return location;
+      else if (depth > 2) return null;
+      return file(name)(path.join(directory, ".."), depth + 1);
+    };
+}