typeorm 0.2.38-dev.324f1d8

package/browser/persistence/EntityPersistExecutor.js

@@ -0,0 +1,201 @@
+import { __awaiter, __generator, __values } from "tslib";
+import { MustBeEntityError } from "../error/MustBeEntityError";
+import { SubjectExecutor } from "./SubjectExecutor";
+import { CannotDetermineEntityError } from "../error/CannotDetermineEntityError";
+import { Subject } from "./Subject";
+import { OneToManySubjectBuilder } from "./subject-builder/OneToManySubjectBuilder";
+import { OneToOneInverseSideSubjectBuilder } from "./subject-builder/OneToOneInverseSideSubjectBuilder";
+import { ManyToManySubjectBuilder } from "./subject-builder/ManyToManySubjectBuilder";
+import { SubjectDatabaseEntityLoader } from "./SubjectDatabaseEntityLoader";
+import { CascadesSubjectBuilder } from "./subject-builder/CascadesSubjectBuilder";
+import { OrmUtils } from "../util/OrmUtils";
+/**
+ * Persists a single entity or multiple entities - saves or removes them.
+ */
+var EntityPersistExecutor = /** @class */ (function () {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    function EntityPersistExecutor(connection, queryRunner, mode, target, entity, options) {
+        this.connection = connection;
+        this.queryRunner = queryRunner;
+        this.mode = mode;
+        this.target = target;
+        this.entity = entity;
+        this.options = options;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Executes persistence operation ob given entity or entities.
+     */
+    EntityPersistExecutor.prototype.execute = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryRunner, oldQueryRunnerData, entities, entitiesInChunks, executors, executorsWithExecutableOperations, isTransactionStartedByUs, executorsWithExecutableOperations_1, executorsWithExecutableOperations_1_1, executor, e_1_1, error_1, rollbackError_1;
+            var e_1, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // check if entity we are going to save is valid and is an object
+                        if (!this.entity || typeof this.entity !== "object")
+                            return [2 /*return*/, Promise.reject(new MustBeEntityError(this.mode, this.entity))];
+                        // we MUST call "fake" resolve here to make sure all properties of lazily loaded relations are resolved
+                        return [4 /*yield*/, Promise.resolve()];
+                    case 1:
+                        // we MUST call "fake" resolve here to make sure all properties of lazily loaded relations are resolved
+                        _b.sent();
+                        queryRunner = this.queryRunner || this.connection.createQueryRunner();
+                        oldQueryRunnerData = queryRunner.data;
+                        if (this.options && this.options.data) {
+                            queryRunner.data = this.options.data;
+                        }
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, , 22, 25]);
+                        entities = Array.isArray(this.entity) ? this.entity : [this.entity];
+                        entitiesInChunks = this.options && this.options.chunk && this.options.chunk > 0 ? OrmUtils.chunk(entities, this.options.chunk) : [entities];
+                        return [4 /*yield*/, Promise.all(entitiesInChunks.map(function (entities) { return __awaiter(_this, void 0, void 0, function () {
+                                var subjects, cascadesSubjectBuilder;
+                                var _this = this;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            subjects = [];
+                                            // create subjects for all entities we received for the persistence
+                                            entities.forEach(function (entity) {
+                                                var entityTarget = _this.target ? _this.target : entity.constructor;
+                                                if (entityTarget === Object)
+                                                    throw new CannotDetermineEntityError(_this.mode);
+                                                subjects.push(new Subject({
+                                                    metadata: _this.connection.getMetadata(entityTarget),
+                                                    entity: entity,
+                                                    canBeInserted: _this.mode === "save",
+                                                    canBeUpdated: _this.mode === "save",
+                                                    mustBeRemoved: _this.mode === "remove",
+                                                    canBeSoftRemoved: _this.mode === "soft-remove",
+                                                    canBeRecovered: _this.mode === "recover"
+                                                }));
+                                            });
+                                            cascadesSubjectBuilder = new CascadesSubjectBuilder(subjects);
+                                            subjects.forEach(function (subject) {
+                                                // next step we build list of subjects we will operate with
+                                                // these subjects are subjects that we need to insert or update alongside with main persisted entity
+                                                cascadesSubjectBuilder.build(subject, _this.mode);
+                                            });
+                                            // console.timeEnd("building cascades...");
+                                            // load database entities for all subjects we have
+                                            // next step is to load database entities for all operate subjects
+                                            // console.time("loading...");
+                                            return [4 /*yield*/, new SubjectDatabaseEntityLoader(queryRunner, subjects).load(this.mode)];
+                                        case 1:
+                                            // console.timeEnd("building cascades...");
+                                            // load database entities for all subjects we have
+                                            // next step is to load database entities for all operate subjects
+                                            // console.time("loading...");
+                                            _a.sent();
+                                            // console.timeEnd("loading...");
+                                            // console.time("other subjects...");
+                                            // build all related subjects and change maps
+                                            if (this.mode === "save" || this.mode === "soft-remove" || this.mode === "recover") {
+                                                new OneToManySubjectBuilder(subjects).build();
+                                                new OneToOneInverseSideSubjectBuilder(subjects).build();
+                                                new ManyToManySubjectBuilder(subjects).build();
+                                            }
+                                            else {
+                                                subjects.forEach(function (subject) {
+                                                    if (subject.mustBeRemoved) {
+                                                        new ManyToManySubjectBuilder(subjects).buildForAllRemoval(subject);
+                                                    }
+                                                });
+                                            }
+                                            // console.timeEnd("other subjects...");
+                                            // console.timeEnd("building subjects...");
+                                            // console.log("subjects", subjects);
+                                            // create a subject executor
+                                            return [2 /*return*/, new SubjectExecutor(queryRunner, subjects, this.options)];
+                                    }
+                                });
+                            }); }))];
+                    case 3:
+                        executors = _b.sent();
+                        executorsWithExecutableOperations = executors.filter(function (executor) { return executor.hasExecutableOperations; });
+                        if (executorsWithExecutableOperations.length === 0)
+                            return [2 /*return*/];
+                        isTransactionStartedByUs = false;
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 16, , 21]);
+                        if (!!queryRunner.isTransactionActive) return [3 /*break*/, 6];
+                        if (!(!this.options || this.options.transaction !== false)) return [3 /*break*/, 6];
+                        isTransactionStartedByUs = true;
+                        return [4 /*yield*/, queryRunner.startTransaction()];
+                    case 5:
+                        _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        _b.trys.push([6, 11, 12, 13]);
+                        executorsWithExecutableOperations_1 = __values(executorsWithExecutableOperations), executorsWithExecutableOperations_1_1 = executorsWithExecutableOperations_1.next();
+                        _b.label = 7;
+                    case 7:
+                        if (!!executorsWithExecutableOperations_1_1.done) return [3 /*break*/, 10];
+                        executor = executorsWithExecutableOperations_1_1.value;
+                        return [4 /*yield*/, executor.execute()];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9:
+                        executorsWithExecutableOperations_1_1 = executorsWithExecutableOperations_1.next();
+                        return [3 /*break*/, 7];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (executorsWithExecutableOperations_1_1 && !executorsWithExecutableOperations_1_1.done && (_a = executorsWithExecutableOperations_1.return)) _a.call(executorsWithExecutableOperations_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 13:
+                        if (!(isTransactionStartedByUs === true)) return [3 /*break*/, 15];
+                        return [4 /*yield*/, queryRunner.commitTransaction()];
+                    case 14:
+                        _b.sent();
+                        _b.label = 15;
+                    case 15: return [3 /*break*/, 21];
+                    case 16:
+                        error_1 = _b.sent();
+                        if (!isTransactionStartedByUs) return [3 /*break*/, 20];
+                        _b.label = 17;
+                    case 17:
+                        _b.trys.push([17, 19, , 20]);
+                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
+                    case 18:
+                        _b.sent();
+                        return [3 /*break*/, 20];
+                    case 19:
+                        rollbackError_1 = _b.sent();
+                        return [3 /*break*/, 20];
+                    case 20: throw error_1;
+                    case 21: return [3 /*break*/, 25];
+                    case 22:
+                        queryRunner.data = oldQueryRunnerData;
+                        if (!!this.queryRunner) return [3 /*break*/, 24];
+                        return [4 /*yield*/, queryRunner.release()];
+                    case 23:
+                        _b.sent();
+                        _b.label = 24;
+                    case 24: return [7 /*endfinally*/];
+                    case 25: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return EntityPersistExecutor;
+}());
+export { EntityPersistExecutor };
+
+//# sourceMappingURL=EntityPersistExecutor.js.map

package/browser/persistence/EntityPersistExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/persistence/EntityPersistExecutor.ts"],"names":[],"mappings":"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","file":"EntityPersistExecutor.js","sourcesContent":["import {ObjectLiteral} from \"../common/ObjectLiteral\";\nimport {SaveOptions} from \"../repository/SaveOptions\";\nimport {RemoveOptions} from \"../repository/RemoveOptions\";\nimport {MustBeEntityError} from \"../error/MustBeEntityError\";\nimport {SubjectExecutor} from \"./SubjectExecutor\";\nimport {CannotDetermineEntityError} from \"../error/CannotDetermineEntityError\";\nimport {QueryRunner} from \"../query-runner/QueryRunner\";\nimport {Connection} from \"../connection/Connection\";\nimport {Subject} from \"./Subject\";\nimport {OneToManySubjectBuilder} from \"./subject-builder/OneToManySubjectBuilder\";\nimport {OneToOneInverseSideSubjectBuilder} from \"./subject-builder/OneToOneInverseSideSubjectBuilder\";\nimport {ManyToManySubjectBuilder} from \"./subject-builder/ManyToManySubjectBuilder\";\nimport {SubjectDatabaseEntityLoader} from \"./SubjectDatabaseEntityLoader\";\nimport {CascadesSubjectBuilder} from \"./subject-builder/CascadesSubjectBuilder\";\nimport {OrmUtils} from \"../util/OrmUtils\";\n\n/**\n * Persists a single entity or multiple entities - saves or removes them.\n */\nexport class EntityPersistExecutor {\n\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(protected connection: Connection,\n                protected queryRunner: QueryRunner|undefined,\n                protected mode: \"save\"|\"remove\"|\"soft-remove\"|\"recover\",\n                protected target: Function|string|undefined,\n                protected entity: ObjectLiteral|ObjectLiteral[],\n                protected options?: SaveOptions & RemoveOptions) {\n    }\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Executes persistence operation ob given entity or entities.\n     */\n    async execute(): Promise<void> {\n\n        // check if entity we are going to save is valid and is an object\n        if (!this.entity || typeof this.entity !== \"object\")\n            return Promise.reject(new MustBeEntityError(this.mode, this.entity));\n\n        // we MUST call \"fake\" resolve here to make sure all properties of lazily loaded relations are resolved\n        await Promise.resolve();\n\n        // if query runner is already defined in this class, it means this entity manager was already created for a single connection\n        // if its not defined we create a new query runner - single connection where we'll execute all our operations\n        const queryRunner = this.queryRunner || this.connection.createQueryRunner();\n\n        // save data in the query runner - this is useful functionality to share data from outside of the world\n        // with third classes - like subscribers and listener methods\n        let oldQueryRunnerData = queryRunner.data;\n        if (this.options && this.options.data) {\n            queryRunner.data = this.options.data;\n        }\n\n        try {\n\n            // collect all operate subjects\n            const entities: ObjectLiteral[] = Array.isArray(this.entity) ? this.entity : [this.entity];\n            const entitiesInChunks = this.options && this.options.chunk && this.options.chunk > 0 ? OrmUtils.chunk(entities, this.options.chunk) : [entities];\n\n            // console.time(\"building subject executors...\");\n            const executors = await Promise.all(entitiesInChunks.map(async entities => {\n                const subjects: Subject[] = [];\n\n                // create subjects for all entities we received for the persistence\n                entities.forEach(entity => {\n                    const entityTarget = this.target ? this.target : entity.constructor;\n                    if (entityTarget === Object)\n                        throw new CannotDetermineEntityError(this.mode);\n\n                    subjects.push(new Subject({\n                        metadata: this.connection.getMetadata(entityTarget),\n                        entity: entity,\n                        canBeInserted: this.mode === \"save\",\n                        canBeUpdated: this.mode === \"save\",\n                        mustBeRemoved: this.mode === \"remove\",\n                        canBeSoftRemoved: this.mode === \"soft-remove\",\n                        canBeRecovered: this.mode === \"recover\"\n                    }));\n                });\n\n                // console.time(\"building cascades...\");\n                // go through each entity with metadata and create subjects and subjects by cascades for them\n                const cascadesSubjectBuilder = new CascadesSubjectBuilder(subjects);\n                subjects.forEach(subject => {\n                    // next step we build list of subjects we will operate with\n                    // these subjects are subjects that we need to insert or update alongside with main persisted entity\n                    cascadesSubjectBuilder.build(subject, this.mode);\n                });\n                // console.timeEnd(\"building cascades...\");\n\n                // load database entities for all subjects we have\n                // next step is to load database entities for all operate subjects\n                // console.time(\"loading...\");\n                await new SubjectDatabaseEntityLoader(queryRunner, subjects).load(this.mode);\n                // console.timeEnd(\"loading...\");\n\n                // console.time(\"other subjects...\");\n                // build all related subjects and change maps\n                if (this.mode === \"save\" || this.mode === \"soft-remove\" || this.mode === \"recover\") {\n                    new OneToManySubjectBuilder(subjects).build();\n                    new OneToOneInverseSideSubjectBuilder(subjects).build();\n                    new ManyToManySubjectBuilder(subjects).build();\n                } else {\n                    subjects.forEach(subject => {\n                        if (subject.mustBeRemoved) {\n                            new ManyToManySubjectBuilder(subjects).buildForAllRemoval(subject);\n                        }\n                    });\n                }\n                // console.timeEnd(\"other subjects...\");\n                // console.timeEnd(\"building subjects...\");\n                // console.log(\"subjects\", subjects);\n\n                // create a subject executor\n                return new SubjectExecutor(queryRunner, subjects, this.options);\n            }));\n            // console.timeEnd(\"building subject executors...\");\n\n            // make sure we have at least one executable operation before we create a transaction and proceed\n            // if we don't have operations it means we don't really need to update or remove something\n            const executorsWithExecutableOperations = executors.filter(executor => executor.hasExecutableOperations);\n            if (executorsWithExecutableOperations.length === 0)\n                return;\n\n            // start execute queries in a transaction\n            // if transaction is already opened in this query runner then we don't touch it\n            // if its not opened yet then we open it here, and once we finish - we close it\n            let isTransactionStartedByUs = false;\n            try {\n\n                // open transaction if its not opened yet\n                if (!queryRunner.isTransactionActive) {\n                    if (!this.options || this.options.transaction !== false) { // start transaction until it was not explicitly disabled\n                        isTransactionStartedByUs = true;\n                        await queryRunner.startTransaction();\n                    }\n                }\n\n                // execute all persistence operations for all entities we have\n                // console.time(\"executing subject executors...\");\n                for (const executor of executorsWithExecutableOperations) {\n                    await executor.execute();\n                }\n                // console.timeEnd(\"executing subject executors...\");\n\n                // commit transaction if it was started by us\n                // console.time(\"commit\");\n                if (isTransactionStartedByUs === true)\n                    await queryRunner.commitTransaction();\n                // console.timeEnd(\"commit\");\n\n            } catch (error) {\n\n                // rollback transaction if it was started by us\n                if (isTransactionStartedByUs) {\n                    try {\n                        await queryRunner.rollbackTransaction();\n                    } catch (rollbackError) { }\n                }\n                throw error;\n            }\n\n        } finally {\n            queryRunner.data = oldQueryRunnerData;\n\n            // release query runner only if its created by us\n            if (!this.queryRunner)\n                await queryRunner.release();\n        }\n    }\n\n}\n"],"sourceRoot":".."}

package/browser/persistence/Subject.d.ts

@@ -0,0 +1,154 @@
+import { ObjectLiteral } from "../common/ObjectLiteral";
+import { EntityMetadata } from "../metadata/EntityMetadata";
+import { SubjectChangeMap } from "./SubjectChangeMap";
+import { RelationMetadata } from "../metadata/RelationMetadata";
+import { ColumnMetadata } from "../metadata/ColumnMetadata";
+/**
+ * Subject is a subject of persistence.
+ * It holds information about each entity that needs to be persisted:
+ * - what entity should be persisted
+ * - what is database representation of the persisted entity
+ * - what entity metadata of the persisted entity
+ * - what is allowed to with persisted entity (insert/update/remove)
+ *
+ * Having this collection of subjects we can perform database queries.
+ */
+export declare class Subject {
+    /**
+     * Entity metadata of the subject entity.
+     */
+    metadata: EntityMetadata;
+    /**
+     * Subject identifier.
+     * This identifier is not limited to table entity primary columns.
+     * This can be entity id or ids as well as some unique entity properties, like name or title.
+     * Insert / Update / Remove operation will be executed by a given identifier.
+     */
+    identifier: ObjectLiteral | undefined;
+    /**
+     * Copy of entity but with relational ids fulfilled.
+     */
+    entityWithFulfilledIds: ObjectLiteral | undefined;
+    /**
+     * If subject was created by cascades this property will contain subject
+     * from where this subject was created.
+     */
+    parentSubject?: Subject;
+    /**
+     * Gets entity sent to the persistence (e.g. changed entity).
+     * If entity is not set then this subject is created only for the entity loaded from the database,
+     * or this subject is used for the junction operation (junction operations are relying only on identifier).
+     */
+    entity?: ObjectLiteral;
+    /**
+     * Database entity.
+     * THIS IS NOT RAW ENTITY DATA, its a real entity.
+     */
+    databaseEntity?: ObjectLiteral;
+    /**
+     * Indicates if database entity was loaded.
+     * No matter if it was found or not, it indicates the fact of loading.
+     */
+    databaseEntityLoaded: boolean;
+    /**
+     * Changes needs to be applied in the database for the given subject.
+     */
+    changeMaps: SubjectChangeMap[];
+    /**
+     * Generated values returned by a database (for example generated id or default values).
+     * Used in insert and update operations.
+     * Has entity-like structure (not just column database name and values).
+     */
+    generatedMap?: ObjectLiteral;
+    /**
+     * Inserted values with updated values of special and default columns.
+     * Has entity-like structure (not just column database name and values).
+     */
+    insertedValueSet?: ObjectLiteral;
+    /**
+     * Indicates if this subject can be inserted into the database.
+     * This means that this subject either is newly persisted, either can be inserted by cascades.
+     */
+    canBeInserted: boolean;
+    /**
+     * Indicates if this subject can be updated in the database.
+     * This means that this subject either was persisted, either can be updated by cascades.
+     */
+    canBeUpdated: boolean;
+    /**
+     * Indicates if this subject MUST be removed from the database.
+     * This means that this subject either was removed, either was removed by cascades.
+     */
+    mustBeRemoved: boolean;
+    /**
+     * Indicates if this subject can be soft-removed from the database.
+     * This means that this subject either was soft-removed, either was soft-removed by cascades.
+     */
+    canBeSoftRemoved: boolean;
+    /**
+     * Indicates if this subject can be recovered from the database.
+     * This means that this subject either was recovered, either was recovered by cascades.
+     */
+    canBeRecovered: boolean;
+    /**
+     * Relations updated by the change maps.
+     */
+    updatedRelationMaps: {
+        relation: RelationMetadata;
+        value: ObjectLiteral;
+    }[];
+    /**
+     * List of updated columns
+     */
+    diffColumns: ColumnMetadata[];
+    /**
+     * List of updated relations
+     */
+    diffRelations: RelationMetadata[];
+    constructor(options: {
+        metadata: EntityMetadata;
+        parentSubject?: Subject;
+        entity?: ObjectLiteral;
+        canBeInserted?: boolean;
+        canBeUpdated?: boolean;
+        mustBeRemoved?: boolean;
+        canBeSoftRemoved?: boolean;
+        canBeRecovered?: boolean;
+        identifier?: ObjectLiteral;
+        changeMaps?: SubjectChangeMap[];
+    });
+    /**
+     * Checks if this subject must be inserted into the database.
+     * Subject can be inserted into the database if it is allowed to be inserted (explicitly persisted or by cascades)
+     * and if it does not have database entity set.
+     */
+    get mustBeInserted(): boolean;
+    /**
+     * Checks if this subject must be updated into the database.
+     * Subject can be updated in the database if it is allowed to be updated (explicitly persisted or by cascades)
+     * and if it does have differentiated columns or relations.
+     */
+    get mustBeUpdated(): boolean | undefined;
+    /**
+     * Checks if this subject must be soft-removed into the database.
+     * Subject can be updated in the database if it is allowed to be soft-removed (explicitly persisted or by cascades)
+     * and if it does have differentiated columns or relations.
+     */
+    get mustBeSoftRemoved(): boolean | ObjectLiteral | undefined;
+    /**
+     * Checks if this subject must be recovered into the database.
+     * Subject can be updated in the database if it is allowed to be recovered (explicitly persisted or by cascades)
+     * and if it does have differentiated columns or relations.
+     */
+    get mustBeRecovered(): boolean | ObjectLiteral | undefined;
+    /**
+     * Creates a value set needs to be inserted / updated in the database.
+     * Value set is based on the entity and change maps of the subject.
+     * Important note: this method pops data from this subject's change maps.
+     */
+    createValueSetAndPopChangeMap(): ObjectLiteral;
+    /**
+     * Recomputes entityWithFulfilledIds and identifier when entity changes.
+     */
+    recompute(): void;
+}

