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

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));
   }
 }