@loomcore/api 0.0.24 → 0.0.25

package/dist/services/generic-api-service.interface.d.ts

@@ -1,6 +1,6 @@
-import { DeleteResult, Document, FindOptions } from 'mongodb';
+import { DeleteResult } from 'mongodb';
 import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, IPagedResult, QueryOptions } from '@loomcore/common/models';
+import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
 export interface IGenericApiService<T extends IEntity> {
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
@@ -9,17 +9,17 @@ export interface IGenericApiService<T extends IEntity> {
     prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     getAll(userContext: IUserContext): Promise<T[]>;
-    get(userContext: IUserContext, queryOptions: QueryOptions): Promise<IPagedResult<T>>;
+    get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
-    create(userContext: IUserContext, item: T): Promise<T | null>;
-    createMany(userContext: IUserContext, items: T[]): Promise<T[]>;
-    fullUpdateById(userContext: IUserContext, id: string, item: T): Promise<T>;
-    partialUpdateById(userContext: IUserContext, id: string, item: Partial<T>): Promise<T>;
-    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, item: Partial<T>): Promise<T>;
-    update(userContext: IUserContext, queryObject: any, item: Partial<T>): Promise<T[]>;
+    create(userContext: IUserContext, entity: T | Partial<T>): Promise<T | null>;
+    createMany(userContext: IUserContext, entities: T[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    update(userContext: IUserContext, queryObject: any, entity: Partial<T>): Promise<T[]>;
     deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
     deleteMany(userContext: IUserContext, queryObject: any): Promise<DeleteResult>;
-    find(userContext: IUserContext, mongoQueryObject: any, options?: FindOptions<Document> | undefined): Promise<T[]>;
-    findOne(userContext: IUserContext, mongoQueryObject: any, options?: FindOptions<Document> | undefined): Promise<T>;
+    find(userContext: IUserContext, mongoQueryObject: any, options?: any): Promise<T[]>;
+    findOne(userContext: IUserContext, mongoQueryObject: any, options?: any): Promise<T>;
 }

package/dist/services/generic-api.service.d.ts

@@ -1,6 +1,6 @@
 import { Db, Collection, DeleteResult, Document, FindOptions } from 'mongodb';
 import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, QueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import { IUserContext, IEntity, IQueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
 import { IGenericApiService } from './generic-api-service.interface.js';
 export declare class GenericApiService<T extends IEntity> implements IGenericApiService<T> {
     protected db: Db;
@@ -12,9 +12,9 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
     protected getAdditionalPipelineStages(): any[];
-    protected createAggregationPipeline(userContext: IUserContext, query: any, queryOptions?: QueryOptions): any[];
+    protected createAggregationPipeline(userContext: IUserContext, query: any, queryOptions?: IQueryOptions): any[];
     getAll(userContext: IUserContext): Promise<T[]>;
-    get(userContext: IUserContext, queryOptions?: QueryOptions): Promise<IPagedResult<T>>;
+    get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: T | Partial<T>): Promise<T | null>;
@@ -44,5 +44,5 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean): Promise<T | Partial<T>>;
     protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
-    protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: QueryOptions): QueryOptions;
+    protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
 }

package/dist/services/generic-api.service.js

@@ -1,7 +1,7 @@
 import { ObjectId } from 'mongodb';
 import moment from 'moment';
 import _ from 'lodash';
-import { QueryOptions } from '@loomcore/common/models';
+import { DefaultQueryOptions } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, DuplicateKeyError, IdNotFoundError, NotFoundError, ServerError } from '../errors/index.js';
 import { apiUtils, dbUtils } from '../utils/index.js';
