@nestia/sdk 3.10.0 → 3.11.0-dev.20240812

package/src/transformers/SdkMetadataProgrammer.ts

@@ -0,0 +1,227 @@
+import ts from "typescript";
+import { CommentFactory } from "typia/lib/factories/CommentFactory";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { ImportAnalyzer } from "../analyses/ImportAnalyzer";
+import { IOperationMetadata } from "./IOperationMetadata";
+import { ISdkTransformerContext } from "./ISdkTransformerContext";
+
+export namespace SdkMetadataProgrammer {
+  export interface IProps {
+    context: ISdkTransformerContext;
+    generics: WeakMap<ts.Type, ts.Type>;
+    node: ts.MethodDeclaration;
+  }
+  export const write = (p: IProps): IOperationMetadata => {
+    const symbol: ts.Symbol | undefined = p.context.checker.getSymbolAtLocation(
+      p.node,
+    );
+    const signature: ts.Signature | undefined =
+      p.context.checker.getSignatureFromDeclaration(p.node);
+    return {
+      parameters: p.node.parameters.map((parameter, index) =>
+        writeParameter({
+          context: p.context,
+          generics: p.generics,
+          parameter,
+          index,
+        }),
+      ),
+      success: writeResponse({
+        context: p.context,
+        generics: p.generics,
+        type: getReturnType({
+          checker: p.context.checker,
+          signature,
+        }),
+      }),
+      exceptions: {}, // @todo
+      description: (symbol && CommentFactory.description(symbol)) ?? null,
+      jsDocTags: signature?.getJsDocTags() ?? [],
+    };
+  };
+
+  const writeParameter = (props: {
+    context: ISdkTransformerContext;
+    generics: WeakMap<ts.Type, ts.Type>;
+    parameter: ts.ParameterDeclaration;
+    index: number;
+  }): IOperationMetadata.IParameter => {
+    const symbol: ts.Symbol | undefined =
+      props.context.checker.getSymbolAtLocation(props.parameter);
+    return {
+      ...writeType({
+        ...props,
+        type:
+          props.context.checker.getTypeFromTypeNode(
+            props.parameter.type ?? TypeFactory.keyword("any"),
+          ) ?? null,
+        required: props.parameter.questionToken === undefined,
+      }),
+      name: props.parameter.name.getText(),
+      index: props.index,
+      description: (symbol && CommentFactory.description(symbol)) ?? null,
+      jsDocTags: symbol?.getJsDocTags() ?? [],
+    };
+  };
+
+  const writeResponse = (props: {
+    context: ISdkTransformerContext;
+    generics: WeakMap<ts.Type, ts.Type>;
+    type: ts.Type | null;
+  }): IOperationMetadata.IResponse =>
+    writeType({
+      ...props,
+      required: true,
+    });
+
+  const writeType = (p: {
+    context: ISdkTransformerContext;
+    generics: WeakMap<ts.Type, ts.Type>;
+    type: ts.Type | null;
+    required: boolean;
+  }): IOperationMetadata.IResponse => {
+    const analyzed: ImportAnalyzer.IOutput = p.type
+      ? ImportAnalyzer.analyze(p.context.checker, p.generics, p.type)
+      : {
+          type: { name: "any" },
+          imports: [],
+        };
+    const [primitive, resolved] = [true, false].map((escape) =>
+      MetadataFactory.analyze(
+        p.context.checker,
+        p.context.api,
+      )({
+        escape,
+        constant: true,
+        absorb: true,
+      })(p.context.collection)(p.type),
+    );
+    return {
+      ...analyzed,
+      primitive: writeSchema({
+        collection: p.context.collection,
+        result: primitive,
+      }),
+      resolved: writeSchema({
+        collection: p.context.collection,
+        result: resolved,
+      }),
+    };
+  };
+
+  const writeSchema = (p: {
+    collection: MetadataCollection;
+    result: ValidationPipe<Metadata, 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 getReturnType = (p: {
+    checker: ts.TypeChecker;
+    signature: ts.Signature | undefined;
+  }): ts.Type | null => {
+    const type: ts.Type | null = p.signature?.getReturnType() ?? 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;
+  };
+}
+
+const iterateVisited = (metdata: Metadata): Set<string> => {
+  const names: Set<string> = new Set();
+  const visited: WeakSet<Metadata> = new WeakSet();
+  const iterate = (metadata: Metadata): void => {
+    if (visited.has(metadata)) return;
+    visited.add(metadata);
+    for (const alias of metadata.aliases) {
+      names.add(alias.name);
+      iterate(alias.value);
+    }
+    for (const array of metadata.arrays) {
+      names.add(array.type.name);
+      iterate(array.type.value);
+    }
+    for (const tuple of metadata.tuples) {
+      names.add(tuple.type.name);
+      tuple.type.elements.map(iterate);
+    }
+    for (const object of metadata.objects) {
+      names.add(object.name);
+      object.properties.map((p) => {
+        iterate(p.key);
+        iterate(p.value);
+      });
+    }
+    if (metadata.escaped) {
+      iterate(metadata.escaped.original);
+      iterate(metadata.escaped.returns);
+    }
+    if (metadata.rest) iterate(metadata.rest);
+  };
+  iterate(metdata);
+  return names;
+};
+
+const join = ({
+  object,
+  key,
+}: {
+  object: MetadataObject;
+  key: string | object | null;
+}) => {
+  if (key === null) return object.name;
+  else if (typeof key === "object") return `${object.name}[key]`;
+  else if (Escaper.variable(key)) return `${object.name}.${key}`;
+  return `${object.name}[${JSON.stringify(key)}]`;
+};

package/src/transformers/SdkTransformer.ts

@@ -0,0 +1,168 @@
+import { HashSet, 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 { ISdkTransformerContext } from "./ISdkTransformerContext";
+import { SdkMetadataProgrammer } from "./SdkMetadataProgrammer";
+
+export namespace SdkTransformer {
+  export const transformFile =
+    (checker: ts.TypeChecker) => (api: ts.TransformationContext) => {
+      const context: ISdkTransformerContext = {
+        checker,
+        api,
+        collection: new MetadataCollection({
+          replace: MetadataCollection.replace,
+        }),
+      };
+      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) =>
+            transformNode({
+              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 transformNode = (props: {
+    context: ISdkTransformerContext;
+    visitor: IVisitor;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.isClassDeclaration(props.node)
+      ? transformClass({
+          ...props,
+          node: props.node,
+        })
+      : props.node;
+
+  const transformClass = (props: {
+    context: ISdkTransformerContext;
+    visitor: IVisitor;
+    node: ts.ClassDeclaration;
+  }): ts.ClassDeclaration => {
+    const generics: WeakMap<ts.Type, ts.Type> = GenericAnalyzer.analyze(
+      props.context.checker,
+      props.node,
+    );
+    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,
+            })
+          : m,
+      ),
+    );
+  };
+
+  const transformMethod = (props: {
+    context: ISdkTransformerContext;
+    visitor: IVisitor;
+    class: ts.ClassDeclaration;
+    generics: WeakMap<ts.Type, ts.Type>;
+    node: ts.MethodDeclaration;
+  }): 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 = SdkMetadataProgrammer.write(props);
+    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.generate(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,
+    );
+  };
+}
+
+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);
+  }
+}

