@jolibox/implement 1.1.4-beta.4

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

@@ -0,0 +1,188 @@
+import { APIError, isArray } from '@jolibox/common';
+
+import { ResponseType, StandardResponse } from '@jolibox/types';
+import { Track } from '../report';
+import { reportError } from '../report/errors/report';
+import { Type, typeAsserts, Validator } from './validator';
+import { createAPIError, createUserAPIError } from '../report/errors';
+
+let traceId = 1;
+
+/**
+ * TODO: 埋点逻辑
+ */
+type Response<T> = T | StandardResponse<T>;
+type SyncFunction<Params extends unknown[], Return> = (
+  ...inputs: Params
+) => Return | { code: ResponseType; data: Return };
+type AsyncFunction<Params extends unknown[], Return> = (
+  ...inputs: Params
+) => Promise<Response<Return> | Return>;
+interface APIFactory {
+  createSyncAPI<Params extends unknown[], Return = void>(
+    method: string,
+    config: {
+      implement: SyncFunction<Params, Return>;
+    }
+  ): (...inputs: Params) => StandardResponse<Return>;
+
+  createAPI<Params extends unknown[], Return = void>(
+    method: string,
+    config: {
+      implement: Params extends undefined ? () => Promise<Return> : AsyncFunction<Params, Return>;
+    }
+  ): (...inputs: unknown[]) => Promise<StandardResponse<Return>>;
+}
+
+export const createAPIFactory = (track: Track) => {
+  /**
+   * create Sync API
+   */
+  function createSyncAPI<
+    ParamsSchema extends Validator<unknown[]>,
+    Inputs extends Type<ParamsSchema> & unknown[],
+    Return = void
+  >(
+    method: string,
+    config: {
+      paramsSchema?: ParamsSchema;
+      implement: (...inputs: Inputs) => Return | { code: ResponseType; data: Return };
+    }
+  ): (...inputs: Inputs) => StandardResponse<Return> {
+    return (...inputs) => {
+      const startTime = Date.now();
+      const reportExtra = { method, trace_id: traceId };
+      traceId += 1;
+
+      let status: ResponseType = 'SUCCESS';
+      let errMsg = `${method}:ok`;
+      let errNo = 0;
+
+      try {
+        // 类型校验
+        if (config.paramsSchema) {
+          try {
+            typeAsserts(config.paramsSchema, inputs, 'params');
+          } catch (err: unknown) {
+            const error = err as { message: string };
+            throw createUserAPIError(`${method}:fail ${error.message}`);
+          }
+        }
+        const res = config.implement(...inputs);
+        let data = res as Return;
+        let message = `${method}:ok`;
+        if (res && 'code' in (res as { code: ResponseType; data: Return })) {
+          const {
+            code,
+            data: originData,
+            message: originMessage
+          } = res as { code: ResponseType; data: Return; message: string };
+          status = code;
+          data = originData;
+          message = originMessage;
+        }
+
+        return {
+          code: status,
+          message,
+          data
+        };
+      } catch (error) {
+        const _error = error as { code?: number; message?: string; errNo?: number; errMsg?: string };
+        errNo = _error.code ?? _error.errNo ?? 2000;
+        status = 'FAILURE';
+        const msg = _error.message ?? _error.errMsg ?? `${error}`;
+        errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, '')}`;
+        reportError(new APIError(errMsg, errNo));
+        return {
+          code: status,
+          message: errMsg
+        };
+      } finally {
+        const duration = Date.now() - startTime;
+        track('apiInvoked', { ...reportExtra, duration, status });
+      }
+    };
+  }
+
+  /**
+   * Async API
+   */
+
+  function createAPI<
+    ParamsSchema extends Validator<unknown[]>,
+    Inputs extends Type<ParamsSchema> & unknown[],
+    Return
+  >(
+    method: string,
+    config: {
+      paramsSchema?: ParamsSchema;
+      implement: Inputs extends undefined
+        ? () => Promise<Response<Return>>
+        : (...params: Inputs) => Promise<Response<Return>>;
+    }
+  ): (...inputs: unknown[]) => Promise<StandardResponse<Return>> {
+    // 异步 API
+    return async (..._inputs) => {
+      const inputs = isArray(_inputs) ? _inputs : [_inputs];
+
+      const startTime = Date.now();
+      const reportExtra = { method, trace_id: traceId };
+      traceId += 1;
+
+      let message = `${method}:ok`;
+      let status: ResponseType = 'SUCCESS';
+      const res: StandardResponse<Return> = {
+        code: status,
+        message
+      };
+
+      try {
+        if (config.paramsSchema) {
+          try {
+            typeAsserts(config.paramsSchema, inputs, 'params');
+          } catch (error) {
+            throw createUserAPIError((error as Error).message);
+          }
+        }
+
+        const data = await config.implement(...inputs);
+
+        let ret = data as Return;
+        if (ret && 'code' in (ret as unknown as { code: ResponseType; data: Return })) {
+          const {
+            code,
+            data: originData,
+            message: originMessage
+          } = ret as unknown as { code: ResponseType; data: Return; message: string };
+          status = code;
+          message = originMessage;
+          ret = originData;
+        }
+        Object.assign(res, {
+          code: status,
+          message,
+          data: ret
+        });
+        return res;
+      } catch (error: any) {
+        const _error = error as { code?: number; message?: string; errNo?: number; errMsg?: string };
+        const errNo = _error.code ?? _error.errNo ?? 2000;
+        status = 'FAILURE';
+        const msg = _error.message ?? _error.errMsg ?? `${error}`;
+        const errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, '')}`;
+        Object.assign(res, {
+          code: status,
+          message: errMsg
+        });
+        reportError(new APIError(errMsg, errNo));
+        return res;
+      } finally {
+        const duration = Date.now() - startTime;
+        track('apiInvoked', { ...reportExtra, duration, status });
+      }
+    };
+  }
+
+  return { createAPI, createSyncAPI };
+};

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

