@nocobase/database 0.5.0-alpha.37 → 0.7.0-alpha.1

package/src/__tests__/magic-attribute-model.test.ts

@@ -0,0 +1,103 @@
+import { mockDatabase } from '.';
+import { Database, MagicAttributeModel } from '..';
+
+describe('magic-attribute-model', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('case 1', async () => {
+    db.registerModels({ MagicAttributeModel });
+
+    const Test = db.collection({
+      name: 'tests',
+      model: 'MagicAttributeModel',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'json', name: 'options' },
+      ],
+    });
+
+    await db.sync();
+
+    const test = await Test.model.create({
+      title: 'aa',
+      'x-component-props': { key1: 'val1', arr1: [1, 2, 3], arr2: [4, 5] },
+    });
+
+    test.set({
+      'x-component-props': { key2: 'val2', arr1: [3, 4] },
+      'x-decorator-props': { key1: 'val1' },
+    });
+
+    test.set('x-component-props', { arr2: [1, 2, 3] });
+
+    await test.save();
+
+    expect(test.toJSON()).toMatchObject({
+      title: 'aa',
+      'x-component-props': {
+        key1: 'val1',
+        key2: 'val2',
+        arr1: [3, 4],
+        arr2: [1, 2, 3],
+      },
+      'x-decorator-props': { key1: 'val1' },
+    });
+  });
+
+  it('case 2', async () => {
+    db.registerModels({ MagicAttributeModel });
+
+    const Test = db.collection({
+      name: 'tests',
+      model: 'MagicAttributeModel',
+      magicAttribute: 'schema',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'json', name: 'schema' },
+      ],
+    });
+
+    await db.sync();
+
+    let test = await Test.model.create({
+      title: 'aa',
+      'x-component-props': { key1: 'val1', arr1: [1, 2, 3], arr2: [4, 5] },
+    });
+
+    test.set({
+      'x-component-props': { key2: 'val2', arr1: [3, 4] },
+      'x-decorator-props': { key1: 'val1' },
+    });
+
+    test.set('x-component-props', { arr2: [1, 2, 3] });
+
+    await test.save();
+
+    test = await Test.model.findByPk(test.get('id') as string);
+
+    await test.update({
+      'x-component-props': { arr2: [1, 2, 3, 4] },
+    });
+
+    test = await Test.model.findByPk(test.get('id') as string);
+
+    expect(test.toJSON()).toMatchObject({
+      title: 'aa',
+      'x-component-props': {
+        key1: 'val1',
+        key2: 'val2',
+        arr1: [3, 4],
+        arr2: [1, 2, 3, 4],
+      },
+      'x-decorator-props': { key1: 'val1' },
+    });
+  });
+});

package/src/__tests__/model.test.ts

@@ -0,0 +1,60 @@
+import { Database, mockDatabase } from '@nocobase/database';
+
+describe('model', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  describe('toJSON', () => {
+    it('should return null when belongsTo association empty', async () => {
+      const user = db.collection({
+        name: 'users',
+        fields: [
+          { type: 'string', name: 'name' },
+          { type: 'hasMany', name: 'posts' },
+        ],
+      });
+
+      const posts = db.collection({
+        name: 'posts',
+        fields: [
+          {
+            type: 'string',
+            name: 'title',
+          },
+          {
+            type: 'belongsTo',
+            name: 'user',
+          },
+        ],
+      });
+
+      await db.sync();
+
+      const u1 = await db.getRepository('users').create({
+        values: {
+          name: 'u1',
+        },
+      });
+
+      await db.getRepository('posts').create({
+        values: {
+          title: 'p1',
+        },
+      });
+
+      const p1 = await db.getRepository('posts').findOne({
+        appends: ['user'],
+      });
+
+      const p1JSON = p1.toJSON();
+      expect(p1JSON['user']).toBeNull();
+    });
+  });
+});

package/src/__tests__/operator/array-operator.test.ts

