@tinkerstack/graphql-annotation 0.0.0 → 0.0.2

package/dist/index.mjs

@@ -1,16 +1,5 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-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);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/modules/core/annotation.decorators.ts
 import { SetMetadata } from "@nestjs/common";
@@ -48,47 +37,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.`
-          );
-        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.`);
+        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) => {
     SetMetadata(ANNOTATION_RESOLVER_METADATA, {
@@ -96,43 +76,119 @@ function ResolveAnnotation(name) {
     })(target, property, descriptor);
   };
 }
+__name(ResolveAnnotation, "ResolveAnnotation");
 
 // src/modules/core/annotation.loader.ts
 import { stitchSchemas } from "@graphql-tools/stitch";
 import { MapperKind, mapSchema } from "@graphql-tools/utils";
 import { FilterRootFields } from "@graphql-tools/wrap";
-import { Injectable as Injectable2, Logger as Logger2 } from "@nestjs/common";
-import {
-  PARAM_ARGS_METADATA
-} from "@nestjs/graphql";
+import { Injectable as Injectable3, Logger as Logger2 } from "@nestjs/common";
+import { ExternalContextCreator, MetadataScanner as MetadataScanner2 } from "@nestjs/core";
+import { PARAM_ARGS_METADATA } from "@nestjs/graphql";
 import { GqlParamtype } from "@nestjs/graphql/dist/enums/gql-paramtype.enum";
 import { GraphQLClient } from "graphql-request";
 
 // src/modules/core/annotation.resolver.ts
-import { Inject, Injectable, Logger } from "@nestjs/common";
+import { Inject, Injectable as Injectable2, Logger } from "@nestjs/common";
+import { MetadataScanner } from "@nestjs/core";
 import { Field, ObjectType, Query, Resolver } from "@nestjs/graphql";
 import { GraphQLJSONObject } from "graphql-scalars";
 import "reflect-metadata";
+
+// src/modules/core/resolver.explorer.ts
+import { Injectable } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+import { RESOLVER_TYPE_METADATA } from "@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(RESOLVER_TYPE_METADATA, instance.constructor);
+      if (!isResolver) return [];
+      return wrapped;
+    });
+  }
+};
+ResolverDiscoveryService = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : 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([
-  Field(() => String)
-], GraphQLAnnotationMeta.prototype, "name", 2);
-__decorateClass([
-  Field(() => GraphQLJSONObject, { name: "resolvers" })
-], GraphQLAnnotationMeta.prototype, "resolvers", 2);
-GraphQLAnnotationMeta = __decorateClass([
+_ts_decorate2([
+  Field(() => String),
+  _ts_metadata2("design:type", String)
+], GraphQLAnnotationMeta.prototype, "name", void 0);
+_ts_decorate2([
+  Field(() => GraphQLJSONObject, {
+    name: "resolvers"
+  }),
+  _ts_metadata2("design:type", typeof GraphQLResolversAnnotations === "undefined" ? Object : GraphQLResolversAnnotations)
+], GraphQLAnnotationMeta.prototype, "resolvers", void 0);
+GraphQLAnnotationMeta = _ts_decorate2([
   ObjectType()
 ], GraphQLAnnotationMeta);
+var ANNOTATION_QUERY_NAME = "_annotations";
 var GraphQLAnnotationResolver = class {
+  static {
+    __name(this, "GraphQLAnnotationResolver");
+  }
+  metadataScanner;
+  resolverDiscoveryService;
+  meta;
+  _logger = new Logger("GraphQLAnnotationModule");
   constructor(metadataScanner, resolverDiscoveryService, meta) {
     this.metadataScanner = metadataScanner;
     this.resolverDiscoveryService = resolverDiscoveryService;
     this.meta = meta;
   }
-  _logger = new Logger("GraphQLAnnotationModule");
   async getGraphQLAnnotations() {
     return {
       ...this.meta,
@@ -146,41 +202,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([
+_ts_decorate2([
   Query(() => GraphQLAnnotationMeta, {
-    name: GraphQLAnnotationResolver.QUERY_NAME
-  })
-], GraphQLAnnotationResolver.prototype, "getGraphQLAnnotations", 1);
-GraphQLAnnotationResolver = __decorateClass([
+    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([
   Resolver(),
-  Injectable(),
-  __decorateParam(2, Inject(ANNOTATION_RESOLVER_METADATA))
+  Injectable2(),
+  _ts_param(2, Inject(ANNOTATION_RESOLVER_METADATA)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
+    typeof ResolverDiscoveryService === "undefined" ? Object : ResolverDiscoveryService,
+    typeof GraphQLAnnotationResolverMetadata === "undefined" ? Object : GraphQLAnnotationResolverMetadata
+  ])
 ], GraphQLAnnotationResolver);
 
 // src/modules/core/annotation.utils.ts
@@ -193,9 +244,9 @@ async function loadGraphQLSchema(url) {
   return {
     schema: await schemaFromExecutor(executor),
     executor
-    // Has to be included.
   };
 }
+__name(loadGraphQLSchema, "loadGraphQLSchema");
 function split(array, predicate) {
   const match = [];
   const rest = [];
@@ -209,71 +260,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
 import { instanceToPlain } from "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 Logger2("GraphQLAnnotationModule");
   constructor(resolverDiscoveryService, metadataScanner, externalContextCreator) {
     this.resolverDiscoveryService = resolverDiscoveryService;
     this.metadataScanner = metadataScanner;
     this.externalContextCreator = externalContextCreator;
   }
-  _logger = new Logger2("GraphQLAnnotationModule");
   async load(sources) {
     const loadedSources = await this.batchLoadSources(sources);
     const schema = 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,
-            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, PARAM_ARGS_METADATA, paramFactory, void 0, void 0, void 0, "graphql"));
+    }
     return annotationResolvers;
   }
   async batchLoadSources(sources) {
@@ -288,9 +332,7 @@ var GraphQLAnnotatedSchemaLoader = class {
           annotation: await this.loadAnnotations(url)
         };
         loaded2.subschema.transforms = [
-          new FilterRootFields(
-            (op, fieldName) => !fieldName.endsWith(GraphQLAnnotationResolver.QUERY_NAME)
-          )
+          new FilterRootFields((op, fieldName) => !fieldName.endsWith(ANNOTATION_QUERY_NAME))
         ];
         this._logger.log(`Loaded schema for ${loadId}`);
         return loaded2;
@@ -299,14 +341,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) {
@@ -314,14 +350,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 {};
@@ -333,65 +369,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 ? 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 ? instanceToPlain(call.return) : call.return;
+            params[call.annotation.target.paramName] = returnValue;
+            return params;
+          }, {});
+          return defaultResolver(parent, {
+            ...args,
+            ...resolvedParams
+          }, context, info);
         };
         return fieldSchema;
       }
     });
   }
 };
