@graphql-mesh/plugin-rate-limit 0.0.0

package/index.d.ts

@@ -0,0 +1,3 @@
+import { MeshPluginOptions, YamlConfig } from '@graphql-mesh/types';
+import { Plugin } from '@envelop/core';
+export default function useMeshRateLimit(options: MeshPluginOptions<YamlConfig.RateLimitPluginConfig>): Plugin;

package/index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+const stringInterpolation = require('@graphql-mesh/string-interpolation');
+const crossHelpers = require('@graphql-mesh/cross-helpers');
+const utils = require('@graphql-tools/utils');
+const minimatch = _interopDefault(require('minimatch'));
+const graphql = require('graphql');
+
+function deleteNode(parent, remaining, currentKey) {
+    const nextKey = remaining.shift();
+    if (nextKey) {
+        const nextParent = currentKey ? parent[currentKey] : parent;
+        return deleteNode(nextParent, remaining, nextKey);
+    }
+    delete parent[currentKey];
+}
+function useMeshRateLimit(options) {
+    return {
+        async onExecute(onExecuteArgs) {
+            const typeInfo = new graphql.TypeInfo(onExecuteArgs.args.schema);
+            const errors = [];
+            const jobs = [];
+            let remainingFields = 0;
+            graphql.visit(onExecuteArgs.args.document, graphql.visitInParallel(options.config.map(config => {
+                const typeMatcher = new minimatch.Minimatch(config.type);
+                const fieldMatcher = new minimatch.Minimatch(config.field);
+                const identifier = stringInterpolation.stringInterpolator.parse(config.identifier, {
+                    env: crossHelpers.process.env,
+                    root: onExecuteArgs.args.rootValue,
+                    context: onExecuteArgs.args.contextValue,
+                });
+                return graphql.visitWithTypeInfo(typeInfo, {
+                    Field: (fieldNode, key, parent, path) => {
+                        const parentType = typeInfo.getParentType();
+                        if (typeMatcher.match(parentType.name)) {
+                            const fieldDef = typeInfo.getFieldDef();
+                            if (fieldMatcher.match(fieldDef.name)) {
+                                const cacheKey = `rate-limit-${identifier}-${parentType.name}.${fieldDef.name}`;
+                                const remainingTokens$ = options.cache.get(cacheKey);
+                                jobs.push(remainingTokens$.then((remainingTokens) => {
+                                    var _a;
+                                    if (remainingTokens == null) {
+                                        remainingTokens = config.max;
+                                    }
+                                    if (remainingTokens === 0) {
+                                        errors.push(utils.createGraphQLError(`Rate limit of "${parentType.name}.${fieldDef.name}" exceeded for "${identifier}"`, {
+                                            path: [((_a = fieldNode.alias) === null || _a === void 0 ? void 0 : _a.value) || fieldDef.name],
+                                        }));
+                                        deleteNode(parent, [...path]);
+                                        remainingFields--;
+                                        return null;
+                                    }
+                                    return options.cache.set(cacheKey, remainingTokens - 1, {
+                                        ttl: config.ttl / 1000,
+                                    });
+                                }));
+                            }
+                        }
+                        remainingFields++;
+                        return false;
+                    },
+                });
+            })));
+            await Promise.all(jobs);
+            if (errors.length > 0) {
+                // If there is a field left in the final selection set
+                if (remainingFields > 0) {
+                    // Add the errors to the final result
+                    return {
+                        onExecuteDone(onExecuteDoneArgs) {
+                            onExecuteDoneArgs.setResult({
+                                ...onExecuteDoneArgs.result,
+                                errors,
+                            });
+                        },
+                    };
+                }
+                // If there is no need to continue the execution, stop
+                onExecuteArgs.setResultAndStopExecution({
+                    data: null,
+                    errors,
+                });
+            }
+            return undefined;
+        },
+    };
+}
+
+module.exports = useMeshRateLimit;

package/index.mjs

