@fibery/schema 8.1.4 → 8.1.6

package/lib/index.js

@@ -75,30 +75,35 @@ const formatWithCustomInspectParams = values => {
         maxArrayLength: null
       });
     }
-
     return value;
   }).join(" ");
 };
-function assert(condition, ...args) {
+function assert(condition) {
   if (!condition) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
     const message = args.length > 0 ? formatWithCustomInspectParams(args) : `Assertion failed with no details`;
     throw new Error(message);
   }
 }
-function assertWithTraceError(condition, ...args) {
+function assertWithTraceError(condition) {
   if (!condition) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
     const message = args.length > 0 ? formatWithCustomInspectParams(args) : `Assertion failed with no details`;
     traceError(message);
   }
-} // eslint-disable-next-line no-console
+}
 
+// eslint-disable-next-line no-console
 let traceErrorSubscribers = [console.error.bind(console)];
 const overridden = false;
 function subscribeOnTraceError(fn) {
   if (overridden) {
     throw new Error("cannot subscribe while overridden");
   }
-
   traceErrorSubscribers.push(fn);
   let unsubscribed = false;
   return function unsubscribe() {
@@ -107,12 +112,16 @@ function subscribeOnTraceError(fn) {
     traceErrorSubscribers = traceErrorSubscribers.filter(x => x !== fn);
   };
 }
-const traceError = external_memoize_one_default()(function traceError(...args) {
+const traceError = external_memoize_one_default()(function traceError() {
+  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    args[_key3] = arguments[_key3];
+  }
   traceErrorSubscribers.forEach(fn => {
     fn(...args);
   });
-}); // eslint-disable-next-line no-console
+});
 
+// eslint-disable-next-line no-console
 let captureMessageSubscribers = [console.info.bind(console)];
 function subscribeOnCaptureMessage(fn) {
   captureMessageSubscribers.push(fn);
@@ -123,7 +132,10 @@ function subscribeOnCaptureMessage(fn) {
     captureMessageSubscribers = captureMessageSubscribers.filter(x => x !== fn);
   };
 }
