@quanxiaoxiao/datav 0.3.2 → 0.5.0

package/src/validateExpressSchema.test.ts

@@ -0,0 +1,295 @@
+import assert from 'node:assert';
+import { describe, test } from 'node:test';
+
+import { validateExpressSchema } from './validateExpressSchema.js';
+
+// 用于测试无效类型输入
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnySchema = any;
+
+describe('validateExpressSchema', () => {
+  describe('基础类型验证', () => {
+    const basicTypes = ['string', 'number', 'boolean', 'integer'] as const;
+
+    basicTypes.forEach(type => {
+      test(`应该通过 ${type} 类型验证`, () => {
+        assert.doesNotThrow(() => {
+          validateExpressSchema({ type });
+        });
+      });
+    });
+
+    test('基础类型可以包含可选的 properties', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'string',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          properties: ['dataKey'] as any,
+        });
+      });
+    });
+  });
+
+  describe('对象类型验证', () => {
+    test('应该通过有效的 object 类型验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            age: { type: 'number' },
+          },
+        });
+      });
+    });
+
+    test('应该通过空 properties 的 object 类型验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'object',
+          properties: {},
+        });
+      });
+    });
+
+    test('object 类型缺少 properties 应该抛出错误', () => {
+      assert.throws(
+        () => validateExpressSchema({ type: 'object' } as AnySchema),
+        /Invalid schema/,
+      );
+    });
+
+    test('object 类型的 properties 必须是对象', () => {
+      assert.throws(
+        () => validateExpressSchema({
+          type: 'object',
+          properties: 'invalid',
+        } as AnySchema),
+        /Invalid schema/,
+      );
+    });
+
+    test('object 类型的 properties 不能是数组', () => {
+      assert.throws(
+        () => validateExpressSchema({
+          type: 'object',
+          properties: [],
+        } as AnySchema),
+        /Invalid schema/,
+      );
+    });
+  });
+
+  describe('数组类型验证', () => {
+    test('应该通过 properties 为对象的 array 类型验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'array',
+          properties: {
+            items: { type: 'string' },
+          },
+        });
+      });
+    });
+
+    test('应该通过 properties 为元组的 array 类型验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'array',
+          properties: ['items', { type: 'string' }],
+        });
+      });
+    });
+
+    test('应该通过空 properties 对象的 array 类型验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'array',
+          properties: {},
+        });
+      });
+    });
+
+    test('array 类型缺少 properties 应该抛出错误', () => {
+      assert.throws(
+        () => validateExpressSchema({ type: 'array' } as AnySchema),
+        /Invalid schema/,
+      );
+    });
+
+    describe('元组 properties 验证', () => {
+      test('元组长度必须为 2', () => {
+        assert.throws(
+          () => validateExpressSchema({
+            type: 'array',
+            properties: ['items'],
+          } as AnySchema),
+          /Invalid schema/,
+        );
+
+        assert.throws(
+          () => validateExpressSchema({
+            type: 'array',
+            properties: ['items', { type: 'string' }, 'extra'],
+          } as AnySchema),
+          /Invalid schema/,
+        );
+      });
+
+      test('元组第一项必须是 string', () => {
+        assert.throws(
+          () => validateExpressSchema({
+            type: 'array',
+            properties: [123, { type: 'string' }],
+          } as AnySchema),
+          /Invalid schema/,
+        );
+      });
+
+      test('元组第二项必须是 object', () => {
+        assert.throws(
+          () => validateExpressSchema({
+            type: 'array',
+            properties: ['items', 'invalid'],
+          } as AnySchema),
+          /Invalid schema/,
+        );
+
+        assert.throws(
+          () => validateExpressSchema({
+            type: 'array',
+            properties: ['items', []],
+          } as AnySchema),
+          /Invalid schema/,
+        );
+      });
+    });
+  });
+
+  describe('无效输入验证', () => {
+    const invalidInputs = [
+      { input: [], description: '空数组' },
+      { input: 'number', description: '字符串' },
+      { input: 'integer', description: '字符串 integer' },
+      { input: {}, description: '空对象' },
+      { input: { type: 'xxx' }, description: '无效的 type' },
+      { input: { type: 'json' }, description: '不支持的 type: json' },
+      { input: { type: null }, description: 'type 为 null' },
+      { input: { type: undefined }, description: 'type 为 undefined' },
+    ];
+
+    invalidInputs.forEach(({ input, description }) => {
+      test(`${description}应该抛出错误`, () => {
+        assert.throws(
+          () => validateExpressSchema(input as AnySchema),
+          /Invalid schema/,
+        );
+      });
+    });
+  });
+
+  describe('可选的 resolve 函数', () => {
+    const typesWithResolve = [
+      { type: 'string', properties: undefined },
+      { type: 'object', properties: { name: { type: 'string' } } },
+      { type: 'array', properties: ['items', { type: 'number' }] },
+    ];
+
+    typesWithResolve.forEach(schema => {
+      test(`${schema.type} 类型应该允许包含 resolve 函数`, () => {
+        assert.doesNotThrow(() => {
+          validateExpressSchema({
+            ...schema,
+            resolve: (value: unknown) => value,
+          } as AnySchema);
+        });
+      });
+    });
+  });
+
+  describe('复杂嵌套场景', () => {
+    test('应该通过嵌套对象验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'object',
+          properties: {
+            user: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                age: { type: 'number' },
+                address: {
+                  type: 'object',
+                  properties: {
+                    city: { type: 'string' },
+                    zipCode: { type: 'integer' },
+                  },
+                },
+              },
+            },
+          },
+        });
+      });
+    });
+
+    test('应该通过嵌套数组验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'array',
+          properties: {
+            items: {
+              type: 'array',
+              properties: ['item', { type: 'string' }],
+            },
+          },
+        });
+      });
+    });
+
+    test('应该通过混合嵌套验证', () => {
+      assert.doesNotThrow(() => {
+        validateExpressSchema({
+          type: 'object',
+          properties: {
+            users: {
+              type: 'array',
+              properties: {
+                user: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string' },
+                    tags: {
+                      type: 'array',
+                      properties: ['tag', { type: 'string' }],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        });
+      });
+    });
+  });
+
+  describe('错误消息验证', () => {
+    test('错误消息应该包含无效的 schema 信息', () => {
+      try {
+        validateExpressSchema({ type: 'invalid' } as AnySchema);
+        assert.fail('应该抛出错误');
+      } catch (error: unknown) {
+        assert.match((error as Error).message, /Invalid schema/);
+        assert.match((error as Error).message, /invalid/);
+      }
+    });
+
+    test('错误消息应该包含验证错误详情', () => {
+      try {
+        validateExpressSchema({ type: 'object' } as AnySchema);
+        assert.fail('应该抛出错误');
+      } catch (error: unknown) {
+        assert.match((error as Error).message, /Validation errors/);
+      }
+    });
+  });
+});

