@fibery/schema 8.4.0 → 10.0.0

package/lib/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class NotDefinedGetError extends Error {
+}

package/lib/src/errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotDefinedGetError = void 0;
+class NotDefinedGetError extends Error {
+}
+exports.NotDefinedGetError = NotDefinedGetError;

package/lib/src/factory.d.ts

@@ -0,0 +1,22 @@
+import { FieldObject, FieldObjectParams } from "./field-object";
+import { Schema } from "./schema";
+import { TypeObject, TypeObjectParams } from "./type-object";
+export type Factory = {
+    makeSchema: (rawSchema: Record<string, unknown>, options?: {
+        shouldRemoveDeletedTypesAndFields: boolean;
+    }) => Schema;
+    makeTypeObject: (params: Omit<TypeObjectParams, "factory">) => TypeObject;
+    makeTypeObjectsById: (typeObjects: TypeObject[]) => Record<string, TypeObject>;
+    makeTypeObjectsByName: (typeObjects: TypeObject[]) => Record<string, TypeObject>;
+    makeFieldObject: (params: FieldObjectParams) => FieldObject;
+    makeFieldObjectsById: (params: {
+        type: string;
+        fieldObjects: FieldObject[];
+    }) => Record<string, FieldObject>;
+    makeFieldObjectsByName: (params: {
+        type: string;
+        fieldObjects: FieldObject[];
+    }) => Record<string, FieldObject>;
+};
+export declare const factory: Factory;
+export declare const protectiveFactory: Factory;

package/lib/src/factory.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protectiveFactory = exports.factory = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const field_object_1 = require("./field-object");
+const schema_1 = require("./schema");
+const type_object_1 = require("./type-object");
+const utils_1 = require("./utils");
+exports.factory = {
+    makeSchema: (rawSchema, options = { shouldRemoveDeletedTypesAndFields: true }) => new schema_1.Schema({
+        rawSchema: options.shouldRemoveDeletedTypesAndFields
+            ? (0, utils_1.removeDeletedTypesAndFields)(rawSchema)
+            : rawSchema,
+        factory: exports.factory,
+    }),
+    makeTypeObject: (args) => new type_object_1.TypeObject({ ...args, factory: exports.factory }),
+    makeTypeObjectsById: (typeObjects) => lodash_1.default.keyBy(typeObjects, (x) => x.id),
+    makeTypeObjectsByName: (typeObjects) => lodash_1.default.keyBy(typeObjects, (x) => x.name),
+    makeFieldObject: (args) => new field_object_1.FieldObject(args),
+    makeFieldObjectsById: ({ fieldObjects }) => lodash_1.default.keyBy(fieldObjects, (x) => x.id),
+    makeFieldObjectsByName: ({ fieldObjects }) => lodash_1.default.keyBy(fieldObjects, (x) => x.name),
+};
+exports.protectiveFactory = {
+    makeSchema: (rawSchema, options = { shouldRemoveDeletedTypesAndFields: true }) => (0, utils_1.withOnlyDefinedGets)(new schema_1.Schema({
+        rawSchema: options.shouldRemoveDeletedTypesAndFields
+            ? (0, utils_1.removeDeletedTypesAndFields)(rawSchema)
+            : rawSchema,
+        factory: exports.protectiveFactory,
+    }), `schema`),
+    makeTypeObject: (args) => {
+        const typeObject = new type_object_1.TypeObject({ ...args, factory: exports.protectiveFactory });
+        return (0, utils_1.withOnlyDefinedGets)(typeObject, `schema.typeObjectsByName["${typeObject.name}"]`);
+    },
+    makeTypeObjectsById: (typeObjects) => (0, utils_1.withOnlyDefinedGets)(lodash_1.default.keyBy(typeObjects, (x) => x.id), "schema.typeObjectsById"),
+    makeTypeObjectsByName: (typeObjects) => (0, utils_1.withOnlyDefinedGets)(lodash_1.default.keyBy(typeObjects, (x) => x.name), "schema.typeObjectsByName"),
+    makeFieldObject: (args) => {
+        const fieldObject = new field_object_1.FieldObject(args);
+        return (0, utils_1.withOnlyDefinedGets)(fieldObject, `schema.typeObjectsByName["${fieldObject.holderType}"].fieldObjectsByName["${fieldObject.name}"]`);
+    },
+    makeFieldObjectsById: ({ type, fieldObjects }) => (0, utils_1.withOnlyDefinedGets)(lodash_1.default.keyBy(fieldObjects, (x) => x.id), `schema.typeObjectsByName["${type}"].fieldObjectsById`),
+    makeFieldObjectsByName: ({ type, fieldObjects }) => (0, utils_1.withOnlyDefinedGets)(lodash_1.default.keyBy(fieldObjects, (x) => x.name), `schema.typeObjectsByName["${type}"].fieldObjectsByName`),
+};

