@power-plant/core 0.0.26 → 0.0.28

package/dist/execute-3oK9lgh3.cjs

@@ -0,0 +1,501 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_context = require('./context.cjs');
+const require_helpers_type_checks = require('./helpers/type-checks.cjs');
+const require_helpers_meta = require('./helpers/meta.cjs');
+let _stryke_unique_id_uuid = require("@stryke/unique-id/uuid");
+let _stryke_env_get_env_paths = require("@stryke/env/get-env-paths");
+let _stryke_fs_read_file = require("@stryke/fs/read-file");
+let _stryke_fs_write_file = require("@stryke/fs/write-file");
+let _stryke_path_join_paths = require("@stryke/path/join-paths");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let defu = require("defu");
+defu = __toESM(defu, 1);
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+let unstorage = require("unstorage");
+let unstorage_drivers_fs_lite = require("unstorage/drivers/fs-lite");
+unstorage_drivers_fs_lite = __toESM(unstorage_drivers_fs_lite, 1);
+let _power_plant_schema_storage = require("@power-plant/schema/storage");
+let _stryke_resolve_load = require("@stryke/resolve/load");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let _power_plant_schema = require("@power-plant/schema");
+let _stryke_resolve_type_checks = require("@stryke/resolve/type-checks");
+
+//#region src/lib/context.ts
+const logger = {
+	debug: console.debug,
+	info: console.info,
+	warn: console.warn,
+	error: console.error
+};
+const paths = (0, _stryke_env_get_env_paths.getEnvPaths)({
+	appId: "power-plant",
+	orgId: "storm-software"
+});
+/**
+* Create a session context for the engine.
+*
+* @param session - The session for the context.
+* @param userConfig - The user configuration.
+* @returns A session context.
+*/
+async function createSessionContext(userConfig = {}) {
+	const cwd = userConfig.cwd || process.cwd();
+	const now = /* @__PURE__ */ new Date();
+	const storage = (0, unstorage.createStorage)({ driver: (0, unstorage_drivers_fs_lite.default)({ base: cwd }) });
+	const store = JSON.parse(await (0, _stryke_fs_read_file.readFileIfExisting)((0, _stryke_path_join_paths.joinPaths)(paths.data, ".local-store.json")) || "{}");
+	const device = store.device || node_os.default.hostname() || (0, _stryke_unique_id_uuid.uuid)();
+	const user = store.user || node_os.default.userInfo().username || (0, _stryke_unique_id_uuid.uuid)();
+	if (!(0, _stryke_type_checks_is_set_string.isSetString)(store.device) || !(0, _stryke_type_checks_is_set_string.isSetString)(store.user)) await (0, _stryke_fs_write_file.writeFile)((0, _stryke_path_join_paths.joinPaths)(paths.data, ".local-store.json"), JSON.stringify({
+		device,
+		user
+	}, null, 2));
+	return (0, defu.default)({
+		cwd,
+		session: {
+			id: (0, _stryke_unique_id_uuid.uuid)(),
+			createdAt: now,
+			updatedAt: now,
+			device,
+			user,
+			executions: []
+		}
+	}, userConfig, {
+		storage,
+		settings: {},
+		logger
+	});
+}
+/**
+* Create an execution context for the engine.
+*
+* @param executionId - The ID of the execution.
+* @param sessionContext - The session context.
+* @param options - The options.
+* @param schema - The schema.
+* @param input - The input.
+* @param output - The output.
+* @returns A promise that resolves to an execution context.
+*/
+async function createExecutionContext(executionId, sessionContext, options, schema, input, output) {
+	const documents = {};
+	const addDocument = (pathOrDocument, document) => {
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(pathOrDocument)) documents[pathOrDocument] = (0, defu.default)({ path: pathOrDocument }, document, {
+			chunks: [],
+			meta: {}
+		});
+		else documents[pathOrDocument.path] = (0, defu.default)(pathOrDocument, document);
+	};
+	let specValue;
+	const context = {
+		...sessionContext,
+		id: executionId,
+		createdAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date(),
+		options,
+		schema,
+		input,
+		output,
+		documents,
+		spec() {
+			if (!specValue) throw new Error("The specification was accessed prior to the input processing.");
+			return specValue;
+		},
+		addDocument,
+		meta: {
+			id: executionId,
+			executedAt: /* @__PURE__ */ new Date(),
+			executedBy: ""
+		}
+	};
+	Object.defineProperty(context, "~spec", {
+		get() {
+			return specValue;
+		},
+		set(value) {
+			specValue = value;
+		},
+		enumerable: false
+	});
+	return context;
+}
+
+//#endregion
+//#region src/lib/extract.ts
+async function extractExecution(execution, _spec, _options) {
+	return execution;
+}
+
+//#endregion
+//#region src/lib/schema.ts
+/**
+* Extracts and normalizes {@link SchemaMetaConfig | schema metadata} from a given {@link SchemaMetaConfig}. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema from which to extract metadata.
+* @param input - The schema metadata input to extract and normalize.
+* @returns The normalized schema metadata.
+*/
+function extractSchemaMeta(schema, input) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = require_helpers_meta.resolveMeta(schema, input);
+	meta.description = require_helpers_meta.resolveMetaDescription(`Accepts a ${meta.title ?? ""} specification and processes it with a {title} sink.`, jsonSchema, meta, input?.description);
+	meta.examples = require_helpers_meta.resolveMetaExample(jsonSchema, meta, input?.examples);
+	return meta;
+}
+/**
+* Normalizes any accepted schema input into a concrete schema descriptor.
+*
+* @param input - The schema input to normalize.
+* @param options - Optional options for resolving the schema input.
+* @returns A promise that resolves to a normalized schema descriptor.
+*/
+async function createSchema(input, options = {}) {
+	const { meta, schema } = require_helpers_type_checks.isSchemaConfigObject(input) ? input : {
+		schema: input,
+		meta: {}
+	};
+	const resolvedSchema = await (0, _power_plant_schema.extractSchemaWithSource)(schema, options);
+	return {
+		...resolvedSchema,
+		meta: extractSchemaMeta(resolvedSchema, meta)
+	};
+}
+/**
+* Ensures resolved input/output schema overrides do not contradict the generator schema.
+*
+* @param baseSchema - The resolved generator schema.
+* @param input - The resolved generator input descriptor.
+* @param output - The resolved generator output descriptor.
+*/
+function assertGeneratorConfigSchemasDoNotContradict(baseSchema, input, output) {
+	if (input && input.schema !== baseSchema) (0, _power_plant_schema.assertSchemasDoNotContradict)(baseSchema.schema, input.schema.schema, "input");
+	if (output && output.schema !== baseSchema) (0, _power_plant_schema.assertSchemasDoNotContradict)(baseSchema.schema, output.schema.schema, "output");
+}
+
+//#endregion
+//#region src/lib/input.ts
+/**
+* Extracts and normalizes input metadata from a given configuration. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema that the input input is expected to conform to.
+* @param input - The input metadata input to extract and normalize.
+* @returns The normalized input metadata.
+*/
+function extractInputMeta(schema, input) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = require_helpers_meta.resolveMeta(schema, input);
+	meta.description = require_helpers_meta.resolveMetaDescription(`Determines the ${meta.title ?? ""} specification from a {title} input.`, jsonSchema, meta, input?.description);
+	return meta;
+}
+/**
+* Normalizes any accepted input configuration into a concrete input descriptor.
+*
+* @param schema - The schema that the specification is expected to conform to.
+* @param config - The input configuration to normalize.
+* @param options - Optional options for resolving the input configuration.
+* @returns A promise that resolves to a normalized input descriptor.
+*/
+async function createInput(schema, config, options = {}) {
+	const { input, meta, schema: inputSchema } = require_helpers_type_checks.isInputConfigObject(config) ? config : {
+		input: config,
+		meta: {}
+	};
+	let resolvedSchema = schema;
+	if (inputSchema) {
+		let resolvedInputSchema;
+		if ((0, _stryke_resolve_type_checks.isLoadReference)(inputSchema)) try {
+			resolvedInputSchema = await (0, _stryke_resolve_load.load)(inputSchema, options);
+		} catch {}
+		else resolvedInputSchema = inputSchema;
+		if (resolvedInputSchema) {
+			resolvedSchema = await createSchema(resolvedInputSchema, options);
+			resolvedSchema.schema = (0, _power_plant_schema.mergeMetadata)(resolvedSchema.schema, schema.schema);
+		}
+	}
+	let resolvedInput;
+	if ((0, _stryke_resolve_type_checks.isLoadReference)(input)) try {
+		const loaded = await (0, _stryke_resolve_load.load)(input, options);
+		if (require_helpers_type_checks.isInputConfigObject(loaded)) resolvedInput = await createInput(resolvedSchema, loaded.input, options).then((s) => s.input);
+		else resolvedInput = loaded;
+	} catch {}
+	if (!resolvedInput) resolvedInput = input;
+	return {
+		schema: resolvedSchema,
+		input: resolvedInput,
+		meta: extractInputMeta(resolvedSchema, meta)
+	};
+}
+
+//#endregion
+//#region src/lib/output.ts
+/**
+* Extracts and normalizes output metadata from a given configuration. This function ensures that the metadata is in a consistent format, converting version numbers to strings and filtering out any invalid or empty tags.
+*
+* @param schema - The schema that the specification is expected to conform to.
+* @param config - The output metadata config to extract and normalize.
+* @returns The normalized output metadata.
+*/
+function extractOutputMeta(schema, config) {
+	const jsonSchema = schema?.schema ?? {};
+	const meta = require_helpers_meta.resolveMeta(schema, config);
+	meta.description = require_helpers_meta.resolveMetaDescription(`Accepts a ${meta.title ?? ""} specification and processes it with a {title} output.`, jsonSchema, meta, config?.description);
+	return meta;
+}
+/**
+* Normalizes any accepted output config into a concrete output descriptor.
+*
+* @param schema - The schema that the output config is expected to conform to.
+* @param config - The output config to normalize.
+* @param options - Optional options for resolving the output config.
+* @returns A promise that resolves to a normalized output descriptor.
+*/
+async function createOutput(schema, config, options = {}) {
+	const { output, meta, schema: configSchema } = require_helpers_type_checks.isOutputConfigObject(config) ? config : {
+		output: config,
+		meta: {}
+	};
+	let resolvedSchema = schema;
+	if (configSchema) {
+		let resolvedConfigSchema;
+		if ((0, _stryke_resolve_type_checks.isLoadReference)(configSchema)) try {
+			resolvedConfigSchema = await (0, _stryke_resolve_load.load)(configSchema, options);
+		} catch {}
+		else resolvedConfigSchema = configSchema;
+		if (resolvedConfigSchema) {
+			resolvedSchema = await createSchema(resolvedConfigSchema, options);
+			resolvedSchema.schema = (0, _power_plant_schema.mergeMetadata)(resolvedSchema.schema, schema.schema);
+		}
+	}
+	let resolvedOutput;
+	if ((0, _stryke_resolve_type_checks.isLoadReference)(output)) try {
+		const loaded = await (0, _stryke_resolve_load.load)(output, options);
+		if (require_helpers_type_checks.isOutputConfigObject(loaded)) resolvedOutput = await createOutput(resolvedSchema, loaded.output, options).then((s) => s.output);
+		else resolvedOutput = loaded;
+	} catch {}
+	if (!resolvedOutput) resolvedOutput = output;
+	return {
+		schema: resolvedSchema,
+		output: resolvedOutput,
+		meta: extractOutputMeta(resolvedSchema, meta)
+	};
+}
+
+//#endregion
+//#region src/lib/generator.ts
+/**
+* Creates a generator from raw schema/input/output configurations and resolves all descriptors.
+*
+* @remarks
+* This function is used to create a generator from raw schema, input, and output configurations. It resolves all descriptors and returns a fully constructed generator that can be used to generate output based on the provided schema and options.
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @param config - The generator configuration containing schema, input, output, and optional meta information.
+* @param options - Optional extraction options for schema, input, and output.
+* @returns A promise that resolves to a fully constructed generator.
+*/
+async function createGenerator(executionId, sessionContext, config, options = {}) {
+	let configObject;
+	if (require_helpers_type_checks.isGeneratorConfigObject(config)) configObject = config;
+	else configObject = await (0, _stryke_resolve_load.load)(config, {
+		fs: (0, _power_plant_schema_storage.mapStorageToFileSystem)(sessionContext.storage),
+		...options
+	});
+	if (!configObject.schema) configObject.schema = { type: "any" };
+	const schema = await createSchema(configObject.schema, {
+		storage: sessionContext.storage,
+		tsconfig: options.tsconfig,
+		...options
+	});
+	let inputConfig = configObject.input;
+	if (!inputConfig) if (options.inputPath) inputConfig = "@power-plant/unstorage-input";
+	else throw new Error("No input configuration provided. Please provide an input configuration, a valid specification, or a `inputPath` option that points to a valid input file.");
+	let outputConfig = configObject.output;
+	if (!outputConfig) outputConfig = "@power-plant/unstorage-output";
+	const [input, output] = await Promise.all([createInput(schema, inputConfig, {
+		storage: sessionContext.storage,
+		...options
+	}), createOutput(schema, outputConfig, {
+		storage: sessionContext.storage,
+		...options
+	})]);
+	assertGeneratorConfigSchemasDoNotContradict(schema, input, output);
+	const generator = async (options) => {
+		const context = await createExecutionContext(executionId, sessionContext, options, schema, input, output);
+		return require_context.callAsyncExecutionContext(context, async () => {
+			const spec = (0, _stryke_type_checks_is_function.isFunction)(input.input) ? await input.input({
+				storage: context.storage,
+				...options
+			}) : input.input;
+			context["~spec"] = spec;
+			let generatorFn;
+			if ((0, _stryke_type_checks_is_function.isFunction)(configObject.generator)) generatorFn = configObject.generator;
+			else generatorFn = await (0, _stryke_resolve_load.load)(configObject.generator, {
+				storage: context.storage,
+				...options
+			});
+			const documents = await generatorFn(spec, options);
+			return {
+				spec,
+				options,
+				documents,
+				returns: await output.output(spec, options, documents)
+			};
+		});
+	};
+	return {
+		meta: configObject.meta,
+		schema,
+		input,
+		output,
+		generator
+	};
+}
+
+//#endregion
+//#region src/execute.ts
+/**
+* Creates an execution function that can be used to execute a generator.
+*
+* @remarks
+* This function is used to create an execution function that can be used to execute a generator. It creates a new execution context and returns an execution function that can be used to execute the generator with the given configuration and options.
+*
+*
+* @example
+* ```ts
+* import { createExecute } from "@power-plant/core";
+*
+* // First, create an execution function with a custom configuration
+* const execute = await createExecute({
+*  ...
+* });
+*
+* // Then, execute the generator
+* const result = await execute("my-generator", {
+*  ...
+* });
+* ```
+*
+* @example
+* ```ts
+* import { createExecute } from "@power-plant/core";
+*
+* // First, create an execution function with a custom configuration
+* const execute = await createExecute({
+*  ...
+* });
+*
+* // Then, execute the generator
+* const result = await execute({
+*  generator: (spec, options) => { ... },
+*  ...
+* });
+* ```
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @template TReturns - The type of the returns that the generator will produce.
+* @param userConfig - The user configuration for the engine.
+* @returns A promise that resolves to an execution function.
+*/
+async function createExecute(userConfig = {}) {
+	const context = await createSessionContext(userConfig);
+	const execute = async (config, options = {}) => require_context.callAsyncSessionContext(context, async () => {
+		const executionId = (0, _stryke_unique_id_uuid.uuid)();
+		const { generator } = await createGenerator(executionId, context, config, options);
+		const { documents, returns, spec, options: returnedOptions } = await generator(options);
+		const execution = await extractExecution({
+			documents: Object.fromEntries(Object.entries(documents).map(([path, document]) => [path, {
+				...document,
+				path,
+				meta: { executionId }
+			}])),
+			meta: {
+				executionId,
+				executedAt: /* @__PURE__ */ new Date(),
+				executedBy: context.session.user
+			}
+		}, spec, returnedOptions);
+		context.session.executions.push(execution);
+		return returns;
+	});
+	return execute;
+}
+/**
+* Executes a generator with a given configuration and options.
+*
+* @remarks
+* This function is used to execute a generator with a given configuration and options. It creates a new execution context and returns an execution function that can be used to execute the generator with the given configuration and options.
+*
+* @example
+* ```ts
+* import { execute } from "@power-plant/core";
+*
+* // Create and execute the generator
+* const result = await execute("my-generator", {
+*  ...
+* });
+* ```
+*
+* @example
+* ```ts
+* import { execute } from "@power-plant/core";
+*
+* // Create and execute the generator
+* const result = await execute({
+*  generator: (spec, options) => { ... },
+* }, {
+*  ...
+* });
+* ```
+*
+* @template TSpec - The type of the specification that the generator will produce.
+* @template TOptions - The type of the options that will be passed to the generator during generation.
+* @template TReturns - The type of the returns that the generator will produce.
+* @param config - The configuration for the generator.
+* @param options - The options for the generator.
+* @returns A promise that resolves to the returns of the generator.
+*/
+async function execute(config, options = {}) {
+	return (await createExecute(options))(config, options);
+}
+
+//#endregion
+Object.defineProperty(exports, 'createExecute', {
+  enumerable: true,
+  get: function () {
+    return createExecute;
+  }
+});
+Object.defineProperty(exports, 'execute', {
+  enumerable: true,
+  get: function () {
+    return execute;
+  }
+});