@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/contracts/base/relation-definition.js

@@ -0,0 +1,116 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationDefinition = void 0;
+const ta_json_1 = require("ta-json");
+const data_type_1 = __importDefault(require("./data-type"));
+const member_definition_1 = require("./member-definition");
+const member_definition_type_1 = require("./member-definition-type");
+const relation_cardinality_1 = require("./relation-cardinality");
+const relation_role_1 = require("./relation-role");
+let RelationDefinition = class RelationDefinition extends member_definition_1.MemberDefinition {
+    constructor(name, init) {
+        super(name, data_type_1.default.Relation);
+        this.allowNavigation = true;
+        this.nestedProperties = [];
+        this.associatedLabels = {};
+        Object.assign(this, init);
+    }
+    get definitionType() {
+        return member_definition_type_1.MemberDefinitionType.Relation;
+    }
+};
+__decorate([
+    ta_json_1.JsonProperty("role"),
+    __metadata("design:type", Number)
+], RelationDefinition.prototype, "role", void 0);
+__decorate([
+    ta_json_1.JsonProperty("cardinality"),
+    __metadata("design:type", Number)
+], RelationDefinition.prototype, "cardinality", void 0);
+__decorate([
+    ta_json_1.JsonProperty("associated_entitydefinition"),
+    __metadata("design:type", String)
+], RelationDefinition.prototype, "associatedEntityDefinitionName", void 0);
+__decorate([
+    ta_json_1.JsonProperty("child_is_mandatory"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "childIsMandatory", void 0);
+__decorate([
+    ta_json_1.JsonProperty("parent_is_mandatory"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "parentIsMandatory", void 0);
+__decorate([
+    ta_json_1.JsonProperty("inherits_security"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "inheritsSecurity", void 0);
+__decorate([
+    ta_json_1.JsonProperty("allow_navigation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "allowNavigation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_nested"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isNested", void 0);
+__decorate([
+    ta_json_1.JsonProperty("nested_properties"),
+    ta_json_1.JsonElementType(String),
+    __metadata("design:type", Array)
+], RelationDefinition.prototype, "nestedProperties", void 0);
+__decorate([
+    ta_json_1.JsonProperty("nested_permissions"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "nestedPermissions", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_taxonomy_relation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isTaxonomyRelation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_taxonomy_hierarchy_relation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isTaxonomyHierarchyRelation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("content_is_copied"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "contentIsCopied", void 0);
+__decorate([
+    ta_json_1.JsonProperty("completion_is_copied"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "completionIsCopied", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_path_relation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isPathRelation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_path_hierarchy_relation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isPathHierarchyRelation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("path_hierarchy_score"),
+    __metadata("design:type", String)
+], RelationDefinition.prototype, "pathHierarchyScore", void 0);
+__decorate([
+    ta_json_1.JsonProperty("is_rendition_relation"),
+    __metadata("design:type", Boolean)
+], RelationDefinition.prototype, "isRenditionRelation", void 0);
+__decorate([
+    ta_json_1.JsonProperty("associated_labels"),
+    __metadata("design:type", Object)
+], RelationDefinition.prototype, "associatedLabels", void 0);
+RelationDefinition = __decorate([
+    ta_json_1.JsonObject(),
+    ta_json_1.JsonDiscriminatorValue(data_type_1.default.Relation),
+    __metadata("design:paramtypes", [String, Object])
+], RelationDefinition);
+exports.RelationDefinition = RelationDefinition;

package/dist/contracts/base/relation-manager.d.ts

@@ -0,0 +1,70 @@
+import { Nullable, NullableResultPromise } from "../../base-types";
+import { IContentHubClient } from "../../clients/content-hub-client";
+import { IRelationLoadOption } from "../querying/relation-load-option";
+import { IEntity } from "./entity";
+import { IRelation } from "./relation";
+import { RelationRole } from "./relation-role";
+export declare class RelationManager {
+    private readonly _client;
+    private readonly _entity;
+    private readonly _relations;
+    private _count;
+    get count(): number;
+    constructor(client: IContentHubClient, relations: Array<IRelation>, entity: IEntity);
+    /**
+     * Gets the relation for the specified name. If role is null and the relation is self-referencing, it will throw.
+     * Returns null if there are no loaded relations.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns A relation or null.
+     */
+    getRelation(relationName: string, role?: RelationRole): Nullable<IRelation>;
+    /**
+     * Gets a list of all loaded relations.
+     */
+    getRelations(): Array<IRelation>;
+    /**
+     * Lazy loads a relation if it is not loaded yet, adds it to the loaded relations and returns it.
+     * If the relation does not exist, null will be returned.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns A promise resolving to the relation or null.
+     */
+    loadRelationAsync(relationName: string, role?: RelationRole): NullableResultPromise<IRelation>;
+    /**
+     * Loads the specified relations.
+     * It will only load if it is actually missing relations and does not overwrite existing relations.
+     * @param relationLoadOption - Option specifying which relations to load
+     * @returns True when something was loaded.
+     */
+    loadRelationsAsync(relationLoadOption: IRelationLoadOption): Promise<boolean>;
+    /**
+     * Checks if the entity is missing relations that are specified in the {@link IRelationLoadOption}.
+     * @param relationLoadOption - Option specifying which relations to load
+     * @returns Boolean indicating if something is missing.
+     */
+    hasMissingRelations(relationLoadOption: IRelationLoadOption): boolean;
+    /**
+     * Checks if the specified relation is loaded. If role is null, any loaded role will return true.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns Boolean indicating if the specified relation exists.
+     */
+    exists(relationName: string, role?: Nullable<RelationRole>): boolean;
+    /**
+     * Imports missing relations from the entity.
+     * @param tempEntity - An entity
+     */
+    importMissingRelations(tempEntity: Nullable<IEntity>): void;
+    /**
+     * Fetches the relation from the server.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     */
+    private fetchRelationAsync;
+    /**
+     * Adds the relation to the loaded relations and updates the count.
+     * @param relation - Relation to add
+     */
+    private addRelation;
+}

package/dist/contracts/base/relation-manager.js

@@ -0,0 +1,197 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationManager = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const base_types_1 = require("../../base-types");
+const error_messages_1 = __importDefault(require("../../error-messages"));
+const guard_1 = __importDefault(require("../../guard"));
+const culture_load_option_1 = require("../querying/culture-load-option");
+const entity_load_configuration_1 = require("../querying/entity-load-configuration");
+const load_options_1 = require("../querying/load-options");
+const property_load_option_1 = require("../querying/property-load-option");
+const relation_load_option_1 = require("../querying/relation-load-option");
+const lazy_loading_manager_1 = require("./lazy-loading-manager");
+const relation_container_1 = require("./relation-container");
+class RelationManager {
+    constructor(client, relations, entity) {
+        guard_1.default.notNullOrUndefined(client);
+        guard_1.default.notNullOrUndefined(relations);
+        guard_1.default.notNullOrUndefined(entity);
+        this._client = client;
+        this._entity = entity;
+        this._relations = new base_types_1.CaseInsensitiveStringMap();
+        for (const relation of relations) {
+            this.addRelation(relation);
+        }
+    }
+    get count() {
+        return this._count;
+    }
+    /**
+     * Gets the relation for the specified name. If role is null and the relation is self-referencing, it will throw.
+     * Returns null if there are no loaded relations.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns A relation or null.
+     */
+    getRelation(relationName, role) {
+        guard_1.default.stringNotNullOrEmpty(relationName);
+        const container = this._relations[relationName];
+        if (!container) {
+            return null;
+        }
+        return container.getRelation(role);
+    }
+    /**
+     * Gets a list of all loaded relations.
+     */
+    getRelations() {
+        const relations = [];
+        for (const container of Object.values(this._relations)) {
+            if (container.isSelfRelation) {
+                Array.prototype.push.apply(relations, container.getRelations());
+            }
+            else {
+                relations.push(container.getRelation());
+            }
+        }
+        return relations;
+    }
+    /**
+     * Lazy loads a relation if it is not loaded yet, adds it to the loaded relations and returns it.
+     * If the relation does not exist, null will be returned.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns A promise resolving to the relation or null.
+     */
+    loadRelationAsync(relationName, role) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(relationName);
+            lazy_loading_manager_1.LazyLoadingManager.ensureLazyLoadingIsPossible(this._entity);
+            let relation = this.getRelation(relationName, role);
+            if (relation != null) {
+                return relation;
+            }
+            relation = yield this.fetchRelationAsync(relationName, role);
+            if (relation != null) {
+                this.addRelation(relation);
+            }
+            return relation;
+        });
+    }
+    /**
+     * Loads the specified relations.
+     * It will only load if it is actually missing relations and does not overwrite existing relations.
+     * @param relationLoadOption - Option specifying which relations to load
+     * @returns True when something was loaded.
+     */
+    loadRelationsAsync(relationLoadOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(relationLoadOption);
+            lazy_loading_manager_1.LazyLoadingManager.ensureLazyLoadingIsPossible(this._entity);
+            if (!this.hasMissingRelations(relationLoadOption)) {
+                return false;
+            }
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, property_load_option_1.PropertyLoadOption.None, relationLoadOption);
+            const tempEntity = yield this._client.entities.getAsync(this._entity.id, loadConfig);
+            this.importMissingRelations(tempEntity);
+            return true;
+        });
+    }
+    /**
+     * Checks if the entity is missing relations that are specified in the {@link IRelationLoadOption}.
+     * @param relationLoadOption - Option specifying which relations to load
+     * @returns Boolean indicating if something is missing.
+     */
+    hasMissingRelations(relationLoadOption) {
+        if (relationLoadOption == null ||
+            relationLoadOption.loadOption === load_options_1.LoadOption.None ||
+            relationLoadOption.relations == null ||
+            relationLoadOption.relations.length === 0) {
+            return false;
+        }
+        if (relationLoadOption.loadOption === load_options_1.LoadOption.All) {
+            // We don't have any info about the definition here. (Same logic as in the C# SDK)
+            return true;
+        }
+        return relationLoadOption.relations.some(requestedRelation => !this.exists(requestedRelation.name, requestedRelation.role));
+    }
+    /**
+     * Checks if the specified relation is loaded. If role is null, any loaded role will return true.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     * @returns Boolean indicating if the specified relation exists.
+     */
+    exists(relationName, role) {
+        guard_1.default.stringNotNullOrEmpty(relationName);
+        let exists = false;
+        const container = this._relations[relationName];
+        if (container) {
+            if (role == null) {
+                exists = container.any();
+            }
+            else {
+                exists = container.relationExists(role);
+            }
+        }
+        return exists;
+    }
+    /**
+     * Imports missing relations from the entity.
+     * @param tempEntity - An entity
+     */
+    importMissingRelations(tempEntity) {
+        guard_1.default.notNullOrUndefined(tempEntity);
+        for (const relation of tempEntity.relations) {
+            if (!this.exists(relation.name, relation.role)) {
+                this.addRelation(relation);
+            }
+        }
+    }
+    /**
+     * Fetches the relation from the server.
+     * @param relationName - The name of the relation
+     * @param role - The role of the relation
+     */
+    fetchRelationAsync(relationName, role) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relationLoadOption = new relation_load_option_1.RelationLoadOption([relationName]);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, property_load_option_1.PropertyLoadOption.None, relationLoadOption);
+            const tempEntity = yield this._client.entities.getAsync(this._entity.id, loadConfig);
+            if (tempEntity == null) {
+                return null;
+            }
+            const relation = tempEntity.getRelation(relationName, role);
+            return relation;
+        });
+    }
+    /**
+     * Adds the relation to the loaded relations and updates the count.
+     * @param relation - Relation to add
+     */
+    addRelation(relation) {
+        let container = this._relations[relation.name];
+        if (!container) {
+            container = new relation_container_1.RelationContainer(relation.name);
+            this._relations[relation.name] = container;
+        }
+        if (container.relationExists(relation.role)) {
+            throw new Error(string_format_1.default(error_messages_1.default.RelationManager.RelationWasAlreadyAdded, relation.name, relation.role));
+        }
+        container.setRelation(relation);
+        this._count++;
+    }
+}
+exports.RelationManager = RelationManager;

package/dist/contracts/base/relation-role.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Role of a relation.
+ */
+export declare enum RelationRole {
+    /**
+     * Parent.
+     */
+    Parent = 0,
+    /**
+     * Child.
+     */
+    Child = 1
+}
+export declare type RelationRoleType = "Parent" | "Child";

package/dist/contracts/base/relation-role.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationRole = void 0;
+/**
+ * Role of a relation.
+ */
+var RelationRole;
+(function (RelationRole) {
+    /**
+     * Parent.
+     */
+    RelationRole[RelationRole["Parent"] = 0] = "Parent";
+    /**
+     * Child.
+     */
+    RelationRole[RelationRole["Child"] = 1] = "Child";
+})(RelationRole = exports.RelationRole || (exports.RelationRole = {}));

package/dist/contracts/base/relation.d.ts

@@ -0,0 +1,74 @@
+import DirtyValueCalculator from "../../dirty-value-calculator";
+import { IMember, MemberBase } from "./member";
+import { RelationRole } from "./relation-role";
+import { ChildToManyParentsRelation, IChildToManyParentsRelation } from "./relations/child-to-many-parents-relation";
+import { ChildToOneParentRelation, IChildToOneParentRelation } from "./relations/child-to-one-parent-relation";
+import { IParentToManyChildrenRelation, ParentToManyChildrenRelation } from "./relations/parent-to-many-children-relation";
+import { IParentToOneChildRelation, ParentToOneChildRelation } from "./relations/parent-to-one-child-relation";
+/**
+ * Interface for relations.
+ */
+export interface IRelation extends IMember {
+    /**
+     * The role of this instance in the relation.
+     */
+    readonly role: RelationRole;
+    /**
+     * Indicates if multiple values can be linked in the relation's direction.
+     */
+    readonly isMultiValue: boolean;
+    /**
+     * Gets the ids of the linked entities.
+     *
+     * In case of an {@link IToManyRelation} the result will contain all ids on the relation.
+     * In case of an {@link IToOneRelation} the list can contain 1 id (maximum) if an id was set on the relation.
+     *
+     * If no id was set on the relation, an empty list is returned.
+     */
+    getIds(): Array<number>;
+    /**
+     * Sets the related entities. The values should be strictly positive.
+     *
+     * In case of an {@link IToManyRelation}, the list of ids will be set on the relation.
+     * In case of an {@link IToOneRelation}, ids can have at most one value.
+     *
+     * If the list is empty then the value will be set to null.
+     * @param ids - The ids of the entities to link
+     */
+    setIds(ids: Array<number>): void;
+    /**
+     * Clears the value(s) of the relation.
+     */
+    clear(): void;
+}
+export declare abstract class RelationBase extends MemberBase implements IRelation {
+    abstract readonly role: RelationRole;
+    abstract readonly isMultiValue: boolean;
+    protected _dirtyValueCalculator: DirtyValueCalculator;
+    protected constructor(name: string);
+    abstract getIds(): Array<number>;
+    abstract setIds(ids: Array<number>): void;
+    abstract clear(): void;
+    protected getTypeName(): string;
+    static isChildRelation(r: IRelation): r is IChildRelation;
+    static isChildToOneParentRelation(r: IRelation): r is IChildToOneParentRelation;
+    static isChildToManyParentsRelation(r: IRelation): r is IChildToManyParentsRelation;
+    static isParentRelation(r: IRelation): r is IParentRelation;
+    static isParentToOneChildRelation(r: IRelation): r is IParentToOneChildRelation;
+    static isParentToManyChildrenRelation(r: IRelation): r is IParentToManyChildrenRelation;
+}
+/** Base interface for all child relations. */
+export interface IChildRelation extends IRelation {
+    /** Indicates if this relation is used to inherit any security
+     * related metadata (from the parents towards the children).
+     */
+    inheritsSecurity: boolean;
+}
+export declare abstract class ChildRelationBase extends RelationBase implements IChildRelation {
+    inheritsSecurity: boolean;
+    protected constructor(name: string);
+}
+/** Base interface for all parent relations. */
+export interface IParentRelation extends IRelation {
+}
+export declare type RelationType = ChildToManyParentsRelation | ChildToOneParentRelation | ParentToManyChildrenRelation | ParentToOneChildRelation;

package/dist/contracts/base/relation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChildRelationBase = exports.RelationBase = void 0;
+const member_1 = require("./member");
+const member_definition_type_1 = require("./member-definition-type");
+const relation_role_1 = require("./relation-role");
+class RelationBase extends member_1.MemberBase {
+    constructor(name) {
+        super(name, member_definition_type_1.MemberDefinitionType.Relation);
+    }
+    getTypeName() {
+        return relation_role_1.RelationRole[this.role];
+    }
+    static isChildRelation(r) {
+        return r.role === relation_role_1.RelationRole.Child;
+    }
+    static isChildToOneParentRelation(r) {
+        return r.role === relation_role_1.RelationRole.Child && !r.isMultiValue;
+    }
+    static isChildToManyParentsRelation(r) {
+        return r.role === relation_role_1.RelationRole.Child && r.isMultiValue;
+    }
+    static isParentRelation(r) {
+        return r.role === relation_role_1.RelationRole.Parent;
+    }
+    static isParentToOneChildRelation(r) {
+        return r.role === relation_role_1.RelationRole.Parent && !r.isMultiValue;
+    }
+    static isParentToManyChildrenRelation(r) {
+        return r.role === relation_role_1.RelationRole.Parent && r.isMultiValue;
+    }
+}
+exports.RelationBase = RelationBase;
+class ChildRelationBase extends RelationBase {
+    constructor(name) {
+        super(name);
+        this.inheritsSecurity = true;
+    }
+}
+exports.ChildRelationBase = ChildRelationBase;

package/dist/contracts/base/relations/child-to-many-parents-relation.d.ts

@@ -0,0 +1,27 @@
+import { ChildRelationBase, IChildRelation } from "../relation";
+import { RelationRole } from "../relation-role";
+import { IToManyRelation } from "./to-many-relation";
+/**
+ * A relation where the child has many parents.
+ */
+export interface IChildToManyParentsRelation extends IChildRelation, IToManyRelation {
+    /**
+     * The list of parent ids.
+     */
+    readonly parents: Array<number>;
+}
+export declare class ChildToManyParentsRelation extends ChildRelationBase implements IChildToManyParentsRelation {
+    private _parents;
+    readonly role: RelationRole;
+    readonly isMultiValue: boolean;
+    get isDirty(): boolean;
+    get parents(): Array<number>;
+    constructor(name: string);
+    getIds(): Array<number>;
+    setIds(ids: Array<number>): void;
+    clear(): void;
+    add(id: number): void;
+    addRange(ids: Array<number>): void;
+    startTracking(): void;
+    markClean(): void;
+}

package/dist/contracts/base/relations/child-to-many-parents-relation.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChildToManyParentsRelation = void 0;
+const dirty_value_calculator_1 = __importDefault(require("../../../dirty-value-calculator"));
+const guard_1 = __importDefault(require("../../../guard"));
+const relation_1 = require("../relation");
+const relation_role_1 = require("../relation-role");
+class ChildToManyParentsRelation extends relation_1.ChildRelationBase {
+    constructor(name) {
+        super(name);
+        this._parents = [];
+        this.role = relation_role_1.RelationRole.Child;
+        this.isMultiValue = true;
+    }
+    get isDirty() {
+        if (!this.isTracking) {
+            return false;
+        }
+        else {
+            return this._dirtyValueCalculator.isDirty(this._parents);
+        }
+    }
+    get parents() {
+        return this._parents.slice();
+    }
+    getIds() {
+        return this._parents.slice();
+    }
+    setIds(ids) {
+        guard_1.default.validIds(ids);
+        this._parents.splice(0, this._parents.length);
+        this._parents.push(...ids);
+    }
+    clear() {
+        this._parents.splice(0, this._parents.length);
+    }
+    add(id) {
+        guard_1.default.validId(id);
+        if (!this._parents.includes(id)) {
+            this._parents.push(id);
+        }
+    }
+    addRange(ids) {
+        guard_1.default.validIds(ids);
+        ids.forEach(id => {
+            if (!this._parents.includes(id)) {
+                this._parents.push(id);
+            }
+        });
+    }
+    startTracking() {
+        if (this.isTracking)
+            return;
+        this.isTracking = true;
+        this._dirtyValueCalculator = new dirty_value_calculator_1.default();
+        this._dirtyValueCalculator.setOriginalValue(this._parents);
+    }
+    markClean() {
+        if (this.isTracking) {
+            this._dirtyValueCalculator.setOriginalValue(this._parents);
+        }
+    }
+}
+exports.ChildToManyParentsRelation = ChildToManyParentsRelation;

package/dist/contracts/base/relations/child-to-one-parent-relation.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from "../../../base-types";
+import { ChildRelationBase, IChildRelation } from "../relation";
+import { RelationRole } from "../relation-role";
+import { IToOneRelation } from "./to-one-relation";
+export interface IChildToOneParentRelation extends IChildRelation, IToOneRelation {
+    /**
+     * The parent id or null.
+     */
+    parent: Nullable<number>;
+}
+export declare class ChildToOneParentRelation extends ChildRelationBase implements IChildToOneParentRelation {
+    private _parent;
+    readonly role: RelationRole;
+    readonly isMultiValue: boolean;
+    get isDirty(): boolean;
+    get parent(): Nullable<number>;
+    set parent(id: Nullable<number>);
+    constructor(name: string);
+    getIds(): Array<number>;
+    setIds(ids: Array<number>): void;
+    clear(): void;
+    getId(): Nullable<number>;
+    setId(id: Nullable<number>): void;
+    startTracking(): void;
+    markClean(): void;
+}