@powerlines/engine 0.47.3 → 0.49.1

package/dist/config-DKEmqMrh.d.cts

@@ -0,0 +1,204 @@
+import { CustomLogger, ExecutionOptions, FrameworkOptions, LogMeta, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
+import { MaybePromise, PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { BirpcOptions, BirpcReturn, ProxifiedRemoteFunctions } from "birpc";
+import { RpcCacheManager, RpcCacheOptions, RpcFunctionsCollector } from "devframe/rpc";
+import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
+import { ConnectionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevframeDefinition, EventEmitter, RpcSharedStateHost } from "devframe/types";
+import { Asyncify } from "@stryke/types/async";
+import { RpcStreamingClientHost } from "devframe/client";
+
+//#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;
+  /**
+   * An optional root directory for the engine to use when resolving paths and loading configuration files. This value can be used to specify a custom root directory for the engine, which can be useful in cases where the default behavior of using the current working directory is not desirable. If this option is not provided, the engine will use the current working directory as the root directory by default.
+   */
+  root?: string;
+  /**
+   * 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-DKEmqMrh.d.cts.map

package/dist/config-DKEmqMrh.d.cts.map

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

package/dist/context/engine-context.cjs

@@ -0,0 +1,177 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-C_NdSu1c.cjs');
+let _powerlines_core_plugin_utils = require("@powerlines/core/plugin-utils");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_unique_id_uuid = require("@stryke/unique-id/uuid");
+let devframe_node = require("devframe/node");
+let _powerlines_core_lib_config = require("@powerlines/core/lib/config");
+let _powerlines_core_context_base_context = require("@powerlines/core/context/base-context");
+let _stryke_env_get_env_paths = require("@stryke/env/get-env-paths");
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let valibot = require("valibot");
+valibot = require_chunk.__toESM(valibot, 1);
+
+//#region src/context/engine-context.ts
+var PowerlinesEngineContext = class PowerlinesEngineContext extends _powerlines_core_context_base_context.PowerlinesBaseContext {
+	options;
+	connection;
+	#executions = [];
+	#devtools;
+	#logLevel;
+	/**
+	* Creates a new instance of the PowerlinesEngineContext class.
+	*
+	* @param options - The options to initialize the context with.
+	* @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
+	*/
+	static async from(options, host, connection) {
+		const context = new PowerlinesEngineContext(options, connection);
+		context.#devtools = await (0, devframe_node.createHostContext)({
+			cwd: context.cwd,
+			mode: "dev",
+			host
+		});
+		await options.setup?.(context.#devtools);
+		context.#devtools.rpc.register({
+			name: "powerlines:log",
+			type: "event",
+			args: [valibot.object({
+				meta: valibot.object({
+					category: valibot.string(),
+					name: valibot.string(),
+					command: valibot.string(),
+					hook: valibot.string(),
+					plugin: valibot.string(),
+					source: valibot.string()
+				}),
+				message: valibot.string()
+			})],
+			setup: (_) => ({ handler: (payload) => {
+				switch (payload.meta.type) {
+					case "error":
+						context.error(payload);
+						break;
+					case "warn":
+						context.warn(payload);
+						break;
+					case "info":
+						context.info(payload);
+						break;
+					case "debug":
+						context.debug(payload);
+						break;
+					case "trace":
+						context.trace(payload);
+						break;
+					default:
+						context.info(payload);
+						break;
+				}
+			} })
+		});
+		context.#logLevel = options.logLevel ? (0, _powerlines_core_plugin_utils.resolveLogLevel)(options.logLevel) : await (0, _powerlines_core_lib_config.getDefaultLogLevel)(context.cwd);
+		return context;
+	}
+	createLogger(options = {}, logFn) {
+		let logger = (0, _powerlines_core_plugin_utils.createLogger)("engine", {
+			logLevel: this.#logLevel,
+			...options
+		}, logFn);
+		if (this.options.customLogger) logger = (0, _powerlines_core_plugin_utils.withCustomLogger)(logger, this.options.customLogger);
+		return logger;
+	}
+	get executions() {
+		return this.#executions;
+	}
+	get devtools() {
+		return this.#devtools;
+	}
+	get envPaths() {
+		return (0, _stryke_env_get_env_paths.getEnvPaths)({
+			orgId: (0, _stryke_string_format_kebab_case.kebabCase)(this.orgId),
+			appId: (0, _stryke_string_format_kebab_case.kebabCase)(this.framework.name),
+			workspaceRoot: this.cwd
+		});
+	}
+	get framework() {
+		return {
+			name: "powerlines",
+			orgId: "storm-software",
+			...this.options.framework
+		};
+	}
+	get orgId() {
+		return this.framework.orgId;
+	}
+	/**
+	* Creates a new Context instance.
+	*
+	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+	* @param connection - The connection metadata for the dev server.
+	*/
+	constructor(options, connection) {
+		super(options);
+		this.options = options;
+		this.connection = connection;
+	}
+	/**
+	* Initialize the context with the provided configuration options
+	*
+	* @remarks
+	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+	*
+	* @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.
+	* @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.
+	*/
+	async loadExecutions(method, inlineConfig) {
+		const root = (0, _powerlines_core_lib_config.resolveRoot)(this.cwd, inlineConfig.root, inlineConfig.configFile);
+		const config = await (0, _powerlines_core_lib_config.loadParsedConfig)(this.cwd, root, this.framework?.name, this.orgId, inlineConfig);
+		if (!config) throw new Error("Failed to load configuration");
+		const invocationId = (0, _stryke_unique_id_uuid.uuid)();
+		const executions = await Promise.all((0, _stryke_convert_to_array.toArray)(config.config).map(async (_, configIndex) => {
+			const executionId = (0, _stryke_unique_id_uuid.uuid)();
+			const options = {
+				cwd: this.cwd,
+				root,
+				framework: this.framework,
+				orgId: this.orgId,
+				...this.options,
+				command: method,
+				baseURL: this.#devtools.host.resolveOrigin(),
+				connection: this.connection,
+				configFile: config.configFile,
+				executionId,
+				configIndex
+			};
+			this.logger.debug({
+				meta: { category: "config" },
+				message: `Invoking ${method} with the following execution parameters: \n --- Options --- \n${(0, _powerlines_core_plugin_utils.formatConfig)(options)}\n --- Inline Config --- \n${(0, _powerlines_core_plugin_utils.formatConfig)(inlineConfig)}`
+			});
+			return {
+				invocationId,
+				method,
+				configFile: config,
+				options,
+				state: {
+					command: null,
+					hook: null,
+					plugin: null
+				}
+			};
+		}));
+		this.#executions = this.#executions.concat(executions);
+		return executions;
+	}
+	/**
+	* Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+	*
+	* @param invocationId - The unique identifier for the invocation of the execution to be completed.
+	* @param executionId - The unique identifier for the specific execution to be completed.
+	*/
+	completeExecution(invocationId, executionId) {
+		this.#executions = this.#executions.filter((execution) => execution.options.executionId !== executionId || execution.invocationId !== invocationId);
+	}
+};
+
+//#endregion
+exports.PowerlinesEngineContext = PowerlinesEngineContext;

