@strapi/database 4.2.1-alpha.0 → 4.3.0-beta.2

package/lib/dialects/mysql/schema-inspector.js

@@ -26,19 +26,32 @@ const SQL_QUERIES = {
   `,
   FOREIGN_KEY_LIST: /* sql */ `
     SELECT
-      tc.constraint_name as constraint_name,
+      tc.constraint_name as constraint_name
+    FROM information_schema.table_constraints tc
+    WHERE tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = database()
+    AND tc.table_name = ?;
+  `,
+  FOREIGN_KEY_REFERENCES: /* sql */ `
+    SELECT
+      kcu.constraint_name as constraint_name,
       kcu.column_name as column_name,
       kcu.referenced_table_name as referenced_table_name,
-      kcu.referenced_column_name as referenced_column_name,
+      kcu.referenced_column_name as referenced_column_name
+    FROM information_schema.key_column_usage kcu
+    WHERE kcu.constraint_name in (?)
+    AND kcu.table_schema = database()
+    AND kcu.table_name = ?;
+  `,
+  FOREIGN_KEY_REFERENTIALS_CONSTRAINTS: /* sql */ `
+    SELECT
+      rc.constraint_name as constraint_name,
       rc.update_rule as on_update,
       rc.delete_rule as on_delete
-    FROM information_schema.table_constraints tc
-    INNER JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name
-    INNER JOIN information_schema.referential_constraints AS rc ON kcu.constraint_name = rc.constraint_name
-    WHERE constraint_type = 'FOREIGN KEY'
-    AND tc.table_schema = database()
-    AND tc.table_name = ?;
-
+    FROM information_schema.referential_constraints AS rc
+    WHERE rc.constraint_name in (?)
+    AND rc.constraint_schema = database()
+    AND rc.table_name = ?;
   `,
 };
 
@@ -177,18 +190,44 @@ class MysqlSchemaInspector {
     const ret = {};
 
     for (const fk of rows) {
-      if (!ret[fk.constraint_name]) {
-        ret[fk.constraint_name] = {
-          name: fk.constraint_name,
-          columns: [fk.column_name],
-          referencedColumns: [fk.referenced_column_name],
-          referencedTable: fk.referenced_table_name,
-          onUpdate: fk.on_update.toUpperCase(),
-          onDelete: fk.on_delete.toUpperCase(),
-        };
-      } else {
-        ret[fk.constraint_name].columns.push(fk.column_name);
-        ret[fk.constraint_name].referencedColumns.push(fk.referenced_column_name);
+      ret[fk.constraint_name] = {
+        name: fk.constraint_name,
+        columns: [],
+        referencedColumns: [],
+        referencedTable: null,
+        onUpdate: null,
+        onDelete: null,
+      };
+    }
+
+    const contraintNames = Object.keys(ret);
+
+    if (contraintNames.length > 0) {
+      const [fkReferences] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES, [
+        contraintNames,
+        tableName,
+      ]);
+
+      for (const fkReference of fkReferences) {
+        ret[fkReference.constraint_name].referencedTable = fkReference.referenced_table_name;
+        ret[fkReference.constraint_name].columns.push(fkReference.column_name);
+        ret[fkReference.constraint_name].referencedColumns.push(fkReference.referenced_column_name);
+      }
+
+      const [
+        fkReferentialConstraints,
+      ] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENTIALS_CONSTRAINTS, [
+        contraintNames,
+        tableName,
+      ]);
+
+      for (const fkReferentialConstraint of fkReferentialConstraints) {
+        ret[
+          fkReferentialConstraint.constraint_name
+        ].onUpdate = fkReferentialConstraint.on_update.toUpperCase();
+        ret[
+          fkReferentialConstraint.constraint_name
+        ].onDelete = fkReferentialConstraint.on_delete.toUpperCase();
       }
     }
 

package/lib/dialects/postgresql/schema-inspector.js

@@ -40,29 +40,41 @@ const SQL_QUERIES = {
   `,
   FOREIGN_KEY_LIST: /* sql */ `
     SELECT
-      tco."constraint_name" as constraint_name,
-      kcu."column_name" as column_name,
-      rel_kcu."table_name" as foreign_table,
-      rel_kcu."column_name" as fk_column_name,
-      rco.update_rule as on_update,
-      rco.delete_rule as on_delete
+      tco."constraint_name" as constraint_name
     FROM information_schema.table_constraints tco
-    JOIN information_schema.key_column_usage kcu
-      ON tco.constraint_schema = kcu.constraint_schema
-      AND tco.constraint_name = kcu.constraint_name
-    JOIN information_schema.referential_constraints rco
-      ON tco.constraint_schema = rco.constraint_schema
-      AND tco.constraint_name = rco.constraint_name
-    JOIN information_schema.key_column_usage rel_kcu
-      ON rco.unique_constraint_schema = rel_kcu.constraint_schema
-      AND rco.unique_constraint_name = rel_kcu.constraint_name
-      AND kcu.ordinal_position = rel_kcu.ordinal_position
     WHERE
       tco.constraint_type = 'FOREIGN KEY'
       AND tco.constraint_schema = ?
       AND tco.table_name = ?
-    ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position, kcu.constraint_name;
   `,
+  FOREIGN_KEY_REFERENCES: /* sql */ `
+    SELECT
+      kcu."constraint_name" as constraint_name,
+      kcu."column_name" as column_name
+     
+    FROM information_schema.key_column_usage kcu
+    WHERE kcu.constraint_name=ANY(?)
+    AND kcu.table_schema = ?
+    AND kcu.table_name = ?;
+  `,
+
+  FOREIGN_KEY_REFERENCES_CONSTRAIN: /* sql */ `
+  SELECT
+  rco.update_rule as on_update,
+  rco.delete_rule as on_delete,
+  rco."unique_constraint_name" as unique_constraint_name
+  FROM information_schema.referential_constraints rco
+  WHERE rco.constraint_name=ANY(?)
+  AND rco.constraint_schema = ?
+`,
+  FOREIGN_KEY_REFERENCES_CONSTRAIN_RFERENCE: /* sql */ `
+  SELECT
+  rel_kcu."table_name" as foreign_table,
+  rel_kcu."column_name" as fk_column_name
+    FROM information_schema.key_column_usage rel_kcu
+    WHERE rel_kcu.constraint_name=?
+    AND rel_kcu.table_schema = ?
+`,
 };
 
 const toStrapiType = column => {
@@ -210,18 +222,52 @@ class PostgresqlSchemaInspector {
     const ret = {};
 
     for (const fk of rows) {
-      if (!ret[fk.constraint_name]) {
-        ret[fk.constraint_name] = {
-          name: fk.constraint_name,
-          columns: [fk.column_name],
-          referencedColumns: [fk.fk_column_name],
-          referencedTable: fk.foreign_table,
-          onUpdate: fk.on_update.toUpperCase(),
-          onDelete: fk.on_delete.toUpperCase(),
-        };
-      } else {
-        ret[fk.constraint_name].columns.push(fk.column_name);
-        ret[fk.constraint_name].referencedColumns.push(fk.fk_column_name);
+      ret[fk.constraint_name] = {
+        name: fk.constraint_name,
+        columns: [],
+        referencedColumns: [],
+        referencedTable: null,
+        onUpdate: null,
+        onDelete: null,
+      };
+    }
+    const constraintNames = Object.keys(ret);
+    const dbSchema = this.getDatabaseSchema();
+    if (constraintNames.length > 0) {
+      const {
+        rows: fkReferences,
+      } = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES, [
+        [constraintNames],
+        dbSchema,
+        tableName,
+      ]);
+
+      for (const fkReference of fkReferences) {
+        ret[fkReference.constraint_name].columns.push(fkReference.column_name);
+
+        const {
+          rows: fkReferencesConstraint,
+        } = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES_CONSTRAIN, [
+          [fkReference.constraint_name],
+          dbSchema,
+        ]);
+
+        for (const fkReferenceC of fkReferencesConstraint) {
+          const {
+            rows: fkReferencesConstraintReferece,
+          } = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES_CONSTRAIN_RFERENCE, [
+            fkReferenceC.unique_constraint_name,
+            dbSchema,
+          ]);
+          for (const fkReferenceConst of fkReferencesConstraintReferece) {
+            ret[fkReference.constraint_name].referencedTable = fkReferenceConst.foreign_table;
+            ret[fkReference.constraint_name].referencedColumns.push(
+              fkReferenceConst.fk_column_name
+            );
+          }
+          ret[fkReference.constraint_name].onUpdate = fkReferenceC.on_update.toUpperCase();
+          ret[fkReference.constraint_name].onDelete = fkReferenceC.on_delete.toUpperCase();
+        }
       }
     }
 

