@jolibox/implement 1.1.4-beta.10

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

@@ -0,0 +1,54 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts } from '../../index';
+
+describe('function', () => {
+  it('function', () => {
+    expect.hasAssertions();
+    const schema = t.function();
+
+    expect(schema.validate(() => {})).toBe(true);
+    expect(() => typeAsserts(schema, () => {})).not.toThrow();
+
+    expect(schema.validate(-1)).toBe(false);
+    expect(() => typeAsserts(schema, -1)).toThrow(`param should be function, but got -1`);
+
+    expect(schema.validate(+0)).toBe(false);
+    expect(() => typeAsserts(schema, +0)).toThrow(`param should be function, but got 0`);
+
+    expect(schema.validate(-0)).toBe(false);
+    expect(() => typeAsserts(schema, -0)).toThrow(`param should be function, but got 0`);
+
+    expect(schema.validate(1)).toBe(false);
+    expect(() => typeAsserts(schema, 1)).toThrow(`param should be function, but got 1`);
+
+    expect(schema.validate(NaN)).toBe(false);
+    expect(() => typeAsserts(schema, NaN)).toThrow(`param should be function, but got NaN`);
+
+    expect(schema.validate('str')).toBe(false);
+    expect(() => typeAsserts(schema, 'str')).toThrow(`param should be function, but got "str"`);
+
+    expect(schema.validate(Symbol(1))).toBe(false);
+    expect(() => typeAsserts(schema, Symbol(1))).toThrow(`param should be function, but got a(n) symbol`);
+
+    expect(schema.validate(null)).toBe(false);
+    expect(() => typeAsserts(schema, null)).toThrow(`param should be function, but got null`);
+
+    expect(schema.validate(undefined)).toBe(false);
+    expect(() => typeAsserts(schema, undefined)).toThrow(`param should be function, but got undefined`);
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => typeAsserts(schema, {})).toThrow(`param should be function, but got a(n) object`);
+
+    expect(schema.validate(BigInt(1))).toBe(false);
+    expect(() => typeAsserts(schema, BigInt(1))).toThrow(`param should be function, but got a(n) bigint`);
+  });
+
+  it('optional', () => {
+    expect.hasAssertions();
+    const schema = t.function().optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,130 @@
+import { t, typeAsserts } from '../../index';
+
+describe('literal', () => {
+  it('valid', () => {
+    expect.hasAssertions();
+    expect(t.literal(1).validate(1)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(1), 1);
+    }).not.toThrow();
+
+    expect(t.literal('str').validate('str')).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal('str'), 'str');
+    }).not.toThrow();
+
+    expect(t.literal(true).validate(true)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(true), true);
+    }).not.toThrow();
+
+    expect(t.literal(false).validate(false)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(false), false);
+    }).not.toThrow();
+
+    expect(t.literal(undefined).validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(undefined), undefined);
+    }).not.toThrow();
+
+    expect(t.literal(null).validate(null)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(null), null);
+    }).not.toThrow();
+  });
+
+  it('invalid', () => {
+    expect.hasAssertions();
+    expect(t.literal(1).validate(123)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(1), 123);
+    }).toThrow('param should be 1, but got 123');
+
+    expect(t.literal('str').validate('string')).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal('str'), 'string');
+    }).toThrow('param should be "str", but got "string"');
+
+    expect(t.literal(true).validate(false)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(true), false);
+    }).toThrow('param should be true, but got false');
+
+    expect(t.literal(false).validate(true)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(false), true);
+    }).toThrow('param should be false, but got true');
+
+    expect(t.literal(undefined).validate(null)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(undefined), null);
+    }).toThrow('param should be undefined, but got null');
+
+    expect(t.literal(null).validate(undefined)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(null), undefined);
+    }).toThrow('param should be null, but got undefined');
+  });
+
+  it('optional valid', () => {
+    expect.hasAssertions();
+    expect(t.literal(1).optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(1).optional(), undefined);
+    }).not.toThrow();
+
+    expect(t.literal(1).optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(1).optional(), undefined);
+    }).not.toThrow();
+
+    expect(t.literal('str').optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal('str').optional(), undefined);
+    }).not.toThrow();
+
+    expect(t.literal(true).optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(true).optional(), undefined);
+    }).not.toThrow();
+
+    expect(t.literal(false).optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(false).optional(), undefined);
+    }).not.toThrow();
+
+    expect(t.literal(undefined).optional().validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(t.literal(undefined).optional(), undefined);
+    }).not.toThrow();
+  });
+
+  it('optional invalid', () => {
+    expect.hasAssertions();
+    expect(t.literal(1).optional().validate(123)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(1).optional(), 123);
+    }).toThrow('param should be 1 or undefined, but got 123');
+
+    expect(t.literal('str').optional().validate(123)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal('str').optional(), 123);
+    }).toThrow('param should be "str" or undefined, but got 123');
+
+    expect(t.literal(true).optional().validate(false)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(true).optional(), false);
+    }).toThrow('param should be true or undefined, but got false');
+
+    expect(t.literal(false).optional().validate(true)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(false).optional(), true);
+    }).toThrow('param should be false or undefined, but got true');
+
+    expect(t.literal(undefined).optional().validate(123)).toBe(false);
+    expect(() => {
+      typeAsserts(t.literal(undefined).optional(), 123);
+    }).toThrow('param should be undefined, but got 123');
+  });
+});

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

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

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

