@jolibox/implement 1.1.4-beta.10

package/src/common/api-factory/validator/__tests__/validate/record.test.ts

@@ -0,0 +1,274 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts } from '../../index';
+
+describe('record', () => {
+  it('string record', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string());
+    expect(schema.validate({ value: 'str' })).toBe(true);
+    expect(() => typeAsserts(schema, { value: 'str' })).not.toThrow();
+
+    expect(schema.validate(123)).toBe(false);
+    expect(() => typeAsserts(schema, 123)).toThrow('param should be object, but got 123');
+
+    expect(schema.validate({ value: 123 })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 123 })).toThrow('param.value should be string, but got 123');
+
+    expect(schema.validate({ value: true })).toBe(false);
+    expect(() => typeAsserts(schema, { value: true })).toThrow(`param.value should be string, but got true`);
+
+    expect(schema.validate({ value: false })).toBe(false);
+    expect(() => typeAsserts(schema, { value: false })).toThrow(
+      `param.value should be string, but got false`
+    );
+
+    expect(schema.validate({ value: Symbol.for('mocked') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: Symbol.for('mocked') })).toThrow(
+      `param.value should be string, but got a(n) symbol`
+    );
+
+    expect(schema.validate({ value: BigInt('123') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: BigInt('123') })).toThrow(
+      `param.value should be string, but got a(n) bigint`
+    );
+
+    expect(schema.validate({ value: null })).toBe(false);
+    expect(() => typeAsserts(schema, { value: null })).toThrow(`param.value should be string, but got null`);
+
+    expect(schema.validate({ value: undefined })).toBe(false);
+    expect(() => typeAsserts(schema, { value: undefined })).toThrow(
+      `param.value should be string, but got undefined`
+    );
+
+    expect(schema.validate({ value: () => {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: () => {} })).toThrow(
+      `param.value should be string, but got a(n) function`
+    );
+
+    expect(schema.validate({ value: [] })).toBe(false);
+    expect(() => typeAsserts(schema, { value: [] })).toThrow(
+      `param.value should be string, but got a(n) array`
+    );
+
+    expect(schema.validate({ value: {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: {} })).toThrow(
+      `param.value should be string, but got a(n) object`
+    );
+  });
+
+  it('number record', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.number());
+
+    // valid
+    expect(schema.validate({ value: 123 })).toBe(true);
+    expect(() => typeAsserts(schema, { value: 123 })).not.toThrow();
+
+    // invalid
+
+    expect(schema.validate({ value: 'str' })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 'str' })).toThrow(
+      'param.value should be number, but got "str"'
+    );
+
+    expect(schema.validate({ value: true })).toBe(false);
+    expect(() => typeAsserts(schema, { value: true })).toThrow('param.value should be number, but got true');
+
+    expect(schema.validate({ value: false })).toBe(false);
+    expect(() => typeAsserts(schema, { value: false })).toThrow(
+      `param.value should be number, but got false`
+    );
+
+    expect(schema.validate({ value: Symbol.for('mocked') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: Symbol.for('mocked') })).toThrow(
+      `param.value should be number, but got a(n) symbol`
+    );
+
+    expect(schema.validate({ value: BigInt('123') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: BigInt('123') })).toThrow(
+      `param.value should be number, but got a(n) bigint`
+    );
+
+    expect(schema.validate({ value: null })).toBe(false);
+    expect(() => typeAsserts(schema, { value: null })).toThrow(`param.value should be number, but got null`);
+
+    expect(schema.validate({ value: undefined })).toBe(false);
+    expect(() => typeAsserts(schema, { value: undefined })).toThrow(
+      `param.value should be number, but got undefined`
+    );
+
+    expect(schema.validate({ value: () => {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: () => {} })).toThrow(
+      `param.value should be number, but got a(n) function`
+    );
+
+    expect(schema.validate({ value: [] })).toBe(false);
+    expect(() => typeAsserts(schema, { value: [] })).toThrow(
+      `param.value should be number, but got a(n) array`
+    );
+
+    expect(schema.validate({ value: {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: {} })).toThrow(
+      `param.value should be number, but got a(n) object`
+    );
+  });
+
+  it('boolean record', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.boolean());
+
+    // valid
+
+    expect(schema.validate({ value: true })).toBe(true);
+    expect(() => typeAsserts(schema, { value: true })).not.toThrow();
+
+    expect(schema.validate({ value: false })).toBe(true);
+    expect(() => typeAsserts(schema, { value: false })).not.toThrow();
+
+    // invalid
+
+    expect(schema.validate({ value: 123 })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 123 })).toThrow('param.value should be boolean, but got 123');
+
+    expect(schema.validate({ value: 'str' })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 'str' })).toThrow(
+      'param.value should be boolean, but got "str"'
+    );
+
+    expect(schema.validate({ value: Symbol.for('mocked') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: Symbol.for('mocked') })).toThrow(
+      `param.value should be boolean, but got a(n) symbol`
+    );
+
+    expect(schema.validate({ value: BigInt('123') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: BigInt('123') })).toThrow(
+      `param.value should be boolean, but got a(n) bigint`
+    );
+
+    expect(schema.validate({ value: null })).toBe(false);
+    expect(() => typeAsserts(schema, { value: null })).toThrow(`param.value should be boolean, but got null`);
+
+    expect(schema.validate({ value: undefined })).toBe(false);
+    expect(() => typeAsserts(schema, { value: undefined })).toThrow(
+      `param.value should be boolean, but got undefined`
+    );
+
+    expect(schema.validate({ value: () => {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: () => {} })).toThrow(
+      `param.value should be boolean, but got a(n) function`
+    );
+
+    expect(schema.validate({ value: [] })).toBe(false);
+    expect(() => typeAsserts(schema, { value: [] })).toThrow(
+      `param.value should be boolean, but got a(n) array`
+    );
+
+    expect(schema.validate({ value: {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: {} })).toThrow(
+      `param.value should be boolean, but got a(n) object`
+    );
+  });
+
+  it('symbol record', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.symbol());
+
+    expect(schema.validate({ value: Symbol.for('mocked') })).toBe(true);
+    expect(() => typeAsserts(schema, { value: Symbol.for('mocked') })).not.toThrow();
+
+    expect(schema.validate({ value: true })).toBe(false);
+    expect(() => typeAsserts(schema, { value: true })).toThrow('param.value should be symbol, but got true');
+
+    expect(schema.validate({ value: false })).toBe(false);
+    expect(() => typeAsserts(schema, { value: false })).toThrow(
+      'param.value should be symbol, but got false'
+    );
+
+    expect(schema.validate({ value: 123 })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 123 })).toThrow('param.value should be symbol, but got 123');
+
+    expect(schema.validate({ value: 'str' })).toBe(false);
+    expect(() => typeAsserts(schema, { value: 'str' })).toThrow(
+      'param.value should be symbol, but got "str"'
+    );
+
+    expect(schema.validate({ value: BigInt('123') })).toBe(false);
+    expect(() => typeAsserts(schema, { value: BigInt('123') })).toThrow(
+      `param.value should be symbol, but got a(n) bigint`
+    );
+
+    expect(schema.validate({ value: null })).toBe(false);
+    expect(() => typeAsserts(schema, { value: null })).toThrow(`param.value should be symbol, but got null`);
+
+    expect(schema.validate({ value: undefined })).toBe(false);
+    expect(() => typeAsserts(schema, { value: undefined })).toThrow(
+      `param.value should be symbol, but got undefined`
+    );
+
+    expect(schema.validate({ value: () => {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: () => {} })).toThrow(
+      `param.value should be symbol, but got a(n) function`
+    );
+
+    expect(schema.validate({ value: [] })).toBe(false);
+    expect(() => typeAsserts(schema, { value: [] })).toThrow(
+      `param.value should be symbol, but got a(n) array`
+    );
+
+    expect(schema.validate({ value: {} })).toBe(false);
+    expect(() => typeAsserts(schema, { value: {} })).toThrow(
+      `param.value should be symbol, but got a(n) object`
+    );
+  });
+
+  it('special key', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string());
+
+    expect(() => {
+      typeAsserts(schema, {
+        '@@': 1
+      });
+    }).toThrow('param["@@"] should be string, but got 1');
+
+    expect(() => {
+      typeAsserts(schema, { '-a': 1 });
+    }).toThrow('param["-a"] should be string, but got 1');
+
+    expect(() => {
+      typeAsserts(schema, { 'a b': 1 });
+    }).toThrow('param["a b"] should be string, but got 1');
+  });
+
+  it('optional', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string()).optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+
+  it('item optional', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string().optional());
+    const data = { a: undefined };
+    expect(schema.validate(data)).toBe(true);
+  });
+
+  it('item default', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string().default('str'));
+    const data = { a: undefined };
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual({ a: 'str' });
+  });
+
+  it('item fallback', () => {
+    expect.hasAssertions();
+    const schema = t.record(t.string().fallback('str'));
+    const data = { a: 111 };
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual({ a: 'str' });
+  });
+});

