@loomcore/api 0.0.59 → 0.1.0

package/dist/databases/postgres/commands/postgres-delete-many.command.js

@@ -0,0 +1,13 @@
+import { buildWhereClause } from '../utils/build-where-clause.js';
+import { DeleteResult } from "../../models/delete-result.js";
+export async function deleteMany(client, queryObject, pluralResourceName) {
+    try {
+        const { whereClause, values } = buildWhereClause(queryObject);
+        const query = `DELETE FROM "${pluralResourceName}" ${whereClause}`;
+        const result = await client.query(query, values);
+        return new DeleteResult(true, result.rowCount || 0);
+    }
+    catch (error) {
+        return new DeleteResult(false, 0);
+    }
+}

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.d.ts

@@ -0,0 +1,4 @@
+import { Client } from 'pg';
+import { Operation } from "../../operations/operation.js";
+import { IEntity } from '@loomcore/common/models';
+export declare function fullUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.js

@@ -0,0 +1,72 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+export async function fullUpdateById(client, operations, id, entity, pluralResourceName) {
+    try {
+        const tableColumns = await client.query(`
+                SELECT column_name, column_default
+                FROM information_schema.columns
+                WHERE table_schema = current_schema()
+                  AND table_name = $1
+                ORDER BY ordinal_position
+            `, [pluralResourceName]);
+        if (tableColumns.rows.length === 0) {
+            throw new BadRequestError(`Unable to resolve columns for ${pluralResourceName}`);
+        }
+        const preservedColumns = new Set(['_id', '_created', '_createdBy']);
+        const entityRecord = entity;
+        const updateColumns = [];
+        const updateValues = [];
+        let paramIndex = 1;
+        for (const column of tableColumns.rows) {
+            const columnName = column.column_name;
+            if (preservedColumns.has(columnName)) {
+                continue;
+            }
+            if (columnName in entityRecord && entityRecord[columnName] !== undefined) {
+                updateColumns.push(`"${columnName}" = $${paramIndex}`);
+                updateValues.push(entityRecord[columnName]);
+                paramIndex++;
+            }
+            else if (column.column_default !== null) {
+                updateColumns.push(`"${columnName}" = DEFAULT`);
+            }
+            else {
+                updateColumns.push(`"${columnName}" = $${paramIndex}`);
+                updateValues.push(null);
+                paramIndex++;
+            }
+        }
+        if (updateColumns.length === 0) {
+            throw new BadRequestError('Cannot perform full update with no fields to update');
+        }
+        const setClause = updateColumns.join(', ');
+        const query = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            WHERE "_id" = $${paramIndex}
+        `;
+        const result = await client.query(query, [...updateValues, id]);
+        if (result.rowCount === 0) {
+            throw new IdNotFoundError();
+        }
+        const joinClauses = buildJoinClauses(operations);
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            WHERE "_id" = $1 LIMIT 1
+        `;
+        const selectResult = await client.query(selectQuery, [id]);
+        if (selectResult.rows.length === 0) {
+            throw new IdNotFoundError();
+        }
+        return selectResult.rows[0];
+    }
+    catch (err) {
+        if (err instanceof IdNotFoundError) {
+            throw err;
+        }
+        if (err.code === '23505') {
+            throw new BadRequestError(`${pluralResourceName} has duplicate key violations`);
+        }
+        throw new BadRequestError(`Error updating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.d.ts

@@ -0,0 +1,4 @@
+import { Client } from 'pg';
+import { Operation } from "../../operations/operation.js";
+import { IEntity } from '@loomcore/common/models';
+export declare function partialUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.js

@@ -0,0 +1,42 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+export async function partialUpdateById(client, operations, id, entity, pluralResourceName) {
+    try {
+        const { columns, values } = columnsAndValuesFromEntity(entity);
+        const updateColumns = columns.filter(col => col !== '"_id"');
+        const updateValues = values.filter((_, index) => columns[index] !== '"_id"');
+        if (updateColumns.length === 0) {
+            throw new BadRequestError('Cannot perform partial update with no fields to update');
+        }
+        const setClause = updateColumns.map((col, index) => `${col} = $${index + 1}`).join(', ');
+        const query = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            WHERE "_id" = $${updateValues.length + 1}
+        `;
+        const result = await client.query(query, [...updateValues, id]);
+        if (result.rowCount === 0) {
+            throw new IdNotFoundError();
+        }
+        const joinClauses = buildJoinClauses(operations);
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            WHERE "_id" = $1 LIMIT 1
+        `;
+        const selectResult = await client.query(selectQuery, [id]);
+        if (selectResult.rows.length === 0) {
+            throw new IdNotFoundError();
+        }
+        return selectResult.rows[0];
+    }
+    catch (err) {
+        if (err instanceof IdNotFoundError) {
+            throw err;
+        }
+        if (err.code === '23505') {
+            throw new BadRequestError(`${pluralResourceName} has duplicate key violations`);
+        }
+        throw new BadRequestError(`Error updating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/commands/postgres-update.command.d.ts

@@ -0,0 +1,5 @@
+import { Client } from 'pg';
+import { IQueryOptions } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+import { IEntity } from '@loomcore/common/models';
+export declare function update<T extends IEntity>(client: Client, queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/commands/postgres-update.command.js

@@ -0,0 +1,48 @@
+import { BadRequestError, NotFoundError } from "../../../errors/index.js";
+import { buildWhereClause } from '../utils/build-where-clause.js';
+import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildOrderByClause } from '../utils/build-order-by-clause.js';
+import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+export async function update(client, queryObject, entity, operations, pluralResourceName) {
+    try {
+        const { whereClause, values: whereValues } = buildWhereClause(queryObject);
+        const { columns, values: entityValues } = columnsAndValuesFromEntity(entity);
+        const updateColumns = columns.filter(col => col !== '"_id"');
+        const updateValues = entityValues.filter((_, index) => columns[index] !== '"_id"');
+        if (updateColumns.length === 0) {
+            throw new BadRequestError('Cannot perform update with no fields to update');
+        }
+        const setClause = updateColumns.map((col, index) => `${col} = $${index + 1}`).join(', ');
+        const whereClauseWithAdjustedParams = whereClause.replace(/\$(\d+)/g, (match, num) => {
+            const originalIndex = parseInt(num, 10);
+            return `$${originalIndex + updateValues.length}`;
+        });
+        const updateQuery = `
+            UPDATE "${pluralResourceName}"
+            SET ${setClause}
+            ${whereClauseWithAdjustedParams}
+        `;
+        const allUpdateValues = [...updateValues, ...whereValues];
+        const result = await client.query(updateQuery, allUpdateValues);
+        if (result.rowCount === 0) {
+            throw new NotFoundError('No records found matching update query');
+        }
+        const joinClauses = buildJoinClauses(operations);
+        const orderByClause = buildOrderByClause(queryObject);
+        const selectQuery = `
+            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            ${whereClause} ${orderByClause}
+        `.trim();
+        const selectResult = await client.query(selectQuery, whereValues);
+        return selectResult.rows;
+    }
+    catch (err) {
+        if (err instanceof NotFoundError) {
+            throw err;
+        }
+        if (err.code === '23505') {
+            throw new BadRequestError(`${pluralResourceName} has duplicate key violations`);
+        }
+        throw new BadRequestError(`Error updating ${pluralResourceName}: ${err.message}`);
+    }
+}

package/dist/databases/postgres/migrations/001-create-migrations-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "./migration.interface.js";
+export declare class CreateMigrationTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/databases/postgres/migrations/001-create-migrations-table.migration.js

@@ -0,0 +1,52 @@
+import { randomUUID } from 'crypto';
+export class CreateMigrationTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 1;
+    _id = randomUUID().toString();
+    async execute() {
+        let alreadyRun = false;
+        try {
+            await this.client.query(`
+                CREATE TABLE "migrations" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "index" INTEGER NOT NULL,
+                    "hasRun" BOOLEAN NOT NULL,
+                    "reverted" BOOLEAN NOT NULL
+                )
+            `);
+        }
+        catch (error) {
+            if (error.data.error.includes('already exists')) {
+                alreadyRun = true;
+            }
+            else {
+                throw error;
+            }
+        }
+        if (!alreadyRun) {
+            if (this.orgId) {
+                await this.client.query(`
+                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+            `);
+            }
+            else {
+                await this.client.query(`
+                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted") VALUES ('${this._id}', ${this.index}, TRUE, FALSE);
+            `);
+            }
+        }
+        return true;
+    }
+    async revert() {
+        await this.client.query(`
+            DROP TABLE "migrations";
+        `);
+        return true;
+    }
+}

package/dist/databases/postgres/migrations/002-create-organizations-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "./migration.interface.js";
+export declare class CreateOrganizationTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId;
+    constructor(client: Client, orgId: string);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/databases/postgres/migrations/002-create-organizations-table.migration.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "crypto";
+export class CreateOrganizationTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 2;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+            CREATE TABLE "organizations" (
+                "_id" VARCHAR(255) PRIMARY KEY,
+                "name" VARCHAR(255) NOT NULL,
+                "code" VARCHAR(255) NOT NULL,
+                "description" TEXT,
+                "status" INTEGER NOT NULL,
+                "isMetaOrg" BOOLEAN NOT NULL,
+                "authToken" TEXT,
+                "_created" TIMESTAMP NOT NULL,
+                "_createdBy" VARCHAR(255) NOT NULL,
+                "_updated" TIMESTAMP NOT NULL,
+                "_updatedBy" VARCHAR(255) NOT NULL,
+                "_deleted" TIMESTAMP,
+                "_deletedBy" VARCHAR(255)
+                )
+            `);
+            await this.client.query(`
+                Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+            `);
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating organization table:', error);
+            return false;
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+            DROP TABLE "organizations";
+        `);
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+        }
+        catch (error) {
+            console.error('Error reverting organization table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/databases/postgres/migrations/003-create-users-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "./migration.interface.js";
+export declare class CreateUsersTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/databases/postgres/migrations/003-create-users-table.migration.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "crypto";
+export class CreateUsersTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 3;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "users" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "email" VARCHAR(255) NOT NULL,
+                    "firstName" VARCHAR(255),
+                    "lastName" VARCHAR(255),
+                    "displayName" VARCHAR(255),
+                    "password" VARCHAR(255) NOT NULL,
+                    "roles" TEXT[],
+                    "_lastLoggedIn" TIMESTAMP,
+                    "_lastPasswordChange" TIMESTAMP,
+                    "_created" TIMESTAMP NOT NULL,
+                    "_createdBy" VARCHAR(255) NOT NULL,
+                    "_updated" TIMESTAMP NOT NULL,
+                    "_updatedBy" VARCHAR(255) NOT NULL,
+                    "_deleted" TIMESTAMP,
+                    "_deletedBy" VARCHAR(255)
+                )
+            `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+        }
+        catch (error) {
+            console.error('Error creating users table:', error);
+            return false;
+        }
+        return true;
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "users";
+            `);
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+        }
+        catch (error) {
+            console.error('Error reverting users table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/databases/postgres/migrations/004-create-refresh-token-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "./index.js";
+export declare class CreateRefreshTokenTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/databases/postgres/migrations/004-create-refresh-token-table.migration.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "crypto";
+export class CreateRefreshTokenTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 4;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+            CREATE TABLE "refreshTokens" (
+                "_id" VARCHAR(255) PRIMARY KEY,
+                "_orgId" VARCHAR(255),
+                "token" VARCHAR(255) NOT NULL,
+                "deviceId" VARCHAR(255) NOT NULL,
+                "userId" VARCHAR(255) NOT NULL,
+                "expiresOn" BIGINT NOT NULL,
+                "created" TIMESTAMP NOT NULL,
+                "createdBy" VARCHAR(255) NOT NULL
+            )
+        `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating refresh token table:', error);
+            return false;
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "refresh_tokens";
+            `);
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+            return true;
+        }
+        catch (error) {
+            console.error('Error reverting refresh token table:', error);
+            return false;
+        }
+    }
+}