package/lib/entity-manager.js

@@ -617,7 +617,7 @@ const createEntityManager = db => {
         }
 
         if (attribute.joinColumn && attribute.owner) {
-          // handled in the row itslef
+          // handled in the row itself
           continue;
         }
 

package/lib/index.d.ts

@@ -2,16 +2,37 @@ import { LifecycleProvider } from './lifecycles';
 import { MigrationProvider } from './migrations';
 import { SchemaProvideer } from './schema';
 
-type BooleanWhere<T> = {
+type LogicalOperators<T> = {
   $and?: WhereParams<T>[];
   $or?: WhereParams<T>[];
   $not?: WhereParams<T>;
 };
 
-type WhereParams<T> = {
-  [K in keyof T]?: T[K];
+type AttributeOperators<T, K extends keyof T> = {
+  $eq?: T[K] | Array<T[K]>;
+  $ne?: T[K] | Array<T[K]>;
+  $in?: T[K][];
+  $notIn?: T[K][];
+  $lt?: T[K];
+  $lte?: T[K];
+  $gt?: T[K];
+  $gte?: T[K];
+  $between?: [T[K], T[K]];
+  $contains?: T[K];
+  $notContains?: T[K];
+  $containsi?: T[K];
+  $notContainsi?: T[K];
+  $startsWith?: T[K];
+  $endsWith?: T[K];
+  $null?: boolean;
+  $notNull?: boolean;
+  $not?: WhereParams<T> | AttributeOperators<T, K>;
+};
+
+export type WhereParams<T> = {
+  [K in keyof T]?: T[K] | T[K][] | AttributeOperators<T, K>;
 } &
-  BooleanWhere<T>;
+  LogicalOperators<T>;
 
 type Sortables<T> = {
   // check sortable

package/lib/index.js

@@ -58,6 +58,10 @@ class Database {
     return schema ? trx.schema.withSchema(schema) : trx.schema;
   }
 
+  transaction() {
+    return this.connection.transaction();
+  }
+
   queryBuilder(uid) {
     return this.entityManager.createQueryBuilder(uid);
   }

package/lib/metadata/index.js

@@ -33,6 +33,7 @@ const createMetadata = (models = []) => {
         ...model.attributes,
       },
       lifecycles: model.lifecycles || {},
+      indexes: model.indexes || [],
     });
   }
 

