@powerlines/engine 0.0.25 → 0.9.2

package/dist/helpers/rpc.mjs

@@ -0,0 +1,139 @@
+import { EventEmitter } from "node:events";
+import { isNumber } from "@stryke/type-checks/is-number";
+import { isSet } from "@stryke/type-checks/is-set";
+import { createEventEmitter } from "@powerlines/core/lib/events";
+import { StormURL } from "@stryke/url";
+import { createRpcStreamingClientHost } from "devframe/client";
+import { RpcCacheManager, RpcFunctionsCollectorBase } from "devframe/rpc";
+import { createRpcClient as createRpcClient$1 } from "devframe/rpc/client";
+import { createWsRpcChannel } from "devframe/rpc/transports/ws-client";
+import { promiseWithResolver } from "devframe/utils/promise";
+import { humanId } from "human-id";
+
+//#region src/helpers/rpc.ts
+function createWsRpcClientMode(baseURL, connectionMeta, events, clientRpc, authToken = humanId({
+	separator: "-",
+	capitalize: false
+}), rpcOptions = {}, wsOptions = {}) {
+	let isTrusted = false;
+	const trustedPromise = promiseWithResolver();
+	const url = isNumber(connectionMeta.websocket) || isSet(connectionMeta.websocket) && `${+connectionMeta.websocket}` === `${connectionMeta.websocket}` ? `${baseURL.protocol.replace("http", "ws")}//${baseURL.hostname}:${connectionMeta.websocket}` : connectionMeta.websocket;
+	const definitions = /* @__PURE__ */ new Map();
+	for (const name of connectionMeta.jsonSerializableMethods ?? []) definitions.set(name, { jsonSerializable: true });
+	const serverRpc = createRpcClient$1(clientRpc.functions, {
+		channel: createWsRpcChannel({
+			url,
+			authToken,
+			definitions,
+			...wsOptions
+		}),
+		rpcOptions
+	});
+	clientRpc.register({
+		name: "devframe:auth:revoked",
+		type: "event",
+		handler: () => {
+			isTrusted = false;
+			events.emit("rpc:is-trusted:updated", false);
+		}
+	});
+	let currentAuthToken = authToken;
+	async function requestTrustWithToken(token) {
+		currentAuthToken = token;
+		return true;
+	}
+	async function requestTrust() {
+		if (isTrusted) return true;
+		return requestTrustWithToken(currentAuthToken);
+	}
+	async function ensureTrusted(timeout = 6e4) {
+		if (isTrusted) trustedPromise.resolve(true);
+		if (timeout <= 0) return trustedPromise.promise;
+		let clear = () => {};
+		await Promise.race([trustedPromise.promise.then(clear), new Promise((resolve, reject) => {
+			const id = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Timeout waiting for rpc to be trusted"));
+			}, timeout);
+			clear = () => clearTimeout(id);
+		})]);
+		return isTrusted;
+	}
+	return {
+		get isTrusted() {
+			return isTrusted;
+		},
+		requestTrust,
+		requestTrustWithToken,
+		ensureTrusted,
+		call: (...args) => {
+			return serverRpc.$call(...args);
+		},
+		callEvent: (...args) => {
+			return serverRpc.$callEvent(...args);
+		},
+		callOptional: (...args) => {
+			return serverRpc.$callOptional(...args);
+		}
+	};
+}
+const CONNECTION_AUTH_TOKEN_KEY = "__DEVTOOLS_CONNECTION_AUTH_TOKEN__";
+function createRpcClient(options) {
+	const baseURL = new StormURL(options.baseURL);
+	const cacheManager = new RpcCacheManager({
+		functions: [],
+		...typeof options.cacheOptions === "object" ? options.cacheOptions : {}
+	});
+	const context = { rpc: void 0 };
+	const clientRpc = new RpcFunctionsCollectorBase(context);
+	EventEmitter.setMaxListeners(100);
+	const events = createEventEmitter();
+	const mode = createWsRpcClientMode(baseURL, options.connection, events, clientRpc, void 0, {
+		...options.rpcOptions,
+		async onRequest(req, next, resolve) {
+			await options.rpcOptions?.onRequest?.call(this, req, next, resolve);
+			if (options.cacheOptions && cacheManager?.validate(req.m)) {
+				const cached = cacheManager.cached(req.m, req.a);
+				if (cached) return resolve(cached);
+				else {
+					const res = await next(req);
+					cacheManager?.apply(req, res);
+				}
+			} else await next(req);
+		}
+	}, options.wsOptions);
+	const rpc = {
+		events,
+		get isTrusted() {
+			return mode.isTrusted;
+		},
+		connectionMeta: options.connection,
+		ensureTrusted: mode.ensureTrusted,
+		requestTrust: mode.requestTrust,
+		requestTrustWithToken: async (token) => {
+			localStorage.setItem(CONNECTION_AUTH_TOKEN_KEY, token);
+			globalThis[CONNECTION_AUTH_TOKEN_KEY] = token;
+			return mode.requestTrustWithToken(token);
+		},
+		call: mode.call,
+		callEvent: mode.callEvent,
+		callOptional: mode.callOptional,
+		client: clientRpc,
+		sharedState: void 0,
+		streaming: void 0,
+		cacheManager
+	};
+	rpc.streaming = createRpcStreamingClientHost(rpc);
+	context.rpc = rpc;
+	mode.requestTrust();
+	try {
+		const bc = new BroadcastChannel("vite-devtools-auth");
+		bc.onmessage = (event) => {
+			if (event.data?.type === "auth-update" && event.data.authToken) rpc.requestTrustWithToken(event.data.authToken);
+		};
+	} catch {}
+	return rpc;
+}
+
+//#endregion
+export { createRpcClient };
+//# sourceMappingURL=rpc.mjs.map

