@envelop/persisted-operations 5.0.0-alpha-d0d0776.0 → 5.0.0-alpha-5b6bfa8.0

package/README.md

@@ -15,26 +15,26 @@ yarn add @envelop/persisted-operations
 The most basic implementation can use an in-memory JS `Map` wrapper with a `Store` object:
 
 ```ts
-import { envelop } from '@envelop/core';
-import { usePersistedOperations, InMemoryStore } from '@envelop/persisted-operations';
+import { envelop } from '@envelop/core'
+import { usePersistedOperations, InMemoryStore } from '@envelop/persisted-operations'
 
 // You can retrieve the store in any way (e.g. from a remote source) and implement it with a simple Map / Key->Value
-const myData = new Map();
-myData.set('persisted_1', parse(`query { ... }`));
-myData.set('persisted_2', 'query { ... }'));
+const myData = new Map()
+myData.set('persisted_1', parse(`query { ... }`))
+myData.set('persisted_2', 'query { ... }')
 
 const store = new InMemoryStore({
-  initialData: myData,
+  initialData: myData
 })
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     usePersistedOperations({
-      store: myStore,
-    }),
-  ],
-});
+      store: myStore
+    })
+  ]
+})
 ```
 
 Now, when running operations through your GraphQL server, you can use a key instead of a query language:
@@ -58,25 +58,25 @@ usePersistedOperations({
 ## Usage Example with built-in JsonFileStore
 
 ```ts
-import { usePersistedOperations, JsonFileStore } from '@envelop/persisted-operations';
+import { usePersistedOperations, JsonFileStore } from '@envelop/persisted-operations'
 
-const persistedOperationsStore = new JsonFilesStore();
-const filePath = resolve(process.cwd(), 'assets/client1PersistedOperations.json');
+const persistedOperationsStore = new JsonFilesStore()
+const filePath = resolve(process.cwd(), 'assets/client1PersistedOperations.json')
 
 // sync
-persistedOperationsStore.loadFromFileSync(filePath); // load and parse persisted-operations files
+persistedOperationsStore.loadFromFileSync(filePath) // load and parse persisted-operations files
 
 // or async
-await persistedOperationsStore.loadFromFile(filePath); // load and parse persisted-operations files
+await persistedOperationsStore.loadFromFile(filePath) // load and parse persisted-operations files
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     usePersistedOperations({
-      store: persistedOperationsStore,
-    }),
-  ],
-});
+      store: persistedOperationsStore
+    })
+  ]
+})
 ```
 
 ## Multiple Stores
@@ -90,17 +90,17 @@ const getEnveloped = envelop({
     usePersistedOperations({
       store: context => {
         if (context.req.headers['user-agent'].includes('Android')) {
-          return mobileClientsStore;
+          return mobileClientsStore
         }
 
-        return defaultStore;
-      },
-    }),
-  ],
-});
+        return defaultStore
+      }
+    })
+  ]
+})
 
 // later, pass the initial context
