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

package/src/fields/field.ts

@@ -157,6 +157,11 @@ export abstract class Field {
     //   return;
     // }
 
+    if (this.collection.isView()) {
+      this.remove();
+      return;
+    }
+
     const columnReferencesCount = _.filter(
       this.collection.model.rawAttributes,
       (attr) => attr.field == this.columnName(),
@@ -169,7 +174,7 @@ export abstract class Field {
       columnReferencesCount == 1
     ) {
       const queryInterface = this.database.sequelize.getQueryInterface();
-      await queryInterface.removeColumn(this.collection.addSchemaTableName(), this.columnName(), options);
+      await queryInterface.removeColumn(this.collection.getTableNameWithSchema(), this.columnName(), options);
     }
 
     this.remove();
@@ -181,22 +186,24 @@ export abstract class Field {
     };
     let sql;
     if (this.database.sequelize.getDialect() === 'sqlite') {
-      sql = `SELECT * from pragma_table_info('${this.collection.model.tableName}') WHERE name = '${this.columnName()}'`;
+      sql = `SELECT *
+             from pragma_table_info('${this.collection.model.tableName}')
+             WHERE name = '${this.columnName()}'`;
     } else if (this.database.inDialect('mysql')) {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_SCHEMA='${this.database.options.database}' AND TABLE_NAME='${
-        this.collection.model.tableName
-      }' AND column_name='${this.columnName()}'
+        where TABLE_SCHEMA = '${this.database.options.database}'
+          AND TABLE_NAME = '${this.collection.model.tableName}'
+          AND column_name = '${this.columnName()}'
       `;
     } else {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_NAME='${
-          this.collection.model.tableName
-        }' AND column_name='${this.columnName()}' AND table_schema='${this.collection.collectionSchema() || 'public'}'
+        where TABLE_NAME = '${this.collection.model.tableName}'
+          AND column_name = '${this.columnName()}'
+          AND table_schema = '${this.collection.collectionSchema() || 'public'}'
       `;
     }
     const [rows] = await this.database.sequelize.query(sql, opts);
@@ -230,6 +237,7 @@ export abstract class Field {
     if (this.dataType) {
       Object.assign(opts, { type: this.dataType });
     }
+
     return opts;
   }
 

package/src/fields/json-field.ts

@@ -20,6 +20,7 @@ export class JsonbField extends Field {
     return DataTypes.JSON;
   }
 }
+
 export interface JsonbFieldOptions extends BaseColumnFieldOptions {
   type: 'jsonb';
 }

package/src/fields/sort-field.ts