@@ -43,23 +43,34 @@ export class GenericApiService {
         return [];
     }
     createAggregationPipeline(userContext, query, queryOptions) {
-        const match = { $match: query };
-        const additionalStages = this.getAdditionalPipelineStages();
-        let resultStages = [...additionalStages];
-        if (queryOptions) {
-            if (queryOptions.orderBy) {
-                resultStages.push({
-                    $sort: {
-                        [queryOptions.orderBy]: queryOptions.sortDirection === 'asc' ? 1 : -1
-                    }
-                });
-            }
-            if (queryOptions.page && queryOptions.pageSize) {
-                resultStages.push({ $skip: (queryOptions.page - 1) * queryOptions.pageSize });
-                resultStages.push({ $limit: queryOptions.pageSize });
-            }
-        }
-        return [match, ...resultStages];
+        const pipeline = [
+            { $match: query },
+            { $facet: {
+                    data: (() => {
+                        const resultStages = [];
+                        if (queryOptions) {
+                            if (queryOptions.orderBy) {
+                                resultStages.push({
+                                    $sort: {
+                                        [queryOptions.orderBy]: queryOptions.sortDirection === 'asc' ? 1 : -1
+                                    }
+                                });
+                            }
+                            if (queryOptions.page && queryOptions.pageSize) {
+                                resultStages.push({ $skip: (queryOptions.page - 1) * queryOptions.pageSize });
+                                resultStages.push({ $limit: queryOptions.pageSize });
+                            }
+                        }
+                        return resultStages;
+                    })(),
+                    count: [{ $count: 'total' }]
+                } },
+            { $project: {
+                    data: 1,
+                    total: { $arrayElemAt: ['$count.total', 0] }
+                } }
+        ];
+        return pipeline;
     }
     async getAll(userContext) {
         const query = this.prepareQuery(userContext, {});
@@ -74,7 +85,7 @@ export class GenericApiService {
         }
         return this.transformList(entities);
     }