package/src/validateExpressSchema.ts

@@ -0,0 +1,62 @@
+import Ajv from 'ajv';
+
+export interface ExpressSchema {
+  type: 'string' | 'number' | 'boolean' | 'integer' | 'object' | 'array';
+  properties?: Record<string, unknown> | [string, object];
+  resolve?: (value: unknown, root: unknown) => unknown;
+}
+
+const ajv = new Ajv.default();
+
+const schemaValidationRules = {
+  type: 'object',
+  anyOf: [
+    // 对象类型规则
+    {
+      properties: {
+        type: { enum: ['object'] },
+        properties: { type: 'object' },
+      },
+      required: ['type', 'properties'],
+    },
+    // 数组类型规则
+    {
+      properties: {
+        type: { enum: ['array'] },
+        properties: {
+          anyOf: [
+            { type: 'object' },
+            {
+              type: 'array',
+              items: [
+                { type: 'string' },
+                { type: 'object' },
+              ],
+              additionalItems: false,
+              minItems: 2,
+              maxItems: 2,
+            },
+          ],
+        },
+      },
+      required: ['type', 'properties'],
+    },
+    // 基础类型规则
+    {
+      properties: {
+        type: { enum: ['string', 'number', 'boolean', 'integer'] },
+      },
+      required: ['type'],
+    },
+  ],
+};
+
+const validateSchema = ajv.compile(schemaValidationRules);
+
+export function validateExpressSchema(schema: ExpressSchema): void {
+  if (!validateSchema(schema)) {
+    const schemaStr = JSON.stringify(schema);
+    const errorsStr = JSON.stringify(validateSchema.errors);
+    throw new Error(`Invalid schema: ${schemaStr}. Validation errors: ${errorsStr}`);
+  }
+}

