@nocobase/database 0.9.2-alpha.3 → 0.9.3-alpha.1

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

@@ -1,7 +1,264 @@
 import { mockDatabase } from '../index';
 import Database from '@nocobase/database';
 import { Collection } from '../../collection';
-import { OptionsParser } from '../../options-parser';
+
+describe('find with associations', () => {
+  let db: Database;
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should filter by association array field', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'posts',
+        },
+      ],
+    });
+
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'array',
+          name: 'tags',
+        },
+        {
+          type: 'string',
+          name: 'title',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await User.repository.create({
+      values: [
+        {
+          name: 'u1',
+          posts: [
+            {
+              tags: ['t1'],
+              title: 'u1p1',
+            },
+          ],
+        },
+      ],
+    });
+
+    const posts = await Post.repository.find({
+      filter: {
+        tags: {
+          $match: ['t1'],
+        },
+      },
+    });
+
+    expect(posts.length).toEqual(1);
+
+    const filter = {
+      $and: [
+        {
+          posts: {
+            tags: {
+              $match: ['t1'],
+            },
+          },
+        },
+      ],
+    };
+
+    const results = await User.repository.find({
+      filter,
+    });
+
+    expect(results[0].get('name')).toEqual('u1');
+  });
+
+  it('should filter with append', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { name: 'title', type: 'string' },
+        {
+          name: 'user',
+          type: 'belongsTo',
+        },
+        {
+          name: 'category',
+          type: 'belongsTo',
+        },
+      ],
+    });
+
+    const Category = db.collection({
+      name: 'categories',
+      fields: [
+        {
+          name: 'name',
+          type: 'string',
+        },
+      ],
+    });
+
+    const User = db.collection({
+      name: 'users',
+      fields: [
+        { name: 'name', type: 'string' },
+        { type: 'belongsTo', name: 'organization' },
+        {
+          type: 'belongsTo',
+          name: 'department',
+        },
+      ],
+    });
+
+    const Org = db.collection({
+      name: 'organizations',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    const Dept = db.collection({
+      name: 'departments',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    await db.sync();
+
+    await Post.repository.create({
+      values: [
+        {
+          title: 'p1',
+          category: { name: 'c1' },
+          user: {
+            name: 'u1',
+            organization: {
+              name: 'o1',
+            },
+            department: {
+              name: 'd1',
+            },
+          },
+        },
+        {
+          title: 'p2',
+          category: { name: 'c2' },
+          user: {
+            name: 'u2',
+            organization: {
+              name: 'o2',
+            },
+            department: {
+              name: 'd2',
+            },
+          },
+        },
+      ],
+    });
+
+    const filterResult = await Post.repository.find({
+      appends: ['user.department'],
+      filter: {
+        'user.name': 'u1',
+      },
+    });
+
+    expect(filterResult[0].user.department).toBeDefined();
+  });
+
+  it('should filter by association field', async () => {
+    const User = db.collection({
+      name: 'users',
+      tree: 'adjacency-list',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'posts', target: 'posts', foreignKey: 'user_id' },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          foreignKey: 'parent_id',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          foreignKey: 'parent_id',
+          treeChildren: true,
+        },
+      ],
+    });
+
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'belongsTo', name: 'user', target: 'users', foreignKey: 'user_id' },
+      ],
+    });
+
+    await db.sync();
+
+    expect(User.options.tree).toBeTruthy();
+
+    await User.repository.create({
+      values: [
+        {
+          name: 'u1',
+          posts: [
+            {
+              title: 'u1p1',
+            },
+          ],
+          children: [
+            {
+              name: 'u2',
+              posts: [
+                {
+                  title: '标题2',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    const filter = {
+      $and: [
+        {
+          children: {
+            posts: {
+              title: {
+                $eq: '标题2',
+              },
+            },
+          },
+        },
+      ],
+    };
+
+    const [findResult, count] = await User.repository.findAndCount({
+      filter,
+      offset: 0,
+      limit: 20,
+    });
+
+    expect(findResult[0].get('name')).toEqual('u1');
+  });
+});
 
 describe('repository find', () => {
   let db: Database;

package/src/__tests__/tree.test.ts

@@ -1,17 +1,184 @@
 import { Database } from '../database';
 import { mockDatabase } from './';
+import { AdjacencyListRepository } from '../tree-repository/adjacency-list-repository';
 
-describe('sort', function () {
+describe('tree test', function () {
   let db: Database;
 
   beforeEach(async () => {
-    db = mockDatabase();
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({ drop: true });
   });
 
   afterEach(async () => {
     await db.close();
   });
 
+  it('should works with appends option', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          treeChildren: true,
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await collection.repository.create({
+      values: [
+        {
+          name: 'c1',
+          children: [
+            {
+              name: 'c11',
+            },
+            {
+              name: 'c12',
+            },
+          ],
+        },
+        {
+          name: 'c2',
+        },
+      ],
+    });
+
+    const tree = await collection.repository.find({
+      tree: true,
+      filter: {
+        parentId: null,
+      },
+      fields: ['name'],
+    });
+
+    expect(tree.length).toBe(2);
+  });
+
+  it('should not return children property when child nodes are empty', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          treeChildren: true,
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await collection.repository.create({
+      values: [
+        {
+          name: 'c1',
+          children: [
+            {
+              name: 'c11',
+            },
+            {
+              name: 'c12',
+            },
+          ],
+        },
+        {
+          name: 'c2',
+        },
+      ],
+    });
+
+    const tree = await collection.repository.find({
+      filter: {
+        parentId: null,
+      },
+      tree: true,
+    });
+
+    const c2 = tree.find((item) => item.name === 'c2');
+    expect(c2.toJSON()['children']).toBeUndefined();
+
+    const c11 = tree
+      .find((item) => item.name === 'c1')
+      .get('children')
+      .find((item) => item.name === 'c11');
+
+    expect(c11.toJSON()['children']).toBeUndefined();
+  });
+
+  it('should add sort field', async () => {
+    const Tasks = db.collection({
+      name: 'tasks',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          treeChildren: true,
+        },
+        {
+          type: 'string',
+          name: 'status',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await Tasks.repository.create({
+      values: {
+        name: 'task1',
+        status: 'doing',
+      },
+    });
+
+    await Tasks.repository.create({
+      values: {
+        name: 'task2',
+        status: 'pending',
+      },
+    });
+
+    await Tasks.repository.create({
+      values: {
+        name: 'task3',
+        status: 'pending',
+      },
+    });
+
+    Tasks.setField('sort', { type: 'sort', scopeKey: 'status' });
+
+    await db.sync();
+  });
+
   it('should be auto completed', () => {
     const collection = db.collection({
       name: 'categories',
@@ -162,7 +329,7 @@ describe('sort', function () {
     expect(instance.toJSON()).toMatchObject(values[0]);
   });
 
-  it('should be tree', async () => {
+  it('should find tree collection', async () => {
     const collection = db.collection({
       name: 'categories',
       tree: 'adjacency-list',
@@ -214,4 +381,100 @@ describe('sort', function () {
 
     expect(instance.toJSON()).toMatchObject(values[0]);
   });
+
+  it('should get adjacency list repository', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          foreignKey: 'parentId',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          foreignKey: 'parentId',
+          treeChildren: true,
+        },
+      ],
+    });
+
+    const repository = db.getRepository('categories');
+    expect(repository).toBeInstanceOf(AdjacencyListRepository);
+  });
+
+  test('performance', async () => {
+    const collection = db.collection({
+      name: 'categories',
+      tree: 'adjacency-list',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsTo',
+          name: 'parent',
+          foreignKey: 'parentId',
+          treeParent: true,
+        },
+        {
+          type: 'hasMany',
+          name: 'children',
+          foreignKey: 'parentId',
+          treeChildren: true,
+        },
+      ],
+    });
+    await db.sync();
+
+    const values = [];
+    for (let i = 0; i < 10; i++) {
+      const children = [];
+      for (let j = 0; j < 10; j++) {
+        const grandchildren = [];
+        for (let k = 0; k < 10; k++) {
+          grandchildren.push({
+            name: `name-${i}-${j}-${k}`,
+          });
+        }
+        children.push({
+          name: `name-${i}-${j}`,
+          children: grandchildren,
+        });
+      }
+
+      values.push({
+        name: `name-${i}`,
+        description: `description-${i}`,
+        children,
+      });
+    }
+
+    await db.getRepository('categories').create({
+      values,
+    });
+
+    const before = Date.now();
+
+    const instances = await db.getRepository('categories').find({
+      filter: {
+        parentId: null,
+      },
+      tree: true,
+      fields: ['id', 'name'],
+      sort: 'id',
+      limit: 10,
+    });
+
+    const after = Date.now();
+    console.log(after - before);
+  });
 });

package/src/collection.ts

@@ -14,6 +14,7 @@ import { BelongsToField, Field, FieldOptions, HasManyField } from './fields';
 import { Model } from './model';
 import { Repository } from './repository';
 import { checkIdentifier, md5, snakeCase } from './utils';
+import { AdjacencyListRepository } from './tree-repository/adjacency-list-repository';
 
 export type RepositoryType = typeof Repository;
 
@@ -223,6 +224,11 @@ export class Collection<
     if (typeof repository === 'string') {
       repo = this.context.database.repositories.get(repository) || Repository;
     }
+
+    if (this.options.tree == 'adjacency-list' || this.options.tree == 'adjacencyList') {
+      repo = AdjacencyListRepository;
+    }
+
     this.repository = new repo(this);
   }
 

package/src/fields/field.ts

@@ -217,6 +217,7 @@ export abstract class Field {
   bind() {
     const { model } = this.context.collection;
     model.rawAttributes[this.name] = this.toSequelize();
+
     // @ts-ignore
     model.refreshAttributes();
     if (this.options.index) {
@@ -226,6 +227,9 @@ export abstract class Field {
 
   unbind() {
     const { model } = this.context.collection;
+
+    delete model.prototype[this.name];
+
     model.removeAttribute(this.name);
     if (this.options.index || this.options.unique) {
       this.context.collection.removeIndex([this.name]);

package/src/listeners/adjacency-list.ts

@@ -17,44 +17,3 @@ export const beforeDefineAdjacencyListCollection = (options: CollectionOptions)
     }
   });
 };
-
-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

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

package/src/operators/array.ts

@@ -11,6 +11,11 @@ const escape = (value, ctx) => {
   return sequelize.escape(value);
 };
 
+const getQueryInterface = (ctx) => {
+  const sequelize = ctx.db.sequelize;
+  return sequelize.getQueryInterface();
+};
+
 const sqliteExistQuery = (value, ctx) => {
   const fieldName = getFieldName(ctx);
   const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
@@ -45,10 +50,9 @@ export default {
     const fieldName = getFieldName(ctx);
 
     if (isPg(ctx)) {
-      return {
-        [Op.contained]: value,
-        [Op.contains]: value,
-      };
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      const queryValue = escape(JSON.stringify(value), ctx);
+      return Sequelize.literal(`${name} @> ${queryValue}::JSONB AND ${name} <@ ${queryValue}::JSONB`);
     }
 
     value = escape(JSON.stringify(value.sort()), ctx);

package/src/options-parser.ts

@@ -249,6 +249,11 @@ export class OptionsParser {
       }
 
       if (appendFields.length == 2) {
+        const association = associations[appendFields[0]];
+        if (!association) {
+          throw new Error(`association ${appendFields[0]} in ${model.name} not found`);
+        }
+
         const associationModel = associations[appendFields[0]].target;
         if (associationModel.rawAttributes[appendFields[1]]) {
           lastLevel = true;
@@ -307,6 +312,13 @@ export class OptionsParser {
           attributes,
         };
       } else {
+        const existInclude = queryParams['include'][existIncludeIndex];
+        if (existInclude.attributes && Array.isArray(existInclude.attributes) && existInclude.attributes.length == 0) {
+          existInclude.attributes = {
+            include: [],
+          };
+        }
+
         setInclude(
           model.associations[queryParams['include'][existIncludeIndex].association].target,
           queryParams['include'][existIncludeIndex],