package/lib/src/field-object.d.ts

@@ -0,0 +1,84 @@
+import { TypeObject } from "./type-object";
+export type Cardinality = ":cardinality/one-to-one" | ":cardinality/one-to-many" | ":cardinality/many-to-many" | ":cardinality/many-to-one";
+export type RawFieldObject = {
+    "fibery/id": string;
+    "fibery/name": string;
+    "fibery/type": string;
+    "fibery/description"?: string;
+    "fibery/deleted?"?: boolean;
+    "fibery/meta": {
+        "fibery/collection?"?: boolean;
+        "ui/title?"?: boolean;
+        "fibery/id?"?: boolean;
+        "fibery/public-id?"?: boolean;
+        "fibery/readonly?"?: boolean;
+        "formula/formula?"?: boolean;
+        "formula/disabled?"?: boolean;
+        "formula/disable-reason"?: string;
+        "formula/formula"?: unknown;
+        "formula/lookup?"?: boolean;
+        "link-rule/link-rule?"?: boolean;
+        "link-rule/link-rule"?: unknown;
+        "link-rule/disabled?"?: boolean;
+        "link-rule/disable-reason"?: string;
+        "fibery/relation"?: string;
+        "fibery/default-value"?: unknown;
+        "ui/object-editor-order"?: number;
+        "fibery/required?"?: boolean;
+        "ui/hidden?"?: boolean;
+        "ui/disable-link-existing-items"?: boolean;
+        "fibery/multi-relation"?: string;
+    };
+};
+export type FieldObjectParams = {
+    rawFieldObject: RawFieldObject;
+    holderType: string;
+    resolveTypeObject: (type: string) => TypeObject;
+    version: string;
+    resolveMultiRelatedFieldObjects: (multiRelation: string) => FieldObject[];
+};
+export declare class FieldObject {
+    name: string;
+    description: string | null;
+    id: string;
+    type: string;
+    rawMeta: Record<string, unknown>;
+    holderType: string;
+    isCollection: boolean;
+    isTitle: boolean;
+    isId: boolean;
+    isPublicId: boolean;
+    isReadOnly: boolean;
+    isFormula: boolean;
+    isFormulaDisabled: boolean;
+    formulaDisableReason: string | null;
+    formula: unknown | null;
+    isLookup: boolean;
+    hasLinkRule: boolean;
+    linkRule: unknown | null;
+    isLinkRuleDisabled: boolean;
+    linkRuleDisableReason: string | null;
+    relation: string | null;
+    multiRelation: string | null;
+    defaultValue: unknown | null;
+    objectEditorOrder: number;
+    isRequired: boolean;
+    isHidden: boolean;
+    isDeleted: boolean;
+    disableLinkExistingItems: boolean;
+    version: string;
+    typeObject: TypeObject;
+    mixinTypeObject: unknown;
+    holderTypeObject: TypeObject;
+    nameParts: {
+        namespace: string;
+        name: string;
+    };
+    title: string;
+    multiRelatedFieldObjects: Array<FieldObject>;
+    constructor({ rawFieldObject, holderType, resolveTypeObject, version, resolveMultiRelatedFieldObjects, }: FieldObjectParams);
+    get relatedFieldObject(): FieldObject | null;
+    get cardinality(): Cardinality;
+    /** @deprecated use !typeObject.isPrimitive && cardinality === ... instead */
+    get kind(): ":field/basic" | ":field/reference-collection" | ":field/reference";
+}