@@ -0,0 +1,87 @@
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { process } from '@graphql-mesh/cross-helpers';
+import { createGraphQLError } from '@graphql-tools/utils';
+import minimatch from 'minimatch';
+import { TypeInfo, visit, visitInParallel, visitWithTypeInfo } from 'graphql';
+
+function deleteNode(parent, remaining, currentKey) {
+    const nextKey = remaining.shift();
+    if (nextKey) {
+        const nextParent = currentKey ? parent[currentKey] : parent;
+        return deleteNode(nextParent, remaining, nextKey);
+    }
+    delete parent[currentKey];
+}
+function useMeshRateLimit(options) {
+    return {
+        async onExecute(onExecuteArgs) {
+            const typeInfo = new TypeInfo(onExecuteArgs.args.schema);
+            const errors = [];
+            const jobs = [];
+            let remainingFields = 0;
+            visit(onExecuteArgs.args.document, visitInParallel(options.config.map(config => {
+                const typeMatcher = new minimatch.Minimatch(config.type);
+                const fieldMatcher = new minimatch.Minimatch(config.field);
+                const identifier = stringInterpolator.parse(config.identifier, {
+                    env: process.env,
+                    root: onExecuteArgs.args.rootValue,
+                    context: onExecuteArgs.args.contextValue,
+                });
+                return visitWithTypeInfo(typeInfo, {
+                    Field: (fieldNode, key, parent, path) => {
+                        const parentType = typeInfo.getParentType();
+                        if (typeMatcher.match(parentType.name)) {
+                            const fieldDef = typeInfo.getFieldDef();
+                            if (fieldMatcher.match(fieldDef.name)) {
+                                const cacheKey = `rate-limit-${identifier}-${parentType.name}.${fieldDef.name}`;
+                                const remainingTokens$ = options.cache.get(cacheKey);
+                                jobs.push(remainingTokens$.then((remainingTokens) => {
+                                    var _a;
+                                    if (remainingTokens == null) {
+                                        remainingTokens = config.max;
+                                    }
+                                    if (remainingTokens === 0) {
+                                        errors.push(createGraphQLError(`Rate limit of "${parentType.name}.${fieldDef.name}" exceeded for "${identifier}"`, {
+                                            path: [((_a = fieldNode.alias) === null || _a === void 0 ? void 0 : _a.value) || fieldDef.name],
+                                        }));
+                                        deleteNode(parent, [...path]);
+                                        remainingFields--;
+                                        return null;
+                                    }
+                                    return options.cache.set(cacheKey, remainingTokens - 1, {
+                                        ttl: config.ttl / 1000,
+                                    });
+                                }));
+                            }
+                        }
+                        remainingFields++;
+                        return false;
+                    },
+                });
+            })));
+            await Promise.all(jobs);
+            if (errors.length > 0) {
+                // If there is a field left in the final selection set
+                if (remainingFields > 0) {
+                    // Add the errors to the final result
+                    return {
+                        onExecuteDone(onExecuteDoneArgs) {
+                            onExecuteDoneArgs.setResult({
+                                ...onExecuteDoneArgs.result,
+                                errors,
+                            });
+                        },
+                    };
+                }
+                // If there is no need to continue the execution, stop
+                onExecuteArgs.setResultAndStopExecution({
+                    data: null,
+                    errors,
+                });
+            }
+            return undefined;
+        },
+    };
+}
+
+export default useMeshRateLimit;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@graphql-mesh/plugin-rate-limit",
+  "version": "0.0.0",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "*"
+  },
+  "dependencies": {
+    "@envelop/core": "^2.3.2",
+    "@graphql-mesh/cross-helpers": "0.1.6",
+    "@graphql-mesh/string-interpolation": "0.3.0",
+    "@graphql-mesh/types": "0.76.0",
+    "@graphql-tools/utils": "8.8.0",
+    "minimatch": "5.1.0",
+    "tslib": "^2.4.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/plugins/response-cache"
+  },
+  "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"
+  }
+}