@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/analyses/DtoAnalyzer.ts

@@ -1,260 +0,0 @@
-import ts from "typescript";
-
-import { IReflectImport } from "../structures/IReflectImport";
-import { IReflectType } from "../structures/IReflectType";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-
-export namespace DtoAnalyzer {
-  export interface INodeProps {
-    checker: ts.TypeChecker;
-    imports: IReflectImport[];
-    typeNode: ts.TypeNode;
-  }
-  export interface ITypeProps {
-    checker: ts.TypeChecker;
-    imports: IReflectImport[];
-    type: ts.Type;
-  }
-  export interface IOutput {
-    imports: IReflectImport[];
-    type: IReflectType;
-  }
-
-  export const analyzeNode = (props: INodeProps): IOutput | null => {
-    try {
-      const container: IReflectImport[] = [];
-      const type: IReflectType = exploreNode(
-        {
-          checker: props.checker,
-          imports: props.imports,
-          container,
-        },
-        props.typeNode,
-      );
-      return {
-        type,
-        imports: ImportAnalyzer.merge(container),
-      };
-    } catch {
-      return null;
-    }
-  };
-
-  export const analyzeType = (props: ITypeProps): IOutput | null => {
-    try {
-      const container: IReflectImport[] = [];
-      const type: IReflectType = exploreType(
-        {
-          checker: props.checker,
-          imports: props.imports,
-          container,
-        },
-        props.type,
-      );
-      return {
-        type,
-        imports: ImportAnalyzer.merge(container),
-      };
-    } catch {
-      return null;
-    }
-  };
-
-  type IContext = Omit<INodeProps, "typeNode"> & {
-    container: IReflectImport[];
-  };
-
-  const exploreNode = (ctx: IContext, typeNode: ts.TypeNode): IReflectType => {
-    // Analyze symbol, and take special cares
-    if (ts.isIntersectionTypeNode(typeNode))
-      return {
-        name: typeNode.types
-          .map((child) => exploreNode(ctx, child))
-          .map(getEscapedText)
-          .join(" & "),
-      };
-    else if (ts.isUnionTypeNode(typeNode))
-      return {
-        name: typeNode.types
-          .map((child) => exploreNode(ctx, child))
-          .map(getEscapedText)
-          .join(" | "),
-      };
-    else if (ts.isArrayTypeNode(typeNode)) {
-      const element: IReflectType = exploreNode(ctx, typeNode.elementType);
-      return {
-        name: "Array",
-        typeArguments: [element],
-      };
-    } else if (ts.isParenthesizedTypeNode(typeNode))
-      return {
-        name: `(${exploreNode(ctx, typeNode.type).name})`,
-      };
-    else if (ts.isTypeOperatorNode(typeNode)) {
-      const prefix: string | null =
-        typeNode.operator === ts.SyntaxKind.KeyOfKeyword
-          ? "keyof"
-          : typeNode.operator === ts.SyntaxKind.UniqueKeyword
-            ? "unique"
-            : typeNode.operator === ts.SyntaxKind.ReadonlyKeyword
-              ? "readonly"
-              : null;
-      if (prefix === null)
-        return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
-      return {
-        name: `${prefix} ${exploreNode(ctx, typeNode.type).name}`,
-      };
-    } else if (ts.isTypePredicateNode(typeNode) || ts.isTypeQueryNode(typeNode))
-      return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
-    else if (ts.isTypeReferenceNode(typeNode) === false)
-      return {
-        name: typeNode.getText(),
-      };
-
-    // Find matched import statement
-    const name: string = typeNode.typeName.getText();
-    const prefix: string = name.split(".")[0]!;
-
-    let matched: boolean = false;
-    const insert = (imp: IReflectImport): void => {
-      matched ||= true;
-      ctx.container.push(imp);
-    };
-    for (const imp of ctx.imports)
-      if (prefix === imp.default)
-        insert({
-          file: imp.file,
-          asterisk: null,
-          default: prefix,
-          elements: [],
-        });
-      else if (prefix === imp.asterisk)
-        insert({
-          file: imp.file,
-          asterisk: prefix,
-          default: null,
-          elements: [],
-        });
-      else if (imp.elements.includes(prefix))
-        insert({
-          file: imp.file,
-          asterisk: null,
-          default: null,
-          elements: [prefix],
-        });
-    if (prefix !== "Promise" && matched === false)
-      return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
-
-    // Finalize with generic arguments
-    if (!!typeNode.typeArguments?.length) {
-      const top: ts.TypeNode = typeNode.typeArguments[0]!;
-      if (name === "Promise") return exploreNode(ctx, top);
-      return {
-        name,
-        typeArguments: typeNode.typeArguments.map((child) =>
-          exploreNode(ctx, child),
-        ),
-      };
-    }
-    return { name };
-  };
-
-  const exploreType = (ctx: IContext, type: ts.Type): IReflectType => {
-    // Analyze symbol, and take special cares
-    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.symbol;
-    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-      const joiner: string = type.isIntersection() ? " & " : " | ";
-      return {
-        name: type.types
-          .map((child) => exploreType(ctx, child))
-          .map(getEscapedText)
-          .join(joiner),
-      };
-    } else if (ctx.checker.isArrayLikeType(type)) {
-      const arrayItem: ts.Type | undefined =
-        ctx.checker.getElementTypeOfArrayType(type);
-      if (arrayItem === undefined) return { name: "Array<any>" };
-      return {
-        name: "Array",
-        typeArguments: [exploreType(ctx, arrayItem)],
-      };
-    } else if (symbol === undefined)
-      return {
-        name: ctx.checker.typeToString(
-          type,
-          undefined,
-          ts.TypeFormatFlags.NoTruncation,
-        ),
-      };
-
-    // Find matched import statement
-    const name: string = getNameOfSymbol(symbol);
-    const prefix: string = name.split(".")[0]!;
-
-    let matched: boolean = false;
-    const insert = (imp: IReflectImport): void => {
-      matched ||= true;
-      ctx.container.push(imp);
-    };
-    for (const imp of ctx.imports)
-      if (imp.elements.includes(prefix))
-        insert({
-          file: imp.file,
-          asterisk: null,
-          default: null,
-          elements: [prefix],
-        });
-    if (prefix !== "Promise" && matched === false)
-      emplaceSymbol(ctx, symbol, prefix);
-
-    // Finalize with generic arguments
-    const generic: readonly ts.Type[] = type.aliasSymbol
-      ? (type.aliasTypeArguments ?? [])
-      : ctx.checker.getTypeArguments(type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? exploreType(ctx, generic[0]!)
-        : {
-            name,
-            typeArguments: generic.map((child) => exploreType(ctx, child)),
-          }
-      : { name };
-  };
-
-  const emplaceSymbol = (
-    ctx: IContext,
-    symbol: ts.Symbol,
-    prefix: string,
-  ): void => {
-    // GET SOURCE FILE
-    const sourceFile: ts.SourceFile | undefined =
-      symbol.declarations?.[0]?.getSourceFile();
-    if (sourceFile === undefined) return;
-    if (sourceFile.fileName.indexOf("/typescript/lib") === -1)
-      ctx.container.push({
-        file: sourceFile.fileName,
-        asterisk: null,
-        default: null,
-        elements: [prefix],
-      });
-  };
-}
-
-const getEscapedText = (type: IReflectType): string =>
-  type.typeArguments
-    ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
-    : type.name;
-
-const getNameOfSymbol = (symbol: ts.Symbol): string =>
-  exploreName(
-    symbol.escapedName.toString(),
-    symbol.getDeclarations()?.[0]?.parent,
-  );
-
-const exploreName = (name: string, decl?: ts.Node): string =>
-  decl && ts.isModuleBlock(decl)
-    ? exploreName(
-        `${decl.parent.name.getFullText().trim()}.${name}`,
-        decl.parent.parent,
-      )
-    : name;

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,154 +0,0 @@
-// import path from "path";
-// import ts from "typescript";
-// import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-// import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-// import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-// import { INestiaProject } from "../structures/INestiaProject";
-// import { IReflectController } from "../structures/IReflectController";
-// import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-// import { ITypeTuple } from "../structures/ITypeTuple";
-// import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-// import { GenericAnalyzer } from "./GenericAnalyzer";
-// import { ImportAnalyzer } from "./ImportAnalyzer";
-
-// export namespace ExceptionAnalyzer {
-//   export const analyze =
-//     (project: INestiaProject) =>
-//     (props: {
-//       generics: GenericAnalyzer.Dictionary;
-//       imports: ImportAnalyzer.Dictionary;
-//       controller: IReflectController;
-//       operation: IReflectHttpOperation;
-//       declaration: ts.MethodDeclaration;
-//     }): Record<
-//       number | "2XX" | "3XX" | "4XX" | "5XX",
-//       ITypedHttpRoute.IOutput
-//     > => {
-//       const output: Record<
-//         number | "2XX" | "3XX" | "4XX" | "5XX",
-//         ITypedHttpRoute.IOutput
-//       > = {} as any;
-//       for (const decorator of props.declaration.modifiers ?? [])
-//         if (ts.isDecorator(decorator))
-//           analyzeTyped(project)({
-//             ...props,
-//             output,
-//             decorator,
-//           });
-//       return output;
-//     };
-
-//   const analyzeTyped =
-//     (project: INestiaProject) =>
-//     (props: {
-//       generics: GenericAnalyzer.Dictionary;
-//       imports: ImportAnalyzer.Dictionary;
-//       controller: IReflectController;
-//       operation: IReflectHttpOperation;
-//       output: Record<
-//         number | "2XX" | "3XX" | "4XX" | "5XX",
-//         ITypedHttpRoute.IOutput
-//       >;
-//       decorator: ts.Decorator;
-//     }): boolean => {
-//       // CHECK DECORATOR
-//       if (!ts.isCallExpression(props.decorator.expression)) return false;
-//       else if ((props.decorator.expression.typeArguments ?? []).length !== 1)
-//         return false;
-
-//       // CHECK SIGNATURE
-//       const signature: ts.Signature | undefined =
-//         project.checker.getResolvedSignature(props.decorator.expression);
-//       if (!signature || !signature.declaration) return false;
-//       else if (
-//         path
-//           .resolve(signature.declaration.getSourceFile().fileName)
-//           .indexOf(TYPED_EXCEPTION_PATH) === -1
-//       )
-//         return false;
-
-//       // GET TYPE INFO
-//       const status: string | null = getStatus(project.checker)(
-//         props.decorator.expression.arguments[0] ?? null,
-//       );
-//       if (status === null) return false;
-
-//       const node: ts.TypeNode = props.decorator.expression.typeArguments![0];
-//       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-//       if (type.isTypeParameter()) {
-//         project.errors.push({
-//           file: props.controller.file,
-//           controller: props.controller.name,
-//           function: props.operation.name,
-//           message: "TypedException() without generic argument specification.",
-//         });
-//         return false;
-//       }
-
-//       const tuple: ITypeTuple | null = ImportAnalyzer.analyze(project.checker)({
-//         generics: props.generics,
-//         imports: props.imports,
-//         type,
-//       });
-//       if (tuple === null) {
-//         project.errors.push({
-//           file: props.controller.file,
-//           controller: props.controller.name,
-//           function: props.operation.name,
-//           message: `TypeException() with unknown type on ${status} status.`,
-//         });
-//         return false;
-//       }
-
-//       // DO ASSIGN
-//       const matched: IReflectHttpOperation.IException[] = Object.entries(
-//         props.operation.exceptions,
-//       )
-//         .filter(([key]) => status === key)
-//         .map(([_key, value]) => value);
-//       for (const m of matched)
-//         props.output[m.status] = {
-//           type: tuple.type,
-//           typeName: tuple.typeName,
-//           contentType: "application/json",
-//           description: m.description,
-//         };
-//       return true;
-//     };
-
-//   const getStatus =
-//     (checker: ts.TypeChecker) =>
-//     (expression: ts.Expression | null): string | null => {
-//       if (expression === null) return null;
-
-//       const type: ts.Type = checker.getTypeAtLocation(expression);
-//       const result = MetadataFactory.analyze(checker)({
-//         escape: true,
-//         constant: true,
-//         absorb: true,
-//       })(new MetadataCollection())(type);
-//       if (false === result.success) return null;
-
-//       const meta: Metadata = result.data;
-//       if (meta.constants.length === 1)
-//         return meta.constants[0].values[0].value.toString();
-//       else if (meta.escaped && meta.escaped.returns.constants.length === 1)
-//         return meta.escaped.returns.constants[0].values[0].value.toString();
-//       else if (ts.isStringLiteral(expression)) return expression.text;
-//       else if (ts.isNumericLiteral(expression)) {
-//         const value: number = Number(expression.text.split("_").join(""));
-//         if (false === isNaN(value)) return value.toString();
-//       }
-//       return null;
-//     };
-// }
-
-// const TYPED_EXCEPTION_PATH = path.join(
-//   "node_modules",
-//   "@nestia",
-//   "core",
-//   "lib",
-//   "decorators",
-//   "TypedException.d.ts",
-// );