package/lib/migrations/index.js

@@ -34,7 +34,7 @@ const migrationResolver = ({ name, path, context }) => {
 };
 
 const createUmzugProvider = db => {
-  const migrationDir = path.join(strapi.dirs.root, 'database/migrations');
+  const migrationDir = path.join(strapi.dirs.app.root, 'database/migrations');
 
   fse.ensureDirSync(migrationDir);
 

package/lib/query/query-builder.js

@@ -12,6 +12,7 @@ const createQueryBuilder = (uid, db) => {
     type: 'select',
     select: [],
     count: null,
+    max: null,
     first: false,
     data: null,
     where: [],
@@ -19,6 +20,8 @@ const createQueryBuilder = (uid, db) => {
     populate: null,
     limit: null,
     offset: null,
+    transaction: null,
+    forUpdate: false,
     orderBy: [],
     groupBy: [],
   };
@@ -75,6 +78,13 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    max(column) {
+      state.type = 'max';
+      state.max = column;
+
+      return this;
+    },
+
     where(where = {}) {
       if (!_.isPlainObject(where)) {
         throw new Error('Where must be an object');
@@ -115,6 +125,16 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    transacting(transaction) {
+      state.transaction = transaction;
+      return this;
+    },
+
+    forUpdate() {
+      state.forUpdate = true;
+      return this;
+    },
+
     init(params = {}) {
       const { _q, filters, where, select, limit, offset, orderBy, groupBy, populate } = params;
 
@@ -281,7 +301,15 @@ const createQueryBuilder = (uid, db) => {
           break;
         }
         case 'count': {
-          qb.count({ count: state.count });
+          const dbColumnName =
+            state.count === '*' ? '*' : this.aliasColumn(helpers.toColumnName(meta, state.count));
+
+          qb.count({ count: dbColumnName });
+          break;
+        }
+        case 'max': {
+          const dbColumnName = this.aliasColumn(helpers.toColumnName(meta, state.max));
+          qb.max({ max: dbColumnName });
           break;
         }
         case 'insert': {
@@ -308,6 +336,14 @@ const createQueryBuilder = (uid, db) => {
         }
       }
 
+      if (state.transaction) {
+        qb.transacting(state.transaction);
+      }
+
+      if (state.forUpdate) {
+        qb.forUpdate();
+      }
+
       if (state.limit) {
         qb.limit(state.limit);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.2.1-alpha.0",
+  "version": "4.3.0-beta.2",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -31,7 +31,7 @@
     "test:unit": "jest --verbose"
   },
   "dependencies": {
-    "date-fns": "2.22.1",
+    "date-fns": "2.28.0",
     "debug": "4.3.1",
     "fs-extra": "10.0.0",
     "knex": "1.0.4",
@@ -42,5 +42,5 @@
     "node": ">=14.19.1 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "90bd3b9e294a69cd9538bde4e2e853e6de60f238"
+  "gitHead": "42aba356ad1b0751584d3b375e83baa4a2c18f65"
 }