@nocobase/plugin-data-visualization 0.11.1-alpha.5 → 0.12.0-alpha.2

package/src/locale/zh-CN.ts

@@ -1,72 +0,0 @@
-export default {
-  Edit: '编辑',
-  Delete: '删除',
-  Cancel: '取消',
-  Submit: '提交',
-  Actions: '操作',
-  Title: '名称',
-  Enable: '启用',
-  Chart: '图表',
-  ChartV2: '图表V2',
-  Charts: '图表',
-  Configure: '配置',
-  Duplicate: '复制',
-  'Configure chart': '配置图表',
-  Transform: '数据转换',
-  'Chart type': '图表类型',
-  'JSON config': 'JSON 配置',
-  Query: '查询',
-  Data: '数据',
-  'Run query': '执行查询',
-  Measures: '度量',
-  Dimensions: '维度',
-  Filter: '过滤',
-  Sort: '排序',
-  Limit: '结果数量',
-  'Enable cache': '启用缓存',
-  'TTL (second)': '缓存时间 (秒)',
-  Field: '字段',
-  Aggregation: '聚合',
-  Alias: '别名',
-  Format: '格式',
-  'The first 10 records of the query result:': '查询结果的前 10 条记录：',
-  'Please run query to retrive data.': '请执行查询来获取数据。',
-  Type: '类型',
-  'Add field': '添加字段',
-  'Add chart': '添加图表',
-  xField: 'x轴字段',
-  yField: 'y轴字段',
-  seriesField: '分类字段',
-  angleField: '角度字段',
-  colorField: '颜色字段',
-  'Line Chart': '折线图',
-  'Area Chart': '面积图',
-  'Column Chart': '柱状图',
-  'Bar Chart': '条形图',
-  'Pie Chart': '饼图',
-  'Dual Axes Chart': '双轴图',
-  'Scatter Chart': '散点图',
-  'Gauge Chart': '仪表盘',
-  Statistic: '统计',
-  Currency: '货币',
-  Percent: '百分比',
-  Exponential: '科学记数法',
-  Abbreviation: '缩写',
-  'Please configure and run query': '请配置并执行数据查询',
-  'Please configure chart': '请配置图表',
-  'Are you sure to cancel?': '确定要取消吗？',
-  'You changes are not saved. If you click OK, your changes will be lost.':
-    '您的更改尚未保存。如果您点击“确定”，您的更改将丢失。',
-  'Same properties set in the form above will be overwritten by this JSON config.':
-    '上面表单中设置的相同属性将被JSON配置覆盖。',
-  'Built-in': '内置图表',
-  'Config reference: ': '配置参考: ',
-  Table: '表格',
-  Sum: '求和',
-  Avg: '平均值',
-  Count: '计数',
-  Min: '最小值',
-  Max: '最大值',
-  'Please select a chart type.': '请选择图表类型',
-  Collection: '数据表',
-};

package/src/server/__tests__/api.test.ts

