@nestia/sdk 11.2.0 → 12.0.0-dev.20260520.1

package/src/transformers/SdkOperationProgrammer.ts

@@ -1,240 +0,0 @@
-import {
-  CommentFactory,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataObjectType,
-  MetadataSchema,
-  TypeFactory,
-} from "@typia/core";
-import { ValidationPipe } from "@typia/interface";
-import { NamingConvention } from "@typia/utils";
-import { Singleton } from "tstl";
-import ts from "typescript";
-
-import { DtoAnalyzer } from "../analyses/DtoAnalyzer";
-import { IReflectImport } from "../structures/IReflectImport";
-import { MetadataUtil } from "../utils/MetadataUtil";
-import { IOperationMetadata } from "./IOperationMetadata";
-import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
-
-export namespace SdkOperationProgrammer {
-  export interface IProps {
-    context: ISdkOperationTransformerContext;
-    imports: Singleton<IReflectImport[]>;
-    node: ts.MethodDeclaration;
-    symbol: ts.Symbol | undefined;
-    exceptions: ts.TypeNode[];
-  }
-  export const write = (p: IProps): IOperationMetadata => {
-    return {
-      parameters: p.node.parameters.map((parameter, index) =>
-        writeParameter({
-          context: p.context,
-          imports: p.imports,
-          parameter,
-          index,
-        }),
-      ),
-      success: writeResponse({
-        context: p.context,
-        imports: p.imports,
-        typeNode: p.node.type ? getReturnTypeNode(p.node.type) : null,
-        type: getReturnType({
-          checker: p.context.checker,
-          signature: p.context.checker.getSignatureFromDeclaration(p.node),
-        }),
-      }),
-      exceptions: p.exceptions.map((e) =>
-        writeResponse({
-          context: p.context,
-          imports: p.imports,
-          typeNode: e,
-          type: p.context.checker.getTypeFromTypeNode(e),
-        }),
-      ),
-      jsDocTags: p.symbol?.getJsDocTags() ?? [],
-      description: p.symbol
-        ? (CommentFactory.description(p.symbol) ?? null)
-        : null,
-    };
-  };
-
-  const writeParameter = (props: {
-    context: ISdkOperationTransformerContext;
-    imports: Singleton<IReflectImport[]>;
-    parameter: ts.ParameterDeclaration;
-    index: number;
-  }): IOperationMetadata.IParameter => {
-    const symbol: ts.Symbol | undefined =
-      props.context.checker.getSymbolAtLocation(props.parameter);
-    const common: IOperationMetadata.IResponse = writeResponse({
-      context: props.context,
-      imports: props.imports,
-      typeNode: props.parameter.type ?? null,
-      type:
-        props.context.checker.getTypeFromTypeNode(
-          props.parameter.type ?? TypeFactory.keyword("any"),
-        ) ?? null,
-    });
-    const optional: boolean = props.parameter.questionToken !== undefined;
-    if (common.primitive.success)
-      common.primitive.data.metadata.optional = optional;
-    if (common.resolved.success)
-      common.resolved.data.metadata.optional = optional;
-
-    return {
-      ...common,
-      name: props.parameter.name.getText(),
-      index: props.index,
-      description: (symbol && CommentFactory.description(symbol)) ?? null,
-      jsDocTags: symbol?.getJsDocTags() ?? [],
-    };
-  };
-
-  const writeResponse = (p: {
-    context: ISdkOperationTransformerContext;
-    imports: Singleton<IReflectImport[]>;
-    typeNode: ts.TypeNode | null;
-    type: ts.Type | null;
-  }): IOperationMetadata.IResponse => {
-    const analyzed: DtoAnalyzer.IOutput | null = p.typeNode
-      ? DtoAnalyzer.analyzeNode({
-          checker: p.context.checker,
-          imports: p.imports.get(),
-          typeNode: p.typeNode,
-        })
-      : p.type
-        ? DtoAnalyzer.analyzeType({
-            checker: p.context.checker,
-            imports: p.imports.get(),
-            type: p.type,
-          })
-        : {
-            type: { name: "any" },
-            imports: [],
-          };
-    const [primitive, resolved] = [true, false].map((escape) =>
-      MetadataFactory.analyze({
-        checker: p.context.checker,
-        transformer: p.context.transformer,
-        options: {
-          escape,
-          constant: true,
-          absorb: true,
-        },
-        components: p.context.collection,
-        type: p.type,
-      }),
-    );
-    return {
-      ...(analyzed
-        ? analyzed
-        : {
-            imports: [],
-            type: null,
-          }),
-      primitive: writeSchema({
-        collection: p.context.collection,
-        result: primitive!,
-      }),
-      resolved: writeSchema({
-        collection: p.context.collection,
-        result: resolved!,
-      }),
-    };
-  };
-
-  const writeSchema = (p: {
-    collection: MetadataCollection;
-    result: ValidationPipe<MetadataSchema, MetadataFactory.IError>;
-  }): ValidationPipe<IOperationMetadata.ISchema, IOperationMetadata.IError> => {
-    if (p.result.success === false)
-      return {
-        success: false,
-        errors: p.result.errors.map((e) => ({
-          name: e.name,
-          accessor:
-            e.explore.object !== null
-              ? join({
-                  object: e.explore.object,
-                  key: e.explore.property,
-                })
-              : null,
-          messages: e.messages,
-        })),
-      };
-    const visited: Set<string> = iterateVisited(p.result.data);
-    return {
-      success: true,
-      data: {
-        components: {
-          objects: p.collection
-            .objects()
-            .filter((o) => visited.has(o.name))
-            .map((o) => o.toJSON()),
-          aliases: p.collection
-            .aliases()
-            .filter((a) => visited.has(a.name))
-            .map((a) => a.toJSON()),
-          arrays: p.collection
-            .arrays()
-            .filter((a) => visited.has(a.name))
-            .map((a) => a.toJSON()),
-          tuples: p.collection
-            .tuples()
-            .filter((t) => visited.has(t.name))
-            .map((t) => t.toJSON()),
-        },
-        metadata: p.result.data.toJSON(),
-      },
-    };
-  };
-}
-
-const iterateVisited = (metadata: MetadataSchema): Set<string> => {
-  const names: Set<string> = new Set();
-  MetadataUtil.visit((m) => {
-    for (const alias of m.aliases) names.add(alias.type.name);
-    for (const array of m.arrays) names.add(array.type.name);
-    for (const tuple of m.tuples) names.add(tuple.type.name);
-    for (const object of m.objects) names.add(object.type.name);
-  })(metadata);
-  return names;
-};
-
-const join = ({
-  object,
-  key,
-}: {
-  object: MetadataObjectType;
-  key: string | object | null;
-}) => {
-  if (key === null) return object.name;
-  else if (typeof key === "object") return `${object.name}[key]`;
-  else if (NamingConvention.variable(key)) return `${object.name}.${key}`;
-  return `${object.name}[${JSON.stringify(key)}]`;
-};
-
-const getReturnTypeNode = (node: ts.TypeNode): ts.TypeNode | null => {
-  if (ts.isTypeReferenceNode(node)) {
-    const typeName: string = node.typeName.getText();
-    if (typeName === "Promise") return node.typeArguments?.[0] ?? null;
-  }
-  return node;
-};
-
-const getReturnType = (p: {
-  checker: ts.TypeChecker;
-  signature: ts.Signature | undefined;
-}): ts.Type | null => {
-  const type: ts.Type | null =
-    (p.signature && p.checker.getReturnTypeOfSignature(p.signature)) ?? null;
-  if (type === null) return null;
-  else if (type.symbol?.name === "Promise") {
-    const generic: readonly ts.Type[] = p.checker.getTypeArguments(
-      type as ts.TypeReference,
-    );
-    return generic[0] ?? null;
-  }
-  return type;
-};

