@fibery/schema 8.0.6

package/lib/index.js

@@ -0,0 +1,684 @@
+/******/ (() => { // 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);
+  });
+});
+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.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__;
+/******/ })()
+;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@fibery/schema",
+  "version": "8.0.6",
+  "description": "utils for working with fibery schema",
+  "main": "./lib/index.js",
+  "browser": "./index.js",
+  "types": "./types.d.ts",
+  "files": [
+    "/lib",
+    "types.d.ts"
+  ],
+  "private": false,
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "pluralize": "^8.0.0",
+    "memoize-one": "^6.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "7.15.0",
+    "babel-jest": "27.5.1",
+    "babel-loader": "8.2.5",
+    "@fibery/babel-preset": "7.2.0",
+    "@fibery/eslint-config": "7.1.0",
+    "@fibery/helpers": "*",
+    "jest": "27.5.1",
+    "jest-junit": "13.0.0",
+    "webpack": "5.72.0",
+    "webpack-cli": "4.9.2"
+  },
+  "scripts": {
+    "build": "BABEL_ENV=production webpack",
+    "test": "node scripts/test.js",
+    "test:ci": "yarn test --coverage --reporters=default --reporters=jest-junit",
+    "lint": "eslint ."
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts"
+    ],
+    "coverageReporters": [
+      "text",
+      "cobertura"
+    ],
+    "testPathIgnorePatterns": [
+      "<rootDir>[/\\\\](build|docs|node_modules|scripts)[/\\\\]"
+    ],
+    "transform": {
+      "^.+\\.(js|jsx|ts|tsx)$": "../fibery-ui/config/jest/babel.js"
+    },
+    "testURL": "http://localhost"
+  }
+}

package/types.d.ts

@@ -0,0 +1,89 @@
+type Cardinality =
+  | ":cardinality/one-to-one"
+  | ":cardinality/one-to-many"
+  | ":cardinality/many-to-many"
+  | ":cardinality/many-to-one";
+export type FieldObject = {
+  name: string;
+  id: string;
+  type: string;
+  rawMeta: unknown;
+  holderType: unknown;
+  isCollection: boolean;
+  isTitle: boolean;
+  isId: boolean;
+  isPublicId: boolean;
+  isReadOnly: boolean;
+  isFormula: boolean;
+  formula: unknown | null;
+  isLookup: boolean;
+  hasLinkRule: boolean;
+  linkRule: unknown | null;
+  relation: string | null;
+  defaultValue: unknown | null;
+  objectEditorOrder: number;
+  isRequired: boolean;
+  isHidden: boolean;
+  disableLinkExistingItems: boolean;
+  version: string;
+  // eslint-disable-next-line no-use-before-define
+  typeObject: TypeObject;
+  mixinTypeObject: unknown;
+  holderTypeObject: TypeObject;
+  nameParts: {
+    namespace: string;
+    name: string;
+  };
+  title: string;
+  relatedFieldObject: FieldObject | null;
+  cardinality: Cardinality;
+  kind: ":field/reference" | ":field/reference-collection" | ":field/basic";
+};
+
+export type TypeObject = {
+  name: string;
+  id: string;
+  idField: string;
+  publicIdField: string;
+  titleField: string;
+  rankField: string | null;
+  rawMeta: Record<string, unknown>;
+  isDomain: boolean;
+  isMixin: boolean;
+  mixinIcon: string | null;
+  isEnum: boolean;
+  isPrimitive: boolean;
+  isRequired: boolean;
+  isWriterModeByDefault: boolean;
+  nameParts: {
+    namespace: string;
+    name: string;
+  };
+  color: string;
+  units: unknown | null;
+  installedMixins: unknown | null;
+  syncSource: unknown | null;
+  version: string;
+  installedMixinTypeObjects: unknown;
+  title: string;
+  pluralTitle: string;
+  fieldObjects: Array<FieldObject>;
+  fieldObjectsById: Record<string, FieldObject>;
+  fieldObjectsByName: Record<string, FieldObject>;
+};
+
+export type Schema = {
+  typeObjects: Array<TypeObject>;
+  typeObjectsById: Record<string, TypeObject>;
+  typeObjectsByName: Record<string, TypeObject>;
+  id: string;
+  version: string;
+};
+
+interface Factory {
+  makeSchema: (rawSchema: Record<string, unknown>, options?: {shouldRemoveDeletedTypesAndFields: boolean}) => Schema;
+}
+
+export const factory: Factory;
+
+export const protectiveFactory: Factory;