@graphql-mesh/store 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/{index.js → cjs/index.js}

@@ -1,17 +1,17 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const crossHelpers = require('@graphql-mesh/cross-helpers');
-const utils = require('@graphql-mesh/utils');
-const core = require('@graphql-inspector/core');
-const utils$1 = require('@graphql-tools/utils');
-const graphql = require('graphql');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshStore = exports.PredefinedProxyOptions = exports.PredefinedProxyOptionsName = exports.FsStoreStorageAdapter = exports.InMemoryStoreStorageAdapter = exports.ValidationError = exports.ReadonlyStoreError = void 0;
+const graphql_1 = require("graphql");
+const core_1 = require("@graphql-inspector/core");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
 class ReadonlyStoreError extends Error {
 }
+exports.ReadonlyStoreError = ReadonlyStoreError;
 class ValidationError extends Error {
 }
+exports.ValidationError = ValidationError;
 class InMemoryStoreStorageAdapter {
     constructor() {
         this.data = new Map();
@@ -29,12 +29,15 @@ class InMemoryStoreStorageAdapter {
         this.data.clear();
     }
 }
+exports.InMemoryStoreStorageAdapter = InMemoryStoreStorageAdapter;
 class FsStoreStorageAdapter {
     constructor(options) {
         this.options = options;
     }
     getAbsolutePath(jsFileName) {
-        return crossHelpers.path.isAbsolute(jsFileName) ? jsFileName : crossHelpers.path.join(this.options.cwd, jsFileName);
+        return cross_helpers_1.path.isAbsolute(jsFileName)
+            ? jsFileName
+            : cross_helpers_1.path.join(this.options.cwd, jsFileName);
     }
     async read(key, options) {
         let absoluteModulePath = this.getAbsolutePath(key);
@@ -42,7 +45,9 @@ class FsStoreStorageAdapter {
             absoluteModulePath += '.' + this.options.fileType;
         }
         try {
-            const importedData = await this.options.importFn(absoluteModulePath).then(m => m.default || m);
+            const importedData = await this.options
+                .importFn(absoluteModulePath)
+                .then(m => m.default || m);
             if (this.options.fileType === 'json') {
                 return await options.fromJSON(importedData, key);
             }
@@ -61,20 +66,22 @@ class FsStoreStorageAdapter {
             : `// @ts-nocheck\n` + (await options.codify(data, key));
         const modulePath = this.getAbsolutePath(key);
         const filePath = modulePath + '.' + this.options.fileType;
-        await utils.writeFile(filePath, asString);
+        await (0, utils_1.writeFile)(filePath, asString);
         await this.options.importFn(this.options.fileType !== 'ts' ? filePath : modulePath);
     }
     async delete(key) {
         const filePath = this.getAbsolutePath(key) + '.' + this.options.fileType;
-        return crossHelpers.fs.promises.unlink(filePath);
+        return cross_helpers_1.fs.promises.unlink(filePath);
     }
 }
+exports.FsStoreStorageAdapter = FsStoreStorageAdapter;
+var PredefinedProxyOptionsName;
 (function (PredefinedProxyOptionsName) {
     PredefinedProxyOptionsName["JsonWithoutValidation"] = "JsonWithoutValidation";
     PredefinedProxyOptionsName["StringWithoutValidation"] = "StringWithoutValidation";
     PredefinedProxyOptionsName["GraphQLSchemaWithDiffing"] = "GraphQLSchemaWithDiffing";
-})(exports.PredefinedProxyOptionsName || (exports.PredefinedProxyOptionsName = {}));
-const PredefinedProxyOptions = {
+})(PredefinedProxyOptionsName = exports.PredefinedProxyOptionsName || (exports.PredefinedProxyOptionsName = {}));
+exports.PredefinedProxyOptions = {
     JsonWithoutValidation: {
         codify: v => `export default ${JSON.stringify(v, null, 2)}`,
         fromJSON: v => v,
@@ -91,21 +98,23 @@ const PredefinedProxyOptions = {
         codify: schema => `
 import { buildASTSchema } from 'graphql';
 
-const schemaAST = ${JSON.stringify(utils$1.getDocumentNodeFromSchema(schema), null, 2)};
+const schemaAST = ${JSON.stringify((0, utils_2.getDocumentNodeFromSchema)(schema), null, 2)};
 
 export default buildASTSchema(schemaAST, {
   assumeValid: true,
   assumeValidSDL: true
 });
     `.trim(),
-        fromJSON: schemaAST => graphql.buildASTSchema(schemaAST, { assumeValid: true, assumeValidSDL: true }),
-        toJSON: schema => utils$1.getDocumentNodeFromSchema(schema),
+        fromJSON: schemaAST => (0, graphql_1.buildASTSchema)(schemaAST, { assumeValid: true, assumeValidSDL: true }),
+        toJSON: schema => (0, utils_2.getDocumentNodeFromSchema)(schema),
         validate: async (oldSchema, newSchema) => {
-            const changes = await core.diff(oldSchema, newSchema);
+            const changes = await (0, core_1.diff)(oldSchema, newSchema);
             const errors = [];
             for (const change of changes) {
-                if (change.criticality.level === core.CriticalityLevel.Breaking ||
-                    change.criticality.level === core.CriticalityLevel.Dangerous) {
+                if ((change.criticality.level === core_1.CriticalityLevel.Breaking ||
+                    change.criticality.level === core_1.CriticalityLevel.Dangerous) &&
+                    !change.message.includes('@specifiedBy') &&
+                    !change.message.includes('@deprecated')) {
                     errors.push(change.message);
                 }
             }
@@ -114,7 +123,7 @@ export default buildASTSchema(schemaAST, {
                     throw errors[0];
                 }
                 else {
-                    throw new utils$1.AggregateError(errors);
+                    throw new Error(`Breaking changes found; \n${errors.map(error => `- ${error}`).join('\n')}`);
                 }
             }
         },
@@ -127,13 +136,13 @@ class MeshStore {
         this.flags = flags;
     }
     child(childIdentifier, flags) {
-        return new MeshStore(crossHelpers.path.join(this.identifier, childIdentifier), this.storage, {
+        return new MeshStore(cross_helpers_1.path.join(this.identifier, childIdentifier), this.storage, {
             ...this.flags,
             ...flags,
         });
     }
     proxy(id, options) {
-        const path = crossHelpers.path.join(this.identifier, id);
+        const path = cross_helpers_1.path.join(this.identifier, id);
         let value;
         let isValueCached = false;
         const ensureValueCached = async () => {
@@ -187,10 +196,4 @@ class MeshStore {
         return proxy;
     }
 }
-
-exports.FsStoreStorageAdapter = FsStoreStorageAdapter;
-exports.InMemoryStoreStorageAdapter = InMemoryStoreStorageAdapter;
 exports.MeshStore = MeshStore;
-exports.PredefinedProxyOptions = PredefinedProxyOptions;
-exports.ReadonlyStoreError = ReadonlyStoreError;
-exports.ValidationError = ValidationError;

package/cjs/package.json

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

package/{index.mjs → esm/index.js}

@@ -1,14 +1,13 @@
-import { path, fs } from '@graphql-mesh/cross-helpers';
-import { writeFile } from '@graphql-mesh/utils';
-import { diff, CriticalityLevel } from '@graphql-inspector/core';
-import { getDocumentNodeFromSchema, AggregateError } from '@graphql-tools/utils';
 import { buildASTSchema } from 'graphql';
-
-class ReadonlyStoreError extends Error {
+import { CriticalityLevel, diff } from '@graphql-inspector/core';
+import { fs, path as pathModule } from '@graphql-mesh/cross-helpers';
+import { writeFile } from '@graphql-mesh/utils';
+import { getDocumentNodeFromSchema } from '@graphql-tools/utils';
+export class ReadonlyStoreError extends Error {
 }
-class ValidationError extends Error {
+export class ValidationError extends Error {
 }
-class InMemoryStoreStorageAdapter {
+export class InMemoryStoreStorageAdapter {
     constructor() {
         this.data = new Map();
     }
@@ -25,12 +24,14 @@ class InMemoryStoreStorageAdapter {
         this.data.clear();
     }
 }
-class FsStoreStorageAdapter {
+export class FsStoreStorageAdapter {
     constructor(options) {
         this.options = options;
     }
     getAbsolutePath(jsFileName) {
-        return path.isAbsolute(jsFileName) ? jsFileName : path.join(this.options.cwd, jsFileName);
+        return pathModule.isAbsolute(jsFileName)
+            ? jsFileName
+            : pathModule.join(this.options.cwd, jsFileName);
     }
     async read(key, options) {
         let absoluteModulePath = this.getAbsolutePath(key);
@@ -38,7 +39,9 @@ class FsStoreStorageAdapter {
             absoluteModulePath += '.' + this.options.fileType;
         }
         try {
-            const importedData = await this.options.importFn(absoluteModulePath).then(m => m.default || m);
+            const importedData = await this.options
+                .importFn(absoluteModulePath)
+                .then(m => m.default || m);
             if (this.options.fileType === 'json') {
                 return await options.fromJSON(importedData, key);
             }
@@ -65,13 +68,13 @@ class FsStoreStorageAdapter {
         return fs.promises.unlink(filePath);
     }
 }
-var PredefinedProxyOptionsName;
+export var PredefinedProxyOptionsName;
 (function (PredefinedProxyOptionsName) {
     PredefinedProxyOptionsName["JsonWithoutValidation"] = "JsonWithoutValidation";
     PredefinedProxyOptionsName["StringWithoutValidation"] = "StringWithoutValidation";
     PredefinedProxyOptionsName["GraphQLSchemaWithDiffing"] = "GraphQLSchemaWithDiffing";
 })(PredefinedProxyOptionsName || (PredefinedProxyOptionsName = {}));
-const PredefinedProxyOptions = {
+export const PredefinedProxyOptions = {
     JsonWithoutValidation: {
         codify: v => `export default ${JSON.stringify(v, null, 2)}`,
         fromJSON: v => v,
@@ -101,8 +104,10 @@ export default buildASTSchema(schemaAST, {
             const changes = await diff(oldSchema, newSchema);
             const errors = [];
             for (const change of changes) {
-                if (change.criticality.level === CriticalityLevel.Breaking ||
-                    change.criticality.level === CriticalityLevel.Dangerous) {
+                if ((change.criticality.level === CriticalityLevel.Breaking ||
+                    change.criticality.level === CriticalityLevel.Dangerous) &&
+                    !change.message.includes('@specifiedBy') &&
+                    !change.message.includes('@deprecated')) {
                     errors.push(change.message);
                 }
             }
@@ -111,31 +116,31 @@ export default buildASTSchema(schemaAST, {
                     throw errors[0];
                 }
                 else {
-                    throw new AggregateError(errors);
+                    throw new Error(`Breaking changes found; \n${errors.map(error => `- ${error}`).join('\n')}`);
                 }
             }
         },
     },
 };
-class MeshStore {
+export class MeshStore {
     constructor(identifier, storage, flags) {
         this.identifier = identifier;
         this.storage = storage;
         this.flags = flags;
     }
     child(childIdentifier, flags) {
-        return new MeshStore(path.join(this.identifier, childIdentifier), this.storage, {
+        return new MeshStore(pathModule.join(this.identifier, childIdentifier), this.storage, {
             ...this.flags,
             ...flags,
         });
     }
     proxy(id, options) {
-        const path$1 = path.join(this.identifier, id);
+        const path = pathModule.join(this.identifier, id);
         let value;
         let isValueCached = false;
         const ensureValueCached = async () => {
             if (!isValueCached) {
-                value = await this.storage.read(path$1, options);
+                value = await this.storage.read(path, options);
                 isValueCached = true;
             }
         };
@@ -177,12 +182,10 @@ class MeshStore {
                 }
                 value = newValue;
                 isValueCached = true;
-                await this.storage.write(path$1, value, options);
+                await this.storage.write(path, value, options);
             },
-            delete: () => this.storage.delete(path$1),
+            delete: () => this.storage.delete(path),
         };
         return proxy;
     }
 }
-
-export { FsStoreStorageAdapter, InMemoryStoreStorageAdapter, MeshStore, PredefinedProxyOptions, PredefinedProxyOptionsName, ReadonlyStoreError, ValidationError };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@graphql-mesh/store",
-  "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-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-inspector/core": "3.3.0",
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-tools/utils": "8.8.0",
-    "tslib": "^2.4.0"
+    "@graphql-inspector/core": "3.3.0"
   },
   "repository": {
     "type": "git",
@@ -19,21 +19,28 @@
     "directory": "packages/store"
   },
   "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,60 @@
+import { ImportFn } from '@graphql-mesh/types';
+export declare class ReadonlyStoreError extends Error {
+}
+export declare class ValidationError extends Error {
+}
+export type StoreStorageAdapter<TData = any, TKey = string> = {
+    read: (key: TKey, options: ProxyOptions<TData>) => Promise<TData>;
+    write: (key: TKey, data: TData, options: ProxyOptions<TData>) => Promise<TData>;
+    delete: (key: TKey) => Promise<void>;
+};
+export declare class InMemoryStoreStorageAdapter implements StoreStorageAdapter {
+    private data;
+    read<TData>(key: string, options: ProxyOptions<any>): Promise<TData>;
+    write<TData>(key: string, data: TData, options: ProxyOptions<any>): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): void;
+}
+export interface FsStoreStorageAdapterOptions {
+    cwd: string;
+    importFn: ImportFn;
+    fileType: 'ts' | 'json' | 'js';
+}
+export declare class FsStoreStorageAdapter implements StoreStorageAdapter {
+    private options;
+    constructor(options: FsStoreStorageAdapterOptions);
+    private getAbsolutePath;
+    read<TData, TJSONData = any>(key: string, options: ProxyOptions<TData, TJSONData>): Promise<TData>;
+    write<TData, TJSONData = any>(key: string, data: TData, options: ProxyOptions<TData, TJSONData>): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export type StoreProxy<TData> = {
+    set(value: TData): Promise<void>;
+    get(): Promise<TData>;
+    getWithSet(setterFn: () => TData | Promise<TData>): Promise<TData>;
+    delete(): Promise<void>;
+};
+export type ProxyOptions<TData, TJSONData = any> = {
+    codify: (value: TData, identifier: string) => string | Promise<string>;
+    fromJSON: (jsonData: TJSONData, identifier: string) => TData | Promise<TData>;
+    toJSON: (value: TData, identifier: string) => TJSONData | Promise<TJSONData>;
+    validate: (oldValue: TData, newValue: TData, identifier: string) => void | Promise<void>;
+};
+export type StoreFlags = {
+    readonly: boolean;
+    validate: boolean;
+};
+export declare enum PredefinedProxyOptionsName {
+    JsonWithoutValidation = "JsonWithoutValidation",
+    StringWithoutValidation = "StringWithoutValidation",
+    GraphQLSchemaWithDiffing = "GraphQLSchemaWithDiffing"
+}
+export declare const PredefinedProxyOptions: Record<PredefinedProxyOptionsName, ProxyOptions<any>>;
+export declare class MeshStore {
+    identifier: string;
+    protected storage: StoreStorageAdapter;
+    flags: StoreFlags;
+    constructor(identifier: string, storage: StoreStorageAdapter, flags: StoreFlags);
+    child(childIdentifier: string, flags?: Partial<StoreFlags>): MeshStore;
+    proxy<TData>(id: string, options: ProxyOptions<TData>): StoreProxy<TData>;
+}

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

@@ -3,7 +3,7 @@ export declare class ReadonlyStoreError extends Error {
 }
 export declare class ValidationError extends Error {
 }
-export declare type StoreStorageAdapter<TData = any, TKey = string> = {
+export type StoreStorageAdapter<TData = any, TKey = string> = {
     read: (key: TKey, options: ProxyOptions<TData>) => Promise<TData>;
     write: (key: TKey, data: TData, options: ProxyOptions<TData>) => Promise<TData>;
     delete: (key: TKey) => Promise<void>;
@@ -28,19 +28,19 @@ export declare class FsStoreStorageAdapter implements StoreStorageAdapter {
     write<TData, TJSONData = any>(key: string, data: TData, options: ProxyOptions<TData, TJSONData>): Promise<void>;
     delete(key: string): Promise<void>;
 }
-export declare type StoreProxy<TData> = {
+export type StoreProxy<TData> = {
     set(value: TData): Promise<void>;
     get(): Promise<TData>;
     getWithSet(setterFn: () => TData | Promise<TData>): Promise<TData>;
     delete(): Promise<void>;
 };
-export declare type ProxyOptions<TData, TJSONData = any> = {
+export type ProxyOptions<TData, TJSONData = any> = {
     codify: (value: TData, identifier: string) => string | Promise<string>;
     fromJSON: (jsonData: TJSONData, identifier: string) => TData | Promise<TData>;
     toJSON: (value: TData, identifier: string) => TJSONData | Promise<TJSONData>;
     validate: (oldValue: TData, newValue: TData, identifier: string) => void | Promise<void>;
 };
-export declare type StoreFlags = {
+export type StoreFlags = {
     readonly: boolean;
     validate: boolean;
 };