@sqb/connect 4.7.0 → 4.8.2

package/cjs/orm/commands/{destroy.command.js → delete.command.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DestroyCommand = void 0;
+exports.DeleteCommand = void 0;
 const builder_1 = require("@sqb/builder");
 const command_helper_js_1 = require("./command.helper.js");
-class DestroyCommand {
+class DeleteCommand {
     // istanbul ignore next
     constructor() {
         throw new Error('This class is abstract');
@@ -27,4 +27,4 @@ class DestroyCommand {
         return (resp && resp.rowsAffected) || 0;
     }
 }
-exports.DestroyCommand = DestroyCommand;
+exports.DeleteCommand = DeleteCommand;

package/cjs/orm/repository.class.js

@@ -5,7 +5,7 @@ const strict_typed_events_1 = require("strict-typed-events");
 const sqb_connection_js_1 = require("../client/sqb-connection.js");
 const count_command_js_1 = require("./commands/count.command.js");
 const create_command_js_1 = require("./commands/create.command.js");
-const destroy_command_js_1 = require("./commands/destroy.command.js");
+const delete_command_js_1 = require("./commands/delete.command.js");
 const find_command_js_1 = require("./commands/find.command.js");
 const update_command_js_1 = require("./commands/update.command.js");
 const extract_keyvalues_js_1 = require("./util/extract-keyvalues.js");
@@ -27,12 +27,17 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
     }
     create(values, options) {
         return this._execute(async (connection) => {
-            return this._create(values, { ...options, connection });
+            const keyValue = await this._create(values, { ...options, connection, returning: true });
+            const result = keyValue &&
+                await this._find(keyValue, { ...options, connection });
+            if (!result)
+                throw new Error('Unable to insert new row');
+            return result;
         }, options);
     }
     createOnly(values, options) {
         return this._execute(async (connection) => {
-            return this._createOnly(values, { ...options, connection });
+            await this._create(values, { ...options, connection, returning: false });
         }, options);
     }
     exists(keyValue, options) {
@@ -45,47 +50,50 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
             return this._count({ ...options, connection });
         }, options);
     }
