@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.1

package/src/__tests__/underscored-options.test.ts

@@ -0,0 +1,207 @@
+import { Database, mockDatabase } from '@nocobase/database';
+
+describe('underscored options', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      underscored: true,
+    });
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should set two field with same type', async () => {
+    const collection = db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'test_field',
+        },
+        {
+          type: 'string',
+          name: 'testField',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  it('should not set two field with difference type but same field name', async () => {
+    const collection = db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'test_field',
+        },
+      ],
+    });
+
+    expect(() => {
+      collection.addField('testField', { type: 'integer' });
+    }).toThrowError();
+
+    expect(() => {
+      collection.addField('test123', { type: 'integer', field: 'test_field' });
+    }).toThrowError();
+  });
+
+  it('should create index', async () => {
+    const collectionA = db.collection({
+      name: 'testCollection',
+      fields: [
+        {
+          type: 'string',
+          name: 'aField',
+        },
+        {
+          type: 'string',
+          name: 'bField',
+        },
+      ],
+      indexes: [
+        {
+          type: 'UNIQUE',
+          fields: ['aField', 'bField'],
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  it('should use underscored option', async () => {
+    const collectionA = db.collection({
+      name: 'testCollection',
+      underscored: true,
+      fields: [
+        {
+          type: 'string',
+          name: 'testField',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const tableName = collectionA.model.tableName;
+
+    expect(tableName.includes('test_collection')).toBeTruthy();
+
+    const repository = db.getRepository('testCollection');
+
+    await repository.create({
+      values: {
+        testField: 'test',
+      },
+    });
+
+    const record = await repository.findOne({});
+
+    expect(record.get('testField')).toBe('test');
+  });
+
+  it('should use database options', async () => {
+    const collectionA = db.collection({
+      name: 'testCollection',
+      fields: [
+        {
+          type: 'string',
+          name: 'testField',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const tableName = collectionA.model.tableName;
+
+    expect(tableName.includes('test_collection')).toBeTruthy();
+  });
+
+  test('through table', async () => {
+    db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+          through: 'collectionCategory',
+          target: 'posts',
+          sourceKey: 'name',
+          foreignKey: 'postsName',
+          targetKey: 'name',
+          otherKey: 'tagsName',
+        },
+      ],
+    });
+
+    db.collection({
+      name: 'tags',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'posts',
+          target: 'posts',
+          through: 'collectionCategory',
+          sourceKey: 'name',
+          foreignKey: 'tagsName',
+          targetKey: 'name',
+          otherKey: 'postsName',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const through = db.getCollection('collectionCategory');
+
+    expect(through.model.tableName.includes('collection_category')).toBeTruthy();
+  });
+
+  test('db collectionExists', async () => {
+    const collectionA = db.collection({
+      name: 'testCollection',
+      underscored: true,
+      fields: [
+        {
+          type: 'string',
+          name: 'testField',
+        },
+      ],
+    });
+
+    expect(await db.collectionExistsInDb('testCollection')).toBeFalsy();
+
+    await db.sync();
+
+    expect(await db.collectionExistsInDb('testCollection')).toBeTruthy();
+  });
+
+  it('should throw error when table names conflict', async () => {
+    db.collection({
+      name: 'b1_z',
+    });
+
+    expect(() => {
+      db.collection({
+        name: 'b1Z',
+      });
+    }).toThrowError();
+  });
+});

package/src/__tests__/update-associations-through.test.ts

@@ -0,0 +1,73 @@
+import { Database } from '../database';
+import { mockDatabase } from './';
+
+describe('update through', () => {
+  let db: Database;
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should not be reset', async () => {
+    db.collection({
+      name: 'c',
+      autoGenId: true,
+      fields: [
+        {
+          name: 'id',
+          type: 'integer',
+          primaryKey: true,
+          autoIncrement: true,
+        },
+      ],
+    });
+    db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'b',
+          target: 'b',
+          through: 'c',
+        },
+      ],
+    });
+    db.collection({
+      name: 'b',
+      fields: [],
+    });
+    await db.sync();
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    db.on('c.afterCreate', callback1);
+    db.on('c.afterBulkCreate', callback2);
+    const b = await db.getRepository('b').create({
+      values: {},
+    });
+    const a = await db.getRepository('a').create({
+      values: {
+        b: [b.toJSON()],
+      },
+    });
+    const c1 = await db.getRepository('c').findOne();
+    await db.getRepository('a').update({
+      filterByTk: a.id,
+      values: {
+        b: [b.toJSON()],
+      },
+    });
+
+    const c2 = await db.getRepository('c').findOne();
+    expect(c1.get('id')).toBe(c2.get('id'));
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/value-parsers/base.test.ts

@@ -0,0 +1,20 @@
+import { BaseValueParser as ValueParser } from '../../value-parsers';
+
+describe('number value parser', () => {
+  let parser: ValueParser;
+
+  beforeEach(() => {
+    parser = new ValueParser({}, {});
+  });
+
+  it('should be converted to an array', () => {
+    expect(parser.toArr('A/B', '/')).toEqual(['A', 'B']);
+    expect(parser.toArr('A,B')).toEqual(['A', 'B']);
+    expect(parser.toArr('A, B')).toEqual(['A', 'B']);
+    expect(parser.toArr('A， B')).toEqual(['A', 'B']);
+    expect(parser.toArr('A, B ')).toEqual(['A', 'B']);
+    expect(parser.toArr('A， B  ')).toEqual(['A', 'B']);
+    expect(parser.toArr('A、 B')).toEqual(['A', 'B']);
+    expect(parser.toArr('A ,, B')).toEqual(['A', 'B']);
+  });
+});

package/src/__tests__/value-parsers/date.test.ts

@@ -0,0 +1,67 @@
+import moment from 'moment';
+import { Database, mockDatabase } from '../..';
+import { DateValueParser } from '../../value-parsers';
+
+describe('number value parser', () => {
+  let parser: DateValueParser;
+  let db: Database;
+
+  beforeEach(() => {
+    db = mockDatabase();
+    db.collection({
+      name: 'tests',
+      fields: [
+        {
+          name: 'date',
+          type: 'date',
+        },
+        {
+          name: 'dateOnly',
+          type: 'date',
+          uiSchema: {
+            ['x-component-props']: {
+              showTime: false,
+              gmt: false,
+            },
+          },
+        },
+        {
+          name: 'dateTime',
+          type: 'date',
+          uiSchema: {
+            ['x-component-props']: {
+              showTime: true,
+            },
+          },
+        },
+        {
+          name: 'dateTimeGmt',
+          type: 'date',
+          uiSchema: {
+            ['x-component-props']: {
+              showTime: true,
+              gmt: true,
+            },
+          },
+        },
+      ],
+    });
+    parser = new DateValueParser({}, {});
+  });
+
+  const expectValue = (value, field = 'date') => {
+    const collection = db.getCollection('tests');
+    parser = new DateValueParser(collection.getField(field), {});
+    parser.setValue(value);
+    return expect(parser.getValue());
+  };
+
+  it('should be correct', () => {
+    expectValue(42510).toBe('2016-05-20T00:00:00.000Z');
+    expectValue('42510').toBe('2016-05-20T00:00:00.000Z');
+    expectValue('2016-05-20T00:00:00.000Z').toBe('2016-05-20T00:00:00.000Z');
+    expectValue('2016-05-20 04:22:22', 'dateOnly').toBe('2016-05-20T00:00:00.000Z');
+    expectValue('2016-05-20 01:00:00', 'dateTime').toBe(moment('2016-05-20 01:00:00').toISOString());
+    expectValue('2016-05-20 01:00:00', 'dateTimeGmt').toBe('2016-05-20T01:00:00.000Z');
+  });
+});

package/src/__tests__/value-parsers/number.test.ts

@@ -0,0 +1,46 @@
+import { NumberValueParser } from '../../value-parsers';
+
+describe('number value parser', () => {
+  let parser: NumberValueParser;
+
+  beforeEach(() => {
+    parser = new NumberValueParser({}, {});
+  });
+
+  const expectValue = (value) => {
+    parser = new NumberValueParser({}, {});
+    parser.setValue(value);
+    return expect(parser.getValue());
+  };
+
+  it('should be number', () => {
+    expectValue(123).toBe(123);
+    expect(parser.errors.length === 0).toBeTruthy();
+    expectValue('123').toBe(123);
+    expect(parser.errors.length === 0).toBeTruthy();
+    expectValue('123%').toBe(1.23);
+    expect(parser.errors.length === 0).toBeTruthy();
+    expectValue('22.5507%').toBe(0.225507);
+    expect(parser.errors.length === 0).toBeTruthy();
+  });
+
+  it('should be null', () => {
+    expectValue('').toBe(null);
+    expect(parser.errors.length === 0).toBeTruthy();
+    expectValue('n/a').toBe(null);
+    expect(parser.errors.length === 0).toBeTruthy();
+    expectValue('-').toBe(null);
+    expect(parser.errors.length === 0).toBeTruthy();
+  });
+
+  it('should be errors', () => {
+    expectValue({}).toBe(null);
+    expect(parser.errors.length > 0).toBeTruthy();
+    expectValue('123a').toBe(null);
+    expect(parser.errors.length > 0).toBeTruthy();
+    expectValue('123a%').toBe(null);
+    expect(parser.errors.length > 0).toBeTruthy();
+    expectValue('aaa').toBe(null);
+    expect(parser.errors.length > 0).toBeTruthy();
+  });
+});

package/src/__tests__/value-parsers/to-many.test.ts

@@ -0,0 +1,206 @@
+import { Database, mockDatabase } from '../..';
+import { ToManyValueParser } from '../../value-parsers';
+
+describe('number value parser', () => {
+  let parser: ToManyValueParser;
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'attachments',
+          interface: 'attachment',
+        },
+      ],
+    });
+    db.collection({
+      name: 'attachments',
+      fields: [],
+    });
+    db.collection({
+      name: 'tags',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+    await db.sync();
+    const tag = db.getRepository('tags');
+    await tag.create({
+      values: { name: 'tag1' },
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  const setValue = async (value) => {
+    const post = db.getCollection('posts');
+    parser = new ToManyValueParser(post.getField('tags'), {
+      column: {
+        dataIndex: ['tags', 'name'],
+      },
+    });
+    await parser.setValue(value);
+  };
+
+  const setAttachment = async (value) => {
+    const post = db.getCollection('posts');
+    parser = new ToManyValueParser(post.getField('attachments'), {});
+    await parser.setValue(value);
+  };
+
+  it('should be [1]', async () => {
+    await setValue('tag1');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toEqual([1]);
+  });
+
+  it('should be null', async () => {
+    await setValue('tag2');
+    expect(parser.errors.length).toBe(1);
+    expect(parser.getValue()).toBeNull();
+  });
+
+  it('should be attachment', async () => {
+    await setAttachment('https://www.nocobase.com/images/logo.png');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toMatchObject([
+      {
+        title: 'logo.png',
+        extname: '.png',
+        filename: 'logo.png',
+        url: 'https://www.nocobase.com/images/logo.png',
+      },
+    ]);
+  });
+});
+
+describe.only('china region', () => {
+  let parser: ToManyValueParser;
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'belongsToMany',
+          name: 'chinaRegion',
+          target: 'chinaRegions',
+          interface: 'chinaRegion',
+          targetKey: 'code',
+          sortBy: 'level',
+        },
+      ],
+    });
+    db.collection({
+      name: 'chinaRegions',
+      autoGenId: false,
+      fields: [
+        {
+          name: 'code',
+          type: 'string',
+          // unique: true,
+          primaryKey: true,
+        },
+        {
+          name: 'name',
+          type: 'string',
+        },
+        {
+          name: 'parent',
+          type: 'belongsTo',
+          target: 'chinaRegions',
+          targetKey: 'code',
+          foreignKey: 'parentCode',
+        },
+        {
+          name: 'children',
+          type: 'hasMany',
+          target: 'chinaRegions',
+          sourceKey: 'code',
+          foreignKey: 'parentCode',
+        },
+        {
+          name: 'level',
+          type: 'integer',
+        },
+      ],
+    });
+    await db.sync();
+    const areas = require('china-division/dist/areas.json');
+    const cities = require('china-division/dist/cities.json');
+    const provinces = require('china-division/dist/provinces.json');
+    const ChinaRegion = db.getModel('chinaRegions');
+    await ChinaRegion.bulkCreate(
+      provinces.map((item) => ({
+        code: item.code,
+        name: item.name,
+        level: 1,
+      })),
+    );
+    await ChinaRegion.bulkCreate(
+      cities.map((item) => ({
+        code: item.code,
+        name: item.name,
+        level: 2,
+        parentCode: item.provinceCode,
+      })),
+    );
+    await ChinaRegion.bulkCreate(
+      areas.map((item) => ({
+        code: item.code,
+        name: item.name,
+        level: 3,
+        parentCode: item.cityCode,
+      })),
+    );
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  const setValue = async (value) => {
+    const r = db.getCollection('users');
+    parser = new ToManyValueParser(r.getField('chinaRegion'), {});
+    await parser.setValue(value);
+  };
+
+  it('should be correct', async () => {
+    await setValue('北京市/市辖区');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toEqual(['11', '1101']);
+
+    await setValue('北京市 / 市辖区');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toEqual(['11', '1101']);
+
+    await setValue('天津市 / 市辖区');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toEqual(['12', '1201']);
+  });
+
+  it('should be null', async () => {
+    await setValue('北京市2 / 市辖区');
+    expect(parser.errors.length).toBe(1);
+    expect(parser.getValue()).toBeNull();
+
+    await setValue('北京市 / 市辖区 2');
+    expect(parser.errors.length).toBe(1);
+    expect(parser.getValue()).toBeNull();
+  });
+});

package/src/__tests__/value-parsers/to-one.test.ts

@@ -0,0 +1,60 @@
+import { Database, mockDatabase } from '../..';
+import { ToManyValueParser } from '../../value-parsers';
+
+describe('number value parser', () => {
+  let parser: ToManyValueParser;
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+      ],
+    });
+    db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+    await db.sync();
+    const r = db.getRepository('users');
+    await r.create({
+      values: { name: 'user1' },
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  const setValue = async (value) => {
+    const post = db.getCollection('posts');
+    parser = new ToManyValueParser(post.getField('user'), {
+      column: {
+        dataIndex: ['user', 'name'],
+      },
+    });
+    await parser.setValue(value);
+  };
+
+  it('should be correct', async () => {
+    await setValue('user1');
+    expect(parser.errors.length).toBe(0);
+    expect(parser.getValue()).toEqual([1]);
+  });
+
+  it('should be null', async () => {
+    await setValue('user2');
+    expect(parser.errors.length).toBe(1);
+    expect(parser.getValue()).toBeNull();
+  });
+});

package/src/collection-importer.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 import { readdir } from 'fs/promises';
-import { isPlainObject } from 'lodash';
+import { cloneDeep, isPlainObject } from 'lodash';
 import { requireModule } from '@nocobase/utils';
 
 export type ImportFileExtension = 'js' | 'ts' | 'json';
@@ -36,6 +36,6 @@ export class ImporterReader {
         return typeof mod === 'function' ? mod() : mod;
       });
 
-    return (await Promise.all(modules)).filter((module) => isPlainObject(module));
+    return (await Promise.all(modules)).filter((module) => isPlainObject(module)).map((module) => cloneDeep(module));
   }
 }