bring in map caching implementation (#4)

* fix: remove use of "any" types in cache type definitions

* fix: use Set() for middleware cache

* fix: reset state on tests, move class init to BeforeEach instead of BeforeAll

* commit build

* rebuild

* remove time logs

* update build o/p

* update build

* remove benchmark build output

* update build

* update package-lock

* Merge pull request #3 from scope3data/feature/performance-improvements

feat: major schema generation performance optimization - eliminate array-based type lookups

Author: benminer

.gitignore

@@ -2,8 +2,8 @@
 **/node_modules/
 
 # Builded sources
-**/build/
-**/dist/
+!**/build/
+!**/dist/
 
 # Coverage
 **/coverage/

.npmrc

@@ -1 +1,3 @@
 engine-strict=true
+@scope3data:registry=https://npm.pkg.github.com
+//npm.pkg.github.com/:_authToken=${NPM_TOKEN}

build/cjs/decorators/Arg.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arg = Arg;
+const decorators_1 = require("../helpers/decorators");
+const params_1 = require("../helpers/params");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Arg(name, returnTypeFuncOrOptions, maybeOptions) {
+    return (prototype, propertyKey, parameterIndex) => {
+        const { options, returnTypeFunc } = (0, decorators_1.getTypeDecoratorParams)(returnTypeFuncOrOptions, maybeOptions);
+        (0, getMetadataStorage_1.getMetadataStorage)().collectHandlerParamMetadata({
+            kind: "arg",
+            name,
+            description: options.description,
+            deprecationReason: options.deprecationReason,
+            ...(0, params_1.getParamInfo)({
+                prototype,
+                propertyKey,
+                parameterIndex,
+                returnTypeFunc,
+                options,
+                argName: name,
+            }),
+        });
+    };
+}

build/cjs/decorators/Args.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Args = Args;
+const decorators_1 = require("../helpers/decorators");
+const params_1 = require("../helpers/params");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Args(paramTypeFnOrOptions, maybeOptions) {
+    const { options, returnTypeFunc } = (0, decorators_1.getTypeDecoratorParams)(paramTypeFnOrOptions, maybeOptions);
+    return (prototype, propertyKey, parameterIndex) => {
+        (0, getMetadataStorage_1.getMetadataStorage)().collectHandlerParamMetadata({
+            kind: "args",
+            ...(0, params_1.getParamInfo)({ prototype, propertyKey, parameterIndex, returnTypeFunc, options }),
+        });
+    };
+}

build/cjs/decorators/ArgsType.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgsType = ArgsType;
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function ArgsType() {
+    return target => {
+        (0, getMetadataStorage_1.getMetadataStorage)().collectArgsMetadata({
+            name: target.name,
+            target,
+        });
+    };
+}

build/cjs/decorators/Authorized.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Authorized = Authorized;
+const errors_1 = require("../errors");
+const decorators_1 = require("../helpers/decorators");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Authorized(...rolesOrRolesArray) {
+    const roles = (0, decorators_1.getArrayFromOverloadedRest)(rolesOrRolesArray);
+    return (target, propertyKey, _descriptor) => {
+        if (propertyKey == null) {
+            (0, getMetadataStorage_1.getMetadataStorage)().collectAuthorizedResolverMetadata({
+                target: target,
+                roles,
+            });
+            return;
+        }
+        if (typeof propertyKey === "symbol") {
+            throw new errors_1.SymbolKeysNotSupportedError();
+        }
+        (0, getMetadataStorage_1.getMetadataStorage)().collectAuthorizedFieldMetadata({
+            target: target.constructor,
+            fieldName: propertyKey,
+            roles,
+        });
+    };
+}

build/cjs/decorators/Ctx.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ctx = Ctx;
+const errors_1 = require("../errors");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Ctx(propertyName) {
+    return (prototype, propertyKey, parameterIndex) => {
+        if (typeof propertyKey === "symbol") {
+            throw new errors_1.SymbolKeysNotSupportedError();
+        }
+        (0, getMetadataStorage_1.getMetadataStorage)().collectHandlerParamMetadata({
+            kind: "context",
+            target: prototype.constructor,
+            methodName: propertyKey,
+            index: parameterIndex,
+            propertyName,
+        });
+    };
+}

build/cjs/decorators/Directive.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directive = Directive;
+const errors_1 = require("../errors");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Directive(nameOrDefinition) {
+    return (targetOrPrototype, propertyKey, parameterIndexOrDescriptor) => {
+        const directive = { nameOrDefinition, args: {} };
+        if (typeof propertyKey === "symbol") {
+            throw new errors_1.SymbolKeysNotSupportedError();
+        }
+        if (propertyKey) {
+            if (typeof parameterIndexOrDescriptor === "number") {
+                (0, getMetadataStorage_1.getMetadataStorage)().collectDirectiveArgumentMetadata({
+                    target: targetOrPrototype.constructor,
+                    fieldName: propertyKey,
+                    parameterIndex: parameterIndexOrDescriptor,
+                    directive,
+                });
+            }
+            else {
+                (0, getMetadataStorage_1.getMetadataStorage)().collectDirectiveFieldMetadata({
+                    target: targetOrPrototype.constructor,
+                    fieldName: propertyKey,
+                    directive,
+                });
+            }
+        }
+        else {
+            (0, getMetadataStorage_1.getMetadataStorage)().collectDirectiveClassMetadata({
+                target: targetOrPrototype,
+                directive,
+            });
+        }
+    };
+}

build/cjs/decorators/Extensions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extensions = Extensions;
+const errors_1 = require("../errors");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Extensions(extensions) {
+    return (targetOrPrototype, propertyKey, _descriptor) => {
+        if (typeof propertyKey === "symbol") {
+            throw new errors_1.SymbolKeysNotSupportedError();
+        }
+        if (propertyKey) {
+            (0, getMetadataStorage_1.getMetadataStorage)().collectExtensionsFieldMetadata({
+                target: targetOrPrototype.constructor,
+                fieldName: propertyKey,
+                extensions,
+            });
+        }
+        else {
+            (0, getMetadataStorage_1.getMetadataStorage)().collectExtensionsClassMetadata({
+                target: targetOrPrototype,
+                extensions,
+            });
+        }
+    };
+}

build/cjs/decorators/Field.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = Field;
+const errors_1 = require("../errors");
+const decorators_1 = require("../helpers/decorators");
+const findType_1 = require("../helpers/findType");
+const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
+function Field(returnTypeFuncOrOptions, maybeOptions) {
+    return (prototype, propertyKey, descriptor) => {
+        if (typeof propertyKey === "symbol") {
+            throw new errors_1.SymbolKeysNotSupportedError();
+        }
+        const { options, returnTypeFunc } = (0, decorators_1.getTypeDecoratorParams)(returnTypeFuncOrOptions, maybeOptions);
+        const isResolver = Boolean(descriptor);
+        const isResolverMethod = Boolean(descriptor && descriptor.value);
+        const { getType, typeOptions } = (0, findType_1.findType)({
+            metadataKey: isResolverMethod ? "design:returntype" : "design:type",
+            prototype,
+            propertyKey,
+            returnTypeFunc,
+            typeOptions: options,
+        });
+        (0, getMetadataStorage_1.getMetadataStorage)().collectClassFieldMetadata({
+            name: propertyKey,
+            schemaName: options.name || propertyKey,
+            getType,
+            typeOptions,
+            complexity: options.complexity,
+            target: prototype.constructor,
+            description: options.description,
+            deprecationReason: options.deprecationReason,
+            simple: options.simple,
+        });
+        if (isResolver) {
+            (0, getMetadataStorage_1.getMetadataStorage)().collectFieldResolverMetadata({
+                kind: "internal",
+                methodName: propertyKey,
+                schemaName: options.name || propertyKey,
+                target: prototype.constructor,
+                complexity: options.complexity,
+            });
+        }
+    };
+}