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

package/src/__tests__/fields/has-many-field.test.ts

@@ -0,0 +1,152 @@
+import { Database } from '../../database';
+import { mockDatabase } from '../';
+import { makeWatchHost } from 'ts-loader/dist/servicesHost';
+
+describe('has many field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('association undefined', async () => {
+    const collection = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments' }],
+    });
+    await db.sync();
+    expect(collection.model.associations['comments']).toBeUndefined();
+  });
+
+  it('association defined', async () => {
+    const { model } = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments' }],
+    });
+    expect(model.associations['comments']).toBeUndefined();
+    const comments = db.collection({
+      name: 'comments',
+      fields: [{ type: 'string', name: 'content' }],
+    });
+    const association = model.associations.comments;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('postId');
+    // @ts-ignore
+    expect(association.sourceKey).toBe('id');
+    expect(comments.model.rawAttributes['postId']).toBeDefined();
+    await db.sync();
+    const post = await model.create<any>();
+    await post.createComment({
+      content: 'content111',
+    });
+    const postComments = await post.getComments();
+    expect(postComments.map((comment) => comment.content)).toEqual(['content111']);
+  });
+
+  it('custom sourceKey', async () => {
+    const collection = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'key', unique: true },
+        {
+          type: 'hasMany',
+          name: 'comments',
+          sourceKey: 'key',
+          // foreignKey: 'postKey',
+        },
+      ],
+    });
+    const comments = db.collection({
+      name: 'comments',
+      fields: [],
+    });
+    const association = collection.model.associations.comments;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('postKey');
+    // @ts-ignore
+    expect(association.sourceKey).toBe('key');
+    expect(comments.model.rawAttributes['postKey']).toBeDefined();
+    await db.sync();
+  });
+
+  it('custom sourceKey and foreignKey', async () => {
+    const collection = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'key', unique: true },
+        {
+          type: 'hasMany',
+          name: 'comments',
+          sourceKey: 'key',
+          foreignKey: 'postKey',
+        },
+      ],
+    });
+    const comments = db.collection({
+      name: 'comments',
+      fields: [],
+    });
+    const association = collection.model.associations.comments;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('postKey');
+    // @ts-ignore
+    expect(association.sourceKey).toBe('key');
+    expect(comments.model.rawAttributes['postKey']).toBeDefined();
+    await db.sync();
+  });
+
+  it('custom name and target', async () => {
+    const collection = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'key', unique: true },
+        {
+          type: 'hasMany',
+          name: 'reviews',
+          target: 'comments',
+          sourceKey: 'key',
+          foreignKey: 'postKey',
+        },
+      ],
+    });
+    db.collection({
+      name: 'comments',
+      fields: [{ type: 'string', name: 'content' }],
+    });
+    const association = collection.model.associations.reviews;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('postKey');
+    // @ts-ignore
+    expect(association.sourceKey).toBe('key');
+    await db.sync();
+    const post = await collection.model.create<any>({
+      key: 'key1',
+    });
+    await post.createReview({
+      content: 'content111',
+    });
+    const postComments = await post.getReviews();
+    expect(postComments.map((comment) => comment.content)).toEqual(['content111']);
+  });
+
+  it('schema delete', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments' }],
+    });
+    const Comment = db.collection({
+      name: 'comments',
+      fields: [{ type: 'belongsTo', name: 'post' }],
+    });
+    await db.sync();
+    Post.removeField('comments');
+    expect(Post.model.associations.comments).toBeUndefined();
+    expect(Comment.model.rawAttributes.postId).toBeDefined();
+    Comment.removeField('post');
+    expect(Comment.model.rawAttributes.postId).toBeUndefined();
+  });
+});

package/src/__tests__/fields/has-one-field.test.ts

