@clairejs/server 3.18.2 → 3.19.1

package/README.md

@@ -1,5 +1,10 @@
 ## Change Log
 
+#### 3.19.1:
+
+-   fix ModelRepository getMany
+-   adapt interface with new claire orm
+
 #### 3.18.2:
 
 -   fix multi locale issue with model repo

package/dist/http/controller/AbstractHttpController.d.ts

@@ -2,7 +2,7 @@ import { type ITransactionFactory } from "@clairejs/orm";
 import { type EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { Transactionable } from "../../common/Transactionable";
 export declare abstract class AbstractHttpController extends Transactionable {
-    protected readonly databaseAdapter: ITransactionFactory;
-    constructor(databaseAdapter: ITransactionFactory);
+    protected readonly db: ITransactionFactory;
+    constructor(db: ITransactionFactory);
     getEndpointMetadata(): Readonly<EndpointMetadata>[];
 }

package/dist/http/controller/AbstractHttpController.js

@@ -4,10 +4,10 @@ const isEndpoint = (metadata) => {
     return !!metadata.method;
 };
 export class AbstractHttpController extends Transactionable {
-    databaseAdapter;
-    constructor(databaseAdapter) {
-        super(databaseAdapter);
-        this.databaseAdapter = databaseAdapter;
+    db;
+    constructor(db) {
+        super(db);
+        this.db = db;
     }
     getEndpointMetadata() {
         const controllerMetadata = getObjectMetadata(this.constructor);

package/dist/http/controller/CrudHttpController.d.ts

@@ -8,10 +8,10 @@ import { type ICrudRepository } from "../repository/ICrudRepository";
 export declare class CrudHttpController<T extends Identifiable> extends AbstractHttpController {
     protected readonly model: Constructor<T>;
     protected readonly crudRepository: ICrudRepository<T>;
-    protected readonly databaseAdapter: ITransactionFactory & IQueryProvider;
+    protected readonly db: ITransactionFactory & IQueryProvider;
     protected readonly modelMetadata: ModelMetadata;
     private principalResolver?;
-    constructor(model: Constructor<T>, crudRepository: ICrudRepository<T>, databaseAdapter: ITransactionFactory & IQueryProvider);
+    constructor(model: Constructor<T>, crudRepository: ICrudRepository<T>, db: ITransactionFactory & IQueryProvider);
     protected getMountedUrl(): string;
     private getAuthProvider;
     /**

package/dist/http/controller/CrudHttpController.js

@@ -19,14 +19,14 @@ import { AbstractHttpController } from "./AbstractHttpController";
 export class CrudHttpController extends AbstractHttpController {
     model;
     crudRepository;
-    databaseAdapter;
+    db;
     modelMetadata;
     principalResolver;
-    constructor(model, crudRepository, databaseAdapter) {
-        super(databaseAdapter);
+    constructor(model, crudRepository, db) {
+        super(db);
         this.model = model;
         this.crudRepository = crudRepository;
-        this.databaseAdapter = databaseAdapter;
+        this.db = db;
         this.modelMetadata = getObjectMetadata(model);
     }
     getMountedUrl() {
@@ -197,7 +197,6 @@ export class CrudHttpController extends AbstractHttpController {
     async getMany(req) {
         const result = await this.crudRepository.getMany({
             queries: req.getQuery(),
-            queryProvider: this.databaseAdapter,
         });
         return ResponseBuilder.json(result).get();
     }

package/dist/http/repository/DtoRepository.d.ts

@@ -1,8 +1,8 @@
-import { AbstractLogger, AbstractModel, Constructor, CreateManyRequestBody, CreateManyResponseBody, DeepPartial, GetManyQueries, GetManyResponseBody, Identifiable, UpdateManyBody, UpdateManyQueries, UpdateManyResponse } from "@clairejs/core";
-import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
-import { IPrincipal } from "../../common/auth/IPrincipal";
+import { type Identifiable, type Constructor, type CreateManyRequestBody, type CreateManyResponseBody, type DeepPartial, type GetManyQueries, type GetManyResponseBody, type UpdateManyBody, type UpdateManyQueries, type UpdateManyResponse, AbstractLogger, AbstractModel } from "@clairejs/core";
+import { type ITransaction, type QueryCondition, AbstractDbAdapter } from "@clairejs/orm";
+import { type IPrincipal } from "../../common/auth/IPrincipal";
 import { AbstractRepository } from "./AbstractRepository";
-import { ICrudRepository } from "./ICrudRepository";
+import { type ICrudRepository } from "./ICrudRepository";
 export type DtoDissolver<R extends Identifiable, K extends Identifiable> = (t: DeepPartial<K>) => MappingMetadata<R, any>[];
 export interface MappingMetadata<R extends Identifiable, K extends AbstractModel> {
     multiple: boolean;
@@ -30,13 +30,14 @@ export declare const MultipleMap: <R extends Identifiable, K extends AbstractMod
 };
 export declare class DtoRepository<T extends Identifiable> extends AbstractRepository<T> implements ICrudRepository<T> {
     protected readonly model: Constructor<T>;
+    protected readonly db: AbstractDbAdapter;
     protected readonly dissolver: DtoDissolver<T, any>;
-    constructor(model: Constructor<T>, dissolver: DtoDissolver<T, any>);
+    constructor(model: Constructor<T>, db: AbstractDbAdapter, dissolver: DtoDissolver<T, any>);
     private getMapValue;
     createMany({ principal, body, tx, logger, }: {
         principal?: IPrincipal | undefined;
         body: CreateManyRequestBody<T>;
-        tx: ITransaction & IQueryProvider;
+        tx: ITransaction;
         logger?: AbstractLogger;
     }): Promise<CreateManyResponseBody<T>>;
     updateMany({ principal, queries, ops, body, tx, logger, }: {
@@ -44,13 +45,13 @@ export declare class DtoRepository<T extends Identifiable> extends AbstractRepos
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         body: UpdateManyBody<T>;
-        tx: ITransaction & IQueryProvider;
+        tx: ITransaction;
         logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
-    getMany({ queries, ops, queryProvider, logger, }: {
+    getMany({ queries, ops, tx, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
-        queryProvider: IQueryProvider;
+        tx?: ITransaction;
         logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
     deleteMany({ queries, ops, tx, logger, }: {

package/dist/http/repository/DtoRepository.js

@@ -25,10 +25,12 @@ export const MultipleMap = (modelClass, forwardOps, forwardMapping, rootMapping,
 });
 export class DtoRepository extends AbstractRepository {
     model;
+    db;
     dissolver;
-    constructor(model, dissolver) {
+    constructor(model, db, dissolver) {
         super(model);
         this.model = model;
+        this.db = db;
         this.dissolver = dissolver;
     }
     async getMapValue(root, currentInstancesResolver, mappers, preOperator, postOperator) {
@@ -56,10 +58,10 @@ export class DtoRepository extends AbstractRepository {
         await this.beforeCreating(principal, body.records);
         for (const record of body.records) {
             await this.getMapValue(record, async (mapper) => {
-                const repo = new ModelRepository(mapper.modelClass);
+                const repo = new ModelRepository(mapper.modelClass, this.db);
                 const currentInstances = await repo.getMany({
                     ops: mapper.forwardOps(),
-                    queryProvider: tx,
+                    tx,
                     logger,
                 });
                 return currentInstances.records;
@@ -67,7 +69,7 @@ export class DtoRepository extends AbstractRepository {
                 if (!ks) {
                     return [];
                 }
-                const repo = new ModelRepository(mapper.modelClass);
+                const repo = new ModelRepository(mapper.modelClass, this.db);
                 const ops = mapper.forwardOps();
                 if (mapper.multiple) {
                     //-- if ks contain an array of instances, we need to remove old instances and create new ones
@@ -118,10 +120,10 @@ export class DtoRepository extends AbstractRepository {
         const result = { ...body.update, id: queries.fields.id[0] };
         await this.beforeCreating(principal, [result]);
         await this.getMapValue(result, async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass);
+            const repo = new ModelRepository(mapper.modelClass, this.db);
             const currentInstances = await repo.getMany({
                 ops: mapper.forwardOps(ops),
-                queryProvider: tx,
+                tx,
                 logger,
             });
             return currentInstances.records;
@@ -129,7 +131,7 @@ export class DtoRepository extends AbstractRepository {
             if (!ks) {
                 return [];
             }
-            const repo = new ModelRepository(mapper.modelClass);
+            const repo = new ModelRepository(mapper.modelClass, this.db);
             const opsx = mapper.forwardOps(ops);
             if (mapper.multiple) {
                 //-- if ks contain an array of instances, we need to remove old instances and create new ones
@@ -171,18 +173,18 @@ export class DtoRepository extends AbstractRepository {
         }
         return { modified: result.id ? this.project([result], projection) : [] };
     }
-    async getMany({ queries, ops, queryProvider, logger, }) {
+    async getMany({ queries, ops, tx, logger, }) {
         //-- check queries for id field
         if (!queries?.fields?.id || queries.fields.id.length !== 1) {
             throw Errors.VALIDATION_ERROR("Missing required id field in query");
         }
         const result = { id: queries.fields.id[0] };
         await this.getMapValue(result, async () => [], this.dissolver(result), async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass);
+            const repo = new ModelRepository(mapper.modelClass, this.db);
             //-- forward get
             const instances = await repo.getMany({
                 ops: mapper.forwardOps(ops),
-                queryProvider,
+                tx,
                 logger,
             });
             return instances.records;
@@ -198,7 +200,7 @@ export class DtoRepository extends AbstractRepository {
         }
         const result = { id: queries.fields.id[0] };
         await this.getMapValue(result, async () => [], this.dissolver(result), undefined, async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass);
+            const repo = new ModelRepository(mapper.modelClass, this.db);
             //const nestedQueries = mapper.forwardQuery();
             const nestedOps = mapper.forwardOps(ops);
             const result = await repo.deleteMany({

package/dist/http/repository/ICrudRepository.d.ts

@@ -1,5 +1,5 @@
 import { type AbstractLogger, type CreateManyRequestBody, type CreateManyResponseBody, type GetManyQueries, type GetManyResponseBody, type UpdateManyBody, type UpdateManyQueries, type UpdateManyResponse } from "@clairejs/core";
-import { type IQueryProvider, type ITransaction, type QueryCondition } from "@clairejs/orm";
+import { type ITransaction, type QueryCondition } from "@clairejs/orm";
 import { type IPrincipal } from "../../common/auth/IPrincipal";
 export interface ICrudRepository<T> {
     createMany({ principal, body, tx, logger, }: {
@@ -8,10 +8,10 @@ export interface ICrudRepository<T> {
         logger?: AbstractLogger;
         principal?: IPrincipal;
     }): Promise<CreateManyResponseBody<T>>;
-    getMany({ queries, ops, queryProvider, logger, }: {
+    getMany({ queries, ops, tx, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
-        queryProvider: IQueryProvider;
+        tx?: ITransaction;
         logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
     updateMany({ principal, queries, ops, body, tx, logger, }: {

package/dist/http/repository/ModelRepository.d.ts

@@ -1,12 +1,13 @@
 import { AbstractModel, Constructor, CreateManyRequestBody, CreateManyResponseBody, GetManyQueries, GetManyResponseBody, UpdateManyBody, UpdateManyQueries, UpdateManyResponse, AbstractLogger } from "@clairejs/core";
-import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
+import { AbstractDbAdapter, ITransaction, QueryCondition } from "@clairejs/orm";
 import { IPrincipal } from "../../common/auth/IPrincipal";
 import { ICrudRepository } from "./ICrudRepository";
 import { AbstractRepository } from "./AbstractRepository";
 export declare class ModelRepository<T extends AbstractModel> extends AbstractRepository<T> implements ICrudRepository<T> {
     protected readonly model: Constructor<T>;
+    protected readonly db: AbstractDbAdapter;
     private fileUploadHandler?;
-    constructor(model: Constructor<T>);
+    constructor(model: Constructor<T>, db: AbstractDbAdapter);
     private getNestedQueries;
     private getUploadHandler;
     private getRequestQueryConditionFromQuery;
@@ -26,10 +27,10 @@ export declare class ModelRepository<T extends AbstractModel> extends AbstractRe
         tx: ITransaction;
         logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
-    getMany({ queries, ops, queryProvider, logger, }: {
+    getMany({ queries, ops, tx, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
-        queryProvider: IQueryProvider;
+        tx?: ITransaction;
         logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
     deleteMany({ queries, ops, tx, logger, }: {

package/dist/http/repository/ModelRepository.js

@@ -1,15 +1,17 @@
 import { DataType, getModelById, getServiceProvider, RangeQueryDto, uniqueReducer, leanData, getSystemLocale, Errors, omitData, } from "@clairejs/core";
-import { getDirectFields } from "@clairejs/orm";
+import { getDirectFields, } from "@clairejs/orm";
 import { AbstractFileUploadHandler } from "../file-upload/AbstractFileUploadHandler";
 import { AbstractRepository } from "./AbstractRepository";
 import { LocaleTranslation } from "../../system/locale/LocaleTranslation";
 import { LocaleEntry } from "../../system/locale/LocaleEntry";
 export class ModelRepository extends AbstractRepository {
     model;
+    db;
     fileUploadHandler;
-    constructor(model) {
+    constructor(model, db) {
         super(model);
         this.model = model;
+        this.db = db;
     }
     getNestedQueries(queries) {
         return this.modelMetadata.fields
@@ -238,8 +240,8 @@ export class ModelRepository extends AbstractRepository {
                 entryObject: {},
             }));
         });
-        const translationEntries = await tx
-            .use(LocaleEntry)
+        const translationEntries = await this.db
+            .use(LocaleEntry, tx)
             .createMany(translationEntryData.map((data) => data.entryObject));
         //-- translation data will have same length as translationEntries
         const translationData = originalRecords.flatMap((record) => {
@@ -256,7 +258,7 @@ export class ModelRepository extends AbstractRepository {
             }));
         });
         //-- create translation records
-        await tx.use(LocaleTranslation).createMany(translations);
+        await this.db.use(LocaleTranslation, tx).createMany(translations);
         //-- first create records for direct fields
         body.records = originalRecords.map((record, index) => {
             const data = directFields.reduce((collector, field) => {
@@ -278,7 +280,9 @@ export class ModelRepository extends AbstractRepository {
             return data;
         });
         await this.beforeCreating(principal, body.records);
-        let records = body.records.length ? await tx.use(this.model).createMany(body.records) : [];
+        let records = body.records.length
+            ? await this.db.use(this.model, tx).createMany(body.records)
+            : [];
         await this.beforeReturning(records);
         const projection = this.modelMetadata.fields
             .filter((field) => !field.multiLocaleColumn && (field.pk || field.serverValue || field.mimeProps))
@@ -301,7 +305,7 @@ export class ModelRepository extends AbstractRepository {
             });
             if (hasManyRecords.length) {
                 //-- insert to db
-                const innerService = new ModelRepository(getModelById(field.hasMany.relationDto.id));
+                const innerService = new ModelRepository(getModelById(field.hasMany.relationDto.id), this.db);
                 body.records = hasManyRecords;
                 const persistedInnerRecords = await innerService.createMany({ principal, body, tx });
                 //-- map back ids to hasManyRecords
@@ -362,12 +366,14 @@ export class ModelRepository extends AbstractRepository {
         let modified = [];
         let updatedRecords = [];
         if (nestedQueries.length) {
-            const tobeUpdated = await tx.use(this.model).getMany(condition, { projection: ["id"] }, nestedQueries);
+            const tobeUpdated = await this.db
+                .use(this.model, tx)
+                .getMany(condition, { projection: ["id"] }, nestedQueries);
             modified = tobeUpdated.records.map((r) => r.id);
             if (modified.length) {
                 if (directUpdateFields.length) {
-                    updatedRecords = await tx
-                        .use(this.model)
+                    updatedRecords = await this.db
+                        .use(this.model, tx)
                         .updateMany({ _in: { id: modified } }, directUpdate, true);
                 }
                 else {
@@ -377,11 +383,11 @@ export class ModelRepository extends AbstractRepository {
         }
         else {
             if (directUpdateFields.length) {
-                updatedRecords = await tx.use(this.model).updateMany(condition, directUpdate, true);
+                updatedRecords = await this.db.use(this.model, tx).updateMany(condition, directUpdate, true);
                 modified = updatedRecords.map((re) => re.id);
             }
             else {
-                const tobeUpdated = await tx.use(this.model).getMany(condition, { projection: ["id"] });
+                const tobeUpdated = await this.db.use(this.model, tx).getMany(condition, { projection: ["id"] });
                 modified = tobeUpdated.records.map((r) => r.id);
                 updatedRecords = modified.map((id) => ({ id }));
             }
@@ -391,7 +397,7 @@ export class ModelRepository extends AbstractRepository {
         //-- update translations
         if (localeOfFields.length) {
             //-- check if there is missing locale entry for localeFields
-            const records = await tx.use(this.model).getRecords({
+            const records = await this.db.use(this.model, tx).getRecords({
                 _in: { id: modified },
             }, { projection: ["id", ...localeOfFields.map((f) => f.name)] });
             //-- check missing
@@ -403,7 +409,9 @@ export class ModelRepository extends AbstractRepository {
                 field: field.name,
             })))
                 .flatMap((arr) => arr);
-            const missingEntries = !missing.length ? [] : await tx.use(LocaleEntry).createMany(missing.map(() => ({})));
+            const missingEntries = !missing.length
+                ? []
+                : await this.db.use(LocaleEntry, tx).createMany(missing.map(() => ({})));
             const updateEntryRecords = [];
             missingEntries.forEach((entry, index) => {
                 const missingData = missing[index];
@@ -420,7 +428,7 @@ export class ModelRepository extends AbstractRepository {
                 }
             });
             //-- update records
-            await Promise.all(updateEntryRecords.map((re) => tx.use(this.model).updateById(re.id, omitData(re, ["id"]))));
+            await Promise.all(updateEntryRecords.map((re) => this.db.use(this.model, tx).updateById(re.id, omitData(re, ["id"]))));
             const tobeModified = [];
             for (const field of localeOfFields) {
                 const localOfData = body.update[field.name];
@@ -438,13 +446,13 @@ export class ModelRepository extends AbstractRepository {
             }
             if (tobeModified.length) {
                 //-- remove old translations
-                await tx.use(LocaleTranslation).deleteMany({
+                await this.db.use(LocaleTranslation, tx).deleteMany({
                     _or: tobeModified.map((rem) => ({
                         _eq: { entryId: rem.entryId, localeCode: rem.langCode },
                     })),
                 });
                 //-- add new translations
-                await tx.use(LocaleTranslation).createMany(tobeModified.map((rem) => ({
+                await this.db.use(LocaleTranslation, tx).createMany(tobeModified.map((rem) => ({
                     entryId: rem.entryId,
                     localeCode: rem.langCode,
                     translation: rem.translation,
@@ -463,7 +471,7 @@ export class ModelRepository extends AbstractRepository {
             const theRecord = records.find((r) => r.id === modified[0]);
             //-- get all inner records and compare
             const model = getModelById(field.hasMany.relationDto.id);
-            const adapter = tx.use(model);
+            const adapter = this.db.use(model, tx);
             const allInnerRecords = await adapter.getRecords({ _eq: { [field.hasMany.column]: theRecord.id } }, { limit: field.hasMany?.single ? 1 : undefined });
             const currentIds = allInnerRecords.map((r) => r.id);
             const newIds = innerUpdates.map((r) => r.id).filter((id) => !!id);
@@ -475,7 +483,7 @@ export class ModelRepository extends AbstractRepository {
             if (tobeRemovedIds.length) {
                 await adapter.deleteMany({ _in: { id: tobeRemovedIds } });
             }
-            const modelService = new ModelRepository(model);
+            const modelService = new ModelRepository(model, this.db);
             const added = await modelService.createMany({
                 principal,
                 body: { records: tobeAdded },
@@ -510,7 +518,7 @@ export class ModelRepository extends AbstractRepository {
         await this.beforeReturning(records);
         return { modified: this.project(records, projection) };
     }
-    async getMany({ queries, ops, queryProvider, logger: _logger, }) {
+    async getMany({ queries, ops, tx, logger: _logger, }) {
         const conditions = ops || [];
         if (queries?.fields) {
             conditions.push(...this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata));
@@ -533,7 +541,7 @@ export class ModelRepository extends AbstractRepository {
             ...queries.projection.filter((fieldName) => !this.modelMetadata.fields.find((f) => f.name === fieldName && !!f.hasMany)),
             ...localeOfFields.map((f) => f.name),
         ];
-        const result = await queryProvider.use(this.model).getMany(conditions.length ? { _and: conditions } : {}, {
+        const result = await this.db.use(this.model, tx).getMany(conditions.length ? { _and: conditions } : {}, {
             limit: queries?.limit,
             page: queries?.page,
             projection: finalProjection,
@@ -551,12 +559,12 @@ export class ModelRepository extends AbstractRepository {
             ? []
             : !queries?.locale
                 ? //-- if locale is not specified then get translation for all locales
-                    await queryProvider.use(LocaleTranslation).getRecords({
+                    await this.db.use(LocaleTranslation, tx).getRecords({
                         _in: { entryId: allLocaleEntries },
                     }, { projection: ["entryId", "localeCode", "translation"] })
                 : //-- if locale is specified then get only the translation of that locale
                     queries.locale.toLowerCase() !== systemLocale
-                        ? await queryProvider.use(LocaleTranslation).getRecords({
+                        ? await this.db.use(LocaleTranslation, tx).getRecords({
                             _in: { entryId: allLocaleEntries },
                             _eq: { localeCode: queries.locale },
                         }, { projection: ["entryId", "localeCode", "translation"] })
@@ -593,12 +601,12 @@ export class ModelRepository extends AbstractRepository {
             if (!model) {
                 throw Errors.NOT_FOUND(`Model not found by id: ${field.hasMany.relationDto.id}`);
             }
-            const service = new ModelRepository(model);
+            const service = new ModelRepository(model, this.db);
             const innerRecords = !recordIds.length
                 ? { records: [] }
                 : await service.getMany({
                     queries: { fields: { [field.hasMany.column]: recordIds }, limit: field.hasMany.single ? 1 : 0 },
-                    queryProvider,
+                    tx,
                 });
             //-- filter corresponding inner records for each master record
             for (const record of result.records) {
@@ -627,10 +635,10 @@ export class ModelRepository extends AbstractRepository {
         const uriMapperFields = this.modelMetadata.fields.filter((f) => f.uriMapper);
         const localeOfFields = this.modelMetadata.fields.filter((f) => f.multiLocaleColumn);
         if (nestedQueries.length || localeOfFields.length || uriMapperFields.length) {
-            const tobeRemoved = await tx
-                .use(this.model)
+            const tobeRemoved = await this.db
+                .use(this.model, tx)
                 .getRecords(condition, { projection: ["id", ...[...localeOfFields, ...uriMapperFields].map((f) => f.name)] }, nestedQueries);
-            await tx.use(this.model).deleteMany({
+            await this.db.use(this.model, tx).deleteMany({
                 _in: { id: tobeRemoved.map((r) => r.id) },
             });
             //-- collect uri to remove
@@ -655,8 +663,8 @@ export class ModelRepository extends AbstractRepository {
             }
             if (localeUriLocalEntryIds.length) {
                 //-- get all uris and add to remove list
-                const records = await tx
-                    .use(LocaleTranslation)
+                const records = await this.db
+                    .use(LocaleTranslation, tx)
                     .getRecords({ _in: { entryId: localeUriLocalEntryIds } }, { projection: ["translation"] });
                 for (const record of records) {
                     if (record.translation) {
@@ -671,7 +679,7 @@ export class ModelRepository extends AbstractRepository {
                 .filter((id) => !!id);
             //-- remove locale entry, will cascade locale translations
             if (localeEntryIds.length) {
-                await tx.use(LocaleEntry).deleteMany({ _in: { id: localeEntryIds } });
+                await this.db.use(LocaleEntry, tx).deleteMany({ _in: { id: localeEntryIds } });
             }
             //-- remove uris
             if (toBeRemovedUris.length) {
@@ -683,7 +691,7 @@ export class ModelRepository extends AbstractRepository {
             returning = tobeRemoved;
         }
         else {
-            returning = await tx.use(this.model).deleteMany(condition, queries?.returning);
+            returning = await this.db.use(this.model, tx).deleteMany(condition, queries?.returning);
         }
         return { modified: returning };
     }

package/dist/job/AbstractJobRepository.d.ts

@@ -1,18 +1,18 @@
-import { IQueryProvider } from "@clairejs/orm";
-import { CustomJobInfo } from "./interfaces";
+import { type ITransaction } from "@clairejs/orm";
+import { type CustomJobInfo } from "./interfaces";
 export declare abstract class AbstractJobRepository<T extends CustomJobInfo> {
     /**
      * Return all persisted jobs
      */
-    abstract getJobs(query: IQueryProvider): Promise<T[]>;
+    abstract getJobs(): Promise<T[]>;
     /**
      * Save the job info and return a unique id
      * @param jobInfo The custom job info to save
      */
-    abstract saveJob(jobInfo: T, query: IQueryProvider): Promise<string>;
+    abstract saveJob(jobInfo: T, tx?: ITransaction): Promise<string>;
     /**
      * Remove job info by id
      * @param id Unique id of job
      */
-    abstract removeJobById(id: string, query: IQueryProvider): Promise<void>;
+    abstract removeJobById(id: string, tx?: ITransaction): Promise<void>;
 }

package/dist/job/LocalJobScheduler.js

@@ -180,7 +180,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                 }
             }
             //-- re-schedule jobs that are stored in repo
-            const allPersistedJobs = await this.jobRepo.getJobs(this.db);
+            const allPersistedJobs = await this.jobRepo.getJobs();
             //-- run job anyway, expired job will be removed then
             for (const job of allPersistedJobs) {
                 await this.scheduleJob(job);
@@ -205,7 +205,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                         jobName: jobInfo.jobName,
                         params: jobInfo.params,
                         at: jobInfo.at,
-                    }, this.db));
+                    }));
                 //-- use the lib
                 const scheduledJob = { ...jobInfo, id };
                 const timeout = setTimeout(() => {
@@ -256,7 +256,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                 this.jobHolder[id] = undefined;
             }
             //-- remove from persistence
-            await this.jobRepo.removeJobById(id, this.db);
+            await this.jobRepo.removeJobById(id);
         }
         else {
             //-- get unique message id

package/dist/job/default-job-repo.d.ts

@@ -1,11 +1,12 @@
 import { AbstractModel, Constructor } from "@clairejs/core";
-import { IQueryProvider } from "@clairejs/orm";
+import { type ITransaction, AbstractDbAdapter } from "@clairejs/orm";
 import { CustomJobInfo } from "./interfaces";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 export declare class DefaultJobRepository<T extends CustomJobInfo & AbstractModel> extends AbstractJobRepository<T> {
     protected readonly model: Constructor<T>;
-    constructor(model: Constructor<T>);
-    getJobs(query: IQueryProvider): Promise<T[]>;
-    saveJob({ id, ...jobInfo }: T, query: IQueryProvider): Promise<string>;
-    removeJobById(id: string, query: IQueryProvider): Promise<void>;
+    protected db: AbstractDbAdapter;
+    constructor(model: Constructor<T>, db: AbstractDbAdapter);
+    getJobs(): Promise<T[]>;
+    saveJob({ id, ...jobInfo }: T, tx?: ITransaction): Promise<string>;
+    removeJobById(id: string, tx?: ITransaction): Promise<void>;
 }

package/dist/job/default-job-repo.js

@@ -1,27 +1,29 @@
 import { AbstractJobRepository } from "./AbstractJobRepository";
 export class DefaultJobRepository extends AbstractJobRepository {
     model;
-    constructor(model) {
+    db;
+    constructor(model, db) {
         super();
         this.model = model;
+        this.db = db;
     }
-    async getJobs(query) {
-        const jobs = await query.use(this.model).getRecords();
+    async getJobs() {
+        const jobs = await this.db.use(this.model).getRecords();
         return jobs;
     }
-    async saveJob({ id, ...jobInfo }, query) {
+    async saveJob({ id, ...jobInfo }, tx) {
         if (id) {
             //-- update
-            await query.use(this.model).updateById(id, jobInfo);
+            await this.db.use(this.model, tx).updateById(id, jobInfo);
         }
         else {
             //-- create new
-            const job = await query.use(this.model).createOne(jobInfo);
+            const job = await this.db.use(this.model, tx).createOne(jobInfo);
             id = job.id;
         }
         return id;
     }
-    async removeJobById(id, query) {
-        await query.use(this.model).deleteById(id);
+    async removeJobById(id, tx) {
+        await this.db.use(this.model, tx).deleteById(id);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.18.2",
+    "version": "3.19.1",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -34,7 +34,7 @@
     },
     "peerDependencies": {
         "@clairejs/core": "^3.7.9",
-        "@clairejs/orm": "^3.14.0"
+        "@clairejs/orm": "^3.15.0"
     },
     "devDependencies": {
         "@types/cookie-parser": "^1.4.3",