@tinkerstack/graphql-annotation 0.0.0 → 0.0.2

package/dist/index.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,16 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
@@ -76,47 +66,38 @@ function Annotate(name, opts) {
       case "number": {
         const paramIndex = descriptorOrParameterIndex;
         const paramName = opts?.parameter;
-        if (!paramName)
-          throw new Error(
-            `Unable to apply annotation "${annotationName}". Parameter name not specified.`
-          );
-        (0, import_graphql.Args)(paramName)(target, propertyKey, paramIndex);
-        _updateAnnotation(
-          target.constructor,
-          (meta) => ({
-            ...meta,
-            [`${annotationName}@${paramIndex}`]: {
-              annotation: annotationName,
-              data: annotationData,
-              target: {
-                type: "parameter",
-                paramIndex,
-                paramName
-              }
+        if (!paramName) throw new Error(`Unable to apply annotation "${annotationName}". Parameter name not specified.`);
+        (0, import_graphql.Args)({
+          name: paramName,
+          type: opts?.type,
+          description: opts?.description
+        })(target, propertyKey, paramIndex);
+        _updateAnnotation(target.constructor, (meta) => ({
+          ...meta,
+          [`${annotationName}@${paramIndex}`]: {
+            annotation: annotationName,
+            data: annotationData,
+            target: {
+              type: "parameter",
+              paramIndex,
+              paramName
             }
-          }),
-          propertyKey
-        );
+          }
+        }), propertyKey);
         break;
       }
       default:
-        throw new Error(
-          `Unable to attach annotation "${name}". Unsupported target.`
-        );
+        throw new Error(`Unable to attach annotation "${name}". Unsupported target.`);
     }
   };
 }
+__name(Annotate, "Annotate");
 function _updateAnnotation(target, updateFn, propertyKey) {
   const meta = Reflect.getMetadata(ANNOTATION_METADATA, target) ?? {};
-  if (propertyKey)
-    Reflect.defineMetadata(
-      ANNOTATION_METADATA,
-      updateFn(meta),
-      target,
-      propertyKey
-    );
+  if (propertyKey) Reflect.defineMetadata(ANNOTATION_METADATA, updateFn(meta), target, propertyKey);
   else Reflect.defineMetadata(ANNOTATION_METADATA, updateFn(meta), target);
 }
+__name(_updateAnnotation, "_updateAnnotation");
 function ResolveAnnotation(name) {
   return (target, property, descriptor) => {
     (0, import_common.SetMetadata)(ANNOTATION_RESOLVER_METADATA, {
@@ -124,41 +105,119 @@ function ResolveAnnotation(name) {
     })(target, property, descriptor);
   };
 }
+__name(ResolveAnnotation, "ResolveAnnotation");
 
 // src/modules/core/annotation.loader.ts
 var import_stitch = require("@graphql-tools/stitch");
 var import_utils = require("@graphql-tools/utils");
 var import_wrap2 = require("@graphql-tools/wrap");
-var import_common3 = require("@nestjs/common");
-var import_graphql3 = require("@nestjs/graphql");
+var import_common4 = require("@nestjs/common");
+var import_core3 = require("@nestjs/core");
+var import_graphql4 = require("@nestjs/graphql");
 var import_gql_paramtype = require("@nestjs/graphql/dist/enums/gql-paramtype.enum");
 var import_graphql_request = require("graphql-request");
 
 // src/modules/core/annotation.resolver.ts
-var import_common2 = require("@nestjs/common");
-var import_graphql2 = require("@nestjs/graphql");
+var import_common3 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+var import_graphql3 = require("@nestjs/graphql");
 var import_graphql_scalars = require("graphql-scalars");
 var import_reflect_metadata2 = require("reflect-metadata");
+
+// src/modules/core/resolver.explorer.ts
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_graphql2 = require("@nestjs/graphql");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var ResolverDiscoveryService = class {
+  static {
+    __name(this, "ResolverDiscoveryService");
+  }
+  discoveryService;
+  constructor(discoveryService) {
+    this.discoveryService = discoveryService;
+  }
+  explore() {
+    const wrappedProviders = this.discoveryService.getProviders();
+    return wrappedProviders.flatMap((wrapped) => {
+      const { instance } = wrapped;
+      if (!instance) return [];
+      const isResolver = Reflect.hasMetadata(import_graphql2.RESOLVER_TYPE_METADATA, instance.constructor);
+      if (!isResolver) return [];
+      return wrapped;
+    });
+  }
+};
+ResolverDiscoveryService = _ts_decorate([
+  (0, import_common2.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService
+  ])
+], ResolverDiscoveryService);
+
+// src/modules/core/annotation.resolver.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
 var GraphQLAnnotationMeta = class {
+  static {
+    __name(this, "GraphQLAnnotationMeta");
+  }
   name;
   resolvers;
 };