package/.editorconfig

@@ -1,13 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-max_line_length = 100
-
-[*.md]
-trim_trailing_whitespace = false

package/eslint.config.mjs

@@ -1,40 +0,0 @@
-import js from '@eslint/js';
-import globals from 'globals';
-
-export default [
-  {
-    ignores: [
-      '_resources/*',
-      'static/*',
-      'node_modules/*',
-    ],
-  },
-  js.configs.recommended,
-  {
-    files: [
-      'src/**/*.mjs',
-      '_index.mjs',
-      'scripts/**/*.mjs',
-      'eslint.config.mjs',
-    ],
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-      globals: {
-        ...globals.node,
-      },
-    },
-    rules: {
-      'no-console': 0,
-      'max-len': 0,
-      'no-continue': 0,
-      'no-bitwise': 0,
-      'no-mixed-operators': 0,
-      'no-underscore-dangle': 0,
-      'import/prefer-default-export': 0,
-      'class-methods-use-this': 0,
-      'no-plusplus': 0,
-      'global-require': 0,
-    },
-  },
-];

package/src/checkout.mjs

@@ -1,134 +0,0 @@
-import _ from 'lodash';
-
-const DATA_TYPE_NUMBER = 'number';
-const DATA_TYPE_STRING = 'string';
-const DATA_TYPE_BOOLEAN = 'boolean';
-const DATA_TYPE_JSON = 'json';
-const DATA_TYPE_ARRAY = 'array';
-const DATA_TYPE_OBJECT = 'object';
-const DATA_TYPE_INTEGER = 'integer';
-
-const map = {
-  [DATA_TYPE_STRING]: (v) => {
-    if (typeof v !== 'string') {
-      return v.toString ? `${v.toString()}` : JSON.stringify(v);
-    }
-    return v;
-  },
-  [DATA_TYPE_INTEGER]: (v) => {
-    if (Number.isNaN(v)) {
-      return v;
-    }
-    if (v === '') {
-      return null;
-    }
-    const type = typeof v;
-    if (type !== 'number' && type !== 'string') {
-      return null;
-    }
-    const number = Number(v);
-    if (Number.isNaN(number)) {
-      return null;
-    }
-    if (`${number}` !== `${v}`) {
-      return null;
-    }
-    return parseInt(number, 10);
-  },
-  [DATA_TYPE_NUMBER]: (v) => {
-    if (v === '') {
-      return null;
-    }
-    const number = Number(v);
-    if (Number.isNaN(number)) {
-      return null;
-    }
-    if (`${number}` !== `${v}`) {
-      return null;
-    }
-    return number;
-  },
-  [DATA_TYPE_BOOLEAN]: (v) => {
-    if (v !== 'false' && v !== 'true') {
-      return null;
-    }
-    return v === 'true';
-  },
-  [DATA_TYPE_JSON]: (v) => {
-    try {
-      return JSON.parse(v);
-    } catch (error) { // eslint-disable-line
-      return null;
-    }
-  },
-  [DATA_TYPE_OBJECT]: (v) => {
-    try {
-      const d = JSON.parse(v);
-      if (Array.isArray(d)) {
-        return null;
-      }
-      if (typeof d !== 'object') {
-        return null;
-      }
-      return d;
-    } catch (error) { // eslint-disable-line
-      return null;
-    }
-  },
-  [DATA_TYPE_ARRAY]: (v) => {
-    try {
-      const d = JSON.parse(v);
-      if (Array.isArray(d)) {
-        return d;
-      }
-      return [];
-    } catch (error) { // eslint-disable-line
-      return [];
-    }
-  },
-};
-
-const typeNameMap = {
-  [DATA_TYPE_NUMBER]: 'number',
-  [DATA_TYPE_STRING]: 'string',
-  [DATA_TYPE_INTEGER]: 'integer',
-  [DATA_TYPE_BOOLEAN]: 'boolean',
-  [DATA_TYPE_JSON]: 'object',
-  [DATA_TYPE_ARRAY]: 'object',
-  [DATA_TYPE_OBJECT]: 'object',
-};
-
-export default (value, type) => {
-  if (type == null) {
-    throw new Error('data type is empty');
-  }
-  if (!Object.hasOwnProperty.call(map, type)) {
-    throw new Error(`\`${type}\` invalid data type`);
-  }
-  if (value == null) {
-    if (type === 'array') {
-      return [];
-    }
-    return null;
-  }
-  const valueType = typeof value;
-  if (valueType !== 'string') {
-    if (type === DATA_TYPE_INTEGER) {
-      return map[DATA_TYPE_INTEGER](value);
-    }
-    if (type === DATA_TYPE_STRING) {
-      return map[DATA_TYPE_STRING](value);
-    }
-    if (valueType === typeNameMap[type]) {
-      if (type === DATA_TYPE_ARRAY) {
-        return Array.isArray(value) ? value : [];
-      }
-      if (type === DATA_TYPE_OBJECT) {
-        return _.isPlainObject(value) ? value : null;
-      }
-      return value;
-    }
-    return type === DATA_TYPE_ARRAY ? [] : null;
-  }
-  return map[type](value);
-};

