@graphql-mesh/transform-transfer-schema 0.1.2

package/cjs/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const micromatch_1 = require("micromatch");
+const utils_1 = require("@graphql-tools/utils");
+class TransferSchemaTransform {
+    constructor(options) {
+        this.noWrap = true;
+        const { config } = options;
+        this.additionalFieldsMap = new Map();
+        this.additionalArgsMap = new Map();
+        this.additionalFieldsConfig = new Map();
+        this.additionalArgsConfig = new Map();
+        this.removalFieldsMap = new Map();
+        this.removalArgsMap = new Map();
+        for (const transfer of config.transfers) {
+            const [fromType, fromFieldNameOrGlob, fromArgsGlob] = transfer.from.split('.');
+            const rawGlob = fromArgsGlob || fromFieldNameOrGlob;
+            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',')
+                ? rawGlob.replace('{', '').replace('}', '')
+                : rawGlob;
+            const polishedGlob = fixedGlob.split(', ').join(',').trim();
+            const mapName = fromArgsGlob ? 'ArgsMap' : 'FieldsMap';
+            const mapKey = fromArgsGlob ? `${fromType}.${fromFieldNameOrGlob}` : fromType;
+            if (transfer.action === 'move') {
+                const currentRemovalRules = this[`removal${mapName}`].get(mapKey) || new Set();
+                currentRemovalRules.add(polishedGlob);
+                this[`removal${mapName}`].set(mapKey, currentRemovalRules);
+            }
+            const currentAdditionalRules = this[`additional${mapName}`].get(mapKey) || new Set();
+            currentAdditionalRules.add(`${transfer.to}.${polishedGlob}`);
+            this[`additional${mapName}`].set(mapKey, currentAdditionalRules);
+        }
+    }
+    handleAdditions(rulesArray, value, config) {
+        for (const rule of rulesArray) {
+            const [toType, toField, pattern] = rule.split('.');
+            const usePattern = pattern || toField;
+            const mapIdentifier = pattern ? 'ArgsConfig' : 'FieldsConfig';
+            const mapKey = pattern ? `${toType}.${toField}` : toType;
+            const isMatch = (0, micromatch_1.matcher)(usePattern);
+            if (isMatch(value)) {
+                const currentAdditionalConfigs = this[`additional${mapIdentifier}`].get(mapKey) || {};
+                this[`additional${mapIdentifier}`].set(mapKey, {
+                    ...currentAdditionalConfigs,
+                    [value]: config,
+                });
+                break;
+            }
+        }
+    }
+    matchInSet(rulesSet, value) {
+        for (const rule of rulesSet) {
+            const isMatch = (0, micromatch_1.matcher)(rule);
+            if (isMatch(value))
+                return true;
+        }
+        return undefined;
+    }
+    transformSchema(schema) {
+        // initial mapSchema is necessary to store fields/args configs that will be attached to Types/fields in second map
+        const schemaWithRemovals = (0, utils_1.mapSchema)(schema, {
+            [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                const additionalFieldRules = this.additionalFieldsMap.get(typeName);
+                const additionalArgRules = this.additionalArgsMap.get(`${typeName}.${fieldName}`);
+                const removalFieldRules = this.removalFieldsMap.get(typeName);
+                const removalArgRules = this.removalArgsMap.get(`${typeName}.${fieldName}`);
+                const hasAdditionalFieldRules = Boolean(additionalFieldRules);
+                const hasAdditionalArgRules = Boolean(additionalArgRules);
+                const hasRemovalFieldRules = Boolean(removalFieldRules && removalFieldRules.size);
+                const hasRemovalArgRules = Boolean(removalArgRules && removalArgRules.size);
+                // handle field addition
+                if (hasAdditionalFieldRules) {
+                    this.handleAdditions(additionalFieldRules, fieldName, fieldConfig);
+                }
+                // handle args addition
+                if (hasAdditionalArgRules) {
+                    for (const [argName, argConfig] of Object.entries(fieldConfig.args)) {
+                        this.handleAdditions(additionalArgRules, argName, argConfig);
+                    }
+                }
+                // handle field removal
+                if (hasRemovalFieldRules && this.matchInSet(removalFieldRules, fieldName))
+                    return null;
+                // handle args removal
+                if (hasRemovalArgRules) {
+                    const newArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => {
+                        return this.matchInSet(removalArgRules, argName)
+                            ? args
+                            : { ...args, [argName]: argConfig };
+                    }, {});
+                    return { ...fieldConfig, args: newArgs };
+                }
+                return undefined;
+            },
+        });
+        const schemaWithAdditions = (0, utils_1.mapSchema)(schemaWithRemovals, {
+            ...(this.additionalFieldsConfig.size && {
+                [utils_1.MapperKind.OBJECT_TYPE]: type => {
+                    const additionalFieldsConfigMap = this.additionalFieldsConfig.get(type.toString());
+                    if (!additionalFieldsConfigMap)
+                        return undefined;
+                    const newConfig = { ...type.toConfig() };
+                    newConfig.fields = { ...newConfig.fields, ...additionalFieldsConfigMap };
+                    return new graphql_1.GraphQLObjectType(newConfig);
+                },
+            }),
+            ...(this.additionalArgsConfig.size && {
+                [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const additionalArgsConfigMap = this.additionalArgsConfig.get(`${typeName}.${fieldName}`);
+                    if (!additionalArgsConfigMap)
+                        return undefined;
+                    return {
+                        ...fieldConfig,
+                        args: { ...(fieldConfig.args || {}), ...additionalArgsConfigMap },
+                    };
+                },
+            }),
+        });
+        return (0, utils_1.pruneSchema)(schemaWithAdditions);
+    }
+}
+exports.default = TransferSchemaTransform;

