@oox/client 1.0.0

package/types/config.d.ts

@@ -0,0 +1,14 @@
+export interface ConfigAllow {
+    untrusted: boolean;
+    ip: string[];
+    caller: string[];
+}
+interface ConfigInterface {
+    id: string;
+    name: string;
+}
+export declare class Config implements ConfigInterface {
+    id: string;
+    name: string;
+}
+export {};

package/types/context.d.ts

@@ -0,0 +1,18 @@
+import { KeepAliveConnection, KeepAliveNativeConnection } from './keepalive-connection.js';
+export declare class AppContext {
+    [x: string]: any;
+    traceId?: string | undefined;
+}
+export interface KeepAliveRPCContext {
+    traceId?: string;
+    sourceIP?: string;
+}
+export declare class Context extends AppContext {
+    sourceIP: string;
+    ip: string;
+    caller: string;
+    callerId: string;
+    connection?: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(context?: Partial<Context>);
+    toJSON?(): {} & this;
+}

package/types/index.d.ts

@@ -0,0 +1,23 @@
+import { Context } from "./context.js";
+import { Config } from './config.js';
+import { KeepAliveConnection, KeepAliveNativeConnection } from "./keepalive-connection.js";
+export declare const config: Config;
+export declare function setGenTraceIdFunction(fn: () => string): void;
+/**
+ * 生成随机不重复id
+ */
+export declare function genTraceId(): string;
+export declare function genContext(context?: Context): Context;
+export declare function getContext(): Context;
+export declare function addKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
+export declare function removeKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
+export declare function removeKeepAliveConnection(name: string, id: string): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => KeepAliveConnection<KeepAliveNativeConnection>): void;
+export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
+export declare function rpc(connection: KeepAliveConnection<KeepAliveNativeConnection>, action: string, params: any[], context?: Context): Promise<any>;
+export * from './app.js';
+export * from './context.js';
+export * from './config.js';
+export * as logger from './logger.js';
+export * from './keepalive-connection.js';
+export * from './keepalive-connection-sample.js';

package/types/keepalive-connection-sample.d.ts

@@ -0,0 +1,56 @@
+import { Context, KeepAliveRPCContext } from './context.js';
+import { KeepAliveConnection, KeepAliveConnectionData, KeepAliveNativeConnection, KeepAliveConnectionAdapter, KeepAliveSyncConnectionsQuery } from './keepalive-connection.js';
+import { ReturnsBody } from './index.js';
+export interface SampleKeepAliveNativeConnection extends KeepAliveNativeConnection {
+    connected: boolean;
+    connect?(): void;
+    on(event: string, listener: (...args: any[]) => any): any;
+    once(event: string, listener: (...args: any[]) => any): any;
+    off(event: string, listener?: (...args: any[]) => any): any;
+    emit(event: string, ...args: any[]): any;
+    removeAllListeners(event?: string): any;
+}
+export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection extends SampleKeepAliveNativeConnection> implements KeepAliveConnectionAdapter<NativeConnection> {
+    abstract name: string;
+    OOXEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+        CALL: string;
+        READY: string;
+        ENABLED: string;
+        DISABLED: string;
+        REGISTRY_SYNC_CONNECTIONS: string;
+        REGISTRY_SUBSCRIBE: string;
+        REGISTRY_NOTIFY: string;
+    };
+    abstract newConnection(identify: string | URL | KeepAliveConnectionData): KeepAliveConnection<NativeConnection>;
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection: KeepAliveConnection<NativeConnection>, datas: KeepAliveConnectionData[]): void;
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection: KeepAliveConnection<NativeConnection>, query: KeepAliveSyncConnectionsQuery): void;
+    bindConnectionEvents(connection: KeepAliveConnection<NativeConnection>): void;
+    open(identify: string | URL | KeepAliveConnectionData): Promise<KeepAliveConnection<NativeConnection>>;
+    close(connection: KeepAliveConnection<NativeConnection>): Promise<void>;
+    /**
+     * 发送事件
+     * @param socket
+     * @param event
+     * @param params
+     */
+    emit(socket: NativeConnection, event: string, params: any[]): Promise<unknown>;
+    /**
+     * RPC
+     */
+    rpc(connection: KeepAliveConnection<NativeConnection>, action: string, params: any[], context?: KeepAliveRPCContext): Promise<any>;
+    /**
+     * 绑定 call 事件
+     * @param connection
+     */
+    bindCall(connection: KeepAliveConnection<NativeConnection>): void;
+    call(action: string, params: any[], context: Context, callback?: (returns: any) => void): Promise<ReturnsBody<any>>;
+}

package/types/keepalive-connection.d.ts

