@backland/schema
Version:
TypeScript schema declaration and validation library with static type inference
198 lines (195 loc) • 6.72 kB
JavaScript
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
/*
* Handles circular dependencies with type safety
*/
import { RuntimeError } from '@backland/utils';
import { dynamicRequire } from '@backland/utils';
import { isBrowser } from '@backland/utils';
import { fieldTypeNames } from './fields/fieldTypeNames';
var nodeModule = typeof module !== undefined ? module : undefined;
function getModules() {
var 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
}
};
var 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 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 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 _objectSpread(_objectSpread(_objectSpread({}, serverCode), sharedCode), {}, {
// shared should override others
graphql: {
// @only-server
module: () => require('graphql'),
// Too big to show in logs, let at last position
server: true
}
});
}
var cache = new Map();
function get(key) {
var existing = cache.get(key);
if (cache.has(key)) return existing;
var modules = getModules();
Object.entries(modules).forEach(_ref => {
var _mainModule;
var [_key, value] = _ref;
if (cache.has(_key)) return;
// parser -> parser
// parser -> vizinho
if (isBrowser() && value.server) {
cache.set(_key, undefined);
return;
}
var moduleObject = value.module();
if (!moduleObject) {
return;
}
var mainModule = moduleObject.default ? moduleObject.default : moduleObject;
if ((_mainModule = mainModule) !== null && _mainModule !== void 0 && _mainModule[_key]) {
mainModule = mainModule[_key];
}
Object.entries(moduleObject || {}).forEach(_ref2 => {
var [subKey, subModule] = _ref2;
if (subKey !== _key) {
cache.set(subKey, subModule);
}
if (typeof mainModule === 'function' && mainModule[subKey] === undefined) {
mainModule[subKey] = subModule;
}
});
cache.set(_key, mainModule);
});
var fieldTypes = modules.fieldTypes.module();
fieldTypeNames.forEach(key => {
var creator = fieldTypes.create[key];
cache.set(key, creator);
});
return cache.get(key);
}
export var CircularDeps = new Proxy({}, {
get(_, key) {
var item = get(key);
if (!item) {
throw new RuntimeError("".concat(key, " is not available at this environment."), {
validModules: [...cache.entries()].filter(el => el[1] !== undefined).map(el => el[0])
});
}
return item;
}
});
//# sourceMappingURL=CircularDeps.js.map