@@ -1,102 +0,0 @@
-import { Database } from '@nocobase/database';
-import { MockServer, mockServer } from '@nocobase/test';
-import { queryData } from '../actions/query';
-import ChartsV2Plugin from '../plugin';
-
-describe('api', () => {
-  let app: MockServer;
-  let db: Database;
-
-  beforeAll(async () => {
-    app = mockServer({
-      acl: true,
-      plugins: ['users', 'auth'],
-    });
-    app.plugin(ChartsV2Plugin);
-    await app.loadAndInstall({ clean: true });
-    db = app.db;
-
-    db.collection({
-      name: 'chart_test',
-      fields: [
-        {
-          type: 'double',
-          name: 'price',
-        },
-        {
-          type: 'bigInt',
-          name: 'count',
-        },
-        {
-          type: 'string',
-          name: 'title',
-        },
-        {
-          type: 'date',
-          name: 'createdAt',
-        },
-      ],
-    });
-    await db.sync();
-    const repo = db.getRepository('chart_test');
-    await repo.create({
-      values: [
-        { price: 1, count: 1, title: 'title1', createdAt: '2023-02-02' },
-        { price: 2, count: 2, title: 'title2', createdAt: '2023-01-01' },
-      ],
-    });
-  });
-
-  afterAll(async () => {
-    await db.close();
-  });
-
-  test('query', async () => {
-    const result = await queryData({ db } as any, {
-      collection: 'chart_test',
-      measures: [
-        {
-          field: ['price'],
-          alias: 'Price',
-        },
-        {
-          field: ['count'],
-          alias: 'Count',
-        },
-      ],
-      dimensions: [
-        {
-          field: ['title'],
-          alias: 'Title',
-        },
-      ],
-    });
-    expect(result).toBeDefined();
-  });
-
-  test('query with sort', async () => {
-    const result = await queryData({ db } as any, {
-      collection: 'chart_test',
-      measures: [
-        {
-          field: ['price'],
-          aggregation: 'sum',
-          alias: 'Price',
-        },
-      ],
-      dimensions: [
-        {
-          field: ['title'],
-          alias: 'Title',
-        },
-        {
-          field: ['createdAt'],
-          format: 'YYYY-MM',
-        },
-      ],
-      orders: [{ field: 'createdAt', order: 'asc' }],
-    });
-    expect(result).toBeDefined();
-    expect(result).toMatchObject([{ createdAt: '2023-01' }, { createdAt: '2023-02' }]);
-  });
-});

package/src/server/__tests__/formatter.test.ts

@@ -1,49 +0,0 @@
-import { dateFormatFn } from '../actions/formatter';
-
-describe('formatter', () => {
-  const field = 'field';
-  const format = 'YYYY-MM-DD hh:mm:ss';
-  describe('dateFormatFn', () => {
-    it('should return correct format for sqlite', () => {
-      const sequelize = {
-        fn: jest.fn().mockImplementation((fn: string, format: string, field: string) => ({
-          fn,
-          format,
-          field,
-        })),
-        col: jest.fn().mockImplementation((field: string) => field),
-      };
-      const dialect = 'sqlite';
-      const result = dateFormatFn(sequelize, dialect, field, format);
-      expect(result.format).toEqual('%Y-%m-%d %H:%M:%S');
-    });
-
-    it('should return correct format for mysql', () => {
-      const sequelize = {
-        fn: jest.fn().mockImplementation((fn: string, field: string, format: string) => ({
-          fn,
-          format,
-          field,
-        })),
-        col: jest.fn().mockImplementation((field: string) => field),
-      };
-      const dialect = 'mysql';
-      const result = dateFormatFn(sequelize, dialect, field, format);
-      expect(result.format).toEqual('%Y-%m-%d %H:%i:%S');
-    });
-
-    it('should return correct format for postgres', () => {
-      const sequelize = {
-        fn: jest.fn().mockImplementation((fn: string, field: string, format: string) => ({
-          fn,
-          format,
-          field,
-        })),
-        col: jest.fn().mockImplementation((field: string) => field),
-      };
-      const dialect = 'postgres';
-      const result = dateFormatFn(sequelize, dialect, field, format);
-      expect(result.format).toEqual('YYYY-MM-DD HH24:MI:SS');
-    });
-  });
-});

package/src/server/__tests__/query.test.ts