package/src/transformers/SdkOperationTransformer.ts

@@ -1,248 +0,0 @@
-import { LiteralFactory, MetadataCollection, TypeFactory } from "@typia/core";
-import path from "path";
-import { HashSet, Singleton, hash } from "tstl";
-import ts from "typescript";
-
-import { ImportAnalyzer } from "../analyses/ImportAnalyzer";
-import { IReflectImport } from "../structures/IReflectImport";
-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,
-              imports: new Singleton(() => ImportAnalyzer.analyze(file)),
-              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"),
-            undefined,
-          ),
-          ...file.statements,
-        ]);
-      };
-    };
-
-  interface IVisitor {
-    done: boolean;
-    visited: HashSet<MethodKey>;
-  }
-
-  const iterateNode = (props: {
-    context: ISdkOperationTransformerContext;
-    imports: Singleton<IReflectImport[]>;
-    visitor: IVisitor;
-    node: ts.Node;
-  }): ts.Node =>
-    ts.visitEachChild(
-      transformNode(props),
-      (child) =>
-        iterateNode({
-          ...props,
-          node: child,
-        }),
-      props.context.transformer,
-    );
-
-  const transformNode = (props: {
-    context: ISdkOperationTransformerContext;
-    imports: Singleton<IReflectImport[]>;
-    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;
-    imports: Singleton<IReflectImport[]>;
-    node: ts.ClassDeclaration;
-  }): ts.ClassDeclaration => {
-    // 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,
-              class: props.node,
-              node: m,
-              symbol: symbolDict.get(m.name.getText()),
-            })
-          : m,
-      ),
-    );
-  };
-
-  const transformMethod = (props: {
-    context: ISdkOperationTransformerContext;
-    visitor: IVisitor;
-    imports: Singleton<IReflectImport[]>;
-    class: ts.ClassDeclaration;
-    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",
-  "src",
-  "decorators",
-  `TypedException.ts`,
-);
-
-const collection = new Singleton(
-  () =>
-    new MetadataCollection({
-      replace: MetadataCollection.replace,
-    }),
-);

package/src/utils/MetadataUtil.ts

@@ -1,26 +0,0 @@
-import { MetadataSchema } from "@typia/core";
-
-export namespace MetadataUtil {
-  export const visit = (closure: (m: MetadataSchema) => unknown) => {
-    const visited: WeakSet<MetadataSchema> = new WeakSet();
-    const iterate = (metadata: MetadataSchema): void => {
-      if (visited.has(metadata)) return;
-      visited.add(metadata);
-      closure(metadata);
-      for (const alias of metadata.aliases) iterate(alias.type.value);
-      for (const array of metadata.arrays) iterate(array.type.value);
-      for (const tuple of metadata.tuples) tuple.type.elements.map(iterate);
-      for (const object of metadata.objects)
-        object.type.properties.forEach((p) => {
-          iterate(p.key);
-          iterate(p.value);
-        });
-      if (metadata.escaped) {
-        iterate(metadata.escaped.original);
-        iterate(metadata.escaped.returns);
-      }
-      if (metadata.rest) iterate(metadata.rest);
-    };
-    return iterate;
-  };
-}

package/src/utils/StripEnums.ts

@@ -1,5 +0,0 @@
-export type StripEnums<T extends Record<string, any>> = {
-  [Key in keyof T]: T[Key] extends string | boolean | object | undefined | any[]
-    ? T[Key]
-    : any;
-};