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

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

@@ -0,0 +1,165 @@
+import { mockDatabase } from '../index';
+import { Collection } from '../../collection';
+import Database from '../../database';
+
+describe('date operator test', () => {
+  let db: Database;
+
+  let User: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        {
+          name: 'birthday',
+          type: 'date',
+        },
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+
+    await db.sync({ force: true, alter: { drop: false } });
+  });
+
+  test('$dateOn', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-01-02 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateOn': '1990-01-01' },
+    });
+
+    expect(user.get('id')).toEqual(user1.get('id'));
+  });
+
+  test('$dateNotOn', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-01-02 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateNotOn': '1990-01-01' },
+    });
+
+    expect(user.get('id')).toEqual(u0.get('id'));
+  });
+
+  test('$dateBefore', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-05-01 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateBefore': '1990-04-01' },
+    });
+
+    expect(user.get('id')).toEqual(user1.get('id'));
+  });
+
+  test('$dateNotBefore', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-05-01 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateNotBefore': '1990-04-01' },
+    });
+
+    expect(user.get('id')).toEqual(u0.get('id'));
+  });
+
+  test('$dateAfter', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-05-01 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateAfter': '1990-04-01' },
+    });
+
+    expect(user.get('id')).toEqual(u0.get('id'));
+  });
+
+  test('$dateNotAfter', async () => {
+    const u0 = await User.repository.create({
+      values: {
+        birthday: '1990-05-01 12:03:02',
+        name: 'u0',
+      },
+    });
+
+    const user1 = await User.repository.create({
+      values: {
+        birthday: '1990-01-01 12:03:02',
+        name: 'user1',
+      },
+    });
+
+    const user = await User.repository.findOne({
+      filter: { 'birthday.$dateNotAfter': '1990-04-01' },
+    });
+
+    expect(user.get('id')).toEqual(user1.get('id'));
+  });
+});

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

@@ -0,0 +1,77 @@
+import Database from '../../database';
+import { Collection } from '../../collection';
+
+import { mockDatabase } from '../index';
+
+describe('empty operator', () => {
+  let db: Database;
+
+  let User: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase({});
+    User = db.collection({
+      name: 'users',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync({
+      force: true,
+    });
+  });
+
+  test('string field empty', async () => {
+    const u1 = await User.repository.create({
+      values: {
+        name: 'u1',
+      },
+    });
+
+    const u2 = await User.repository.create({
+      values: {
+        name: '',
+      },
+    });
+
+    const result = await User.repository.find({
+      filter: {
+        'name.$empty': true,
+      },
+    });
+
+    expect(result.length).toEqual(1);
+    expect(result[0].get('id')).toEqual(u2.get('id'));
+  });
+
+  test('string empty with or operator ', async () => {
+    const u1 = await User.repository.create({
+      values: {
+        name: 'u1',
+      },
+    });
+
+    const u2 = await User.repository.create({
+      values: {
+        name: '',
+      },
+    });
+
+    const u3 = await User.repository.create({
+      values: {
+        name: 'u3',
+      },
+    });
+
+    const result = await User.repository.find({
+      filter: {
+        $or: [{ 'name.$empty': true }, { name: 'u1' }],
+      },
+    });
+
+    expect(result.length).toEqual(2);
+  });
+});

package/src/__tests__/operator/ne.test.ts

@@ -0,0 +1,33 @@
+import { mockDatabase } from '../index';
+import Database from '../../database';
+
+describe('ne operator', () => {
+  let db: Database;
+  let Test;
+  beforeEach(async () => {
+    db = mockDatabase({});
+
+    Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should ne with null', async () => {
+    await db.getRepository('tests').create({});
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$ne': '123',
+      },
+    });
+
+    expect(results).toEqual(1);
+  });
+});

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