-GraphQLAnnotatedSchemaLoader = __decorateClass([
-  Injectable2()
+GraphQLAnnotatedSchemaLoader = _ts_decorate3([
+  Injectable3(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ResolverDiscoveryService === "undefined" ? Object : ResolverDiscoveryService,
+    typeof MetadataScanner2 === "undefined" ? Object : MetadataScanner2,
+    typeof ExternalContextCreator === "undefined" ? Object : 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],
@@ -416,61 +445,54 @@ var GraphQLAnnotationResolverParamsFactory = class {
 // src/modules/core/annotation.module.ts
 import { Module } from "@nestjs/common";
 import { DiscoveryModule } from "@nestjs/core";
-
-// src/modules/core/resolver.explorer.ts
-import { Injectable as Injectable3 } from "@nestjs/common";
-import { RESOLVER_TYPE_METADATA } from "@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(
-        RESOLVER_TYPE_METADATA,
-        instance.constructor
-      );
-      if (!isResolver) return [];
-      return wrapped;
-    });
+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([
-  Injectable3()
-], ResolverDiscoveryService);
-
-// src/modules/core/annotation.module.ts
-var GraphQLAnnotationModule = class {
   static forRoot(opts) {
-    if (opts?.serveAnnotations)
-      return {
-        global: true,
-        module: GraphQLAnnotationModule,
-        imports: [DiscoveryModule],
-        providers: [
-          ResolverDiscoveryService,
-          GraphQLAnnotatedSchemaLoader,
-          {
-            provide: ANNOTATION_RESOLVER_METADATA,
-            useValue: opts.serveConfig
-          },
-          GraphQLAnnotationResolver
-        ],
-        exports: [GraphQLAnnotatedSchemaLoader]
-      };
+    if (opts?.serveAnnotations) return {
+      global: true,
+      module: _GraphQLAnnotationModule,
+      imports: [
+        DiscoveryModule
+      ],
+      providers: [
+        ResolverDiscoveryService,
+        GraphQLAnnotatedSchemaLoader,
+        {
+          provide: ANNOTATION_RESOLVER_METADATA,
+          useValue: opts.serveConfig
+        },
+        GraphQLAnnotationResolver
+      ],
+      exports: [
+        GraphQLAnnotatedSchemaLoader
+      ]
+    };
     return {
       global: true,
-      module: GraphQLAnnotationModule,
-      imports: [DiscoveryModule],
-      providers: [ResolverDiscoveryService, GraphQLAnnotatedSchemaLoader],
-      exports: [GraphQLAnnotatedSchemaLoader]
+      module: _GraphQLAnnotationModule,
+      imports: [
+        DiscoveryModule
+      ],
+      providers: [
+        ResolverDiscoveryService,
+        GraphQLAnnotatedSchemaLoader
+      ],
+      exports: [
+        GraphQLAnnotatedSchemaLoader
+      ]
     };
   }
 };
-GraphQLAnnotationModule = __decorateClass([
+GraphQLAnnotationModule = _ts_decorate4([
   Module({})
 ], GraphQLAnnotationModule);
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkerstack/graphql-annotation",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Better type-safe-able graphql directives",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -17,6 +17,9 @@
     "class-transformer": "^0.5.1",
     "graphql-request": "^7.2.0"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "peerDependencies": {
     "@nestjs/common": "^10 || ^11",
     "@nestjs/core": "^10 || ^11",
@@ -36,6 +39,7 @@
     "@nestjs/graphql": "^13.2.3",
     "@nestjs/mapped-types": "^2.1.0",
     "@nestjs/platform-fastify": "^11.1.11",
+    "@swc/core": "^1.15.11",
     "class-validator": "^0.14.2",
     "concurrently": "^9.2.1",
     "eslint": "^9.37.0",