package/src/transformers/TextPlainValidator.ts

@@ -0,0 +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 === "String").length;
+    if (metadata.size() === 0 || metadata.size() !== expected)
+      return [`Only string type is allowed in the "text/plain" content type.`];
+    return [];
+  };
+}

package/src/utils/StringUtil.ts

@@ -1,4 +1,7 @@
 export namespace StringUtil {
+  export const capitalize = (text: string): string =>
+    text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+
   export const escapeDuplicate =
     (keep: string[]) =>
     (change: string): string =>

package/lib/analyses/TypedControllerAnalyzer.d.ts

@@ -1,8 +0,0 @@
-import ts from "typescript";
-import { INestiaProject } from "../structures/INestiaProject";
-import { IReflectController } from "../structures/IReflectController";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
-export declare namespace TypedControllerAnalyzer {
-    const analyze: (project: INestiaProject) => (sourceFile: ts.SourceFile, controller: IReflectController) => Promise<Array<ITypedHttpRoute | ITypedWebSocketRoute>>;
-}

package/lib/analyses/TypedControllerAnalyzer.js

@@ -1,77 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedControllerAnalyzer = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const GenericAnalyzer_1 = require("./GenericAnalyzer");
-const TypedHttpOperationAnalyzer_1 = require("./TypedHttpOperationAnalyzer");
-const TypedWebSocketOperationAnalyzer_1 = require("./TypedWebSocketOperationAnalyzer");
-var TypedControllerAnalyzer;
-(function (TypedControllerAnalyzer) {
-    TypedControllerAnalyzer.analyze = (project) => (sourceFile, controller) => __awaiter(this, void 0, void 0, function* () {
-        // FIND CONTROLLER CLASS
-        const ret = [];
-        typescript_1.default.forEachChild(sourceFile, (node) => {
-            var _a;
-            if (typescript_1.default.isClassDeclaration(node) &&
-                ((_a = node.name) === null || _a === void 0 ? void 0 : _a.escapedText) === controller.name) {
-                // ANALYZE THE CONTROLLER
-                ret.push(..._Analyze_controller(project)(controller, node));
-                return;
-            }
-        });
-        return ret;
-    });
-    /* ---------------------------------------------------------
-          CLASS
-      --------------------------------------------------------- */
-    const _Analyze_controller = (project) => (controller, classNode) => {
-        const classType = project.checker.getTypeAtLocation(classNode);
-        const generics = GenericAnalyzer_1.GenericAnalyzer.analyze(project.checker, classNode);
-        const ret = [];
-        for (const symbol of classType.getProperties()) {
-            // GET METHOD DECLARATION
-            const declaration = (symbol.declarations ||
-                [])[0];
-            if (!declaration || !typescript_1.default.isMethodDeclaration(declaration))
-                continue;
-            // IDENTIFIER MUST BE
-            const identifier = declaration.name;
-            if (!typescript_1.default.isIdentifier(identifier))
-                continue;
-            // ANALYZED WITH THE REFLECTED-FUNCTION
-            const operation = controller.operations.find((f) => f.name === identifier.escapedText);
-            if (operation === undefined)
-                continue;
-            const routes = operation.protocol === "http"
-                ? TypedHttpOperationAnalyzer_1.TypedHttpOperationAnalyzer.analyze(project)({
-                    controller,
-                    generics,
-                    operation,
-                    declaration,
-                    symbol,
-                })
-                : TypedWebSocketOperationAnalyzer_1.TypedWebSocketOperationAnalyzer.analyze(project)({
-                    controller,
-                    operation,
-                    declaration,
-                    symbol,
-                    generics,
-                });
-            ret.push(...routes);
-        }
-        return ret;
-    };
-})(TypedControllerAnalyzer || (exports.TypedControllerAnalyzer = TypedControllerAnalyzer = {}));
-//# sourceMappingURL=TypedControllerAnalyzer.js.map

package/lib/analyses/TypedControllerAnalyzer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypedControllerAnalyzer.js","sourceRoot":"","sources":["../../src/analyses/TypedControllerAnalyzer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,4DAA4B;AAQ5B,uDAAoD;AACpD,6EAA0E;AAC1E,uFAAoF;AAEpF,IAAiB,uBAAuB,CA+EvC;AA/ED,WAAiB,uBAAuB;IACzB,+BAAO,GAClB,CAAC,OAAuB,EAAE,EAAE,CAC5B,CACE,UAAyB,EACzB,UAA8B,EAC0B,EAAE;QAC1D,wBAAwB;QACxB,MAAM,GAAG,GAAkD,EAAE,CAAC;QAC9D,oBAAE,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;;YACnC,IACE,oBAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC;gBAC3B,CAAA,MAAA,IAAI,CAAC,IAAI,0CAAE,WAAW,MAAK,UAAU,CAAC,IAAI,EAC1C,CAAC;gBACD,yBAAyB;gBACzB,GAAG,CAAC,IAAI,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;gBAC5D,OAAO;YACT,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC,CAAA,CAAC;IAEJ;;kEAE8D;IAC9D,MAAM,mBAAmB,GACvB,CAAC,OAAuB,EAAE,EAAE,CAC5B,CACE,UAA8B,EAC9B,SAA8B,EACiB,EAAE;QACjD,MAAM,SAAS,GAAqB,OAAO,CAAC,OAAO,CAAC,iBAAiB,CACnE,SAAS,CACU,CAAC;QACtB,MAAM,QAAQ,GAA+B,iCAAe,CAAC,OAAO,CAClE,OAAO,CAAC,OAAO,EACf,SAAS,CACV,CAAC;QAEF,MAAM,GAAG,GAAkD,EAAE,CAAC;QAC9D,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,aAAa,EAAE,EAAE,CAAC;YAC/C,yBAAyB;YACzB,MAAM,WAAW,GAA+B,CAAC,MAAM,CAAC,YAAY;gBAClE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACT,IAAI,CAAC,WAAW,IAAI,CAAC,oBAAE,CAAC,mBAAmB,CAAC,WAAW,CAAC;gBAAE,SAAS;YAEnE,qBAAqB;YACrB,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC;YACpC,IAAI,CAAC,oBAAE,CAAC,YAAY,CAAC,UAAU,CAAC;gBAAE,SAAS;YAE3C,uCAAuC;YACvC,MAAM,SAAS,GAGC,UAAU,CAAC,UAAU,CAAC,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,WAAW,CACzC,CAAC;YACF,IAAI,SAAS,KAAK,SAAS;gBAAE,SAAS;YAEtC,MAAM,MAAM,GACV,SAAS,CAAC,QAAQ,KAAK,MAAM;gBAC3B,CAAC,CAAC,uDAA0B,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;oBAC1C,UAAU;oBACV,QAAQ;oBACR,SAAS;oBACT,WAAW;oBACX,MAAM;iBACP,CAAC;gBACJ,CAAC,CAAC,iEAA+B,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;oBAC/C,UAAU;oBACV,SAAS;oBACT,WAAW;oBACX,MAAM;oBACN,QAAQ;iBACT,CAAC,CAAC;YACT,GAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;QACtB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;AACN,CAAC,EA/EgB,uBAAuB,uCAAvB,uBAAuB,QA+EvC"}

package/lib/analyses/TypedHttpOperationAnalyzer.d.ts

@@ -1,15 +0,0 @@
-import ts from "typescript";
-import { INestiaProject } from "../structures/INestiaProject";
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-export declare namespace TypedHttpOperationAnalyzer {
-    const analyze: (project: INestiaProject) => (props: {
-        controller: IReflectController;
-        operation: IReflectHttpOperation;
-        declaration: ts.MethodDeclaration;
-        symbol: ts.Symbol;
-        generics: GenericAnalyzer.Dictionary;
-    }) => ITypedHttpRoute[];
-}