@@ -42,49 +42,110 @@ export class SortField extends Field {
   };
 
   initRecordsSortValue = async ({ transaction }) => {
-    const totalCount = await this.collection.repository.count({
-      transaction,
-    });
-
-    const emptyCount = await this.collection.repository.count({
-      filter: {
-        [this.name]: null,
-      },
-      transaction,
-    });
-
-    const orderKey = (() => {
+    const orderField = (() => {
       const model = this.collection.model;
       if (model.primaryKeyAttribute) {
         return model.primaryKeyAttribute;
       }
       if (model.rawAttributes['createdAt']) {
-        return 'createdAt';
+        return model.rawAttributes['createdAt'].field;
       }
 
       throw new Error(`can not find order key for collection ${this.collection.name}`);
     })();
 
-    if (emptyCount === totalCount && emptyCount > 0) {
-      const records = await this.collection.repository.find({
-        order: [orderKey],
+    const needInit = async (scopeKey = null, scopeValue = null) => {
+      const filter = {};
+      if (scopeKey && scopeValue) {
+        filter[scopeKey] = scopeValue;
+      }
+
+      const totalCount = await this.collection.repository.count({
+        filter,
+        transaction,
+      });
+
+      const emptyCount = await this.collection.repository.count({
+        filter: {
+          [this.name]: null,
+          ...filter,
+        },
         transaction,
       });
 
-      let start = 1;
-      for (const record of records) {
-        await record.update(
-          {
-            sort: start,
-          },
-          {
-            transaction,
-            silent: true,
-          },
-        );
-
-        start += 1;
+      return emptyCount === totalCount && emptyCount > 0;
+    };
+
+    const doInit = async (scopeKey = null, scopeValue = null) => {
+      const queryInterface = this.collection.db.sequelize.getQueryInterface();
+
+      const quotedOrderField = queryInterface.quoteIdentifier(orderField);
+
+      const sql = `
+        WITH ordered_table AS (
+          SELECT *, ROW_NUMBER() OVER (${
+            scopeKey ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey)}` : ''
+          } ORDER BY ${quotedOrderField}) AS new_sequence_number
+          FROM ${this.collection.quotedTableName()}
+          ${(() => {
+            if (scopeKey && scopeValue) {
+              const hasNull = scopeValue.includes(null);
+
+              return `WHERE ${queryInterface.quoteIdentifier(scopeKey)} IN (${scopeValue
+                .filter((v) => v !== null)
+                .map((v) => `'${v}'`)
+                .join(',')}) ${hasNull ? `OR ${queryInterface.quoteIdentifier(scopeKey)} IS NULL` : ''} `;
+            }
+
+            return '';
+          })()}
+
+        )
+        ${
+          this.collection.db.inDialect('mysql')
+            ? `
+             UPDATE ${this.collection.quotedTableName()}, ordered_table
+             SET ${this.collection.quotedTableName()}.${this.name} = ordered_table.new_sequence_number
+             WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
+            `
+            : `
+          UPDATE ${this.collection.quotedTableName()}
+        SET ${queryInterface.quoteIdentifier(this.name)} = ordered_table.new_sequence_number
+        FROM ordered_table
+        WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ${queryInterface.quoteIdentifier(
+                'ordered_table',
+              )}.${quotedOrderField};
+        `
+        }
+
+      `;
+
+      await this.collection.db.sequelize.query(sql, {
+        transaction,
+      });
+    };
+
+    const scopeKey = this.options.scopeKey;
+    if (scopeKey) {
+      const groups = await this.collection.repository.find({
+        attributes: [scopeKey],
+        group: [scopeKey],
+        raw: true,
+        transaction,
+      });
+
+      const needInitGroups = [];
+      for (const group of groups) {
+        if (await needInit(scopeKey, group[scopeKey])) {
+          needInitGroups.push(group[scopeKey]);
+        }
+      }
+
+      if (needInitGroups.length > 0) {
+        await doInit(scopeKey, needInitGroups);
       }
+    } else if (await needInit()) {
+      await doInit();
     }
   };
 

package/src/filter-parser.ts

@@ -135,6 +135,7 @@ export default class FilterParser {
                 path: skipPrefix,
                 fullName,
                 fieldName,
+                fieldPath: `${this.collection.name}.${fullName}`,
                 model: this.model,
               });
               break;

package/src/index.ts

@@ -20,4 +20,6 @@ export * from './repository';
 export * from './update-associations';
 export { snakeCase } from './utils';
 export * from './value-parsers';
-
+export * from './collection-group-manager';
+export * from './view-collection';
+export * from './view/view-inference';

package/src/listeners/adjacency-list.ts

@@ -0,0 +1,60 @@
+import lodash from 'lodash';
+import { Collection, CollectionOptions } from '../collection';
+import { Model } from '../model';
+
+export const beforeDefineAdjacencyListCollection = (options: CollectionOptions) => {
+  if (!options.tree) {
+    return;
+  }
+  (options.fields || []).forEach((field) => {
+    if (field.treeParent || field.treeChildren) {
+      if (!field.target) {
+        field.target = options.name;
+      }
+      if (!field.foreignKey) {
+        field.foreignKey = 'parentId';
+      }
+    }
+  });
+};
+
+export const afterDefineAdjacencyListCollection = (collection: Collection) => {
+  if (!collection.options.tree) {
+    return;
+  }
+  collection.model.afterFind(async (instances, options: any) => {
+    if (!options.tree) {
+      return;
+    }
+    const foreignKey = collection.treeParentField?.foreignKey ?? 'parentId';
+    const childrenKey = collection.treeChildrenField?.name ?? 'children';
+    const arr: Model[] = Array.isArray(instances) ? instances : [instances];
+    let index = 0;
+    for (const instance of arr) {
+      const opts = {
+        ...lodash.pick(options, ['tree', 'fields', 'appends', 'except', 'sort']),
+      };
+      let __index = `${index++}`;
+      if (options.parentIndex) {
+        __index = `${options.parentIndex}.${__index}`;
+      }
+      instance.setDataValue('__index', __index);
+      const children = await collection.repository.find({
+        filter: {
+          [foreignKey]: instance.id,
+        },
+        transaction: options.transaction,
+        ...opts,
+        // @ts-ignore
+        parentIndex: `${__index}.${childrenKey}`,
+        context: options.context,
+      });
+      if (children?.length > 0) {
+        instance.setDataValue(
+          childrenKey,
+          children.map((r) => r.toJSON()),
+        );
+      }
+    }
+  });
+};

package/src/listeners/index.ts

@@ -0,0 +1,7 @@
+import { Database } from '../database';
+import { afterDefineAdjacencyListCollection, beforeDefineAdjacencyListCollection } from './adjacency-list';
+
+export const registerBuiltInListeners = (db: Database) => {
+  db.on('beforeDefineCollection', beforeDefineAdjacencyListCollection);
+  db.on('afterDefineCollection', afterDefineAdjacencyListCollection);
+};

package/src/mock-database.ts

@@ -14,14 +14,14 @@ export class MockDatabase extends Database {
 }
 
 export function getConfigByEnv() {
-  return {
+  const options = {
     username: process.env.DB_USER,
     password: process.env.DB_PASSWORD,
     database: process.env.DB_DATABASE,
     host: process.env.DB_HOST,
     port: process.env.DB_PORT,
     dialect: process.env.DB_DIALECT || 'sqlite',
-    logging: process.env.DB_LOGGING === 'on' ? console.log : false,
+    logging: process.env.DB_LOGGING === 'on' ? customLogger : false,
     storage:
       process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:'
         ? resolve(process.cwd(), process.env.DB_STORAGE)
@@ -33,7 +33,19 @@ export function getConfigByEnv() {
     timezone: process.env.DB_TIMEZONE,
     underscored: process.env.DB_UNDERSCORED === 'true',
     schema: process.env.DB_SCHEMA !== 'public' ? process.env.DB_SCHEMA : undefined,
+    dialectOptions: {},
   };
+
+  if (process.env.DB_DIALECT == 'postgres') {
+    options.dialectOptions['application_name'] = 'nocobase.main';
+  }
+
+  return options;
+}
+
+function customLogger(queryString, queryObject) {
+  console.log(queryString); // outputs a string
+  console.log(queryObject.bind); // outputs an array
 }
 
 export function mockDatabase(options: IDatabaseOptions = {}): MockDatabase {

package/src/model.ts

@@ -151,6 +151,10 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   }
 
   static async sync(options) {
+    if (this.collection.isView()) {
+      return;
+    }
+
     const model = this as any;
 
     const _schema = model._schema;

package/src/operators/child-collection.ts

@@ -0,0 +1,24 @@
+import { Op, Sequelize } from 'sequelize';
+
+const mapVal = (values, db) =>
+  values.map((v) => {
+    const collection = db.getCollection(v);
+    return Sequelize.literal(`'${collection.tableNameAsString()}'::regclass`);
+  });
+
+export default {
+  $childIn(values, ctx: any) {
+    const db = ctx.db;
+
+    return {
+      [Op.in]: mapVal(values, db),
+    };
+  },
+  $childNotIn(values, ctx: any) {
+    const db = ctx.db;
+
+    return {
+      [Op.notIn]: mapVal(values, db),
+    };
+  },
+} as Record<string, any>;

package/src/operators/date.ts

@@ -1,41 +1,125 @@
+import { parseDate } from '@nocobase/utils';
 import { Op } from 'sequelize';
-import moment, { MomentInput } from 'moment';
-function stringToDate(value: string): Date {
-  return moment(value).toDate();
-}
 
-function getNextDay(value: MomentInput): Date {
-  return moment(value).add(1, 'd').toDate();
+function isDate(input) {
+  return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
 }
 
+const toDate = (date) => {
+  if (isDate(date)) {
+    return date;
+  }
+  return new Date(date);
+};
+
 export default {
-  $dateOn(value) {
-    return {
-      [Op.and]: [{ [Op.gte]: stringToDate(value) }, { [Op.lt]: getNextDay(value) }],
-    };
+  $dateOn(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.eq]: toDate(r),
+      };
+    }
+    if (Array.isArray(r)) {
+      return {
+        [Op.and]: [{ [Op.gte]: toDate(r[0]) }, { [Op.lt]: toDate(r[1]) }],
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+
+  $dateNotOn(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.ne]: toDate(r),
+      };
+    }
+    if (Array.isArray(r)) {
+      return {
+        [Op.or]: [{ [Op.lt]: toDate(r[0]) }, { [Op.gte]: toDate(r[1]) }],
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 
-  $dateNotOn(value) {
-    return {
-      [Op.or]: [{ [Op.lt]: stringToDate(value) }, { [Op.gte]: getNextDay(value) }],
-    };
+  $dateBefore(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.lt]: toDate(r),
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [Op.lt]: toDate(r[0]),
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 
-  $dateBefore(value) {
-    return { [Op.lt]: stringToDate(value) };
+  $dateNotBefore(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.gte]: toDate(r),
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [Op.gte]: toDate(r[0]),
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 
-  $dateNotBefore(value) {
-    return {
-      [Op.gte]: stringToDate(value),
-    };
+  $dateAfter(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.gt]: toDate(r),
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [Op.gte]: toDate(r[1]),
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 
-  $dateAfter(value) {
-    return { [Op.gte]: getNextDay(value) };
+  $dateNotAfter(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (typeof r === 'string') {
+      return {
+        [Op.lte]: toDate(r),
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [Op.lt]: toDate(r[1]),
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 
-  $dateNotAfter(value) {
-    return { [Op.lt]: getNextDay(value) };
+  $dateBetween(value, ctx) {
+    const r = parseDate(value, {
+      timezone: ctx.db.options.timezone,
+    });
+    if (r) {
+      return {
+        [Op.and]: [{ [Op.gte]: toDate(r[0]) }, { [Op.lt]: toDate(r[1]) }],
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
 } as Record<string, any>;

package/src/operators/eq.ts

@@ -0,0 +1,14 @@
+import { Op } from 'sequelize';
+
+export default {
+  $eq(val: any) {
+    if (Array.isArray(val)) {
+      return {
+        [Op.in]: val,
+      };
+    }
+    return {
+      [Op.eq]: val,
+    };
+  },
+} as Record<string, any>;

package/src/operators/index.ts

@@ -4,7 +4,9 @@ export default {
   ...require('./array').default,
   ...require('./empty').default,
   ...require('./string').default,
+  ...require('./eq').default,
   ...require('./ne').default,
   ...require('./notIn').default,
   ...require('./boolean').default,
+  ...require('./child-collection').default,
 };

package/src/operators/ne.ts

@@ -2,15 +2,20 @@ import { Op } from 'sequelize';
 
 export default {
   $ne(val, ctx) {
+    if (Array.isArray(val)) {
+      return {
+        [Op.notIn]: val,
+      };
+    }
     return val === null
       ? {
-        [Op.ne]: null,
-      }
+          [Op.ne]: null,
+        }
       : {
-        [Op.or]: {
-          [Op.ne]: val,
-          [Op.is]: null,
-        },
-      };
+          [Op.or]: {
+            [Op.ne]: val,
+            [Op.is]: null,
+          },
+        };
   },
 } as Record<string, any>;

package/src/options-parser.ts

@@ -109,27 +109,48 @@ export class OptionsParser {
     return filterParams;
   }
 
-  protected inheritFromSubQuery(): any {
-    return [
+  protected inheritFromSubQuery(include): any {
+    include.push([
       Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${this.collection.name}".tableoid)`),
       '__tableName',
-    ];
+    ]);
+
+    include.push([
+      Sequelize.literal(`
+        (SELECT n.nspname
+        FROM pg_class c
+               JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.oid = "${this.collection.name}".tableoid)
+      `),
+      '__schemaName',
+    ]);
   }
 
   protected parseFields(filterParams: any) {
     const appends = this.options?.appends || [];
     const except = [];
 
+    if (this.options?.attributes) {
+      return {
+        attributes: this.options.attributes,
+      };
+    }
+
     let attributes: FindAttributeOptions = {
       include: [],
       exclude: [],
     }; // out put all fields by default
 
     if (this.collection.isParent()) {
-      attributes.include.push(this.inheritFromSubQuery());
+      this.inheritFromSubQuery(attributes.include);
     }
 
     if (this.options?.fields) {
+      attributes = [];
+      if (this.collection.isParent()) {
+        this.inheritFromSubQuery(attributes);
+      }
+
       // 将fields拆分为 attributes 和 appends
       for (const field of this.options.fields) {
         if (this.isAssociationPath(field)) {
@@ -137,13 +158,6 @@ export class OptionsParser {
           appends.push(field);
         } else {
           // field is model attribute, change attributes to array type
-          if (!Array.isArray(attributes)) {
-            attributes = [];
-            if (this.collection.isParent()) {
-              attributes.push(this.inheritFromSubQuery());
-            }
-          }
-
           attributes.push(field);
         }
       }