@fibery/schema 8.1.0 → 8.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/schema",
-  "version": "8.1.0",
+  "version": "8.1.2",
   "description": "utils for working with fibery schema",
   "main": "./lib/index.js",
   "browser": "./index.js",
@@ -20,7 +20,7 @@
     "babel-jest": "27.5.1",
     "babel-loader": "8.2.5",
     "@fibery/babel-preset": "7.2.0",
-    "@fibery/eslint-config": "8.1.0",
+    "@fibery/eslint-config": "8.2.0",
     "@fibery/helpers": "1.0.2",
     "jest": "27.5.1",
     "jest-junit": "13.0.0",

package/types.d.ts

@@ -43,6 +43,7 @@ export type FieldObject = {
 
 export type TypeObject = {
   name: string;
+  description: string | null;
   id: string;
   idField: string;
   publicIdField: string;
@@ -71,6 +72,7 @@ export type TypeObject = {
   fieldObjects: Array<FieldObject>;
   fieldObjectsById: Record<string, FieldObject>;
   fieldObjectsByName: Record<string, FieldObject>;
+  typeComponentFieldObject: FieldObject | undefined;
 };
 
 export type Schema = {

package/lib/index.js

@@ -1,721 +0,0 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/compat get default export */
-/******/ 	(() => {
-/******/ 		// getDefaultExport function for compatibility with non-harmony modules
-/******/ 		__webpack_require__.n = (module) => {
-/******/ 			var getter = module && module.__esModule ?
-/******/ 				() => (module['default']) :
-/******/ 				() => (module);
-/******/ 			__webpack_require__.d(getter, { a: getter });
-/******/ 			return getter;
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/make namespace object */
-/******/ 	(() => {
-/******/ 		// define __esModule on exports
-/******/ 		__webpack_require__.r = (exports) => {
-/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 			}
-/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "factory": () => (/* binding */ factory),
-  "protectiveFactory": () => (/* binding */ protectiveFactory)
-});
-
-;// CONCATENATED MODULE: external "lodash"
-const external_lodash_namespaceObject = require("lodash");
-var external_lodash_default = /*#__PURE__*/__webpack_require__.n(external_lodash_namespaceObject);
-;// CONCATENATED MODULE: external "util"
-const external_util_namespaceObject = require("util");
-;// CONCATENATED MODULE: external "memoize-one"
-const external_memoize_one_namespaceObject = require("memoize-one");
-var external_memoize_one_default = /*#__PURE__*/__webpack_require__.n(external_memoize_one_namespaceObject);
-;// CONCATENATED MODULE: ../helpers/utils/trace.ts
-
-
-const formatWithCustomInspectParams = values => {
-  return values.map(value => {
-    if (typeof value === "object") {
-      return util.inspect(value, {
-        showHidden: false,
-        depth: null,
-        maxArrayLength: null
-      });
-    }
-
-    return value;
-  }).join(" ");
-};
-function assert(condition, ...args) {
-  if (!condition) {
-    const message = args.length > 0 ? formatWithCustomInspectParams(args) : "Assertion failed with no details";
-    throw new Error(message);
-  }
-}
-function assertWithTraceError(condition, ...args) {
-  if (!condition) {
-    const message = args.length > 0 ? formatWithCustomInspectParams(args) : "Assertion failed with no details";
-    traceError(message);
-  }
-} // eslint-disable-next-line no-console
-
-let traceErrorSubscribers = [console.error.bind(console)];
-let overridden = false;
-function subscribeOnTraceError(fn) {
-  if (overridden) {
-    throw new Error("cannot subscribe while overridden");
-  }
-
-  traceErrorSubscribers.push(fn);
-  let unsubscribed = false;
-  return function unsubscribe() {
-    assert(!unsubscribed, "Cannot unsubscribe more than once");
-    unsubscribed = true;
-    traceErrorSubscribers = traceErrorSubscribers.filter(x => x !== fn);
-  };
-}
-const traceError = external_memoize_one_default()(function traceError(...args) {
-  traceErrorSubscribers.forEach(fn => {
-    fn(...args);
-  });
-}); // eslint-disable-next-line no-console
-
-let captureMessageSubscribers = [console.info.bind(console)];
-function subscribeOnCaptureMessage(fn) {
-  captureMessageSubscribers.push(fn);
-  let unsubscribed = false;
-  return function unsubscribe() {
-    assert(!unsubscribed, "Cannot unsubscribe more than once");
-    unsubscribed = true;
-    captureMessageSubscribers = captureMessageSubscribers.filter(x => x !== fn);
-  };
-}
-const captureMessage = external_memoize_one_default()(function captureMessage(...args) {
-  captureMessageSubscribers.forEach(fn => {
-    fn(...args);
-  });
-});
-const tracedErrorTracker = {};
-const traceErrorOncePerSession = (seed, err) => {
-  if (tracedErrorTracker[seed]) {
-    return;
-  }
-
-  tracedErrorTracker[seed] = true;
-  const message = [seed, err].filter(Boolean).join(": ");
-  traceError(message);
-};
-const capturedMessageTracker = {};
-const captureMessageOncePerSession = (seed, err) => {
-  if (capturedMessageTracker[seed]) {
-    return;
-  }
-
-  capturedMessageTracker[seed] = true;
-  const message = [seed, err].filter(Boolean).join(": ");
-  captureMessage(message);
-};
-function withErrorTrace(f) {
-  return async function (...args) {
-    try {
-      return await f(...args);
-    } catch (err) {
-      traceError(err);
-      throw err;
-    }
-  };
-}
-;// CONCATENATED MODULE: ./errors.js
-class NotDefinedGetError extends Error {}
-;// CONCATENATED MODULE: ./utils.js
-
-
-
-
-const jestKey = new Set(["nodeType", "tagName", "hasAttribute"]);
-const withOnlyDefinedGets = (target, targetKind = "object") => new Proxy(target, {
-  get(target, key) {
-    if (!(key in target) && "production" !== "production") {}
-
-    return target[key];
-  }
-
-});
-
-const getNamePart = str => splitKeyword(str).name;
-
-const capitalizeFirstChar = input => {
-  const str = input || "";
-  return str ? str.charAt(0).toUpperCase() + str.slice(1) : str;
-};
-
-const replaceTildes = str => (str || "").split("~").join(" ");
-
-const toTypeOrFieldNamePartTitle = external_lodash_default().flow([capitalizeFirstChar, replaceTildes]);
-const toTypeOrFieldTitle = external_lodash_default().flow([getNamePart, toTypeOrFieldNamePartTitle]);
-const toPascalCase = (lispCasedString = "") => lispCasedString && external_lodash_default().last(lispCasedString.split("/")).split("-").map((external_lodash_default()).capitalize).join(" ");
-
-const isObsoleteTitle = str => {
-  const {
-    name
-  } = splitKeyword(str);
-  return name.toLowerCase() === name && !hasTildes(name);
-};
-
-const hasTildes = str => str.includes("~");
-
-const toNonEnumTitle = str => {
-  return isObsoleteTitle(str) ? toPascalCase(str) : toTypeOrFieldTitle(str);
-};
-const parseEnumType = type => {
-  const [templateType, targetType] = type.split("_");
-  const {
-    name: templateName,
-    namespace: templateNamespace
-  } = parseType(templateType);
-  const {
-    name: targetName,
-    namespace: targetNamespace
-  } = parseType(targetType);
-  return {
-    templateName,
-    templateNamespace,
-    targetName,
-    targetNamespace
-  };
-};
-
-const toEnumTitle = type => {
-  // enum logic
-  const {
-    templateName,
-    targetName
-  } = parseEnumType(type);
-  return toTitle(targetName) + " " + toTitle(templateName);
-};
-
-const toTitle = typeOrAttr => {
-  const str = typeOrAttr || "";
-  return str.includes("_") ? toEnumTitle(str) : toNonEnumTitle(str);
-};
-
-const splitKeyword = keyword => {
-  const str = keyword || "";
-  const index = str.indexOf("/");
-
-  if (index === -1) {
-    return {
-      namespace: "",
-      name: str
-    };
-  }
-
-  const namespace = str.substring(0, index);
-  const name = str.substring(index + 1);
-  return {
-    namespace,
-    name
-  };
-};
-
-const parseType = external_lodash_default().memoize(type => {
-  if (!type.includes("/")) {
-    traceError("parseType invalid usage: passed type is '".concat(type, "'"));
-  }
-
-  return splitKeyword(type);
-});
-const makeEnumTypeNamePart = ({
-  holderType,
-  enumName
-}) => {
-  const {
-    namespace,
-    name
-  } = parseType(holderType);
-  return "".concat(enumName, "_").concat(namespace, "/").concat(name);
-};
-const attachEnumNamespace = ({
-  enumNamespace,
-  typeNamePart
-}) => {
-  return "".concat(enumNamespace, "/").concat(typeNamePart);
-};
-const removeDeletedTypesAndFields = rawSchema => {
-  const {
-    "fibery/types": rawTypeObjects,
-    ...schemaRest
-  } = rawSchema;
-  const filteredRawTypeObjects = rawTypeObjects.filter(rawTypeObject => rawTypeObject["fibery/deleted?"] !== true).map(rawTypeObject => {
-    const {
-      "fibery/fields": rawFieldObjects,
-      ...rawTypeObjectRest
-    } = rawTypeObject;
-    const filteredRawFieldObjects = rawFieldObjects.filter(rawFieldObject => rawFieldObject["fibery/deleted?"] !== true);
-    return { ...rawTypeObjectRest,
-      "fibery/fields": filteredRawFieldObjects
-    };
-  });
-  return { ...schemaRest,
-    "fibery/types": filteredRawTypeObjects
-  };
-};
-;// CONCATENATED MODULE: ./FieldObject.js
-
-
-class FieldObject {
-  constructor({
-    rawFieldObject,
-    holderType,
-    resolveTypeObject,
-    version
-  }) {
-    if (!external_lodash_default().isPlainObject(rawFieldObject)) {
-      throw new Error("rawFieldObject arg must be plain object");
-    }
-
-    if (!external_lodash_default().isString(holderType)) {
-      throw new Error("holderType arg must be string");
-    }
-
-    if (!external_lodash_default().isFunction(resolveTypeObject)) {
-      throw new Error("resolveTypeObject arg must be function");
-    }
-
-    this.name = rawFieldObject["fibery/name"];
-    this.description = rawFieldObject["fibery/description"] || null;
-    this.id = rawFieldObject["fibery/id"];
-    this.type = rawFieldObject["fibery/type"];
-    const rawMeta = rawFieldObject["fibery/meta"] || {};
-    this.rawMeta = rawMeta;
-    this.holderType = holderType;
-    this.isCollection = rawMeta["fibery/collection?"] || false;
-    this.isTitle = rawMeta["ui/title?"] || false;
-    this.isId = rawMeta["fibery/id?"] || false;
-    this.isPublicId = rawMeta["fibery/public-id?"] || false;
-    this.isReadOnly = rawMeta["fibery/readonly?"] || false;
-    this.isFormula = rawMeta["formula/formula?"] || false;
-    this.isFormulaDisabled = rawMeta["formula/disabled?"] || false;
-    this.formulaDisableReason = rawMeta["formula/disable-reason"] || null;
-    this.formula = rawMeta["formula/formula"] || null;
-    this.isLookup = rawMeta["formula/lookup?"] || false;
-    this.hasLinkRule = rawMeta["link-rule/link-rule?"] || false;
-    this.linkRule = rawMeta["link-rule/link-rule"] || null;
-    this.relation = rawMeta["fibery/relation"] || null;
-    this.defaultValue = rawMeta["fibery/default-value"] || null;
-    this.objectEditorOrder = rawMeta["ui/object-editor-order"] || 0;
-    this.isRequired = rawMeta["fibery/required?"] === true;
-    this.isHidden = rawMeta["ui/hidden?"] === true;
-    this.isDeleted = rawFieldObject["fibery/deleted?"] || false;
-    this.disableLinkExistingItems = rawMeta["ui/disable-link-existing-items"] || false;
-    this.version = version;
-    Object.defineProperties(this, {
-      typeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => resolveTypeObject(this.type))
-      },
-      mixinTypeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return this.holderTypeObject.installedMixinTypeObjects.find(mixinTypeObject => mixinTypeObject.fieldObjectsByName.hasOwnProperty(this.name) || this.name === "workflow/state" && mixinTypeObject.name === "workflow/workflow");
-        })
-      },
-      holderTypeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return resolveTypeObject(holderType);
-        })
-      },
-      nameParts: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => parseType(rawFieldObject["fibery/name"]))
-      },
-      title: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toNonEnumTitle(rawFieldObject["fibery/name"]))
-      }
-    });
-  }
-
-  get relatedFieldObject() {
-    const {
-      name,
-      relation
-    } = this;
-
-    if (!relation) {
-      return null;
-    }
-
-    const selector = this.type !== this.holderType ? fieldObject => fieldObject.relation === relation : fieldObject => fieldObject.relation === relation && fieldObject.name !== name;
-    const fieldObject = this.typeObject.fieldObjects.find(selector);
-
-    if (!fieldObject) {
-      throw new Error("there no other end for relation ".concat(relation));
-    }
-
-    return fieldObject;
-  }
-
-  get cardinality() {
-    const {
-      isCollection,
-      relatedFieldObject,
-      typeObject
-    } = this;
-
-    if (typeObject.isPrimitive) {
-      throw new Error("Only non-basic fields have cardinality");
-    }
-
-    if (isCollection && this.rawMeta["fibery/field-reversed-collection?"]) {
-      return ":cardinality/many-to-many";
-    }
-
-    if (!relatedFieldObject) {
-      return isCollection ? ":cardinality/one-to-many" : ":cardinality/many-to-one";
-    }
-
-    const isRelationCollection = relatedFieldObject.isCollection;
-
-    if (!isCollection && !isRelationCollection) {
-      return ":cardinality/one-to-one";
-    }
-
-    if (isCollection && !isRelationCollection) {
-      return ":cardinality/one-to-many";
-    }
-
-    if (!isCollection && isRelationCollection) {
-      return ":cardinality/many-to-one";
-    }
-
-    if (isCollection && isRelationCollection) {
-      return ":cardinality/many-to-many";
-    }
-
-    throw new Error("get cardinality invariant");
-  }
-  /** @deprecated use !typeObject.isPrimitive && cardinality === ... instead */
-
-
-  get kind() {
-    if (this.typeObject.isPrimitive) {
-      if (this.isCollection) {
-        throw new Error("basic collection is not implemented");
-      } else {
-        return ":field/basic";
-      }
-    } else {
-      if (this.isCollection) {
-        return ":field/reference-collection";
-      } else {
-        return ":field/reference";
-      }
-    }
-  }
-
-}
-;// CONCATENATED MODULE: ./Schema.js
-class Schema {
-  constructor({
-    factory,
-    rawSchema: {
-      "fibery/id": id,
-      "fibery/types": rawTypeObjects,
-      "fibery/version": version
-    }
-  }) {
-    if (!Array.isArray(rawTypeObjects)) {
-      throw new Error("rawTypeObjects arg must be array");
-    }
-
-    Object.defineProperties(this, {
-      toJSON: {
-        value: () => ({
-          "fibery/types": rawTypeObjects,
-          "fibery/meta": {
-            "fibery/version": version
-          }
-        }),
-        enumerable: false
-      }
-    });
-    this.typeObjects = rawTypeObjects.map(rawTypeObject => factory.makeTypeObject({
-      rawTypeObject,
-      resolveTypeObject: type => this.typeObjectsByName[type] || null,
-      version
-    }));
-    this.typeObjectsById = factory.makeTypeObjectsById(this.typeObjects);
-    this.typeObjectsByName = factory.makeTypeObjectsByName(this.typeObjects);
-    this.id = id;
-    this.version = version;
-  }
-
-}
-;// CONCATENATED MODULE: external "pluralize"
-const external_pluralize_namespaceObject = require("pluralize");
-var external_pluralize_default = /*#__PURE__*/__webpack_require__.n(external_pluralize_namespaceObject);
-;// CONCATENATED MODULE: ./TypeObject.js
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-
-
-
-class TypeObject {
-  constructor({
-    rawTypeObject,
-    resolveTypeObject,
-    version,
-    factory
-  }) {
-    _defineProperty(this, "_getFieldObjectShortcuts", external_lodash_default().once(() => {
-      const hasRank = this.installedMixins.has("fibery/rank-mixin");
-      return this.fieldObjects.reduce((result, fieldObject) => {
-        if (fieldObject.isId) {
-          result.idField = fieldObject.name;
-          result.idFieldObject = fieldObject;
-        } else if (fieldObject.isPublicId) {
-          result.publicIdField = fieldObject.name;
-          result.publicIdFieldObject = fieldObject;
-        } else if (fieldObject.isTitle) {
-          result.titleField = fieldObject.name;
-          result.titleFieldObject = fieldObject;
-        } else if (hasRank && fieldObject.name === "fibery/rank") {
-          result.rankField = fieldObject.name;
-          result.rankFieldObject = fieldObject;
-        }
-
-        return result;
-      }, {
-        idField: null,
-        idFieldObject: null,
-        publicIdField: null,
-        publicIdFieldObject: null,
-        titleField: null,
-        titleFieldObject: null,
-        rankField: null,
-        rankFieldObject: null
-      });
-    }));
-
-    if (!external_lodash_default().isPlainObject(rawTypeObject)) {
-      throw new Error("rawTypeObject arg must be plain object");
-    }
-
-    if (!external_lodash_default().isFunction(resolveTypeObject)) {
-      throw new Error("resolveTypeObject arg must be function");
-    }
-
-    this.name = rawTypeObject["fibery/name"];
-    this.id = rawTypeObject["fibery/id"];
-    const rawMeta = rawTypeObject["fibery/meta"] || {};
-    this.rawMeta = rawMeta;
-    this.isDomain = rawMeta["fibery/domain?"] || false;
-    this.isMixin = rawMeta["app/mixin?"] || false;
-    this.mixinIcon = rawMeta["ui/mixin-icon"] || null;
-    this.isEnum = rawMeta["fibery/enum?"] || false;
-    this.isPrimitive = rawMeta["fibery/primitive?"] || false;
-    this.isWriterModeByDefault = rawMeta["ui/writer-mode?"] || false;
-    this.isDeleted = rawTypeObject["fibery/deleted?"] || false;
-    this.nameParts = parseType(this.name);
-    this.color = rawMeta["ui/color"] || "#4568FB";
-    this.units = rawMeta["ui/units"] || null;
-    this.installedMixins = new Set(Object.keys(rawMeta["app/mixins"] || {}));
-    this.syncSource = rawMeta["sync/source"] || null;
-    this.version = version;
-
-    const fieldObjectsByNameOnceGetter = external_lodash_default().once(() => {
-      return factory.makeFieldObjectsByName({
-        type: this.name,
-        fieldObjects: this.fieldObjects
-      });
-    });
-
-    const fieldObjectsGetter = external_lodash_default().once(() => rawTypeObject["fibery/fields"].map(rawFieldObject => {
-      return factory.makeFieldObject({
-        rawFieldObject,
-        holderType: this.name,
-        resolveTypeObject,
-        version
-      });
-    }));
-
-    Object.defineProperties(this, {
-      toJSON: {
-        value() {
-          if (false) {}
-
-          return rawTypeObject;
-        },
-
-        enumerable: false
-      },
-      fieldObjects: {
-        configurable: false,
-        enumerable: true,
-        get: fieldObjectsGetter
-      },
-      fieldObjectsById: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return factory.makeFieldObjectsById({
-            type: this.name,
-            fieldObjects: this.fieldObjects
-          });
-        })
-      },
-      fieldObjectsByName: {
-        configurable: false,
-        enumerable: true,
-        get: fieldObjectsByNameOnceGetter
-      },
-      installedMixinTypeObjects: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => [...this.installedMixins].map(resolveTypeObject))
-      },
-      title: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toTitle(this.name))
-      },
-      pluralTitle: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toTitle(external_pluralize_default().plural(this.name)))
-      }
-    });
-  }
-
-  get idField() {
-    return this._getFieldObjectShortcuts().idField;
-  }
-
-  get idFieldObject() {
-    return this._getFieldObjectShortcuts().idFieldObject;
-  }
-
-  get publicIdField() {
-    return this._getFieldObjectShortcuts().publicIdField;
-  }
-
-  get publicIdFieldObject() {
-    return this._getFieldObjectShortcuts().publicIdFieldObject;
-  }
-
-  get titleField() {
-    return this._getFieldObjectShortcuts().titleField;
-  }
-
-  get titleFieldObject() {
-    return this._getFieldObjectShortcuts().titleFieldObject;
-  }
-
-  get rankField() {
-    return this._getFieldObjectShortcuts().rankField;
-  }
-
-  get rankFieldObject() {
-    return this._getFieldObjectShortcuts().rankFieldObject;
-  }
-
-}
-;// CONCATENATED MODULE: ./index.js
-
-
-
-
-
-const factory = {
-  makeSchema: (rawSchema, options = {
-    shouldRemoveDeletedTypesAndFields: true
-  }) => new Schema({
-    rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-    factory
-  }),
-  makeTypeObject: args => new TypeObject({ ...args,
-    factory
-  }),
-  makeTypeObjectsById: typeObjects => external_lodash_default().keyBy(typeObjects, x => x.id),
-  makeTypeObjectsByName: typeObjects => external_lodash_default().keyBy(typeObjects, x => x.name),
-  makeFieldObject: args => new FieldObject(args),
-  makeFieldObjectsById: ({
-    type,
-    fieldObjects
-  }) => external_lodash_default().keyBy(fieldObjects, x => x.id),
-  makeFieldObjectsByName: ({
-    type,
-    fieldObjects
-  }) => external_lodash_default().keyBy(fieldObjects, x => x.name)
-};
-const protectiveFactory = {
-  makeSchema: (rawSchema, options = {
-    shouldRemoveDeletedTypesAndFields: true
-  }) => withOnlyDefinedGets(new Schema({
-    rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-    factory: protectiveFactory
-  }), "schema"),
-  makeTypeObject: args => {
-    const typeObject = new TypeObject({ ...args,
-      factory: protectiveFactory
-    });
-    return withOnlyDefinedGets(typeObject, "schema.typeObjectsByName[\"".concat(typeObject.name, "\"]"));
-  },
-  makeTypeObjectsById: typeObjects => withOnlyDefinedGets(external_lodash_default().keyBy(typeObjects, x => x.id), "schema.typeObjectsById"),
-  makeTypeObjectsByName: typeObjects => withOnlyDefinedGets(external_lodash_default().keyBy(typeObjects, x => x.name), "schema.typeObjectsByName"),
-  makeFieldObject: args => {
-    const fieldObject = new FieldObject(args);
-    return withOnlyDefinedGets(fieldObject, "schema.typeObjectsByName[\"".concat(fieldObject.holderType, "\"].fieldObjectsByName[\"").concat(fieldObject.name, "\"]"));
-  },
-  makeFieldObjectsById: ({
-    type,
-    fieldObjects
-  }) => withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.id), "schema.typeObjectsByName[\"".concat(type, "\"].fieldObjectsById")),
-  makeFieldObjectsByName: ({
-    type,
-    fieldObjects
-  }) => withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.name), "schema.typeObjectsByName[\"".concat(type, "\"].fieldObjectsByName"))
-};
-module.exports = __webpack_exports__;
-/******/ })()
-;