@tinkerstack/graphql-annotation 0.0.0

package/dist/index.js

@@ -0,0 +1,511 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 = {};
+__export(index_exports, {
+  ANNOTATION_METADATA: () => ANNOTATION_METADATA,
+  ANNOTATION_RESOLVER_METADATA: () => ANNOTATION_RESOLVER_METADATA,
+  Annotate: () => Annotate,
+  GRAPHQL_ANNOTATION_RESOLVER_METADATA: () => GRAPHQL_ANNOTATION_RESOLVER_METADATA,
+  GraphQLAnnotatedSchemaLoader: () => GraphQLAnnotatedSchemaLoader,
+  GraphQLAnnotationModule: () => GraphQLAnnotationModule,
+  ResolveAnnotation: () => ResolveAnnotation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/modules/core/annotation.decorators.ts
+var import_common = require("@nestjs/common");
+var import_graphql = require("@nestjs/graphql");
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/modules/core/annotation.constants.ts
+var ANNOTATION_METADATA = "graphql-annotation";
+var ANNOTATION_RESOLVER_METADATA = "graphql-annotation-resolver";
+var GRAPHQL_ANNOTATION_RESOLVER_METADATA = "graphql-annotation-provider";
+
+// src/modules/core/annotation.decorators.ts
+function Annotate(name, opts) {
+  const annotationName = name;
+  const annotationData = opts?.data;
+  return (target, propertyKey, descriptorOrParameterIndex) => {
+    switch (typeof descriptorOrParameterIndex) {
+      // Method
+      case "object": {
+        const descriptor = descriptorOrParameterIndex;
+        _updateAnnotation(descriptor.value ?? target, (meta) => ({
+          ...meta,
+          [annotationName]: {
+            annotation: annotationName,
+            data: annotationData,
+            target: {
+              type: "method",
+              name: propertyKey
+            }
+          }
+        }));
+        break;
+      }
+      // Parameter
+      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
+              }
+            }
+          }),
+          propertyKey
+        );
+        break;
+      }
+      default:
+        throw new Error(
+          `Unable to attach annotation "${name}". Unsupported target.`
+        );
+    }
+  };
+}
+function _updateAnnotation(target, updateFn, propertyKey) {
+  const meta = Reflect.getMetadata(ANNOTATION_METADATA, target) ?? {};
+  if (propertyKey)
+    Reflect.defineMetadata(
+      ANNOTATION_METADATA,
+      updateFn(meta),
+      target,
+      propertyKey
+    );
+  else Reflect.defineMetadata(ANNOTATION_METADATA, updateFn(meta), target);
+}
+function ResolveAnnotation(name) {
+  return (target, property, descriptor) => {
+    (0, import_common.SetMetadata)(ANNOTATION_RESOLVER_METADATA, {
+      annotation: name ?? property
+    })(target, property, descriptor);
+  };
+}
+
+// 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_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_graphql_scalars = require("graphql-scalars");
+var import_reflect_metadata2 = require("reflect-metadata");
+var GraphQLAnnotationMeta = class {
+  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)()
+], GraphQLAnnotationMeta);
+var GraphQLAnnotationResolver = class {
+  constructor(metadataScanner, resolverDiscoveryService, meta) {
+    this.metadataScanner = metadataScanner;
+    this.resolverDiscoveryService = resolverDiscoveryService;
+    this.meta = meta;
+  }
+  _logger = new import_common2.Logger("GraphQLAnnotationModule");
+  async getGraphQLAnnotations() {
+    return {
+      ...this.meta,
+      resolvers: this.resolverAnnotations
+    };
+  }
+  resolverAnnotations = {};
+  async onModuleInit() {
+    this.resolverAnnotations = this.compileResolversAnnotations();
+  }
+  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)`
+        );
+      }
+    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))
+], GraphQLAnnotationResolver);
+
+// src/modules/core/annotation.utils.ts
+var import_executor_http = require("@graphql-tools/executor-http");
+var import_wrap = require("@graphql-tools/wrap");
+async function loadGraphQLSchema(url) {
+  const executor = (0, import_executor_http.buildHTTPExecutor)({
+    endpoint: url
+  });
+  return {
+    schema: await (0, import_wrap.schemaFromExecutor)(executor),
+    executor
+    // Has to be included.
+  };
+}
+function split(array, predicate) {
+  const match = [];
+  const rest = [];
+  array.forEach((item) => {
+    const matchedPredicate = predicate(item);
+    const target = matchedPredicate ? match : rest;
+    target.push(item);
+  });
+  return [
+    match,
+    rest
+  ];
+}
+function shallowMerge(objects) {
+  const res = {};
+  objects.forEach((o) => Object.assign(res, o));
+  return res;
+}
+function isPlainObject(obj) {
+  const prototype = Object.getPrototypeOf(obj);
+  return prototype === Object.getPrototypeOf({}) || prototype === null;
+}
+
+// src/modules/core/annotation.loader.ts
+var import_class_transformer = require("class-transformer");
+var GraphQLAnnotatedSchemaLoader = class {
+  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 annotationResolvers = await this.discoverAnnotationResolvers();
+    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"
+          )
+        );
+      }
+    return annotationResolvers;
+  }
+  async batchLoadSources(sources) {
+    const pending = Object.entries(sources).map(async ([name, url]) => {
+      const loadId = `${name}@${url}`;
+      try {
+        const loaded2 = {
+          id: loadId,
+          url,
+          name,
+          subschema: await loadGraphQLSchema(url),
+          annotation: await this.loadAnnotations(url)
+        };
+        loaded2.subschema.transforms = [
+          new import_wrap2.FilterRootFields(
+            (op, fieldName) => !fieldName.endsWith(GraphQLAnnotationResolver.QUERY_NAME)
+          )
+        ];
+        this._logger.log(`Loaded schema for ${loadId}`);
+        return loaded2;
+      } catch (err) {
+        this._logger.error(`Unable to load schema for ${loadId}`);
+        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.`
+      );
+    return loaded.map((l) => l.value);
+  }
+  async loadAnnotations(url) {
+    const client = new import_graphql_request.GraphQLClient(url);
+    try {
+      const res = await client.rawRequest(`
+        query IntrospectAnnotations {
+          ${GraphQLAnnotationResolver.QUERY_NAME} {
+            name
+            resolvers
+          }
+        }
+      `);
+      this._logger.log(`Loaded annotations for ${url}`);
+      return res.data[GraphQLAnnotationResolver.QUERY_NAME];
+    } catch (err) {
+      this._logger.warn(`Failed to load annotations at ${url}, assuming empty`);
+      return {};
+    }
+  }
+  async embedAnnotationResolversToSchema(schema, annotations, annotationResolvers) {
+    return (0, import_utils.mapSchema)(schema, {
+      [import_utils.MapperKind.ROOT_FIELD]: (fieldSchema, name, type) => {
+        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`
+            );
+          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];
+        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
+          );
+        };
+        return fieldSchema;
+      }
+    });
+  }
+};
+GraphQLAnnotatedSchemaLoader = __decorateClass([
+  (0, import_common3.Injectable)()
+], GraphQLAnnotatedSchemaLoader);
+var GraphQLAnnotationResolverParamsFactory = class {
+  // 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],
+      context: argsContext[2],
+      info: argsContext[3]
+    };
+    switch (type) {
+      case import_gql_paramtype.GqlParamtype.ROOT:
+        return args.parentValue;
+      case import_gql_paramtype.GqlParamtype.ARGS:
+        return possibleKey && args.data ? args.data[possibleKey] : args.data;
+      case import_gql_paramtype.GqlParamtype.CONTEXT:
+        return possibleKey && args.context ? args.context[possibleKey] : args.context;
+      case import_gql_paramtype.GqlParamtype.INFO:
+        return possibleKey && args.context ? args.info[possibleKey] : args.info;
+      default:
+        return null;
+    }
+  }
+};
+
+// 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;
+    });
+  }
+};
+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]
+      };
+    return {
+      global: true,
+      module: GraphQLAnnotationModule,
+      imports: [import_core.DiscoveryModule],
+      providers: [ResolverDiscoveryService, GraphQLAnnotatedSchemaLoader],
+      exports: [GraphQLAnnotatedSchemaLoader]
+    };
+  }
+};
+GraphQLAnnotationModule = __decorateClass([
+  (0, import_common5.Module)({})
+], GraphQLAnnotationModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANNOTATION_METADATA,
+  ANNOTATION_RESOLVER_METADATA,
+  Annotate,
+  GRAPHQL_ANNOTATION_RESOLVER_METADATA,
+  GraphQLAnnotatedSchemaLoader,
+  GraphQLAnnotationModule,
+  ResolveAnnotation
+});