@clairejs/server 3.18.1 → 3.19.0

package/README.md

@@ -1,7 +1,12 @@
 ## Change Log
 
-#### 3.18.1:
+#### 3.19.0:
 
+-   adapt interface with new claire orm
+
+#### 3.18.2:
+
+-   fix multi locale issue with model repo
 -   fix multi locale field data type
 -   adapt claire core & clare orm
 

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,7 @@ export class CrudHttpController extends AbstractHttpController {
     async getMany(req) {
         const result = await this.crudRepository.getMany({
             queries: req.getQuery(),
-            queryProvider: this.databaseAdapter,
+            queryProvider: this.db,
         });
         return ResponseBuilder.json(result).get();
     }

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

@@ -1,5 +1,5 @@
 import { AbstractLogger, AbstractModel, Constructor, CreateManyRequestBody, CreateManyResponseBody, DeepPartial, GetManyQueries, GetManyResponseBody, Identifiable, UpdateManyBody, UpdateManyQueries, UpdateManyResponse } from "@clairejs/core";
-import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
+import { AbstractDbAdapter, IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
 import { IPrincipal } from "../../common/auth/IPrincipal";
 import { AbstractRepository } from "./AbstractRepository";
 import { ICrudRepository } from "./ICrudRepository";
@@ -30,8 +30,9 @@ 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;

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,7 +58,7 @@ 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,
@@ -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,7 +120,7 @@ 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,
@@ -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
@@ -178,7 +180,7 @@ export class DtoRepository extends AbstractRepository {
         }
         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),
@@ -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/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, IQueryProvider, 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;

package/dist/http/repository/ModelRepository.js

@@ -6,10 +6,12 @@ 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
@@ -229,8 +231,7 @@ export class ModelRepository extends AbstractRepository {
             }
         }
         //-- create locale entries
-        const translationEntryData = originalRecords
-            .map((record, index) => {
+        const translationEntryData = originalRecords.flatMap((record, index) => {
             return localeFields
                 .filter((f) => !!record[f.name])
                 .map((f) => ({
@@ -238,29 +239,26 @@ export class ModelRepository extends AbstractRepository {
                 field: f.name,
                 entryObject: {},
             }));
-        })
-            .flatMap((arr) => arr);
-        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
-            .map((record) => {
+        const translationData = originalRecords.flatMap((record) => {
             return localeFields.filter((f) => !!record[f.name]).map((f) => record[f.name]);
-        })
-            .flatMap((arr) => arr);
+        });
         //-- mapping supplied data with entry ids
-        const translations = translationData
-            .map((data, index) => {
-            return Object.keys(data).map((localeCode) => ({
+        const translations = translationData.flatMap((data, index) => {
+            return Object.keys(data)
+                .filter((locale) => locale !== systemLocale)
+                .map((localeCode) => ({
                 localeCode,
                 entryId: translationEntries[index].id,
                 translation: data[localeCode],
             }));
-        })
-            .flatMap((arr) => arr);
+        });
         //-- 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) => {
@@ -282,7 +280,7 @@ 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))
@@ -305,7 +303,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
@@ -343,7 +341,7 @@ export class ModelRepository extends AbstractRepository {
         const localeOfFields = this.modelMetadata.fields.filter((f) => updatedFields.includes(f.name) && f.multiLocaleColumn);
         const cleanUp = await this.uriHandling([body.update]);
         //-- calculate direct update after uri handling
-        const directUpdate = leanData(directUpdateFields.reduce((collector, field) => Object.assign(collector, { [field.name]: body.update[field.name] }), {})) || {};
+        const directUpdate = leanData(Object.fromEntries(directUpdateFields.map((field) => [field.name, body.update[field.name]]))) || {};
         if (systemLocale) {
             //-- override values in record
             for (const field of localeOfFields) {
@@ -366,12 +364,12 @@ 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 {
@@ -381,21 +379,21 @@ 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 }));
             }
         }
         //-- body.update here had been modified by uri handling
-        const records = updatedRecords.map((re) => ({ ...body.update, ...re }));
+        const records = updatedRecords.map((re) => ({ ...body.update, ...directUpdate, ...re }));
         //-- 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
@@ -407,7 +405,7 @@ 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];
@@ -424,7 +422,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];
@@ -442,13 +440,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,
@@ -467,7 +465,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);
@@ -479,7 +477,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 },
@@ -505,7 +503,7 @@ export class ModelRepository extends AbstractRepository {
             //-- return result
             projection = [
                 ...projection,
-                ...Object.keys(body.update).filter((key) => body.update[key] !== undefined),
+                ...Object.keys(directUpdate).filter((key) => directUpdate[key] !== undefined),
                 "lastModified",
             ];
         }
@@ -571,13 +569,13 @@ export class ModelRepository extends AbstractRepository {
                 //-- map back translation
                 if (!queries?.locale) {
                     //-- map as object
-                    const fieldTranslations = translations.filter((t) => t.entryId === record[field.name]);
-                    if (!fieldTranslations.length) {
-                        record[field.name] = {};
-                    }
-                    else {
-                        record[field.name] = fieldTranslations.reduce((collector, t) => Object.assign(collector, { [t.localeCode]: t.translation }), {});
+                    const fieldTranslations = translations
+                        .filter((t) => t.entryId === record[field.name])
+                        .map((t) => [t.localeCode, t.translation]);
+                    if (systemLocale) {
+                        fieldTranslations.push([systemLocale, record[field.multiLocaleColumn]]);
                     }
+                    record[field.name] = Object.fromEntries(fieldTranslations);
                 }
                 else {
                     //-- replace value
@@ -597,7 +595,7 @@ 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({
@@ -631,10 +629,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
@@ -659,8 +657,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) {
@@ -675,7 +673,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) {
@@ -687,7 +685,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.1",
+    "version": "3.19.0",
     "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",