@@ -0,0 +1,147 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts } from '../../index';
+
+describe('number', () => {
+  it('number', () => {
+    expect.hasAssertions();
+    const schema = t.number();
+
+    expect(schema.validate(-1)).toBe(true);
+    expect(() => typeAsserts(schema, -1)).not.toThrow();
+
+    expect(schema.validate(+0)).toBe(true);
+    expect(() => typeAsserts(schema, +0)).not.toThrow();
+
+    expect(schema.validate(-0)).toBe(true);
+    expect(() => typeAsserts(schema, -0)).not.toThrow();
+
+    expect(schema.validate(1)).toBe(true);
+    expect(() => typeAsserts(schema, 1)).not.toThrow();
+
+    expect(schema.validate(NaN)).toBe(true);
+    expect(() => typeAsserts(schema, NaN)).not.toThrow();
+
+    expect(schema.validate('str')).toBe(false);
+    expect(() => typeAsserts(schema, 'str')).toThrow(`param should be number, but got "str"`);
+
+    expect(schema.validate(Symbol(1))).toBe(false);
+    expect(() => typeAsserts(schema, Symbol(1))).toThrow(`param should be number, but got a(n) symbol`);
+
+    expect(schema.validate(null)).toBe(false);
+    expect(() => typeAsserts(schema, null)).toThrow(`param should be number, but got null`);
+
+    expect(schema.validate(undefined)).toBe(false);
+    expect(() => typeAsserts(schema, undefined)).toThrow(`param should be number, but got undefined`);
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => typeAsserts(schema, {})).toThrow(`param should be number, but got a(n) object`);
+
+    expect(schema.validate(() => {})).toBe(false);
+    expect(() => typeAsserts(schema, () => {})).toThrow(`param should be number, but got a(n) function`);
+
+    expect(schema.validate(BigInt(1))).toBe(false);
+    expect(() => typeAsserts(schema, BigInt(1))).toThrow(`param should be number, but got a(n) bigint`);
+  });
+
+  it('optional number', () => {
+    expect.hasAssertions();
+    const schema = t.number().optional();
+
+    expect(schema.validate(-1)).toBe(true);
+    expect(() => typeAsserts(schema, -1)).not.toThrow();
+
+    expect(schema.validate(+0)).toBe(true);
+    expect(() => typeAsserts(schema, +0)).not.toThrow();
+
+    expect(schema.validate(-0)).toBe(true);
+    expect(() => typeAsserts(schema, -0)).not.toThrow();
+
+    expect(schema.validate(1)).toBe(true);
+    expect(() => typeAsserts(schema, 1)).not.toThrow();
+
+    expect(schema.validate(NaN)).toBe(true);
+    expect(() => typeAsserts(schema, NaN)).not.toThrow();
+
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => typeAsserts(schema, undefined)).not.toThrow();
+
+    expect(schema.validate('str')).toBe(false);
+    expect(() => typeAsserts(schema, 'str')).toThrow(`param should be number or undefined, but got "str"`);
+
+    expect(schema.validate(Symbol(1))).toBe(false);
+    expect(() => typeAsserts(schema, Symbol(1))).toThrow(
+      `param should be number or undefined, but got a(n) symbol`
+    );
+
+    expect(schema.validate(null)).toBe(false);
+    expect(() => typeAsserts(schema, null)).toThrow(`param should be number or undefined, but got null`);
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => typeAsserts(schema, {})).toThrow(`param should be number or undefined, but got a(n) object`);
+
+    expect(schema.validate(() => {})).toBe(false);
+    expect(() => typeAsserts(schema, () => {})).toThrow(
+      `param should be number or undefined, but got a(n) function`
+    );
+
+    expect(schema.validate(BigInt(1))).toBe(false);
+    expect(() => typeAsserts(schema, BigInt(1))).toThrow(
+      `param should be number or undefined, but got a(n) bigint`
+    );
+  });
+
+  it('max', () => {
+    expect.hasAssertions();
+    const schema = t.number().max(100);
+
+    expect(schema.validate(1)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).not.toThrow();
+
+    expect(schema.validate(100)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 100);
+    }).not.toThrow();
+
+    expect(schema.validate(-101)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, -101);
+    }).not.toThrow();
+
+    expect(schema.validate(-0)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, -0);
+    }).not.toThrow();
+
+    expect(schema.validate(101)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 101);
+    }).toThrow('param should be less than or equal to 100');
+  });
+
+  it('min', () => {
+    expect.hasAssertions();
+    const schema = t.number().min(100);
+
+    expect(schema.validate(100)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 100);
+    }).not.toThrow();
+
+    expect(schema.validate(101)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 101);
+    }).not.toThrow();
+
+    expect(schema.validate(99)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 99);
+    }).toThrow();
+
+    expect(schema.validate(-99)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, -99);
+    }).toThrow('param should be greater than or equal to 100');
+  });
+});

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