@@ -0,0 +1,68 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts, Validator } from '../../index';
+
+describe('any,unknown,as', () => {
+  function testSchema(schema: Validator) {
+    expect(schema.validate('')).toBe(true);
+
+    expect(schema.validate('str')).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 'str');
+    }).not.toThrow();
+
+    expect(schema.validate(1)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).not.toThrow();
+
+    expect(schema.validate(Symbol.for('1'))).toBe(true);
+    expect(() => {
+      typeAsserts(schema, Symbol.for('1'));
+    }).not.toThrow();
+
+    expect(schema.validate(null)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, null);
+    }).not.toThrow();
+
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+
+    expect(schema.validate({})).toBe(true);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).not.toThrow();
+
+    expect(schema.validate([])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, []);
+    }).not.toThrow();
+
+    expect(schema.validate(() => {})).toBe(true);
+    expect(() => {
+      typeAsserts(schema, () => {});
+    }).not.toThrow();
+
+    expect(schema.validate(BigInt(1))).toBe(true);
+    expect(() => {
+      typeAsserts(schema, BigInt(1));
+    }).not.toThrow();
+  }
+
+  it('any', () => {
+    expect.hasAssertions();
+    testSchema(t.any());
+  });
+
+  it('unknown', () => {
+    expect.hasAssertions();
+    testSchema(t.unknown());
+  });
+
+  it('as', () => {
+    expect.hasAssertions();
+    testSchema(t.as());
+  });
+});

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