-const captureMessage = external_memoize_one_default()(function captureMessage(...args) {
+const captureMessage = external_memoize_one_default()(function captureMessage() {
+  for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+    args[_key4] = arguments[_key4];
+  }
   captureMessageSubscribers.forEach(fn => {
     fn(...args);
   });
@@ -133,7 +145,6 @@ const traceErrorOncePerSession = (seed, err) => {
   if (tracedErrorTracker[seed]) {
     return;
   }
-
   tracedErrorTracker[seed] = true;
   const message = [seed, err].filter(Boolean).join(": ");
   traceError(message);
@@ -143,15 +154,14 @@ 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) {
+  return async function () {
     try {
-      return await f(...args);
+      return await f(...arguments);
     } catch (err) {
       traceError(err);
       throw err;
@@ -166,37 +176,34 @@ class NotDefinedGetError extends Error {}
 
 
 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 withOnlyDefinedGets = function (target) {
+  let targetKind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "object";
+  return 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 toPascalCase = function () {
+  let lispCasedString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  return 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);
 };
@@ -217,7 +224,6 @@ const parseEnumType = type => {
     targetNamespace
   };
 };
-
 const toEnumTitle = type => {
   // enum logic
   const {
@@ -226,23 +232,19 @@ const toEnumTitle = type => {
   } = 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 {
@@ -250,28 +252,28 @@ const splitKeyword = keyword => {
     name
   };
 };
-
 const parseType = external_lodash_default().memoize(type => {
   if (!type.includes("/")) {
     traceError(`parseType invalid usage: passed type is '${type}'`);
   }
-
   return splitKeyword(type);
 });
-const makeEnumTypeNamePart = ({
-  holderType,
-  enumName
-}) => {
+const makeEnumTypeNamePart = _ref => {
+  let {
+    holderType,
+    enumName
+  } = _ref;
   const {
     namespace,
     name
   } = parseType(holderType);
   return `${enumName}_${namespace}/${name}`;
 };
-const attachEnumNamespace = ({
-  enumNamespace,
-  typeNamePart
-}) => {
+const attachEnumNamespace = _ref2 => {
+  let {
+    enumNamespace,
+    typeNamePart
+  } = _ref2;
   return `${enumNamespace}/${typeNamePart}`;
 };
 const removeDeletedTypesAndFields = rawSchema => {
@@ -285,11 +287,13 @@ const removeDeletedTypesAndFields = rawSchema => {
       ...rawTypeObjectRest
     } = rawTypeObject;
     const filteredRawFieldObjects = rawFieldObjects.filter(rawFieldObject => rawFieldObject["fibery/deleted?"] !== true);
-    return { ...rawTypeObjectRest,
+    return {
+      ...rawTypeObjectRest,
       "fibery/fields": filteredRawFieldObjects
     };
   });
-  return { ...schemaRest,
+  return {
+    ...schemaRest,
     "fibery/types": filteredRawTypeObjects
   };
 };
@@ -297,24 +301,22 @@ const removeDeletedTypesAndFields = rawSchema => {
 
 
 class FieldObject {
-  constructor({
-    rawFieldObject,
-    holderType,
-    resolveTypeObject,
-    version
-  }) {
+  constructor(_ref) {
+    let {
+      rawFieldObject,
+      holderType,
+      resolveTypeObject,
+      version
+    } = _ref;
     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"];
@@ -334,6 +336,8 @@ class FieldObject {
     this.isLookup = rawMeta["formula/lookup?"] || false;
     this.hasLinkRule = rawMeta["link-rule/link-rule?"] || false;
     this.linkRule = rawMeta["link-rule/link-rule"] || null;
+    this.isLinkRuleDisabled = rawMeta["link-rule/disabled?"] || false;
+    this.linkRuleDisableReason = rawMeta["link-rule/disable-reason"] || null;
     this.relation = rawMeta["fibery/relation"] || null;
     this.defaultValue = rawMeta["fibery/default-value"] || null;
     this.objectEditorOrder = rawMeta["ui/object-editor-order"] || 0;
@@ -374,69 +378,53 @@ class FieldObject {
       }
     });
   }
-
   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 ${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 */
-
 
+  /** @deprecated use !typeObject.isPrimitive && cardinality === ... instead */
   get kind() {
     if (this.typeObject.isPrimitive) {
       if (this.isCollection) {
@@ -452,22 +440,22 @@ class FieldObject {
       }
     }
   }
-
 }
 ;// CONCATENATED MODULE: ./Schema.js
+
 class Schema {
-  constructor({
-    factory,
-    rawSchema: {
-      "fibery/id": id,
-      "fibery/types": rawTypeObjects,
-      "fibery/version": version
-    }
-  }) {
+  constructor(_ref) {
+    let {
+      factory,
+      rawSchema: {
+        "fibery/id": id,
+        "fibery/types": rawTypeObjects,
+        "fibery/version": version
+      }
+    } = _ref;
     if (!Array.isArray(rawTypeObjects)) {
       throw new Error("rawTypeObjects arg must be array");
     }
-
     Object.defineProperties(this, {
       toJSON: {
         value: () => ({
@@ -479,42 +467,46 @@ class Schema {
         enumerable: false
       }
     });
-    const typeComponentTypeToFieldObject = new Map();
+    const getTypeComponentTypeToFieldObject = external_lodash_default().once(() => {
+      const typeComponentTypeToFieldObject = new Map();
+      this.typeObjects.flatMap(typeObject => typeObject.fieldObjects).filter(fieldObject => {
+        return fieldObject.rawMeta["fibery/type-component?"] === true && fieldObject.typeObject.rawMeta["fibery/type-component?"] === true;
+      }).forEach(fieldObject => {
+        typeComponentTypeToFieldObject.set(fieldObject.type, fieldObject);
+      });
+      return typeComponentTypeToFieldObject;
+    });
     this.typeObjects = rawTypeObjects.map(rawTypeObject => factory.makeTypeObject({
       rawTypeObject,
       resolveTypeObject: type => this.typeObjectsByName[type] || null,
-      getTypeComponentTypeToFieldObject: type => typeComponentTypeToFieldObject.get(type),
+      getTypeComponentTypeToFieldObject: type => getTypeComponentTypeToFieldObject().get(type),
       version
     }));
     this.typeObjectsById = factory.makeTypeObjectsById(this.typeObjects);
     this.typeObjectsByName = factory.makeTypeObjectsByName(this.typeObjects);
-    this.typeObjects.flatMap(typeObject => typeObject.fieldObjects).filter(fieldObject => {
-      return fieldObject.rawMeta["fibery/type-component?"] === true && fieldObject.typeObject.rawMeta["fibery/type-component?"] === true;
-    }).forEach(fieldObject => {
-      typeComponentTypeToFieldObject.set(fieldObject.type, fieldObject);
-    });
     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; }
-
+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); }
 
 
 
 class TypeObject {
-  constructor({
-    rawTypeObject,
-    resolveTypeObject,
-    getTypeComponentTypeToFieldObject,
-    version,
-    factory
-  }) {
+  constructor(_ref) {
+    let {
+      rawTypeObject,
+      resolveTypeObject,
+      getTypeComponentTypeToFieldObject,
+      version,
+      factory
+    } = _ref;
     _defineProperty(this, "_getFieldObjectShortcuts", external_lodash_default().once(() => {
       const hasRank = this.installedMixins.has("fibery/rank-mixin");
       return this.fieldObjects.reduce((result, fieldObject) => {
@@ -531,7 +523,6 @@ class TypeObject {
           result.rankField = fieldObject.name;
           result.rankFieldObject = fieldObject;
         }
-
         return result;
       }, {
         idField: null,
@@ -544,15 +535,12 @@ class TypeObject {
         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.description = rawTypeObject["fibery/description"] || null;
     this.id = rawTypeObject["fibery/id"];
@@ -571,14 +559,12 @@ class TypeObject {
     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,
@@ -587,15 +573,12 @@ class TypeObject {
         version
       });
     }));
-
     Object.defineProperties(this, {
       toJSON: {
         value() {
           if (false) {}
-
           return rawTypeObject;
         },
-
         enumerable: false
       },
       fieldObjects: {
@@ -642,39 +625,30 @@ class TypeObject {
       }
     });
   }
-
   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
 
@@ -683,36 +657,50 @@ class TypeObject {
 
 
 const factory = {
-  makeSchema: (rawSchema, options = {
-    shouldRemoveDeletedTypesAndFields: true
-  }) => new Schema({
-    rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-    factory
-  }),
-  makeTypeObject: args => new TypeObject({ ...args,
+  makeSchema: function (rawSchema) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      shouldRemoveDeletedTypesAndFields: true
+    };
+    return 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)
+  makeFieldObjectsById: _ref => {
+    let {
+      type,
+      fieldObjects
+    } = _ref;
+    return external_lodash_default().keyBy(fieldObjects, x => x.id);
+  },
+  makeFieldObjectsByName: _ref2 => {
+    let {
+      type,
+      fieldObjects
+    } = _ref2;
+    return 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`),
+  makeSchema: function (rawSchema) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      shouldRemoveDeletedTypesAndFields: true
+    };
+    return withOnlyDefinedGets(new Schema({
+      rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
+      factory: protectiveFactory
+    }), `schema`);
+  },
   makeTypeObject: args => {
-    const typeObject = new TypeObject({ ...args,
+    const typeObject = new TypeObject({
+      ...args,
       factory: protectiveFactory
     });
     return withOnlyDefinedGets(typeObject, `schema.typeObjectsByName["${typeObject.name}"]`);
@@ -723,14 +711,20 @@ const protectiveFactory = {
     const fieldObject = new FieldObject(args);
     return withOnlyDefinedGets(fieldObject, `schema.typeObjectsByName["${fieldObject.holderType}"].fieldObjectsByName["${fieldObject.name}"]`);
   },
-  makeFieldObjectsById: ({
-    type,
-    fieldObjects
-  }) => withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.id), `schema.typeObjectsByName["${type}"].fieldObjectsById`),
-  makeFieldObjectsByName: ({
-    type,
-    fieldObjects
-  }) => withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.name), `schema.typeObjectsByName["${type}"].fieldObjectsByName`)
+  makeFieldObjectsById: _ref3 => {
+    let {
+      type,
+      fieldObjects
+    } = _ref3;
+    return withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.id), `schema.typeObjectsByName["${type}"].fieldObjectsById`);
+  },
+  makeFieldObjectsByName: _ref4 => {
+    let {
+      type,
+      fieldObjects
+    } = _ref4;
+    return withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.name), `schema.typeObjectsByName["${type}"].fieldObjectsByName`);
+  }
 };
 module.exports = __webpack_exports__;
 /******/ })()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/schema",
-  "version": "8.1.4",
+  "version": "8.1.6",
   "description": "utils for working with fibery schema",
   "main": "./lib/index.js",
   "browser": "./index.js",
@@ -12,16 +12,16 @@
   "private": false,
   "dependencies": {
     "lodash": "^4.17.21",
-    "pluralize": "^8.0.0",
-    "memoize-one": "^6.0.0"
+    "memoize-one": "^6.0.0",
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.15.0",
-    "babel-jest": "27.5.1",
-    "babel-loader": "8.2.5",
+    "@babel/core": "7.20.5",
     "@fibery/babel-preset": "7.2.0",
     "@fibery/eslint-config": "8.2.0",
     "@fibery/helpers": "1.0.2",
+    "babel-jest": "27.5.1",
+    "babel-loader": "9.1.0",
     "jest": "27.5.1",
     "jest-junit": "13.0.0",
     "webpack": "5.74.0",
@@ -30,7 +30,8 @@
   "scripts": {
     "build": "BABEL_ENV=production webpack",
     "test": "node scripts/test.js",
-    "test:ci": "yarn test --coverage --reporters=default --reporters=jest-junit",
+    "test:ci": "yarn test --reporters=default --reporters=jest-junit",
+    "test:coverage": "yarn test --coverage --coverageDirectory=${JEST_COVERAGE_RESULT_DIR:-$(pwd)}/coverage/schema --reporters=default --reporters=jest-junit",
     "lint": "eslint ."
   },
   "jest": {

package/types.d.ts

@@ -30,6 +30,7 @@ export type FieldObject = {
   // eslint-disable-next-line no-use-before-define
   typeObject: TypeObject;
   mixinTypeObject: unknown;
+  // eslint-disable-next-line no-use-before-define
   holderTypeObject: TypeObject;
   nameParts: {
     namespace: string;