@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.10

package/src/__tests__/field-options/sort-by.test.ts

@@ -0,0 +1,220 @@
+import { mockDatabase } from '@nocobase/test';
+import { BelongsToManyRepository, Database } from '../../index';
+
+describe('associated field order', () => {
+  let db: Database;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+
+    db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'posts',
+          sortBy: 'title',
+        },
+        {
+          type: 'hasMany',
+          name: 'records',
+          sortBy: 'count',
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'records',
+      fields: [
+        {
+          type: 'integer',
+          name: 'count',
+          hidden: true,
+        },
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'string',
+          name: 'title',
+        },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+          sortBy: 'name',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'images',
+          through: 'posts_images',
+          sortBy: ['-posts_images.sort'],
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'tags',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsToMany',
+          name: 'posts',
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'posts_images',
+      fields: [{ type: 'integer', name: 'sort' }],
+    });
+
+    db.collection({
+      name: 'images',
+      fields: [
+        {
+          type: 'belongsToMany',
+          name: 'posts',
+          through: 'posts_images',
+        },
+        {
+          type: 'string',
+          name: 'url',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  it('should sort hasMany association', async () => {
+    await db.getRepository('users').create({
+      values: {
+        name: 'u1',
+        posts: [{ title: 'c' }, { title: 'b' }, { title: 'a' }],
+      },
+    });
+
+    const u1 = await db.getRepository('users').findOne({
+      appends: ['posts'],
+    });
+
+    const u1Json = u1.toJSON();
+
+    const u1Posts = u1Json['posts'];
+    expect(u1Posts.map((p) => p['title'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should sort belongsToMany association', async () => {
+    await db.getRepository('posts').create({
+      values: {
+        title: 'p1',
+        tags: [{ name: 'c' }, { name: 'b' }, { name: 'a' }],
+      },
+    });
+
+    const p1 = await db.getRepository('posts').findOne({
+      appends: ['tags'],
+    });
+
+    const p1JSON = p1.toJSON();
+
+    const p1Tags = p1JSON['tags'];
+    expect(p1Tags.map((p) => p['name'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should sort nested associations', async () => {
+    await db.getRepository('users').create({
+      values: {
+        name: 'u1',
+        posts: [{ title: 'c', tags: [{ name: 'c' }, { name: 'b' }, { name: 'a' }] }, { title: 'b' }, { title: 'a' }],
+      },
+    });
+
+    const u1 = await db.getRepository('users').findOne({
+      appends: ['posts.tags'],
+    });
+
+    const u1Json = u1.toJSON();
+    const u1Posts = u1Json['posts'];
+    expect(u1Posts.map((p) => p['title'])).toEqual(['a', 'b', 'c']);
+
+    const postCTags = u1Posts[2]['tags'];
+    expect(postCTags.map((p) => p['name'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should sortBy hidden field', async () => {
+    await db.getRepository('users').create({
+      values: {
+        name: 'u1',
+        records: [
+          { count: 3, name: 'c' },
+          { count: 2, name: 'b' },
+          { count: 1, name: 'a' },
+        ],
+      },
+    });
+
+    const u1 = await db.getRepository('users').findOne({
+      appends: ['records'],
+    });
+
+    const u1Json = u1.toJSON();
+
+    const u1Records = u1Json['records'];
+    expect(u1Records[0].count).toBeUndefined();
+    expect(u1Records.map((p) => p['name'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should sortBy through table field', async () => {
+    const p1 = await db.getRepository('posts').create({
+      values: {
+        name: 'u1',
+      },
+    });
+
+    const t1 = await db.getRepository('images').create({
+      values: {
+        url: 't1',
+      },
+    });
+
+    const t2 = await db.getRepository('images').create({
+      values: {
+        url: 't2',
+      },
+    });
+
+    const postImageRepository = db.getRepository<BelongsToManyRepository>('posts.images', p1.get('id') as string);
+
+    await postImageRepository.add([[t2.get('id') as string, { sort: 2 }]]);
+    await postImageRepository.add([[t1.get('id') as string, { sort: 1 }]]);
+
+    const p1Result = await db.getRepository('posts').findOne({
+      appends: ['images'],
+    });
+
+    const p1JSON = p1Result.toJSON();
+    const p1Images = p1JSON['images'];
+    expect(p1Images.map((i) => i['url'])).toEqual(['t2', 't1']);
+  });
+});

package/src/__tests__/fields/belongs-to-field.test.ts

@@ -0,0 +1,162 @@
+import { Database } from '../../database';
+import { mockDatabase } from '../';
+
+describe('belongs to field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('association undefined', async () => {
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [{ type: 'belongsTo', name: 'post' }],
+    });
+    expect(Comment.model.associations['post']).toBeUndefined();
+  });
+
+  it('association defined', async () => {
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [
+        { type: 'string', name: 'content' },
+        { type: 'belongsTo', name: 'post' },
+      ],
+    });
+    expect(Comment.model.associations.post).toBeUndefined();
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+    const association = Comment.model.associations.post;
+    expect(Comment.model.associations.post).toBeDefined();
+    expect(association.foreignKey).toBe('postId');
+    // @ts-ignore
+    expect(association.targetKey).toBe('id');
+    expect(Comment.model.rawAttributes.postId).toBeDefined();
+    await db.sync();
+    const comment = await Comment.model.create<any>();
+    await comment.createPost({
+      title: 'title222',
+    });
+    const post1 = await comment.getPost();
+    expect(post1.toJSON()).toMatchObject({
+      title: 'title222',
+    });
+    const post = await Post.model.create<any>({
+      title: 'title111',
+    });
+    await comment.setPost(post);
+    const post2 = await comment.getPost();
+    expect(post2.toJSON()).toMatchObject({
+      title: 'title111',
+    });
+  });
+
+  it('custom targetKey and foreignKey', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'key', unique: true }],
+    });
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [
+        {
+          type: 'belongsTo',
+          name: 'post',
+          targetKey: 'key',
+          foreignKey: 'postKey',
+        },
+      ],
+    });
+    const association = Comment.model.associations.post;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('postKey');
+    // @ts-ignore
+    expect(association.targetKey).toBe('key');
+    expect(Comment.model.rawAttributes['postKey']).toBeDefined();
+  });
+
+  it('custom name and target', async () => {
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [
+        { type: 'string', name: 'content' },
+        {
+          type: 'belongsTo',
+          name: 'article',
+          target: 'posts',
+          targetKey: 'key',
+          foreignKey: 'postKey',
+        },
+      ],
+    });
+    expect(Comment.model.associations.article).toBeUndefined();
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'key', unique: true }],
+    });
+    const association = Comment.model.associations.article;
+    expect(Comment.model.associations.article).toBeDefined();
+    expect(association.foreignKey).toBe('postKey');
+    // @ts-ignore
+    expect(association.targetKey).toBe('key');
+    expect(Comment.model.rawAttributes.postKey).toBeDefined();
+    await db.sync();
+    const comment = await Comment.model.create<any>();
+    await comment.createArticle({
+      key: 'title222',
+    });
+    const post1 = await comment.getArticle();
+    expect(post1.toJSON()).toMatchObject({
+      key: 'title222',
+    });
+    const post = await Post.model.create<any>({
+      key: 'title111',
+    });
+    await comment.setArticle(post);
+    const post2 = await comment.getArticle();
+    expect(post2.toJSON()).toMatchObject({
+      key: 'title111',
+    });
+  });
+
+  it('schema delete', async () => {
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [{ type: 'belongsTo', name: 'post' }],
+    });
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments' }],
+    });
+    // await db.sync();
+    Comment.removeField('post');
+    expect(Comment.model.associations.post).toBeUndefined();
+    expect(Comment.model.rawAttributes.postId).toBeDefined();
+    Post.removeField('comments');
+    expect(Comment.model.rawAttributes.postId).toBeUndefined();
+  });
+
+  it('has inverse field', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments' }],
+    });
+
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [{ type: 'belongsTo', name: 'post' }],
+    });
+
+    const belongsToField = Comment.fields.get('post');
+    expect(belongsToField).toBeDefined();
+    const association = Post.model.associations;
+    expect(association['comments']).toBeDefined();
+  });
+});

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

