@strapi/database 5.55.1 → 5.57.0

package/dist/entity-manager/index.mjs

@@ -1,4 +1,4 @@
-import { castArray, pick, has, isNull, isEmpty, compact, differenceWith, uniqBy, difference, map, isNil, isPlainObject, isArray, isString, isNumber, isUndefined, isObject, uniqWith, isEqual, isInteger } from 'lodash/fp';
+import { pick, has, isEmpty, compact, differenceWith, uniqBy, difference, map, isPlainObject, isString, isNumber, castArray, isObject, uniqWith, isEqual } from 'lodash';
 import { isScalarAttribute, isRelationalAttribute } from '../utils/types.mjs';
 import { createField } from '../fields/index.mjs';
 import createQueryBuilder from '../query/query-builder.mjs';
@@ -30,7 +30,7 @@ import { relationsOrderer } from './relations-orderer.mjs';
         await qb.execute();
     }
 }
-const isRecord = (value)=>isObject(value) && !isNil(value);
+const isRecord = (value)=>isObject(value) && value != null;
 const toId = (value)=>{
     if (isRecord(value) && 'id' in value && isValidId(value.id)) {
         return value.id;
@@ -41,10 +41,10 @@ const toId = (value)=>{
     throw new Error(`Invalid id, expected a string or integer, got ${JSON.stringify(value)}`);
 };
 const toIds = (value)=>castArray(value || []).map(toId);
-const isValidId = (value)=>isString(value) || isInteger(value);
+const isValidId = (value)=>isString(value) || Number.isInteger(value);
 const isValidObjectId = (value)=>isRecord(value) && 'id' in value && isValidId(value.id);
 const toIdArray = (data)=>{
-    const array = castArray(data).filter((datum)=>!isNil(datum)).map((datum)=>{
+    const array = castArray(data).filter((datum)=>datum != null).map((datum)=>{
         // if it is a string or an integer return an obj with id = to datum
         if (isValidId(datum)) {
             return {
@@ -58,17 +58,17 @@ const toIdArray = (data)=>{
         }
         return datum;
     });
-    return uniqWith(isEqual, array);
+    return uniqWith(array, isEqual);
 };
 const toAssocs = (data)=>{
-    if (isArray(data) || isString(data) || isNumber(data) || isNull(data) || isRecord(data) && 'id' in data) {
+    if (Array.isArray(data) || isString(data) || isNumber(data) || data === null || isRecord(data) && 'id' in data) {
         return {
-            set: isNull(data) ? data : toIdArray(data)
+            set: data === null ? data : toIdArray(data)
         };
     }
     if (data?.set) {
         return {
-            set: isNull(data.set) ? data.set : toIdArray(data.set)
+            set: data.set === null ? data.set : toIdArray(data.set)
         };
     }
     return {
@@ -93,8 +93,8 @@ const processData = (metadata, data = {}, { withDefaults = false } = {})=>{
         const attribute = attributes[attributeName];
         if (isScalarAttribute(attribute)) {
             const field = createField(attribute);
-            if (isUndefined(data[attributeName])) {
-                if (!isUndefined(attribute.default) && withDefaults) {
+            if (data[attributeName] === undefined) {
+                if (attribute.default !== undefined && withDefaults) {
                     if (typeof attribute.default === 'function') {
                         obj[attributeName] = attribute.default();
                     } else {
@@ -114,7 +114,7 @@ const processData = (metadata, data = {}, { withDefaults = false } = {})=>{
             if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner) {
                 const joinColumnName = attribute.joinColumn.name;
                 // allow setting to null
-                let attrValue = !isUndefined(data[attributeName]) ? data[attributeName] : data[joinColumnName];
+                let attrValue = data[attributeName] !== undefined ? data[attributeName] : data[joinColumnName];
                 // Legacy single-column storage: only one id fits. Take the last
                 // and warn — modern schemas use a join table that can hold both
                 // the draft and published rows of the related entry.
@@ -125,9 +125,9 @@ const processData = (metadata, data = {}, { withDefaults = false } = {})=>{
                     }
                     attrValue = setIds.length > 0 ? setIds[setIds.length - 1] : null;
                 }
-                if (isNull(attrValue)) {
+                if (attrValue === null) {
                     obj[joinColumnName] = attrValue;
-                } else if (!isUndefined(attrValue)) {
+                } else if (attrValue !== undefined) {
                     obj[joinColumnName] = toId(attrValue);
                 }
                 continue;
@@ -142,8 +142,8 @@ const processData = (metadata, data = {}, { withDefaults = false } = {})=>{
                     });
                     continue;
                 }
-                if (!isUndefined(value)) {
-                    if (!has('id', value) || !has(typeField, value)) {
+                if (value !== undefined) {
+                    if (!has(value, 'id') || !has(value, typeField)) {
                         throw new Error(`Expects properties ${typeField} an id to make a morph association`);
                     }
                     Object.assign(obj, {
@@ -186,11 +186,11 @@ const createEntityManager = (db)=>{
             const states = await db.lifecycles.run('beforeCount', uid, {
                 params
             });
-            const res = await this.createQueryBuilder(uid).init(pick([
+            const res = await this.createQueryBuilder(uid).init(pick(params, [
                 '_q',
                 'where',
                 'filters'
-            ], params)).count().first().execute();
+            ])).count().first().execute();
             const result = Number(res.count);
             await db.lifecycles.run('afterCount', uid, {
                 params,
@@ -248,7 +248,7 @@ const createEntityManager = (db)=>{
             });
             const metadata = db.metadata.get(uid);
             const { data } = params;
-            if (!isArray(data)) {
+            if (!Array.isArray(data)) {
                 throw new Error('CreateMany expects data to be an array');
             }
             const dataToInsert = data.map((datum)=>processData(metadata, datum, {
@@ -348,11 +348,11 @@ const createEntityManager = (db)=>{
                 throw new Error('Update requires data');
             }
             // Same pick set as count and deleteMany. See deleteMany for why.
-            const updatedRows = await this.createQueryBuilder(uid).init(pick([
+            const updatedRows = await this.createQueryBuilder(uid).init(pick(params, [
                 '_q',
                 'where',
                 'filters'
-            ], params)).update(dataToUpdate).execute({
+            ])).update(dataToUpdate).execute({
                 mapResults: false
             });
             const result = {
@@ -411,11 +411,11 @@ const createEntityManager = (db)=>{
             // Only apply filter criteria (_q / where / filters), same as count — not full findMany params.
             // limit, offset, orderBy, populate, etc. must be ignored: populate throws on delete results,
             // and pagination keys can make deleteMany diverge from findMany or delete an unexpected slice.
-            const deletedRows = await this.createQueryBuilder(uid).init(pick([
+            const deletedRows = await this.createQueryBuilder(uid).init(pick(params, [
                 '_q',
                 'where',
                 'filters'
-            ], params)).delete().execute({
+            ])).delete().execute({
                 mapResults: false
             });
             const result = {
@@ -434,7 +434,7 @@ const createEntityManager = (db)=>{
             const { transaction: trx } = options ?? {};
             for (const attributeName of Object.keys(attributes)){
                 const attribute = attributes[attributeName];
-                const isValidLink = has(attributeName, data) && !isNil(data[attributeName]);
+                const isValidLink = has(data, attributeName) && data[attributeName] != null;
                 if (attribute.type !== 'relation' || !isValidLink) {
                     continue;
                 }
@@ -574,7 +574,7 @@ const createEntityManager = (db)=>{
                         });
                     }
                     // prepare new relations to insert
-                    const insert = uniqBy('id', relsToAdd).map((data)=>{
+                    const insert = uniqBy(relsToAdd, 'id').map((data)=>{
                         return {
                             [joinColumn.name]: id,
                             [inverseJoinColumn.name]: data.id,
@@ -627,7 +627,7 @@ const createEntityManager = (db)=>{
             const { transaction: trx } = options ?? {};
             for (const attributeName of Object.keys(attributes)){
                 const attribute = attributes[attributeName];
-                if (attribute.type !== 'relation' || !has(attributeName, data)) {
+                if (attribute.type !== 'relation' || !has(data, attributeName)) {
                     continue;
                 }
                 const cleanRelationData = toAssocs(data[attributeName]);
@@ -646,7 +646,7 @@ const createEntityManager = (db)=>{
                             [idColumn.name]: id,
                             [typeColumn.name]: uid
                         }).transacting(trx).execute();
-                        if (!isNull(cleanRelationData.set)) {
+                        if (cleanRelationData.set !== null) {
                             const relId = toIds(cleanRelationData.set?.[0]);
                             await this.createQueryBuilder(target).update({
                                 [idColumn.name]: id,
@@ -876,7 +876,7 @@ const createEntityManager = (db)=>{
                     }).update({
                         [attribute.joinColumn.referencedColumn]: null
                     }).transacting(trx).execute();
-                    if (!isNull(cleanRelationData.set)) {
+                    if (cleanRelationData.set !== null) {
                         const relIdsToAdd = toIds(cleanRelationData.set);
                         await this.createQueryBuilder(target).where({
                             id: relIdsToAdd
@@ -899,7 +899,7 @@ const createEntityManager = (db)=>{
                         select.push(inverseOrderColumnName);
                     }
                     // only delete relations
-                    if (isNull(cleanRelationData.set)) {
+                    if (cleanRelationData.set === null) {
                         await deleteRelations({
                             id,
                             attribute,
@@ -908,7 +908,7 @@ const createEntityManager = (db)=>{
                             transaction: trx
                         });
                     } else {
-                        const isPartialUpdate = !has('set', cleanRelationData);
+                        const isPartialUpdate = !has(cleanRelationData, 'set');
                         let relIdsToaddOrMove;
                         if (isPartialUpdate) {
                             if (isAnyToOne(attribute)) ;
@@ -916,7 +916,7 @@ const createEntityManager = (db)=>{
                             // Use id-only comparison so a disconnect item whose id also appears in
                             // the connect array is correctly excluded from deletion (deep-equality
                             // fails because connect items carry extra fields like `position`).
-                            const relIdsToDelete = toIds(differenceWith((a, b)=>a.id === b.id, cleanRelationData.disconnect, cleanRelationData.connect ?? []));
+                            const relIdsToDelete = toIds(differenceWith(cleanRelationData.disconnect, cleanRelationData.connect ?? [], (a, b)=>a.id === b.id));
                             // When a connect item's position.before/after references an id that is
                             // about to be deleted (relIdsToDelete), the referenced row won't exist by
                             // the time the adjacentRelations query runs below, causing sortConnectArray
@@ -1056,7 +1056,7 @@ const createEntityManager = (db)=>{
                                 }).where(joinTable.on || {}).transacting(trx).execute();
                             }
                             // prepare relations to insert
-                            const insert = uniqBy('id', cleanRelationData.connect).map((relToAdd)=>({
+                            const insert = uniqBy(cleanRelationData.connect, 'id').map((relToAdd)=>({
                                     [joinColumn.name]: id,
                                     [inverseJoinColumn.name]: relToAdd.id,
                                     ...joinTable.on,
@@ -1093,7 +1093,7 @@ const createEntityManager = (db)=>{
                             }
                             // add inv order value
                             if (hasInverseOrderColumn(attribute)) {
-                                const nonExistingRelsIds = difference(relIdsToaddOrMove, map(inverseJoinColumn.name, currentMovingRels));
+                                const nonExistingRelsIds = difference(relIdsToaddOrMove, map(currentMovingRels, inverseJoinColumn.name));
                                 const maxResults = await db.getConnection().select(inverseJoinColumn.name).max(inverseOrderColumnName, {
                                     as: 'max'
                                 }).whereIn(inverseJoinColumn.name, nonExistingRelsIds).where(joinTable.on || {}).groupBy(inverseJoinColumn.name).from(joinTable.name).transacting(trx);
@@ -1138,7 +1138,7 @@ const createEntityManager = (db)=>{
                             if (isEmpty(cleanRelationData.set)) {
                                 continue;
                             }
-                            const insert = uniqBy('id', cleanRelationData.set).map((relToAdd)=>({
+                            const insert = uniqBy(cleanRelationData.set, 'id').map((relToAdd)=>({
                                     [joinColumn.name]: id,
                                     [inverseJoinColumn.name]: relToAdd.id,
                                     ...joinTable.on,
@@ -1158,7 +1158,7 @@ const createEntityManager = (db)=>{
                                         $in: relIdsToaddOrMove
                                     }
                                 }).where(joinTable.on || {}).transacting(trx).execute();
-                                const inverseRelsIds = map(inverseJoinColumn.name, existingRels);
+                                const inverseRelsIds = map(existingRels, inverseJoinColumn.name);
                                 const nonExistingRelsIds = difference(relIdsToaddOrMove, inverseRelsIds);
                                 const maxResults = await db.getConnection().select(inverseJoinColumn.name).max(inverseOrderColumnName, {
                                     as: 'max'
@@ -1315,7 +1315,9 @@ const createEntityManager = (db)=>{
         // TODO: add lifecycle events
         async load (uid, entity, fields, populate) {
             const { attributes } = db.metadata.get(uid);
-            const fieldsArr = castArray(fields);
+            const fieldsArr = Array.isArray(fields) ? fields : [
+                fields
+            ];
             fieldsArr.forEach((field)=>{
                 const attribute = attributes[field];
                 if (!attribute || attribute.type !== 'relation') {
@@ -1338,7 +1340,7 @@ const createEntityManager = (db)=>{
                 return null;
             }
             if (Array.isArray(fields)) {
-                return pick(fields, entry);
+                return pick(entry, fields);
             }
             return entry[fields];
         },