package/lib/src/field-object.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldObject = void 0;
+/* eslint-disable no-use-before-define */
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("./utils");
+class FieldObject {
+    name;
+    description;
+    id;
+    type;
+    rawMeta;
+    holderType;
+    isCollection;
+    isTitle;
+    isId;
+    isPublicId;
+    isReadOnly;
+    isFormula;
+    isFormulaDisabled;
+    formulaDisableReason;
+    formula;
+    isLookup;
+    hasLinkRule;
+    linkRule;
+    isLinkRuleDisabled;
+    linkRuleDisableReason;
+    relation;
+    multiRelation;
+    defaultValue;
+    objectEditorOrder;
+    isRequired;
+    isHidden;
+    isDeleted;
+    disableLinkExistingItems;
+    version;
+    typeObject;
+    mixinTypeObject;
+    holderTypeObject;
+    nameParts;
+    title;
+    multiRelatedFieldObjects;
+    constructor({ rawFieldObject, holderType, resolveTypeObject, version, resolveMultiRelatedFieldObjects, }) {
+        if (!lodash_1.default.isPlainObject(rawFieldObject)) {
+            throw new Error("rawFieldObject arg must be plain object");
+        }
+        if (!lodash_1.default.isString(holderType)) {
+            throw new Error("holderType arg must be string");
+        }
+        if (!lodash_1.default.isFunction(resolveTypeObject)) {
+            throw new Error("resolveTypeObject arg must be function");
+        }
+        if (!lodash_1.default.isFunction(resolveMultiRelatedFieldObjects)) {
+            throw new Error("resolveMultiRelationFieldObjects 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.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;
+        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;
+        this.multiRelation = rawMeta["fibery/multi-relation"] || null;
+        Object.defineProperties(this, {
+            typeObject: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => resolveTypeObject(this.type)),
+            },
+            mixinTypeObject: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => {
+                    return this.holderTypeObject.installedMixinTypeObjects.find((mixinTypeObject) => 
+                    // eslint-disable-next-line prefer-object-has-own
+                    Object.prototype.hasOwnProperty.call(mixinTypeObject.fieldObjectsByName, this.name) ||
+                        (this.name === "workflow/state" && mixinTypeObject.name === "workflow/workflow"));
+                }),
+            },
+            holderTypeObject: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => {
+                    return resolveTypeObject(holderType);
+                }),
+            },
+            nameParts: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => (0, utils_1.parseType)(rawFieldObject["fibery/name"])),
+            },
+            title: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => (0, utils_1.toNonEnumTitle)(rawFieldObject["fibery/name"])),
+            },
+            multiRelatedFieldObjects: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => {
+                    const { multiRelation, typeObject } = this;
+                    if (!multiRelation || !typeObject.isEntityRef) {
+                        return [];
+                    }
+                    return resolveMultiRelatedFieldObjects(multiRelation);
+                }),
+            },
+        });
+    }
+    get relatedFieldObject() {
+        const { name, relation, multiRelation, typeObject } = this;
+        if (!relation && !multiRelation) {
+            return null;
+        }
+        if (!relation && multiRelation && typeObject.isEntityRef) {
+            return null;
+        }
+        let relationKey;
+        let relationId;
+        if (relation) {
+            relationKey = "relation";
+            relationId = relation;
+        }
+        else {
+            relationId = multiRelation;
+            relationKey = "multiRelation";
+        }
+        const selector = this.type !== this.holderType
+            ? (fieldObject) => fieldObject[relationKey] === relationId
+            : (fieldObject) => fieldObject[relationKey] === relationId && fieldObject.name !== name;
+        const fieldObject = this.typeObject.fieldObjects.find(selector);
+        if (!fieldObject) {
+            throw new Error(`there no other end for ${relationKey} ${relationId}`);
+        }
+        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";
+            }
+        }
+    }
+}
+exports.FieldObject = FieldObject;

package/lib/src/print-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidIdentifier: (x: string) => boolean;
+export declare const printJsPath: (keys: string[]) => string;

package/lib/src/print-utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJsPath = exports.isValidIdentifier = void 0;
+const validIdentifierRegExp = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+const isValidIdentifier = (x) => validIdentifierRegExp.test(x);
+exports.isValidIdentifier = isValidIdentifier;
+const printJsPath = (keys) => keys.map((key) => ((0, exports.isValidIdentifier)(key) ? "." + key : `["${key}"]`)).join("");
+exports.printJsPath = printJsPath;

package/lib/src/schema.d.ts

@@ -0,0 +1,18 @@
+import { RawTypeObject, TypeObject } from "./type-object";
+import { Factory } from "./factory";
+export type RawSchema = {
+    "fibery/id": string;
+    "fibery/types": RawTypeObject[];
+    "fibery/version": string;
+};
+export declare class Schema {
+    typeObjects: Array<TypeObject>;
+    typeObjectsById: Record<string, TypeObject>;
+    typeObjectsByName: Record<string, TypeObject>;
+    id: string;
+    version: string;
+    constructor({ factory, rawSchema: { "fibery/id": id, "fibery/types": rawTypeObjects, "fibery/version": version }, }: {
+        factory: Factory;
+        rawSchema: RawSchema;
+    });
+}

package/lib/src/schema.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+class Schema {
+    typeObjects;
+    typeObjectsById;
+    typeObjectsByName;
+    id;
+    version;
+    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,
+            },
+        });
+        const getTypeComponentTypeToFieldObject = lodash_1.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;
+        });
+        let multiRelatedFieldsObjectsMap;
+        const initMultiRelatedFieldsObjectsMap = () => {
+            multiRelatedFieldsObjectsMap = new Map();
+            this.typeObjects.forEach((typeObject) => {
+                typeObject.fieldObjects.forEach((fieldObject) => {
+                    if (fieldObject.multiRelation && !fieldObject.typeObject.isEntityRef) {
+                        const store = multiRelatedFieldsObjectsMap.get(fieldObject.multiRelation) || [];
+                        store.push(fieldObject);
+                        multiRelatedFieldsObjectsMap.set(fieldObject.multiRelation, store);
+                    }
+                });
+            });
+        };
+        this.typeObjects = rawTypeObjects.map((rawTypeObject) => factory.makeTypeObject({
+            rawTypeObject,
+            resolveTypeObject: (type) => this.typeObjectsByName[type] || null,
+            getTypeComponentTypeToFieldObject: (type) => getTypeComponentTypeToFieldObject().get(type),
+            resolveMultiRelatedFieldObjects: (multiRelation) => {
+                if (!multiRelatedFieldsObjectsMap) {
+                    initMultiRelatedFieldsObjectsMap();
+                }
+                return multiRelatedFieldsObjectsMap.get(multiRelation) || [];
+            },
+            version,
+        }));
+        this.typeObjectsById = factory.makeTypeObjectsById(this.typeObjects);
+        this.typeObjectsByName = factory.makeTypeObjectsByName(this.typeObjects);
+        this.id = id;
+        this.version = version;
+    }
+}
+exports.Schema = Schema;

package/lib/src/type-object.d.ts

@@ -0,0 +1,100 @@
+import { FieldObject, RawFieldObject } from "./field-object";
+type SyncSource = {
+    appId: string;
+    appName: string;
+    id: string;
+    state: string;
+    type: string;
+};
+export type RawTypeObject = {
+    "fibery/id": string;
+    "fibery/name": string;
+    "fibery/description"?: string | null;
+    "fibery/deleted?"?: boolean;
+    "fibery/fields": RawFieldObject[];
+    "fibery/meta": {
+        "fibery/domain?"?: boolean;
+        "fibery/platform?"?: boolean;
+        "fibery/highlight?"?: boolean;
+        "app/mixin?"?: boolean;
+        "ui/mixin-icon"?: string;
+        "fibery/enum?"?: boolean;
+        "fibery/primitive?"?: boolean;
+        "ui/writer-mode?"?: boolean;
+        "ui/color"?: string;
+        "ui/units"?: unknown[];
+        "app/mixins"?: Record<string, boolean>;
+        "sync/source"?: SyncSource;
+        "fibery/secured?"?: boolean;
+    };
+};
+export type TypeObjectParams = {
+    rawTypeObject: RawTypeObject;
+    resolveTypeObject: (type: string) => TypeObject;
+    getTypeComponentTypeToFieldObject: (value: string) => FieldObject;
+    version: string;
+    factory: {
+        makeFieldObjectsByName: (params: {
+            type: string;
+            fieldObjects: FieldObject[];
+        }) => Record<string, FieldObject>;
+        makeFieldObjectsById: (params: {
+            type: string;
+            fieldObjects: FieldObject[];
+        }) => Record<string, FieldObject>;
+        makeFieldObject: (params: any) => FieldObject;
+    };
+    resolveMultiRelatedFieldObjects: (multiRelation: string) => FieldObject[];
+};
+export declare class TypeObject {
+    name: string;
+    description: string | null;
+    id: string;
+    rawMeta: Record<string, unknown>;
+    isDomain: boolean;
+    isPlatform: boolean;
+    isHighlight: boolean;
+    isMixin: boolean;
+    mixinIcon: string | null;
+    isEnum: boolean;
+    isPrimitive: boolean;
+    isWriterModeByDefault: boolean;
+    nameParts: {
+        namespace: string;
+        name: string;
+    };
+    color: string;
+    units: unknown | null;
+    installedMixins: Set<string>;
+    syncSource: SyncSource | null;
+    version: string;
+    installedMixinTypeObjects: TypeObject[];
+    title: string;
+    pluralTitle: string;
+    fieldObjects: Array<FieldObject>;
+    fieldObjectsById: Record<string, FieldObject>;
+    fieldObjectsByName: Record<string, FieldObject>;
+    typeComponentFieldObject: FieldObject | undefined;
+    isDeleted: boolean;
+    isEntityRef: boolean;
+    constructor({ rawTypeObject, resolveTypeObject, getTypeComponentTypeToFieldObject, version, factory, resolveMultiRelatedFieldObjects, }: TypeObjectParams);
+    _getFieldObjectShortcuts: () => {
+        idField: string;
+        idFieldObject: FieldObject;
+        publicIdField: string;
+        publicIdFieldObject: FieldObject;
+        titleField: string;
+        titleFieldObject: FieldObject;
+        rankField: null | string;
+        rankFieldObject: null | FieldObject;
+    };
+    get idField(): string;
+    get idFieldObject(): FieldObject;
+    get publicIdField(): string;
+    get publicIdFieldObject(): FieldObject;
+    get titleField(): string;
+    get titleFieldObject(): FieldObject;
+    get rankField(): string | null;
+    get rankFieldObject(): FieldObject | null;
+}
+export {};