@graphql-mesh/plugin-live-query 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const live_query_1 = require("@envelop/live-query");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const in_memory_live_query_store_1 = require("@n1ru4l/in-memory-live-query-store");
+const useInvalidateByResult_js_1 = require("./useInvalidateByResult.js");
+function useMeshLiveQuery(options) {
+    options.logger.debug(`Creating Live Query Store`);
+    const liveQueryStore = new in_memory_live_query_store_1.InMemoryLiveQueryStore({
+        buildResourceIdentifier: options.resourceIdentifier != null
+            ? function resourceIdentifierFactory({ typename, id }) {
+                return string_interpolation_1.stringInterpolator.parse(options.resourceIdentifier, {
+                    typename,
+                    id,
+                    env: cross_helpers_1.process.env,
+                });
+            }
+            : in_memory_live_query_store_1.defaultResourceIdentifierNormalizer,
+        includeIdentifierExtension: options.includeIdentifierExtension != null
+            ? options.includeIdentifierExtension
+            : cross_helpers_1.process.env.DEBUG === '1',
+        idFieldName: options.idFieldName,
+        indexBy: options.indexBy,
+    });
+    options.pubsub.subscribe('live-query:invalidate', (identifiers) => liveQueryStore.invalidate(identifiers));
+    return {
+        onPluginInit({ addPlugin }) {
+            var _a;
+            addPlugin((0, live_query_1.useLiveQuery)({ liveQueryStore }));
+            if ((_a = options.invalidations) === null || _a === void 0 ? void 0 : _a.length) {
+                addPlugin((0, useInvalidateByResult_js_1.useInvalidateByResult)({
+                    pubsub: options.pubsub,
+                    invalidations: options.invalidations,
+                    logger: options.logger,
+                }));
+            }
+        },
+    };
+}
+exports.default = useMeshLiveQuery;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/useInvalidateByResult.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInvalidateByResult = void 0;
+const graphql_1 = require("graphql");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+function useInvalidateByResult(params) {
+    const liveQueryInvalidationFactoryMap = new Map();
+    params.invalidations.forEach(liveQueryInvalidation => {
+        const rawInvalidationPaths = liveQueryInvalidation.invalidate;
+        const factories = rawInvalidationPaths.map(rawInvalidationPath => (0, string_interpolation_1.getInterpolatedStringFactory)(rawInvalidationPath));
+        liveQueryInvalidationFactoryMap.set(liveQueryInvalidation.field, factories);
+    });
+    return {
+        onExecute() {
+            return {
+                onExecuteDone({ args: executionArgs, result }) {
+                    const { schema, document, operationName, variableValues, rootValue, contextValue } = executionArgs;
+                    const operationAST = (0, graphql_1.getOperationAST)(document, operationName);
+                    if (!operationAST) {
+                        throw new Error(`Operation couldn't be found`);
+                    }
+                    const typeInfo = new graphql_1.TypeInfo(schema);
+                    (0, graphql_1.visit)(operationAST, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+                        Field: fieldNode => {
+                            const parentType = typeInfo.getParentType();
+                            const fieldDef = typeInfo.getFieldDef();
+                            const path = `${parentType.name}.${fieldDef.name}`;
+                            if (liveQueryInvalidationFactoryMap.has(path)) {
+                                const invalidationPathFactories = liveQueryInvalidationFactoryMap.get(path);
+                                const args = (0, graphql_1.getArgumentValues)(fieldDef, fieldNode, variableValues);
+                                const invalidationPaths = invalidationPathFactories.map(invalidationPathFactory => invalidationPathFactory({
+                                    root: rootValue,
+                                    args,
+                                    context: contextValue,
+                                    env: process.env,
+                                    result,
+                                }));
+                                params.pubsub.publish('live-query:invalidate', invalidationPaths);
+                            }
+                        },
+                    }));
+                },
+            };
+        },
+    };
+}
+exports.useInvalidateByResult = useInvalidateByResult;

package/esm/index.js