package/src/analyses/GenericAnalyzer.ts

@@ -1,49 +0,0 @@
-import ts from "typescript";
-
-export namespace GenericAnalyzer {
-  export function analyze(
-    checker: ts.TypeChecker,
-    classNode: ts.ClassDeclaration,
-  ): WeakMap<ts.Type, ts.Type> {
-    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
-    explore(checker, dict, classNode);
-    return dict;
-  }
-
-  function explore(
-    checker: ts.TypeChecker,
-    dict: WeakMap<ts.Type, ts.Type>,
-    classNode: ts.ClassDeclaration,
-  ): void {
-    if (classNode.heritageClauses === undefined) return;
-
-    for (const heritage of classNode.heritageClauses)
-      for (const hType of heritage.types) {
-        // MUST BE CLASS
-        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
-        const superNode: ts.Declaration | undefined =
-          expression.symbol?.getDeclarations?.()?.[0];
-
-        if (superNode === undefined || !ts.isClassDeclaration(superNode))
-          continue;
-
-        // SPECIFY GENERICS
-        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
-        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
-          superNode.typeParameters || [];
-
-        parameters.forEach((param, index) => {
-          const paramType: ts.Type = checker.getTypeAtLocation(param);
-          const usageType: ts.Type =
-            usages[index] !== undefined
-              ? checker.getTypeAtLocation(usages[index])
-              : checker.getTypeAtLocation(param.default!);
-
-          dict.set(paramType, usageType);
-        });
-
-        // RECURSIVE EXPLORATION
-        explore(checker, dict, superNode);
-      }
-  }
-}