package/src/common/api-factory/validator/__tests__/validate/string.test.ts

@@ -0,0 +1,187 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts } from '../../index';
+
+describe('string', () => {
+  it('string', () => {
+    expect.hasAssertions();
+    const schema = t.string();
+    expect(schema.validate('str')).toBe(true);
+    expect(() => typeAsserts(schema, 'str')).not.toThrow();
+
+    expect(schema.validate(1)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).toThrow('param should be string, but got 1');
+
+    expect(schema.validate(Symbol.for('1'))).toBe(false);
+    expect(() => {
+      typeAsserts(schema, Symbol.for('1'));
+    }).toThrow('param should be string, but got a(n) symbol');
+
+    expect(schema.validate(null)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, null);
+    }).toThrow('param should be string, but got null');
+
+    expect(schema.validate(undefined)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).toThrow('param should be string, but got undefined');
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).toThrow('param should be string, but got a(n) object');
+
+    expect(schema.validate([])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, []);
+    }).toThrow('param should be string, but got a(n) array');
+
+    expect(schema.validate(() => {})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, () => {});
+    }).toThrow('param should be string, but got a(n) function');
+
+    expect(schema.validate(BigInt(1))).toBe(false);
+    expect(() => {
+      typeAsserts(schema, BigInt(1));
+    }).toThrow('param should be string, but got a(n) bigint');
+  });
+
+  it('optional string', () => {
+    expect.hasAssertions();
+    const schema = t.string().optional();
+    expect(schema.validate('str')).toBe(true);
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => typeAsserts(schema, 'str')).not.toThrow();
+    expect(() => typeAsserts(schema, undefined)).not.toThrow();
+
+    expect(schema.validate(1)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).toThrow('param should be string or undefined, but got 1');
+
+    expect(schema.validate(Symbol(1))).toBe(false);
+    expect(() => {
+      typeAsserts(schema, Symbol(1));
+    }).toThrow('param should be string or undefined, but got a(n) symbol');
+
+    expect(schema.validate(null)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, null);
+    }).toThrow('param should be string or undefined, but got null');
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).toThrow('param should be string or undefined, but got a(n) object');
+
+    expect(schema.validate(() => {})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, () => {});
+    }).toThrow('param should be string or undefined, but got a(n) function');
+
+    expect(schema.validate(BigInt(1))).toBe(false);
+    expect(() => {
+      typeAsserts(schema, BigInt(1));
+    }).toThrow('param should be string or undefined, but got a(n) bigint');
+  });
+
+  describe('string pattern', () => {
+    it('string params', () => {
+      expect.hasAssertions();
+      const abc = t.string().pattern('abc');
+      expect(abc.validate('abc')).toBe(true);
+      expect(abc.validate('abd')).toBe(false);
+
+      const wss = t.string().pattern('^wss?://');
+      expect(wss.validate('wss://echo.socket.com/abc')).toBe(true);
+      expect(wss.validate('ws://echo.socket.com/abc')).toBe(true);
+
+      expect(wss.validate('wws://echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('wss:echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('http://echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('https://echo.socket.com/abc')).toBe(false);
+
+      expect(() => {
+        typeAsserts(wss, 'xxx');
+      }).toThrow(`param should match pattern "^wss?://"`);
+    });
+
+    it('string params2', () => {
+      expect.hasAssertions();
+      const abc = t.string().pattern(/abc/);
+      expect(abc.validate('abc')).toBe(true);
+      expect(abc.validate('abd')).toBe(false);
+
+      const wss = t.string().pattern(/^wss?:\/\//);
+      expect(wss.validate('wss://echo.socket.com/abc')).toBe(true);
+      expect(wss.validate('ws://echo.socket.com/abc')).toBe(true);
+
+      expect(wss.validate('wws://echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('wss:echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('http://echo.socket.com/abc')).toBe(false);
+      expect(wss.validate('https://echo.socket.com/abc')).toBe(false);
+
+      expect(() => {
+        typeAsserts(wss, 'xxx');
+      }).toThrow(`param should match pattern "/^wss?:\\/\\//"`);
+    });
+  });
+
+  it('minLength', () => {
+    expect.hasAssertions();
+    const schema = t.string().minLength(3);
+
+    expect(schema.validate('123')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, '123');
+    }).not.toThrow();
+
+    expect(schema.validate('1234')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, '1234');
+    }).not.toThrow();
+
+    expect(schema.validate('')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, '');
+    }).toThrow('the length of param should be greater than or equal to 3');
+
+    expect(schema.validate('12')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, '12');
+    }).toThrow('the length of param should be greater than or equal to 3');
+  });
+
+  it('maxLength', () => {
+    expect.hasAssertions();
+    const schema = t.string().maxLength(3);
+
+    expect(schema.validate('')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, '');
+    }).not.toThrow();
+
+    expect(schema.validate('12')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, '12');
+    }).not.toThrow();
+
+    expect(schema.validate('123')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, '123');
+    }).not.toThrow();
+
+    expect(schema.validate('1234')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, '1234');
+    }).toThrow('the length of param should be less than or equal to 3');
+
+    expect(schema.validate('12345')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, '12345');
+    }).toThrow('the length of param should be less than or equal to 3');
+  });
+});