@@ -0,0 +1,104 @@
+import EventEmitter from 'events';
+import { Context } from './context.js';
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare class KeepAliveConnectionError extends Error {
+    connection: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(message: string, connection: KeepAliveConnection<KeepAliveNativeConnection>);
+}
+export interface KeepAliveNativeConnection {
+    disconnect(): void;
+}
+export interface KeepAliveSyncConnectionsQuery {
+    [x: string]: any;
+    name?: string | string[];
+}
+export interface KeepAliveConnectionAdapter<T extends KeepAliveNativeConnection> {
+    /**
+     * 连接适配器名称
+     */
+    name: string;
+    open(identify: string | URL | KeepAliveConnectionData): Promise<KeepAliveConnection<T>>;
+    close(connection: KeepAliveConnection<T>): Promise<void>;
+    rpc(connection: KeepAliveConnection<T>, action: string, params: any[], context: Context): Promise<any>;
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection: KeepAliveConnection<T>, datas: KeepAliveConnectionData[]): void;
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection: KeepAliveConnection<T>, query: KeepAliveSyncConnectionsQuery): void;
+}
+export interface KeepAliveConnectionData {
+    /**
+     * 连接适配器名称
+     */
+    adapter: string;
+    /**
+     * 连接主机地址
+     */
+    ip: string;
+    /**
+     * 连接服务名称
+     */
+    name: string;
+    /**
+     * 连接URL
+     */
+    url?: string | URL;
+    /**
+     * 目标服务网络唯一ID
+     */
+    id: string;
+    /**
+     * 验证令牌
+     */
+    token: string;
+}
+export interface KeepAliveConnectionReadyParams {
+    [x: string]: any;
+    id: KeepAliveConnectionData['id'];
+    name: KeepAliveConnectionData['name'];
+}
+interface KeepAliveConnectionEventMap<T> {
+    "enabled": [];
+    "disabled": [];
+    "connect": [];
+    "disconnect": [];
+    'error': [KeepAliveConnectionError];
+}
+export declare class KeepAliveConnection<T extends KeepAliveNativeConnection> extends EventEmitter<KeepAliveConnectionEventMap<KeepAliveConnection<T>>> {
+    #private;
+    isRegistry: boolean;
+    data: KeepAliveConnectionData;
+    nativeConnection: T;
+    adapter: KeepAliveConnectionAdapter<T>;
+    constructor(adapter: KeepAliveConnectionAdapter<T>, nativeConnection: T, data: MakeOptional<KeepAliveConnectionData, 'adapter'>);
+    /**
+     * 设置连接是否可用，并自动触发enabled或disabled事件
+     * @param enabled 是否可用
+     */
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    /**
+     * enable & mount connection
+     * @param params
+     * @returns
+     */
+    ready(params: KeepAliveConnectionReadyParams): void;
+    disconnect(): void;
+}
+export declare class KeepAliveConnectionStore<T extends KeepAliveNativeConnection> {
+    #private;
+    entries(): MapIterator<[string, Map<string, KeepAliveConnection<T>>]>;
+    getConnectionsOfService(name: string): Map<string, KeepAliveConnection<T>>;
+    has(name: string, id: string): boolean;
+    get(name: string, id: string): KeepAliveConnection<T> | null;
+    add(connection: KeepAliveConnection<T>): void;
+    remove(connection: KeepAliveConnection<T>): void;
+    remove(name: string, id: string): void;
+}
+export declare const keepAliveConnectionAdapters: Map<string, KeepAliveConnectionAdapter<KeepAliveNativeConnection>>;
+export declare const keepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
+export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
+export {};

package/types/logger.d.ts

@@ -0,0 +1,5 @@
+export declare function info(...content: any[]): void;
+export declare function warn(...content: any[]): void;
+export declare function error(...content: any[]): void;
+export declare function tag(name: string): void;
+export declare function trace(name?: string): void;

package/types/tracer.d.ts

@@ -0,0 +1,7 @@
+import { AppContext } from './context.js';
+export type OOX_TRACER = Record<string, (...args: any[]) => any>;
+export declare const contexts: Record<string, AppContext>;
+export declare function parseTraceIdByStack(stack: string): string | null;
+export declare function enterWith(context: AppContext): void;
+export declare function exitWith(context: AppContext): void;
+export declare function getContext(): AppContext;

package/types/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function getAllCallablePropertyNames(obj: any): string[];
+export declare function genKVMethods(methods: any, kvMethods?: Map<string, Function>, sourceKVMethods?: Map<string, Function>, nameStack?: string[]): {
+    kvMethods: Map<string, Function>;
+    sourceKVMethods: Map<string, Function>;
+};

package/utils.js

@@ -0,0 +1,40 @@
+export function getAllCallablePropertyNames(obj) {
+    if (!obj)
+        return [];
+    let props = [], tmpProps = [], index = 0, size = 0, tmpProp = '';
+    const bans = ["constructor", "__defineGetter__", "__defineSetter__",
+        "hasOwnProperty", "__lookupGetter__", "__lookupSetter__",
+        "isPrototypeOf", "propertyIsEnumerable", "toString",
+        "valueOf", "__proto__", "toLocaleString"];
+    do {
+        tmpProps = Object.getOwnPropertyNames(obj);
+        index = -1, size = tmpProps.length;
+        while (++index < size) {
+            tmpProp = tmpProps[index];
+            if (!props.includes(tmpProp) && !bans.includes(tmpProp)) {
+                props.push(tmpProp);
+            }
+        }
+    } while (obj = Object.getPrototypeOf(obj));
+    return props;
+}
+export function genKVMethods(methods, kvMethods = new Map(), sourceKVMethods = new Map(), nameStack = []) {
+    let keys = getAllCallablePropertyNames(methods);
+    for (const key of keys) {
+        /**
+         * @type {Function}
+         */
+        let val = methods[key];
+        if ('function' === typeof val) {
+            const action = nameStack.concat(key).join('.');
+            // 原函数绑定
+            sourceKVMethods.set(action, val);
+            // 壳函数绑定
+            kvMethods.set(action, val.bind(methods));
+        }
+        else {
+            genKVMethods(val, kvMethods, sourceKVMethods, nameStack.concat(key));
+        }
+    }
+    return { kvMethods, sourceKVMethods };
+}