@@ -0,0 +1,131 @@
+import { t, typeAsserts } from '../../index';
+
+describe('object', () => {
+  it('object first key', () => {
+    expect.hasAssertions();
+    const schema = t.object({
+      name: t.string().optional(),
+      age: t.number()
+    });
+
+    expect(
+      schema.validate({
+        // name: 'yinz', optional
+        age: 30
+      })
+    ).toBe(true);
+
+    expect(
+      schema.validate({
+        // name: 'yinz', optional
+        age: 30
+      })
+    ).toBe(true);
+
+    expect(
+      schema.validate({
+        name: 1, // error here
+        age: 30
+      })
+    ).toBe(false);
+
+    expect(() =>
+      typeAsserts(schema, {
+        name: 1, // error here
+        age: 30
+      })
+    ).toThrow('param.name should be string or undefined, but got 1');
+
+    expect(() => typeAsserts(schema, [])).toThrow('param should be object, but got a(n) array');
+  });
+
+  it('object not first key', () => {
+    expect.hasAssertions();
+    const schema = t.object({
+      name: t.string().optional(),
+      age: t.number()
+    });
+
+    expect(
+      schema.validate({
+        age: 30
+      })
+    ).toBe(true);
+
+    expect(
+      schema.validate({
+        age: '30' // error here
+      })
+    ).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, {
+        age: '30' // error here
+      });
+    }).toThrow('param.age should be number, but got "30"');
+  });
+
+  it('optional object', () => {
+    expect.hasAssertions();
+    const schema = t.object({ name: t.string(), age: t.number() }).optional();
+
+    expect(schema.validate(undefined)).toBe(true);
+
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+
+    expect(schema.validate({ name: 'yinz', age: 30 })).toBe(true);
+
+    expect(() => {
+      typeAsserts(schema, { name: 123, age: 30 });
+    }).toThrow('param.name should be string, but got 123');
+  });
+
+  it('default', () => {
+    expect.hasAssertions();
+    const schema = t.object({
+      a: t.boolean().default(true)
+    });
+    const data = {};
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual({ a: true });
+  });
+
+  it('fallback', () => {
+    expect.hasAssertions();
+    const schema = t.object({
+      a: t.boolean().fallback(true)
+    });
+    const data = { a: [] };
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual({ a: true });
+  });
+
+  it('special key', () => {
+    expect.hasAssertions();
+    const schema1 = t.object({
+      '@@': t.string()
+    });
+
+    expect(() => {
+      typeAsserts(schema1, {});
+    }).toThrow('param["@@"] should be string, but got undefined');
+
+    const schema2 = t.object({
+      '-a': t.string()
+    });
+
+    expect(() => {
+      typeAsserts(schema2, {});
+    }).toThrow('param["-a"] should be string, but got undefined');
+
+    const schema3 = t.object({
+      'a b': t.string()
+    });
+
+    expect(() => {
+      typeAsserts(schema3, {});
+    }).toThrow('param["a b"] should be string, but got undefined');
+  });
+});

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