package/src/common/api-factory/validator/__tests__/validate/symbol.test.ts

@@ -0,0 +1,23 @@
+import { t, typeAsserts } from '../../index';
+
+describe('symbol', () => {
+  it('null', () => {
+    expect.hasAssertions();
+    const schema = t.symbol();
+
+    expect(schema.validate(Symbol.for('mocked'))).toBe(true);
+    expect(() => {
+      typeAsserts(schema, Symbol.for('mocked'));
+    }).not.toThrow();
+  });
+
+  it('symbol optional', () => {
+    expect.hasAssertions();
+
+    const schema = t.symbol().optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+});

package/src/common/api-factory/validator/__tests__/validate/tuple.test.ts

@@ -0,0 +1,86 @@
+import { t, typeAsserts } from '../../index';
+
+describe('tuple', () => {
+  it('tuple', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string(), t.number(), t.object());
+
+    expect(schema.validate([123, 123, 123])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [123, 123, 123]);
+    }).toThrow('param[0] should be string, but got 123\nparam[2] should be object, but got 123');
+  });
+
+  it('optional tuple', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string(), t.number(), t.object()).optional();
+    expect(schema.validate(undefined)).toBe(true);
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).toThrow('param should be array or undefined, but got a(n) object');
+  });
+
+  it('tuple fixed length', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string(), t.number(), t.object());
+
+    expect(schema.validate(['str', 123, {}])).toBe(true);
+
+    expect(schema.validate(['str', 123])).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, ['str', 123]);
+    }).toThrow('the length of param should be greater than or equal to 3');
+  });
+
+  it('optional length', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string(), t.number(), t.object().optional());
+
+    expect(schema.validate(['str', 123, {}])).toBe(true);
+
+    expect(schema.validate(['str', 123])).toBe(true);
+
+    expect(schema.validate(['str'])).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, ['str']);
+    }).toThrow('the length of param should be greater than or equal to 2');
+  });
+
+  it('optional length should ignore optional items before item without optional', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string().optional(), t.number(), t.object().optional());
+
+    expect(schema.validate(['str', 123, {}])).toBe(true);
+
+    expect(schema.validate(['str', 123])).toBe(true);
+
+    expect(schema.validate(['str'])).toBe(false);
+
+    expect(schema.validate([])).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, ['str']);
+    }).toThrow('the length of param should be greater than or equal to 2');
+  });
+
+  it('fallback', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string().fallback('str'));
+    const data = [123];
+
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual(['str']);
+  });
+
+  it('default', () => {
+    expect.hasAssertions();
+    const schema = t.tuple(t.string().default('str'));
+    const data: unknown[] = [];
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual(['str']);
+  });
+});

