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

package/src/fields/belongs-to-many-field.ts

@@ -32,9 +32,21 @@ export class BelongsToManyField extends RelationField {
 
     const onDelete = this.options.onDelete || 'CASCADE';
 
+    const targetAssociation = association.toTarget;
+
+    if (association.targetKey) {
+      targetAssociation.targetKey = association.targetKey;
+    }
+
+    const sourceAssociation = association.toSource;
+
+    if (association.sourceKey) {
+      sourceAssociation.targetKey = association.sourceKey;
+    }
+
     return [
-      BelongsToField.toReference(db, association.toSource, onDelete),
-      BelongsToField.toReference(db, association.toTarget, onDelete),
+      BelongsToField.toReference(db, targetAssociation, onDelete),
+      BelongsToField.toReference(db, sourceAssociation, onDelete),
     ];
   }
 
@@ -55,9 +67,16 @@ export class BelongsToManyField extends RelationField {
     if (database.hasCollection(through)) {
       Through = database.getCollection(through);
     } else {
-      Through = database.collection({
+      const throughCollectionOptions = {
         name: through,
-      });
+      };
+
+      // set through collection schema
+      if (this.collection.collectionSchema()) {
+        throughCollectionOptions['schema'] = this.collection.collectionSchema();
+      }
+
+      Through = database.collection(throughCollectionOptions);
 
       Object.defineProperty(Through.model, 'isThrough', { value: true });
     }

package/src/fields/date-field.ts

@@ -5,6 +5,24 @@ export class DateField extends Field {
   get dataType() {
     return DataTypes.DATE(3);
   }
+
+  get timezone() {
+    return this.isGMT() ? '+00:00' : null;
+  }
+
+  getProps() {
+    return this.options?.uiSchema?.['x-component-props'] || {};
+  }
+
+  isDateOnly() {
+    const props = this.getProps();
+    return !props.showTime;
+  }
+
+  isGMT() {
+    const props = this.getProps();
+    return props.gmt;
+  }
 }
 
 export interface DateFieldOptions extends BaseColumnFieldOptions {

package/src/fields/field.ts

@@ -6,7 +6,7 @@ import {
   ModelIndexesOptions,
   QueryInterfaceOptions,
   SyncOptions,
-  Transactionable
+  Transactionable,
 } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
@@ -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.model.tableName, this.columnName(), options);
+      await queryInterface.removeColumn(this.collection.getTableNameWithSchema(), this.columnName(), options);
     }
 
     this.remove();
@@ -181,20 +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()}'
+        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);
@@ -228,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;
@@ -178,7 +179,7 @@ export default class FilterParser {
           origins.push(attr);
           // if it is target model attribute
           if (target.rawAttributes[attr]) {
-            associationKeys.push(attr);
+            associationKeys.push(target.rawAttributes[attr].field || attr);
             target = null;
           } else if (target.associations[attr]) {
             // if it is target model association (nested association filter)

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>;