-__decorateClass([
-  (0, import_graphql2.Field)(() => String)
-], GraphQLAnnotationMeta.prototype, "name", 2);
-__decorateClass([
-  (0, import_graphql2.Field)(() => import_graphql_scalars.GraphQLJSONObject, { name: "resolvers" })
-], GraphQLAnnotationMeta.prototype, "resolvers", 2);
-GraphQLAnnotationMeta = __decorateClass([
-  (0, import_graphql2.ObjectType)()
+_ts_decorate2([
+  (0, import_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], GraphQLAnnotationMeta.prototype, "name", void 0);
+_ts_decorate2([
+  (0, import_graphql3.Field)(() => import_graphql_scalars.GraphQLJSONObject, {
+    name: "resolvers"
+  }),
+  _ts_metadata2("design:type", typeof GraphQLResolversAnnotations === "undefined" ? Object : GraphQLResolversAnnotations)
+], GraphQLAnnotationMeta.prototype, "resolvers", void 0);
+GraphQLAnnotationMeta = _ts_decorate2([
+  (0, import_graphql3.ObjectType)()
 ], GraphQLAnnotationMeta);
+var ANNOTATION_QUERY_NAME = "_annotations";
 var GraphQLAnnotationResolver = class {
+  static {
+    __name(this, "GraphQLAnnotationResolver");
+  }
+  metadataScanner;
+  resolverDiscoveryService;
+  meta;
+  _logger = new import_common3.Logger("GraphQLAnnotationModule");
   constructor(metadataScanner, resolverDiscoveryService, meta) {
     this.metadataScanner = metadataScanner;
     this.resolverDiscoveryService = resolverDiscoveryService;
     this.meta = meta;
   }
-  _logger = new import_common2.Logger("GraphQLAnnotationModule");
   async getGraphQLAnnotations() {
     return {
       ...this.meta,
@@ -172,41 +231,36 @@ var GraphQLAnnotationResolver = class {
   compileResolversAnnotations() {
     const instances = this.resolverDiscoveryService.explore();
     const resolversAnnotations = {};
-    for (const { instance } of instances)
-      for (const methodName of this.metadataScanner.getAllMethodNames(
-        Object.getPrototypeOf(instance)
-      )) {
-        const annotations = [
-          ...Object.values(
-            Reflect.getMetadata(ANNOTATION_METADATA, instance[methodName]) ?? {}
-          ),
-          ...Object.values(
-            Reflect.getMetadata(
-              ANNOTATION_METADATA,
-              instance.constructor,
-              methodName
-            ) ?? {}
-          )
-        ];
-        if (annotations.length <= 0) continue;
-        resolversAnnotations[methodName] = annotations;
-        this._logger.log(
-          `Discovered annotated resolver "${instance.constructor.name}.${methodName}" with ${annotations.length} annotation(s)`
-        );
-      }
+    for (const { instance } of instances) for (const methodName of this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance))) {
+      const annotations = [
+        ...Object.values(Reflect.getMetadata(ANNOTATION_METADATA, instance[methodName]) ?? {}),
+        ...Object.values(Reflect.getMetadata(ANNOTATION_METADATA, instance.constructor, methodName) ?? {})
+      ];
+      if (annotations.length <= 0) continue;
+      resolversAnnotations[methodName] = annotations;
+      this._logger.log(`Discovered annotated resolver "${instance.constructor.name}.${methodName}" with ${annotations.length} annotation(s)`);
+    }
     return resolversAnnotations;
   }
 };
-__publicField(GraphQLAnnotationResolver, "QUERY_NAME", "_annotations");
-__decorateClass([
-  (0, import_graphql2.Query)(() => GraphQLAnnotationMeta, {
-    name: GraphQLAnnotationResolver.QUERY_NAME
-  })
-], GraphQLAnnotationResolver.prototype, "getGraphQLAnnotations", 1);
-GraphQLAnnotationResolver = __decorateClass([
-  (0, import_graphql2.Resolver)(),
-  (0, import_common2.Injectable)(),
-  __decorateParam(2, (0, import_common2.Inject)(ANNOTATION_RESOLVER_METADATA))
+_ts_decorate2([
+  (0, import_graphql3.Query)(() => GraphQLAnnotationMeta, {
+    name: ANNOTATION_QUERY_NAME
+  }),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", Promise)
+], GraphQLAnnotationResolver.prototype, "getGraphQLAnnotations", null);
+GraphQLAnnotationResolver = _ts_decorate2([
+  (0, import_graphql3.Resolver)(),
+  (0, import_common3.Injectable)(),
+  _ts_param(2, (0, import_common3.Inject)(ANNOTATION_RESOLVER_METADATA)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof import_core2.MetadataScanner === "undefined" ? Object : import_core2.MetadataScanner,
+    typeof ResolverDiscoveryService === "undefined" ? Object : ResolverDiscoveryService,
+    typeof GraphQLAnnotationResolverMetadata === "undefined" ? Object : GraphQLAnnotationResolverMetadata
+  ])
 ], GraphQLAnnotationResolver);
 
 // src/modules/core/annotation.utils.ts
@@ -219,9 +273,9 @@ async function loadGraphQLSchema(url) {
   return {
     schema: await (0, import_wrap.schemaFromExecutor)(executor),
     executor
-    // Has to be included.
   };
 }
+__name(loadGraphQLSchema, "loadGraphQLSchema");
 function split(array, predicate) {
   const match = [];
   const rest = [];
@@ -235,71 +289,64 @@ function split(array, predicate) {
     rest
   ];
 }
+__name(split, "split");
 function shallowMerge(objects) {
   const res = {};
   objects.forEach((o) => Object.assign(res, o));
   return res;
 }
+__name(shallowMerge, "shallowMerge");
 function isPlainObject(obj) {
   const prototype = Object.getPrototypeOf(obj);
   return prototype === Object.getPrototypeOf({}) || prototype === null;
 }
+__name(isPlainObject, "isPlainObject");
 
 // src/modules/core/annotation.loader.ts
 var import_class_transformer = require("class-transformer");
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
 var GraphQLAnnotatedSchemaLoader = class {
+  static {
+    __name(this, "GraphQLAnnotatedSchemaLoader");
+  }
+  resolverDiscoveryService;
+  metadataScanner;
+  externalContextCreator;
+  _logger = new import_common4.Logger("GraphQLAnnotationModule");
   constructor(resolverDiscoveryService, metadataScanner, externalContextCreator) {
     this.resolverDiscoveryService = resolverDiscoveryService;
     this.metadataScanner = metadataScanner;
     this.externalContextCreator = externalContextCreator;
   }
-  _logger = new import_common3.Logger("GraphQLAnnotationModule");
   async load(sources) {
     const loadedSources = await this.batchLoadSources(sources);
     const schema = (0, import_stitch.stitchSchemas)({
       subschemas: loadedSources.map((s) => s.subschema)
     });
-    const annotations = shallowMerge(
-      loadedSources.map((s) => s.annotation)
-    );
+    const annotations = shallowMerge(loadedSources.map((s) => s.annotation));
     const annotationResolvers = await this.discoverAnnotationResolvers();
-    return this.embedAnnotationResolversToSchema(
-      schema,
-      annotations,
-      annotationResolvers
-    );
+    return this.embedAnnotationResolversToSchema(schema, annotations, annotationResolvers);
   }
   async discoverAnnotationResolvers() {
     const annotationResolvers = /* @__PURE__ */ new Map();
     const paramFactory = new GraphQLAnnotationResolverParamsFactory();
     const instances = this.resolverDiscoveryService.explore();
-    for (const { instance } of instances)
-      for (const methodName of this.metadataScanner.getAllMethodNames(
-        Object.getPrototypeOf(instance)
-      )) {
-        const resolverMeta = Reflect.getMetadata(
-          ANNOTATION_RESOLVER_METADATA,
-          instance[methodName]
-        );
-        if (!resolverMeta) continue;
-        this._logger.log(
-          `Discovered resolver for annotation "${resolverMeta.annotation}"`
-        );
-        annotationResolvers.set(
-          resolverMeta.annotation,
-          this.externalContextCreator.create(
-            instance,
-            instance[methodName],
-            methodName,
-            import_graphql3.PARAM_ARGS_METADATA,
-            paramFactory,
-            void 0,
-            void 0,
-            void 0,
-            "graphql"
-          )
-        );
-      }
+    for (const { instance } of instances) for (const methodName of this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance))) {
+      const resolverMeta = Reflect.getMetadata(ANNOTATION_RESOLVER_METADATA, instance[methodName]);
+      if (!resolverMeta) continue;
+      this._logger.log(`Discovered resolver for annotation "${resolverMeta.annotation}"`);
+      annotationResolvers.set(resolverMeta.annotation, this.externalContextCreator.create(instance, instance[methodName], methodName, import_graphql4.PARAM_ARGS_METADATA, paramFactory, void 0, void 0, void 0, "graphql"));
+    }
     return annotationResolvers;
   }
   async batchLoadSources(sources) {
@@ -314,9 +361,7 @@ var GraphQLAnnotatedSchemaLoader = class {
           annotation: await this.loadAnnotations(url)
         };
         loaded2.subschema.transforms = [
-          new import_wrap2.FilterRootFields(
-            (op, fieldName) => !fieldName.endsWith(GraphQLAnnotationResolver.QUERY_NAME)
-          )
+          new import_wrap2.FilterRootFields((op, fieldName) => !fieldName.endsWith(ANNOTATION_QUERY_NAME))
         ];
         this._logger.log(`Loaded schema for ${loadId}`);
         return loaded2;
@@ -325,14 +370,8 @@ var GraphQLAnnotatedSchemaLoader = class {
         throw err;
       }
     });
-    const [loaded, failed] = split(
-      await Promise.allSettled(pending),
-      (q) => q.status === "fulfilled"
-    );
-    if (failed.length > 0)
-      throw new Error(
-        `Failed to load ${failed.length} schema(s) from sources.`
-      );
+    const [loaded, failed] = split(await Promise.allSettled(pending), (q) => q.status === "fulfilled");
+    if (failed.length > 0) throw new Error(`Failed to load ${failed.length} schema(s) from sources.`);
     return loaded.map((l) => l.value);
   }
   async loadAnnotations(url) {
@@ -340,14 +379,14 @@ var GraphQLAnnotatedSchemaLoader = class {
     try {
       const res = await client.rawRequest(`
         query IntrospectAnnotations {
-          ${GraphQLAnnotationResolver.QUERY_NAME} {
+          ${ANNOTATION_QUERY_NAME} {
             name
             resolvers
           }
         }
       `);
       this._logger.log(`Loaded annotations for ${url}`);
-      return res.data[GraphQLAnnotationResolver.QUERY_NAME];
+      return res.data[ANNOTATION_QUERY_NAME];
     } catch (err) {
       this._logger.warn(`Failed to load annotations at ${url}, assuming empty`);
       return {};
@@ -359,65 +398,58 @@ var GraphQLAnnotatedSchemaLoader = class {
         const fieldAnnotations = (annotations.resolvers[name] ?? []).map((info) => ({
           ...info,
           resolver: annotationResolvers.get(info.annotation)
-          // NOTE: should be validated in filter
         })).filter((info) => {
           const annotationHasResolver = info.resolver !== void 0;
-          if (!annotationHasResolver)
-            this._logger.warn(
-              `Found unhandled annotation "${info.annotation}", skipping linking process`
-            );
+          if (!annotationHasResolver) this._logger.warn(`Found unhandled annotation "${info.annotation}", skipping linking process`);
           return annotationHasResolver;
         });
         if (fieldAnnotations.length <= 0) return fieldSchema;
-        for (const annotation of fieldAnnotations)
-          if (annotation.target.type === "parameter" && fieldSchema.args)
-            delete fieldSchema.args[annotation.target.paramName];
+        for (const annotation of fieldAnnotations) if (annotation.target.type === "parameter" && fieldSchema.args) delete fieldSchema.args[annotation.target.paramName];
         const defaultResolver = fieldSchema.resolve;
         fieldSchema.resolve = async function(parent, args, context, info) {
-          const annotationCallbacks = await Promise.all(
-            fieldAnnotations.map(async (annotation) => ({
-              annotation,
-              return: await annotation.resolver(
-                ...[
-                  info.rootValue,
-                  annotation.data,
-                  context,
-                  info
-                ]
-              )
-            }))
-          );
-          const resolvedParams = annotationCallbacks.reduce(
-            (params, call) => {
-              if (call.annotation.target.type !== "parameter") return params;
-              const returnedClassType = typeof call.return === "object" && !isPlainObject(call.return);
-              const returnValue = returnedClassType ? (0, import_class_transformer.instanceToPlain)(call.return) : call.return;
-              params[call.annotation.target.paramName] = returnValue;
-              return params;
-            },
-            {}
-          );
-          return defaultResolver(
-            parent,
-            { ...args, ...resolvedParams },
-            context,
-            info
-          );
+          const annotationCallbacks = await Promise.all(fieldAnnotations.map(async (annotation) => ({
+            annotation,
+            return: await annotation.resolver(...[
+              info.rootValue,
+              annotation.data,
+              context,
+              info
+            ])
+          })));
+          const resolvedParams = annotationCallbacks.reduce((params, call) => {
+            if (call.annotation.target.type !== "parameter") return params;
+            const returnedClassType = typeof call.return === "object" && !isPlainObject(call.return);
+            const returnValue = returnedClassType ? (0, import_class_transformer.instanceToPlain)(call.return) : call.return;
+            params[call.annotation.target.paramName] = returnValue;
+            return params;
+          }, {});
+          return defaultResolver(parent, {
+            ...args,
+            ...resolvedParams
+          }, context, info);
         };
         return fieldSchema;
       }
     });
   }
 };
-GraphQLAnnotatedSchemaLoader = __decorateClass([
-  (0, import_common3.Injectable)()
+GraphQLAnnotatedSchemaLoader = _ts_decorate3([
+  (0, import_common4.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ResolverDiscoveryService === "undefined" ? Object : ResolverDiscoveryService,
+    typeof import_core3.MetadataScanner === "undefined" ? Object : import_core3.MetadataScanner,
+    typeof import_core3.ExternalContextCreator === "undefined" ? Object : import_core3.ExternalContextCreator
+  ])
 ], GraphQLAnnotatedSchemaLoader);
-var GraphQLAnnotationResolverParamsFactory = class {
+var GraphQLAnnotationResolverParamsFactory = class GraphQLAnnotationResolverParamsFactory2 {
+  static {
+    __name(this, "GraphQLAnnotationResolverParamsFactory");
+  }
   // This param factory extends graphql's own just with different inputs from annotations instead.
   // https://github.com/nestjs/graphql/blob/master/packages/graphql/lib/factories/params.factory.ts#L9
   exchangeKeyForValue(type, possibleKey, argsContext) {
     if (!argsContext) return null;
-    console.log(type, possibleKey, argsContext);
     const args = {
       parentValue: argsContext[0],
       data: argsContext[1],
@@ -441,62 +473,55 @@ var GraphQLAnnotationResolverParamsFactory = class {
 
 // src/modules/core/annotation.module.ts
 var import_common5 = require("@nestjs/common");
-var import_core = require("@nestjs/core");
-
-// src/modules/core/resolver.explorer.ts
-var import_common4 = require("@nestjs/common");
-var import_graphql4 = require("@nestjs/graphql");
-var ResolverDiscoveryService = class {
-  constructor(discoveryService) {
-    this.discoveryService = discoveryService;
-  }
-  explore() {
-    const wrappedProviders = this.discoveryService.getProviders();
-    return wrappedProviders.flatMap((wrapped) => {
-      const { instance } = wrapped;
-      if (!instance) return [];
-      const isResolver = Reflect.hasMetadata(
-        import_graphql4.RESOLVER_TYPE_METADATA,
-        instance.constructor
-      );
-      if (!isResolver) return [];
-      return wrapped;
-    });
+var import_core4 = require("@nestjs/core");
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var GraphQLAnnotationModule = class _GraphQLAnnotationModule {
+  static {
+    __name(this, "GraphQLAnnotationModule");
   }
-};
-ResolverDiscoveryService = __decorateClass([
-  (0, import_common4.Injectable)()
-], ResolverDiscoveryService);
-
-// src/modules/core/annotation.module.ts
-var GraphQLAnnotationModule = class {
   static forRoot(opts) {
-    if (opts?.serveAnnotations)
-      return {
-        global: true,
-        module: GraphQLAnnotationModule,
-        imports: [import_core.DiscoveryModule],
-        providers: [
-          ResolverDiscoveryService,
-          GraphQLAnnotatedSchemaLoader,
-          {
-            provide: ANNOTATION_RESOLVER_METADATA,
-            useValue: opts.serveConfig
-          },
-          GraphQLAnnotationResolver
-        ],
-        exports: [GraphQLAnnotatedSchemaLoader]
-      };
+    if (opts?.serveAnnotations) return {
+      global: true,
+      module: _GraphQLAnnotationModule,
+      imports: [
+        import_core4.DiscoveryModule
+      ],
+      providers: [
+        ResolverDiscoveryService,
+        GraphQLAnnotatedSchemaLoader,
+        {
+          provide: ANNOTATION_RESOLVER_METADATA,
+          useValue: opts.serveConfig
+        },
+        GraphQLAnnotationResolver
+      ],
+      exports: [
+        GraphQLAnnotatedSchemaLoader
+      ]
+    };
     return {
       global: true,
-      module: GraphQLAnnotationModule,
-      imports: [import_core.DiscoveryModule],
-      providers: [ResolverDiscoveryService, GraphQLAnnotatedSchemaLoader],
-      exports: [GraphQLAnnotatedSchemaLoader]
+      module: _GraphQLAnnotationModule,
+      imports: [
+        import_core4.DiscoveryModule
+      ],
+      providers: [
+        ResolverDiscoveryService,
+        GraphQLAnnotatedSchemaLoader
+      ],
+      exports: [
+        GraphQLAnnotatedSchemaLoader
+      ]
     };
   }
 };
-GraphQLAnnotationModule = __decorateClass([
+GraphQLAnnotationModule = _ts_decorate4([
   (0, import_common5.Module)({})
 ], GraphQLAnnotationModule);
 // Annotate the CommonJS export names for ESM import in node: