taon 0.0.0 → 18.0.15

package/websql/esm2022/lib/base-classes/base-repository.mjs

@@ -0,0 +1,431 @@
+import { __decorate, __metadata } from "tslib";
+import { Helpers } from 'tnp-core/websql';
+import { _ } from 'tnp-core/websql';
+import { ClassHelpers } from '../helpers/class-helpers';
+import { MySqlQuerySource } from 'taon-type-sql/websql';
+import { TaonRepository } from '../decorators/classes/repository-decorator';
+import { BaseInjector } from './base-injector';
+const INDEX_KEYS_NO_FOR_UPDATE = ['id'];
+let BaseRepository = class BaseRepository extends BaseInjector {
+    constructor(__entityClassResolveFn) {
+        super();
+        this.__entityClassResolveFn = __entityClassResolveFn;
+        // @ts-ignore
+        this.entityClassResolveFn = __entityClassResolveFn;
+    }
+    get dbQuery() {
+        if (!this.__dbQuery) {
+            if (!this.__endpoint_context__) {
+                return; // TODO
+                throw new Error(`[BaseRepository] Context not inited for class ${ClassHelpers.getName(this)}`);
+            }
+            const connection = this.__endpoint_context__?.connection;
+            if (!connection) {
+                throw new Error(`[BaseRepository] Database not inited for context ${this.__endpoint_context__?.contextName}`);
+            }
+            this.__dbQuery = new MySqlQuerySource(connection);
+        }
+        return this.__dbQuery;
+    }
+    get connection() {
+        return this.__endpoint_context__?.connection;
+    }
+    get repository() {
+        return this.__repository;
+    }
+    /**
+     * target for repository
+     */
+    get target() {
+        return this?.repository?.target;
+    }
+    /**
+     * alias to repository
+     */
+    get repo() {
+        return this.repository;
+    }
+    get repositoryExists() {
+        return !!this.__repository;
+    }
+    async __init(context) {
+        if (this.__repository) {
+            return;
+        }
+        let entityClassFn = this.entityClassResolveFn();
+        if (!entityClassFn) {
+            Helpers.warn(`Entity class not provided for repository ${ClassHelpers.getName(this)}`);
+            return;
+        }
+        const ctx = this.__endpoint_context__;
+        if (ctx.remoteHost) {
+            return;
+        }
+        const connection = ctx.connection;
+        if (!connection) {
+            throw new Error(`
+
+        Connection not found for context ${ctx.contextName}
+
+
+        Maybe you forgot to init database ?
+
+        Taon.createContext({
+        ...
+        database:true
+        ...
+        })
+
+        `);
+        }
+        if (!entityClassFn) {
+            Helpers.warn(`Entity class not found for repository ${ClassHelpers.getName(this)}`);
+            return;
+        }
+        this.__repository = (await connection.getRepository(ClassHelpers.getOrginalClass(entityClassFn)));
+    }
+    /**
+     * Checks if entity has an id.
+     * If entity composite compose ids, it will check them all.
+     */
+    hasId(entity) {
+        return this.repo.hasId(entity);
+    }
+    /**
+     * Gets entity mixed id.
+     */
+    getId(entity) {
+        return this.repo.getId(entity);
+    }
+    /**
+      Saves a given entity in the database.
+     * If entity does not exist in the database then inserts, otherwise updates.
+     */
+    async save(item, options) {
+        let model = await this.repo.create(item);
+        model = await this.repo.save(model, options);
+        const { id } = model;
+        model = await this.repo.findOne({
+            where: { id },
+        });
+        return model;
+    }
+    /**
+     * alias to save
+     * -> it will actuall create new entity in db
+     * in oposite to typeorm create method
+     */
+    async create(item, options) {
+        return this.save(item, options);
+    }
+    async bulkSave(items, options) {
+        const models = [];
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const model = await this.save(item, options);
+            models.push(model);
+        }
+        return models;
+    }
+    async bulkCreate(items, options) {
+        return this.bulkSave(items, options);
+    }
+    /**
+     * Saves all given entities in the database.
+     * If entities do not exist in the database then inserts, otherwise updates.
+     */
+    /**
+     * Merges multiple entities (or entity-like objects) into a given entity.
+     */
+    merge(mergeIntoEntity, ...entityLikes) {
+        return this.repo.merge(mergeIntoEntity, ...entityLikes);
+    }
+    /**
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
+     * it loads it (and everything related to it), replaces all values with the new ones from the given object
+     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
+     * replaced from the new object.
+     *
+     * Note that given entity-like object must have an entity id / primary key to find entity by.
+     * Returns undefined if entity with given id was not found.
+     */
+    preload(entityLike) {
+        return this.repo.preload(entityLike);
+    }
+    /**
+     * Removes a given entities from the database.
+     */
+    async remove(idOrEntity) {
+        if (_.isObject(idOrEntity)) {
+            idOrEntity = idOrEntity.id;
+        }
+        const deletedEntity = await this.repo.findOne({
+            where: { id: idOrEntity },
+        });
+        const idCopy = deletedEntity.id;
+        await this.repo.remove(deletedEntity);
+        deletedEntity.id = idCopy;
+        return deletedEntity;
+    }
+    /**
+     * alias to remove
+     */
+    async delete(idOrEntity) {
+        return this.remove(idOrEntity);
+    }
+    /**
+     * alias to removeById
+     */
+    async deleteById(id) {
+        return this.remove(id);
+    }
+    async bulkRemove(idsOrEntities) {
+        idsOrEntities = idsOrEntities.map(id => {
+            return _.isObject(id) ? id.id : id;
+        });
+        const models = [];
+        for (let index = 0; index < idsOrEntities.length; index++) {
+            const id = idsOrEntities[index];
+            const model = await this.remove(id);
+            models.push(model);
+        }
+        return models;
+    }
+    async bulkDelete(ids) {
+        return this.bulkRemove(ids);
+    }
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove(entity, options) {
+        return this.repo.softRemove(entity, options);
+    }
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover(entity, options) {
+        return this.repo.recover(entity, options);
+    }
+    /**
+     * Inserts a given entity into the database.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT query.
+     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
+     */
+    insert(entity) {
+        return this.repo.insert(entity);
+    }
+    async update(item) {
+        const { id } = item;
+        return await this.updateById(id, item);
+    }
+    async updateById(id, item) {
+        const allowedPropsToUpdate = [];
+        for (const key in item) {
+            if (_.isObject(item) &&
+                item.hasOwnProperty(key) &&
+                typeof item[key] !== 'object' &&
+                !_.isUndefined(this.repo.metadata.ownColumns.find(c => c.propertyName === key))) {
+                allowedPropsToUpdate.push(key);
+            }
+        }
+        for (let i = 0; i < allowedPropsToUpdate.length; i++) {
+            const key = allowedPropsToUpdate[i];
+            if (!INDEX_KEYS_NO_FOR_UPDATE.includes(key.toLowerCase())) {
+                const toSet = item[key];
+                await this.repo.update({
+                    id,
+                }, {
+                    [key]: toSet,
+                });
+            }
+        }
+        let model = await this.repo.findOne({
+            where: { id },
+        });
+        return model;
+    }
+    async bulkUpdate(items) {
+        const models = [];
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const { id } = item; // TOOD
+            const model = await this.updateById(id, item);
+            models.push(model);
+        }
+        return { models };
+    }
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities, conflictPathsOrOptions) {
+        return this.repo.upsert(entityOrEntities, conflictPathsOrOptions);
+    }
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria) {
+        return this.repo.softDelete(criteria);
+    }
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria) {
+        return this.repo.restore(criteria);
+    }
+    /**
+     * Counts entities that match given options.
+     * Useful for pagination.
+     */
+    count(options) {
+        return this.repo.count(options);
+    }
+    /**
+     * Counts entities that match given conditions.
+     * Useful for pagination.
+     */
+    countBy(where) {
+        return this.repo.countBy(where);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    find(options) {
+        return this.repo.find(options);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    findBy(where) {
+        return this.repo.findBy(where);
+    }
+    //
+    /**
+     * Finds entities that match given find options.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCount(options) {
+        return this.repo.findAndCount(options);
+    }
+    /**
+     * Finds entities that match given WHERE conditions.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCountBy(where) {
+        return this.repo.findAndCountBy(where);
+    }
+    /**
+     * Finds entities with ids.
+     * Optionally find options or conditions can be applied.
+     *
+     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findBy({
+     *     id: In([1, 2, 3])
+     * })
+     */
+    findByIds(ids) {
+        return this.repo.findByIds(ids);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
+     */
+    findOne(options) {
+        return this.repo.findOne(options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
+     */
+    findOneBy(where) {
+        return this.repo.findOneBy(where);
+    }
+    /**
+     * Finds first entity that matches given id.
+     * If entity was not found in the database - returns null.
+     *
+     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findOneBy({
+     *     id: 1 // where "id" is your primary column name
+     * })
+     */
+    findOneById(id) {
+        return this.repo.findOneById(id);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneOrFail(options) {
+        return this.repo.findOneOrFail(options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneByOrFail(where) {
+        return this.repo.findOneByOrFail(where);
+    }
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    query(query, parameters) {
+        return this.repo.query(query, parameters);
+    }
+    /**
+     * Clears all the data from the given table/collection (truncates/drops it).
+     *
+     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @see https://stackoverflow.com/a/5972738/925151
+     */
+    clear() {
+        return this.repo.clear();
+    }
+    /**
+     * Increments some column by provided value of the entities matched given conditions.
+     */
+    increment(conditions, propertyPath, value) {
+        return this.repo.increment(conditions, propertyPath, value);
+    }
+    /**
+     * Decrements some column by provided value of the entities matched given conditions.
+     */
+    decrement(conditions, propertyPath, value) {
+        return this.repo.decrement(conditions, propertyPath, value);
+    }
+    /**
+     * @deprecated use findAndCount instead
+     */
+    async getAll() {
+        const totalCount = await this.repo.count();
+        const models = await this.repo.find();
+        return { models, totalCount };
+    }
+    async getBy(id) {
+        const model = await await this.repo.findOne({
+            where: { id },
+        });
+        return model;
+    }
+};
+BaseRepository = __decorate([
+    TaonRepository({ className: 'BaseRepository' }),
+    __metadata("design:paramtypes", [Function])
+], BaseRepository);
+export { BaseRepository };
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-repository.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-repository.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/base-classes/base-repository.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport type {\n  DataSource,\n  DeepPartial,\n  DeleteResult,\n  FindManyOptions,\n  FindOneOptions,\n  FindOptionsWhere,\n  InsertResult,\n\n  RemoveOptions,\n  Repository,\n  SaveOptions,\n  UpdateResult,\n} from 'taon-typeorm';\n\nimport type { QueryDeepPartialEntity } from 'taon-typeorm/lib/typeorm/query-builder/QueryPartialEntity';\n\nimport type { UpsertOptions } from 'taon-typeorm/lib/typeorm/repository/UpsertOptions';\n\n\n\nimport type { DataSource as DataSourceType } from 'taon-typeorm/websql';\nimport { EndpointContext } from '../endpoint-context';\nimport { Helpers } from 'tnp-core/websql';\nimport { _ } from 'tnp-core/websql';\nimport { ClassHelpers } from '../helpers/class-helpers';\nimport { MySqlQuerySource } from 'taon-type-sql/websql';\nimport { TaonRepository } from '../decorators/classes/repository-decorator';\nimport { BaseInjector } from './base-injector';\n\n\nconst INDEX_KEYS_NO_FOR_UPDATE = ['id'];\n\n@TaonRepository({ className: 'BaseRepository' })\nexport abstract class BaseRepository<\n  Entity extends { id?: any },\n> extends BaseInjector {\n\n\n\n\n\n\n  abstract entityClassResolveFn: () => any;\n  constructor(\n\n    private __entityClassResolveFn: () => any,\n  ) {\n    super();\n    // @ts-ignore\n    this.entityClassResolveFn = __entityClassResolveFn;\n  }\n\n\n\n  private __dbQuery: MySqlQuerySource;\n\n  public get dbQuery(): MySqlQuerySource {\n\n    if (!this.__dbQuery) {\n      if (!this.__endpoint_context__) {\n        return; // TODO\n        throw new Error(\n          `[BaseRepository] Context not inited for class ${ClassHelpers.getName(\n            this,\n          )}`,\n        );\n      }\n      const connection = this.__endpoint_context__?.connection;\n      if (!connection) {\n        throw new Error(\n          `[BaseRepository] Database not inited for context ${this.__endpoint_context__?.contextName}`,\n        );\n      }\n      this.__dbQuery = new MySqlQuerySource(connection);\n    }\n    return this.__dbQuery;\n\n  }\n\n\n\n  public get connection(): DataSourceType {\n\n    return this.__endpoint_context__?.connection;\n\n  }\n\n\n\n\n  private __repository: Repository<Entity>;\n\n  protected get repository() {\n\n    return this.__repository;\n\n  }\n\n  /**\n   * target for repository\n   */\n  public get target(): Function {\n\n    return this?.repository?.target as any;\n\n  }\n\n  /**\n   * alias to repository\n   */\n  protected get repo() {\n\n    return this.repository;\n\n  }\n\n  public get repositoryExists(): boolean {\n\n    return !!this.__repository;\n\n  }\n\n\n\n\n\n  async __init(context?: any) {\n\n    if (this.__repository) {\n      return;\n    }\n    let entityClassFn: any = this.entityClassResolveFn();\n    if (!entityClassFn) {\n      Helpers.warn(\n        `Entity class not provided for repository ${ClassHelpers.getName(\n          this,\n        )}`,\n      );\n      return;\n    }\n    const ctx: EndpointContext = this.__endpoint_context__;\n    if (ctx.remoteHost) {\n      return;\n    }\n    const connection = ctx.connection;\n\n    if (!connection) {\n      throw new Error(`\n\n        Connection not found for context ${ctx.contextName}\n\n\n        Maybe you forgot to init database ?\n\n        Taon.createContext({\n        ...\n        database:true\n        ...\n        })\n\n        `);\n    }\n\n    if (!entityClassFn) {\n      Helpers.warn(\n        `Entity class not found for repository ${ClassHelpers.getName(this)}`,\n      );\n      return;\n    }\n\n    this.__repository = (await connection.getRepository(\n      ClassHelpers.getOrginalClass(entityClassFn),\n    )) as any;\n\n\n\n\n\n\n  }\n\n\n\n  /**\n   * Checks if entity has an id.\n   * If entity composite compose ids, it will check them all.\n   */\n  hasId(entity: Entity): boolean {\n    return this.repo.hasId(entity);\n  }\n\n\n\n  /**\n   * Gets entity mixed id.\n   */\n  getId(entity: Entity): any {\n    return this.repo.getId(entity);\n  }\n\n\n\n  /**\n    Saves a given entity in the database.\n   * If entity does not exist in the database then inserts, otherwise updates.\n   */\n  async save(\n    item: Entity,\n    options?: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<Entity> {\n\n    let model = await this.repo.create(item);\n\n    model = await this.repo.save(model, options);\n    const { id } = model as any;\n\n    model = await this.repo.findOne({\n      where: { id } as any,\n    });\n\n    return model;\n\n  }\n\n  /**\n   * alias to save\n   * -> it will actuall create new entity in db\n   * in oposite to typeorm create method\n   */\n  async create(\n    item: Entity,\n    options?: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<Entity> {\n    return this.save(item, options);\n  }\n\n  async bulkSave(\n    items: Entity[],\n    options?: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<Entity[]> {\n\n    const models = [];\n    for (let index = 0; index < items.length; index++) {\n      const item = items[index];\n\n      const model = await this.save(item, options);\n      models.push(model);\n    }\n    return models;\n\n  }\n\n  async bulkCreate(\n    items: Entity[],\n    options?: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<Entity[]> {\n    return this.bulkSave(items, options);\n  }\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n  /**\n   * Saves all given entities in the database.\n   * If entities do not exist in the database then inserts, otherwise updates.\n   */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n  /**\n   * Merges multiple entities (or entity-like objects) into a given entity.\n   */\n  merge(mergeIntoEntity: Entity, ...entityLikes: Entity[]): Entity {\n    return this.repo.merge(mergeIntoEntity, ...entityLikes);\n  }\n\n\n\n  /**\n   * Creates a new entity from the given plain javascript object. If entity already exist in the database, then\n   * it loads it (and everything related to it), replaces all values with the new ones from the given object\n   * and returns this new entity. This new entity is actually a loaded from the db entity with all properties\n   * replaced from the new object.\n   *\n   * Note that given entity-like object must have an entity id / primary key to find entity by.\n   * Returns undefined if entity with given id was not found.\n   */\n  preload(entityLike: Entity): Promise<Entity | undefined> {\n    return this.repo.preload(entityLike);\n  }\n\n\n\n\n  /**\n   * Removes a given entities from the database.\n   */\n  async remove(idOrEntity: number | string | Entity): Promise<Entity> {\n\n    if (_.isObject(idOrEntity)) {\n      idOrEntity = (idOrEntity as Entity).id;\n    }\n    const deletedEntity = await this.repo.findOne({\n      where: { id: idOrEntity } as any,\n    });\n\n    const idCopy = deletedEntity.id;\n    await this.repo.remove(deletedEntity);\n\n    deletedEntity.id = idCopy;\n    return deletedEntity;\n\n  }\n\n  /**\n   * alias to remove\n   */\n  async delete(idOrEntity: number | string | Entity): Promise<Entity> {\n    return this.remove(idOrEntity);\n  }\n\n  /**\n   * alias to removeById\n   */\n  async deleteById(id: number | string): Promise<Entity> {\n    return this.remove(id);\n  }\n  async bulkRemove(\n    idsOrEntities: (number | string | Entity)[],\n  ): Promise<Entity[]> {\n\n    idsOrEntities = idsOrEntities.map(id => {\n      return _.isObject(id) ? (id as Entity).id : id;\n    });\n\n    const models = [];\n    for (let index = 0; index < idsOrEntities.length; index++) {\n      const id = idsOrEntities[index];\n      const model = await this.remove(id);\n      models.push(model);\n    }\n    return models;\n\n  }\n\n  async bulkDelete(ids: (number | string | Entity)[]): Promise<Entity[]> {\n    return this.bulkRemove(ids);\n  }\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n  /**\n   * Records the delete date of all given entities.\n   */\n  softRemove<T extends Entity>(\n    entities: T[],\n    options: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<T[]>;\n  /**\n   * Records the delete date of all given entities.\n   */\n  softRemove<T extends Entity>(\n    entities: T[],\n    options?: SaveOptions,\n  ): Promise<(T & Entity)[]>;\n  /**\n   * Records the delete date of a given entity.\n   */\n  softRemove<T extends Entity>(\n    entity: T,\n    options: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<T>;\n  /**\n   * Records the delete date of a given entity.\n   */\n  softRemove<T extends Entity>(\n    entity: T,\n    options?: SaveOptions,\n  ): Promise<T & Entity> {\n    return this.repo.softRemove(entity, options);\n  }\n\n\n\n  /**\n   * Recovers all given entities in the database.\n   */\n  recover<T extends Entity>(\n    entities: T[],\n    options: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<T[]>;\n  /**\n   * Recovers all given entities in the database.\n   */\n  recover<T extends Entity>(\n    entities: T[],\n    options?: SaveOptions,\n  ): Promise<(T & Entity)[]>;\n  /**\n   * Recovers a given entity in the database.\n   */\n  recover<T extends Entity>(\n    entity: T,\n    options: SaveOptions & {\n      reload: false;\n    },\n  ): Promise<T>;\n  /**\n   * Recovers a given entity in the database.\n   */\n  recover<T extends Entity>(\n    entity: T,\n    options?: SaveOptions,\n  ): Promise<T & Entity> {\n    return this.repo.recover(entity, options);\n  }\n\n\n\n  /**\n   * Inserts a given entity into the database.\n   * Unlike save method executes a primitive operation without cascades, relations and other operations included.\n   * Executes fast and efficient INSERT query.\n   * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.\n   */\n  insert(\n    entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[],\n  ): Promise<InsertResult> {\n    return this.repo.insert(entity);\n  }\n\n\n\n  async update(item: Entity) {\n\n    const { id } = item as any;\n    return await this.updateById(id, item);\n\n  }\n\n  async updateById(id: number | string, item: Entity) {\n\n    const allowedPropsToUpdate = [];\n    for (const key in item) {\n      if (\n        _.isObject(item) &&\n        item.hasOwnProperty(key) &&\n        typeof item[key] !== 'object' &&\n        !_.isUndefined(\n          this.repo.metadata.ownColumns.find(c => c.propertyName === key),\n        )\n      ) {\n        allowedPropsToUpdate.push(key);\n      }\n    }\n\n    for (let i = 0; i < allowedPropsToUpdate.length; i++) {\n      const key: string = allowedPropsToUpdate[i];\n      if (!INDEX_KEYS_NO_FOR_UPDATE.includes(key.toLowerCase())) {\n\n        const toSet = item[key];\n\n\n        await this.repo.update(\n          {\n            id,\n          } as any,\n          {\n            [key]: toSet,\n          } as any,\n        );\n\n\n\n\n\n      }\n    }\n    let model = await this.repo.findOne({\n      where: { id } as any,\n    });\n\n    return model;\n\n  }\n  async bulkUpdate(items: Entity[]) {\n\n    const models = [];\n    for (let index = 0; index < items.length; index++) {\n      const item = items[index];\n      const { id } = item as any; // TOOD\n      const model = await this.updateById(id, item);\n      models.push(model);\n    }\n    return { models };\n\n  }\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n  /**\n   * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity\n   * Unlike save method executes a primitive operation without cascades, relations and other operations included.\n   * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.\n   */\n  upsert(\n    entityOrEntities:\n      | QueryDeepPartialEntity<Entity>\n      | QueryDeepPartialEntity<Entity>[],\n    conflictPathsOrOptions: string[] | UpsertOptions<Entity>,\n  ): Promise<InsertResult> {\n    return this.repo.upsert(entityOrEntities, conflictPathsOrOptions);\n  }\n\n\n\n  /**\n   * Records the delete date of entities by a given criteria.\n   * Unlike save method executes a primitive operation without cascades, relations and other operations included.\n   * Executes fast and efficient SOFT-DELETE query.\n   * Does not check if entity exist in the database.\n   */\n  softDelete(\n    criteria:\n      | string\n      | string[]\n      | number\n      | number[]\n      | Date\n      | Date[]\n\n\n      | FindOptionsWhere<Entity>,\n  ): Promise<UpdateResult> {\n    return this.repo.softDelete(criteria);\n  }\n\n\n\n  /**\n   * Restores entities by a given criteria.\n   * Unlike save method executes a primitive operation without cascades, relations and other operations included.\n   * Executes fast and efficient SOFT-DELETE query.\n   * Does not check if entity exist in the database.\n   */\n  restore(\n    criteria:\n      | string\n      | string[]\n      | number\n      | number[]\n      | Date\n      | Date[]\n\n\n      | FindOptionsWhere<Entity>,\n  ): Promise<UpdateResult> {\n    return this.repo.restore(criteria);\n  }\n\n\n\n  /**\n   * Counts entities that match given options.\n   * Useful for pagination.\n   */\n  count(options?: FindManyOptions<Entity>): Promise<number> {\n    return this.repo.count(options);\n  }\n\n\n\n  /**\n   * Counts entities that match given conditions.\n   * Useful for pagination.\n   */\n  countBy(\n    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],\n  ): Promise<number> {\n    return this.repo.countBy(where);\n  }\n\n\n\n  /**\n   * Finds entities that match given find options.\n   */\n  find(options?: FindManyOptions<Entity>): Promise<Entity[]> {\n    return this.repo.find(options);\n  }\n\n\n\n  /**\n   * Finds entities that match given find options.\n   */\n  findBy(\n    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],\n  ): Promise<Entity[]> {\n    return this.repo.findBy(where);\n  }\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n  //\n  /**\n   * Finds entities that match given find options.\n   * Also counts all entities that match given conditions,\n   * but ignores pagination settings (from and take options).\n   */\n  findAndCount(options?: FindManyOptions<Entity>): Promise<[Entity[], number]> {\n    return this.repo.findAndCount(options);\n  }\n\n\n\n  /**\n   * Finds entities that match given WHERE conditions.\n   * Also counts all entities that match given conditions,\n   * but ignores pagination settings (from and take options).\n   */\n  findAndCountBy(\n    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],\n  ): Promise<[Entity[], number]> {\n    return this.repo.findAndCountBy(where);\n  }\n\n\n\n  /**\n   * Finds entities with ids.\n   * Optionally find options or conditions can be applied.\n   *\n   * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:\n   *\n   * .findBy({\n   *     id: In([1, 2, 3])\n   * })\n   */\n  findByIds(ids: any[]): Promise<Entity[]> {\n    return this.repo.findByIds(ids);\n  }\n\n\n\n  /**\n   * Finds first entity by a given find options.\n   * If entity was not found in the database - returns null.\n   */\n  findOne(options: FindOneOptions<Entity>): Promise<Entity | null> {\n    return this.repo.findOne(options);\n  }\n\n\n\n  /**\n   * Finds first entity that matches given where condition.\n   * If entity was not found in the database - returns null.\n   */\n  findOneBy(\n    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],\n  ): Promise<Entity | null> {\n    return this.repo.findOneBy(where);\n  }\n\n\n\n  /**\n   * Finds first entity that matches given id.\n   * If entity was not found in the database - returns null.\n   *\n   * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:\n   *\n   * .findOneBy({\n   *     id: 1 // where \"id\" is your primary column name\n   * })\n   */\n  findOneById(\n    id: number | string | Date,\n\n  ): Promise<Entity | null> {\n    return this.repo.findOneById(id);\n  }\n\n\n\n  /**\n   * Finds first entity by a given find options.\n   * If entity was not found in the database - rejects with error.\n   */\n  findOneOrFail(options: FindOneOptions<Entity>): Promise<Entity> {\n    return this.repo.findOneOrFail(options);\n  }\n\n\n\n  /**\n   * Finds first entity that matches given where condition.\n   * If entity was not found in the database - rejects with error.\n   */\n  findOneByOrFail(\n    where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],\n  ): Promise<Entity> {\n    return this.repo.findOneByOrFail(where);\n  }\n\n\n\n  /**\n   * Executes a raw SQL query and returns a raw database results.\n   * Raw query execution is supported only by relational databases (MongoDB is not supported).\n   */\n  query(query: string, parameters?: any[]): Promise<any> {\n    return this.repo.query(query, parameters);\n  }\n\n\n\n  /**\n   * Clears all the data from the given table/collection (truncates/drops it).\n   *\n   * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.\n   * @see https://stackoverflow.com/a/5972738/925151\n   */\n  clear(): Promise<void> {\n    return this.repo.clear();\n  }\n\n\n\n  /**\n   * Increments some column by provided value of the entities matched given conditions.\n   */\n  increment(\n    conditions: FindOptionsWhere<Entity>,\n    propertyPath: string,\n    value: number | string,\n  ): Promise<UpdateResult> {\n    return this.repo.increment(conditions, propertyPath, value);\n  }\n\n\n\n  /**\n   * Decrements some column by provided value of the entities matched given conditions.\n   */\n  decrement(\n    conditions: FindOptionsWhere<Entity>,\n    propertyPath: string,\n    value: number | string,\n  ): Promise<UpdateResult> {\n    return this.repo.decrement(conditions, propertyPath, value);\n  }\n\n\n\n  /**\n   * @deprecated use findAndCount instead\n   */\n  async getAll() {\n\n\n\n\n\n\n    const totalCount = await this.repo.count();\n    const models = await this.repo.find();\n\n\n    return { models, totalCount };\n\n  }\n\n\n\n  async getBy(id: number | string): Promise<Entity> {\n\n    const model = await await this.repo.findOne({\n      where: { id } as any,\n    });\n\n    return model;\n\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/base-classes/base-repository.ts"]}

package/websql/esm2022/lib/base-classes/base-subscriber-for-entity.mjs

@@ -0,0 +1,137 @@
+import { __decorate } from "tslib";
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+import { BaseInjector } from './base-injector';
+import { TaonSubscriber } from '../decorators/classes/subscriber-decorator';
+let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity) {
+        console.log(`AFTER ENTITY LOADED: `, entity);
+    }
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event) {
+        console.log(`BEFORE QUERY: `, event.query);
+    }
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event) {
+        console.log(`AFTER QUERY: `, event.query);
+    }
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event) {
+        console.log(`BEFORE ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event) {
+        console.log(`AFTER ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event) {
+        console.log(`BEFORE ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event) {
+        console.log(`AFTER ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event) {
+        console.log(`BEFORE TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event) {
+        console.log(`AFTER TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event) {
+        console.log(`BEFORE TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event) {
+        console.log(`AFTER TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event) {
+        console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
+    }
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event) {
+        console.log(`AFTER TRANSACTION ROLLBACK: `, event);
+    }
+};
+BaseSubscriberForEntity = __decorate([
+    TaonSubscriber({
+        className: 'BaseSubscriberForEntity',
+    })
+], BaseSubscriberForEntity);
+export { BaseSubscriberForEntity };
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber-for-entity.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-subscriber-for-entity.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/base-classes/base-subscriber-for-entity.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nimport {   EntitySubscriberInterface,   RecoverEvent,   SoftRemoveEvent,   InsertEvent,   TransactionStartEvent,   TransactionCommitEvent,   TransactionRollbackEvent,   RemoveEvent,   UpdateEvent, } from 'taon-typeorm/websql';/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n\nimport { BaseInjector } from './base-injector';\nimport { TaonSubscriber } from '../decorators/classes/subscriber-decorator';\n\n@TaonSubscriber({\n  className: 'BaseSubscriberForEntity',\n})\nexport abstract class BaseSubscriberForEntity<Entity = any>\n  extends BaseInjector\n  implements EntitySubscriberInterface\n{\n  abstract listenTo(): new (...args) => Entity;\n\n  /**\n   * Called after entity is loaded.\n   */\n  afterLoad(entity: any) {\n    console.log(`AFTER ENTITY LOADED: `, entity);\n  }\n\n  /**\n   * Called before query execution.\n   */\n  beforeQuery(event: any) {\n\n    console.log(`BEFORE QUERY: `, event.query);\n  }\n\n  /**\n   * Called after query execution.\n   */\n  afterQuery(event: any) {\n\n    console.log(`AFTER QUERY: `, event.query);\n  }\n\n  /**\n   * Called before entity insertion.\n   */\n  beforeInsert(event: InsertEvent<any>) {\n    console.log(`BEFORE ENTITY INSERTED: `, event.entity);\n  }\n\n  /**\n   * Called after entity insertion.\n   */\n  afterInsert(event: InsertEvent<any>) {\n    console.log(`AFTER ENTITY INSERTED: `, event.entity);\n  }\n\n  /**\n   * Called before entity update.\n   */\n  beforeUpdate(event: UpdateEvent<any>) {\n    console.log(`BEFORE ENTITY UPDATED: `, event.entity);\n  }\n\n  /**\n   * Called after entity update.\n   */\n  afterUpdate(event: UpdateEvent<any>) {\n    console.log(`AFTER ENTITY UPDATED: `, event.entity);\n  }\n\n  /**\n   * Called before entity removal.\n   */\n  beforeRemove(event: RemoveEvent<any>) {\n    console.log(\n      `BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called after entity removal.\n   */\n  afterRemove(event: RemoveEvent<any>) {\n    console.log(\n      `AFTER ENTITY WITH ID ${event.entityId} REMOVED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called before entity removal.\n   */\n  beforeSoftRemove(event: SoftRemoveEvent<any>) {\n    console.log(\n      `BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called after entity removal.\n   */\n  afterSoftRemove(event: SoftRemoveEvent<any>) {\n    console.log(\n      `AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called before entity recovery.\n   */\n  beforeRecover(event: RecoverEvent<any>) {\n    console.log(\n      `BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called after entity recovery.\n   */\n  afterRecover(event: RecoverEvent<any>) {\n    console.log(\n      `AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `,\n      event.entity,\n    );\n  }\n\n  /**\n   * Called before transaction start.\n   */\n  beforeTransactionStart(event: TransactionStartEvent) {\n    console.log(`BEFORE TRANSACTION STARTED: `, event);\n  }\n\n  /**\n   * Called after transaction start.\n   */\n  afterTransactionStart(event: TransactionStartEvent) {\n    console.log(`AFTER TRANSACTION STARTED: `, event);\n  }\n\n  /**\n   * Called before transaction commit.\n   */\n  beforeTransactionCommit(event: TransactionCommitEvent) {\n    console.log(`BEFORE TRANSACTION COMMITTED: `, event);\n  }\n\n  /**\n   * Called after transaction commit.\n   */\n  afterTransactionCommit(event: TransactionCommitEvent) {\n    console.log(`AFTER TRANSACTION COMMITTED: `, event);\n  }\n\n  /**\n   * Called before transaction rollback.\n   */\n  beforeTransactionRollback(event: TransactionRollbackEvent) {\n    console.log(`BEFORE TRANSACTION ROLLBACK: `, event);\n  }\n\n  /**\n   * Called after transaction rollback.\n   */\n  afterTransactionRollback(event: TransactionRollbackEvent) {\n    console.log(`AFTER TRANSACTION ROLLBACK: `, event);\n  }\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber-for-entity.ts"]}