package/cjs/package.json

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

package/esm/index.js

@@ -0,0 +1,120 @@
+import { GraphQLObjectType, } from 'graphql';
+import { matcher } from 'micromatch';
+import { MapperKind, mapSchema, pruneSchema } from '@graphql-tools/utils';
+export default class TransferSchemaTransform {
+    constructor(options) {
+        this.noWrap = true;
+        const { config } = options;
+        this.additionalFieldsMap = new Map();
+        this.additionalArgsMap = new Map();
+        this.additionalFieldsConfig = new Map();
+        this.additionalArgsConfig = new Map();
+        this.removalFieldsMap = new Map();
+        this.removalArgsMap = new Map();
+        for (const transfer of config.transfers) {
+            const [fromType, fromFieldNameOrGlob, fromArgsGlob] = transfer.from.split('.');
+            const rawGlob = fromArgsGlob || fromFieldNameOrGlob;
+            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',')
+                ? rawGlob.replace('{', '').replace('}', '')
+                : rawGlob;
+            const polishedGlob = fixedGlob.split(', ').join(',').trim();
+            const mapName = fromArgsGlob ? 'ArgsMap' : 'FieldsMap';
+            const mapKey = fromArgsGlob ? `${fromType}.${fromFieldNameOrGlob}` : fromType;
+            if (transfer.action === 'move') {
+                const currentRemovalRules = this[`removal${mapName}`].get(mapKey) || new Set();
+                currentRemovalRules.add(polishedGlob);
+                this[`removal${mapName}`].set(mapKey, currentRemovalRules);
+            }
+            const currentAdditionalRules = this[`additional${mapName}`].get(mapKey) || new Set();
+            currentAdditionalRules.add(`${transfer.to}.${polishedGlob}`);
+            this[`additional${mapName}`].set(mapKey, currentAdditionalRules);
+        }
+    }
+    handleAdditions(rulesArray, value, config) {
+        for (const rule of rulesArray) {
+            const [toType, toField, pattern] = rule.split('.');
+            const usePattern = pattern || toField;
+            const mapIdentifier = pattern ? 'ArgsConfig' : 'FieldsConfig';
+            const mapKey = pattern ? `${toType}.${toField}` : toType;
+            const isMatch = matcher(usePattern);
+            if (isMatch(value)) {
+                const currentAdditionalConfigs = this[`additional${mapIdentifier}`].get(mapKey) || {};
+                this[`additional${mapIdentifier}`].set(mapKey, {
+                    ...currentAdditionalConfigs,
+                    [value]: config,
+                });
+                break;
+            }
+        }
+    }
+    matchInSet(rulesSet, value) {
+        for (const rule of rulesSet) {
+            const isMatch = matcher(rule);
+            if (isMatch(value))
+                return true;
+        }
+        return undefined;
+    }
+    transformSchema(schema) {
+        // initial mapSchema is necessary to store fields/args configs that will be attached to Types/fields in second map
+        const schemaWithRemovals = mapSchema(schema, {
+            [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                const additionalFieldRules = this.additionalFieldsMap.get(typeName);
+                const additionalArgRules = this.additionalArgsMap.get(`${typeName}.${fieldName}`);
+                const removalFieldRules = this.removalFieldsMap.get(typeName);
+                const removalArgRules = this.removalArgsMap.get(`${typeName}.${fieldName}`);
+                const hasAdditionalFieldRules = Boolean(additionalFieldRules);
+                const hasAdditionalArgRules = Boolean(additionalArgRules);
+                const hasRemovalFieldRules = Boolean(removalFieldRules && removalFieldRules.size);
+                const hasRemovalArgRules = Boolean(removalArgRules && removalArgRules.size);
+                // handle field addition
+                if (hasAdditionalFieldRules) {
+                    this.handleAdditions(additionalFieldRules, fieldName, fieldConfig);
+                }
+                // handle args addition
+                if (hasAdditionalArgRules) {
+                    for (const [argName, argConfig] of Object.entries(fieldConfig.args)) {
+                        this.handleAdditions(additionalArgRules, argName, argConfig);
+                    }
+                }
+                // handle field removal
+                if (hasRemovalFieldRules && this.matchInSet(removalFieldRules, fieldName))
+                    return null;
+                // handle args removal
+                if (hasRemovalArgRules) {
+                    const newArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => {
+                        return this.matchInSet(removalArgRules, argName)
+                            ? args
+                            : { ...args, [argName]: argConfig };
+                    }, {});
+                    return { ...fieldConfig, args: newArgs };
+                }
+                return undefined;
+            },
+        });
+        const schemaWithAdditions = mapSchema(schemaWithRemovals, {
+            ...(this.additionalFieldsConfig.size && {
+                [MapperKind.OBJECT_TYPE]: type => {
+                    const additionalFieldsConfigMap = this.additionalFieldsConfig.get(type.toString());
+                    if (!additionalFieldsConfigMap)
+                        return undefined;
+                    const newConfig = { ...type.toConfig() };
+                    newConfig.fields = { ...newConfig.fields, ...additionalFieldsConfigMap };
+                    return new GraphQLObjectType(newConfig);
+                },
+            }),
+            ...(this.additionalArgsConfig.size && {
+                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const additionalArgsConfigMap = this.additionalArgsConfig.get(`${typeName}.${fieldName}`);
+                    if (!additionalArgsConfigMap)
+                        return undefined;
+                    return {
+                        ...fieldConfig,
+                        args: { ...(fieldConfig.args || {}), ...additionalArgsConfigMap },
+                    };
+                },
+            }),
+        });
+        return pruneSchema(schemaWithAdditions);
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@graphql-mesh/transform-transfer-schema",
+  "version": "0.1.2",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@graphql-mesh/types": "^0.91.12",
+    "@graphql-mesh/utils": "^0.43.20",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*"
+  },
+  "dependencies": {
+    "micromatch": "4.0.4"
+  },
+  "license": "MIT",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "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,15 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+export default class TransferSchemaTransform implements MeshTransform {
+    noWrap: boolean;
+    private additionalFieldsMap;
+    private additionalArgsMap;
+    private additionalFieldsConfig;
+    private additionalArgsConfig;
+    private removalFieldsMap;
+    private removalArgsMap;
+    constructor(options: MeshTransformOptions<YamlConfig.TransferSchemaTransformConfig>);
+    handleAdditions(rulesArray: Set<string>, value: string, config: any): void;
+    matchInSet(rulesSet: Set<string>, value: string): true | undefined;
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}

package/typings/index.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+export default class TransferSchemaTransform implements MeshTransform {
+    noWrap: boolean;
+    private additionalFieldsMap;
+    private additionalArgsMap;
+    private additionalFieldsConfig;
+    private additionalArgsConfig;
+    private removalFieldsMap;
+    private removalArgsMap;
+    constructor(options: MeshTransformOptions<YamlConfig.TransferSchemaTransformConfig>);
+    handleAdditions(rulesArray: Set<string>, value: string, config: any): void;
+    matchInSet(rulesSet: Set<string>, value: string): true | undefined;
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}