package/src/structures/IReflectApplication.ts

@@ -1,8 +0,0 @@
-import { INestApplication } from "@nestjs/common";
-
-import { IReflectController } from "./IReflectController";
-
-export interface IReflectApplication {
-  application: INestApplication;
-  controllers: IReflectController[];
-}

package/src/structures/MethodType.ts

@@ -1,5 +0,0 @@
-export type MethodType = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-
-export namespace MethodType {
-  export const VALUES: MethodType[] = ["GET", "POST", "PUT", "PATCH", "DELETE"];
-}

package/src/structures/ParamCategory.ts

@@ -1 +0,0 @@
-export type ParamCategory = "param" | "query" | "body" | "rawBody" | "headers";

package/src/structures/TypeEntry.ts

@@ -1,22 +0,0 @@
-import { hash } from "tstl";
-import ts from "typescript";
-
-export class TypeEntry {
-  public constructor(
-    public readonly type: ts.Type,
-    public readonly nullable: boolean,
-    public readonly required: boolean,
-  ) {}
-
-  public equals(obj: TypeEntry): boolean {
-    return (
-      this.type === obj.type &&
-      this.nullable === obj.nullable &&
-      this.required === obj.required
-    );
-  }
-
-  public hashCode(): number {
-    return hash(this.type, this.nullable, this.required);
-  }
-}

package/src/transformers/ISdkOperationTransformerContext.ts

@@ -1,8 +0,0 @@
-import { MetadataCollection } from "@typia/core";
-import ts from "typescript";
-
-export interface ISdkOperationTransformerContext {
-  checker: ts.TypeChecker;
-  transformer: ts.TransformationContext;
-  collection: MetadataCollection;
-}