-const proxyFns = getEnveloped({ req });
+const proxyFns = getEnveloped({ req })
 ```
 
 ## Additional options
@@ -116,8 +116,8 @@ The function receives the context and operationId as arguments, so you can use i
 
 ```js
 onMissingMatch: (context, operationId) => {
-  myEventPool.add(`Missing match for operation "${operationId}" from agent "${context.req.headers['user-agent']}"`);
-};
+  myEventPool.add(`Missing match for operation "${operationId}" from agent "${context.req.headers['user-agent']}"`)
+}
 ```
 
 ## With Relay

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);
+tslib_1.__exportStar(require("./stores/aggregated-store.js"), exports);
+tslib_1.__exportStar(require("./stores/inmemory-store.js"), exports);
+tslib_1.__exportStar(require("./stores/json-file-store.js"), exports);
+tslib_1.__exportStar(require("./plugin.js"), exports);

package/cjs/package.json

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

package/cjs/plugin.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePersistedOperations = exports.readOperationId = void 0;
+const graphql_1 = require("@graphql-tools/graphql");
+const utils_js_1 = require("./utils.js");
+const DEFAULT_OPTIONS = {
+    onlyPersisted: false,
+};
+const contextProperty = Symbol('persistedOperationId');
+function readOperationId(context) {
+    return context[contextProperty];
+}
+exports.readOperationId = readOperationId;
+const usePersistedOperations = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    return {
+        onParse({ context, params, extendContext, setParsedDocument }) {
+            const operationId = options.extractOperationId
+                ? options.extractOperationId(context)
+                : (0, utils_js_1.operationIdFromSource)(params.source);
+            if (!operationId) {
+                if (options.onlyPersisted) {
+                    throw new graphql_1.GraphQLError('Must provide operation id');
+                }
+                return;
+            }
+            const store = typeof options.store === 'function' ? options.store(context) : options.store;
+            if (!store) {
+                throw new graphql_1.GraphQLError('Must provide store for persisted-operations!');
+            }
+            const rawResult = store.get(operationId);
+            if (rawResult) {
+                const document = typeof rawResult === 'string' ? (0, graphql_1.parse)(rawResult) : rawResult;
+                extendContext({ [contextProperty]: operationId });
+                setParsedDocument(document);
+                return;
+            }
+            if (options.onMissingMatch)
+                options.onMissingMatch(context, operationId);
+            if (options.onlyPersisted) {
+                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
+                throw new graphql_1.GraphQLError(`Unable to match operation with id '${operationId}'`);
+            }
+            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
+            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
+        },
+    };
+};
+exports.usePersistedOperations = usePersistedOperations;

package/cjs/stores/aggregated-store.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregatedStore = void 0;
+class AggregatedStore {
+    constructor(stores) {
+        this.stores = stores;
+    }
+    get(operationId) {
+        for (const store of this.stores) {
+            const item = store.get(operationId);
+            if (item) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+}
+exports.AggregatedStore = AggregatedStore;

package/cjs/stores/inmemory-store.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStore = void 0;
+class InMemoryStore {
+    constructor(options) {
+        var _a;
+        this.storeData = (_a = options === null || options === void 0 ? void 0 : options.initialData) !== null && _a !== void 0 ? _a : new Map();
+    }
+    get(operationId) {
+        return this.storeData.get(operationId) || undefined;
+    }
+    prime(operationId, document) {
+        this.storeData.set(operationId, document);
+    }
+    clear(operationId) {
+        this.storeData.delete(operationId);
+    }
+}
+exports.InMemoryStore = InMemoryStore;

package/cjs/stores/json-file-store.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileStore = void 0;
+const fs_1 = require("fs");
+class JsonFileStore {
+    constructor() {
+        this.storeData = null;
+    }
+    get(operationId) {
+        if (!this.storeData) {
+            return undefined;
+        }
+        return this.storeData.get(operationId) || undefined;
+    }
+    loadFromFileSync(path) {
+        const data = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+    async loadFromFile(path) {
+        const data = JSON.parse(await fs_1.promises.readFile(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+}
+exports.JsonFileStore = JsonFileStore;

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationIdFromSource = void 0;
+function operationIdFromSource(source) {
+    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
+}
+exports.operationIdFromSource = operationIdFromSource;

package/esm/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './utils.js';
+export * from './stores/aggregated-store.js';
+export * from './stores/inmemory-store.js';
+export * from './stores/json-file-store.js';
+export * from './plugin.js';

package/esm/plugin.js

@@ -0,0 +1,47 @@
+import { GraphQLError, parse } from '@graphql-tools/graphql';
+import { operationIdFromSource } from './utils.js';
+const DEFAULT_OPTIONS = {
+    onlyPersisted: false,
+};
+const contextProperty = Symbol('persistedOperationId');
+export function readOperationId(context) {
+    return context[contextProperty];
+}
+export const usePersistedOperations = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    return {
+        onParse({ context, params, extendContext, setParsedDocument }) {
+            const operationId = options.extractOperationId
+                ? options.extractOperationId(context)
+                : operationIdFromSource(params.source);
+            if (!operationId) {
+                if (options.onlyPersisted) {
+                    throw new GraphQLError('Must provide operation id');
+                }
+                return;
+            }
+            const store = typeof options.store === 'function' ? options.store(context) : options.store;
+            if (!store) {
+                throw new GraphQLError('Must provide store for persisted-operations!');
+            }
+            const rawResult = store.get(operationId);
+            if (rawResult) {
+                const document = typeof rawResult === 'string' ? parse(rawResult) : rawResult;
+                extendContext({ [contextProperty]: operationId });
+                setParsedDocument(document);
+                return;
+            }
+            if (options.onMissingMatch)
+                options.onMissingMatch(context, operationId);
+            if (options.onlyPersisted) {
+                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
+                throw new GraphQLError(`Unable to match operation with id '${operationId}'`);
+            }
+            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
+            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
+        },
+    };
+};

package/esm/stores/aggregated-store.js

@@ -0,0 +1,14 @@
+export class AggregatedStore {
+    constructor(stores) {
+        this.stores = stores;
+    }
+    get(operationId) {
+        for (const store of this.stores) {
+            const item = store.get(operationId);
+            if (item) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+}

package/esm/stores/inmemory-store.js

@@ -0,0 +1,15 @@
+export class InMemoryStore {
+    constructor(options) {
+        var _a;
+        this.storeData = (_a = options === null || options === void 0 ? void 0 : options.initialData) !== null && _a !== void 0 ? _a : new Map();
+    }
+    get(operationId) {
+        return this.storeData.get(operationId) || undefined;
+    }
+    prime(operationId, document) {
+        this.storeData.set(operationId, document);
+    }
+    clear(operationId) {
+        this.storeData.delete(operationId);
+    }
+}

package/esm/stores/json-file-store.js

@@ -0,0 +1,20 @@
+import { readFileSync, promises } from 'fs';
+export class JsonFileStore {
+    constructor() {
+        this.storeData = null;
+    }
+    get(operationId) {
+        if (!this.storeData) {
+            return undefined;
+        }
+        return this.storeData.get(operationId) || undefined;
+    }
+    loadFromFileSync(path) {
+        const data = JSON.parse(readFileSync(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+    async loadFromFile(path) {
+        const data = JSON.parse(await promises.readFile(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils.js

@@ -0,0 +1,3 @@
+export function operationIdFromSource(source) {
+    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@envelop/persisted-operations",
-  "version": "5.0.0-alpha-d0d0776.0",
+  "version": "5.0.0-alpha-5b6bfa8.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "3.0.0-alpha-d0d0776.0",
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+    "@envelop/core": "3.0.0-alpha-5b6bfa8.0",
+    "@graphql-tools/graphql": "0.1.0-alpha-33fb2950.0"
   },
   "repository": {
     "type": "git",
@@ -13,33 +13,42 @@
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "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": {
-        "default": "./index.js",
-        "types": "./index.d.ts"
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
       },
       "import": {
-        "default": "./index.mjs",
-        "types": "./index.d.ts"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       }
     },
     "./*": {
       "require": {
-        "default": "./*.js",
-        "types": "./*.d.ts"
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
       },
       "import": {
-        "default": "./*.mjs",
-        "types": "./*.d.ts"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './utils.js';
+export * from './stores/aggregated-store.js';
+export * from './stores/inmemory-store.js';
+export * from './stores/json-file-store.js';
+export * from './plugin.js';

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

@@ -1,5 +1,5 @@
 import { Plugin, DefaultContext } from '@envelop/core';
-import { PersistedOperationsFunctionStore, PersistedOperationsStore } from './types';
+import { PersistedOperationsFunctionStore, PersistedOperationsStore } from './types.js';
 export declare type UsePersistedOperationsOptions<ContextType = DefaultContext> = {
     /**
      * Set to `false` to allow running operations that are not available in the store.

package/{stores → typings/stores}/aggregated-store.d.ts

@@ -1,5 +1,5 @@
-import { DocumentNode } from 'graphql';
-import { PersistedOperationsStore } from '../types';
+import { DocumentNode } from '@graphql-tools/graphql';
+import { PersistedOperationsStore } from '../types.js';
 export declare class AggregatedStore implements PersistedOperationsStore {
     private stores;
     constructor(stores: PersistedOperationsStore[]);

package/{stores → typings/stores}/inmemory-store.d.ts

@@ -1,5 +1,5 @@
-import { DocumentNode } from 'graphql';
-import { PersistedOperationsStore } from '../types';
+import { DocumentNode } from '@graphql-tools/graphql';
+import { PersistedOperationsStore } from '../types.js';
 export declare type InMemoryStoreDataMap = Map<string, DocumentNode | string>;
 export declare class InMemoryStore implements PersistedOperationsStore {
     private storeData;

package/{stores → typings/stores}/json-file-store.d.ts

@@ -1,5 +1,5 @@
-import { DocumentNode } from 'graphql';
-import { PersistedOperationsStore } from '../types';
+import { DocumentNode } from '@graphql-tools/graphql';
+import { PersistedOperationsStore } from '../types.js';
 export declare type JsonFileStoreDataMap = Map<string, DocumentNode | string>;
 export declare class JsonFileStore implements PersistedOperationsStore {
     private storeData;

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

@@ -1,5 +1,5 @@
 import { DefaultContext } from '@envelop/core';
-import { DocumentNode } from 'graphql';
+import { DocumentNode } from '@graphql-tools/graphql';
 export interface PersistedOperationsStore {
     /**
      * Transfroms a hash/id into a DocumentNode or SDL string.

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

@@ -1,2 +1,2 @@
-import { Source } from 'graphql';
+import { Source } from '@graphql-tools/graphql';
 export declare function operationIdFromSource(source: string | Source): string | undefined;

package/index.d.ts

@@ -1,6 +0,0 @@
-export * from './types';
-export * from './utils';
-export * from './stores/aggregated-store';
-export * from './stores/inmemory-store';
-export * from './stores/json-file-store';
-export * from './plugin';

package/index.js

@@ -1,111 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const fs = require('fs');
-const graphql = require('graphql');
-
-function operationIdFromSource(source) {
-    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
-}
-
-class AggregatedStore {
-    constructor(stores) {
-        this.stores = stores;
-    }
-    get(operationId) {
-        for (const store of this.stores) {
-            const item = store.get(operationId);
-            if (item) {
-                return item;
-            }
-        }
-        return undefined;
-    }
-}
-
-class InMemoryStore {
-    constructor(options) {
-        this.storeData = options?.initialData ?? new Map();
-    }
-    get(operationId) {
-        return this.storeData.get(operationId) || undefined;
-    }
-    prime(operationId, document) {
-        this.storeData.set(operationId, document);
-    }
-    clear(operationId) {
-        this.storeData.delete(operationId);
-    }
-}
-
-class JsonFileStore {
-    constructor() {
-        this.storeData = null;
-    }
-    get(operationId) {
-        if (!this.storeData) {
-            return undefined;
-        }
-        return this.storeData.get(operationId) || undefined;
-    }
-    loadFromFileSync(path) {
-        const data = JSON.parse(fs.readFileSync(path, 'utf-8'));
-        this.storeData = new Map(Object.entries(data));
-    }
-    async loadFromFile(path) {
-        const data = JSON.parse(await fs.promises.readFile(path, 'utf-8'));
-        this.storeData = new Map(Object.entries(data));
-    }
-}
-
-const DEFAULT_OPTIONS = {
-    onlyPersisted: false,
-};
-const contextProperty = Symbol('persistedOperationId');
-function readOperationId(context) {
-    return context[contextProperty];
-}
-const usePersistedOperations = (rawOptions) => {
-    const options = {
-        ...DEFAULT_OPTIONS,
-        ...(rawOptions || {}),
-    };
-    return {
-        onParse({ context, params, extendContext, setParsedDocument }) {
-            const operationId = options.extractOperationId ? options.extractOperationId(context) : operationIdFromSource(params.source);
-            if (!operationId) {
-                if (options.onlyPersisted) {
-                    throw new graphql.GraphQLError('Must provide operation id');
-                }
-                return;
-            }
-            const store = typeof options.store === 'function' ? options.store(context) : options.store;
-            if (!store) {
-                throw new graphql.GraphQLError('Must provide store for persisted-operations!');
-            }
-            const rawResult = store.get(operationId);
-            if (rawResult) {
-                const document = typeof rawResult === 'string' ? graphql.parse(rawResult) : rawResult;
-                extendContext({ [contextProperty]: operationId });
-                setParsedDocument(document);
-                return;
-            }
-            if (options.onMissingMatch)
-                options.onMissingMatch(context, operationId);
-            if (options.onlyPersisted) {
-                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
-                throw new graphql.GraphQLError(`Unable to match operation with id '${operationId}'`);
-            }
-            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
-            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
-        },
-    };
-};
-
-exports.AggregatedStore = AggregatedStore;
-exports.InMemoryStore = InMemoryStore;
-exports.JsonFileStore = JsonFileStore;
-exports.operationIdFromSource = operationIdFromSource;
-exports.readOperationId = readOperationId;
-exports.usePersistedOperations = usePersistedOperations;

package/index.mjs

@@ -1,102 +0,0 @@
-import { readFileSync, promises } from 'fs';
-import { GraphQLError, parse } from 'graphql';
-
-function operationIdFromSource(source) {
-    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
-}
-
-class AggregatedStore {
-    constructor(stores) {
-        this.stores = stores;
-    }
-    get(operationId) {
-        for (const store of this.stores) {
-            const item = store.get(operationId);
-            if (item) {
-                return item;
-            }
-        }
-        return undefined;
-    }
-}
-
-class InMemoryStore {
-    constructor(options) {
-        this.storeData = options?.initialData ?? new Map();
-    }
-    get(operationId) {
-        return this.storeData.get(operationId) || undefined;
-    }
-    prime(operationId, document) {
-        this.storeData.set(operationId, document);
-    }
-    clear(operationId) {
-        this.storeData.delete(operationId);
-    }
-}
-
-class JsonFileStore {
-    constructor() {
-        this.storeData = null;
-    }
-    get(operationId) {
-        if (!this.storeData) {
-            return undefined;
-        }
-        return this.storeData.get(operationId) || undefined;
-    }
-    loadFromFileSync(path) {
-        const data = JSON.parse(readFileSync(path, 'utf-8'));
-        this.storeData = new Map(Object.entries(data));
-    }
-    async loadFromFile(path) {
-        const data = JSON.parse(await promises.readFile(path, 'utf-8'));
-        this.storeData = new Map(Object.entries(data));
-    }
-}
-
-const DEFAULT_OPTIONS = {
-    onlyPersisted: false,
-};
-const contextProperty = Symbol('persistedOperationId');
-function readOperationId(context) {
-    return context[contextProperty];
-}
-const usePersistedOperations = (rawOptions) => {
-    const options = {
-        ...DEFAULT_OPTIONS,
-        ...(rawOptions || {}),
-    };
-    return {
-        onParse({ context, params, extendContext, setParsedDocument }) {
-            const operationId = options.extractOperationId ? options.extractOperationId(context) : operationIdFromSource(params.source);
-            if (!operationId) {
-                if (options.onlyPersisted) {
-                    throw new GraphQLError('Must provide operation id');
-                }
-                return;
-            }
-            const store = typeof options.store === 'function' ? options.store(context) : options.store;
-            if (!store) {
-                throw new GraphQLError('Must provide store for persisted-operations!');
-            }
-            const rawResult = store.get(operationId);
-            if (rawResult) {
-                const document = typeof rawResult === 'string' ? parse(rawResult) : rawResult;
-                extendContext({ [contextProperty]: operationId });
-                setParsedDocument(document);
-                return;
-            }
-            if (options.onMissingMatch)
-                options.onMissingMatch(context, operationId);
-            if (options.onlyPersisted) {
-                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
-                throw new GraphQLError(`Unable to match operation with id '${operationId}'`);
-            }
-            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
-            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
-        },
-    };
-};
-
-export { AggregatedStore, InMemoryStore, JsonFileStore, operationIdFromSource, readOperationId, usePersistedOperations };