@strapi/database 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/index.js

@@ -2298,13 +2298,9 @@ const createManyToMany = (attributeName, attribute, meta, metadata) => {
 const createMorphToOne = (attributeName, attribute) => {
   const idColumnName = identifiers.getJoinColumnAttributeIdName("target");
   const typeColumnName = identifiers.getMorphColumnTypeName("target");
-  if ("morphColumn" in attribute && attribute.morphColumn) {
-    return;
-  }
   Object.assign(attribute, {
     owner: true,
-    morphColumn: {
-      // TODO: add referenced column
+    morphColumn: attribute.morphColumn ?? {
       typeColumn: {
         name: typeColumnName
       },
@@ -3066,11 +3062,54 @@ const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
   return subAlias;
 };
 const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
-  const { db, qb } = ctx;
+  const { db, qb, uid } = ctx;
   if (attribute.type !== "relation") {
     throw new Error(`Cannot join on non relational field ${attributeName}`);
   }
   const targetMeta = db.metadata.get(attribute.target);
+  if (["morphOne", "morphMany"].includes(attribute.relation)) {
+    const targetAttribute = targetMeta.attributes[attribute.morphBy];
+    const { joinTable: joinTable2, morphColumn } = targetAttribute;
+    if (morphColumn) {
+      const subAlias = refAlias || qb.getAlias();
+      qb.join({
+        alias: subAlias,
+        referencedTable: targetMeta.tableName,
+        referencedColumn: morphColumn.idColumn.name,
+        rootColumn: morphColumn.idColumn.referencedColumn,
+        rootTable: alias,
+        on: {
+          [morphColumn.typeColumn.name]: uid,
+          ...morphColumn.on
+        }
+      });
+      return subAlias;
+    }
+    if (joinTable2) {
+      const joinAlias = qb.getAlias();
+      qb.join({
+        alias: joinAlias,
+        referencedTable: joinTable2.name,
+        referencedColumn: joinTable2.morphColumn.idColumn.name,
+        rootColumn: joinTable2.morphColumn.idColumn.referencedColumn,
+        rootTable: alias,
+        on: {
+          [joinTable2.morphColumn.typeColumn.name]: uid,
+          field: attributeName
+        }
+      });
+      const subAlias = refAlias || qb.getAlias();
+      qb.join({
+        alias: subAlias,
+        referencedTable: targetMeta.tableName,
+        referencedColumn: joinTable2.joinColumn.referencedColumn,
+        rootColumn: joinTable2.joinColumn.name,
+        rootTable: joinAlias
+      });
+      return subAlias;
+    }
+    return alias;
+  }
   const { joinColumn } = attribute;
   if (joinColumn) {
     const subAlias = refAlias || qb.getAlias();
@@ -3729,6 +3768,28 @@ const processNested = (where, ctx) => {
   }
   return processWhere(where, ctx);
 };
+const processRelationWhere = (where, ctx) => {
+  const { qb, alias } = ctx;
+  const idAlias = qb.aliasColumn("id", alias);
+  if (!isRecord$1(where)) {
+    return { [idAlias]: where };
+  }
+  const keys = Object.keys(where);
+  const operatorKeys = keys.filter((key) => utils.isOperator(key));
+  if (operatorKeys.length > 0 && operatorKeys.length !== keys.length) {
+    throw new Error(`Operator and non-operator keys cannot be mixed in a relation where clause`);
+  }
+  if (operatorKeys.length > 1) {
+    throw new Error(
+      `Only one operator key is allowed in a relation where clause, but found: ${operatorKeys}`
+    );
+  }
+  if (operatorKeys.length === 1) {
+    const operator = operatorKeys[0];
+    return { [idAlias]: { [operator]: processNested(where[operator], ctx) } };
+  }
+  return processWhere(where, ctx);
+};
 function processWhere(where, ctx) {
   if (!_.isArray(where) && !isRecord$1(where)) {
     throw new Error("Where must be an array or an object");
@@ -3741,7 +3802,10 @@ function processWhere(where, ctx) {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (utils.isOperatorOfType("group", key) && Array.isArray(value)) {
+    if (utils.isOperatorOfType("group", key)) {
+      if (!Array.isArray(value)) {
+        throw new Error(`Operator ${key} must be an array`);
+      }
       filters[key] = value.map((sub) => processNested(sub, ctx));
       continue;
     }
@@ -3765,15 +3829,12 @@ function processWhere(where, ctx) {
         attributeName: key,
         attribute
       });
-      let nestedWhere = processNested(value, {
+      const nestedWhere = processRelationWhere(value, {
         db,
         qb,
         alias: subAlias,
         uid: attribute.target
       });
-      if (!isRecord$1(nestedWhere) || utils.isOperatorOfType("where", _.keys(nestedWhere)[0])) {
-        nestedWhere = { [qb.aliasColumn("id", subAlias)]: nestedWhere };
-      }
       Object.assign(filters, nestedWhere);
       continue;
     }
@@ -3926,8 +3987,8 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
     }
     return qb.where(column, columnWhere);
   }
-  const keys2 = Object.keys(columnWhere);
-  keys2.forEach((operator) => {
+  const keys = Object.keys(columnWhere);
+  keys.forEach((operator) => {
     const value = columnWhere[operator];
     applyOperator(qb, column, operator, value);
   });