@@ -1,220 +0,0 @@
-import { MockServer, mockServer } from '@nocobase/test';
-import * as formatter from '../actions/formatter';
-import { cacheWrap, parseBuilder, parseFieldAndAssociations } from '../actions/query';
-
-describe('query', () => {
-  describe('parseBuilder', () => {
-    const sequelize = {
-      fn: jest.fn().mockImplementation((fn: string, field: string) => [fn, field]),
-      col: jest.fn().mockImplementation((field: string) => field),
-    };
-    let ctx: any;
-    let app: MockServer;
-
-    beforeAll(() => {
-      app = mockServer();
-      app.db.collection({
-        name: 'orders',
-        fields: [
-          {
-            name: 'id',
-            type: 'bigInt',
-          },
-          {
-            name: 'price',
-            type: 'double',
-          },
-          {
-            name: 'createdAt',
-            type: 'date',
-          },
-          {
-            type: 'belongsTo',
-            name: 'user',
-            target: 'users',
-            targetKey: 'id',
-            foreignKey: 'userId',
-          },
-        ],
-      });
-      app.db.collection({
-        name: 'users',
-        fields: [
-          {
-            name: 'id',
-            type: 'bigInt',
-          },
-          {
-            name: 'name',
-            type: 'string',
-          },
-        ],
-      });
-      ctx = {
-        db: {
-          sequelize,
-          getRepository: (name: string) => app.db.getRepository(name),
-          getModel: (name: string) => app.db.getModel(name),
-          getCollection: (name: string) => app.db.getCollection(name),
-          options: {
-            underscored: true,
-          },
-        },
-      };
-    });
-
-    it('should parse field and associations', () => {
-      const associations = parseFieldAndAssociations(ctx, {
-        collection: 'orders',
-        measures: [{ field: ['price'], aggregation: 'sum', alias: 'price' }],
-        dimensions: [{ field: ['createdAt'] }, { field: ['user', 'name'] }],
-      });
-      expect(associations).toMatchObject({
-        measures: [{ field: 'orders.price', aggregation: 'sum', alias: 'price', type: 'double' }],
-        dimensions: [
-          { field: 'orders.created_at', alias: 'createdAt', type: 'date' },
-          { field: 'user.name', alias: 'user.name' },
-        ],
-        include: [{ association: 'user' }],
-      });
-    });
-
-    it('should parse measures', () => {
-      const measures1 = [
-        {
-          field: ['price'],
-        },
-      ];
-      const { queryParams: result1 } = parseBuilder(ctx, { collection: 'orders', measures: measures1 });
-      expect(result1.attributes).toEqual([['orders.price', 'price']]);
-
-      const measures2 = [
-        {
-          field: ['price'],
-          aggregation: 'sum',
-          alias: 'price-alias',
-        },
-      ];
-      const { queryParams: result2 } = parseBuilder(ctx, { collection: 'orders', measures: measures2 });
-      expect(result2.attributes).toEqual([[['sum', 'orders.price'], 'price-alias']]);
-    });
-
-    it('should parse dimensions', () => {
-      jest.spyOn(formatter, 'formatter').mockReturnValue('formatted-field');
-      const dimensions = [
-        {
-          field: ['createdAt'],
-          format: 'YYYY-MM-DD',
-          alias: 'Created at',
-        },
-      ];
-      const { queryParams: result } = parseBuilder(ctx, { collection: 'orders', dimensions });
-      expect(result.attributes).toEqual([['formatted-field', 'Created at']]);
-      expect(result.group).toEqual([]);
-
-      const measures = [
-        {
-          field: ['field'],
-          aggregation: 'sum',
-        },
-      ];
-      const { queryParams: result2 } = parseBuilder(ctx, { collection: 'orders', measures, dimensions });
-      expect(result2.group).toEqual(['formatted-field']);
-    });
-
-    it('should parse filter', () => {
-      const filter = {
-        createdAt: {
-          $gt: '2020-01-01',
-        },
-      };
-      const { queryParams: result } = parseBuilder(ctx, { collection: 'orders', filter });
-      expect(result.where.createdAt).toBeDefined();
-    });
-  });
-
-  describe('cacheWrap', () => {
-    const key = 'test-key';
-    const value = 'test-val';
-    class MockCache {
-      map: Map<string, any> = new Map();
-      async func() {
-        return value;
-      }
-
-      get(key: string) {
-        return this.map.get(key);
-      }
-      set(key: string, value: any) {
-        this.map.set(key, value);
-      }
-    }
-    let cache: any;
-    let query: () => Promise<any>;
-
-    beforeEach(() => {
-      cache = new MockCache();
-    });
-
-    it('should use cache', async () => {
-      query = async () =>
-        await cacheWrap(cache, {
-          key,
-          func: cache.func,
-          useCache: true,
-          refresh: false,
-        });
-
-      const spy = jest.spyOn(cache, 'func');
-      expect(cache.get(key)).toBeUndefined();
-      const result = await query();
-      expect(cache.func).toBeCalled();
-      expect(result).toEqual(value);
-      expect(cache.get(key)).toEqual(value);
-
-      spy.mockReset();
-      const result2 = await query();
-      expect(result2).toEqual(value);
-      expect(cache.func).not.toBeCalled();
-    });
-
-    it('should not use cache', async () => {
-      query = async () =>
-        await cacheWrap(cache, {
-          key,
-          func: cache.func,
-          useCache: false,
-          refresh: false,
-        });
-
-      cache.set(key, value);
-      expect(cache.get(key)).toBeDefined();
-      jest.spyOn(cache, 'func');
-      const result = await query();
-      expect(cache.func).toBeCalled();
-      expect(result).toEqual(value);
-    });
-
-    it('should refresh', async () => {
-      query = async () =>
-        await cacheWrap(cache, {
-          key,
-          func: cache.func,
-          useCache: true,
-          refresh: true,
-        });
-
-      const spy = jest.spyOn(cache, 'func');
-      expect(cache.get(key)).toBeUndefined();
-      const result = await query();
-      expect(cache.func).toBeCalled();
-      expect(result).toEqual(value);
-      expect(cache.get(key)).toEqual(value);
-
-      spy.mockClear();
-      const result2 = await query();
-      expect(cache.func).toBeCalled();
-      expect(result2).toEqual(value);
-    });
-  });
-});

package/src/server/actions/formatter.ts

@@ -1,49 +0,0 @@
-export const dateFormatFn = (sequelize: any, dialect: string, field: string, format: string) => {
-  switch (dialect) {
-    case 'sqlite':
-      format = format
-        .replace(/YYYY/g, '%Y')
-        .replace(/MM/g, '%m')
-        .replace(/DD/g, '%d')
-        .replace(/hh/g, '%H')
-        .replace(/mm/g, '%M')
-        .replace(/ss/g, '%S');
-      return sequelize.fn('strftime', format, sequelize.col(field));
-    case 'mysql':
-      format = format
-        .replace(/YYYY/g, '%Y')
-        .replace(/MM/g, '%m')
-        .replace(/DD/g, '%d')
-        .replace(/hh/g, '%H')
-        .replace(/mm/g, '%i')
-        .replace(/ss/g, '%S');
-      return sequelize.fn('date_format', sequelize.col(field), format);
-    case 'postgres':
-      format = format.replace(/hh/g, 'HH24').replace(/mm/g, 'MI').replace(/ss/g, 'SS');
-      return sequelize.fn('to_char', sequelize.col(field), format);
-    default:
-      return field;
-  }
-};
-
-export const formatFn = (sequelize: any, dialect: string, field: string, format: string) => {
-  switch (dialect) {
-    case 'sqlite':
-    case 'postgres':
-      return sequelize.fn('format', format, sequelize.col(field));
-    default:
-      return field;
-  }
-};
-
-export const formatter = (sequelize: any, type: string, field: string, format: string) => {
-  const dialect = sequelize.getDialect();
-  switch (type) {
-    case 'date':
-    case 'datetime':
-    case 'time':
-      return dateFormatFn(sequelize, dialect, field, format);
-    default:
-      return formatFn(sequelize, dialect, field, format);
-  }
-};

package/src/server/index.ts

@@ -1 +0,0 @@
-export { default } from './plugin';

package/src/server/plugin.ts

@@ -1,37 +0,0 @@
-import { Cache, createCache } from '@nocobase/cache';
-import { InstallOptions, Plugin } from '@nocobase/server';
-import { query } from './actions/query';
-
-export class DataVisualizationPlugin extends Plugin {
-  cache: Cache;
-
-  afterAdd() {}
-
-  beforeLoad() {
-    this.app.resource({
-      name: 'charts',
-      actions: {
-        query,
-      },
-    });
-    this.app.acl.allow('charts', 'query', 'loggedIn');
-  }
-
-  async load() {
-    this.cache = createCache({
-      ttl: 30, // seconds
-      max: 1000,
-      store: 'memory',
-    });
-  }
-
-  async install(options?: InstallOptions) {}
-
-  async afterEnable() {}
-
-  async afterDisable() {}
-
-  async remove() {}
-}
-
-export default DataVisualizationPlugin;