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

package/lib/query-interface/sqlite-query-interface.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _queryInterface = _interopRequireDefault(require("./query-interface"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class SqliteQueryInterface extends _queryInterface.default {
+  constructor(db) {
+    super(db);
+  }
+
+  collectionTableExists(collection, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = options === null || options === void 0 ? void 0 : options.transaction;
+      const tableName = collection.model.tableName;
+      const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`;
+      const results = yield _this.db.sequelize.query(sql, {
+        type: 'SELECT',
+        transaction
+      });
+      return results.length > 0;
+    })();
+  }
+
+}
+
+exports.default = SqliteQueryInterface;

package/lib/relation-repository/belongs-to-many-repository.js

@@ -97,13 +97,15 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
       const transaction = yield _this2.getTransaction(options);
       const association = _this2.association;
 
+      const throughModel = _this2.throughModel();
+
       const instancesToIds = instances => {
         return instances.map(instance => instance.get(_this2.targetKey()));
       }; // Through Table
 
 
       const throughTableWhere = [{
-        [association.foreignKey]: _this2.sourceKeyValue
+        [throughModel.rawAttributes[association.foreignKey].field]: _this2.sourceKeyValue
       }];
       let ids;
 
@@ -130,7 +132,7 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
       }
 
       throughTableWhere.push({
-        [association.otherKey]: {
+        [throughModel.rawAttributes[association.otherKey].field]: {
           [_sequelize().Op.in]: ids
         }
       }); // delete through table data

package/lib/relation-repository/multiple-relation-repository.js

@@ -75,6 +75,7 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
       const getAccessor = _this.accessors().get;
 
       const sourceModel = yield _this.getSourceModel(transaction);
+      if (!sourceModel) return [];
 
       if (findOptions.include && findOptions.include.length > 0) {
         const ids = (yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
@@ -139,6 +140,7 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
     return _asyncToGenerator(function* () {
       const transaction = yield _this3.getTransaction(options);
       const sourceModel = yield _this3.getSourceModel(transaction);
+      if (!sourceModel) return 0;
 
       const queryOptions = _this3.buildQueryOptions(options);
 

package/lib/relation-repository/single-relation-repository.js

@@ -80,6 +80,7 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
       const getAccessor = _this3.accessors().get;
 
       const sourceModel = yield _this3.getSourceModel(transaction);
+      if (!sourceModel) return null;
 
       if ((findOptions === null || findOptions === void 0 ? void 0 : (_findOptions$include = findOptions.include) === null || _findOptions$include === void 0 ? void 0 : _findOptions$include.length) > 0) {
         const templateModel = yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {

package/lib/repository.js

@@ -350,7 +350,8 @@ class Repository {
       const transaction = yield _this5.getTransaction(options);
 
       const guard = _updateGuard.UpdateGuard.fromOptions(_this5.model, _objectSpread(_objectSpread({}, options), {}, {
-        action: 'create'
+        action: 'create',
+        underscored: _this5.collection.options.underscored
       }));
 
       const values = guard.sanitize(options.values || {});
@@ -436,7 +437,9 @@ class Repository {
 
       const transaction = yield _this7.getTransaction(options);
 
-      const guard = _updateGuard.UpdateGuard.fromOptions(_this7.model, options);
+      const guard = _updateGuard.UpdateGuard.fromOptions(_this7.model, _objectSpread(_objectSpread({}, options), {}, {
+        underscored: _this7.collection.options.underscored
+      }));
 
       const values = guard.sanitize(options.values);
 

package/lib/sync-runner.d.ts

@@ -1,4 +1,4 @@
 export declare class SyncRunner {
     static syncInheritModel(model: any, options: any): Promise<void>;
-    static createTable(tableName: any, attributes: any, options: any, model: any, parentTables: any): Promise<any>;
+    static createTable(tableName: any, attributes: any, options: any, model: any, parents: any): Promise<any>;
 }

package/lib/sync-runner.js

@@ -54,8 +54,7 @@ class SyncRunner {
         throw new Error(`Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${_lodash().default.castArray(inheritedCollection.options.inherits).join(', ')}`);
       }
 
-      const parentTables = parents.map(parent => parent.model.tableName);
-      const tableName = model.getTableName();
+      const tableName = inheritedCollection.addSchemaTableName();
       const attributes = model.tableAttributes;
 
       const childAttributes = _lodash().default.pickBy(attributes, value => {
@@ -63,17 +62,20 @@ class SyncRunner {
       });
 
       let maxSequenceVal = 0;
-      let maxSequenceName;
+      let maxSequenceName; // find max sequence
 
       if (childAttributes.id && childAttributes.id.autoIncrement) {
-        var _iterator = _createForOfIteratorHelper(parentTables),
+        var _iterator = _createForOfIteratorHelper(parents),
             _step;
 
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done;) {
             const parent = _step.value;
-            const sequenceNameResult = yield queryInterface.sequelize.query(`SELECT column_default FROM information_schema.columns WHERE 
-          table_name='${parent}' and "column_name" = 'id';`, {
+            const sequenceNameResult = yield queryInterface.sequelize.query(`SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${parent.model.tableName}'
+            and table_schema = '${parent.collectionSchema()}'
+             and "column_name" = 'id';`, {
               transaction
             });
 
@@ -87,10 +89,11 @@ class SyncRunner {
               throw new Error(`Can't find sequence name of ${parent}`);
             }
 
-            const regex = new RegExp(/nextval\('("?\w+"?)\'.*\)/);
+            const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
             const match = regex.exec(columnDefault);
             const sequenceName = match[1];
-            const sequenceCurrentValResult = yield queryInterface.sequelize.query(`select last_value from ${sequenceName}`, {
+            const sequenceCurrentValResult = yield queryInterface.sequelize.query(`select last_value
+           from ${sequenceName}`, {
               transaction
             });
             const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]['last_value']);
@@ -107,22 +110,21 @@ class SyncRunner {
         }
       }
 
-      yield _this.createTable(tableName, childAttributes, options, model, parentTables);
+      yield _this.createTable(tableName, childAttributes, options, model, parents); // if we have max sequence, set it to child table
 
       if (maxSequenceName) {
-        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(parent => db.getCollection(parent).model.tableName);
+        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(parent => db.getCollection(parent).addSchemaTableName());
         const sequenceTables = [...parentsDeep, tableName];
 
         for (var _i = 0, _sequenceTables = sequenceTables; _i < _sequenceTables.length; _i++) {
           const sequenceTable = _sequenceTables[_i];
-          const queryName = Boolean(sequenceTable.match(/[A-Z]/)) ? `"${sequenceTable}"` : sequenceTable;
-          const idColumnQuery = yield queryInterface.sequelize.query(`
-SELECT true
-FROM   pg_attribute 
-WHERE  attrelid = '${queryName}'::regclass  -- cast to a registered class (table)
-AND    attname = 'id'
-AND    NOT attisdropped 
-`, {
+          const tableName = sequenceTable.tableName;
+          const schemaName = sequenceTable.schema;
+          const queryName = Boolean(tableName.match(/[A-Z]/)) && !tableName.includes(`"`) ? `"${tableName}"` : tableName;
+          const idColumnQuery = yield queryInterface.sequelize.query(`SELECT column_name
+FROM information_schema.columns
+WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
+          `, {
             transaction
           });
 
@@ -130,7 +132,8 @@ AND    NOT attisdropped
             continue;
           }
 
-          yield queryInterface.sequelize.query(`alter table "${sequenceTable}" alter column id set default nextval('${maxSequenceName}')`, {
+          yield queryInterface.sequelize.query(`alter table ${db.utils.quoteTable(sequenceTable)}
+            alter column id set default nextval('${maxSequenceName}')`, {
             transaction
           });
         }
@@ -139,7 +142,9 @@ AND    NOT attisdropped
       if (options.alter) {
         const columns = yield queryInterface.describeTable(tableName, options);
 
-        for (const columnName in childAttributes) {
+        for (const attribute in childAttributes) {
+          const columnName = childAttributes[attribute].field;
+
           if (!columns[columnName]) {
             yield queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
           }
@@ -148,7 +153,7 @@ AND    NOT attisdropped
     })();
   }
 
-  static createTable(tableName, attributes, options, model, parentTables) {
+  static createTable(tableName, attributes, options, model, parents) {
     return _asyncToGenerator(function* () {
       let sql = '';
       options = _objectSpread({}, options);
@@ -171,7 +176,9 @@ AND    NOT attisdropped
         table: tableName,
         context: 'createTable'
       });
-      sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(';', ` INHERITS (${parentTables.map(t => `"${t}"`).join(', ')});`);
+      sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(';', ` INHERITS (${parents.map(t => {
+        return t.addSchemaTableName();
+      }).join(', ')});`);
       return yield model.sequelize.query(sql, options);
     })();
   }

package/lib/types.d.ts

@@ -13,6 +13,9 @@ export declare type ModelDestroyEventType = 'beforeDestroy' | 'afterDestroy';
 export declare type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations';
 export declare type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
 export declare type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
+export declare type ModelBulkCreateEvnetType = 'beforeBulkCreate' | 'afterBulkCreate';
+export declare type ModelBulkUpdateEvnetType = 'beforeBulkUpdate' | 'afterBulkUpdate';
+export declare type ModelBulkDestroyEvnetType = 'beforeBulkDestroy' | 'afterBulkDestroy';
 export declare type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
 export declare type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
 export declare type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
@@ -21,7 +24,10 @@ export declare type ModelDestroyEventTypes = ModelDestroyEventType | `${Collecti
 export declare type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsEventType | `${CollectionNameType}.${ModelCreateWithAssociationsEventType}`;
 export declare type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
 export declare type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
-export declare type ModelEventTypes = ModelSyncEventType | ModelValidateEventTypes | ModelCreateEventTypes | ModelUpdateEventTypes | ModelSaveEventTypes | ModelDestroyEventTypes | ModelCreateWithAssociationsEventTypes | ModelUpdateWithAssociationsEventTypes | ModelSaveWithAssociationsEventTypes;
+export declare type ModelBulkCreateEvnetTypes = ModelBulkCreateEvnetType | `${CollectionNameType}.${ModelBulkCreateEvnetType}`;
+export declare type ModelBulkUpdateEvnetTypes = ModelBulkUpdateEvnetType | `${CollectionNameType}.${ModelBulkUpdateEvnetType}`;
+export declare type ModelBulkDestroyEvnetTypes = ModelBulkDestroyEvnetType | `${CollectionNameType}.${ModelBulkDestroyEvnetType}`;
+export declare type ModelEventTypes = ModelSyncEventType | ModelValidateEventTypes | ModelCreateEventTypes | ModelUpdateEventTypes | ModelSaveEventTypes | ModelDestroyEventTypes | ModelCreateWithAssociationsEventTypes | ModelUpdateWithAssociationsEventTypes | ModelSaveWithAssociationsEventTypes | ModelBulkCreateEvnetTypes | ModelBulkUpdateEvnetTypes | ModelBulkDestroyEvnetTypes;
 export declare type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
 export declare type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';
 export declare type DatabaseBeforeRemoveCollectionEventType = 'beforeRemoveCollection';

package/lib/update-associations.js

@@ -463,7 +463,8 @@ function _updateMultipleAssociation() {
       if (isStringOrNumber(value)) {
         yield model[setAccessor](value, {
           transaction,
-          context
+          context,
+          individualHooks: true
         });
         return;
       }
@@ -476,6 +477,8 @@ function _updateMultipleAssociation() {
 
       const list2 = []; // to be added
 
+      const created = [];
+
       var _iterator3 = _createForOfIteratorHelper(value),
           _step3;
 
@@ -494,6 +497,13 @@ function _updateMultipleAssociation() {
           } else if (item.sequelize) {
             list1.push(item);
           } else if (typeof item === 'object') {
+            const targetKey = association.targetKey || 'id';
+
+            if (item[targetKey]) {
+              created.push(item[targetKey]);
+              list1.push(item[targetKey]);
+            }
+
             list2.push(item);
           }
         } // associate targets in lists1
@@ -506,7 +516,8 @@ function _updateMultipleAssociation() {
 
       yield model[setAccessor](list1, {
         transaction,
-        context
+        context,
+        individualHooks: true
       });
       const list3 = [];
 
@@ -544,7 +555,10 @@ function _updateMultipleAssociation() {
           }
 
           const addAccessor = association.accessors.add;
-          yield model[addAccessor](item[pk], accessorOptions);
+
+          if (!created.includes(item[pk])) {
+            yield model[addAccessor](item[pk], accessorOptions);
+          }
 
           if (!recursive) {
             continue;

package/lib/update-guard.d.ts

@@ -8,6 +8,7 @@ declare type UpdateAction = 'create' | 'update';
 export declare class UpdateGuard {
     model: ModelStatic<any>;
     action: UpdateAction;
+    underscored: boolean;
     private associationKeysToBeUpdate;
     private blackList;
     private whiteList;

package/lib/update-guard.js

@@ -23,6 +23,7 @@ class UpdateGuard {
   constructor() {
     this.model = void 0;
     this.action = void 0;
+    this.underscored = void 0;
     this.associationKeysToBeUpdate = void 0;
     this.blackList = void 0;
     this.whiteList = void 0;
@@ -164,6 +165,11 @@ class UpdateGuard {
     guard.setBlackList(options.blacklist);
     guard.setAction(_lodash().default.get(options, 'action', 'update'));
     guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+
+    if (options.underscored) {
+      guard.underscored = options.underscored;
+    }
+
     return guard;
   }
 

package/lib/utils.d.ts

@@ -1,3 +1,4 @@
+import Database from './database';
 import { Model } from './model';
 declare type HandleAppendsQueryOptions = {
     templateModel: any;
@@ -6,4 +7,8 @@ declare type HandleAppendsQueryOptions = {
 export declare function handleAppendsQuery(options: HandleAppendsQueryOptions): Promise<Model<any, any>[]>;
 export declare function md5(value: string): string;
 export declare function checkIdentifier(value: string): void;
+export declare function getTableName(collectionName: string, options: any): any;
+export declare function snakeCase(name: string): any;
+export declare function patchSequelizeQueryInterface(db: Database): void;
+export declare function percent2float(value: string): number;
 export {};

package/lib/utils.js

@@ -4,8 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.checkIdentifier = checkIdentifier;
+exports.getTableName = getTableName;
 exports.handleAppendsQuery = handleAppendsQuery;
 exports.md5 = md5;
+exports.patchSequelizeQueryInterface = patchSequelizeQueryInterface;
+exports.percent2float = percent2float;
+exports.snakeCase = snakeCase;
 
 function _crypto() {
   const data = _interopRequireDefault(require("crypto"));
@@ -19,6 +23,16 @@ function _crypto() {
 
 var _identifierError = require("./errors/identifier-error");
 
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -128,4 +142,68 @@ function checkIdentifier(value) {
   if (value.length > MAX_IDENTIFIER_LENGTH) {
     throw new _identifierError.IdentifierError(`Identifier ${value} is too long`);
   }
+}
+
+function getTableName(collectionName, options) {
+  return options.underscored ? snakeCase(collectionName) : collectionName;
+}
+
+function snakeCase(name) {
+  return require('sequelize').Utils.underscore(name);
+}
+
+function patchShowConstraintsQuery(queryGenerator, db) {
+  queryGenerator.showConstraintsQuery = (tableName, constraintName) => {
+    const lines = ['SELECT constraint_catalog AS "constraintCatalog",', 'constraint_schema AS "constraintSchema",', 'constraint_name AS "constraintName",', 'table_catalog AS "tableCatalog",', 'table_schema AS "tableSchema",', 'table_name AS "tableName",', 'constraint_type AS "constraintType",', 'is_deferrable AS "isDeferrable",', 'initially_deferred AS "initiallyDeferred"', 'from INFORMATION_SCHEMA.table_constraints', `WHERE table_name='${_lodash().default.isPlainObject(tableName) ? tableName.tableName : tableName}'`];
+
+    if (!constraintName) {
+      lines.push(`AND constraint_name='${constraintName}'`);
+    }
+
+    if (_lodash().default.isPlainObject(tableName) && tableName.schema) {
+      lines.push(`AND table_schema='${tableName.schema}'`);
+    }
+
+    return lines.join(' ');
+  };
+}
+
+function patchDescribeTableQuery(queryGenerator) {
+  const describeTableQuery = function describeTableQuery(tableName, schema) {
+    schema = schema || this.options.schema || 'public';
+    return 'SELECT ' + 'pk.constraint_type as "Constraint",' + 'c.column_name as "Field", ' + 'c.column_default as "Default",' + 'c.is_nullable as "Null", ' + "(CASE WHEN c.udt_name = 'hstore' THEN c.udt_name ELSE c.data_type END) || (CASE WHEN c.character_maximum_length IS NOT NULL THEN '(' || c.character_maximum_length || ')' ELSE '' END) as \"Type\", " + '(SELECT array_agg(e.enumlabel) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_enum e ON t.oid=e.enumtypid WHERE t.typname=c.udt_name) AS "special", ' + '(SELECT pgd.description FROM pg_catalog.pg_statio_all_tables AS st INNER JOIN pg_catalog.pg_description pgd on (pgd.objoid=st.relid) WHERE c.ordinal_position=pgd.objsubid AND c.table_name=st.relname AND st.schemaname = c.table_schema) AS "Comment" ' + 'FROM information_schema.columns c ' + 'LEFT JOIN (SELECT tc.table_schema, tc.table_name, ' + 'cu.column_name, tc.constraint_type ' + 'FROM information_schema.TABLE_CONSTRAINTS tc ' + 'JOIN information_schema.KEY_COLUMN_USAGE  cu ' + 'ON tc.table_schema=cu.table_schema and tc.table_name=cu.table_name ' + 'and tc.constraint_name=cu.constraint_name ' + "and tc.constraint_type='PRIMARY KEY') pk " + 'ON pk.table_schema=c.table_schema ' + 'AND pk.table_name=c.table_name ' + 'AND pk.column_name=c.column_name ' + `WHERE c.table_name = ${this.escape(tableName)} AND c.table_schema = ${this.escape(schema)}`;
+  };
+
+  queryGenerator.describeTableQuery = describeTableQuery.bind(queryGenerator);
+}
+
+function patchSequelizeQueryInterface(db) {
+  if (db.inDialect('postgres')) {
+    //@ts-ignore
+    const queryGenerator = db.sequelize.dialect.queryGenerator;
+    patchShowConstraintsQuery(queryGenerator, db);
+    patchDescribeTableQuery(queryGenerator);
+  }
+}
+
+function percent2float(value) {
+  if (!value.endsWith('%')) {
+    return NaN;
+  }
+
+  let val = value.substring(0, value.length - 1);
+
+  if (isNaN(+val)) {
+    return NaN;
+  }
+
+  const index = value.indexOf('.');
+
+  if (index === -1) {
+    return parseFloat(value) / 100;
+  }
+
+  const repeat = value.length - index - 2;
+  const v = parseInt('1' + '0'.repeat(repeat));
+  return parseFloat(value) * v / (100 * v);
 }

package/lib/value-parsers/array-value-parser.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ArrayValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+    getOptions(): {
+        map: Map<any, any>;
+        set: Set<unknown>;
+    };
+}

package/lib/value-parsers/array-value-parser.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class ArrayValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const _this$getOptions = _this.getOptions(),
+            map = _this$getOptions.map,
+            set = _this$getOptions.set;
+
+      const values = _this.toArr(value);
+
+      if (set.size > 0) {
+        const filtered = values.map(v => map.has(v) ? map.get(v) : v).filter(v => set.has(v));
+
+        if (values.length === filtered.length) {
+          _this.value = filtered;
+        } else {
+          _this.errors.push(`No matching option found - ${JSON.stringify(value)}`);
+        }
+      } else {
+        _this.value = values;
+      }
+    })();
+  }
+
+  getOptions() {
+    var _this$field$options, _this$field$options$u;
+
+    const options = ((_this$field$options = this.field.options) === null || _this$field$options === void 0 ? void 0 : (_this$field$options$u = _this$field$options['uiSchema']) === null || _this$field$options$u === void 0 ? void 0 : _this$field$options$u.enum) || [];
+    const map = new Map();
+    const set = new Set();
+
+    var _iterator = _createForOfIteratorHelper(options),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const option = _step.value;
+        set.add(option.value);
+        set.add(option.label);
+        map.set(option.label, option.value);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return {
+      map,
+      set
+    };
+  }
+
+}
+
+exports.ArrayValueParser = ArrayValueParser;

package/lib/value-parsers/base-value-parser.d.ts

@@ -0,0 +1,12 @@
+export declare class BaseValueParser {
+    ctx: any;
+    field: any;
+    value: any;
+    errors: string[];
+    constructor(field: any, ctx: any);
+    trim(value: any): any;
+    toArr(value: any, splitter?: string): any[];
+    toString(): any;
+    getValue(): any;
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/base-value-parser.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseValueParser = void 0;
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class BaseValueParser {
+  constructor(field, ctx) {
+    this.ctx = void 0;
+    this.field = void 0;
+    this.value = void 0;
+    this.errors = [];
+    this.field = field;
+    this.ctx = ctx;
+    this.value = null;
+  }
+
+  trim(value) {
+    return typeof value === 'string' ? value.trim() : value;
+  }
+
+  toArr(value, splitter) {
+    let values = [];
+
+    if (!value) {
+      values = [];
+    } else if (typeof value === 'string') {
+      values = value.split(splitter || /,|，|、/);
+    } else if (Array.isArray(value)) {
+      values = value;
+    }
+
+    return values.map(v => this.trim(v)).filter(Boolean);
+  }
+
+  toString() {
+    return this.value;
+  }
+
+  getValue() {
+    return this.value;
+  }
+
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.value = value;
+    })();
+  }
+
+}
+
+exports.BaseValueParser = BaseValueParser;

package/lib/value-parsers/boolean-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class BooleanValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}