@quanxiaoxiao/datav 0.4.0 → 0.5.1

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,59 @@
+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();
+
+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,89 +0,0 @@
-import js from '@eslint/js';
-import simpleImportSort from 'eslint-plugin-simple-import-sort';
-import globals from 'globals';
-
-export default [
-  {
-    ignores: [
-      'node_modules/*',
-    ],
-  },
-  js.configs.recommended,
-  {
-    plugins: {
-      'simple-import-sort': simpleImportSort,
-    },
-    files: [
-      'src/**/*.mjs',
-      '_index.mjs',
-      'scripts/**/*.mjs',
-      'eslint.config.mjs',
-    ],
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-      globals: {
-        ...globals.node,
-      },
-    },
-    rules: {
-      'simple-import-sort/imports': 'error',
-      'simple-import-sort/exports': 'error',
-      'no-duplicate-imports': 2,
-      'array-callback-return': 2,
-      'prefer-const': 2,
-      'no-multi-spaces': 2,
-      eqeqeq: ['error', 'always', { null: 'ignore' }],
-      'block-scoped-var': 2,
-      'consistent-return': 2,
-      'default-case': 2,
-      'no-shadow': 2,
-      'object-shorthand': 2,
-      'quote-props': ['error', 'as-needed'],
-      quotes: [
-        'error',
-        'single',
-      ],
-      'object-curly-newline': 2,
-      'no-multi-assign': 2,
-      'no-else-return': 2,
-      indent: [
-        'error',
-        2,
-      ],
-      'keyword-spacing': 2,
-      'no-multiple-empty-lines': ['error', { max: 1, maxEOF: 0 }],
-      'space-infix-ops': 2,
-      'eol-last': 2,
-      'space-in-parens': 2,
-      'array-bracket-spacing': 2,
-      'object-curly-spacing': ['error', 'always'],
-      'block-spacing': 2,
-      'key-spacing': 2,
-      'no-trailing-spaces': 2,
-      'comma-style': 2,
-      'no-use-before-define': 2,
-      'comma-dangle': [
-        'error',
-        {
-          arrays: 'always-multiline',
-          objects: 'always-multiline',
-          imports: 'always-multiline',
-          exports: 'always-multiline',
-          functions: 'always-multiline',
-        },
-      ],
-      semi: 2,
-      '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,131 +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) {
-    return type === DATA_TYPE_ARRAY ? [] : 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);
-};