package/browser/persistence/Subject.js

@@ -0,0 +1,239 @@
+import { __read, __spreadArray } from "tslib";
+import { OrmUtils } from "../util/OrmUtils";
+/**
+ * Subject is a subject of persistence.
+ * It holds information about each entity that needs to be persisted:
+ * - what entity should be persisted
+ * - what is database representation of the persisted entity
+ * - what entity metadata of the persisted entity
+ * - what is allowed to with persisted entity (insert/update/remove)
+ *
+ * Having this collection of subjects we can perform database queries.
+ */
+var Subject = /** @class */ (function () {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    function Subject(options) {
+        var _a;
+        /**
+         * Subject identifier.
+         * This identifier is not limited to table entity primary columns.
+         * This can be entity id or ids as well as some unique entity properties, like name or title.
+         * Insert / Update / Remove operation will be executed by a given identifier.
+         */
+        this.identifier = undefined;
+        /**
+         * Copy of entity but with relational ids fulfilled.
+         */
+        this.entityWithFulfilledIds = undefined;
+        /**
+         * Indicates if database entity was loaded.
+         * No matter if it was found or not, it indicates the fact of loading.
+         */
+        this.databaseEntityLoaded = false;
+        /**
+         * Changes needs to be applied in the database for the given subject.
+         */
+        this.changeMaps = [];
+        /**
+         * Indicates if this subject can be inserted into the database.
+         * This means that this subject either is newly persisted, either can be inserted by cascades.
+         */
+        this.canBeInserted = false;
+        /**
+         * Indicates if this subject can be updated in the database.
+         * This means that this subject either was persisted, either can be updated by cascades.
+         */
+        this.canBeUpdated = false;
+        /**
+         * Indicates if this subject MUST be removed from the database.
+         * This means that this subject either was removed, either was removed by cascades.
+         */
+        this.mustBeRemoved = false;
+        /**
+         * Indicates if this subject can be soft-removed from the database.
+         * This means that this subject either was soft-removed, either was soft-removed by cascades.
+         */
+        this.canBeSoftRemoved = false;
+        /**
+         * Indicates if this subject can be recovered from the database.
+         * This means that this subject either was recovered, either was recovered by cascades.
+         */
+        this.canBeRecovered = false;
+        /**
+         * Relations updated by the change maps.
+         */
+        this.updatedRelationMaps = [];
+        /**
+         * List of updated columns
+         */
+        this.diffColumns = [];
+        /**
+         * List of updated relations
+         */
+        this.diffRelations = [];
+        this.metadata = options.metadata;
+        this.entity = options.entity;
+        this.parentSubject = options.parentSubject;
+        if (options.canBeInserted !== undefined)
+            this.canBeInserted = options.canBeInserted;
+        if (options.canBeUpdated !== undefined)
+            this.canBeUpdated = options.canBeUpdated;
+        if (options.mustBeRemoved !== undefined)
+            this.mustBeRemoved = options.mustBeRemoved;
+        if (options.canBeSoftRemoved !== undefined)
+            this.canBeSoftRemoved = options.canBeSoftRemoved;
+        if (options.canBeRecovered !== undefined)
+            this.canBeRecovered = options.canBeRecovered;
+        if (options.identifier !== undefined)
+            this.identifier = options.identifier;
+        if (options.changeMaps !== undefined)
+            (_a = this.changeMaps).push.apply(_a, __spreadArray([], __read(options.changeMaps)));
+        this.recompute();
+    }
+    Object.defineProperty(Subject.prototype, "mustBeInserted", {
+        // -------------------------------------------------------------------------
+        // Accessors
+        // -------------------------------------------------------------------------
+        /**
+         * Checks if this subject must be inserted into the database.
+         * Subject can be inserted into the database if it is allowed to be inserted (explicitly persisted or by cascades)
+         * and if it does not have database entity set.
+         */
+        get: function () {
+            return this.canBeInserted && !this.databaseEntity;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Subject.prototype, "mustBeUpdated", {
+        /**
+         * Checks if this subject must be updated into the database.
+         * Subject can be updated in the database if it is allowed to be updated (explicitly persisted or by cascades)
+         * and if it does have differentiated columns or relations.
+         */
+        get: function () {
+            return this.canBeUpdated &&
+                this.identifier &&
+                (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity)) &&
+                // ((this.entity && this.databaseEntity) || (!this.entity && !this.databaseEntity)) &&
+                this.changeMaps.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Subject.prototype, "mustBeSoftRemoved", {
+        /**
+         * Checks if this subject must be soft-removed into the database.
+         * Subject can be updated in the database if it is allowed to be soft-removed (explicitly persisted or by cascades)
+         * and if it does have differentiated columns or relations.
+         */
+        get: function () {
+            return this.canBeSoftRemoved &&
+                this.identifier &&
+                (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Subject.prototype, "mustBeRecovered", {
+        /**
+         * Checks if this subject must be recovered into the database.
+         * Subject can be updated in the database if it is allowed to be recovered (explicitly persisted or by cascades)
+         * and if it does have differentiated columns or relations.
+         */
+        get: function () {
+            return this.canBeRecovered &&
+                this.identifier &&
+                (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a value set needs to be inserted / updated in the database.
+     * Value set is based on the entity and change maps of the subject.
+     * Important note: this method pops data from this subject's change maps.
+     */
+    Subject.prototype.createValueSetAndPopChangeMap = function () {
+        var _this = this;
+        var changeMapsWithoutValues = [];
+        var changeSet = this.changeMaps.reduce(function (updateMap, changeMap) {
+            var value = changeMap.value;
+            if (value instanceof Subject) {
+                // referenced columns can refer on values both which were just inserted and which were present in the model
+                // if entity was just inserted valueSets must contain all values from the entity and values just inserted in the database
+                // so, here we check if we have a value set then we simply use it as value to get our reference column values
+                // otherwise simply use an entity which cannot be just inserted at the moment and have all necessary data
+                value = value.insertedValueSet ? value.insertedValueSet : value.entity;
+            }
+            // value = changeMap.valueFactory ? changeMap.valueFactory(value) : changeMap.column.createValueMap(value);
+            var valueMap;
+            if (_this.metadata.isJunction && changeMap.column) {
+                valueMap = changeMap.column.createValueMap(changeMap.column.referencedColumn.getEntityValue(value));
+            }
+            else if (changeMap.column) {
+                valueMap = changeMap.column.createValueMap(value);
+            }
+            else if (changeMap.relation) {
+                // value can be a related object, for example: post.question = { id: 1 }
+                // or value can be a null or direct relation id, e.g. post.question = 1
+                // if its a direction relation id then we just set it to the valueMap,
+                // however if its an object then we need to extract its relation id map and set it to the valueMap
+                if (value instanceof Object && !(value instanceof Buffer)) {
+                    // get relation id, e.g. referenced column name and its value,
+                    // for example: { id: 1 } which then will be set to relation, e.g. post.category = { id: 1 }
+                    var relationId = changeMap.relation.getRelationIdMap(value);
+                    // but relation id can be empty, for example in the case when you insert a new post with category
+                    // and both post and category are newly inserted objects (by cascades) and in this case category will not have id
+                    // this means we need to insert post without question id and update post's questionId once question be inserted
+                    // that's why we create a new changeMap operation for future updation of the post entity
+                    if (relationId === undefined) {
+                        changeMapsWithoutValues.push(changeMap);
+                        _this.canBeUpdated = true;
+                        return updateMap;
+                    }
+                    valueMap = changeMap.relation.createValueMap(relationId);
+                    _this.updatedRelationMaps.push({ relation: changeMap.relation, value: relationId });
+                }
+                else { // value can be "null" or direct relation id here
+                    valueMap = changeMap.relation.createValueMap(value);
+                    _this.updatedRelationMaps.push({ relation: changeMap.relation, value: value });
+                }
+            }
+            OrmUtils.mergeDeep(updateMap, valueMap);
+            return updateMap;
+        }, {});
+        this.changeMaps = changeMapsWithoutValues;
+        return changeSet;
+    };
+    /**
+     * Recomputes entityWithFulfilledIds and identifier when entity changes.
+     */
+    Subject.prototype.recompute = function () {
+        var _this = this;
+        if (this.entity) {
+            this.entityWithFulfilledIds = Object.assign({}, this.entity);
+            if (this.parentSubject) {
+                this.metadata.primaryColumns.forEach(function (primaryColumn) {
+                    if (primaryColumn.relationMetadata && primaryColumn.relationMetadata.inverseEntityMetadata === _this.parentSubject.metadata) {
+                        var value = primaryColumn.referencedColumn.getEntityValue(_this.parentSubject.entity);
+                        primaryColumn.setEntityValue(_this.entityWithFulfilledIds, value);
+                    }
+                });
+            }
+            this.identifier = this.metadata.getEntityIdMap(this.entityWithFulfilledIds);
+        }
+        else if (this.databaseEntity) {
+            this.identifier = this.metadata.getEntityIdMap(this.databaseEntity);
+        }
+    };
+    return Subject;
+}());
+export { Subject };
+
+//# sourceMappingURL=Subject.js.map