package/dist/databases/postgres/migrations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './migration.interface.js';
+export * from './setup-for-multitenant.migration.js';
+export * from './setup-for-auth.migration.js';

package/dist/databases/postgres/migrations/index.js

@@ -0,0 +1,3 @@
+export * from './migration.interface.js';
+export * from './setup-for-multitenant.migration.js';
+export * from './setup-for-auth.migration.js';

package/dist/databases/postgres/migrations/migration.d.ts

@@ -0,0 +1,6 @@
+import { Client } from "pg";
+export declare class Migration {
+    private readonly client;
+    constructor(client: Client);
+    execute(): Promise<void>;
+}

package/dist/databases/postgres/migrations/migration.interface.d.ts

@@ -0,0 +1,6 @@
+import { IEntity } from "@loomcore/common/models";
+export interface IMigration extends IEntity {
+    index: number;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/databases/postgres/migrations/migration.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/postgres/migrations/migration.js

@@ -0,0 +1,14 @@
+export class Migration {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async execute() {
+        await this.client.query(`
+            CREATE TABLE refresh_tokens (
+                id SERIAL PRIMARY KEY,
+                token VARCHAR(255) NOT NULL
+            )
+        `);
+    }
+}

package/dist/databases/postgres/migrations/runMigrations.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "pg";
+export declare function runMigrations(client: Client, orgId: string, version?: number | null): Promise<boolean>;

package/dist/databases/postgres/migrations/runMigrations.js

@@ -0,0 +1,20 @@
+import { CreateMigrationTableMigration, CreateOrganizationTableMigration, CreateUsersTableMigration } from "./index.js";
+import { CreateRefreshTokenTableMigration } from "./004-create-refresh-token-table.migration.js";
+export async function runMigrations(client, orgId, version = null) {
+    const migrations = [
+        new CreateMigrationTableMigration(client, orgId),
+        new CreateOrganizationTableMigration(client, orgId),
+        new CreateUsersTableMigration(client, orgId),
+        new CreateRefreshTokenTableMigration(client, orgId),
+    ];
+    let success = true;
+    for (const migration of migrations) {
+        if (version === null || migration.index <= version) {
+            success = await migration.execute();
+            if (!success) {
+                return false;
+            }
+        }
+    }
+    return success;
+}

package/dist/databases/postgres/migrations/setup-for-auth.migration.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "pg";
+export declare function setupDatabaseForAuth(client: Client, orgId?: string): Promise<boolean>;

package/dist/databases/postgres/migrations/setup-for-auth.migration.js

@@ -0,0 +1,18 @@
+import { CreateRefreshTokenTableMigration } from "./004-create-refresh-token-table.migration.js";
+import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
+import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
+export async function setupDatabaseForAuth(client, orgId) {
+    const migrations = [
+        new CreateMigrationTableMigration(client, orgId),
+        new CreateUsersTableMigration(client, orgId),
+        new CreateRefreshTokenTableMigration(client, orgId),
+    ];
+    let success = true;
+    for (const migration of migrations) {
+        success = await migration.execute();
+        if (!success) {
+            return false;
+        }
+    }
+    return success;
+}

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "pg";
+export declare function setupDatabaseForMultitenant(client: Client, orgId: string): Promise<boolean>;

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.js

@@ -0,0 +1,16 @@
+import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
+import { CreateOrganizationTableMigration } from "./002-create-organizations-table.migration.js";
+export async function setupDatabaseForMultitenant(client, orgId) {
+    const migrations = [
+        new CreateMigrationTableMigration(client, orgId),
+        new CreateOrganizationTableMigration(client, orgId),
+    ];
+    let success = true;
+    for (const migration of migrations) {
+        success = await migration.execute();
+        if (!success) {
+            return false;
+        }
+    }
+    return success;
+}

package/dist/databases/postgres/postgres.database.d.ts

@@ -0,0 +1,31 @@
+import { IQueryOptions, IModelSpec, IPagedResult, IEntity } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+import { DeleteResult, IDatabase } from "../models/index.js";
+import { Operation } from "../operations/operation.js";
+import { Client } from 'pg';
+export declare class PostgresDatabase implements IDatabase {
+    private client;
+    constructor(client: Client);
+    preprocessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
+    postprocessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
+    getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getCount(pluralResourceName: string): Promise<number>;
+    create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
+        insertedId: string;
+        entity: T;
+    }>;
+    createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
+        insertedIds: string[];
+        entities: T[];
+    }>;
+    batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    deleteById(id: string, pluralResourceName: string): Promise<DeleteResult>;
+    deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
+    find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
+}