@@ -0,0 +1,402 @@
+/* eslint-disable no-empty-function */
+import { t, typeAsserts } from '../../index';
+
+describe('array', () => {
+  it('string array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string());
+
+    expect(schema.validate(['str'])).toBe(true);
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).toThrow('param should be array, but got a(n) object');
+
+    expect(schema.validate(1)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).toThrow('param should be array, but got 1');
+
+    expect(schema.validate('str')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 1);
+    }).toThrow('param should be array, but got 1');
+
+    expect(schema.validate([1])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [1]);
+    }).toThrow('param[0] should be string, but got 1');
+
+    expect(schema.validate([true])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [true]);
+    }).toThrow('param[0] should be string, but got true');
+
+    expect(schema.validate([false])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [false]);
+    }).toThrow('param[0] should be string, but got false');
+
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [Symbol(1)]);
+    }).toThrow('param[0] should be string, but got a(n) symbol');
+
+    expect(schema.validate([null])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [null]);
+    }).toThrow('param[0] should be string, but got null');
+
+    expect(schema.validate([undefined])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [undefined]);
+    }).toThrow('param[0] should be string, but got undefined');
+
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [BigInt(1)]);
+    }).toThrow('param[0] should be string, but got a(n) bigint');
+
+    expect(schema.validate([{}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [{}]);
+    }).toThrow('param[0] should be string, but got a(n) object');
+
+    expect(schema.validate([() => {}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [() => {}]);
+    }).toThrow('param[0] should be string, but got a(n) function');
+  });
+
+  it('number array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.number());
+
+    expect(schema.validate([1])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [1]);
+    }).not.toThrow();
+
+    expect(schema.validate(['str'])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, ['str']);
+    }).toThrow('param[0] should be number, but got "str"');
+
+    expect(schema.validate([true])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [true]);
+    }).toThrow('param[0] should be number, but got true');
+
+    expect(schema.validate([false])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [false]);
+    }).toThrow('param[0] should be number, but got false');
+
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [Symbol(1)]);
+    }).toThrow('param[0] should be number, but got a(n) symbol');
+
+    expect(schema.validate([null])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [null]);
+    }).toThrow('param[0] should be number, but got null');
+
+    expect(schema.validate([undefined])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [undefined]);
+    }).toThrow('param[0] should be number, but got undefined');
+
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [BigInt(1)]);
+    }).toThrow('param[0] should be number, but got a(n) bigint');
+
+    expect(schema.validate([{}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [{}]);
+    }).toThrow('param[0] should be number, but got a(n) object');
+
+    expect(schema.validate([() => {}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [() => {}]);
+    }).toThrow('param[0] should be number, but got a(n) function');
+  });
+
+  it('boolean array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.boolean());
+
+    expect(schema.validate([true])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [true]);
+    }).not.toThrow();
+
+    expect(schema.validate([false])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [false]);
+    }).not.toThrow();
+
+    expect(schema.validate([1])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [1]);
+    }).toThrow('param[0] should be boolean, but got 1');
+
+    expect(schema.validate(['str'])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, ['str']);
+    }).toThrow('param[0] should be boolean, but got "str"');
+
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [Symbol(1)]);
+    }).toThrow('param[0] should be boolean, but got a(n) symbol');
+
+    expect(schema.validate([null])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [null]);
+    }).toThrow('param[0] should be boolean, but got null');
+
+    expect(schema.validate([undefined])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [undefined]);
+    }).toThrow('param[0] should be boolean, but got undefined');
+
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [BigInt(1)]);
+    }).toThrow('param[0] should be boolean, but got a(n) bigint');
+
+    expect(schema.validate([{}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [{}]);
+    }).toThrow('param[0] should be boolean, but got a(n) object');
+
+    expect(schema.validate([() => {}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [() => {}]);
+    }).toThrow('param[0] should be boolean, but got a(n) function');
+  });
+
+  it('undefined array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.undefined());
+
+    expect(schema.validate([true])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [true]);
+    }).toThrow('param[0] should be undefined, but got true');
+
+    expect(schema.validate([undefined])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [undefined]);
+    }).not.toThrow();
+
+    expect(schema.validate([true])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [true]);
+    }).toThrow('param[0] should be undefined, but got true');
+
+    expect(schema.validate([false])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [false]);
+    }).toThrow('param[0] should be undefined, but got false');
+
+    expect(schema.validate([1])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [1]);
+    }).toThrow('param[0] should be undefined, but got 1');
+
+    expect(schema.validate(['str'])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, ['str']);
+    }).toThrow('param[0] should be undefined, but got "str"');
+
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [Symbol(1)]);
+    }).toThrow('param[0] should be undefined, but got a(n) symbol');
+
+    expect(schema.validate([null])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [null]);
+    }).toThrow('param[0] should be undefined, but got null');
+
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [BigInt(1)]);
+    }).toThrow('param[0] should be undefined, but got a(n) bigint');
+
+    expect(schema.validate([{}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [{}]);
+    }).toThrow('param[0] should be undefined, but got a(n) object');
+
+    expect(schema.validate([() => {}])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, [() => {}]);
+    }).toThrow('param[0] should be undefined, but got a(n) function');
+  });
+
+  it('null array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.null());
+
+    expect(schema.validate([null])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [null]);
+    }).not.toThrow();
+
+    expect(schema.validate([true])).toBe(false);
+    expect(schema.validate([false])).toBe(false);
+    expect(schema.validate([1])).toBe(false);
+    expect(schema.validate(['str'])).toBe(false);
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(schema.validate([undefined])).toBe(false);
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(schema.validate([{}])).toBe(false);
+    expect(schema.validate([() => {}])).toBe(false);
+  });
+
+  it('object array', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.object());
+
+    expect(schema.validate([{}])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [{}]);
+    }).not.toThrow();
+
+    expect(schema.validate([true])).toBe(false);
+    expect(schema.validate([false])).toBe(false);
+    expect(schema.validate([1])).toBe(false);
+    expect(schema.validate(['str'])).toBe(false);
+    expect(schema.validate([Symbol(1)])).toBe(false);
+    expect(schema.validate([undefined])).toBe(false);
+    expect(schema.validate([BigInt(1)])).toBe(false);
+    expect(schema.validate([null])).toBe(false);
+    expect(schema.validate([() => {}])).toBe(false);
+  });
+
+  it('object.property array', () => {
+    expect.hasAssertions();
+    const schema = t.array(
+      t.object({
+        a: t.string(),
+        b: t.number()
+      })
+    );
+
+    expect(schema.validate([{ a: 'str', b: 1 }])).toBe(true);
+    expect(() => {
+      typeAsserts(schema, [{ a: 'str', b: 1 }]);
+    }).not.toThrow();
+
+    expect(schema.validate([{}])).toBe(false);
+    expect(schema.validate([{ a: 'str' }])).toBe(false);
+    expect(schema.validate([{ b: 1 }])).toBe(false);
+  });
+
+  it('primitive item error message', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string());
+
+    expect(() => typeAsserts(schema, [1])).toThrow(`param[0] should be string, but got 1`);
+
+    expect(() => typeAsserts(schema, ['str', 1])).toThrow(`param[1] should be string, but got 1`);
+  });
+
+  it('object item error message', () => {
+    expect.hasAssertions();
+    const schema = t.array(
+      t.object({
+        a: t.object({
+          b: t.string()
+        })
+      })
+    );
+
+    expect(() => {
+      typeAsserts(schema, [{ a: { b: 123 } }]);
+    }).toThrow(`param[0].a.b should be string, but got 123`);
+
+    expect(() => typeAsserts(schema, [{ a: { b: 'str' } }, { a: { b: 123 } }])).toThrow(
+      `param[1].a.b should be string, but got 123`
+    );
+  });
+
+  it('minItems', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string()).minItems(3);
+
+    expect(schema.validate([])).toBe(false);
+    expect(schema.validate(['str'])).toBe(false);
+    expect(schema.validate(['str', 'str', 'str'])).toBe(true);
+    expect(schema.validate(['str', 'str', 'str', 'str'])).toBe(true);
+  });
+
+  it('maxItems', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string()).maxItems(13);
+
+    expect(schema.validate([])).toBe(true);
+    expect(schema.validate(['str'])).toBe(true);
+    expect(schema.validate(Array(13).fill('str'))).toBe(true);
+    expect(schema.validate(Array(14).fill('str'))).toBe(false);
+  });
+
+  it('optional', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string()).optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+
+  it('item default', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string().default('default-string'));
+    const data: unknown[] = [undefined, undefined, 'str'];
+    schema.validate(data);
+    expect(data).toStrictEqual(['default-string', 'default-string', 'str']);
+  });
+
+  it('item fallback', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string().fallback('fallback-string'));
+    const data: unknown[] = [1, 1, 'str'];
+    expect(schema.validate(data)).toBe(true);
+    expect(data).toStrictEqual(['fallback-string', 'fallback-string', 'str']);
+  });
+
+  it('uniqueItems', () => {
+    expect.hasAssertions();
+    const schema = t.array(t.string()).uniqueItems();
+
+    const data: unknown = ['1', '2', '2', '1', '1'];
+    expect(schema.validate(data)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, data);
+    }).toThrow(`param should NOT have duplicate items (param[1] and param[2] are identical)
+param should NOT have duplicate items (param[0] and param[3] are identical)
+param should NOT have duplicate items (param[0] and param[4] are identical)`);
+
+    const data2: unknown = ['1', '2'];
+    expect(() => typeAsserts(schema, data2)).not.toThrow();
+    expect(schema.validate(data2)).toBe(true);
+  });
+
+  it('length', () => {
+    expect.hasAssertions();
+    const schema = t.array().length(2);
+    expect(schema.validate(['ss', 'xx'])).toBe(true);
+    expect(schema.validate(['ss'])).toBe(false);
+    expect(schema.validate(['ss', 'xx', 'yy'])).toBe(false);
+    expect(schema.validate([])).toBe(false);
+    expect(() => typeAsserts(schema, [])).toThrow(`the length of param should be equal to 2`);
+
+    expect(() => typeAsserts(schema, [1, 2, 3])).toThrow(`the length of param should be equal to 2`);
+  });
+});

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

