@jolibox/implement 1.1.4-beta.4

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');
+  });
+});

package/src/common/api-factory/validator/index.ts

@@ -0,0 +1,107 @@
+import * as V from './validate';
+
+type Constructor<T> = new (...args: any[]) => T;
+
+export { Validator, Primitive } from './validate';
+
+export type Type<T> = T extends V.Validator<infer U> ? U : never;
+type OptionalKeys<T> = { [K in keyof T]-?: T[K] & undefined extends never ? never : Required<K> }[keyof T];
+
+export const t = {
+  object<T extends Record<string, V.Validator>>(schemas?: T) {
+    type U = { [K in keyof T]: Type<T[K]> };
+    type O = { [K in OptionalKeys<U>]?: U[K] } & Omit<U, OptionalKeys<U>>;
+    return new V.$object<{ [K in keyof O]: O[K] }>(schemas);
+  },
+
+  array<T extends V.Validator>(schema?: T) {
+    return new V.$array<unknown>(schema);
+  },
+
+  tuple<T extends V.Validator[]>(...schemas: T) {
+    return new V.$tuple<{ [K in keyof T]: Type<T[K]> }>(...schemas);
+  },
+
+  literal<T extends V.Primitive>(v: T) {
+    return new V.$literal<T>(v);
+  },
+
+  or<T extends V.Validator[]>(...schemas: T) {
+    return new V.$or<T extends V.Validator<infer I>[] ? I : unknown>(...schemas);
+  },
+
+  symbol() {
+    return new V.$symbol();
+  },
+
+  record<T extends V.Validator<unknown>>(schema: T) {
+    return new V.$record<Type<T>>(schema);
+  },
+
+  function() {
+    return new V.$function();
+  },
+
+  boolean() {
+    return new V.$boolean();
+  },
+
+  string() {
+    return new V.$string();
+  },
+
+  number() {
+    return new V.$number();
+  },
+
+  undefined() {
+    return new V.$undefined();
+  },
+
+  null() {
+    return new V.$null();
+  },
+
+  unknown() {
+    return new V.$any<unknown>();
+  },
+
+  any() {
+    return new V.$any();
+  },
+
+  as<T>() {
+    return new V.$any<T>();
+  },
+
+  arraybuffer() {
+    return new V.$arraybuffer();
+  },
+
+  enum<T extends (string | number)[]>(...values: T) {
+    return new V.$enum<T[number]>(...values);
+  },
+
+  typedarray<T extends V.TypedArray>(ctor: Constructor<T>) {
+    return new V.$typedarray(ctor);
+  }
+};
+
+export function typeAsserts<T extends V.Validator>(
+  validator: T,
+  x: unknown,
+  path = 'param'
+): asserts x is Type<T> {
+  validator.errors = [];
+  validator.path = path;
+
+  V.setCollect(true);
+
+  if (!validator.validate(x)) {
+    const messages = validator.errors.join('\n');
+    validator.errors.length = 0;
+    V.setCollect(false);
+
+    throw new TypeError(messages);
+  }
+}