package/src/checkout.test.mjs

@@ -1,143 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert';
-import checkout from './checkout.mjs';
-
-test('checkout invalid data type', () => {
-  assert.throws(() => {
-    checkout('aaa', 'bbb');
-  });
-  assert.throws(() => {
-    checkout('aaa');
-  });
-});
-
-test('checkout with data value null', () => {
-  assert.deepEqual(checkout(null, 'array'), []);
-  assert.equal(checkout(null, 'object'), null);
-  assert.equal(checkout(null, 'string'), null);
-  assert.equal(checkout(null, 'number'), null);
-  assert.equal(checkout(null, 'integer'), null);
-  assert.equal(checkout(null, 'boolean'), null);
-  assert.equal(checkout(null, 'json'), null);
-});
-
-test('checkout with string', () => {
-  assert.equal(checkout(1, 'string'), '1');
-  assert.equal(checkout(null, 'string'), null);
-  assert.equal(checkout(true, 'string'), 'true');
-  assert.equal(checkout(false, 'string'), 'false');
-  assert.equal(checkout(' 1', 'string'), ' 1');
-  assert.equal(checkout([1, 2, 3], 'string'), '1,2,3');
-  assert.equal(checkout({ name: 'cqq' }, 'string'), '[object Object]');
-  assert.equal(checkout({
-    name: 'quan',
-    toString: () => 'cqq',
-  }, 'string'), 'cqq');
-});
-
-test('checkout with integer', () => {
-  assert.equal(checkout(null, 'integer'), null);
-  assert.equal(checkout('', 'integer'), null);
-  assert.equal(checkout(true, 'integer'), null);
-  assert.equal(checkout(false, 'integer'), null);
-  assert.equal(checkout([], 'integer'), null);
-  assert.equal(checkout({}, 'integer'), null);
-  assert.equal(checkout('aaa', 'integer'), null);
-  assert.equal(checkout('1', 'integer'), 1);
-  assert.equal(checkout('01', 'integer'), null);
-  assert.equal(checkout(' 1', 'integer'), null);
-  assert.equal(checkout('1.1', 'integer'), 1);
-  assert.equal(checkout('-3.1', 'integer'), -3);
-  assert.equal(checkout(3.1, 'integer'), 3);
-  assert.equal(checkout(1, 'integer'), 1);
-  assert(Number.isNaN(checkout(NaN, 'integer')));
-});
-
-test('checkout with number', () => {
-  assert.equal(checkout('1', 'number'), 1);
-  assert.equal(checkout('01', 'number'), null);
-  assert.equal(checkout(true, 'number'), null);
-  assert.equal(checkout(false, 'number'), null);
-  assert.equal(checkout([], 'number'), null);
-  assert.equal(checkout({}, 'number'), null);
-  assert.equal(checkout('', 'number'), null);
-  assert.equal(checkout('a', 'number'), null);
-  assert.equal(checkout('1a', 'number'), null);
-  assert.equal(checkout('0', 'number'), 0);
-  assert.equal(checkout('-0', 'number'), null);
-  assert.equal(checkout('-1', 'number'), -1);
-  assert.equal(checkout('-1.5', 'number'), -1.5);
-  assert.equal(checkout('-2.5', 'number'), -2.5);
-  assert.equal(checkout('2.5', 'number'), 2.5);
-  assert.equal(checkout('2.5a', 'number'), null);
-  assert.equal(checkout('2.5.', 'number'), null);
-  assert.equal(checkout('2.5.8', 'number'), null);
-  assert.equal(checkout(1, 'number'), 1);
-  assert(Number.isNaN(checkout(NaN, 'number')));
-});
-
-test('checkout with boolean', () => {
-  assert.equal(checkout('', 'boolean'), null);
-  assert.equal(checkout('false', 'boolean'), false);
-  assert.equal(checkout(' false', 'boolean'), null);
-  assert.equal(checkout('false ', 'boolean'), null);
-  assert.equal(checkout('true', 'boolean'), true);
-  assert.equal(checkout(' true', 'boolean'), null);
-  assert.equal(checkout('true ', 'boolean'), null);
-  assert.equal(checkout(true, 'boolean'), true);
-  assert.equal(checkout(false, 'boolean'), false);
-  assert.equal(checkout(1, 'boolean'), null);
-  assert.equal(checkout({}, 'boolean'), null);
-  assert.equal(checkout([], 'boolean'), null);
-  assert.equal(checkout('aaa', 'boolean'), null);
-});
-
-test('checkout with json', () => {
-  assert.equal(checkout('1', 'json'), 1);
-  assert.equal(checkout(' 1', 'json'), 1);
-  assert.equal(checkout('"1"', 'json'), '1');
-  assert.equal(checkout('\'1\'', 'json'), null);
-  assert.equal(checkout('null', 'json'), null);
-  assert.equal(checkout('aa', 'json'), null);
-  assert.deepEqual(checkout('{}', 'json'), {});
-  assert.deepEqual(checkout('{fail}', 'json'), null);
-  assert.deepEqual(checkout('{"name":"cqq"}', 'json'), { name: 'cqq' });
-  assert.deepEqual(checkout('[]', 'json'), []);
-  assert.deepEqual(checkout([], 'json'), []);
-  assert.deepEqual(checkout({}, 'json'), {});
-  assert.deepEqual(checkout(2, 'json'), null);
-});
-
-test('checkout with array', () => {
-  assert.deepEqual(checkout(null, 'array'), []);
-  assert.deepEqual(checkout('[]', 'array'), []);
-  assert.deepEqual(checkout('[xxx]', 'array'), []);
-  assert.deepEqual(checkout([], 'array'), []);
-  assert.deepEqual(checkout([1, 2, 3], 'array'), [1, 2, 3]);
-  assert.deepEqual(checkout(1, 'array'), []);
-  assert.deepEqual(checkout({}, 'array'), []);
-  assert.deepEqual(checkout('1', 'array'), []);
-  assert.deepEqual(checkout('{}', 'array'), []);
-  assert.deepEqual(checkout(['12345'], 'array'), ['12345']);
-  assert.deepEqual(checkout(true, 'array'), []);
-  assert.deepEqual(checkout(false, 'array'), []);
-  assert.deepEqual(checkout([{ name: 'cqq' }], 'array'), [{ name: 'cqq' }]);
-  assert.deepEqual(checkout(JSON.stringify([{ name: 'cqq' }]), 'array'), [{ name: 'cqq' }]);
-});
-
-test('checkout with object', () => {
-  assert.equal(checkout(null, 'object'), null);
-  assert.equal(checkout(1, 'object'), null);
-  assert.equal(checkout('aa', 'object'), null);
-  assert.equal(checkout('1', 'object'), null);
-  assert.equal(checkout(JSON.stringify('aa'), 'object'), null);
-  assert.equal(checkout(true, 'object'), null);
-  assert.equal(checkout('true', 'object'), null);
-  assert.equal(checkout('false', 'object'), null);
-  assert.equal(checkout(false, 'object'), null);
-  assert.equal(checkout([], 'object'), null);
-  assert.equal(checkout(JSON.stringify([]), 'object'), null);
-  assert.deepEqual(checkout({ name: 'cqq' }, 'object'), { name: 'cqq' });
-  assert.deepEqual(checkout(JSON.stringify({ name: 'cqq' }), 'object'), { name: 'cqq' });
-  assert.deepEqual(checkout('{fail}', 'object'), null);
-});

package/src/index.mjs

@@ -1,7 +0,0 @@
-import checkout from './checkout.mjs';
-import select from './select/index.mjs';
-
-export {
-  select,
-  checkout,
-};