package/src/common/api-factory/validator/__tests__/validate/type-asserts.test.ts

@@ -0,0 +1,13 @@
+import { t, typeAsserts } from '../../index';
+
+describe('typeAsserts', () => {
+  it('custom Key', () => {
+    expect.hasAssertions();
+
+    const schema = t.number();
+
+    expect(() => {
+      typeAsserts(schema, '123', 'CUSTOM_KEY');
+    }).toThrow('CUSTOM_KEY should be number, but got "123"');
+  });
+});

package/src/common/api-factory/validator/__tests__/validate/utils.test.ts

@@ -0,0 +1,44 @@
+/* eslint-disable no-empty-function */
+import { echo, getType } from '../../validate';
+
+describe('validate utils', () => {
+  it('getType', () => {
+    expect.hasAssertions();
+    expect(getType(undefined)).toBe('undefined');
+    expect(getType(null)).toBe('null');
+    expect(getType(Symbol.for(''))).toBe('symbol');
+
+    expect(getType(1)).toBe('number');
+    expect(getType(BigInt('11111'))).toBe('bigint');
+
+    expect(getType('str')).toBe('string');
+    expect(getType({})).toBe('object');
+    expect(getType([])).toBe('array');
+
+    expect(getType(() => {})).toBe('function');
+    expect(getType(async () => {})).toBe('function');
+    expect(getType(function* () {})).toBe('function');
+
+    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+    expect(getType(class {})).toBe('function');
+  });
+
+  it('echo has a(n)', () => {
+    expect.hasAssertions();
+    expect(echo({})).toBe(`a(n) object`);
+    expect(echo([])).toBe(`a(n) array`);
+    expect(echo(BigInt('123'))).toBe('a(n) bigint');
+    expect(echo(() => {})).toBe(`a(n) function`);
+    expect(echo(Symbol.for('abc'))).toBe(`a(n) symbol`);
+  });
+
+  it('echo no a(n)', () => {
+    expect.hasAssertions();
+    expect(echo('1')).toBe(`"1"`);
+    expect(echo(1)).toBe(`1`);
+    expect(echo(null)).toBe(`null`);
+    expect(echo(undefined)).toBe(`undefined`);
+    expect(echo(true)).toBe('true');
+    expect(echo(false)).toBe('false');
+  });
+});