@powerlines/engine 0.0.24 → 0.9.1

package/dist/config-FB8Zqjjz.d.mts

@@ -0,0 +1,200 @@
+import { CustomLogger, ExecutionOptions, FrameworkOptions, LogMeta, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
+import { RpcStreamingClientHost } from "devframe/client";
+import { RpcCacheManager, RpcCacheOptions, RpcFunctionsCollector } from "devframe/rpc";
+import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
+import { MaybePromise, PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { BirpcOptions, BirpcReturn, ProxifiedRemoteFunctions } from "birpc";
+import { ConnectionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevframeDefinition, EventEmitter, RpcSharedStateHost } from "devframe/types";
+import { Asyncify } from "@stryke/types/async";
+
+//#region src/types/rpc.d.ts
+interface RpcPayloadMetadata {
+  /**
+   * A unique identifier for correlating related Rpc messages, which can be used to group messages that belong to the same logical operation or workflow across different parts of the system. This is a required field and should be generated by the sender of the message.
+   */
+  messageId: string;
+  /**
+   * The type of the Rpc message, which indicates the purpose of the message and how it should be handled by the receiving end. This is a required field and must be one of the predefined values in the IpcMessageType enum.
+   */
+  type: string;
+  /**
+   * The timestamp when the Rpc message was created, represented as the number of milliseconds since the Unix epoch.
+   */
+  timestamp: number;
+  /**
+   * A unique identifier for the current execution instance, which can be used for logging and other purposes to distinguish between different executions in the same process.
+   */
+  executionId?: string;
+  /**
+   * The zero-based index of the current execution within the sequence of executions in the same process.
+   */
+  configIndex?: number;
+  /**
+   * Optional environment identifier to specify the context or environment in which the message is being processed.
+   */
+  environment?: string;
+}
+interface RpcPayloadEnvelop<TPayload> extends RpcPayloadMetadata {
+  /**
+   * The payload data associated with the Rpc message, typed according to the message type.
+   */
+  payload: TPayload;
+}
+type RpcFunction = (payload: any) => MaybePromise<any>;
+type RpcFunctions = Record<string, RpcFunction>;
+type InputRpcFunction = (envelop: RpcPayloadEnvelop<any>) => any;
+type InputRpcFunctions = Record<string, InputRpcFunction>;
+type WrappedRpcFunction = (envelop: RpcPayloadEnvelop<any>) => Promise<any>;
+type WrappedRpcFunctions = Record<string, WrappedRpcFunction>;
+type ExtractRpcFunction<TFunction extends WrappedRpcFunction> = (payload: Parameters<TFunction>[0]["payload"]) => ReturnType<Asyncify<TFunction>>;
+type ExtractRpcFunctions<TFunctions extends WrappedRpcFunctions> = { [TKey in keyof TFunctions]: ExtractRpcFunction<TFunctions[TKey]> };
+type WrapRpcFunction<TFunction extends RpcFunction> = (envelop: RpcPayloadEnvelop<Parameters<TFunction>[0]>) => ReturnType<TFunction> extends Promise<infer A> ? A : ReturnType<TFunction>;
+type WrapRpcFunctions<TFunctions extends RpcFunctions> = { [TKey in keyof TFunctions]: WrapRpcFunction<TFunctions[TKey]> };
+type RpcClientRemoteFunctions<TFunctions extends WrappedRpcFunctions> = ProxifiedRemoteFunctions<ExtractRpcFunctions<TFunctions>>;
+/**
+ * Payload for write log Rpc messages.
+ */
+interface LogPayload {
+  /**
+   * Metadata associated with the log message, excluding fields that are automatically added by the engine such as executionId, configIndex, environment, and timestamp. This can include custom fields relevant to the log entry, such as category, name, command, hook, plugin, and source.
+   */
+  meta: LogMeta;
+  /**
+   * The log message content, which can be a string or an array of strings representing the log entry. This field is required and should contain the actual message to be logged.
+   */
+  message: string;
+}
+interface RpcServerFunctions extends DevToolsRpcServerFunctions {
+  "powerlines:log": (payload: LogPayload) => void;
+}
+interface RpcClientFunctions extends DevToolsRpcClientFunctions {}
+interface RpcContext {
+  /**
+   * The Rpc client to interact with the server
+   */
+  readonly rpc: RpcClient;
+}
+type RpcClientHost = RpcFunctionsCollector<RpcClientFunctions, RpcContext>;
+type RpcClientCall = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$call"];
+type RpcClientCallEvent = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$callEvent"];
+type RpcClientCallOptional = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$callOptional"];
+interface RpcClientEvents {
+  "rpc:is-trusted:updated": (isTrusted: boolean) => void;
+}
+interface RpcClient {
+  /**
+   * The events of the client
+   */
+  events: EventEmitter<RpcClientEvents>;
+  /**
+   * Whether the client is trusted
+   */
+  readonly isTrusted: boolean | null;
+  /**
+   * The connection meta
+   */
+  readonly connectionMeta: ConnectionMeta;
+  /**
+   * Return a promise that resolves when the client is trusted
+   *
+   * Rejects with an error if the timeout is reached
+   *
+   * @param timeout - The timeout in milliseconds, default to 60 seconds
+   */
+  ensureTrusted: (timeout?: number) => Promise<boolean>;
+  /**
+   * Request trust from the server
+   */
+  requestTrust: () => Promise<boolean>;
+  /**
+   * Request trust from the server using a specific auth token.
+   * Updates the stored token and re-requests trust without reloading the page.
+   */
+  requestTrustWithToken: (token: string) => Promise<boolean>;
+  /**
+   * Call a Rpc function on the server
+   */
+  call: RpcClientCall;
+  /**
+   * Call a Rpc event on the server, and does not expect a response
+   */
+  callEvent: RpcClientCallEvent;
+  /**
+   * Call a Rpc optional function on the server
+   */
+  callOptional: RpcClientCallOptional;
+  /**
+   * The client Rpc host
+   */
+  client: RpcClientHost;
+  /**
+   * The shared state host
+   */
+  sharedState: RpcSharedStateHost;
+  /**
+   * The streaming channel host. Subscribe to a server-side stream by
+   * channel + id; the returned reader is both `AsyncIterable<T>` and
+   * exposes `.readable: ReadableStream<T>` for `pipeTo` consumption.
+   */
+  streaming: RpcStreamingClientHost;
+  /**
+   * The Rpc cache manager
+   */
+  cacheManager: RpcCacheManager;
+}
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * The options required to start the Powerlines engine.
+ */
+type EngineOptions = Omit<PartialKeys<DevframeDefinition, "name" | "setup">, "id" | "basePath"> & Options & {
+  /**
+   * The host URL for the engine's WebSocket server, which is used for communication between the engine and the various hosts (e.g., dev server, CLI, etc.) that interact with it. This value is required for the engine to function properly, as it allows the engine to establish a WebSocket connection and facilitate communication with other components of the system.
+   */
+  host?: string;
+  /**
+   * The port number to use for the websocket connection between the engine and the various hosts.
+   */
+  port?: number;
+  /**
+   * A custom logger instance that implements the {@link CustomLogger} interface, which can be used for logging messages during the build process instead of the default Powerlines logger.
+   *
+   * @remarks
+   * Providing a custom logger allows you to integrate Powerlines logging with your own logging system or to customize the logging behavior, such as formatting log messages differently or sending logs to an external service. If a custom logger is not provided, Powerlines will use its default logger implementation.
+   */
+  customLogger?: CustomLogger;
+  /**
+   * The framework for which the engine is being used, which can be used by plugins to customize their behavior based on the specific framework being targeted. This value is optional and can be set to `undefined` if not applicable, but providing it allows plugins to make informed decisions about how to handle certain tasks or configurations based on the framework being used.
+   */
+  framework?: FrameworkOptions;
+};
+interface EngineExecutionOptions extends ExecutionOptions {
+  /**
+   * The base URL for the dev server, which can be used by plugins to construct URLs for assets or API endpoints during development. This value is only relevant in "dev" mode and will be `undefined` in "build" mode.
+   */
+  baseURL: string;
+  /**
+   * Metadata for the connection used by the dev server, including the backend type and websocket configuration.
+   */
+  connection: ConnectionMeta;
+  /**
+   * Options for configuring the WebSocket RPC channel used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the WebSocket connection, such as setting custom timeouts, retry strategies, or other options.
+   */
+  wsOptions?: Partial<WsRpcChannelOptions>;
+  /**
+   * Options for configuring the RPC client used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the RPC client, such as setting custom timeouts, retry strategies, or other options.
+   */
+  rpcOptions?: Partial<BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>>;
+  /**
+   * Options for configuring the RPC cache used for caching RPC responses between the dev server and the client, which can be used by plugins to customize the behavior of the RPC cache, such as setting custom cache keys, expiration times, or other options.
+   *
+   * @remarks
+   * This option can be set to `true` to enable caching with default options, or it can be set to a configuration object that allows for fine-grained control over the caching behavior.
+   */
+  cacheOptions?: boolean | Partial<RpcCacheOptions>;
+}
+type RpcClientOptions = RequiredKeys<EngineExecutionOptions, "baseURL" | "connection">;
+type EngineResolvedConfig<TUserConfig extends UserConfig = UserConfig> = ResolvedConfig<TUserConfig, EngineExecutionOptions>;
+//#endregion
+export { RpcServerFunctions as C, WrappedRpcFunctions as D, WrappedRpcFunction as E, RpcPayloadMetadata as S, WrapRpcFunctions as T, RpcClientRemoteFunctions as _, ExtractRpcFunction as a, RpcFunctions as b, InputRpcFunctions as c, RpcClientCall as d, RpcClientCallEvent as f, RpcClientHost as g, RpcClientFunctions as h, RpcClientOptions as i, LogPayload as l, RpcClientEvents as m, EngineOptions as n, ExtractRpcFunctions as o, RpcClientCallOptional as p, EngineResolvedConfig as r, InputRpcFunction as s, EngineExecutionOptions as t, RpcClient as u, RpcContext as v, WrapRpcFunction as w, RpcPayloadEnvelop as x, RpcFunction as y };
+//# sourceMappingURL=config-FB8Zqjjz.d.mts.map

package/dist/config-FB8Zqjjz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-FB8Zqjjz.d.mts","names":[],"sources":["../src/types/rpc.ts","../src/types/config.ts"],"mappings":"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"}

package/dist/context/index.cjs

@@ -1,11 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_base_context = require('../base-context-CFvO2N9I.cjs');
-const require_engine_context = require('../engine-context-NO6enYev.cjs');
-const require_execution_context = require('../execution-context-CyDSAifN.cjs');
+const require_engine_context = require('../engine-context-SEzTm1aq.cjs');
 
-exports.PowerlinesBaseContext = require_base_context.PowerlinesBaseContext;
-exports.PowerlinesContext = require_execution_context.PowerlinesContext;
-exports.PowerlinesEngineContext = require_engine_context.PowerlinesEngineContext;
-exports.PowerlinesEnvironmentContext = require_execution_context.PowerlinesEnvironmentContext;
-exports.PowerlinesExecutionContext = require_execution_context.PowerlinesExecutionContext;
-exports.createPluginContext = require_execution_context.createPluginContext;
+exports.PowerlinesEngineContext = require_engine_context.PowerlinesEngineContext;