@@ -0,0 +1,38 @@
+import { useLiveQuery } from '@envelop/live-query';
+import { process } from '@graphql-mesh/cross-helpers';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { defaultResourceIdentifierNormalizer, InMemoryLiveQueryStore, } from '@n1ru4l/in-memory-live-query-store';
+import { useInvalidateByResult } from './useInvalidateByResult.js';
+export default function useMeshLiveQuery(options) {
+    options.logger.debug(`Creating Live Query Store`);
+    const liveQueryStore = new InMemoryLiveQueryStore({
+        buildResourceIdentifier: options.resourceIdentifier != null
+            ? function resourceIdentifierFactory({ typename, id }) {
+                return stringInterpolator.parse(options.resourceIdentifier, {
+                    typename,
+                    id,
+                    env: process.env,
+                });
+            }
+            : defaultResourceIdentifierNormalizer,
+        includeIdentifierExtension: options.includeIdentifierExtension != null
+            ? options.includeIdentifierExtension
+            : process.env.DEBUG === '1',
+        idFieldName: options.idFieldName,
+        indexBy: options.indexBy,
+    });
+    options.pubsub.subscribe('live-query:invalidate', (identifiers) => liveQueryStore.invalidate(identifiers));
+    return {
+        onPluginInit({ addPlugin }) {
+            var _a;
+            addPlugin(useLiveQuery({ liveQueryStore }));
+            if ((_a = options.invalidations) === null || _a === void 0 ? void 0 : _a.length) {
+                addPlugin(useInvalidateByResult({
+                    pubsub: options.pubsub,
+                    invalidations: options.invalidations,
+                    logger: options.logger,
+                }));
+            }
+        },
+    };
+}

package/esm/useInvalidateByResult.js