package/dist/helpers/rpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.mjs","names":["createDevframeRpcClient"],"sources":["../../src/helpers/rpc.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { createEventEmitter } from \"@powerlines/core/lib/events\";\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isSet } from \"@stryke/type-checks/is-set\";\nimport { StormURL } from \"@stryke/url\";\nimport { BirpcOptions } from \"birpc\";\nimport {\n  createRpcStreamingClientHost,\n  DevToolsClientRpcHost,\n  DevToolsRpcClientMode,\n  RpcClientEvents\n} from \"devframe/client\";\nimport { RpcCacheManager, RpcFunctionsCollectorBase } from \"devframe/rpc\";\nimport { createRpcClient as createDevframeRpcClient } from \"devframe/rpc/client\";\nimport {\n  createWsRpcChannel,\n  WsRpcChannelOptions\n} from \"devframe/rpc/transports/ws-client\";\nimport {\n  ConnectionMeta,\n  EventEmitter as DevFrameEventEmitter\n} from \"devframe/types\";\nimport { promiseWithResolver } from \"devframe/utils/promise\";\nimport { humanId } from \"human-id\";\nimport { EventEmitter } from \"node:events\";\nimport { RpcClientOptions } from \"../types/config\";\nimport {\n  RpcClient,\n  RpcClientFunctions,\n  RpcContext,\n  RpcServerFunctions\n} from \"../types/rpc\";\n\nfunction createWsRpcClientMode(\n  baseURL: StormURL,\n  connectionMeta: ConnectionMeta,\n  events: DevFrameEventEmitter<RpcClientEvents>,\n  clientRpc: DevToolsClientRpcHost,\n  authToken: string = humanId({ separator: \"-\", capitalize: false }),\n  rpcOptions: Partial<\n    BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>\n  > = {},\n  wsOptions: Partial<WsRpcChannelOptions> = {}\n): DevToolsRpcClientMode {\n  let isTrusted = false;\n  const trustedPromise = promiseWithResolver<boolean>();\n  const url =\n    isNumber(connectionMeta.websocket) ||\n    (isSet(connectionMeta.websocket) &&\n      `${+connectionMeta.websocket}` === `${connectionMeta.websocket}`)\n      ? `${baseURL.protocol.replace(\"http\", \"ws\")}//${baseURL.hostname}:${connectionMeta.websocket}`\n      : (connectionMeta.websocket as string);\n\n  // Build a minimal `defs` map from the connection meta so the per-call\n  // wire serializer dispatches outgoing requests with the correct\n  // encoding (JSON for `jsonSerializable: true` methods; structured-\n  // clone for the rest).\n  const definitions = new Map<string, { jsonSerializable: true }>();\n  for (const name of connectionMeta.jsonSerializableMethods ?? [])\n    definitions.set(name, { jsonSerializable: true });\n\n  const serverRpc = createDevframeRpcClient<\n    RpcServerFunctions,\n    RpcClientFunctions\n  >(clientRpc.functions, {\n    channel: createWsRpcChannel({\n      url,\n      authToken,\n      definitions,\n      ...wsOptions\n    }),\n    rpcOptions\n  });\n\n  // Handle server-initiated auth revocation\n  clientRpc.register({\n    name: \"devframe:auth:revoked\",\n    type: \"event\",\n    handler: () => {\n      isTrusted = false;\n      events.emit(\"rpc:is-trusted:updated\", false);\n    }\n  });\n\n  let currentAuthToken = authToken;\n\n  async function requestTrustWithToken(token: string) {\n    currentAuthToken = token;\n\n    // const info = parseUA(navigator.userAgent);\n    // const ua = [\n    //   \"powerlines\",\n    //   \"1.0\",\n    //   \"|\",\n    //   info.os.name,\n    //   info.os.version,\n    //   info.device.type\n    // ]\n    //   .filter(i => i)\n    //   .join(\" \");\n\n    // const result = await serverRpc.$call(\"vite:anonymous:auth\", {\n    //   authToken: token,\n    //   ua,\n    //   origin: baseURL.origin\n    // });\n\n    // isTrusted = result.isTrusted;\n    // trustedPromise.resolve(isTrusted);\n    // events.emit(\"rpc:is-trusted:updated\", isTrusted);\n    // return result.isTrusted;\n\n    return true;\n  }\n\n  async function requestTrust() {\n    if (isTrusted) return true;\n    return requestTrustWithToken(currentAuthToken);\n  }\n\n  async function ensureTrusted(timeout = 60_000): Promise<boolean> {\n    if (isTrusted) trustedPromise.resolve(true);\n\n    if (timeout <= 0) return trustedPromise.promise;\n\n    let clear = () => {};\n    await Promise.race([\n      trustedPromise.promise.then(clear),\n      new Promise((resolve, reject) => {\n        const id = setTimeout(() => {\n          reject(new Error(\"Timeout waiting for rpc to be trusted\"));\n        }, timeout);\n        clear = () => clearTimeout(id);\n      })\n    ]);\n\n    return isTrusted;\n  }\n\n  return {\n    get isTrusted() {\n      return isTrusted;\n    },\n    requestTrust,\n    requestTrustWithToken,\n    ensureTrusted,\n    call: (...args: any): any => {\n      return serverRpc.$call(\n        // @ts-expect-error casting\n        ...args\n      );\n    },\n    callEvent: (...args: any): any => {\n      return serverRpc.$callEvent(\n        // @ts-expect-error casting\n        ...args\n      );\n    },\n    callOptional: (...args: any): any => {\n      return serverRpc.$callOptional(\n        // @ts-expect-error casting\n        ...args\n      );\n    }\n  };\n}\n\nconst CONNECTION_AUTH_TOKEN_KEY = \"__DEVTOOLS_CONNECTION_AUTH_TOKEN__\";\n\nexport function createRpcClient(options: RpcClientOptions) {\n  const baseURL = new StormURL(options.baseURL);\n\n  const cacheManager = new RpcCacheManager({\n    functions: [],\n    ...(typeof options.cacheOptions === \"object\" ? options.cacheOptions : {})\n  });\n  const context: RpcContext = {\n    rpc: undefined!\n  };\n\n  const clientRpc: DevToolsClientRpcHost = new RpcFunctionsCollectorBase<\n    RpcClientFunctions,\n    RpcContext\n  >(context);\n\n  EventEmitter.setMaxListeners(100);\n  const events = createEventEmitter<RpcClientEvents>();\n\n  const mode = createWsRpcClientMode(\n    baseURL,\n    options.connection,\n    events,\n    clientRpc,\n    undefined,\n    {\n      ...options.rpcOptions,\n      async onRequest(req, next, resolve) {\n        await options.rpcOptions?.onRequest?.call(this, req, next, resolve);\n        if (options.cacheOptions && cacheManager?.validate(req.m)) {\n          const cached = cacheManager.cached(req.m, req.a);\n          if (cached) {\n            return resolve(cached);\n          } else {\n            const res = await next(req);\n            cacheManager?.apply(req, res);\n          }\n        } else {\n          await next(req);\n        }\n      }\n    },\n    options.wsOptions\n  );\n\n  const rpc: RpcClient = {\n    events,\n    get isTrusted() {\n      return mode.isTrusted;\n    },\n    connectionMeta: options.connection,\n    ensureTrusted: mode.ensureTrusted,\n    requestTrust: mode.requestTrust,\n    requestTrustWithToken: async (token: string) => {\n      // Update stored token for future reconnections\n      localStorage.setItem(CONNECTION_AUTH_TOKEN_KEY, token);\n      (globalThis as any)[CONNECTION_AUTH_TOKEN_KEY] = token;\n      return mode.requestTrustWithToken(token);\n    },\n    call: mode.call,\n    callEvent: mode.callEvent,\n    callOptional: mode.callOptional,\n    client: clientRpc,\n    sharedState: undefined!,\n    streaming: undefined!,\n    cacheManager\n  };\n\n  // rpc.sharedState = createRpcSharedStateClientHost(rpc);\n  rpc.streaming = createRpcStreamingClientHost(rpc);\n\n  // @ts-expect-error assign to readonly property\n  context.rpc = rpc;\n  void mode.requestTrust();\n\n  // Listen for auth updates from other tabs (e.g., auth URL page)\n  try {\n    const bc = new BroadcastChannel(\"vite-devtools-auth\");\n    bc.onmessage = event => {\n      if (event.data?.type === \"auth-update\" && event.data.authToken) {\n        void rpc.requestTrustWithToken(event.data.authToken);\n      }\n    };\n  } catch {\n    // BroadcastChannel is not supported in all environments, so we can safely ignore errors here\n  }\n\n  return rpc;\n}\n"],"mappings":"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"}