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

package/dist/index.mjs

@@ -1,11 +1,11 @@
 import path from "path";
 import fse from "fs-extra";
 import createDebug from "debug";
-import _, { isNil, castArray, prop, omit, isInteger, snakeCase, partition, sumBy, cloneDeep, toString, toNumber, isString as isString$1, padCharsEnd, isArray, keys, isPlainObject, isFinite, groupBy, pipe, mapValues, map, isEmpty, maxBy, pick, has, uniqBy, isNull, differenceWith, isEqual, compact, difference, isObject, isNumber as isNumber$1, isUndefined, uniqWith } from "lodash/fp";
+import _, { isNil, castArray, prop, omit, isInteger, snakeCase, partition, sumBy, cloneDeep, toString, toNumber, isString as isString$1, padCharsEnd, isArray, isPlainObject, isFinite, groupBy, pipe, mapValues, map, isEmpty, maxBy, pick, has, uniqBy, isNull, differenceWith, isEqual, compact, difference, isObject, isNumber as isNumber$1, isUndefined, uniqWith } from "lodash/fp";
 import crypto from "crypto";
 import crypto$1 from "node:crypto";
 import * as dateFns from "date-fns";
-import { isOperatorOfType } from "@strapi/utils";
+import { isOperatorOfType, isOperator } from "@strapi/utils";
 import KnexBuilder from "knex/lib/query/querybuilder";
 import KnexRaw from "knex/lib/raw";
 import { Readable } from "stream";
@@ -2266,13 +2266,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
       },
@@ -3034,11 +3030,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();
@@ -3697,6 +3736,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) => 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");
@@ -3709,7 +3770,10 @@ function processWhere(where, ctx) {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (isOperatorOfType("group", key) && Array.isArray(value)) {
+    if (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;
     }
@@ -3733,15 +3797,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) || isOperatorOfType("where", keys(nestedWhere)[0])) {
-        nestedWhere = { [qb.aliasColumn("id", subAlias)]: nestedWhere };
-      }
       Object.assign(filters, nestedWhere);
       continue;
     }
@@ -3894,8 +3955,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);
   });