@@ -0,0 +1,61 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('belongs to many field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('association undefined', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags' },
+      ],
+    });
+
+    expect(Post.model.associations.tags).toBeUndefined();
+    expect(db.getCollection('postsTags')).toBeUndefined();
+
+    const Tag = db.collection({
+      name: 'tags',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+    expect(Post.model.associations.tags).toBeDefined();
+    const Through = db.getCollection('postsTags');
+    expect(Through).toBeDefined();
+
+    expect(Through.model.rawAttributes['postId']).toBeDefined();
+    expect(Through.model.rawAttributes['tagId']).toBeDefined();
+  });
+
+  test('redefine collection', () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags' },
+      ],
+    });
+
+    expect(Post.model.associations.tags).toBeUndefined();
+    expect(db.getCollection('postsTags')).toBeUndefined();
+
+    const Tag = db.collection({
+      name: 'tags',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    const PostTag = db.collection({ name: 'postsTags' });
+
+    expect(PostTag.model.rawAttributes['postId']).toBeDefined();
+    expect(PostTag.model.rawAttributes['tagId']).toBeDefined();
+  });
+});

package/src/__tests__/fields/context-field.test.ts

@@ -0,0 +1,140 @@
+import { DataTypes } from 'sequelize';
+import { mockDatabase } from '../';
+import { Database } from '../../';
+
+describe('context field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  describe('dataType', () => {
+    it('case 1, string', async () => {
+      const Test = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'context',
+            name: 'clientIp',
+            dataIndex: 'request.ip',
+            dataType: 'string',
+          },
+        ],
+      });
+      const attribute = Test.model.rawAttributes['clientIp'];
+      expect(attribute.type).toBeInstanceOf(DataTypes.STRING);
+    });
+
+    it('case 2, integer', async () => {
+      const Test = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'context',
+            name: 'userId',
+            dataIndex: 'state.currentUser.id',
+            dataType: 'integer',
+          },
+        ],
+      });
+      const attribute = Test.model.rawAttributes['userId'];
+      expect(attribute.type).toBeInstanceOf(DataTypes.INTEGER);
+    });
+
+    it('case 3, json', async () => {
+      const Test = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'context',
+            name: 'ua',
+            dataIndex: 'userAgent',
+            dataType: 'json',
+          },
+        ],
+      });
+      const attribute = Test.model.rawAttributes['ua'];
+      expect(attribute.type).toBeInstanceOf(DataTypes.JSON);
+    });
+  });
+
+  describe('create and update', () => {
+    it('case 1', async () => {
+      const Test = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'context',
+            name: 'clientIp',
+            dataIndex: 'request.ip',
+            dataType: 'string',
+          },
+        ],
+      });
+      await db.sync();
+      const t1 = await Test.repository.create({
+        values: {},
+        context: {
+          request: {
+            ip: '11.22.33.44',
+          },
+        },
+      });
+      expect(t1.get('clientIp')).toBe('11.22.33.44');
+      const [t2] = await Test.repository.update({
+        filterByTk: t1.get('id') as any,
+        values: {},
+        context: {
+          request: {
+            ip: '11.22.33.55',
+          },
+        },
+      });
+      expect(t2.get('clientIp')).toBe('11.22.33.55');
+      const t3 = await Test.repository.findOne();
+      expect(t3.get('clientIp')).toBe('11.22.33.55');
+    });
+
+    it('case 2, createOnly = true', async () => {
+      const Test = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'context',
+            name: 'clientIp',
+            dataIndex: 'request.ip',
+            dataType: 'string',
+            createOnly: true,
+          },
+        ],
+      });
+      await db.sync();
+      const t1 = await Test.repository.create({
+        values: {},
+        context: {
+          request: {
+            ip: '11.22.33.44',
+          },
+        },
+      });
+      expect(t1.get('clientIp')).toBe('11.22.33.44');
+      const [t2] = await Test.repository.update({
+        filterByTk: t1.get('id') as any,
+        values: {},
+        context: {
+          request: {
+            ip: '11.22.33.55',
+          },
+        },
+      });
+      expect(t2.get('clientIp')).toBe('11.22.33.44');
+      const t3 = await Test.repository.findOne();
+      expect(t3.get('clientIp')).toBe('11.22.33.44');
+    });
+  });
+});