@graphql-mesh/transform-hive 0.1.77

package/index.d.ts

@@ -0,0 +1,16 @@
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { HiveClient } from '@graphql-hive/client';
+import { ExecutionResult, GraphQLSchema } from 'graphql';
+import { DelegationContext } from '@graphql-tools/delegate';
+import { ExecutionRequest } from '@graphql-tools/utils';
+interface TransformationContext {
+    collectUsageCallback: ReturnType<HiveClient['collectUsage']>;
+}
+export default class HiveTransform implements MeshTransform {
+    private hiveClient;
+    constructor({ config, pubsub, logger }: MeshTransformOptions<YamlConfig.HivePlugin>);
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+    transformRequest(request: ExecutionRequest, delegationContext: DelegationContext, transformationContext: TransformationContext): ExecutionRequest<Record<string, any>, any, any, Record<string, any>>;
+    transformResult(result: ExecutionResult, _delegationContext: DelegationContext, transformationContext: TransformationContext): ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>;
+}
+export {};

package/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const client = require('@graphql-hive/client');
+const stringInterpolation = require('@graphql-mesh/string-interpolation');
+const crossHelpers = require('@graphql-mesh/cross-helpers');
+
+class HiveTransform {
+    constructor({ config, pubsub, logger }) {
+        var _a;
+        const token = stringInterpolation.stringInterpolator.parse(config.token, {
+            env: crossHelpers.process.env,
+        });
+        let usage;
+        if (config.usage) {
+            usage = {
+                max: config.usage.max,
+                ttl: config.usage.ttl,
+                exclude: config.usage.exclude,
+                sampleRate: config.usage.sampleRate,
+                processVariables: config.usage.processVariables,
+            };
+            if ((_a = config.usage) === null || _a === void 0 ? void 0 : _a.clientInfo) {
+                usage.clientInfo = function (context) {
+                    return {
+                        name: stringInterpolation.stringInterpolator.parse(config.usage.clientInfo.name, { context, env: crossHelpers.process.env }),
+                        version: stringInterpolation.stringInterpolator.parse(config.usage.clientInfo.version, { context, env: crossHelpers.process.env }),
+                    };
+                };
+            }
+        }
+        let reporting;
+        if (config.reporting) {
+            reporting = {
+                author: stringInterpolation.stringInterpolator.parse(config.reporting.author, { env: crossHelpers.process.env }),
+                commit: stringInterpolation.stringInterpolator.parse(config.reporting.commit, { env: crossHelpers.process.env }),
+                serviceName: stringInterpolation.stringInterpolator.parse(config.reporting.serviceName, { env: crossHelpers.process.env }),
+                serviceUrl: stringInterpolation.stringInterpolator.parse(config.reporting.serviceUrl, { env: crossHelpers.process.env }),
+            };
+        }
+        const agent = {
+            timeout: config.agent.timeout,
+            maxRetries: config.agent.maxRetries,
+            minTimeout: config.agent.minTimeout,
+            sendInterval: config.agent.sendInterval,
+            maxSize: config.agent.maxSize,
+            logger,
+        };
+        this.hiveClient = client.createHive({
+            enabled: true,
+            debug: !!crossHelpers.process.env.DEBUG,
+            token,
+            agent,
+            usage,
+            reporting,
+        });
+        const id = pubsub.subscribe('destroy', () => {
+            this.hiveClient
+                .dispose()
+                .catch(e => logger.error(`Hive client failed to dispose`, e))
+                .finally(() => pubsub.unsubscribe(id));
+        });
+    }
+    transformSchema(schema) {
+        this.hiveClient.reportSchema({ schema });
+        return schema;
+    }
+    transformRequest(request, delegationContext, transformationContext) {
+        transformationContext.collectUsageCallback = this.hiveClient.collectUsage({
+            schema: delegationContext.transformedSchema,
+            document: request.document,
+            rootValue: request.rootValue,
+            contextValue: request.context,
+            variableValues: request.variables,
+            operationName: request.operationName,
+        });
+        return request;
+    }
+    transformResult(result, _delegationContext, transformationContext) {
+        transformationContext.collectUsageCallback(result);
+        return result;
+    }
+}
+
+module.exports = HiveTransform;

package/index.mjs

@@ -0,0 +1,82 @@
+import { createHive } from '@graphql-hive/client';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { process } from '@graphql-mesh/cross-helpers';
+
+class HiveTransform {
+    constructor({ config, pubsub, logger }) {
+        var _a;
+        const token = stringInterpolator.parse(config.token, {
+            env: process.env,
+        });
+        let usage;
+        if (config.usage) {
+            usage = {
+                max: config.usage.max,
+                ttl: config.usage.ttl,
+                exclude: config.usage.exclude,
+                sampleRate: config.usage.sampleRate,
+                processVariables: config.usage.processVariables,
+            };
+            if ((_a = config.usage) === null || _a === void 0 ? void 0 : _a.clientInfo) {
+                usage.clientInfo = function (context) {
+                    return {
+                        name: stringInterpolator.parse(config.usage.clientInfo.name, { context, env: process.env }),
+                        version: stringInterpolator.parse(config.usage.clientInfo.version, { context, env: process.env }),
+                    };
+                };
+            }
+        }
+        let reporting;
+        if (config.reporting) {
+            reporting = {
+                author: stringInterpolator.parse(config.reporting.author, { env: process.env }),
+                commit: stringInterpolator.parse(config.reporting.commit, { env: process.env }),
+                serviceName: stringInterpolator.parse(config.reporting.serviceName, { env: process.env }),
+                serviceUrl: stringInterpolator.parse(config.reporting.serviceUrl, { env: process.env }),
+            };
+        }
+        const agent = {
+            timeout: config.agent.timeout,
+            maxRetries: config.agent.maxRetries,
+            minTimeout: config.agent.minTimeout,
+            sendInterval: config.agent.sendInterval,
+            maxSize: config.agent.maxSize,
+            logger,
+        };
+        this.hiveClient = createHive({
+            enabled: true,
+            debug: !!process.env.DEBUG,
+            token,
+            agent,
+            usage,
+            reporting,
+        });
+        const id = pubsub.subscribe('destroy', () => {
+            this.hiveClient
+                .dispose()
+                .catch(e => logger.error(`Hive client failed to dispose`, e))
+                .finally(() => pubsub.unsubscribe(id));
+        });
+    }
+    transformSchema(schema) {
+        this.hiveClient.reportSchema({ schema });
+        return schema;
+    }
+    transformRequest(request, delegationContext, transformationContext) {
+        transformationContext.collectUsageCallback = this.hiveClient.collectUsage({
+            schema: delegationContext.transformedSchema,
+            document: request.document,
+            rootValue: request.rootValue,
+            contextValue: request.context,
+            variableValues: request.variables,
+            operationName: request.operationName,
+        });
+        return request;
+    }
+    transformResult(result, _delegationContext, transformationContext) {
+        transformationContext.collectUsageCallback(result);
+        return result;
+    }
+}
+
+export default HiveTransform;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@graphql-mesh/transform-hive",
+  "version": "0.1.77",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "*"
+  },
+  "dependencies": {
+    "@graphql-hive/client": "0.21.1",
+    "@graphql-mesh/cross-helpers": "0.2.10",
+    "@graphql-mesh/string-interpolation": "0.3.3",
+    "@graphql-mesh/types": "0.86.0",
+    "@graphql-tools/delegate": "9.0.17",
+    "@graphql-tools/utils": "9.1.1",
+    "tslib": "^2.4.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/transforms/hive"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}