-    async get(userContext, queryOptions = new QueryOptions()) {
+    async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
         const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
         const match = dbUtils.buildMongoMatchFromQueryOptions(preparedOptions);
         const additionalStages = this.getAdditionalPipelineStages();

package/dist/services/multi-tenant-api.service.d.ts

@@ -1,10 +1,10 @@
 import { Db } from 'mongodb';
-import { IUserContext, IEntity, QueryOptions, IModelSpec } from '@loomcore/common/models';
+import { IUserContext, IEntity, IQueryOptions, IModelSpec } from '@loomcore/common/models';
 import { GenericApiService } from './generic-api.service.js';
 export declare class MultiTenantApiService<T extends IEntity> extends GenericApiService<T> {
     private tenantDecorator?;
     constructor(db: Db, pluralResourceName: string, singularResourceName: string, modelSpec?: IModelSpec);
     protected prepareQuery(userContext: IUserContext, query: any): any;
-    protected prepareQueryOptions(userContext: IUserContext, queryOptions: QueryOptions): QueryOptions;
+    protected prepareQueryOptions(userContext: IUserContext, queryOptions: IQueryOptions): IQueryOptions;
     protected prepareEntity(userContext: IUserContext, entity: T, isCreate: boolean): Promise<T | Partial<T>>;
 }

package/dist/services/tenant-query-decorator.d.ts

@@ -1,4 +1,4 @@
-import { IUserContext, QueryOptions, IEntity } from '@loomcore/common/models';
+import { IUserContext, IQueryOptions, IEntity } from '@loomcore/common/models';
 export interface ITenantQueryOptions {
     orgIdField?: string;
     excludedCollections?: string[];
@@ -8,7 +8,7 @@ export declare class TenantQueryDecorator {
     private options;
     constructor(options?: Partial<ITenantQueryOptions>);
     applyTenantToQuery(userContext: IUserContext, queryObject: any, collectionName: string): any;
-    applyTenantToQueryOptions(userContext: IUserContext, queryOptions: QueryOptions, collectionName: string): QueryOptions;
+    applyTenantToQueryOptions(userContext: IUserContext, queryOptions: IQueryOptions, collectionName: string): IQueryOptions;
     applyTenantToEntity<T extends IEntity>(userContext: IUserContext, entity: T, collectionName: string): T;
     getOrgIdField(): string;
 }

package/dist/services/tenant-query-decorator.js

@@ -1,4 +1,3 @@
-import { QueryOptions } from '@loomcore/common/models';
 import { ServerError } from '../errors/index.js';
 export const DEFAULT_TENANT_OPTIONS = {
     orgIdField: '_orgId',
@@ -25,20 +24,17 @@ export class TenantQueryDecorator {
         return result;
     }
     applyTenantToQueryOptions(userContext, queryOptions, collectionName) {
-        let result = queryOptions;
-        const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
-            userContext?._orgId;
+        const result = { ...queryOptions };
+        const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName);
         if (shouldApplyTenantFilter) {
-            const modifiedQueryOptions = new QueryOptions(queryOptions);
-            if (!modifiedQueryOptions.filters) {
-                modifiedQueryOptions.filters = {};
+            if (!userContext._orgId) {
+                throw new ServerError('userContext must have an _orgId property to apply tenant filtering');
             }
-            const orgIdField = this.options.orgIdField || '_orgId';
-            modifiedQueryOptions.filters[orgIdField] = { eq: userContext._orgId };
-            result = modifiedQueryOptions;
-        }
-        else if (!userContext?._orgId) {
-            throw new ServerError('No _orgId found in userContext');
+            if (!result.filters) {
+                result.filters = {};
+            }
+            const orgIdField = this.getOrgIdField();
+            result.filters[orgIdField] = { eq: userContext._orgId };
         }
         return result;
     }

package/dist/utils/api.utils.d.ts

@@ -1,14 +1,14 @@
 import { Request, Response } from 'express';
 import { TSchema } from '@sinclair/typebox';
-import { IError, QueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import { IQueryOptions, IError, IPagedResult, IModelSpec } from '@loomcore/common/models';
 export interface IApiResponseOptions<T> {
     messages?: string[];
     errors?: IError[];
     data?: T;
 }
 declare function apiResponse<T>(response: Response, status: number, options?: IApiResponseOptions<T>, modelSpec?: IModelSpec, publicSchema?: TSchema): Response;
-declare function getQueryOptionsFromRequest(request: Request): QueryOptions;
-declare function getPagedResult<T>(entities: T[], totalRows: number, queryOptions: QueryOptions): IPagedResult<T>;
+declare function getQueryOptionsFromRequest(request: Request): IQueryOptions;
+declare function getPagedResult<T>(entities: T[], totalRows: number, queryOptions: IQueryOptions): IPagedResult<T>;
 export declare const apiUtils: {
     apiResponse: typeof apiResponse;
     getQueryOptionsFromRequest: typeof getQueryOptionsFromRequest;

package/dist/utils/api.utils.js

@@ -1,4 +1,4 @@
-import { QueryOptions } from '@loomcore/common/models';
+import { DefaultQueryOptions } from '@loomcore/common/models';
 function apiResponse(response, status, options = {}, modelSpec, publicSchema) {
     const success = status >= 200 && status < 300;
     let apiResponse;
@@ -35,21 +35,22 @@ function apiResponse(response, status, options = {}, modelSpec, publicSchema) {
 }
 function getQueryOptionsFromRequest(request) {
     const queryOptions = {
+        ...DefaultQueryOptions,
         orderBy: request.query.orderBy,
         sortDirection: request.query.sortDirection,
-        page: request.query.page ? parseInt(request.query.page) : 1,
-        pageSize: request.query.pageSize ? parseInt(request.query.pageSize) : 100,
+        page: request.query.page ? parseInt(request.query.page) : DefaultQueryOptions.page,
+        pageSize: request.query.pageSize ? parseInt(request.query.pageSize) : DefaultQueryOptions.pageSize,
         filters: request.query.filters
     };
-    return new QueryOptions(queryOptions);
+    return queryOptions;
 }
 function getPagedResult(entities, totalRows, queryOptions) {
     const pagedResult = {
         entities,
         total: totalRows,
-        page: queryOptions.page,
-        pageSize: queryOptions.pageSize,
-        totalPages: Math.ceil(totalRows / queryOptions.pageSize),
+        page: queryOptions.page || DefaultQueryOptions.page,
+        pageSize: queryOptions.pageSize || DefaultQueryOptions.pageSize,
+        totalPages: Math.ceil(totalRows / (queryOptions.pageSize || DefaultQueryOptions.pageSize)),
     };
     return pagedResult;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -44,7 +44,7 @@
     "jsonwebtoken": "^9.0.2"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.12",
+    "@loomcore/common": "^0.0.13",
     "@sinclair/typebox": "^0.34.31",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",