fix: some fixes after rebasing with master

Author: gsi-alejandro

__test__/query-array.spec.ts

@@ -13,7 +13,6 @@ describe('Query Builder Array', () => {
   });
 
   test('Basics', async () => {
-    set('DEBUG', true);
     const House = model('House', houseSchema);
     await startInTest(getDefaultInstance());
 
@@ -27,13 +26,12 @@ describe('Query Builder Array', () => {
     const filter = {
       title: 'Beach House',
       $any: {
-        $expr: [{ search: 'numbers' }],
-        $satisfies: { search: { $in: [10] } },
+        $expr: [{ search: { $in: 'numbers' } }],
+        $satisfies: { search: 10 },
       },
     };
 
     const results = await House.find(filter, { consistency: SearchConsistency.LOCAL });
-    console.log(results);
     expect(results.rows.length).toBeGreaterThanOrEqual(1);
   });
 });

src/model/create-model.ts

@@ -1,5 +1,5 @@
 import { DocumentNotFoundError, DropCollectionOptions } from 'couchbase';
-import { Query, SearchConsistency, setValueByPath } from '..';
+import { getValueByPath, Query, SearchConsistency, setValueByPath } from '..';
 import { BuildIndexQueryError, OttomanError } from '../exceptions/ottoman-errors';
 import { createMany, find, FindOptions, ManyQueryResponse, removeMany, updateMany } from '../handler';
 import { FindByIdOptions, IFindOptions } from '../handler/';
@@ -104,7 +104,7 @@ export const _buildModel = (metadata: ModelMetadata) => {
       super(data);
       const strategy = options.strategy || CAST_STRATEGY.DEFAULT_OR_DROP;
       const strict = options.strict !== undefined ? options.strict : schema.options.strict;
-      const skip = options.skip || [modelKey, ID_KEY];
+      const skip = options.skip || [modelKey.split('.')[0], ID_KEY];
       const schemaData = cast(data, schema, { strategy, strict, skip });
 
       this._applyData(schemaData, strategy === CAST_STRATEGY.THROW ? CAST_STRATEGY.THROW : true);
@@ -186,16 +186,27 @@ export const _buildModel = (metadata: ModelMetadata) => {
 
     static findById = async (id: string, options: FindByIdOptions = {}): Promise<Model | Record<string, unknown>> => {
       const { populate, populateMaxDeep: deep, select, lean, enforceRefCheck = false, ...findOptions } = options;
+      const modelKeyClean = modelKey.split('.')[0];
+      let isModelKeyAddedToSelect = false;
       if (select) {
-        findOptions['project'] = extractSelect(select, { noCollection: true }, false, modelKey);
+        const selectArray = typeof select === 'string' ? select.split(',').map((x) => x.trim()) : select;
+        if (selectArray.findIndex((x) => x === modelKeyClean) === -1) {
+          selectArray.push(modelKeyClean);
+          isModelKeyAddedToSelect = true;
+        }
+        findOptions['project'] = extractSelect(selectArray, { noCollection: true }, false, modelKey.split('.')[0]);
       }
       const key = _keyGenerator!(keyGenerator, { metadata, id }, keyGeneratorDelimiter);
       const { value: pojo } = await collection().get(key, findOptions);
 
-      if (pojo[metadata.modelKey] !== metadata.modelName) {
+      if (getValueByPath(pojo, metadata.modelKey) !== metadata.modelName) {
         throw new DocumentNotFoundError();
       }
 
+      if (isModelKeyAddedToSelect) {
+        delete pojo[modelKeyClean];
+      }
+
       if (populate) {
         return getPopulated({ fieldsName: populate, deep, lean, pojo, schema, modelName, ottoman, enforceRefCheck });
       }

src/model/utils/model.utils.ts

@@ -62,10 +62,13 @@ export const getPopulated = async (options: PopulateAuxOptionsType): Promise<Mod
         const current = fieldsName?.[field];
         let select: string | string[] = '';
         if (isObject && current !== '*' && current?.select !== '*') {
-          select =
-            typeof current === 'string' || Array.isArray(current)
-              ? current
-              : extractPopulateFieldsFromObject(current) ?? '';
+          if (typeof current === 'string') {
+            select = current;
+          } else if (Array.isArray(current)) {
+            select = current.join(',');
+          } else {
+            select = extractPopulateFieldsFromObject(current) ?? '';
+          }
         }
 
         const populate = populateMaxDeep === 0 ? undefined : current?.populate ?? current ?? '*';

src/model/utils/store-life-cycle.ts

@@ -20,7 +20,7 @@ export const storeLifeCycle = async ({ key, id, data, options, metadata, refKeys
   document = validate(document, schema, {
     strict: schema.options.strict,
     strategy: CAST_STRATEGY.THROW,
-    skip: [modelKey, ID_KEY],
+    skip: [modelKey.split('.')[0], ID_KEY],
   });
 
   // enforceRefCheck logic

src/schema/schema.ts

@@ -200,9 +200,17 @@ export class Schema {
     for (const key in this.fields) {
       const field = this.fields[key];
       if (typeof obj[field.name] === 'undefined' && field instanceof CoreType) {
-        const _val = field.buildDefault();
-        if (typeof _val !== 'undefined') {
-          obj[field.name] = _val;
+        if (field instanceof EmbedType) {
+          const _val = {};
+          (field as EmbedType).schema.applyDefaultsToObject(_val);
+          if (Object.keys(_val).length > 0) {
+            obj[field.name] = _val;
+          }
+        } else {
+          const _val = field.buildDefault();
+          if (typeof _val !== 'undefined') {
+            obj[field.name] = _val;
+          }
         }
       }
     }