-    findByPk(keyValue, options) {
+    find(keyValue, options) {
         return this._execute(async (connection) => {
-            return this._findByPk(keyValue, { ...options, connection });
+            return this._find(keyValue, { ...options, connection });
         }, options);
     }
     findOne(options) {
         return this._execute(async (connection) => {
-            return this._findOne({ ...options, connection });
+            return await this._findOne({
+                ...options,
+                connection,
+            });
         }, options);
     }
     findMany(options) {
         return this._execute(async (connection) => {
-            return this._findAll({ ...options, connection });
+            return this._findMany({ ...options, connection });
         }, options);
     }
-    deleteByPk(keyValue, options) {
+    delete(keyValue, options) {
         return this._execute(async (connection) => {
-            return this._destroy(keyValue, { ...options, connection });
+            return this._delete(keyValue, { ...options, connection });
         }, options);
     }
     deleteMany(options) {
         return this._execute(async (connection) => {
-            return this._destroyAll({ ...options, connection });
+            return this._deleteMany({ ...options, connection });
         }, options);
     }
-    updateByPk(keyValue, values, options) {
+    update(keyValue, values, options) {
         return this._execute(async (connection) => {
             const opts = { ...options, connection };
-            const keyValues = await this._updateByPk(keyValue, values, opts);
+            const keyValues = await this._update(keyValue, values, opts);
             if (keyValues)
-                return this._findByPk(keyValues, opts);
+                return this._find(keyValues, opts);
         }, options);
     }
-    updateByPkOnly(keyValue, values, options) {
+    updateOnly(keyValue, values, options) {
         return this._execute(async (connection) => {
-            return !!(await this._updateByPk(keyValue, values, { ...options, connection }));
+            return !!(await this._update(keyValue, values, { ...options, connection }));
         }, options);
     }
     updateMany(values, options) {
         return this._execute(async (connection) => {
-            return this._updateAll(values, { ...options, connection });
+            return this._updateMany(values, { ...options, connection });
         });
     }
     /**
@@ -109,20 +117,6 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
     findAll(options) {
         return this.findMany(options);
     }
-    /**
-     *
-     * @deprecated
-     */
-    update(keyValue, values, options) {
-        return this.updateByPk(keyValue, values, options);
-    }
-    /**
-     *
-     * @deprecated
-     */
-    updateOnly(keyValue, values, options) {
-        return this.updateByPkOnly(keyValue, values, options);
-    }
     /**
      *
      * @deprecated
@@ -149,29 +143,14 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
     async _create(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-create', values, options);
         const keyValues = await create_command_js_1.CreateCommand.execute({
             ...options,
             entity: this._entity,
-            values,
-            returning: true
+            values
         });
-        const result = keyValues && (await this.findByPk(keyValues, options));
-        if (!result)
+        if (options.returning && !keyValues)
             throw new Error('Unable to insert new row');
-        await this._emit('after-create', result, options);
-        return result;
-    }
-    async _createOnly(values, options) {
-        if (!values)
-            throw new TypeError('You must provide values');
-        await this._emit('before-create', values, options);
-        await create_command_js_1.CreateCommand.execute({
-            ...options,
-            entity: this._entity,
-            values,
-            returning: false
-        });
+        return keyValues;
     }
     async _exists(keyValue, options) {
         const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
@@ -193,21 +172,20 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
             entity: this._entity
         });
     }
-    async _findAll(options) {
+    async _findMany(options) {
         return await find_command_js_1.FindCommand.execute({
             ...options,
             entity: this._entity,
         });
     }
     async _findOne(options) {
-        const rows = await find_command_js_1.FindCommand.execute({
+        const rows = await this._findMany({
             ...options,
-            entity: this._entity,
             limit: 1
         });
         return rows && rows[0];
     }
-    async _findByPk(keyValue, options) {
+    async _find(keyValue, options) {
         const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
@@ -217,8 +195,7 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
         }
         return await this._findOne({ ...options, filter, offset: 0 });
     }
-    async _destroy(keyValue, options) {
-        await this._emit('before-destroy', keyValue, options);
+    async _delete(keyValue, options) {
         const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
@@ -226,29 +203,23 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
             else
                 filter.push(options.filter);
         }
-        const result = !!(await destroy_command_js_1.DestroyCommand.execute({
+        return !!(await delete_command_js_1.DeleteCommand.execute({
             ...options,
             filter,
             entity: this._entity,
         }));
-        await this._emit('after-destroy', result, keyValue, options);
-        return result;
     }
-    async _destroyAll(options) {
-        await this._emit('before-destroy-all', options);
-        const rowsAffected = destroy_command_js_1.DestroyCommand.execute({
+    async _deleteMany(options) {
+        return delete_command_js_1.DeleteCommand.execute({
             ...options,
             entity: this._entity,
             filter: options?.filter,
             params: options?.params
         });
-        await this._emit('after-destroy-all', rowsAffected, options);
-        return rowsAffected;
     }
-    async _updateByPk(keyValue, values, options) {
+    async _update(keyValue, values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-update', keyValue, values, options);
         const keyValues = (0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true);
         const filter = [keyValues];
         if (options.filter) {
@@ -265,28 +236,16 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
             values: updateValues,
             filter
         });
-        await this._emit('after-update', rowsAffected, keyValues, options);
         return rowsAffected ? keyValues : undefined;
     }
-    async _updateAll(values, options) {
+    async _updateMany(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-update-all', values, options);
-        const rowsAffected = await update_command_js_1.UpdateCommand.execute({
+        return await update_command_js_1.UpdateCommand.execute({
             ...options,
             entity: this._entity,
             values
         });
-        await this._emit('after-update-all', rowsAffected, values, options);
-        return rowsAffected;
-    }
-    async _emit(event, ...args) {
-        const events = this._entity.eventListeners && this._entity.eventListeners[event];
-        if (events) {
-            for (const fn of events) {
-                await fn(this, ...args);
-            }
-        }
     }
 }
 exports.Repository = Repository;

package/esm/orm/commands/{destroy.command.d.ts → delete.command.d.ts}

@@ -4,8 +4,8 @@ import { Repository } from '../repository.class.js';
 export type DestroyCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;
-} & Repository.DestroyOptions;
-export declare class DestroyCommand {
+} & Repository.DeleteManyOptions;
+export declare class DeleteCommand {
     protected constructor();
     static execute(args: DestroyCommandArgs): Promise<number>;
 }

package/esm/orm/commands/{destroy.command.js → delete.command.js}

@@ -1,6 +1,6 @@
 import { And, Delete } from '@sqb/builder';
 import { prepareFilter } from './command.helper.js';
-export class DestroyCommand {
+export class DeleteCommand {
     // istanbul ignore next
     constructor() {
         throw new Error('This class is abstract');

package/esm/orm/commands/find.command.d.ts

@@ -6,7 +6,7 @@ import { RowConverter } from './row-converter.js';
 export type FindCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;
-} & Repository.FindAllOptions;
+} & Repository.FindManyOptions;
 export declare class FindCommand {
     maxEagerFetch: number;
     maxSubQueries: number;

package/esm/orm/commands/update.command.d.ts

@@ -5,7 +5,7 @@ export type UpdateCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;
     values: any;
-} & Repository.UpdateAllOptions;
+} & Repository.UpdateManyOptions;
 type UpdateCommandContext = {
     entity: EntityMetadata;
     queryParams: any;

package/esm/orm/repository.class.d.ts

@@ -1,66 +1,63 @@
-import { Type } from 'ts-gems';
+import { StrictOmit, Type } from 'ts-gems';
 import { FieldInfoMap } from '../client/field-info-map.js';
 import { SqbClient } from '../client/sqb-client.js';
 import { SqbConnection } from '../client/sqb-connection.js';
 import { QueryRequest, TransactionFunction } from '../client/types.js';
 import { EntityInput, EntityOutput } from '../types.js';
 import { EntityMetadata } from './model/entity-metadata.js';
+interface Projection {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+interface Filtering {
+    filter?: any;
+    params?: any;
+}
 export declare namespace Repository {
     type TransformRowFunction = (fields: FieldInfoMap, row: object, obj: object) => void;
     interface CommandOptions {
         connection?: SqbConnection;
     }
-    interface CreateOptions extends CommandOptions {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
+    interface CreateOptions extends CommandOptions, Projection {
+    }
+    interface CountOptions extends CommandOptions, Filtering {
+    }
+    interface ExistsOptions extends CommandOptions, Filtering {
     }
-    interface CountOptions extends CommandOptions {
-        filter?: any;
-        params?: any;
+    interface DeleteOptions extends CommandOptions, Filtering {
     }
-    interface ExistsOptions extends CommandOptions {
-        filter?: any;
-        params?: any;
+    interface DeleteManyOptions extends CommandOptions, Filtering {
     }
-    interface DestroyOptions extends CommandOptions {
-        filter?: any;
-        params?: any;
+    interface FindOptions extends CommandOptions, Projection, Filtering {
     }
-    interface FindOneOptions extends CommandOptions {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        filter?: any;
-        params?: any;
+    interface FindOneOptions extends CommandOptions, Projection, Filtering {
         sort?: string[];
         offset?: number;
-        distinct?: boolean;
-        onTransformRow?: TransformRowFunction;
     }
-    interface FindAllOptions extends FindOneOptions {
+    interface FindManyOptions extends FindOneOptions {
         limit?: number;
+        distinct?: boolean;
         maxEagerFetch?: number;
         maxSubQueries?: number;
+        onTransformRow?: TransformRowFunction;
     }
-    interface GetOptions extends CommandOptions {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        filter?: any;
-        params?: any;
-    }
-    interface UpdateOptions extends CommandOptions {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        filter?: any;
-        params?: any;
+    interface UpdateOptions extends CommandOptions, Projection, Filtering {
     }
-    interface UpdateAllOptions extends CommandOptions {
-        filter?: any;
-        params?: any;
+    interface UpdateManyOptions extends CommandOptions, Filtering {
     }
+    /**
+     * @deprecated
+     */
+    type FindAllOptions = FindManyOptions;
+    /**
+     * @deprecated
+     */
+    type DestroyOptions = DeleteOptions;
+    /**
+     * @deprecated
+     */
+    type UpdateAllOptions = UpdateManyOptions;
 }
 interface RepositoryEvents {
     execute: (request: QueryRequest) => void;
@@ -76,81 +73,68 @@ export declare class Repository<T> extends Repository_base {
     get entity(): EntityMetadata;
     get type(): Type<T>;
     create(values: EntityInput<T>, options?: Repository.CreateOptions): Promise<EntityOutput<T>>;
-    createOnly(values: EntityInput<T>, options?: Repository.CreateOptions): Promise<void>;
+    createOnly(values: EntityInput<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
     exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
     count(options?: Repository.CountOptions): Promise<number>;
-    findByPk(keyValue: any | Record<string, any>, options?: Repository.GetOptions): Promise<EntityOutput<T> | undefined>;
+    find(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<EntityOutput<T> | undefined>;
     findOne(options?: Repository.FindOneOptions): Promise<EntityOutput<T> | undefined>;
-    findMany(options?: Repository.FindAllOptions): Promise<EntityOutput<T>[]>;
-    deleteByPk(keyValue: any | Record<string, any>, options?: Repository.DestroyOptions): Promise<boolean>;
-    deleteMany(options?: Repository.DestroyOptions): Promise<number>;
-    updateByPk(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<EntityOutput<T> | undefined>;
-    updateByPkOnly(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<boolean>;
-    updateMany(values: EntityInput<T>, options?: Repository.UpdateAllOptions): Promise<number>;
-    /**
-     *
-     * @deprecated
-     */
-    destroy(keyValue: any | Record<string, any>, options?: Repository.DestroyOptions): Promise<boolean>;
-    /**
-     *
-     * @deprecated
-     */
-    destroyAll(options?: Repository.DestroyOptions): Promise<number>;
+    findMany(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
+    delete(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
+    deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
+    update(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<EntityOutput<T> | undefined>;
+    updateOnly(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: StrictOmit<Repository.UpdateOptions, keyof Projection>): Promise<boolean>;
+    updateMany(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
     /**
      *
      * @deprecated
      */
-    findAll(options?: Repository.FindAllOptions): Promise<EntityOutput<T>[]>;
+    destroy(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
     /**
      *
      * @deprecated
      */
-    update(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<EntityOutput<T> | undefined>;
+    destroyAll(options?: Repository.DeleteManyOptions): Promise<number>;
     /**
      *
      * @deprecated
      */
-    updateOnly(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<boolean>;
+    findAll(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
     /**
      *
      * @deprecated
      */
-    updateAll(values: EntityInput<T>, options?: Repository.UpdateAllOptions): Promise<number>;
+    updateAll(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
     protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
     protected _create(values: EntityInput<T>, options: Repository.CreateOptions & {
         connection: SqbConnection;
-    }): Promise<EntityOutput<T>>;
-    protected _createOnly(values: EntityInput<T>, options: Repository.CreateOptions & {
-        connection: SqbConnection;
-    }): Promise<void>;
+        returning?: boolean;
+    }): Promise<any>;
     protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
         connection: SqbConnection;
     }): Promise<boolean>;
     protected _count(options: Repository.CountOptions & {
         connection: SqbConnection;
     }): Promise<number>;
-    protected _findAll(options: Repository.FindAllOptions & {
+    protected _findMany(options: Repository.FindManyOptions & {
         connection: SqbConnection;
     }): Promise<EntityOutput<T>[]>;
     protected _findOne(options: Repository.FindOneOptions & {
         connection: SqbConnection;
     }): Promise<EntityOutput<T> | undefined>;
-    protected _findByPk(keyValue: any | Record<string, any>, options: Repository.GetOptions & {
+    protected _find(keyValue: any | Record<string, any>, options: Repository.FindOptions & {
         connection: SqbConnection;
     }): Promise<EntityOutput<T> | undefined>;
-    protected _destroy(keyValue: any | Record<string, any>, options: Repository.DestroyOptions & {
+    protected _delete(keyValue: any | Record<string, any>, options: Repository.DeleteOptions & {
         connection: SqbConnection;
     }): Promise<boolean>;
-    protected _destroyAll(options: Repository.DestroyOptions & {
+    protected _deleteMany(options: Repository.DeleteManyOptions & {
         connection: SqbConnection;
     }): Promise<number>;
-    protected _updateByPk(keyValue: any | Record<string, any>, values: EntityInput<T>, options: Repository.UpdateOptions & {
+    protected _update(keyValue: any | Record<string, any>, values: EntityInput<T>, options: Repository.UpdateOptions & {
         connection: SqbConnection;
     }): Promise<Record<string, any> | undefined>;
-    protected _updateAll(values: EntityInput<T>, options: Repository.UpdateAllOptions & {
+    protected _updateMany(values: EntityInput<T>, options: Repository.UpdateManyOptions & {
         connection: SqbConnection;
     }): Promise<number>;
-    protected _emit(event: string, ...args: any[]): Promise<void>;
 }
 export {};

package/esm/orm/repository.class.js

@@ -2,7 +2,7 @@ import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
 import { SqbConnection } from '../client/sqb-connection.js';
 import { CountCommand } from './commands/count.command.js';
 import { CreateCommand } from './commands/create.command.js';
-import { DestroyCommand } from './commands/destroy.command.js';
+import { DeleteCommand } from './commands/delete.command.js';
 import { FindCommand } from './commands/find.command.js';
 import { UpdateCommand } from './commands/update.command.js';
 import { extractKeyValues } from './util/extract-keyvalues.js';
@@ -24,12 +24,17 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     }
     create(values, options) {
         return this._execute(async (connection) => {
-            return this._create(values, { ...options, connection });
+            const keyValue = await this._create(values, { ...options, connection, returning: true });
+            const result = keyValue &&
+                await this._find(keyValue, { ...options, connection });
+            if (!result)
+                throw new Error('Unable to insert new row');
+            return result;
         }, options);
     }
     createOnly(values, options) {
         return this._execute(async (connection) => {
-            return this._createOnly(values, { ...options, connection });
+            await this._create(values, { ...options, connection, returning: false });
         }, options);
     }
     exists(keyValue, options) {
@@ -42,47 +47,50 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             return this._count({ ...options, connection });
         }, options);
     }
-    findByPk(keyValue, options) {
+    find(keyValue, options) {
         return this._execute(async (connection) => {
-            return this._findByPk(keyValue, { ...options, connection });
+            return this._find(keyValue, { ...options, connection });
         }, options);
     }
     findOne(options) {
         return this._execute(async (connection) => {
-            return this._findOne({ ...options, connection });
+            return await this._findOne({
+                ...options,
+                connection,
+            });
         }, options);
     }
     findMany(options) {
         return this._execute(async (connection) => {
-            return this._findAll({ ...options, connection });
+            return this._findMany({ ...options, connection });
         }, options);
     }
-    deleteByPk(keyValue, options) {
+    delete(keyValue, options) {
         return this._execute(async (connection) => {
-            return this._destroy(keyValue, { ...options, connection });
+            return this._delete(keyValue, { ...options, connection });
         }, options);
     }
     deleteMany(options) {
         return this._execute(async (connection) => {
-            return this._destroyAll({ ...options, connection });
+            return this._deleteMany({ ...options, connection });
         }, options);
     }
-    updateByPk(keyValue, values, options) {
+    update(keyValue, values, options) {
         return this._execute(async (connection) => {
             const opts = { ...options, connection };
-            const keyValues = await this._updateByPk(keyValue, values, opts);
+            const keyValues = await this._update(keyValue, values, opts);
             if (keyValues)
-                return this._findByPk(keyValues, opts);
+                return this._find(keyValues, opts);
         }, options);
     }
-    updateByPkOnly(keyValue, values, options) {
+    updateOnly(keyValue, values, options) {
         return this._execute(async (connection) => {
-            return !!(await this._updateByPk(keyValue, values, { ...options, connection }));
+            return !!(await this._update(keyValue, values, { ...options, connection }));
         }, options);
     }
     updateMany(values, options) {
         return this._execute(async (connection) => {
-            return this._updateAll(values, { ...options, connection });
+            return this._updateMany(values, { ...options, connection });
         });
     }
     /**
@@ -106,20 +114,6 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     findAll(options) {
         return this.findMany(options);
     }
-    /**
-     *
-     * @deprecated
-     */
-    update(keyValue, values, options) {
-        return this.updateByPk(keyValue, values, options);
-    }
-    /**
-     *
-     * @deprecated
-     */
-    updateOnly(keyValue, values, options) {
-        return this.updateByPkOnly(keyValue, values, options);
-    }
     /**
      *
      * @deprecated
@@ -146,29 +140,14 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     async _create(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-create', values, options);
         const keyValues = await CreateCommand.execute({
             ...options,
             entity: this._entity,
-            values,
-            returning: true
+            values
         });
-        const result = keyValues && (await this.findByPk(keyValues, options));
-        if (!result)
+        if (options.returning && !keyValues)
             throw new Error('Unable to insert new row');
-        await this._emit('after-create', result, options);
-        return result;
-    }
-    async _createOnly(values, options) {
-        if (!values)
-            throw new TypeError('You must provide values');
-        await this._emit('before-create', values, options);
-        await CreateCommand.execute({
-            ...options,
-            entity: this._entity,
-            values,
-            returning: false
-        });
+        return keyValues;
     }
     async _exists(keyValue, options) {
         const filter = [extractKeyValues(this._entity, keyValue, true)];
@@ -190,21 +169,20 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             entity: this._entity
         });
     }
-    async _findAll(options) {
+    async _findMany(options) {
         return await FindCommand.execute({
             ...options,
             entity: this._entity,
         });
     }
     async _findOne(options) {
-        const rows = await FindCommand.execute({
+        const rows = await this._findMany({
             ...options,
-            entity: this._entity,
             limit: 1
         });
         return rows && rows[0];
     }
-    async _findByPk(keyValue, options) {
+    async _find(keyValue, options) {
         const filter = [extractKeyValues(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
@@ -214,8 +192,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         }
         return await this._findOne({ ...options, filter, offset: 0 });
     }
-    async _destroy(keyValue, options) {
-        await this._emit('before-destroy', keyValue, options);
+    async _delete(keyValue, options) {
         const filter = [extractKeyValues(this._entity, keyValue, true)];
         if (options && options.filter) {
             if (Array.isArray(options.filter))
@@ -223,29 +200,23 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             else
                 filter.push(options.filter);
         }
-        const result = !!(await DestroyCommand.execute({
+        return !!(await DeleteCommand.execute({
             ...options,
             filter,
             entity: this._entity,
         }));
-        await this._emit('after-destroy', result, keyValue, options);
-        return result;
     }
-    async _destroyAll(options) {
-        await this._emit('before-destroy-all', options);
-        const rowsAffected = DestroyCommand.execute({
+    async _deleteMany(options) {
+        return DeleteCommand.execute({
             ...options,
             entity: this._entity,
             filter: options?.filter,
             params: options?.params
         });
-        await this._emit('after-destroy-all', rowsAffected, options);
-        return rowsAffected;
     }
-    async _updateByPk(keyValue, values, options) {
+    async _update(keyValue, values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-update', keyValue, values, options);
         const keyValues = extractKeyValues(this._entity, keyValue, true);
         const filter = [keyValues];
         if (options.filter) {
@@ -262,27 +233,15 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             values: updateValues,
             filter
         });
-        await this._emit('after-update', rowsAffected, keyValues, options);
         return rowsAffected ? keyValues : undefined;
     }
-    async _updateAll(values, options) {
+    async _updateMany(values, options) {
         if (!values)
             throw new TypeError('You must provide values');
-        await this._emit('before-update-all', values, options);
-        const rowsAffected = await UpdateCommand.execute({
+        return await UpdateCommand.execute({
             ...options,
             entity: this._entity,
             values
         });
-        await this._emit('after-update-all', rowsAffected, values, options);
-        return rowsAffected;
-    }
-    async _emit(event, ...args) {
-        const events = this._entity.eventListeners && this._entity.eventListeners[event];
-        if (events) {
-            for (const fn of events) {
-                await fn(this, ...args);
-            }
-        }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.7.0",
+  "version": "4.8.2",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>",
@@ -46,7 +46,7 @@
     "@types/lodash": "^4.14.194"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.7.0"
+    "@sqb/builder": "^4.8.2"
   },
   "type": "module",
   "types": "esm/index.d.ts",