@@ -0,0 +1,96 @@
+import { t, typeAsserts } from '../../index';
+
+describe('or', () => {
+  it('or', () => {
+    expect.hasAssertions();
+    const schema = t.or(t.string(), t.number(), t.object({ a: t.string() }));
+
+    expect(schema.validate(1)).toBe(true);
+    expect(schema.validate('1')).toBe(true);
+    expect(schema.validate({})).toBe(false);
+    expect(schema.validate({})).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, { a: 1 });
+    }).toThrow(
+      `param should be string, but got a(n) object
+or param should be number, but got a(n) object
+or param.a should be string, but got 1`
+    );
+  });
+
+  it('optional', () => {
+    expect.hasAssertions();
+    const schema = t.or(t.string(), t.null()).optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+
+  it('optional2', () => {
+    expect.hasAssertions();
+    const schema = t.or(t.string(), t.null());
+    expect(schema.validate(null)).toBe(true);
+  });
+
+  it('$or in $object', () => {
+    expect.hasAssertions();
+    const schema = t.object({
+      src: t.or(t.string(), t.array(t.string()))
+    });
+
+    expect(schema.validate({ src: 'str' })).toBe(true);
+    expect(schema.validate({ src: ['str'] })).toBe(true);
+    expect(schema.validate({ src: 123 })).toBe(false);
+    expect(schema.validate({ src: [123] })).toBe(false);
+    expect(schema.validate({ a: 'str' })).toBe(false);
+
+    expect(() => {
+      typeAsserts(schema, { a: 'str' });
+    }).toThrow(
+      `param.src should be string, but got undefined
+or param.src should be array, but got undefined`
+    );
+
+    expect(() => {
+      typeAsserts(schema, { src: 1 });
+    }).toThrow(
+      `param.src should be string, but got 1
+or param.src should be array, but got 1`
+    );
+
+    expect(() => {
+      typeAsserts(schema, { src: [1] });
+    }).toThrow(
+      `param.src should be string, but got a(n) array
+or param.src[0] should be string, but got 1`
+    );
+  });
+
+  it('$tuple in $or', () => {
+    expect.hasAssertions();
+    const schema = [t.or(t.tuple(t.number(), t.number()), t.tuple())];
+
+    const NUMBER = 1;
+    const STRING = 'abc';
+    const BOOLEAN = true;
+    const OBJECT = {};
+    const NULL_TUPLE: undefined[] = [];
+    const NUMBER_TUPLE = [1];
+    const STRING_TUPLE = ['abc'];
+    const NUMBER_STRING_TUPLE = [1, 'abc'];
+
+    const basisDataType = [NUMBER, STRING, BOOLEAN, OBJECT];
+    const tupleDataType = [NULL_TUPLE, NUMBER_TUPLE, STRING_TUPLE, NUMBER_STRING_TUPLE];
+
+    schema.forEach((s) => {
+      basisDataType.forEach((type) => {
+        expect(s.validate(type)).toBe(false);
+      });
+      tupleDataType.forEach((type) => {
+        expect(s.validate(type)).toBe(true);
+      });
+    });
+  });
+});