package/dist/context/engine-context.d.cts

@@ -0,0 +1,2 @@
+import { t as PowerlinesEngineContext } from "../engine-context-B8K6Jtkk.cjs";
+export { PowerlinesEngineContext };

package/dist/context/engine-context.d.mts

@@ -0,0 +1,2 @@
+import { t as PowerlinesEngineContext } from "../engine-context-DKlA5Pgu.mjs";
+export { PowerlinesEngineContext };

package/dist/context/engine-context.mjs

@@ -0,0 +1,175 @@
+import { createLogger, formatConfig, resolveLogLevel, withCustomLogger } from "@powerlines/core/plugin-utils";
+import { toArray } from "@stryke/convert/to-array";
+import { uuid } from "@stryke/unique-id/uuid";
+import { createHostContext } from "devframe/node";
+import { getDefaultLogLevel, loadParsedConfig, resolveRoot } from "@powerlines/core/lib/config";
+import { PowerlinesBaseContext } from "@powerlines/core/context/base-context";
+import { getEnvPaths } from "@stryke/env/get-env-paths";
+import { kebabCase } from "@stryke/string-format/kebab-case";
+import * as v from "valibot";
+
+//#region src/context/engine-context.ts
+var PowerlinesEngineContext = class PowerlinesEngineContext extends PowerlinesBaseContext {
+	options;
+	connection;
+	#executions = [];
+	#devtools;
+	#logLevel;
+	/**
+	* Creates a new instance of the PowerlinesEngineContext class.
+	*
+	* @param options - The options to initialize the context with.
+	* @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
+	*/
+	static async from(options, host, connection) {
+		const context = new PowerlinesEngineContext(options, connection);
+		context.#devtools = await createHostContext({
+			cwd: context.cwd,
+			mode: "dev",
+			host
+		});
+		await options.setup?.(context.#devtools);
+		context.#devtools.rpc.register({
+			name: "powerlines:log",
+			type: "event",
+			args: [v.object({
+				meta: v.object({
+					category: v.string(),
+					name: v.string(),
+					command: v.string(),
+					hook: v.string(),
+					plugin: v.string(),
+					source: v.string()
+				}),
+				message: v.string()
+			})],
+			setup: (_) => ({ handler: (payload) => {
+				switch (payload.meta.type) {
+					case "error":
+						context.error(payload);
+						break;
+					case "warn":
+						context.warn(payload);
+						break;
+					case "info":
+						context.info(payload);
+						break;
+					case "debug":
+						context.debug(payload);
+						break;
+					case "trace":
+						context.trace(payload);
+						break;
+					default:
+						context.info(payload);
+						break;
+				}
+			} })
+		});
+		context.#logLevel = options.logLevel ? resolveLogLevel(options.logLevel) : await getDefaultLogLevel(context.cwd);
+		return context;
+	}
+	createLogger(options = {}, logFn) {
+		let logger = createLogger("engine", {
+			logLevel: this.#logLevel,
+			...options
+		}, logFn);
+		if (this.options.customLogger) logger = withCustomLogger(logger, this.options.customLogger);
+		return logger;
+	}
+	get executions() {
+		return this.#executions;
+	}
+	get devtools() {
+		return this.#devtools;
+	}
+	get envPaths() {
+		return getEnvPaths({
+			orgId: kebabCase(this.orgId),
+			appId: kebabCase(this.framework.name),
+			workspaceRoot: this.cwd
+		});
+	}
+	get framework() {
+		return {
+			name: "powerlines",
+			orgId: "storm-software",
+			...this.options.framework
+		};
+	}
+	get orgId() {
+		return this.framework.orgId;
+	}
+	/**
+	* Creates a new Context instance.
+	*
+	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+	* @param connection - The connection metadata for the dev server.
+	*/
+	constructor(options, connection) {
+		super(options);
+		this.options = options;
+		this.connection = connection;
+	}
+	/**
+	* Initialize the context with the provided configuration options
+	*
+	* @remarks
+	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+	*
+	* @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.
+	* @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.
+	*/
+	async loadExecutions(method, inlineConfig) {
+		const root = resolveRoot(this.cwd, inlineConfig.root, inlineConfig.configFile);
+		const config = await loadParsedConfig(this.cwd, root, this.framework?.name, this.orgId, inlineConfig);
+		if (!config) throw new Error("Failed to load configuration");
+		const invocationId = uuid();
+		const executions = await Promise.all(toArray(config.config).map(async (_, configIndex) => {
+			const executionId = uuid();
+			const options = {
+				cwd: this.cwd,
+				root,
+				framework: this.framework,
+				orgId: this.orgId,
+				...this.options,
+				command: method,
+				baseURL: this.#devtools.host.resolveOrigin(),
+				connection: this.connection,
+				configFile: config.configFile,
+				executionId,
+				configIndex
+			};
+			this.logger.debug({
+				meta: { category: "config" },
+				message: `Invoking ${method} with the following execution parameters: \n --- Options --- \n${formatConfig(options)}\n --- Inline Config --- \n${formatConfig(inlineConfig)}`
+			});
+			return {
+				invocationId,
+				method,
+				configFile: config,
+				options,
+				state: {
+					command: null,
+					hook: null,
+					plugin: null
+				}
+			};
+		}));
+		this.#executions = this.#executions.concat(executions);
+		return executions;
+	}
+	/**
+	* Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+	*
+	* @param invocationId - The unique identifier for the invocation of the execution to be completed.
+	* @param executionId - The unique identifier for the specific execution to be completed.
+	*/
+	completeExecution(invocationId, executionId) {
+		this.#executions = this.#executions.filter((execution) => execution.options.executionId !== executionId || execution.invocationId !== invocationId);
+	}
+};
+
+//#endregion
+export { PowerlinesEngineContext };
+//# sourceMappingURL=engine-context.mjs.map

