@loomcore/api 0.0.52 → 0.0.54

package/dist/controllers/api.controller.js

@@ -52,10 +52,8 @@ export class ApiController {
         apiUtils.apiResponse(res, 200, { data: pagedResult }, this.modelSpec, this.publicSchema);
     }
     async getById(req, res, next) {
-        console.log('Starting getById, id:', req.params?.id);
         let id = req.params?.id;
         res.set('Content-Type', 'application/json');
-        console.log('Calling this.service.getById()');
         const entity = await this.service.getById(req.userContext, id);
         apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSchema);
     }

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

@@ -73,7 +73,6 @@ export class GenericApiService {
         return pipeline;
     }
     async getAll(userContext) {
-        console.log('In GenericApiService.getAll');
         const query = this.prepareQuery(userContext, {});
         let entities = [];
         if (this.getAdditionalPipelineStages().length > 0) {
@@ -87,9 +86,8 @@ export class GenericApiService {
         return this.transformList(entities);
     }
     async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
-        console.log('In GenericApiService.get');
         const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
-        const match = dbUtils.buildMongoMatchFromQueryOptions(preparedOptions);
+        const match = dbUtils.buildMongoMatchFromQueryOptions(preparedOptions, this.modelSpec);
         const additionalStages = this.getAdditionalPipelineStages();
         const results = [...additionalStages];
         if (preparedOptions.orderBy) {
@@ -124,35 +122,25 @@ export class GenericApiService {
         return pagedResult;
     }
     async getById(userContext, id) {
-        console.log(`--- GenericApiService.getById ENTER ---`);
-        console.log(`ID received: ${id}`);
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        console.log('Constructed query:', JSON.stringify(query, null, 2));
         let entity = null;
         if (this.getAdditionalPipelineStages().length > 0) {
-            console.log('Branch: Executing with aggregation pipeline.');
             const pipeline = [
                 { $match: query },
                 ...this.getAdditionalPipelineStages()
             ];
-            console.log('Aggregation Pipeline:', JSON.stringify(pipeline, null, 2));
             entity = await this.collection.aggregate(pipeline).next();
         }
         else {
-            console.log('Branch: Executing with findOne.');
             entity = await this.collection.findOne(query);
         }
-        console.log('IMMEDIATE DB RESULT (entity):', JSON.stringify(entity, null, 2));
         if (!entity) {
-            console.log('Entity not found, throwing IdNotFoundError.');
             throw new IdNotFoundError();
         }
-        console.log('Entity before transformSingle:', JSON.stringify(entity, null, 2));
-        console.log(`--- GenericApiService.getById EXIT ---`);
         return this.transformSingle(entity);
     }
     async getCount(userContext) {
@@ -373,14 +361,12 @@ export class GenericApiService {
         return list.map(item => this.transformSingle(item));
     }
     transformSingle(single) {
-        console.log('Starting base class transformSingle, entity:', JSON.stringify(single, null, 2));
         if (!single)
             return single;
         if (!this.modelSpec?.fullSchema) {
             throw new ServerError(`Cannot transform entity: No model specification with schema provided for ${this.pluralResourceName}`);
         }
         const transformedEntity = dbUtils.convertObjectIdsToStrings(single, this.modelSpec.fullSchema);
-        console.log('Leaving base class transformSingle, transformedEntity:', JSON.stringify(transformedEntity, null, 2));
         return transformedEntity;
     }
     stripSenderProvidedSystemProperties(userContext, doc, allowId = false) {

package/dist/utils/db.utils.d.ts

@@ -1,11 +1,11 @@
 import { ObjectId } from 'mongodb';
 import { TSchema } from '@sinclair/typebox';
-import { IQueryOptions, Filter } from '@loomcore/common/models';
+import { IQueryOptions, Filter, IModelSpec } from '@loomcore/common/models';
 export declare const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS: string[];
 declare function convertObjectIdsToStrings<T>(entity: T, schema?: TSchema): T;
 declare function convertStringsToObjectIds(entity: any, schema: TSchema): any;
 declare function convertStringToObjectId(value: any): ObjectId | any;
-declare function buildMongoMatchFromQueryOptions(queryOptions: IQueryOptions): {
+declare function buildMongoMatchFromQueryOptions(queryOptions: IQueryOptions, modelSpec?: IModelSpec): {
     $match: any;
 };
 declare function buildSQLWhereClauseFromQueryOptions(queryOptions: IQueryOptions, columnAliasMap: {

package/dist/utils/db.utils.js

@@ -2,6 +2,21 @@ import { ObjectId } from 'mongodb';
 import _ from 'lodash';
 import { entityUtils } from '@loomcore/common/utils';
 import { stringUtils } from './string.utils.js';
+function getPropertySchema(key, schema) {
+    if (!schema || typeof schema !== 'object')
+        return undefined;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+        for (const nestedSchema of schema.allOf) {
+            const propSchema = getPropertySchema(key, nestedSchema);
+            if (propSchema)
+                return propSchema;
+        }
+    }
+    if (schema.type === 'object' && schema.properties) {
+        return schema.properties[key];
+    }
+    return undefined;
+}
 export const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS = ['_orgId'];
 function convertObjectIdsToStrings(entity, schema) {
     if (!entity)
@@ -149,27 +164,30 @@ function convertStringToObjectId(value) {
     }
     return value;
 }
-function buildMongoMatchFromQueryOptions(queryOptions) {
+function buildMongoMatchFromQueryOptions(queryOptions, modelSpec) {
     const filters = queryOptions.filters || {};
+    const schema = modelSpec?.fullSchema;
     let match = {};
     for (const [key, value] of Object.entries(filters)) {
         if (value) {
+            const propSchema = schema ? getPropertySchema(key, schema) : undefined;
             if (value.eq !== undefined) {
-                if (typeof value.eq === 'string'
-                    && key.endsWith('Id')
-                    && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)
-                    && entityUtils.isValidObjectId(value.eq)) {
-                    match[key] = new ObjectId(value.eq);
+                const isObjectIdField = propSchema?.format === 'objectid';
+                const valueToCompare = value.eq;
+                if ((isObjectIdField || (!schema && key.endsWith('Id') && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)))
+                    && typeof valueToCompare === 'string' && entityUtils.isValidObjectId(valueToCompare)) {
+                    match[key] = new ObjectId(valueToCompare);
                 }
-                else if (typeof value.eq === 'string' && !isNaN(Number(value.eq))) {
-                    match[key] = Number(value.eq);
+                else if (typeof valueToCompare === 'string' && !isNaN(Number(valueToCompare))) {
+                    match[key] = Number(valueToCompare);
                 }
                 else {
-                    match[key] = value.eq;
+                    match[key] = valueToCompare;
                 }
             }
             else if (value.in !== undefined && Array.isArray(value.in)) {
-                if (key.endsWith('Id') && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
+                const isObjectIdArray = propSchema?.type === 'array' && propSchema.items?.format === 'objectid';
+                if (isObjectIdArray || (!schema && (key.endsWith('Id') || key.endsWith('Ids')) && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key))) {
                     const objectIds = value.in
                         .filter(val => typeof val === 'string' && entityUtils.isValidObjectId(val))
                         .map(val => new ObjectId(val));

package/package.json

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