@@ -0,0 +1,67 @@
+import { Database } from '../../database';
+import { mockDatabase } from '../';
+
+describe('has many field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('association undefined', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile' }],
+    });
+    await db.sync();
+    expect(User.model.associations.profile).toBeUndefined();
+  });
+
+  it('association defined', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile' }],
+    });
+    expect(User.model.associations.phone).toBeUndefined();
+    const Profile = db.collection({
+      name: 'profiles',
+      fields: [{ type: 'string', name: 'content' }],
+    });
+    const association = User.model.associations.profile;
+    expect(association).toBeDefined();
+    expect(association.foreignKey).toBe('userId');
+    // @ts-ignore
+    expect(association.sourceKey).toBe('id');
+    expect(Profile.model.rawAttributes['userId']).toBeDefined();
+    await db.sync();
+    // const post = await model.create<any>();
+    // await post.createComment({
+    //   content: 'content111',
+    // });
+    // const postComments = await post.getComments();
+    // expect(postComments.map((comment) => comment.content)).toEqual([
+    //   'content111',
+    // ]);
+  });
+
+  it('schema delete', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile' }],
+    });
+    const Profile = db.collection({
+      name: 'profiles',
+      fields: [{ type: 'belongsTo', name: 'user' }],
+    });
+    await db.sync();
+    User.removeField('profile');
+    expect(User.model.associations.profile).toBeUndefined();
+    expect(Profile.model.rawAttributes.userId).toBeDefined();
+    Profile.removeField('user');
+    expect(Profile.model.rawAttributes.userId).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,30 @@
+import { mockDatabase } from '../';
+import { Database, PasswordField } from '../../';
+
+describe('password field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('case 1', async () => {
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'password', name: 'password' }],
+    });
+    await db.sync();
+    const user = await User.model.create<any>({
+      password: '123456',
+    });
+    const pwd = User.getField<PasswordField>('password');
+    expect(await pwd.verify('123456', user.password)).toBeTruthy();
+    user.set('password', '654321');
+    await user.save();
+    expect(await pwd.verify('654321', user.password)).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,133 @@
+import { Database } from '../../database';
+import { mockDatabase } from '../';
+import { SortField } from '../../fields';
+
+describe('string field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+    db.registerFieldTypes({
+      sort: SortField,
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('sort', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'sort', name: 'sort' }],
+    });
+    await db.sync();
+
+    const test1 = await Test.model.create<any>();
+    expect(test1.sort).toBe(1);
+    const test2 = await Test.model.create<any>();
+    expect(test2.sort).toBe(2);
+    const test3 = await Test.model.create<any>();
+    expect(test3.sort).toBe(3);
+  });
+
+  it('should init sort value on data already exits', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await db.getRepository('tests').create({
+      values: {
+        name: 't1',
+      },
+    });
+    await db.getRepository('tests').create({
+      values: {
+        name: 't2',
+      },
+    });
+    await db.getRepository('tests').create({
+      values: {
+        name: 't3',
+      },
+    });
+
+    const field = Test.addField('sort', { type: 'sort' });
+
+    await field.sync({});
+
+    const items = await db.getRepository('tests').find({
+      order: ['id'],
+    });
+    expect(items.map((item) => item.get('sort'))).toEqual([1, 2, 3]);
+  });
+
+  test.skip('simultaneously create ', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'sort', name: 'sort' }],
+    });
+
+    await db.sync();
+
+    const promise = [];
+    for (let i = 0; i < 3; i++) {
+      promise.push(Test.model.create());
+    }
+
+    await Promise.all(promise);
+    const tests = await Test.model.findAll();
+    const sortValues = tests.map((t) => t.get('sort')).sort();
+    expect(sortValues).toEqual([1, 2, 3]);
+  });
+
+  it('skip if sort value not empty', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'sort', name: 'sort' }],
+    });
+    await db.sync();
+    const test1 = await Test.model.create<any>({ sort: 3 });
+    expect(test1.sort).toBe(3);
+    const test2 = await Test.model.create<any>();
+    expect(test2.sort).toBe(4);
+    const test3 = await Test.model.create<any>();
+    expect(test3.sort).toBe(5);
+  });
+
+  it('scopeKey', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        { type: 'sort', name: 'sort', scopeKey: 'status' },
+        { type: 'string', name: 'status' },
+      ],
+    });
+    await db.sync();
+
+    const t1 = await Test.model.create({ status: 'publish' });
+    const t2 = await Test.model.create({ status: 'publish' });
+    const t3 = await Test.model.create({ status: 'draft' });
+    const t4 = await Test.model.create({ status: 'draft' });
+
+    expect(t1.get('sort')).toBe(1);
+    expect(t2.get('sort')).toBe(2);
+    expect(t3.get('sort')).toBe(1);
+    expect(t4.get('sort')).toBe(2);
+
+    t1.set('status', 'draft');
+    await t1.save();
+
+    await t1.reload();
+    expect(t1.get('sort')).toBe(3);
+  });
+});

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

@@ -0,0 +1,77 @@
+import { Database } from '../../database';
+import { mockDatabase } from '../';
+
+describe('string field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('define', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+    await db.sync();
+    expect(Test.model.rawAttributes['name']).toBeDefined();
+    const model = await Test.model.create({
+      name: 'abc',
+    });
+    expect(model.toJSON()).toMatchObject({
+      name: 'abc',
+    });
+  });
+
+  it('set', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name1' }],
+    });
+    await db.sync();
+    Test.addField('name2', { type: 'string' });
+    await db.sync({
+      alter: true,
+    });
+    expect(Test.model.rawAttributes['name1']).toBeDefined();
+    expect(Test.model.rawAttributes['name2']).toBeDefined();
+    const model = await Test.model.create({
+      name1: 'a1',
+      name2: 'a2',
+    });
+    expect(model.toJSON()).toMatchObject({
+      name1: 'a1',
+      name2: 'a2',
+    });
+  });
+
+  it('model hook', async () => {
+    const collection = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+    await db.sync();
+    collection.model.beforeCreate((model) => {
+      const changed = model.changed();
+      for (const name of changed || []) {
+        model.set(name, `${model.get(name)}111`);
+      }
+    });
+    collection.addField('name2', { type: 'string' });
+    await db.sync({
+      alter: true,
+    });
+    const model = await collection.model.create({
+      name: 'n1',
+      name2: 'n2',
+    });
+    expect(model.toJSON()).toMatchObject({
+      name: 'n1111',
+      name2: 'n2111',
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import { Op } from 'sequelize';
+import { Database } from '../database';
+import FilterParser from '../filter-parser';
+import { mockDatabase } from './index';
+
+describe('filter by related', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'posts' },
+      ],
+    });
+
+    db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        {
+          type: 'hasMany',
+          name: 'comments',
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'comments',
+      fields: [
+        { type: 'string', name: 'content' },
+        {
+          type: 'belongsTo',
+          name: 'post',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('filter item by string', async () => {
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+
+    const filterParser = new FilterParser(
+      {
+        name: 'hello',
+      },
+      {
+        collection: UserCollection,
+      },
+    );
+
+    const filterParams = filterParser.toSequelizeParams();
+
+    expect(filterParams).toMatchObject({
+      where: {
+        name: 'hello',
+      },
+    });
+  });
+
+  test('hasMany', async () => {
+    const filter = {
+      'posts.title.$iLike': '%hello%',
+    };
+
+    const filterParser = new FilterParser(filter, {
+      collection: db.getCollection('users'),
+    });
+
+    const filterParams = filterParser.toSequelizeParams();
+
+    expect(filterParams.where['$posts.title$'][Op.iLike]).toEqual('%hello%');
+    expect(filterParams.include[0]['association']).toEqual('posts');
+  });
+
+  test('belongsTo', async () => {
+    const filter = {
+      'posts.comments.content.$iLike': '%hello%',
+    };
+
+    const filterParser = new FilterParser(filter, {
+      collection: db.getCollection('users'),
+    });
+
+    const filterParams = filterParser.toSequelizeParams();
+
+    expect(filterParams.where['$posts.comments.content$'][Op.iLike]).toEqual('%hello%');
+    expect(filterParams.include[0]['association']).toEqual('posts');
+    expect(filterParams.include[0]['include'][0]['association']).toEqual('comments');
+  });
+});

package/src/__tests__/fixtures/c0/a.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'tests',
+  fields: [{ type: 'string', name: 'n0' }],
+});

package/src/__tests__/fixtures/c1/b.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'tests',
+  fields: [{ type: 'string', name: 'n1' }],
+});

package/src/__tests__/fixtures/c2/a.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default {
+  name: 'tests',
+  fields: [{ type: 'string', name: 'n2' }],
+};

package/src/__tests__/fixtures/collections/delay-extend.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'images',
+  fields: [{ type: 'string', name: 'url' }],
+});

package/src/__tests__/fixtures/collections/delay-extend2.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'images',
+  fields: [{ type: 'string', name: 'url2' }],
+});

package/src/__tests__/fixtures/collections/extend.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'tags',
+  fields: [{ type: 'string', name: 'color' }],
+});

package/src/__tests__/fixtures/collections/extend2.ts

@@ -0,0 +1,6 @@
+import { extend } from '../../../database';
+
+export default extend({
+  name: 'tags',
+  fields: [{ type: 'string', name: 'color2' }],
+});

package/src/__tests__/fixtures/collections/posts.ts

@@ -0,0 +1,4 @@
+export default {
+  name: 'posts',
+  fields: [{ type: 'string', name: 'title' }],
+};

package/src/__tests__/fixtures/collections/tags.js

@@ -0,0 +1,4 @@
+module.exports = {
+  name: 'tags',
+  fields: [{ type: 'string', name: 'name' }],
+};

package/src/__tests__/fixtures/collections/user.json

@@ -0,0 +1,9 @@
+{
+  "name": "users",
+  "fields": [
+    {
+      "type": "string",
+      "name": "name"
+    }
+  ]
+}

package/src/__tests__/index.ts

@@ -0,0 +1 @@
+export { mockDatabase } from '../mock-database';