@pumped-fn/core-next 0.5.62 → 0.5.64

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pumped-fn/core-next
 
+## 0.5.64
+
+### Patch Changes
+
+- [`d73cdd3`](https://github.com/pumped-fn/pumped-fn/commit/d73cdd3ef852d10e387daf76a36e68868346dd7a) Thanks [@lagz0ne](https://github.com/lagz0ne)! - fix: corrected pod behavior along with presets
+
+## 0.5.63
+
+### Patch Changes
+
+- [`f5bab28`](https://github.com/pumped-fn/pumped-fn/commit/f5bab28ba2b1e7fdb42f5f3eef55f39666c7f557) Thanks [@lagz0ne](https://github.com/lagz0ne)! - improved execute api of flow
+
 ## 0.5.62
 
 ### Patch Changes

package/dist/index.cjs

@@ -1195,6 +1195,9 @@ var Pod = class extends BaseScope {
 	*/
 	async resolve(executor, force) {
 		if (this.cache.has(executor)) return super.resolve(executor, force);
+		const replacer = this.initialValues.find((item) => item.executor === executor);
+		if (replacer) return await super.resolve(executor, force);
+		if (this["~hasDependencyWithPreset"](executor)) return await super.resolve(executor, force);
 		if (this.parentScope["cache"].has(executor)) {
 			const { value } = this.parentScope["cache"].get(executor);
 			const accessor$1 = super["~makeAccessor"](executor);
@@ -1208,13 +1211,28 @@ var Pod = class extends BaseScope {
 		}
 		return await super.resolve(executor, force);
 	}
+	"~hasDependencyWithPreset"(executor) {
+		if (!executor.dependencies) return false;
+		const checkDependency = (dep) => {
+			const actualExecutor = getExecutor(dep);
+			const hasPreset = this.initialValues.some((item) => item.executor === actualExecutor);
+			if (hasPreset) return true;
+			if (actualExecutor.dependencies) return this["~hasDependencyWithPreset"](actualExecutor);
+			return false;
+		};
+		const deps = executor.dependencies;
+		if (Array.isArray(deps)) return deps.some(checkDependency);
+		else if (typeof deps === "object" && deps !== null) return Object.values(deps).some(checkDependency);
+		else return checkDependency(deps);
+	}
 	async "~resolveExecutor"(ie, ref) {
 		if (isReactiveExecutor(ie)) throw new Error("Reactive executors cannot be used in pod");
 		const t = getExecutor(ie);
 		this["~checkCircularDependency"](t, ref);
 		this["~propagateResolutionChain"](ref, t);
 		const a = this["~makeAccessor"](t);
-		if (this.parentScope["cache"].has(t)) {
+		const replacer = this.initialValues.find((item) => item.executor === t);
+		if (!replacer && this.parentScope["cache"].has(t)) {
 			const { value } = this.parentScope["cache"].get(t);
 			this["cache"].set(t, {
 				accessor: a,
@@ -1227,7 +1245,7 @@ var Pod = class extends BaseScope {
 
 //#endregion
 //#region src/flow.ts
-const ok = (data) => ({
+const ok$1 = (data) => ({
 	type: "ok",
 	data,
 	isOk() {
@@ -1237,7 +1255,7 @@ const ok = (data) => ({
 		return false;
 	}
 });
-const ko = (data) => ({
+const ko$1 = (data) => ({
 	type: "ko",
 	data,
 	isOk() {
@@ -1255,13 +1273,13 @@ const FlowExecutionContext = {
 	isParallel: accessor("flow.isParallel", custom(), false)
 };
 var FlowDefinition = class {
-	constructor(name$1, version, input, success, error, meta$1 = []) {
+	constructor(name$1, version, input, success, error, metas = []) {
 		this.name = name$1;
 		this.version = version;
 		this.input = input;
 		this.success = success;
 		this.error = error;
-		this.meta = meta$1;
+		this.metas = metas;
 	}
 	handler(dependenciesOrHandler, handlerFn) {
 		if (typeof dependenciesOrHandler === "function") {
@@ -1271,7 +1289,7 @@ var FlowDefinition = class {
 					return noDepsHandler(ctx, ctx.input);
 				};
 				return flowHandler;
-			}, void 0, [...this.meta, flowDefinitionMeta(this)]);
+			}, void 0, [...this.metas, flowDefinitionMeta(this)]);
 		}
 		const dependencies = dependenciesOrHandler;
 		const dependentHandler = handlerFn;
@@ -1280,7 +1298,7 @@ var FlowDefinition = class {
 				return dependentHandler(deps, ctx, ctx.input);
 			};
 			return flowHandler;
-		}, dependencies, [...this.meta, flowDefinitionMeta(this)]);
+		}, dependencies, [...this.metas, flowDefinitionMeta(this)]);
 	}
 };
 function define(config) {
@@ -1302,8 +1320,8 @@ var FlowContext = class FlowContext {
 		FlowExecutionContext.parentFlowName.set(this, parentFlowName);
 		FlowExecutionContext.isParallel.set(this, isParallel);
 	}
-	ok = (data) => ok(data);
-	ko = (data) => ko(data);
+	ok = (data) => ok$1(data);
+	ko = (data) => ko$1(data);
 	get(key) {
 		if (this.contextData.has(key)) return this.contextData.get(key);
 		return this.parent?.get(key);
@@ -1315,7 +1333,23 @@ var FlowContext = class FlowContext {
 	output = (success, value) => {
 		return success ? this.ok(value) : this.ko(value);
 	};
-	async execute(flow$1, input) {
+	async execute(flowOrFn, input, errorMapperOrOpt, opt) {
+		let errorMapper;
+		let actualOpt;
+		if (typeof errorMapperOrOpt === "function") {
+			errorMapper = errorMapperOrOpt;
+			actualOpt = opt;
+		} else actualOpt = errorMapperOrOpt;
+		if (typeof flowOrFn === "function" && !flowDefinitionMeta.find(flowOrFn)) try {
+			let result;
+			if (Array.isArray(input)) result = await flowOrFn(...input);
+			else result = await flowOrFn(input);
+			return this.ok(result);
+		} catch (error) {
+			const mappedError = errorMapper ? errorMapper(error) : error;
+			return this.ko(mappedError);
+		}
+		const flow$1 = flowOrFn;
 		const handler = await this.pod.resolve(flow$1);
 		const definition = flowDefinitionMeta.find(flow$1);
 		if (!definition) throw new Error("Flow definition not found in executor metadata");
@@ -1323,8 +1357,17 @@ var FlowContext = class FlowContext {
 		childContext.initializeExecutionContext(definition.name, false);
 		return await this.executeWithPlugins(handler, childContext);
 	}
-	async executeParallel(flows) {
-		const results = await Promise.all(flows.map(async ([flow$1, input]) => {
+	async executeParallel(items) {
+		const results = await Promise.all(items.map(async ([flowOrFn, input]) => {
+			if (typeof flowOrFn === "function" && !flowDefinitionMeta.find(flowOrFn)) try {
+				let result;
+				if (Array.isArray(input)) result = await flowOrFn(...input);
+				else result = await flowOrFn(input);
+				return this.ok(result);
+			} catch (error) {
+				return this.ko(error);
+			}
+			const flow$1 = flowOrFn;
 			const childContext = new FlowContext(input, this.pod, this.plugins, this);
 			const handler = await this.pod.resolve(flow$1);
 			const definition = flowDefinitionMeta.find(flow$1);
@@ -1424,6 +1467,150 @@ const eager = {
 	} })
 };
 
+//#endregion
+//#region src/executes.ts
+var executes_exports = {};
+__export(executes_exports, {
+	Service: () => Service,
+	chain: () => chain,
+	chainAsync: () => chainAsync,
+	combine: () => combine,
+	ko: () => ko,
+	map: () => map,
+	mapAsync: () => mapAsync,
+	ok: () => ok,
+	unwrap: () => unwrap,
+	unwrapOrThrow: () => unwrapOrThrow
+});
+/**
+* Helper functions to create Result types
+*/
+const ok = (data) => ({
+	type: "ok",
+	data,
+	isOk() {
+		return true;
+	},
+	isKo() {
+		return false;
+	}
+});
+const ko = (data) => ({
+	type: "ko",
+	data,
+	isOk() {
+		return false;
+	},
+	isKo() {
+		return true;
+	}
+});
+/**
+* Chains Result-returning functions, stopping on first error
+*/
+function chain(result, fn) {
+	if (result.type === "ko") return result;
+	return fn(result.data);
+}
+/**
+* Async version of chain
+*/
+async function chainAsync(result, fn) {
+	if (result.type === "ko") return result;
+	return await fn(result.data);
+}
+/**
+* Maps over a successful Result, leaving errors unchanged
+*/
+function map(result, fn) {
+	if (result.type === "ko") return result;
+	try {
+		return ok(fn(result.data));
+	} catch (error) {
+		return ko(error);
+	}
+}
+/**
+* Async version of map
+*/
+async function mapAsync(result, fn) {
+	if (result.type === "ko") return result;
+	try {
+		const mapped = await fn(result.data);
+		return ok(mapped);
+	} catch (error) {
+		return ko(error);
+	}
+}
+/**
+* Extracts value from Result or returns default
+*/
+function unwrap(result, defaultValue) {
+	return result.type === "ok" ? result.data : defaultValue;
+}
+/**
+* Extracts value from Result or throws
+*/
+function unwrapOrThrow(result) {
+	if (result.type === "ko") throw result.data;
+	return result.data;
+}
+/**
+* Combines multiple Results into one, failing if any fail
+*/
+function combine(results) {
+	const values = [];
+	for (const result of results) {
+		if (result.type === "ko") return result;
+		values.push(result.data);
+	}
+	return ok(values);
+}
+let Service;
+(function(_Service) {
+	function wrap(service) {
+		const wrapped = {};
+		for (const [key, method] of Object.entries(service)) if (typeof method === "function") wrapped[key] = (...args) => {
+			try {
+				const result = method.call(service, ...args);
+				return ok(result);
+			} catch (error) {
+				return ko(error);
+			}
+		};
+		return wrapped;
+	}
+	_Service.wrap = wrap;
+	function wrapAsync(service) {
+		const wrapped = {};
+		for (const [key, method] of Object.entries(service)) if (typeof method === "function") wrapped[key] = async (...args) => {
+			try {
+				const result = await method.call(service, ...args);
+				return ok(result);
+			} catch (error) {
+				return ko(error);
+			}
+		};
+		return wrapped;
+	}
+	_Service.wrapAsync = wrapAsync;
+	function withRetry(service, maxRetries = 3, delayMs = 1e3) {
+		const retryService = {};
+		for (const [key, method] of Object.entries(service)) if (typeof method === "function") retryService[key] = async (...args) => {
+			let lastError;
+			for (let i = 0; i <= maxRetries; i++) {
+				const result = await method(...args);
+				if (result.type === "ok") return result;
+				lastError = result;
+				if (i < maxRetries) await new Promise((resolve) => setTimeout(resolve, delayMs * (i + 1)));
+			}
+			return lastError;
+		};
+		return retryService;
+	}
+	_Service.withRetry = withRetry;
+})(Service || (Service = {}));
+
 //#endregion
 //#region src/index.ts
 const name = meta("pumped-fn/name", custom());
@@ -1446,6 +1633,12 @@ exports.createScope = createScope;
 exports.createSystemError = createSystemError;
 exports.custom = custom;
 exports.derive = derive;
+Object.defineProperty(exports, 'executes', {
+  enumerable: true,
+  get: function () {
+    return executes_exports;
+  }
+});
 exports.executorSymbol = executorSymbol;
 exports.findValue = findValue;
 exports.findValues = findValues;

package/dist/index.d.cts

@@ -254,65 +254,6 @@ declare namespace Core {
     disposePod(scope: Pod): Promise<void>;
   }
 }
-declare namespace Flow {
-  type ContextData = Map<unknown, unknown>;
-  type ExecuteOpt = {
-    scope?: Core.Scope;
-    name?: string;
-    description?: string;
-    plugins?: FlowPlugin[];
-    presets?: Core.Preset<unknown>[];
-    initialContext?: ContextData;
-  };
-  type Controller = {
-    execute: <Input, Output>(input: Flow<Input, Output>, param: Input, opt?: ExecuteOpt) => Promise<Output>;
-    safeExecute: <Input, Output>(input: Flow<Input, Output>, param: Input, opt?: ExecuteOpt) => Promise<Result<Output>>;
-  };
-  type NoDependencyFlowFn<Input, Output> = (input: Input, context: Controller & {
-    context: ExecutionContext;
-  }) => Output | Promise<Output>;
-  type DependentFlowFn<D, Input, Output> = (dependency: D, input: Input, context: Controller & {
-    context: ExecutionContext;
-  }) => Output | Promise<Output>;
-  type FlowPlugin = {
-    name: string;
-    wrap<T>(context: ExecutionContext, execute: () => Promise<T>): Promise<T>;
-  };
-  type Flow<Input, Output> = {
-    execution: NoDependencyFlowFn<Input, Output>;
-  } & Config & Schema<Input, Output>;
-  type Schema<Input, Output> = {
-    input: StandardSchemaV1<Input>;
-    output: StandardSchemaV1<Output>;
-  };
-  type Config = {
-    name?: string;
-    description?: string;
-    plugins?: FlowPlugin[];
-    metas?: Meta.Meta[];
-  };
-  type Executor<Input, Output> = Core.Executor<Flow<Input, Output>> & Config & Schema<Input, Output>;
-  interface ExecutionContext<Input = any, Output = any> extends DataStore {
-    data: Map<unknown, unknown>;
-    parent?: ExecutionContext;
-    scope: Core.Scope;
-    plugins: FlowPlugin[];
-    flow: Flow<Input, Output>;
-  }
-  type Success<T> = {
-    kind: "success";
-    value: T;
-  };
-  type Error = {
-    kind: "error";
-    error: unknown;
-  };
-  type Result<T> = Success<T> | Error;
-  type ExecutionResult<Output> = {
-    context: ExecutionContext;
-    result: Result<Output>;
-  };
-}
 declare namespace Flow {
   type OK<S> = {
     type: "ok";
@@ -333,7 +274,7 @@ declare namespace Flow {
     success: StandardSchemaV1<S>;
     error: StandardSchemaV1<E>;
     version?: string;
-  };
+  } & Meta.MetaContainer;
   interface NoDependencyHandler<I, S, E> {
     (ctx: Context<I, S, E>): OutputLike<S, E> | Promise<OutputLike<S, E>>;
     def: Definition<I, S, E>;
@@ -349,6 +290,9 @@ declare namespace Flow {
   type InferSuccess<F> = F extends NoDependencyFlow<any, infer S, any> ? S : F extends DependentFlow<any, any, infer S, any> ? S : never;
   type InferError<F> = F extends NoDependencyFlow<any, any, infer E> ? E : F extends DependentFlow<any, any, any, infer E> ? E : never;
   type InferOutput<F> = F extends NoDependencyFlow<any, infer S, infer E> ? OK<S> | KO<E> : F extends DependentFlow<any, any, infer S, infer E> ? OK<S> | KO<E> : never;
+  type FnExecutor<I, O> = (input: I) => O | Promise<O>;
+  type MultiFnExecutor<Args extends readonly unknown[], O> = (...args: Args) => O | Promise<O>;
+  type AnyFnExecutor<O = unknown> = FnExecutor<any, O> | MultiFnExecutor<any[], O>;
   type R<S, E> = {
     ok: (value: S) => OK<S>;
     ko: (value: E) => KO<E>;
@@ -356,8 +300,16 @@ declare namespace Flow {
   };
   type Opt = {};
   type C = {
-    execute: <F extends UFlow>(flow: F, param: InferInput<F>, opt?: Opt) => Promise<InferOutput<F>>;
-    executeParallel: <T extends ReadonlyArray<[UFlow, any]>>(flows: T) => Promise<{ [K in keyof T]: T[K] extends [infer F, any] ? F extends UFlow ? Awaited<InferOutput<F>> : never : never }>;
+    execute: {
+      <F extends UFlow>(flow: F, input: InferInput<F>, opt?: Opt): Promise<InferOutput<F>>;
+      <I, O, E = unknown>(fn: FnExecutor<I, O>, input: I, errorMapper?: (error: unknown) => E, opt?: Opt): Promise<OK<O> | KO<E>>;
+      <Args extends readonly unknown[], O, E = unknown>(fn: MultiFnExecutor<Args, O>, args: Args, errorMapper?: (error: unknown) => E, opt?: Opt): Promise<OK<O> | KO<E>>;
+    };
+    executeParallel: {
+      <T extends ReadonlyArray<[UFlow, any]>>(flows: T): Promise<{ [K in keyof T]: T[K] extends [infer F, any] ? F extends UFlow ? Awaited<InferOutput<F>> : never : never }>;
+      <T extends ReadonlyArray<[FnExecutor<any, any> | MultiFnExecutor<any[], any>, any]>>(items: T): Promise<{ [K in keyof T]: T[K] extends [infer F, any] ? F extends FnExecutor<any, infer O> ? OK<O> | KO<unknown> : F extends MultiFnExecutor<any[], infer O> ? OK<O> | KO<unknown> : never : never }>;
+      <T extends ReadonlyArray<[UFlow | FnExecutor<any, any> | MultiFnExecutor<any[], any>, any]>>(mixed: T): Promise<{ [K in keyof T]: T[K] extends [infer F, any] ? F extends UFlow ? Awaited<InferOutput<F>> : F extends FnExecutor<any, infer O> ? OK<O> | KO<unknown> : F extends MultiFnExecutor<any[], infer O> ? OK<O> | KO<unknown> : never : never }>;
+    };
   };
   type Context<I, S, E> = DataStore & R<S, E> & C & {
     input: I;
@@ -537,8 +489,8 @@ declare class FlowDefinition<I, S, E> {
   readonly input: StandardSchemaV1<I>;
   readonly success: StandardSchemaV1<S>;
   readonly error: StandardSchemaV1<E>;
-  readonly meta: Meta.Meta[];
-  constructor(name: string, version: string, input: StandardSchemaV1<I>, success: StandardSchemaV1<S>, error: StandardSchemaV1<E>, meta?: Meta.Meta[]);
+  readonly metas: Meta.Meta[];
+  constructor(name: string, version: string, input: StandardSchemaV1<I>, success: StandardSchemaV1<S>, error: StandardSchemaV1<E>, metas?: Meta.Meta[]);
   handler(handlerFn: (ctx: Flow.Context<I, S, E>, input: I) => Promise<Flow.OutputLike<S, E>> | Flow.OutputLike<S, E>): Core.Executor<Flow.NoDependencyHandler<I, S, E>>;
   handler<D extends Core.DependencyLike>(dependencies: D, handlerFn: (deps: Core.InferOutput<D>, ctx: Flow.Context<I, S, E>, input: I) => Promise<Flow.OutputLike<S, E>> | Flow.OutputLike<S, E>): Core.Executor<Flow.DependentHandler<D, I, S, E>>;
 }
@@ -574,9 +526,57 @@ declare const eager: {
   meta: Meta.MetaFn<boolean>;
   plugin: () => Core.Plugin;
 };
+declare namespace executes_d_exports {
+  export { Result$1 as Result, Service, chain, chainAsync, combine, ko, map, mapAsync, ok$1 as ok, unwrap, unwrapOrThrow };
+}
+/**
+* Result type aliases for cleaner usage
+*/
+type Result$1<T, E = unknown> = Flow.OK<T> | Flow.KO<E>;
+/**
+* Helper functions to create Result types
+*/
+declare const ok$1: <T>(data: T) => Flow.OK<T>;
+declare const ko: <E>(data: E) => Flow.KO<E>;
+/**
+* Chains Result-returning functions, stopping on first error
+*/
+declare function chain<T, U>(result: Result$1<T>, fn: (value: T) => Result$1<U>): Result$1<U>;
+/**
+* Async version of chain
+*/
+declare function chainAsync<T, U>(result: Result$1<T>, fn: (value: T) => Promise<Result$1<U>>): Promise<Result$1<U>>;
+/**
+* Maps over a successful Result, leaving errors unchanged
+*/
+declare function map<T, U>(result: Result$1<T>, fn: (value: T) => U): Result$1<U>;
+/**
+* Async version of map
+*/
+declare function mapAsync<T, U>(result: Result$1<T>, fn: (value: T) => Promise<U>): Promise<Result$1<U>>;
+/**
+* Extracts value from Result or returns default
+*/
+declare function unwrap<T>(result: Result$1<T>, defaultValue: T): T;
+/**
+* Extracts value from Result or throws
+*/
+declare function unwrapOrThrow<T>(result: Result$1<T>): T;
+/**
+* Combines multiple Results into one, failing if any fail
+*/
+declare function combine<T extends readonly Result$1<any>[]>(results: T): Result$1<{ [K in keyof T]: T[K] extends Result$1<infer U> ? U : never }>;
+/**
+* Service composition helpers
+*/
+declare namespace Service {
+  function wrap<T extends Record<string, (...args: any[]) => any>>(service: T): { [K in keyof T]: T[K] extends ((...args: infer Args) => infer R) ? (...args: Args) => Result$1<R> : never };
+  function wrapAsync<T extends Record<string, (...args: any[]) => Promise<any>>>(service: T): { [K in keyof T]: T[K] extends ((...args: infer Args) => Promise<infer R>) ? (...args: Args) => Promise<Result$1<R>> : never };
+  function withRetry<T extends Record<string, (...args: any[]) => Promise<Result$1<any>>>>(service: T, maxRetries?: number, delayMs?: number): T;
+}
 //#endregion
 //#region src/index.d.ts
 declare const name: Meta.MetaFn<string>;
 //#endregion
-export { type Accessor$1 as Accessor, type AccessorSource, type AccessorWithDefault, AdaptedExecutor, Core, type DataStore, DependencyResolutionError, ErrorCode, ErrorCodes, ErrorContext, ErrorMessages, Escapable, ExecutorResolutionError, FactoryExecutionError, type Flow, FlowExecutionContext, GeneratorHandler, Meta, Multi, PreparedExecutor, SchemaError, ScopeOption, StandardSchemaV1, accessor, adapt, buildDependencyChain, collectFromGenerator, createDependencyError, createFactoryError, createScope, createSystemError, custom, derive, executorSymbol, findValue, findValues, flow, formatErrorMessage, getExecutorName, getValue, isAsyncGenerator, isAsyncGeneratorFunction, isExecutor, isGenerator, isGeneratorFunction, isIterableOrAsyncIterable, isLazyExecutor, isMainExecutor, isPreset, isReactiveExecutor, isStaticExecutor, meta, metaSymbol, multi_d_exports as multi, name, plugin, plugins_d_exports as plugins, prepare, preset, processGenerator, provide, resolves, validate };
+export { type Accessor$1 as Accessor, type AccessorSource, type AccessorWithDefault, AdaptedExecutor, Core, type DataStore, DependencyResolutionError, ErrorCode, ErrorCodes, ErrorContext, ErrorMessages, Escapable, ExecutorResolutionError, FactoryExecutionError, type Flow, FlowExecutionContext, GeneratorHandler, Meta, Multi, PreparedExecutor, SchemaError, ScopeOption, StandardSchemaV1, accessor, adapt, buildDependencyChain, collectFromGenerator, createDependencyError, createFactoryError, createScope, createSystemError, custom, derive, executes_d_exports as executes, executorSymbol, findValue, findValues, flow, formatErrorMessage, getExecutorName, getValue, isAsyncGenerator, isAsyncGeneratorFunction, isExecutor, isGenerator, isGeneratorFunction, isIterableOrAsyncIterable, isLazyExecutor, isMainExecutor, isPreset, isReactiveExecutor, isStaticExecutor, meta, metaSymbol, multi_d_exports as multi, name, plugin, plugins_d_exports as plugins, prepare, preset, processGenerator, provide, resolves, validate };
 //# sourceMappingURL=index.d.cts.map