@@ -0,0 +1,43 @@
+import { getArgumentValues, getOperationAST, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
+import { getInterpolatedStringFactory, } from '@graphql-mesh/string-interpolation';
+export function useInvalidateByResult(params) {
+    const liveQueryInvalidationFactoryMap = new Map();
+    params.invalidations.forEach(liveQueryInvalidation => {
+        const rawInvalidationPaths = liveQueryInvalidation.invalidate;
+        const factories = rawInvalidationPaths.map(rawInvalidationPath => getInterpolatedStringFactory(rawInvalidationPath));
+        liveQueryInvalidationFactoryMap.set(liveQueryInvalidation.field, factories);
+    });
+    return {
+        onExecute() {
+            return {
+                onExecuteDone({ args: executionArgs, result }) {
+                    const { schema, document, operationName, variableValues, rootValue, contextValue } = executionArgs;
+                    const operationAST = getOperationAST(document, operationName);
+                    if (!operationAST) {
+                        throw new Error(`Operation couldn't be found`);
+                    }
+                    const typeInfo = new TypeInfo(schema);
+                    visit(operationAST, visitWithTypeInfo(typeInfo, {
+                        Field: fieldNode => {
+                            const parentType = typeInfo.getParentType();
+                            const fieldDef = typeInfo.getFieldDef();
+                            const path = `${parentType.name}.${fieldDef.name}`;
+                            if (liveQueryInvalidationFactoryMap.has(path)) {
+                                const invalidationPathFactories = liveQueryInvalidationFactoryMap.get(path);
+                                const args = getArgumentValues(fieldDef, fieldNode, variableValues);
+                                const invalidationPaths = invalidationPathFactories.map(invalidationPathFactory => invalidationPathFactory({
+                                    root: rootValue,
+                                    args,
+                                    context: contextValue,
+                                    env: process.env,
+                                    result,
+                                }));
+                                params.pubsub.publish('live-query:invalidate', invalidationPaths);
+                            }
+                        },
+                    }));
+                },
+            };
+        },
+    };
+}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@graphql-mesh/plugin-live-query",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@envelop/core": "^2.3.2",
-    "@envelop/live-query": "3.4.0",
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@n1ru4l/in-memory-live-query-store": "0.9.0",
-    "tslib": "^2.4.0"
+    "@envelop/core": "^3.0.0",
+    "@envelop/live-query": "5.0.6",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@n1ru4l/in-memory-live-query-store": "0.10.0"
   },
   "repository": {
     "type": "git",
@@ -20,21 +20,28 @@
     "directory": "packages/plugins/live-query"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

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

package/typings/useInvalidateByResult.d.cts

@@ -0,0 +1,9 @@
+import { Plugin } from '@envelop/core';
+import { Logger, MeshPubSub, YamlConfig } from '@graphql-mesh/types';
+interface InvalidateByResultParams {
+    pubsub: MeshPubSub;
+    invalidations: YamlConfig.LiveQueryInvalidation[];
+    logger: Logger;
+}
+export declare function useInvalidateByResult(params: InvalidateByResultParams): Plugin;
+export {};

package/{useInvalidateByResult.d.ts → typings/useInvalidateByResult.d.ts}

@@ -1,8 +1,7 @@
 import { Plugin } from '@envelop/core';
-import { Logger, YamlConfig } from '@graphql-mesh/types';
-import { InMemoryLiveQueryStore } from '@n1ru4l/in-memory-live-query-store';
+import { Logger, MeshPubSub, YamlConfig } from '@graphql-mesh/types';
 interface InvalidateByResultParams {
-    liveQueryStore: InMemoryLiveQueryStore;
+    pubsub: MeshPubSub;
     invalidations: YamlConfig.LiveQueryInvalidation[];
     logger: Logger;
 }

package/index.js

@@ -1,80 +0,0 @@
-'use strict';
-
-const liveQuery = require('@envelop/live-query');
-const inMemoryLiveQueryStore = require('@n1ru4l/in-memory-live-query-store');
-const stringInterpolation = require('@graphql-mesh/string-interpolation');
-const graphql = require('graphql');
-
-function useInvalidateByResult(params) {
-    const liveQueryInvalidationFactoryMap = new Map();
-    params.invalidations.forEach(liveQueryInvalidation => {
-        const rawInvalidationPaths = liveQueryInvalidation.invalidate;
-        const factories = rawInvalidationPaths.map(rawInvalidationPath => stringInterpolation.getInterpolatedStringFactory(rawInvalidationPath));
-        liveQueryInvalidationFactoryMap.set(liveQueryInvalidation.field, factories);
-    });
-    return {
-        onExecute() {
-            return {
-                onExecuteDone({ args: executionArgs, result }) {
-                    queueMicrotask(() => {
-                        const { schema, document, operationName, rootValue, contextValue } = executionArgs;
-                        const operationAST = graphql.getOperationAST(document, operationName);
-                        if (!operationAST) {
-                            throw new Error(`Operation couldn't be found`);
-                        }
-                        const typeInfo = new graphql.TypeInfo(schema);
-                        graphql.visit(operationAST, graphql.visitWithTypeInfo(typeInfo, {
-                            Field: () => {
-                                const parentType = typeInfo.getParentType();
-                                const fieldDef = typeInfo.getFieldDef();
-                                const path = `${parentType.name}.${fieldDef.name}`;
-                                if (liveQueryInvalidationFactoryMap.has(path)) {
-                                    const invalidationPathFactories = liveQueryInvalidationFactoryMap.get(path);
-                                    const invalidationPaths = invalidationPathFactories.map(invalidationPathFactory => invalidationPathFactory({
-                                        root: rootValue,
-                                        context: contextValue,
-                                        env: process.env,
-                                        result,
-                                    }));
-                                    params.liveQueryStore
-                                        .invalidate(invalidationPaths)
-                                        .catch((e) => params.logger.warn(`Invalidation failed for ${path}: ${e.message}`));
-                                }
-                            },
-                        }));
-                    });
-                },
-            };
-        },
-    };
-}
-
-function useMeshLiveQuery(options) {
-    var _a;
-    options.logger.debug(`Creating Live Query Store`);
-    const liveQueryStore = new inMemoryLiveQueryStore.InMemoryLiveQueryStore({
-        includeIdentifierExtension: true,
-    });
-    (_a = options.polling) === null || _a === void 0 ? void 0 : _a.forEach(pollingConfig => {
-        const interval = setInterval(() => {
-            liveQueryStore
-                .invalidate(pollingConfig.invalidate)
-                .catch((e) => options.logger.warn(`Invalidation failed for ${pollingConfig.invalidate}: ${e.message}`));
-        }, pollingConfig.interval);
-        const id = options.pubsub.subscribe('destroy', () => {
-            clearInterval(interval);
-            options.pubsub.unsubscribe(id);
-        });
-    });
-    return {
-        onPluginInit({ addPlugin }) {
-            var _a;
-            addPlugin(liveQuery.useLiveQuery({ liveQueryStore }));
-            if ((_a = options.invalidations) === null || _a === void 0 ? void 0 : _a.length) {
-                addPlugin(useInvalidateByResult({ liveQueryStore, invalidations: options.invalidations, logger: options.logger }));
-            }
-        },
-    };
-}
-
-module.exports = useMeshLiveQuery;

package/index.mjs

@@ -1,78 +0,0 @@
-import { useLiveQuery } from '@envelop/live-query';
-import { InMemoryLiveQueryStore } from '@n1ru4l/in-memory-live-query-store';
-import { getInterpolatedStringFactory } from '@graphql-mesh/string-interpolation';
-import { getOperationAST, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
-
-function useInvalidateByResult(params) {
-    const liveQueryInvalidationFactoryMap = new Map();
-    params.invalidations.forEach(liveQueryInvalidation => {
-        const rawInvalidationPaths = liveQueryInvalidation.invalidate;
-        const factories = rawInvalidationPaths.map(rawInvalidationPath => getInterpolatedStringFactory(rawInvalidationPath));
-        liveQueryInvalidationFactoryMap.set(liveQueryInvalidation.field, factories);
-    });
-    return {
-        onExecute() {
-            return {
-                onExecuteDone({ args: executionArgs, result }) {
-                    queueMicrotask(() => {
-                        const { schema, document, operationName, rootValue, contextValue } = executionArgs;
-                        const operationAST = getOperationAST(document, operationName);
-                        if (!operationAST) {
-                            throw new Error(`Operation couldn't be found`);
-                        }
-                        const typeInfo = new TypeInfo(schema);
-                        visit(operationAST, visitWithTypeInfo(typeInfo, {
-                            Field: () => {
-                                const parentType = typeInfo.getParentType();
-                                const fieldDef = typeInfo.getFieldDef();
-                                const path = `${parentType.name}.${fieldDef.name}`;
-                                if (liveQueryInvalidationFactoryMap.has(path)) {
-                                    const invalidationPathFactories = liveQueryInvalidationFactoryMap.get(path);
-                                    const invalidationPaths = invalidationPathFactories.map(invalidationPathFactory => invalidationPathFactory({
-                                        root: rootValue,
-                                        context: contextValue,
-                                        env: process.env,
-                                        result,
-                                    }));
-                                    params.liveQueryStore
-                                        .invalidate(invalidationPaths)
-                                        .catch((e) => params.logger.warn(`Invalidation failed for ${path}: ${e.message}`));
-                                }
-                            },
-                        }));
-                    });
-                },
-            };
-        },
-    };
-}
-
-function useMeshLiveQuery(options) {
-    var _a;
-    options.logger.debug(`Creating Live Query Store`);
-    const liveQueryStore = new InMemoryLiveQueryStore({
-        includeIdentifierExtension: true,
-    });
-    (_a = options.polling) === null || _a === void 0 ? void 0 : _a.forEach(pollingConfig => {
-        const interval = setInterval(() => {
-            liveQueryStore
-                .invalidate(pollingConfig.invalidate)
-                .catch((e) => options.logger.warn(`Invalidation failed for ${pollingConfig.invalidate}: ${e.message}`));
-        }, pollingConfig.interval);
-        const id = options.pubsub.subscribe('destroy', () => {
-            clearInterval(interval);
-            options.pubsub.unsubscribe(id);
-        });
-    });
-    return {
-        onPluginInit({ addPlugin }) {
-            var _a;
-            addPlugin(useLiveQuery({ liveQueryStore }));
-            if ((_a = options.invalidations) === null || _a === void 0 ? void 0 : _a.length) {
-                addPlugin(useInvalidateByResult({ liveQueryStore, invalidations: options.invalidations, logger: options.logger }));
-            }
-        },
-    };
-}
-
-export default useMeshLiveQuery;

package/{index.d.ts → typings/index.d.ts}

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