@nestia/sdk 3.11.0-dev.20240813-10 → 3.11.0-dev.20240814

package/src/generates/internal/SdkWebSocketNamespaceProgrammer.ts

@@ -78,22 +78,30 @@ export namespace SdkWebSocketNamespaceProgrammer {
         route.parameters.find((x) => x.category === "acceptor")!;
       const query: ITypedWebSocketRouteParameter.IQuery | undefined =
         route.parameters.find((x) => x.category === "query");
+      const driver: ITypedWebSocketRouteParameter.IDriver | undefined =
+        route.parameters.find((x) => x.category === "driver");
       declare(
         "Header",
-        SdkAliasCollection.name(
-          (route.parameters.find((x) => x.category === "header")?.type ??
+        SdkAliasCollection.name({
+          type: (route.parameters.find((x) => x.category === "header")?.type ??
             acceptor.type.typeArguments?.[0])!,
-        ),
+        }),
       );
       declare(
         "Provider",
-        SdkAliasCollection.name(acceptor.type.typeArguments?.[1]!),
+        SdkAliasCollection.name({
+          type:
+            driver?.type.typeArguments?.[0] ??
+            acceptor.type.typeArguments?.[2]!,
+        }),
       );
       declare(
         "Listener",
-        SdkAliasCollection.name(acceptor.type.typeArguments?.[2]!),
+        SdkAliasCollection.name({
+          type: acceptor.type.typeArguments?.[1]!,
+        }),
       );
-      if (query) declare("Query", SdkAliasCollection.name(query.type));
+      if (query) declare("Query", SdkAliasCollection.name(query));
       return output;
     };
 

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -78,7 +78,7 @@ export namespace SdkWebSocketRouteProgrammer {
               IdentifierFactory.parameter(
                 p.name,
                 p.category === "param"
-                  ? SdkAliasCollection.name(p.type)
+                  ? SdkAliasCollection.name(p)
                   : ts.factory.createTypeReferenceNode(`${route.name}.Query`),
               ),
             ),
@@ -164,13 +164,11 @@ export namespace SdkWebSocketRouteProgrammer {
       ),
       local("driver")(
         ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(
-            importer.external({
-              type: true,
-              library: "tgrid",
-              instance: "Driver",
-            }),
-          ),
+          importer.external({
+            type: true,
+            library: "tgrid",
+            instance: "Driver",
+          }),
           [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
         ),
       )(

package/src/generates/internal/SwaggerOperationComposer.ts

@@ -2,6 +2,7 @@ import { OpenApi } from "@samchon/openapi";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
 import { INestiaConfig } from "../../INestiaConfig";
+import { SecurityAnalyzer } from "../../analyses/SecurityAnalyzer";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
 import { SwaggerDescriptionComposer } from "./SwaggerDescriptionComposer";
@@ -44,6 +45,29 @@ export namespace SwaggerOperationComposer {
       }
     }
 
+    // SECURITY
+    const security: Record<string, string[]>[] = SecurityAnalyzer.merge(
+      ...props.route.controller.security,
+      ...props.route.security,
+      ...props.route.jsDocTags
+        .filter((tag) => tag.name === "security")
+        .map((tag) =>
+          tag.text === undefined
+            ? [{}]
+            : tag.text.map((text) => {
+                const line: string[] = text.text
+                  .split(" ")
+                  .filter((s) => s.trim())
+                  .filter((s) => !!s.length);
+                if (line.length === 0) return {};
+                return {
+                  [line[0]]: line.slice(1),
+                };
+              }),
+        )
+        .flat(),
+    );
+
     // FINALIZE
     return {
       ...SwaggerDescriptionComposer.compose({
@@ -85,6 +109,7 @@ export namespace SwaggerOperationComposer {
         schema: props.schema,
         route: props.route,
       }),
+      security: security.length ? security : undefined,
     };
   };
 }

package/src/generates/internal/SwaggerOperationParameterComposer.ts

@@ -77,6 +77,8 @@ export namespace SwaggerOperationParameterComposer {
       jsDocTags: props.parameter.jsDocTags,
       kind: "title",
     }),
+    example: props.parameter.example,
+    examples: props.parameter.examples,
   });
 
   export const query = (
@@ -114,6 +116,7 @@ export namespace SwaggerOperationParameterComposer {
         jsDocTags: props.jsDocTags,
         kind: "title",
       }),
+      required: props.parameter.metadata.isRequired(),
       example: props.parameter.example,
       examples: props.parameter.examples,
     };

package/src/structures/IReflectHttpOperation.ts