@@ -0,0 +1,268 @@
+import { mockDatabase } from '../index';
+import Database from '../../database';
+
+describe('array field operator', function () {
+  let db: Database;
+  let Test;
+
+  let t1;
+  let t2;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase({});
+    Test = db.collection({
+      name: 'test',
+      fields: [
+        { type: 'array', name: 'selected' },
+        { type: 'string', name: 'name' },
+      ],
+    });
+
+    await db.sync({ force: true });
+
+    t1 = await Test.repository.create({
+      values: {
+        selected: ['1', '2', 'a', 'b'],
+        name: 't1',
+      },
+    });
+
+    t2 = await Test.repository.create({
+      values: {
+        selected: ['11', '22', 'aa', 'bb', 'cc'],
+        name: 't2',
+      },
+    });
+  });
+
+  test('array field update', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'array', name: 'tags' }],
+    });
+
+    await db.sync({ force: true });
+
+    await Post.repository.create({});
+    const p1 = await Post.repository.create({
+      values: {
+        tags: ['t1', 't2'],
+      },
+    });
+
+    let result = await Post.repository.findOne({
+      filter: {
+        'tags.$match': ['t2', 't1'],
+      },
+    });
+
+    expect(result.get('id')).toEqual(p1.get('id'));
+
+    await Post.repository.update({
+      filterByTk: <any>p1.get('id'),
+      values: {
+        tags: ['t3', 't2'],
+      },
+    });
+
+    result = await Post.repository.findOne({
+      filter: {
+        'tags.$match': ['t3', 't2'],
+      },
+    });
+
+    expect(result.get('id')).toEqual(p1.get('id'));
+  });
+
+  test('nested array field', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'hasMany', name: 'posts' },
+        { type: 'string', name: 'name' },
+      ],
+    });
+
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'belongsTo', name: 'user' },
+        { type: 'string', name: 'title' },
+        { type: 'array', name: 'tags' },
+      ],
+    });
+
+    await db.sync();
+
+    await User.repository.createMany({
+      records: [
+        {
+          name: 'u0',
+          posts: [{ title: 'u0p1' }],
+        },
+        {
+          name: 'u1',
+          posts: [{ title: 'u1p1', tags: ['t1', 't2'] }],
+        },
+      ],
+    });
+
+    let result = await User.repository.find({
+      filter: {
+        'posts.tags.$empty': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('name')).toEqual('u0');
+
+    result = await User.repository.find({
+      filter: {
+        'posts.tags.$anyOf': ['t1'],
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('name')).toEqual('u1');
+  });
+
+  test('$match', async () => {
+    const filter1 = await Test.repository.find({
+      filter: {
+        'selected.$match': ['2', '1', 'a', 'b'],
+      },
+    });
+
+    expect(filter1.length).toEqual(1);
+    expect(filter1[0].get('name')).toEqual(t1.get('name'));
+  });
+
+  test('$match with $and', async () => {
+    const filter1 = await Test.repository.find({
+      filter: {
+        $and: [
+          {
+            selected: { $match: ['2', '1', 'a', 'b'] },
+          },
+        ],
+      },
+    });
+
+    expect(filter1.length).toEqual(1);
+    expect(filter1[0].get('name')).toEqual(t1.get('name'));
+  });
+
+  test('$notMatch', async () => {
+    const filter2 = await Test.repository.find({
+      filter: {
+        'selected.$notMatch': ['1', '2', 'a', 'b'],
+      },
+    });
+
+    expect(filter2.length).toEqual(1);
+    expect(filter2[0].get('name')).toEqual(t2.get('name'));
+  });
+
+  test('$anyOf with $and', async () => {
+    const filter3 = await Test.repository.find({
+      filter: {
+        $and: [
+          {
+            'selected.$anyOf': ['aa'],
+          },
+        ],
+      },
+    });
+
+    expect(filter3.length).toEqual(1);
+    expect(filter3[0].get('name')).toEqual(t2.get('name'));
+  });
+
+  test('$anyOf', async () => {
+    const filter3 = await Test.repository.find({
+      filter: {
+        'selected.$anyOf': ['aa'],
+      },
+    });
+
+    expect(filter3.length).toEqual(1);
+    expect(filter3[0].get('name')).toEqual(t2.get('name'));
+  });
+
+  test('$anyOf with multiple items', async () => {
+    const filter3 = await Test.repository.find({
+      filter: {
+        'selected.$anyOf': ['aa', 'a', '1'],
+      },
+    });
+
+    expect(filter3.length).toEqual(2);
+  });
+
+  test('$noneOf', async () => {
+    const filter = await Test.repository.find({
+      filter: {
+        'selected.$noneOf': ['aa'],
+      },
+    });
+
+    expect(filter.length).toEqual(1);
+    expect(filter[0].get('name')).toEqual(t1.get('name'));
+  });
+
+  test('$noneOf with null', async () => {
+    const t3 = await Test.repository.create({
+      values: {
+        name: 't3',
+        selected: null,
+      },
+    });
+
+    const filter = await Test.repository.find({
+      filter: {
+        'selected.$noneOf': ['a', 'aa', '1'],
+      },
+    });
+
+    expect(filter.length).toEqual(1);
+    expect(filter[0].get('name')).toEqual(t3.get('name'));
+  });
+
+  test('$empty', async () => {
+    const t3 = await Test.repository.create({
+      values: {
+        name: 't3',
+        selected: [],
+      },
+    });
+
+    const filter = await Test.repository.find({
+      filter: {
+        'selected.$empty': true,
+      },
+    });
+    expect(filter.length).toEqual(1);
+    expect(filter[0].get('name')).toEqual(t3.get('name'));
+  });
+
+  test('$notEmpty', async () => {
+    const t3 = await Test.repository.create({
+      values: {
+        name: 't3',
+        selected: [],
+      },
+    });
+
+    const filter = await Test.repository.find({
+      filter: {
+        'selected.$notEmpty': true,
+      },
+    });
+
+    expect(filter.length).toEqual(2);
+  });
+});