@@ -0,0 +1,48 @@
+import { t, typeAsserts } from '../../index';
+
+describe('arrayBuffer', () => {
+  it('valid value', () => {
+    expect.hasAssertions();
+    const buffer = new ArrayBuffer(10);
+    const schema = t.arraybuffer();
+
+    expect(schema.validate(buffer)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, buffer);
+    }).not.toThrow();
+
+    expect(schema.validate(123)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 123);
+    }).toThrow('param should be arraybuffer, but got 123');
+
+    expect(schema.validate('str')).toBe(false);
+    expect(() => {
+      typeAsserts(schema, 'str');
+    }).toThrow('param should be arraybuffer, but got "str"');
+
+    expect(schema.validate(true)).toBe(false);
+    expect(() => {
+      typeAsserts(schema, true);
+    }).toThrow('param should be arraybuffer, but got true');
+
+    expect(schema.validate({})).toBe(false);
+    expect(() => {
+      typeAsserts(schema, {});
+    }).toThrow('param should be arraybuffer, but got a(n) object');
+
+    expect(schema.validate([])).toBe(false);
+    expect(() => {
+      typeAsserts(schema, []);
+    }).toThrow('param should be arraybuffer, but got a(n) array');
+  });
+
+  it('optional optional', () => {
+    expect.hasAssertions();
+    const schema = t.arraybuffer().optional();
+    expect(schema.validate(undefined)).toBe(true);
+    expect(() => {
+      typeAsserts(schema, undefined);
+    }).not.toThrow();
+  });
+});