package/dist/context/engine-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context.mjs","names":["#devtools","#logLevel","#executions"],"sources":["../../src/context/engine-context.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 type {\n  FrameworkOptions,\n  InlineConfig,\n  LogFn,\n  LoggerOptions,\n  LogLevelResolvedConfig\n} from \"@powerlines/core\";\nimport { PowerlinesBaseContext } from \"@powerlines/core/context/base-context\";\nimport {\n  getDefaultLogLevel,\n  loadParsedConfig,\n  resolveRoot\n} from \"@powerlines/core/lib/config\";\nimport {\n  createLogger,\n  formatConfig,\n  resolveLogLevel,\n  withCustomLogger\n} from \"@powerlines/core/plugin-utils\";\nimport { toArray } from \"@stryke/convert/to-array\";\nimport { EnvPaths, getEnvPaths } from \"@stryke/env/get-env-paths\";\nimport { kebabCase } from \"@stryke/string-format/kebab-case\";\nimport { uuid } from \"@stryke/unique-id/uuid\";\nimport { createHostContext } from \"devframe/node\";\nimport {\n  ConnectionMeta,\n  DevToolsHost,\n  DevToolsNodeContext\n} from \"devframe/types\";\nimport * as v from \"valibot\";\nimport { EngineOptions } from \"../types/config\";\nimport { EngineContext, EngineExecutionItem } from \"../types/context\";\n\nexport class PowerlinesEngineContext<TSystemContext = unknown>\n  extends PowerlinesBaseContext<TSystemContext>\n  implements EngineContext<TSystemContext>\n{\n  #executions: EngineExecutionItem[] = [];\n\n  #devtools!: DevToolsNodeContext;\n\n  #logLevel!: LogLevelResolvedConfig;\n\n  /**\n   * Creates a new instance of the PowerlinesEngineContext class.\n   *\n   * @param options - The options to initialize the context with.\n   * @returns A promise that resolves to an instance of the PowerlinesEngineContext class.\n   */\n  public static async from<TSystemContext = unknown>(\n    options: EngineOptions,\n    host: DevToolsHost,\n    connection: ConnectionMeta\n  ): Promise<PowerlinesEngineContext<TSystemContext>> {\n    const context = new PowerlinesEngineContext<TSystemContext>(\n      options,\n      connection\n    );\n\n    context.#devtools = await createHostContext({\n      cwd: context.cwd,\n      mode: \"dev\",\n      host\n    });\n    await options.setup?.(context.#devtools);\n\n    context.#devtools.rpc.register({\n      name: \"powerlines:log\",\n      type: \"event\",\n      args: [\n        v.object({\n          meta: v.object({\n            category: v.string(),\n            name: v.string(),\n            command: v.string(),\n            hook: v.string(),\n            plugin: v.string(),\n            source: v.string()\n          }),\n          message: v.string()\n        })\n      ],\n      setup: _ => ({\n        handler: payload => {\n          switch (payload.meta.type) {\n            case \"error\":\n              context.error(payload);\n              break;\n            case \"warn\":\n              context.warn(payload);\n              break;\n            case \"info\":\n              context.info(payload);\n              break;\n            case \"debug\":\n              context.debug(payload);\n              break;\n            case \"trace\":\n              context.trace(payload);\n              break;\n            default:\n              context.info(payload);\n              break;\n          }\n        }\n      })\n    });\n\n    context.#logLevel = options.logLevel\n      ? resolveLogLevel(options.logLevel)\n      : await getDefaultLogLevel(context.cwd);\n\n    return context;\n  }\n\n  public override createLogger(options: LoggerOptions = {}, logFn?: LogFn) {\n    let logger = createLogger(\n      \"engine\",\n      {\n        logLevel: this.#logLevel,\n        ...options\n      },\n      logFn\n    );\n    if (this.options.customLogger) {\n      logger = withCustomLogger(logger, this.options.customLogger);\n    }\n    return logger;\n  }\n\n  public get executions(): EngineExecutionItem[] {\n    return this.#executions;\n  }\n\n  public get devtools(): DevToolsNodeContext {\n    return this.#devtools;\n  }\n\n  public get envPaths(): EnvPaths {\n    return getEnvPaths({\n      orgId: kebabCase(this.orgId),\n      appId: kebabCase(this.framework.name),\n      workspaceRoot: this.cwd\n    });\n  }\n\n  public get framework(): FrameworkOptions {\n    return {\n      name: \"powerlines\",\n      orgId: \"storm-software\",\n      ...this.options.framework\n    };\n  }\n\n  public get orgId(): string {\n    return this.framework.orgId;\n  }\n\n  /**\n   * Creates a new Context instance.\n   *\n   * @param options - The options to use for creating the context, including the resolved configuration and workspace settings.\n   * @param connection - The connection metadata for the dev server.\n   */\n  protected constructor(\n    public override options: EngineOptions,\n    public connection: ConnectionMeta\n  ) {\n    super(options);\n  }\n\n  /**\n   * Initialize the context with the provided configuration options\n   *\n   * @remarks\n   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.\n   *\n   * @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.\n   * @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.\n   */\n  public async loadExecutions(\n    method: string,\n    inlineConfig: InlineConfig\n  ): Promise<EngineExecutionItem[]> {\n    const root = resolveRoot(\n      this.cwd,\n      inlineConfig.root,\n      inlineConfig.configFile\n    );\n\n    const config = await loadParsedConfig(\n      this.cwd,\n      root,\n      this.framework?.name,\n      this.orgId,\n      inlineConfig\n    );\n    if (!config) {\n      throw new Error(\"Failed to load configuration\");\n    }\n\n    const invocationId = uuid();\n    const executions = await Promise.all(\n      toArray(config.config).map(async (_, configIndex) => {\n        const executionId = uuid();\n        const options = {\n          cwd: this.cwd,\n          root,\n          framework: this.framework,\n          orgId: this.orgId,\n          ...this.options,\n          command: method,\n          baseURL: this.#devtools.host.resolveOrigin(),\n          connection: this.connection,\n          configFile: config.configFile!,\n          executionId,\n          configIndex\n        };\n\n        this.logger.debug({\n          meta: { category: \"config\" },\n          message: `Invoking ${method} with the following execution parameters: \\n --- Options --- \\n${formatConfig(\n            options\n          )}\\n --- Inline Config --- \\n${formatConfig(inlineConfig)}`\n        });\n\n        return {\n          invocationId,\n          method,\n          configFile: config,\n          options,\n          state: {\n            command: null,\n            hook: null,\n            plugin: null\n          }\n        };\n      })\n    );\n\n    this.#executions = this.#executions.concat(executions);\n\n    return executions;\n  }\n\n  /**\n   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.\n   *\n   * @param invocationId - The unique identifier for the invocation of the execution to be completed.\n   * @param executionId - The unique identifier for the specific execution to be completed.\n   */\n  public completeExecution(invocationId: string, executionId: string) {\n    this.#executions = this.#executions.filter(\n      execution =>\n        execution.options.executionId !== executionId ||\n        execution.invocationId !== invocationId\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/context/index.cjs

@@ -1,11 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_execution_context = require('../execution-context-CnyaM3Ul.cjs');
-const require_base_context = require('../base-context-DLemGRbd.cjs');
-const require_engine_context = require('../engine-context-D0y88i_J.cjs');
+const require_context_engine_context = require('./engine-context.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_context_engine_context.PowerlinesEngineContext;