@loomcore/api 0.0.32 → 0.0.34

package/dist/__tests__/common-test.utils.d.ts

@@ -1,5 +1,8 @@
 import { Db, ObjectId } from 'mongodb';
-import { IUser, IUserContext } from '@loomcore/common/models';
+import { Application } from 'express';
+import { IUser, IUserContext, IEntity, IAuditable } from '@loomcore/common/models';
+import { GenericApiService } from '../services/generic-api.service.js';
+import { ApiController } from '../controllers/api.controller.js';
 declare function initialize(database: Db): void;
 declare function createIndexes(db: Db): Promise<void>;
 declare function createMetaOrg(): Promise<void>;
@@ -18,6 +21,40 @@ declare function deleteTestUser(): Promise<any[]>;
 declare function simulateloginWithTestUser(): Promise<string>;
 declare function getAuthToken(): string;
 declare function verifyToken(token: string): any;
+export interface ICategory extends IEntity {
+    name: string;
+}
+export interface IProduct extends IEntity, IAuditable {
+    name: string;
+    internalNumber?: string;
+    categoryId: string;
+    category?: ICategory;
+}
+export declare const CategorySchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>;
+export declare const CategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const ProductSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    internalNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    categoryId: import("@sinclair/typebox").TString;
+}>;
+export declare const ProductSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const PublicProductSchema: import("@sinclair/typebox").TObject<{}>;
+export declare class CategoryService extends GenericApiService<ICategory> {
+    constructor(db: Db);
+}
+export declare class CategoryController extends ApiController<ICategory> {
+    constructor(app: Application, db: Db);
+}
+export declare class ProductService extends GenericApiService<IProduct> {
+    constructor(db: Db);
+    protected getAdditionalPipelineStages(): any[];
+    transformSingle(single: any): any;
+}
+export declare class ProductsController extends ApiController<IProduct> {
+    constructor(app: Application, db: Db);
+}
 declare function getTestUser(): Partial<IUser>;
 declare function configureJwtSecret(): void;
 declare function loginWithTestUser(agent: any): Promise<string>;

package/dist/__tests__/common-test.utils.js

@@ -1,9 +1,13 @@
 import { ObjectId } from 'mongodb';
 import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
+import { Type } from '@sinclair/typebox';
 import { JwtService } from '../services/jwt.service.js';
 import { passwordUtils } from '../utils/password.utils.js';
 import { AuthService } from '../services/auth.service.js';
+import { GenericApiService } from '../services/generic-api.service.js';
+import { ApiController } from '../controllers/api.controller.js';
+import { entityUtils } from '@loomcore/common/utils';
 let db;
 let collections = {};
 let deviceIdCookie;
@@ -169,6 +173,71 @@ function getAuthToken() {
 function verifyToken(token) {
     return JwtService.verify(token, JWT_SECRET);
 }
+export const CategorySchema = Type.Object({
+    name: Type.String(),
+});
+export const CategorySpec = entityUtils.getModelSpec(CategorySchema);
+export const ProductSchema = Type.Object({
+    name: Type.String(),
+    internalNumber: Type.Optional(Type.String()),
+    categoryId: Type.String({ format: 'objectid' }),
+});
+export const ProductSpec = entityUtils.getModelSpec(ProductSchema, { isAuditable: true });
+export const PublicProductSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);
+export class CategoryService extends GenericApiService {
+    constructor(db) {
+        super(db, 'categories', 'category', CategorySpec);
+    }
+}
+export class CategoryController extends ApiController {
+    constructor(app, db) {
+        const categoryService = new CategoryService(db);
+        super('categories', app, categoryService, 'category', CategorySpec);
+    }
+}
+export class ProductService extends GenericApiService {
+    constructor(db) {
+        super(db, 'products', 'product', ProductSpec);
+    }
+    getAdditionalPipelineStages() {
+        return [
+            {
+                $lookup: {
+                    from: 'categories',
+                    localField: 'categoryId',
+                    foreignField: '_id',
+                    as: 'category'
+                }
+            },
+            {
+                $unwind: {
+                    path: '$category',
+                    preserveNullAndEmptyArrays: true
+                }
+            }
+        ];
+    }
+    transformSingle(single) {
+        if (single && single.category) {
+            const categoryService = new CategoryService(this.db);
+            single.category = categoryService.transformSingle(single.category);
+        }
+        return super.transformSingle(single);
+    }
+}
+export class ProductsController extends ApiController {
+    constructor(app, db) {
+        const productService = new ProductService(db);
+        const AggregatedProductSchema = Type.Intersect([
+            ProductSpec.fullSchema,
+            Type.Partial(Type.Object({
+                category: CategorySpec.fullSchema
+            }))
+        ]);
+        const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, ['internalNumber']);
+        super('products', app, productService, 'product', ProductSpec, PublicAggregatedProductSchema);
+    }
+}
 function getTestUser() {
     return testUser;
 }

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

@@ -129,7 +129,10 @@ export class GenericApiService {
         const query = this.prepareQuery(userContext, baseQuery);
         let entity = null;
         if (this.getAdditionalPipelineStages().length > 0) {
-            const pipeline = this.createAggregationPipeline(userContext, query);
+            const pipeline = [
+                { $match: query },
+                ...this.getAdditionalPipelineStages()
+            ];
             entity = await this.collection.aggregate(pipeline).next();
         }
         else {

package/dist/utils/api.utils.js

@@ -1,18 +1,20 @@
+import { entityUtils } from '@loomcore/common/utils';
 import { DefaultQueryOptions } from '@loomcore/common/models';
 function apiResponse(response, status, options = {}, modelSpec, publicSchema) {
     const success = status >= 200 && status < 300;
     let apiResponse;
-    if (modelSpec && options.data) {
+    const specForEncoding = publicSchema ? entityUtils.getModelSpec(publicSchema) : modelSpec;
+    if (specForEncoding && options.data) {
         if (Array.isArray(options.data)) {
-            options.data = options.data.map((item) => modelSpec.encode(item, publicSchema));
+            options.data = options.data.map((item) => specForEncoding.encode(item));
         }
         else if (typeof options.data === 'object' && options.data !== null && 'entities' in options.data && Array.isArray(options.data.entities)) {
             const pagedResult = options.data;
-            pagedResult.entities = pagedResult.entities.map((item) => modelSpec.encode(item, publicSchema));
+            pagedResult.entities = pagedResult.entities.map((item) => specForEncoding.encode(item));
             options.data = pagedResult;
         }
         else {
-            options.data = modelSpec.encode(options.data, publicSchema);
+            options.data = specForEncoding.encode(options.data);
         }
     }
     if (success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {