@nocobase/database 0.8.0-alpha.9 → 0.8.1-alpha.3

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

@@ -1,480 +0,0 @@
-import moment from 'moment';
-
-import { Database } from '../../database';
-import { mockDatabase } from '..';
-
-describe('string field', () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = mockDatabase();
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  describe('define', () => {
-    it('without any pattern will throw error', async () => {
-      expect(() => {
-        db.collection({
-          name: 'tests',
-          fields: [{ type: 'sequence', name: 'name' }],
-        });
-      }).toThrow();
-    });
-
-    it('with empty pattern will throw error', async () => {
-      expect(() => {
-        db.collection({
-          name: 'tests',
-          fields: [{ type: 'sequence', name: 'name', patterns: [] }],
-        });
-      }).toThrow();
-    });
-  });
-
-  describe('string pattern', () => {
-    it('no options', async () => {
-      expect(() => {
-        db.collection({
-          name: 'tests',
-          fields: [{ type: 'sequence', name: 'name', patterns: [{ type: 'string' }] }],
-        });
-      }).toThrow();
-    });
-
-    it('constant', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'string', options: { value: 'abc' } }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe('abc');
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe('abc');
-    });
-  });
-
-  describe('integer pattern', () => {
-    it('default start from 0, digits as 1, no cycle', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              {
-                type: 'integer'
-              }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe('0');
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe('1');
-    });
-
-    it('start from 9', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              {
-                type: 'integer',
-                options: {
-                  start: 9
-                }
-              }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe('9');
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe('9');
-    });
-
-    it('start from 0, current set to 9', async () => {
-      const collection = db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              {
-                type: 'integer'
-              }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-      const field = collection.getField('name');
-      // set current option in memory
-      field.options.patterns[0].options = { current: 9 };
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe('0');
-    });
-
-    it('digits more than 1, start from 9', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              {
-                type: 'integer',
-                options: {
-                  digits: 2,
-                  start: 9
-                }
-              }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe('09');
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe('10');
-    });
-
-    it('cycle by day', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              {
-                type: 'integer',
-                options: {
-                  cycle: '0 0 * * * *'
-                }
-              }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const now = new Date();
-      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create({
-        createdAt: yesterday
-      });
-      expect(item1.get('name')).toBe('0');
-
-      const item2 = await TestModel.create({
-        createdAt: yesterday
-      });
-      expect(item2.get('name')).toBe('1');
-
-      const item3 = await TestModel.create();
-      expect(item3.get('name')).toBe('0');
-
-      const item4 = await TestModel.create();
-      expect(item4.get('name')).toBe('1');
-    });
-
-    it('last record has no value of this field', async () => {
-      const testCollection = db.collection({
-        name: 'tests',
-        fields: [],
-      });
-      await db.sync();
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBeUndefined();
-
-      testCollection.addField('name', {
-        type: 'sequence',
-        patterns: [
-          {
-            type: 'integer'
-          }
-        ]
-      });
-      await db.sync();
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe('0');
-    });
-  });
-
-  describe('date pattern', () => {
-    it('default to current createdAt as YYYYMMDD', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'date' }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const now = new Date();
-      const YYYYMMDD = moment(now).format('YYYYMMDD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe(YYYYMMDD);
-    });
-
-    it('field option', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'date', options: { field: 'date' } }
-            ]
-          },
-          {
-            type: 'date',
-            name: 'date'
-          }
-        ],
-      });
-      await db.sync();
-
-      const date = new Date(2022, 7, 1);
-      const YYYYMMDD = moment(date).format('YYYYMMDD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create({
-        date
-      });
-      expect(item1.get('name')).toBe(YYYYMMDD);
-    });
-
-    it('format option', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'date', options: { format: 'YYYY-MM-DD' } }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const now = new Date();
-      const YYYYMMDD = moment(now).format('YYYY-MM-DD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe(YYYYMMDD);
-    });
-  });
-
-  describe('mixed pattern', () => {
-    it('all patterns', async () => {
-      db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'string', options: { value: 'A' } },
-              { type: 'date' },
-              { type: 'integer' }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const now = new Date();
-      const YYYYMMDD = moment(now).format('YYYYMMDD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe(`A${YYYYMMDD}0`);
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe(`A${YYYYMMDD}1`);
-    });
-
-    it('changed after generated', async () => {
-      const testsCollection = db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'string', options: { value: 'A' } },
-              { type: 'date' },
-              { type: 'integer' }
-            ]
-          }
-        ],
-      });
-      await db.sync();
-
-      const now = new Date();
-      const YYYYMMDD = moment(now).format('YYYYMMDD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create();
-      expect(item1.get('name')).toBe(`A${YYYYMMDD}0`);
-
-      testsCollection.setField('name', {
-        type: 'sequence',
-        patterns: [
-          { type: 'string', options: { value: 'A' } },
-          { type: 'date' },
-          // change options but no difference with default
-          { type: 'integer', options: { digits: 1 } }
-        ]
-      });
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe(`A${YYYYMMDD}1`);
-
-      testsCollection.setField('name', {
-        type: 'sequence',
-        patterns: [
-          { type: 'string', options: { value: 'A' } },
-          { type: 'date' },
-          { type: 'integer', options: { digits: 2 } }
-        ]
-      });
-
-      const item3 = await TestModel.create();
-      expect(item3.get('name')).toBe(`A${YYYYMMDD}00`);
-
-      testsCollection.setField('name', {
-        type: 'sequence',
-        patterns: [
-          { type: 'string', options: { value: 'a' } },
-          { type: 'date' },
-          { type: 'integer', options: { digits: 2 } }
-        ]
-      });
-
-      const item4 = await TestModel.create();
-      expect(item4.get('name')).toBe(`a${YYYYMMDD}01`);
-
-      testsCollection.setField('name', {
-        type: 'sequence',
-        patterns: [
-          { type: 'date' },
-          { type: 'integer', options: { digits: 2 } }
-        ]
-      });
-
-      const item5 = await TestModel.create();
-      expect(item5.get('name')).toBe(`${YYYYMMDD}00`);
-    });
-  });
-
-  describe('multiple serial fields', () => {
-    it('2 fields', async () => {
-      const testsCollection = db.collection({
-        name: 'tests',
-        fields: [
-          {
-            type: 'sequence',
-            name: 'name',
-            patterns: [
-              { type: 'string', options: { value: 'A' } },
-              { type: 'date' },
-              { type: 'integer', options: { digits: 2, cycle: '0 0 * * *' } }
-            ]
-          },
-          {
-            type: 'sequence',
-            name: 'code',
-            patterns: [
-              { type: 'string', options: { value: 'C' } },
-              { type: 'integer', options: { digits: 4 }}
-            ]
-          }
-        ]
-      });
-      await db.sync();
-
-      const now = new Date();
-      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-      const NOW = moment(now).format('YYYYMMDD');
-      const YESTERDAY = moment(yesterday).format('YYYYMMDD');
-
-      const TestModel = db.getModel('tests');
-      const item1 = await TestModel.create({ createdAt: yesterday });
-      expect(item1.get('name')).toBe(`A${YESTERDAY}00`);
-      expect(item1.get('code')).toBe(`C0000`);
-
-      const item2 = await TestModel.create();
-      expect(item2.get('name')).toBe(`A${NOW}00`);
-      expect(item2.get('code')).toBe(`C0001`);
-
-      testsCollection.setField('name', {
-        type: 'sequence',
-        patterns: [
-          { type: 'string', options: { value: 'a' } },
-          { type: 'date' },
-          { type: 'integer', options: { digits: 1 } }
-        ]
-      });
-
-      const item3 = await TestModel.create();
-      expect(item3.get('name')).toBe(`a${NOW}0`);
-      expect(item3.get('code')).toBe(`C0002`);
-    });
-  });
-});

package/src/fields/sequence-field.ts

@@ -1,202 +0,0 @@
-import { DataTypes, Transactionable } from 'sequelize';
-import parser from 'cron-parser';
-import moment from 'moment';
-import { escapeRegExp } from 'lodash';
-
-import { Registry } from '@nocobase/utils';
-
-import { Model } from '..';
-import { BaseColumnFieldOptions, Field, FieldContext } from './field';
-
-interface Pattern {
-  validate?(options): string | null;
-  generate(this: SequenceField, instance: Model, index: number): string;
-  getLength(options): number;
-  getMatcher(options): string;
-}
-
-export const sequencePatterns = new Registry<Pattern>();
-
-sequencePatterns.register('string', {
-  validate(options) {
-    if (!options?.value) {
-      return 'options.value should be configured as a non-empty string';
-    }
-    return null;
-  },
-  generate(instance, index) {
-    const { options } = this.options.patterns[index];
-    return options.value;
-  },
-  getLength(options) {
-    return options.value.length;
-  },
-  getMatcher(options) {
-    return escapeRegExp(options.value);
-  }
-});
-
-sequencePatterns.register('integer', {
-  generate(instance: Model, index) {
-    const { options = {} } = this.options.patterns[index];
-    const { digits = 1, start = 0, base = 10, cycle } = options;
-    const max = Math.pow(base, digits) - 1;
-    const { lastRecord = null } = this.options;
-
-    if (typeof options.current === 'undefined') {
-      if (lastRecord && lastRecord.get(this.options.name)) {
-        // if match current pattern
-        const matcher = this.match(lastRecord.get(this.options.name));
-        if (matcher) {
-          const lastNumber = Number.parseInt(matcher[index + 1], base);
-          options.current = Number.isNaN(lastNumber) ? start : lastNumber + 1;
-        } else {
-          options.current = start;
-        }
-      } else {
-        options.current = start;
-      }
-    } else {
-      options.current += 1;
-    }
-
-    // cycle as cron string
-    if (cycle && lastRecord) {
-      const interval = parser.parseExpression(cycle, { currentDate: <Date>lastRecord.get('createdAt') });
-      const next = interval.next();
-      if ((<Date>instance.get('createdAt')).getTime() >= next.getTime()) {
-        options.current = start;
-      }
-    }
-
-    if (options.current > max) {
-      options.current = start;
-    }
-
-    // update options
-    Object.assign(this.options.patterns[index], { options });
-
-    return options.current.toString(base).padStart(digits, '0');
-  },
-
-  getLength({ digits = 1 } = {}) {
-    return digits;
-  },
-
-  getMatcher(options = {}) {
-    const { digits = 1, start = 0, base = 10 } = options;
-    const startLen = start ? start.toString(base).length : 1;
-    const chars = '0123456789abcdefghijklmnopqrstuvwxyz'.slice(0, base);
-    return `[${chars}]{${digits}}`;
-  }
-});
-
-sequencePatterns.register('date', {
-  generate(instance, index) {
-    const { options } = this.options.patterns[index];
-    return moment(instance.get(options?.field ?? 'createdAt')).format(options?.format ?? 'YYYYMMDD');
-  },
-  getLength(options) {
-    return options.format?.length ?? 8;
-  },
-  getMatcher(options = {}) {
-    return `.{${options?.format?.length ?? 8}}`;
-  }
-});
-
-interface PatternConfig {
-  type: string;
-  title?: string;
-  options?: any;
-}
-export interface SequenceFieldOptions extends BaseColumnFieldOptions {
-  type: 'sequence';
-  patterns: PatternConfig[]
-}
-
-export class SequenceField extends Field {
-  matcher: RegExp;
-
-  get dataType() {
-    return DataTypes.STRING;
-  }
-
-  constructor(options: SequenceFieldOptions, context: FieldContext) {
-    super(options, context);
-    if (!options.patterns || !options.patterns.length) {
-      throw new Error('at least one pattern should be defined for sequence type');
-    }
-    options.patterns.forEach(pattern => {
-      const P = sequencePatterns.get(pattern.type);
-      if (!P) {
-        throw new Error(`pattern type ${pattern.type} is not registered`);
-      }
-      if (P.validate) {
-        const error = P.validate(pattern.options);
-        if (error) {
-          throw new Error(error);
-        }
-      }
-    });
-
-    const patterns = options.patterns
-      .map(({ type, options }) => sequencePatterns.get(type).getMatcher(options));
-    this.matcher = new RegExp(`^${patterns.map(p => `(${p})`).join('')}$`, 'i');
-  }
-
-  setValue = async (instance: Model, options) => {
-    const { name, patterns } = this.options;
-    // NOTE: only load when value is not set, if null stand for no last record
-    if (typeof this.options.lastRecord === 'undefined') {
-      const model = <typeof Model>instance.constructor;
-      this.options.lastRecord = await model.findOne({
-        attributes: [model.primaryKeyAttribute, this.options.name, 'createdAt'],
-        order: [
-          ['createdAt', 'DESC'],
-          // TODO(bug): will cause problem if no auto-increment id
-          [model.primaryKeyAttribute, 'DESC']
-        ],
-        transaction: options.transaction
-      });
-    }
-
-    const results = patterns.reduce((result, p, i) => {
-      const item = sequencePatterns.get(p.type).generate.call(this, instance, i, options);
-      return result.concat(item);
-    }, []);
-    instance.set(name, results.join(''));
-  };
-
-  setLast = (instance: Model, options) => {
-    this.options.lastRecord = instance;
-  };
-
-  match(value) {
-    return typeof value === 'string' ? value.match(this.matcher) : null;
-  }
-
-  parse(value: string, patternIndex: number): string {
-    for (let i = 0, index = 0; i < this.options.patterns.length; i += 1) {
-      const { type, options } = this.options.patterns[i];
-      const { getLength } = sequencePatterns.get(type);
-      const length = getLength(options);
-      if (i === patternIndex) {
-        return value.substring(index, index + length);
-      }
-      index += length;
-    }
-    return '';
-  }
-
-  bind() {
-    super.bind();
-    this.on('beforeCreate', this.setValue);
-    this.on('afterCreate', this.setLast);
-  }
-
-  unbind() {
-    super.unbind();
-    this.off('beforeCreate', this.setValue);
-    this.off('afterCreate', this.setLast);
-  }
-}