@nocobase/database 0.9.1-alpha.2 → 0.9.2-alpha.2

package/src/query-interface/mysql-query-interface.ts

@@ -1,6 +1,7 @@
 import QueryInterface from './query-interface';
 import { Collection } from '../collection';
 import { Transactionable } from 'sequelize';
+import sqlParser from '../sql-parser';
 
 export default class MysqlQueryInterface extends QueryInterface {
   constructor(db) {
@@ -12,9 +13,60 @@ export default class MysqlQueryInterface extends QueryInterface {
 
     const tableName = collection.model.tableName;
     const databaseName = this.db.options.database;
-    const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${databaseName}' AND TABLE_NAME = '${tableName}'`;
+    const sql = `SELECT TABLE_NAME
+                 FROM INFORMATION_SCHEMA.TABLES
+                 WHERE TABLE_SCHEMA = '${databaseName}'
+                   AND TABLE_NAME = '${tableName}'`;
 
     const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
     return results.length > 0;
   }
+
+  async listViews() {
+    const sql = `SELECT TABLE_NAME as name, VIEW_DEFINITION as definition
+                 FROM information_schema.views
+                 WHERE TABLE_SCHEMA = DATABASE()
+                 ORDER BY TABLE_NAME;`;
+
+    return await this.db.sequelize.query(sql, { type: 'SELECT' });
+  }
+
+  async viewColumnUsage(options: { viewName: string; schema?: string }): Promise<{
+    [view_column_name: string]: {
+      column_name: string;
+      table_name: string;
+      table_schema?: string;
+    };
+  }> {
+    try {
+      const viewDefinition = await this.db.sequelize.query(`SHOW CREATE VIEW ${options.viewName}`, { type: 'SELECT' });
+      const createView = viewDefinition[0]['Create View'];
+      const regex = /(?<=AS\s)([\s\S]*)/i;
+      const match = createView.match(regex);
+      const sql = match[0];
+
+      const { ast } = sqlParser.parse(sql);
+
+      const columns = ast.columns;
+
+      const results = [];
+      for (const column of columns) {
+        if (column.expr.type === 'column_ref') {
+          results.push([
+            column.as || column.expr.column,
+            {
+              column_name: column.expr.column,
+              table_name: column.expr.table,
+            },
+          ]);
+        }
+      }
+
+      return Object.fromEntries(results);
+    } catch (e) {
+      this.db.logger.warn(e);
+
+      return {};
+    }
+  }
 }

package/src/query-interface/postgres-query-interface.ts

@@ -1,5 +1,6 @@
 import QueryInterface from './query-interface';
 import { Collection } from '../collection';
+import sqlParser from '../sql-parser';
 
 export default class PostgresQueryInterface extends QueryInterface {
   constructor(db) {
@@ -12,11 +13,91 @@ export default class PostgresQueryInterface extends QueryInterface {
     const tableName = collection.model.tableName;
     const schema = collection.collectionSchema() || 'public';
 
-    const sql = `SELECT EXISTS(SELECT 1 FROM information_schema.tables
-                 WHERE  table_schema = '${schema}'
-                 AND    table_name   = '${tableName}')`;
+    const sql = `SELECT EXISTS(SELECT 1
+                               FROM information_schema.tables
+                               WHERE table_schema = '${schema}'
+                                 AND table_name = '${tableName}')`;
 
     const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
     return results[0]['exists'];
   }
+
+  async listViews() {
+    const sql = `
+      SELECT viewname as name, definition, schemaname as schema
+      FROM pg_views
+      WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY viewname;
+    `;
+
+    return await this.db.sequelize.query(sql, { type: 'SELECT' });
+  }
+
+  async viewColumnUsage(options): Promise<{
+    [view_column_name: string]: {
+      column_name: string;
+      table_name: string;
+      table_schema?: string;
+    };
+  }> {
+    const { viewName, schema = 'public' } = options;
+    const sql = `
+      SELECT *
+      FROM information_schema.view_column_usage
+      WHERE view_schema = '${schema}'
+        AND view_name = '${viewName}';
+    `;
+
+    const columnUsages = (await this.db.sequelize.query(sql, { type: 'SELECT' })) as Array<{
+      column_name: string;
+      table_name: string;
+      table_schema: string;
+    }>;
+
+    const viewDefQuery = await this.db.sequelize.query(
+      `
+    select pg_get_viewdef(format('%I.%I', '${schema}', '${viewName}')::regclass, true) as definition
+    `,
+      { type: 'SELECT' },
+    );
+
+    const def = viewDefQuery[0]['definition'];
+    try {
+      const { ast } = sqlParser.parse(def);
+      const columns = ast[0].columns;
+
+      const usages = columns
+        .map((column) => {
+          const fieldAlias = column.as || column.expr.column;
+          const columnUsage = columnUsages.find((columnUsage) => {
+            let columnExprTable = column.expr.table;
+
+            // handle column alias
+            const from = ast[0].from;
+            const findAs = from.find((from) => from.as === columnExprTable);
+
+            if (findAs) {
+              columnExprTable = findAs.table;
+            }
+
+            return columnUsage.column_name === column.expr.column && columnUsage.table_name === columnExprTable;
+          });
+
+          return [
+            fieldAlias,
+            columnUsage
+              ? {
+                  ...columnUsage,
+                }
+              : null,
+          ];
+        })
+        .filter(([, columnUsage]) => columnUsage !== null);
+
+      return Object.fromEntries(usages);
+    } catch (e) {
+      this.db.logger.warn(e);
+      return {};
+    }
+  }
 }

package/src/query-interface/query-interface.ts

@@ -4,9 +4,40 @@ import { QueryInterface as SequelizeQueryInterface, Transactionable } from 'sequ
 
 export default abstract class QueryInterface {
   sequelizeQueryInterface: SequelizeQueryInterface;
+
   protected constructor(public db: Database) {
     this.sequelizeQueryInterface = db.sequelize.getQueryInterface();
   }
 
   abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+
+  abstract listViews();
+
+  abstract viewColumnUsage(options: { viewName: string; schema?: string }): Promise<{
+    [view_column_name: string]: {
+      column_name: string;
+      table_name: string;
+      table_schema?: string;
+    };
+  }>;
+
+  async dropAll(options) {
+    if (options.drop !== true) return;
+
+    const views = await this.listViews();
+
+    for (const view of views) {
+      let removeSql;
+
+      if (view.schema) {
+        removeSql = `DROP VIEW IF EXISTS "${view.schema}"."${view.name}"`;
+      } else {
+        removeSql = `DROP VIEW IF EXISTS ${view.name}`;
+      }
+
+      await this.db.sequelize.query(removeSql, { transaction: options.transaction });
+    }
+
+    await this.db.sequelize.getQueryInterface().dropAllTables(options);
+  }
 }

package/src/query-interface/sqlite-query-interface.ts

@@ -1,5 +1,6 @@
 import QueryInterface from './query-interface';
 import { Collection } from '../collection';
+import sqlParser from '../sql-parser';
 
 export default class SqliteQueryInterface extends QueryInterface {
   constructor(db) {
@@ -11,8 +12,68 @@ export default class SqliteQueryInterface extends QueryInterface {
 
     const tableName = collection.model.tableName;
 
-    const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`;
+    const sql = `SELECT name
+                 FROM sqlite_master
+                 WHERE type = 'table'
+                   AND name = '${tableName}';`;
     const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
     return results.length > 0;
   }
+
+  async listViews() {
+    const sql = `
+      SELECT name , sql as definition
+      FROM sqlite_master
+      WHERE type = 'view'
+      ORDER BY name;
+    `;
+
+    return await this.db.sequelize.query(sql, {
+      type: 'SELECT',
+    });
+  }
+
+  async viewColumnUsage(options: { viewName: string; schema?: string }): Promise<{
+    [view_column_name: string]: {
+      column_name: string;
+      table_name: string;
+      table_schema?: string;
+    };
+  }> {
+    try {
+      const viewDefinition = await this.db.sequelize.query(
+        `SELECT sql FROM sqlite_master WHERE name = '${options.viewName}' AND type = 'view'`,
+        {
+          type: 'SELECT',
+        },
+      );
+
+      const createView = viewDefinition[0]['sql'];
+      const regex = /(?<=AS\s)([\s\S]*)/i;
+      const match = createView.match(regex);
+      const sql = match[0];
+
+      const { ast } = sqlParser.parse(sql);
+
+      const columns = ast.columns;
+
+      const results = [];
+      for (const column of columns) {
+        if (column.expr.type === 'column_ref') {
+          results.push([
+            column.as || column.expr.column,
+            {
+              column_name: column.expr.column,
+              table_name: column.expr.table,
+            },
+          ]);
+        }
+      }
+
+      return Object.fromEntries(results);
+    } catch (e) {
+      this.db.logger.warn(e);
+      return {};
+    }
+  }
 }

package/src/relation-repository/belongs-to-many-repository.ts

@@ -11,20 +11,29 @@ type CreateBelongsToManyOptions = CreateOptions;
 
 interface IBelongsToManyRepository<M extends Model> {
   find(options?: FindOptions): Promise<M[]>;
+
   findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;
+
   findOne(options?: FindOneOptions): Promise<M>;
+
   // 新增并关联，存在中间表数据
   create(options?: CreateOptions): Promise<M>;
+
   // 更新，存在中间表数据
   update(options?: UpdateOptions): Promise<M>;
+
   // 删除
   destroy(options?: number | string | number[] | string[] | DestroyOptions): Promise<Boolean>;
+
   // 建立关联
   set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+
   // 附加关联，存在中间表数据
   add(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+
   // 移除关联
   remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+
   toggle(options: TargetKey | { pk?: TargetKey; transaction?: Transaction }): Promise<void>;
 }
 
@@ -157,7 +166,17 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
       return carry;
     }, {});
 
-    await sourceModel[this.accessors()[call]](Object.keys(setObj), {
+    const targetKeys = Object.keys(setObj);
+    const association = this.association;
+
+    const targetObjects = await this.targetModel.findAll({
+      where: {
+        [association['targetKey']]: targetKeys,
+      },
+      transaction,
+    });
+
+    await sourceModel[this.accessors()[call]](targetObjects, {
       transaction,
     });
 

package/src/relation-repository/hasmany-repository.ts

@@ -43,12 +43,14 @@ export class HasManyRepository extends MultipleRelationRepository implements IHa
       addFilter[this.associationField.targetKey] = options.filterByTk;
     }
 
-    return await targetRepository.find({
-      ...omit(options, ['filterByTk']),
+    const findOptions = {
+      ...omit(options, ['filterByTk', 'where', 'values', 'attributes']),
       filter: {
         $and: [options.filter || {}, addFilter],
       },
-    });
+    };
+
+    return await targetRepository.find(findOptions);
   }
 
   @transaction((args, transaction) => {

package/src/relation-repository/multiple-relation-repository.ts

@@ -80,10 +80,18 @@ export abstract class MultipleRelationRepository extends RelationRepository {
       });
     }
 
-    return await sourceModel[getAccessor]({
+    const data = await sourceModel[getAccessor]({
       ...findOptions,
       transaction,
     });
+
+    await this.collection.db.emitAsync('afterRepositoryFind', {
+      findOptions: options,
+      dataCollection: this.collection,
+      data,
+    });
+
+    return data;
   }
 
   async findAndCount(options?: FindAndCountOptions): Promise<[any[], number]> {

package/src/repository.ts

@@ -106,6 +106,7 @@ export interface CommonFindOptions extends Transactionable {
   except?: Except;
   sort?: Sort;
   context?: any;
+  tree?: boolean;
 }
 
 export type FindOneOptions = Omit<FindOptions, 'limit'>;
@@ -336,19 +337,11 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       });
     }
 
-    if (this.collection.isParent()) {
-      for (const row of rows) {
-        const rowCollectionName = this.database.tableNameCollectionMap.get(
-          options.raw ? row['__tableName'] : row.get('__tableName'),
-        ).name;
-
-        options.raw
-          ? (row['__collection'] = rowCollectionName)
-          : row.set('__collection', rowCollectionName, {
-              raw: true,
-            });
-      }
-    }
+    await this.collection.db.emitAsync('afterRepositoryFind', {
+      findOptions: options,
+      dataCollection: this.collection,
+      data: rows,
+    });
 
     return rows;
   }