@nocobase/database 0.11.1-alpha.3 → 0.11.1-alpha.4

package/lib/options-parser.js

@@ -249,6 +249,8 @@ class OptionsParser {
   }
   parseAppends(appends, filterParams) {
     if (!appends) return filterParams;
+    // sort appends by path length
+    appends = _lodash().default.sortBy(appends, append => append.split('.').length);
     /**
      * set include params
      * @param model
@@ -256,6 +258,7 @@ class OptionsParser {
      * @param append
      */
     const setInclude = (model, queryParams, append) => {
+      var _lodash$get;
       const appendFields = append.split('.');
       const appendAssociation = appendFields[0];
       const associations = model.associations;
@@ -286,6 +289,16 @@ class OptionsParser {
       // if include from filter, remove fromFilter attribute
       if (existIncludeIndex != -1) {
         delete queryParams['include'][existIncludeIndex]['fromFilter'];
+        // set include attributes to all attributes
+        if (Array.isArray(queryParams['include'][existIncludeIndex]['attributes']) && queryParams['include'][existIncludeIndex]['attributes'].length == 0) {
+          queryParams['include'][existIncludeIndex]['attributes'] = {
+            include: []
+          };
+        }
+      }
+      if (lastLevel && existIncludeIndex != -1 && ((_lodash$get = _lodash().default.get(queryParams, ['include', existIncludeIndex, 'attributes', 'include'])) === null || _lodash$get === void 0 ? void 0 : _lodash$get.length) == 0) {
+        // if append is last level and association exists, ignore it
+        return;
       }
       // if association not exist, create it
       if (existIncludeIndex == -1) {

package/lib/sync-runner.js

@@ -64,7 +64,7 @@ class SyncRunner {
             }
             const columnDefault = sequenceNameResult[0][0]['column_default'];
             if (!columnDefault) {
-              throw new Error(`Can't find sequence name of ${parent}`);
+              throw new Error(`Can't find sequence name of parent collection ${parent.options.name}`);
             }
             const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
             const match = regex.exec(columnDefault);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.11.1-alpha.3",
+  "version": "0.11.1-alpha.4",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.11.1-alpha.3",
-    "@nocobase/utils": "0.11.1-alpha.3",
+    "@nocobase/logger": "0.11.1-alpha.4",
+    "@nocobase/utils": "0.11.1-alpha.4",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "dayjs": "^1.11.8",
@@ -29,5 +29,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "5ed3bd7d5b16bd38d268961b34875d5cd45799ef"
+  "gitHead": "d9b5bde913013f1057e1aab49587eb0ad3dcb06e"
 }

package/src/__tests__/option-parser.test.ts

@@ -112,80 +112,114 @@ describe('option parser', () => {
     ]);
   });
 
-  test('option parser with fields option', async () => {
-    let options: any = {
-      fields: ['id', 'posts'],
-    };
-    // 转换为 attributes: ['id'], include: [{association: 'posts'}]
-    let parser = new OptionsParser(options, {
-      collection: User,
+  describe('options parser with fields option', () => {
+    it('should handle field and association', () => {
+      const options: any = {
+        fields: ['id', 'posts'],
+      };
+
+      // 转换为 attributes: ['id'], include: [{association: 'posts'}]
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+
+      const params = parser.toSequelizeParams();
+
+      console.log(params);
+      expect(params['attributes']).toContain('id');
+      expect(params['include'][0]['association']).toEqual('posts');
     });
-    let params = parser.toSequelizeParams();
 
-    expect(params['attributes']).toContain('id');
-    expect(params['include'][0]['association']).toEqual('posts');
+    it('should handle field with association', () => {
+      const options = {
+        appends: ['posts'],
+      };
 
-    // only appends
-    options = {
-      appends: ['posts'],
-    };
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+      const params = parser.toSequelizeParams();
 
-    parser = new OptionsParser(options, {
-      collection: User,
+      expect(params['attributes']['include']).toEqual([]);
+      expect(params['include'][0]['association']).toEqual('posts');
     });
-    params = parser.toSequelizeParams();
-    expect(params['attributes']['include']).toEqual([]);
-    expect(params['include'][0]['association']).toEqual('posts');
 
-    // fields with association field
-    options = {
-      fields: ['id', 'posts.title'],
-    };
+    it('should handle field with association field', () => {
+      // fields with association field
+      const options = {
+        fields: ['id', 'posts.title'],
+      };
 
-    parser = new OptionsParser(options, {
-      collection: User,
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+
+      const params = parser.toSequelizeParams();
+      expect(params['attributes']).toContain('id');
+      expect(params['include'][0]['association']).toEqual('posts');
+      expect(params['include'][0]['attributes']).toContain('title');
     });
-    params = parser.toSequelizeParams();
-    expect(params['attributes']).toContain('id');
-    expect(params['include'][0]['association']).toEqual('posts');
-    expect(params['include'][0]['attributes']).toContain('title');
 
-    // fields with nested field
-    options = {
-      fields: ['id', 'posts', 'posts.comments.content'],
-    };
+    it('should handle nested fields option', () => {
+      const options = {
+        fields: ['posts', 'posts.title'],
+      };
 
-    parser = new OptionsParser(options, {
-      collection: User,
-    });
-    params = parser.toSequelizeParams();
-    expect(params['attributes']).toContain('id');
-    expect(params['include'][0]['association']).toEqual('posts');
-    expect(params['include'][0]['attributes']).toEqual({ include: [] });
-    expect(params['include'][0]['include'][0]['association']).toEqual('comments');
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
 
-    // fields with expect
-    options = {
-      except: ['id'],
-    };
-    parser = new OptionsParser(options, {
-      collection: User,
+      const params = parser.toSequelizeParams();
+      const postAssociationParams = params['include'][0];
+      expect(postAssociationParams['attributes']).toEqual({ include: [] });
     });
-    params = parser.toSequelizeParams();
-    expect(params['attributes']['exclude']).toContain('id');
 
-    // expect with association
-    options = {
-      fields: ['posts'],
-      except: ['posts.id'],
-    };
+    it('should handle fields with association & association field', () => {
+      // fields with nested field
+      const options = {
+        fields: ['id', 'posts', 'posts.comments.content'],
+      };
 
-    parser = new OptionsParser(options, {
-      collection: User,
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+
+      const params = parser.toSequelizeParams();
+      const postAssociationParams = params['include'][0];
+
+      expect(params['attributes']).toContain('id');
+      expect(postAssociationParams['association']).toEqual('posts');
+      expect(postAssociationParams['attributes']).toEqual({ include: [] });
+      expect(postAssociationParams['include'][0]['association']).toEqual('comments');
     });
-    params = parser.toSequelizeParams();
 
-    expect(params['include'][0]['attributes']['exclude']).toContain('id');
+    it('should handle except option', () => {
+      // fields with expect
+      const options = {
+        except: ['id'],
+      };
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+
+      const params = parser.toSequelizeParams();
+      expect(params['attributes']['exclude']).toContain('id');
+    });
+
+    it('should handle fields with except option', () => {
+      // expect with association
+      const options = {
+        fields: ['posts'],
+        except: ['posts.id'],
+      };
+
+      const parser = new OptionsParser(options, {
+        collection: User,
+      });
+      const params = parser.toSequelizeParams();
+
+      expect(params['include'][0]['attributes']['exclude']).toContain('id');
+    });
   });
 
   test('option parser with multiple association', () => {

package/src/__tests__/repository/find.test.ts

@@ -378,23 +378,33 @@ describe('repository find', () => {
     });
   });
 
-  it('should only output filed in fields args', async () => {
-    const resp = await User.model.findOne({
-      attributes: [],
-      include: [
-        {
-          association: 'profile',
-          attributes: ['salary'],
-        },
-      ],
-    });
+  describe('find with fields', () => {
+    it('should only output filed in fields args', async () => {
+      const users = await User.repository.find({
+        fields: ['profile.salary'],
+      });
 
-    const users = await User.repository.find({
-      fields: ['profile', 'profile.salary', 'profile.id'],
+      const firstUser = users[0].toJSON();
+      expect(Object.keys(firstUser)).toEqual(['profile']);
+      expect(Object.keys(firstUser.profile)).toEqual(['salary']);
     });
 
-    const firstUser = users[0].toJSON();
-    expect(Object.keys(firstUser)).toEqual(['profile']);
+    it('should output all fields when field has relation field', async () => {
+      const users = await User.repository.find({
+        fields: ['profile.salary', 'profile'],
+      });
+
+      const firstUser = users[0].toJSON();
+      expect(Object.keys(firstUser)).toEqual(['profile']);
+      expect(Object.keys(firstUser.profile)).toEqual([
+        'id',
+        'createdAt',
+        'updatedAt',
+        'salary',
+        'userId',
+        'description',
+      ]);
+    });
   });
 
   it('append with associations', async () => {

package/src/__tests__/view/view-collection.test.ts

@@ -18,131 +18,155 @@ pgOnly()('', () => {
     await db.close();
   });
 
-  it('should skip on delete on view collection', async () => {
-    const Order = db.collection({
-      name: 'orders',
-      fields: [
-        {
-          type: 'string',
-          name: 'name',
-        },
-        {
-          type: 'hasMany',
-          name: 'orderItems',
-          foreignKey: 'order_id',
-          target: 'orderItems',
-        },
-      ],
-    });
-
-    const OrderItem = db.collection({
-      name: 'orderItems',
-      timestamps: false,
-      fields: [
-        {
-          type: 'integer',
-          name: 'count',
-        },
-        {
-          type: 'belongsTo',
-          name: 'item',
-          target: 'items',
-          foreignKey: 'item_id',
-        },
-        {
-          type: 'belongsTo',
-          name: 'order',
-          target: 'orders',
-          foreignKey: 'order_id',
-          onDelete: 'NO ACTION',
-        },
-      ],
-    });
-
-    const Item = db.collection({
-      name: 'items',
-      fields: [{ name: 'name', type: 'string' }],
-    });
-
-    await db.sync();
-
-    const viewName = 'order_item_view';
+  describe('view as through table', () => {
+    let Order;
+    let OrderItem;
+    let Item;
+    let OrderItemView;
+
+    beforeEach(async () => {
+      Order = db.collection({
+        name: 'orders',
+        fields: [
+          {
+            type: 'string',
+            name: 'name',
+          },
+          {
+            type: 'hasMany',
+            name: 'orderItems',
+            foreignKey: 'order_id',
+            target: 'orderItems',
+          },
+        ],
+      });
 
-    const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
-    await db.sequelize.query(dropViewSQL);
+      OrderItem = db.collection({
+        name: 'orderItems',
+        timestamps: false,
+        fields: [
+          {
+            type: 'integer',
+            name: 'count',
+          },
+          {
+            type: 'belongsTo',
+            name: 'item',
+            target: 'items',
+            foreignKey: 'item_id',
+          },
+          {
+            type: 'belongsTo',
+            name: 'order',
+            target: 'orders',
+            foreignKey: 'order_id',
+            onDelete: 'NO ACTION',
+          },
+        ],
+      });
 
-    const viewSQL = `CREATE VIEW ${viewName} as SELECT orders.*, items.name as item_name FROM ${OrderItem.quotedTableName()} as orders INNER JOIN ${Item.quotedTableName()} as items ON orders.item_id = items.id`;
+      Item = db.collection({
+        name: 'items',
+        fields: [{ name: 'name', type: 'string' }],
+      });
 
-    await db.sequelize.query(viewSQL);
+      await db.sync();
 
-    const OrderItemView = db.collection({
-      name: viewName,
-      view: true,
-      schema: db.inDialect('postgres') ? 'public' : undefined,
-      fields: [
-        {
-          type: 'bigInt',
-          name: 'order_id',
-        },
-        {
-          type: 'bigInt',
-          name: 'item_id',
-          onDelete: 'CASCADE',
-        },
-      ],
-    });
+      const viewName = 'order_item_view';
 
-    await db.sync();
+      const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
+      await db.sequelize.query(dropViewSQL);
 
-    Order.setField('items', {
-      type: 'belongsToMany',
-      target: 'orderItems',
-      through: viewName,
-      foreignKey: 'order_id',
-      otherKey: 'item_id',
-      sourceKey: 'id',
-      targetKey: 'id',
-      onDelete: 'CASCADE',
-    });
+      const viewSQL = `CREATE VIEW ${viewName} as SELECT order_item.order_id as order_id, order_item.item_id as item_id, items.name as item_name FROM ${OrderItem.quotedTableName()} as order_item INNER JOIN ${Item.quotedTableName()} as items ON order_item.item_id = items.id`;
 
-    await db.sync();
+      await db.sequelize.query(viewSQL);
 
-    const order1 = await db.getRepository('orders').create({
-      values: {
-        name: 'order1',
-        orderItems: [
+      OrderItemView = db.collection({
+        name: viewName,
+        view: true,
+        schema: db.inDialect('postgres') ? 'public' : undefined,
+        fields: [
           {
-            count: 1,
-            item: {
-              name: 'item1',
-            },
+            type: 'bigInt',
+            name: 'order_id',
           },
           {
-            count: 2,
-            item: {
-              name: 'item2',
-            },
+            type: 'bigInt',
+            name: 'item_id',
+            onDelete: 'CASCADE',
           },
         ],
-      },
+      });
+
+      await db.sync();
+
+      Order.setField('items', {
+        type: 'belongsToMany',
+        target: 'items',
+        through: viewName,
+        foreignKey: 'order_id',
+        otherKey: 'item_id',
+        sourceKey: 'id',
+        targetKey: 'id',
+        onDelete: 'CASCADE',
+      });
+
+      await db.sync();
+
+      await db.getRepository('orders').create({
+        values: {
+          name: 'order1',
+          orderItems: [
+            {
+              count: 1,
+              item: {
+                name: 'item1',
+              },
+            },
+            {
+              count: 2,
+              item: {
+                name: 'item2',
+              },
+            },
+          ],
+        },
+      });
     });
 
-    const item1 = await db.getRepository('items').findOne({
-      filter: {
-        name: 'item1',
-      },
+    it('should skip on delete on view collection', async () => {
+      const order1 = await db.getRepository('orders').findOne({});
+
+      const item1 = await db.getRepository('items').findOne({
+        filter: {
+          name: 'item1',
+        },
+      });
+
+      let error;
+      try {
+        await db.getRepository('orders').destroy({
+          filterByTk: order1.get('id'),
+        });
+      } catch (err) {
+        error = err;
+      }
+
+      expect(error).toBeUndefined();
     });
 
-    let error;
-    try {
-      await db.getRepository('orders').destroy({
-        filterByTk: order1.get('id'),
+    it('should filter by view collection as through table', async () => {
+      const orders = await db.getRepository('orders').find({
+        appends: ['items'],
+        filter: {
+          items: {
+            name: 'not exists',
+          },
+        },
       });
-    } catch (err) {
-      error = err;
-    }
 
-    expect(error).toBeUndefined();
+      expect(orders).toHaveLength(0);
+    });
   });
 
   it('should update view collection', async () => {
@@ -196,7 +220,7 @@ pgOnly()('', () => {
     });
 
     // create INSTEAD OF INSERT trigger
-    await db.sequelize.query(`    
+    await db.sequelize.query(`
 CREATE OR REPLACE FUNCTION insert_users_with_group() RETURNS TRIGGER AS $$
 DECLARE
   new_group_id BIGINT;

package/src/options-parser.ts

@@ -240,6 +240,9 @@ export class OptionsParser {
   protected parseAppends(appends: Appends, filterParams: any) {
     if (!appends) return filterParams;
 
+    // sort appends by path length
+    appends = lodash.sortBy(appends, (append) => append.split('.').length);
+
     /**
      * set include params
      * @param model
@@ -287,6 +290,25 @@ export class OptionsParser {
       // if include from filter, remove fromFilter attribute
       if (existIncludeIndex != -1) {
         delete queryParams['include'][existIncludeIndex]['fromFilter'];
+
+        // set include attributes to all attributes
+        if (
+          Array.isArray(queryParams['include'][existIncludeIndex]['attributes']) &&
+          queryParams['include'][existIncludeIndex]['attributes'].length == 0
+        ) {
+          queryParams['include'][existIncludeIndex]['attributes'] = {
+            include: [],
+          };
+        }
+      }
+
+      if (
+        lastLevel &&
+        existIncludeIndex != -1 &&
+        lodash.get(queryParams, ['include', existIncludeIndex, 'attributes', 'include'])?.length == 0
+      ) {
+        // if append is last level and association exists, ignore it
+        return;
       }
 
       // if association not exist, create it

package/src/sync-runner.ts

@@ -20,7 +20,9 @@ export class SyncRunner {
 
     if (!parents) {
       throw new Error(
-        `Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${lodash
+        `Inherit model ${
+          inheritedCollection.name
+        } can't be created without parents, parents option is ${lodash
           .castArray(inheritedCollection.options.inherits)
           .join(', ')}`,
       );
@@ -58,7 +60,7 @@ export class SyncRunner {
         const columnDefault = sequenceNameResult[0][0]['column_default'];
 
         if (!columnDefault) {
-          throw new Error(`Can't find sequence name of ${parent}`);
+          throw new Error(`Can't find sequence name of parent collection ${parent.options.name}`);
         }
 
         const regex = new RegExp(/nextval\('(.*)'::regclass\)/);