@@ -0,0 +1,62 @@
+import Database, { Collection, mockDatabase } from '@nocobase/database';
+
+describe('string operator', () => {
+  let db: Database;
+
+  let User: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase({});
+
+    await db.clean({ drop: true });
+
+    User = db.collection({
+      name: 'users',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync({
+      force: true,
+    });
+  });
+
+  it('should query with include operator', async () => {
+    const u1 = await db.getRepository('users').create({
+      values: {
+        name: 'names of u1',
+      },
+    });
+
+    const u1Res = await db.getRepository('users').findOne({
+      filter: {
+        'name.$includes': 'u1',
+      },
+    });
+
+    expect(u1Res.get('id')).toEqual(u1.get('id'));
+  });
+
+  it('should query with and ', async () => {
+    const u1 = await db.getRepository('users').create({
+      values: {
+        name: 'names of u1',
+      },
+    });
+
+    const u1Res = await db.getRepository('users').findOne({
+      filter: {
+        $and: [
+          {
+            'name.$includes': 'u1',
+          },
+        ],
+      },
+    });
+
+    expect(u1Res.get('id')).toEqual(u1.get('id'));
+  });
+});

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

@@ -0,0 +1,185 @@
+import { Collection } from '../collection';
+import { mockDatabase } from './index';
+import { OptionsParser } from '../options-parser';
+import { Database } from '../database';
+
+describe('option parser', () => {
+  let db: Database;
+  let User: Collection;
+  let Post: Collection;
+  let Comment: Collection;
+  let Tag: Collection;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    User = db.collection<{ id: number; name: string }, { name: string }>({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'integer', name: 'age' },
+        { type: 'hasMany', name: 'posts' },
+      ],
+    });
+
+    Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+        {
+          type: 'hasMany',
+          name: 'comments',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+        },
+      ],
+    });
+
+    Comment = db.collection({
+      name: 'comments',
+      fields: [
+        { type: 'string', name: 'content' },
+        { type: 'belongsTo', name: 'posts' },
+      ],
+    });
+
+    Tag = db.collection({
+      name: 'tags',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('fields with association', () => {
+    let options: any = {
+      fields: ['id', 'name', 'tags.id', 'tags.name'],
+    };
+
+    const parser = new OptionsParser(options, {
+      collection: Post,
+    });
+
+    const params = parser.toSequelizeParams();
+
+    expect(params).toEqual({
+      attributes: ['id', 'name'],
+      include: [
+        {
+          association: 'tags',
+          attributes: ['id', 'name'],
+        },
+      ],
+    });
+  });
+  test('with sort option', () => {
+    let options: any = {
+      sort: ['id'],
+    };
+
+    let parser = new OptionsParser(options, {
+      collection: User,
+    });
+    let params = parser.toSequelizeParams();
+    expect(params['order']).toEqual([['id', 'ASC']]);
+
+    options = {
+      sort: ['id', '-posts.title', 'posts.comments.createdAt'],
+    };
+
+    parser = new OptionsParser(options, {
+      collection: User,
+    });
+    params = parser.toSequelizeParams();
+    expect(params['order']).toEqual([
+      ['id', 'ASC'],
+      [Post.model, 'title', 'DESC'],
+      [Post.model, Comment.model, 'createdAt', 'ASC'],
+    ]);
+  });
+
+  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,
+    });
+    let params = parser.toSequelizeParams();
+
+    expect(params['attributes']).toContain('id');
+    expect(params['include'][0]['association']).toEqual('posts');
+
+    // only appends
+    options = {
+      appends: ['posts'],
+    };
+
+    parser = new OptionsParser(options, {
+      collection: User,
+    });
+    params = parser.toSequelizeParams();
+    expect(params['attributes']['include']).toEqual([]);
+    expect(params['include'][0]['association']).toEqual('posts');
+
+    // fields with association field
+    options = {
+      fields: ['id', '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']).toContain('title');
+
+    // fields with nested field
+    options = {
+      fields: ['id', 'posts', 'posts.comments.content'],
+    };
+
+    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');
+
+    // fields with expect
+    options = {
+      except: ['id'],
+    };
+    parser = new OptionsParser(options, {
+      collection: User,
+    });
+    params = parser.toSequelizeParams();
+    expect(params['attributes']['exclude']).toContain('id');
+
+    // expect with association
+    options = {
+      fields: ['posts'],
+      except: ['posts.id'],
+    };
+
+    parser = new OptionsParser(options, {
+      collection: User,
+    });
+    params = parser.toSequelizeParams();
+
+    expect(params['include'][0]['attributes']['exclude']).toContain('id');
+  });
+});