package/src/__tests__/operator/association-operator.test.ts

@@ -0,0 +1,263 @@
+import Database from '../../database';
+import { Collection } from '../../collection';
+
+import { mockDatabase } from '../index';
+
+describe('association operator', () => {
+  let db: Database;
+
+  let Group: Collection;
+
+  let User: Collection;
+  let Profile: Collection;
+  let Post: Collection;
+  let Tag: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    Group = db.collection({
+      name: 'groups',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'users' },
+      ],
+    });
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'belongsTo', name: 'group' },
+
+        { type: 'string', name: 'name' },
+        {
+          type: 'hasMany',
+          name: 'posts',
+        },
+      ],
+    });
+
+    Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+        },
+      ],
+    });
+
+    Tag = db.collection({
+      name: 'tags',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsToMany',
+          name: 'posts',
+        },
+      ],
+    });
+
+    await db.sync({
+      force: true,
+    });
+  });
+
+  test('nested association', async () => {
+    const u1 = await User.repository.create({
+      values: {
+        name: 'u1',
+        posts: [
+          {
+            title: 'u1p1',
+          },
+        ],
+      },
+    });
+
+    const u2 = await User.repository.create({
+      values: {
+        name: 'u2',
+        posts: [
+          {
+            title: 'u1p1',
+          },
+          {
+            title: 'u1p2',
+            tags: [
+              {
+                name: 't1',
+              },
+            ],
+          },
+        ],
+      },
+    });
+
+    const u3 = await User.repository.create({
+      values: {
+        name: 'u3',
+      },
+    });
+
+    let result = await User.repository.find({
+      filter: {
+        'posts.tags.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('id')).toEqual(u2.get('id'));
+
+    result = await User.repository.find({
+      filter: {
+        'posts.tags.id.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('id')).toEqual(u2.get('id'));
+  });
+
+  test('belongs to', async () => {
+    const g1 = await Group.repository.create({
+      values: {
+        name: 'g1',
+      },
+    });
+
+    const u1 = await User.repository.create({
+      values: {
+        name: 'u1',
+        group: g1['id'],
+      },
+    });
+
+    const u2 = await User.repository.create({
+      values: {
+        name: 'u2',
+      },
+    });
+
+    let result = await User.repository.find({
+      filter: {
+        'group.id.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('name')).toEqual(u1.get('name'));
+
+    result = await User.repository.find({
+      filter: {
+        'group.id.$notExists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('name')).toEqual(u2.get('name'));
+  });
+
+  test('belongs to many', async () => {
+    const t1 = await Tag.repository.create({
+      values: {
+        name: 't1',
+      },
+    });
+
+    const t2 = await Tag.repository.create({
+      values: {
+        name: 't2',
+      },
+    });
+
+    const t3 = await Tag.repository.create({
+      values: {
+        name: 't3',
+      },
+    });
+
+    const p1 = await Post.repository.create({
+      values: {
+        title: 'p1',
+      },
+    });
+
+    // p2 belongs to many t1 t2
+    const p2 = await Post.repository.create({
+      values: {
+        title: 'p2',
+        tags: [t1['id'], t2['id']],
+      },
+    });
+
+    const p3 = await Post.repository.create({
+      values: {
+        title: 'p3',
+      },
+    });
+
+    let result = await Post.repository.find({
+      filter: {
+        'tags.id.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('title')).toEqual(p2.get('title'));
+
+    result = await Tag.repository.find({
+      filter: {
+        'posts.id.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(2);
+    expect(result.map((r) => r.get('id'))).toEqual([t1.get('id'), t2.get('id')]);
+
+    result = await Tag.repository.find({
+      filter: {
+        'posts.id.$notExists': true,
+      },
+    });
+    expect(result.length).toEqual(1);
+    expect(result[0].get('id')).toEqual(t3.get('id'));
+  });
+
+  test('has many', async () => {
+    const u1 = await User.repository.create({
+      values: {
+        name: 'u1',
+        posts: [
+          {
+            title: 'p1',
+          },
+          { title: 'p2' },
+        ],
+      },
+    });
+
+    const u2 = await User.repository.create({
+      values: {
+        name: 'u2',
+      },
+    });
+
+    const result = await User.repository.find({
+      filter: {
+        'posts.id.$exists': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('id')).toEqual(u1.get('id'));
+  });
+});