@@ -15,10 +15,7 @@ export interface IReflectHttpOperation {
   versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
   parameters: IReflectHttpOperationParameter[];
   success: IReflectHttpOperationSuccess;
-  exceptions: Record<
-    number | "2XX" | "3XX" | "4XX" | "5XX",
-    IReflectHttpOperationException
-  >;
+  exceptions: Record<string, IReflectHttpOperationException>;
   security: Record<string, string[]>[];
   tags: string[];
   imports: IReflectTypeImport[];

package/src/structures/IReflectHttpOperationException.ts

@@ -8,8 +8,8 @@ export interface IReflectHttpOperationException {
   // BASIC PROPERTIES
   status: number | "2XX" | "3XX" | "4XX" | "5XX";
   description: string | null;
-  example: any;
-  examples: Record<string, any>;
+  example?: any;
+  examples?: Record<string, any>;
 
   // REFLECTED PROPERTIES
   type: IReflectType;

package/src/structures/ITypedApplication.ts

@@ -1,8 +1,11 @@
+import { IMetadataDictionary } from "typia/lib/schemas/metadata/IMetadataDictionary";
+
 import { INestiaProject } from "./INestiaProject";
 import { ITypedHttpRoute } from "./ITypedHttpRoute";
 import { ITypedWebSocketRoute } from "./ITypedWebSocketRoute";
 
 export interface ITypedApplication {
   project: INestiaProject;
+  collection: IMetadataDictionary;
   routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>;
 }

package/src/transform.ts

@@ -1,9 +1,9 @@
 import ts from "typescript";
 
-import { SdkTransformer } from "./transformers/SdkTransformer";
+import { SdkOperationTransformer } from "./transformers/SdkOperationTransformer";
 
 export const transform = (
   program: ts.Program,
 ): ts.TransformerFactory<ts.SourceFile> =>
-  SdkTransformer.transformFile(program.getTypeChecker());
+  SdkOperationTransformer.iterateFile(program.getTypeChecker());
 export default transform;

package/src/transformers/IOperationMetadata.ts

@@ -9,7 +9,7 @@ import { IReflectTypeImport } from "../structures/IReflectTypeImport";
 export interface IOperationMetadata {
   parameters: IOperationMetadata.IParameter[];
   success: IOperationMetadata.IResponse;
-  exceptions: Record<string, IOperationMetadata.IResponse>;
+  exceptions: IOperationMetadata.IResponse[];
   description: string | null;
   jsDocTags: IJsDocTagInfo[];
 }
@@ -26,6 +26,12 @@ export namespace IOperationMetadata {
     primitive: ValidationPipe<ISchema, IError>;
     resolved: ValidationPipe<ISchema, IError>;
   }
+  export interface IException {
+    type: IReflectType | null;
+    imports: IReflectTypeImport[];
+    primitive: ValidationPipe<ISchema, IError>;
+  }
+
   export interface ISchema {
     components: IMetadataComponents;
     metadata: IMetadata;

package/src/transformers/{ISdkTransformerContext.ts → ISdkOperationTransformerContext.ts}

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 
-export interface ISdkTransformerContext {
+export interface ISdkOperationTransformerContext {
   checker: ts.TypeChecker;
   api: ts.TransformationContext;
   collection: MetadataCollection;

package/src/transformers/{SdkMetadataProgrammer.ts → SdkOperationProgrammer.ts}

@@ -9,18 +9,19 @@ import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
 import { Escaper } from "typia/lib/utils/Escaper";
 
 import { ImportAnalyzer } from "../analyses/ImportAnalyzer";
+import { MetadataUtil } from "../utils/MetadataUtil";
 import { IOperationMetadata } from "./IOperationMetadata";
-import { ISdkTransformerContext } from "./ISdkTransformerContext";
+import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
 
-export namespace SdkMetadataProgrammer {
+export namespace SdkOperationProgrammer {
   export interface IProps {
-    context: ISdkTransformerContext;
+    context: ISdkOperationTransformerContext;
     generics: WeakMap<ts.Type, ts.Type>;
     node: ts.MethodDeclaration;
+    symbol: ts.Symbol | undefined;
+    exceptions: ts.TypeNode[];
   }
   export const write = (p: IProps): IOperationMetadata => {
-    const signature: ts.Signature | undefined =
-      p.context.checker.getSignatureFromDeclaration(p.node);
     return {
       parameters: p.node.parameters.map((parameter, index) =>
         writeParameter({
@@ -35,32 +36,42 @@ export namespace SdkMetadataProgrammer {
         generics: p.generics,
         type: getReturnType({
           checker: p.context.checker,
-          signature,
+          signature: p.context.checker.getSignatureFromDeclaration(p.node),
         }),
       }),
-      exceptions: {}, // @todo
-      description: (signature && getDescription(signature)) ?? null,
-      jsDocTags: signature?.getJsDocTags() ?? [],
+      exceptions: p.exceptions.map((e) =>
+        writeResponse({
+          context: p.context,
+          generics: p.generics,
+          type: p.context.checker.getTypeFromTypeNode(e),
+        }),
+      ),
+      jsDocTags: p.symbol?.getJsDocTags() ?? [],
+      description: p.symbol
+        ? CommentFactory.description(p.symbol) ?? null
+        : null,
     };
   };
 
   const writeParameter = (props: {
-    context: ISdkTransformerContext;
+    context: ISdkOperationTransformerContext;
     generics: WeakMap<ts.Type, ts.Type>;
     parameter: ts.ParameterDeclaration;
     index: number;
   }): IOperationMetadata.IParameter => {
     const symbol: ts.Symbol | undefined =
       props.context.checker.getSymbolAtLocation(props.parameter);
+    const common: IOperationMetadata.IResponse = writeType({
+      context: props.context,
+      generics: props.generics,
+      type:
+        props.context.checker.getTypeFromTypeNode(
+          props.parameter.type ?? TypeFactory.keyword("any"),
+        ) ?? null,
+      required: props.parameter.questionToken === undefined,
+    });
     return {
-      ...writeType({
-        ...props,
-        type:
-          props.context.checker.getTypeFromTypeNode(
-            props.parameter.type ?? TypeFactory.keyword("any"),
-          ) ?? null,
-        required: props.parameter.questionToken === undefined,
-      }),
+      ...common,
       name: props.parameter.name.getText(),
       index: props.index,
       description: (symbol && CommentFactory.description(symbol)) ?? null,
@@ -69,7 +80,7 @@ export namespace SdkMetadataProgrammer {
   };
 
   const writeResponse = (props: {
-    context: ISdkTransformerContext;
+    context: ISdkOperationTransformerContext;
     generics: WeakMap<ts.Type, ts.Type>;
     type: ts.Type | null;
   }): IOperationMetadata.IResponse =>
@@ -79,7 +90,7 @@ export namespace SdkMetadataProgrammer {
     });
 
   const writeType = (p: {
-    context: ISdkTransformerContext;
+    context: ISdkOperationTransformerContext;
     generics: WeakMap<ts.Type, ts.Type>;
     type: ts.Type | null;
     required: boolean;
@@ -163,7 +174,8 @@ export namespace SdkMetadataProgrammer {
     checker: ts.TypeChecker;
     signature: ts.Signature | undefined;
   }): ts.Type | null => {
-    const type: ts.Type | null = p.signature?.getReturnType() ?? 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(
@@ -175,38 +187,14 @@ export namespace SdkMetadataProgrammer {
   };
 }
 
-const iterateVisited = (metdata: Metadata): Set<string> => {
+const iterateVisited = (metadata: 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);
+  MetadataUtil.visit((m) => {
+    for (const alias of m.aliases) names.add(alias.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.name);
+  })(metadata);
   return names;
 };
 
@@ -222,13 +210,3 @@ const join = ({
   else if (Escaper.variable(key)) return `${object.name}.${key}`;
   return `${object.name}[${JSON.stringify(key)}]`;
 };
-
-const getDescription = (signature: ts.Signature): string | null => {
-  const content: string[] = signature
-    .getDocumentationComment(undefined)
-    .filter((c) => c.kind === "text")
-    .map((c) => c.text);
-  return content.length
-    ? content.map((line) => line.split("\r\n").join("\n")).join("\n")
-    : null;
-};

package/src/transformers/{SdkTransformer.ts → SdkOperationTransformer.ts}

@@ -1,4 +1,5 @@
-import { HashSet, hash } from "tstl";
+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";
@@ -6,18 +7,16 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
 import { GenericAnalyzer } from "../analyses/GenericAnalyzer";
 import { IOperationMetadata } from "./IOperationMetadata";
-import { ISdkTransformerContext } from "./ISdkTransformerContext";
-import { SdkMetadataProgrammer } from "./SdkMetadataProgrammer";
+import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
+import { SdkOperationProgrammer } from "./SdkOperationProgrammer";
 
-export namespace SdkTransformer {
-  export const transformFile =
+export namespace SdkOperationTransformer {
+  export const iterateFile =
     (checker: ts.TypeChecker) => (api: ts.TransformationContext) => {
-      const context: ISdkTransformerContext = {
+      const context: ISdkOperationTransformerContext = {
         checker,
         api,
-        collection: new MetadataCollection({
-          replace: MetadataCollection.replace,
-        }),
+        collection: collection.get(),
       };
       return (file: ts.SourceFile): ts.SourceFile => {
         if (file.isDeclarationFile === true) return file;
@@ -28,7 +27,7 @@ export namespace SdkTransformer {
         file = ts.visitEachChild(
           file,
           (node) =>
-            transformNode({
+            iterateNode({
               context,
               visitor,
               node,
@@ -61,20 +60,36 @@ export namespace SdkTransformer {
     visited: HashSet<MethodKey>;
   }
 
-  const transformNode = (props: {
-    context: ISdkTransformerContext;
+  const iterateNode = (props: {
+    context: ISdkOperationTransformerContext;
     visitor: IVisitor;
     node: ts.Node;
   }): ts.Node =>
-    ts.isClassDeclaration(props.node)
+    ts.visitEachChild(
+      transformNode(props),
+      (child) =>
+        iterateNode({
+          ...props,
+          node: child,
+        }),
+      props.context.api,
+    );
+
+  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: ISdkTransformerContext;
+    context: ISdkOperationTransformerContext;
     visitor: IVisitor;
     node: ts.ClassDeclaration;
   }): ts.ClassDeclaration => {
@@ -82,6 +97,20 @@ export namespace SdkTransformer {
       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,
@@ -95,6 +124,7 @@ export namespace SdkTransformer {
               generics,
               class: props.node,
               node: m,
+              symbol: symbolDict.get(m.name.getText()),
             })
           : m,
       ),
@@ -102,11 +132,12 @@ export namespace SdkTransformer {
   };
 
   const transformMethod = (props: {
-    context: ISdkTransformerContext;
+    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)
@@ -121,7 +152,13 @@ export namespace SdkTransformer {
     if (props.visitor.visited.has(key)) return props.node;
     else props.visitor.visited.insert(key);
 
-    const metadata: IOperationMetadata = SdkMetadataProgrammer.write(props);
+    const metadata: IOperationMetadata = SdkOperationProgrammer.write({
+      ...props,
+      exceptions: getExceptionTypes({
+        checker: props.context.checker,
+        decorators,
+      }),
+    });
     return ts.factory.updateMethodDeclaration(
       props.node,
       [
@@ -150,6 +187,26 @@ export namespace SdkTransformer {
       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_PATH) === false) return null;
+        else if (deco.expression.typeArguments?.length !== 1) return null;
+        return deco.expression.typeArguments[0];
+      })
+      .filter((t) => t !== null);
 }
 
 class MethodKey {
@@ -166,3 +223,18 @@ class MethodKey {
     return hash(this.className, this.methodName);
   }
 }
+
+const TYPED_EXCEPTION_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `TypedException.d.ts`,
+);
+
+const collection = new Singleton(
+  () =>
+    new MetadataCollection({
+      replace: MetadataCollection.replace,
+    }),
+);

package/src/utils/MetadataUtil.ts

@@ -0,0 +1,26 @@
+import { Metadata as metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export namespace MetadataUtil {
+  export const visit = (closure: (m: metadata) => unknown) => {
+    const visited: WeakSet<metadata> = new WeakSet();
+    const iterate = (metadata: metadata): void => {
+      if (visited.has(metadata)) return;
+      visited.add(metadata);
+      closure(metadata);
+      for (const alias of metadata.aliases) iterate(alias.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.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/StringUtil.ts

@@ -6,4 +6,12 @@ export namespace StringUtil {
     (keep: string[]) =>
     (change: string): string =>
       keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
+
+  export const isImplicit = (str: string) =>
+    str === "object" ||
+    str === "__type" ||
+    str === "__object" ||
+    str.startsWith("__type.") ||
+    str.startsWith("__object.") ||
+    str.includes("readonly [");
 }

package/src/validators/HttpHeadersValidator.ts

@@ -0,0 +1,34 @@
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
+
+export namespace HttpHeadersValidator {
+  export const validate = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+        meta.arrays.length;
+      if (meta.size() !== expected)
+        insert("Only atomic or array of atomic types are allowed.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArrayType
+    ) {
+      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)
+        insert("Only atomic types are allowed in array.");
+    }
+    return errors;
+  };
+}

package/src/validators/HttpQueryValidator.ts

@@ -0,0 +1,34 @@
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
+
+export namespace HttpQueryValidator {
+  export const validate = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+        meta.arrays.length;
+      if (meta.size() !== expected)
+        insert("Only atomic or array of atomic types are allowed.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArrayType
+    ) {
+      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)
+        insert("Only atomic types are allowed in array.");
+    }
+    return errors;
+  };
+}

package/lib/transformers/ISdkTransformerContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISdkTransformerContext.js","sourceRoot":"","sources":["../../src/transformers/ISdkTransformerContext.ts"],"names":[],"mappings":""}