@coderich/autograph 0.11.1 → 0.13.0

package/src/service/graphql.service.js

@@ -1,92 +0,0 @@
-const { get } = require('lodash');
-const { Kind, parse, print } = require('graphql');
-
-//
-const mergePairs = [
-  [Kind.SCHEMA_DEFINITION, Kind.SCHEMA_EXTENSION],
-  [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION],
-  [Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION],
-  [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION],
-  [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION],
-  [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION],
-  [Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION],
-];
-
-// const operators = ['Query', 'Mutation', 'Subscription'];
-
-exports.areMergeableASTs = (a, b) => {
-  const aKind = get(a, 'kind', 'a');
-  const aName = get(a, 'name.value', 'a');
-  const bKind = get(b, 'kind', 'b');
-  const bName = get(b, 'name.value', 'b');
-  const sameKind = Boolean(aKind === bKind || mergePairs.some(pair => pair.indexOf(aKind) > -1 && pair.indexOf(bKind) > -1));
-  const sameName = aName === bName;
-  return Boolean(sameKind && sameName);
-};
-
-exports.getTypeInfo = (ast, info = {}, traverse = true) => {
-  const { type } = ast;
-  if (!type) return info;
-  if (type.name) info.name = type.name.value;
-  if (type.kind === Kind.LIST_TYPE) info.isArray = true;
-  if (type.kind === Kind.NON_NULL_TYPE) info.isRequired = true;
-  return traverse ? exports.getTypeInfo(type, info) : info;
-};
-
-exports.mergeAST = (astLike) => {
-  const ast = exports.toAST(astLike); // Ensure AST
-
-  switch (ast.kind) {
-    case Kind.DOCUMENT: return exports.mergeASTSchema(ast);
-    default: return ast;
-  }
-};
-
-exports.mergeASTSchema = (schema) => {
-  const ast = exports.toAST(schema); // Ensure AST
-  ast.definitions = exports.mergeASTArray(ast.definitions); // Merge like objects
-  return ast;
-};
-
-exports.mergeASTObject = (left, right) => {
-  Object.entries(right).forEach(([key, value]) => {
-    if (key !== 'kind' && key !== 'loc') {
-      if (Array.isArray(value)) {
-        left[key] = exports.mergeASTArray((left[key] || []).concat(...value));
-      } else if (value != null) {
-        left[key] = value;
-        // left[key] = merge(left[key], value);
-      }
-    }
-  });
-};
-
-exports.mergeASTArray = (arr) => {
-  return arr.reduce((prev, curr) => {
-    const match = prev.find(el => !el.deleteFlag && exports.areMergeableASTs(el, curr));
-
-    if (match) {
-      const [left, right] = [match, curr].sort((a, b) => {
-        if (a.kind.indexOf('Extension') > -1 && b.kind.indexOf('Extension') === -1) return 1;
-        if (b.kind.indexOf('Extension') > -1 && a.kind.indexOf('Extension') === -1) return -1;
-        return 0;
-      });
-      exports.mergeASTObject(left, right);
-      right.deleteFlag = true;
-    }
-
-    return prev.concat(curr);
-  }, []).filter(el => !el.deleteFlag);
-};
-
-exports.toAST = (a) => {
-  if (typeof a === 'string') return parse(a);
-  if (Array.isArray(a)) return parse(a.map(e => exports.toGQL(e)).join('\n\n'));
-  return a;
-};
-
-exports.toGQL = (a) => {
-  if (typeof a === 'string') return a;
-  if (Array.isArray(a)) return a.join('\n\n');
-  return print(a);
-};

package/src/service/schema.service.js

@@ -1,95 +0,0 @@
-// https://hasura.io/blog/the-ultimate-guide-to-schema-stitching-in-graphql-f30178ac0072/#d677
-// https://graphql.org/graphql-js/type/
-// https://graphql.org/graphql-js/utilities/
-
-const { uniqWith } = require('lodash');
-const { GraphQLScalarType, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType } = require('graphql');
-
-exports.getSchemaData = (schema) => {
-  const operations = ['Query', 'Mutation', 'Subscription'];
-
-  return Object.entries(schema.getTypeMap()).reduce((prev, [key, value]) => {
-    let type;
-
-    if (value instanceof GraphQLScalarType) {
-      type = 'scalars';
-    } else if (value instanceof GraphQLEnumType) {
-      type = 'enums';
-    } else if (value instanceof GraphQLUnionType) {
-      type = 'unions';
-    } else if (value instanceof GraphQLInterfaceType) {
-      type = 'interfaces';
-    } else if (value instanceof GraphQLInputObjectType) {
-      type = 'inputs';
-    } else if (value instanceof GraphQLObjectType) {
-      if (operations.includes(key)) {
-        type = 'operations';
-      } else {
-        type = 'models';
-      }
-    }
-
-    if (type) {
-      if (!key.startsWith('__')) {
-        prev[type][key] = value;
-      }
-    } else {
-      console.log(`Unknown schema type { ${key}: ${value} }`);
-    }
-
-    return prev;
-  }, {
-    enums: {},
-    models: {},
-    inputs: {},
-    unions: {},
-    scalars: {},
-    operations: {},
-    directives: {},
-    interfaces: {},
-    enumerations: {},
-  });
-};
-
-exports.identifyOnDeletes = (models, parentModel) => {
-  return models.reduce((prev, model) => {
-    model.getOnDeleteFields().forEach((field) => {
-      const { modelRef, isArray } = field.toObject();
-
-      if (`${modelRef}` === `${parentModel}`) {
-        if (model.isEntity()) {
-          prev.push({ model, field, isArray, op: field.getOnDelete() });
-        } else {
-          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray, op: field.getOnDelete() })));
-        }
-      }
-    });
-
-    // Assign model referential integrity
-    return uniqWith(prev, (a, b) => `${a.model}:${a.field}:${a.fieldRef}:${a.op}` === `${b.model}:${b.field}:${b.fieldRef}:${b.op}`);
-  }, []);
-};
-
-const markGQLModels = (gql, models, weakMap = new WeakMap(), include = false) => models.reduce((map, model) => {
-  if (map.has(model)) return map;
-  if (model.isMarkedModel() && !model.hasDALScope(gql)) return map.set(model, false);
-  if (include) return map.set(model, true);
-  if (model.hasGQLScope(gql)) {
-    switch (gql) {
-      case 'c': case 'u': return markGQLModels(gql, model.getEmbeddedFields().filter(field => field.hasGQLScope(gql)).map(f => f.getModelRef()), map.set(model, true), true);
-      default: {
-        const modelRefFields = model.getModelRefFields();
-        const refFields = modelRefFields.filter(field => field.hasGQLScope(gql));
-        const modelRefs = refFields.map(field => field.getModelRef());
-        modelRefs.forEach(m => map.set(m, true));
-        return markGQLModels(gql, modelRefs, map.set(model, true), true);
-      }
-    }
-  }
-  return map;
-}, weakMap);
-
-exports.findGQLModels = (gql, models, cmpModels) => {
-  const markedModels = markGQLModels(gql, models);
-  return (cmpModels || models).filter(model => markedModels.get(model));
-};