@backland/schema/lib/CircularDeps.js

TypeScript schema declaration and validation library with static type inference

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CircularDeps = void 0;
var _utils = require("@backland/utils");
var _fieldTypeNames = require("./fields/fieldTypeNames");
/*
 * Handles circular dependencies with type safety
 */

const nodeModule = typeof module !== undefined ? module : undefined;
function getModules() {
  const sharedCode = {
    GraphType: {
      module: () => require('./GraphType/GraphType'),
      server: false
    },
    fieldInstanceFromDef: {
      module: () => require('./fieldInstanceFromDef'),
      server: false
    },
    MetaField: {
      module: () => require('./fields/MetaFieldField'),
      server: false
    },
    ObjectType: {
      module: () => require('./ObjectType'),
      server: false
    },
    fieldTypes: {
      module: () => require('./fields/fieldTypes'),
      server: false
    },
    implementObject: {
      module: () => require('./implementObject'),
      server: false
    },
    mockObject: {
      module: () => require('./mockObject'),
      server: false
    }
  };
  const serverCode = {
    tsfy: {
      // @only-server
      module: () => require('./tsfy'),
      server: true
    },
    GraphQLParser: {
      // @only-server
      module: () =>
      // @only-server
      require('./GraphType/GraphQLParser'),
      server: true
    },
    fs: {
      // @only-server
      module: () =>
      // @only-server
      require('fs-extra'),
      server: true
    },
    parsePhoneNumberServerSide: {
      // @only-server
      module: () =>
      // @only-server
      require('@backland/utils/lib/parsePhoneNumber'),
      server: true
    },
    clientUtils: {
      // @only-server
      module: () => require('./GraphType/generateClientUtils'),
      server: true
    },
    createGraphQLSchema: {
      // @only-server
      module: () => require('./createGraphQLSchema'),
      server: true
    },
    createResolver: {
      // @only-server
      module: () => require('./Resolver'),
      server: true
    },
    getQueryTemplates: {
      // @only-server
      module: () => require('./GraphType/getQueryTemplates'),
      server: true
    },
    objectToTypescript: {
      // @only-server
      module: () => {
        try {
          // too big to include in bundles
          // @only-server
          return (0, _utils.dynamicRequire)('./objectToTypescript', nodeModule);
        } catch (e) {
          return function objectToTypescript() {
            throw new Error('⚠️ Backland.objectToTypescript is not available when bundled.\n' + e.stack);
          };
        }
      },
      server: true
    },
    prettier: {
      // @only-server
      module: () => {
        try {
          // too big to include in bundled code
          // @only-server
          return (0, _utils.dynamicRequire)('prettier', nodeModule);
        } catch (e) {
          return {
            format(code) {
              console.warn('⚠️ Backland.prettier is not available when bundled.' + e.stack);
              return code;
            }
          };
        }
      },
      server: true
    },
    typesWriter: {
      // @only-server
      module: () => {
        return require('./typesWriter');
      },
      server: true
    }
  };
  return {
    ...serverCode,
    ...sharedCode,
    // shared should override others

    graphql: {
      // @only-server
      module: () => require('graphql'),
      // Too big to show in logs, let at last position
      server: true
    }
  };
}
const cache = new Map();
function get(key) {
  let existing = cache.get(key);
  if (cache.has(key)) return existing;
  const modules = getModules();
  Object.entries(modules).forEach(([_key, value]) => {
    var _mainModule;
    if (cache.has(_key)) return;

    // parser -> parser
    // parser -> vizinho

    if ((0, _utils.isBrowser)() && value.server) {
      cache.set(_key, undefined);
      return;
    }
    const moduleObject = value.module();
    if (!moduleObject) {
      return;
    }
    let mainModule = moduleObject.default ? moduleObject.default : moduleObject;
    if ((_mainModule = mainModule) !== null && _mainModule !== void 0 && _mainModule[_key]) {
      mainModule = mainModule[_key];
    }
    Object.entries(moduleObject || {}).forEach(([subKey, subModule]) => {
      if (subKey !== _key) {
        cache.set(subKey, subModule);
      }
      if (typeof mainModule === 'function' && mainModule[subKey] === undefined) {
        mainModule[subKey] = subModule;
      }
    });
    cache.set(_key, mainModule);
  });
  const fieldTypes = modules.fieldTypes.module();
  _fieldTypeNames.fieldTypeNames.forEach(key => {
    const creator = fieldTypes.create[key];
    cache.set(key, creator);
  });
  return cache.get(key);
}
const CircularDeps = new Proxy({}, {
  get(_, key) {
    const item = get(key);
    if (!item) {
      throw new _utils.RuntimeError(`${key} is not available at this environment.`, {
        validModules: [...cache.entries()].filter(el => el[1] !== undefined).map(el => el[0])
      });
    }
    return item;
  }
});
exports.CircularDeps = CircularDeps;
//# sourceMappingURL=CircularDeps.js.map