chore: add full source code

__tests__/e2e/rpc-accesskey.test.ts

@@ -0,0 +1,35 @@
+import { RPCHandler } from "@/index"
+
+describe('Rpc accessKey test', () => {
+    test('none accesskey', async () => {
+        const server = new RPCHandler();
+        await server.listen({
+            port: 5202
+        });
+
+        const client = new RPCHandler();
+        expect(client.connect({
+            url: 'http://localhost:5202'
+        })).resolves.toBeDefined()
+    })
+
+    test('server required', async () => {
+        const serverAccesskey = 'abc123';
+        const server = new RPCHandler();
+        server.setAccessKey(serverAccesskey)
+        await server.listen({
+            port: 5203
+        });
+
+        const client = new RPCHandler();
+        expect(client.connect({
+            url: 'http://localhost:5203'
+        })).rejects.toThrow()
+
+        const client2 = new RPCHandler();
+        expect(client2.connect({
+            url: 'http://localhost:5203',
+            accessKey: serverAccesskey
+        })).resolves.toBeDefined()
+    })
+})

__tests__/e2e/rpc-full-flow.test.ts

@@ -0,0 +1,85 @@
+import { RPCHandler } from "@/index"
+import { ToDeepPromise } from "@/utils/utils";
+
+type ServerProvider = {
+    add: (a: number, b: number) => number;
+    math: {
+        multiply: (a: number, b: number) => number;
+        utils: {
+            absolute: (num: number) => number;
+        };
+    }
+}
+
+const serverProvider = {
+    add(a: number, b: number) {
+        return a + b;
+    },
+    math: {
+        multiply(a: number, b: number) {
+            return a * b
+        },
+        utils: {
+            absolute(num: number) {
+                return Math.abs(num);
+            },
+        }
+    }
+}
+
+
+type ClientProvider = {
+    getName: () => string;
+    sub: {
+        getName: () => string;
+    }
+}
+
+const clientProvider = {
+    name: '1',
+    getName() {
+        return this.name;
+    },
+    sub: {
+        name: '2',
+        getName() {
+            return this.name;
+        }
+    }
+}
+
+let clientAPI: ToDeepPromise<ClientProvider>
+let serverAPI: ToDeepPromise<ServerProvider>
+describe('Rpc full flow test', () => {
+    beforeAll(async () => {
+        const server = new RPCHandler();
+        server.setProvider(serverProvider)
+        await server.listen();
+
+        server.on('connnect', (rpcSession) => {
+            clientAPI = rpcSession.getAPI<ClientProvider>();
+        })
+
+        const client = new RPCHandler();
+        client.setProvider(clientProvider);
+        await client.connect().then((rpcSession) => {
+            serverAPI = rpcSession.getAPI<ServerProvider>();
+        });
+    })
+
+    test('server', async () => {
+        const addResult = await serverAPI.add(1, 1);
+        expect(addResult).toBe(2);
+        const multiplyResult = await serverAPI.math.multiply(2, 3);
+        expect(multiplyResult).toBe(6);
+        const absoluteResult = await serverAPI.math.utils.absolute(-1);
+        expect(absoluteResult).toBe(1);
+    })
+
+    test('client', async () => {
+        const name1 = await clientAPI.getName();
+        expect(name1).toBe(clientProvider.name);
+        const name2 = await clientAPI.sub.getName();
+        expect(name2).toBe(clientProvider.sub.name);
+    })
+})

__tests__/unit/utils/utils.test.ts

@@ -0,0 +1,23 @@
+import { isObject, isString, makeId } from "@/utils/utils"
+
+test('makeId', () => {
+    const id = makeId();
+    expect(id.length).toBe(32);
+    expect(typeof id === 'string').toBeTruthy();
+})
+
+test('isObject', () => {
+    const nullObj = null;
+    expect(isObject(nullObj)).toBeFalsy();
+    const normalObj = {};
+    expect(isObject(normalObj)).toBeTruthy();
+})
+
+test('isString', () => {
+    const emptyStr = '';
+    expect(isString(emptyStr)).toBeTruthy();
+    const str = 'str';
+    expect(isString(str)).toBeTruthy();
+    const aNumber = 1;
+    expect(isString(aNumber)).toBeFalsy();
+})