ff-effect 0.0.1

package/dist/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  extract: () => extract,
+  runPromiseUnwrapped: () => runPromiseUnwrapped
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/extract.ts
+var import_effect = require("effect");
+function extract(effect, options) {
+  return import_effect.Effect.gen(function* () {
+    const runtime = yield* import_effect.Effect.runtime();
+    const context = runtime.context.pipe(
+      options?.exclude ? import_effect.Context.omit(...options.exclude) : (e) => e
+    );
+    return (...params) => (0, import_effect.pipe)(effect(...params), import_effect.Effect.provide(context));
+  });
+}
+
+// src/run-promise-unwrapped.ts
+var import_effect2 = require("effect");
+async function runPromiseUnwrapped(effect) {
+  const exit = await import_effect2.Effect.runPromiseExit(effect);
+  return import_effect2.Exit.match(exit, {
+    onSuccess: (value) => value,
+    onFailure: (cause) => {
+      throw import_effect2.Cause.isFailType(cause) ? cause.error : cause;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extract,
+  runPromiseUnwrapped
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/extract.ts","../src/run-promise-unwrapped.ts"],"sourcesContent":["export { extract } from './extract.js';\nexport { runPromiseUnwrapped } from './run-promise-unwrapped.js';\n","import { Context, Effect, pipe } from \"effect\";\n\ntype InferClass<T> = T extends new (...args: any[]) => infer R ? R : never;\n\n// biome-ignore lint/suspicious/noExplicitAny: intended\nexport function extract<\n\tP extends any[],\n\tA,\n\tE,\n\tR,\n\tINFERRED_EXCLUDED extends Context.Tag<any, any> = never,\n\tEXCLUDED = InferClass<INFERRED_EXCLUDED>,\n>(\n\teffect: (...params: P) => Effect.Effect<A, E, R>,\n\toptions?: { exclude?: Array<INFERRED_EXCLUDED> }\n): Effect.Effect<\n\t(...params: P) => Effect.Effect<A, E, Extract<R, EXCLUDED>>,\n\tnever,\n\tExclude<R, EXCLUDED>\n> {\n\t// @ts-expect-error quite hard to type, check unit test\n\treturn Effect.gen(function* () {\n\t\tconst runtime = yield* Effect.runtime();\n\n\t\tconst context = runtime.context.pipe(\n\t\t\toptions?.exclude ? Context.omit(...options.exclude) : (e) => e\n\t\t) as Context.Context<Exclude<R, EXCLUDED>>;\n\n\t\treturn (...params: P) =>\n\t\t\tpipe(effect(...params), Effect.provide(context));\n\t});\n}\n","import { Cause, Effect, Exit } from \"effect\";\n\n/**\n * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure\n **/\nexport async function runPromiseUnwrapped<A, E>(\n\teffect: Effect.Effect<A, E, never>\n) {\n\tconst exit = await Effect.runPromiseExit(effect);\n\treturn Exit.match(exit, {\n\t\tonSuccess: (value) => value,\n\t\tonFailure: (cause) => {\n\t\t\tthrow Cause.isFailType(cause) ? cause.error : cause;\n\t\t},\n\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,oBAAsC;AAK/B,SAAS,QAQf,QACA,SAKC;AAED,SAAO,qBAAO,IAAI,aAAa;AAC9B,UAAM,UAAU,OAAO,qBAAO,QAAQ;AAEtC,UAAM,UAAU,QAAQ,QAAQ;AAAA,MAC/B,SAAS,UAAU,sBAAQ,KAAK,GAAG,QAAQ,OAAO,IAAI,CAAC,MAAM;AAAA,IAC9D;AAEA,WAAO,IAAI,eACV,oBAAK,OAAO,GAAG,MAAM,GAAG,qBAAO,QAAQ,OAAO,CAAC;AAAA,EACjD,CAAC;AACF;;;AC/BA,IAAAA,iBAAoC;AAKpC,eAAsB,oBACrB,QACC;AACD,QAAM,OAAO,MAAM,sBAAO,eAAe,MAAM;AAC/C,SAAO,oBAAK,MAAM,MAAM;AAAA,IACvB,WAAW,CAAC,UAAU;AAAA,IACtB,WAAW,CAAC,UAAU;AACrB,YAAM,qBAAM,WAAW,KAAK,IAAI,MAAM,QAAQ;AAAA,IAC/C;AAAA,EACD,CAAC;AACF;","names":["import_effect"]}

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+import { Context, Effect } from 'effect';
+
+type InferClass<T> = T extends new (...args: any[]) => infer R ? R : never;
+declare function extract<P extends any[], A, E, R, INFERRED_EXCLUDED extends Context.Tag<any, any> = never, EXCLUDED = InferClass<INFERRED_EXCLUDED>>(effect: (...params: P) => Effect.Effect<A, E, R>, options?: {
+    exclude?: Array<INFERRED_EXCLUDED>;
+}): Effect.Effect<(...params: P) => Effect.Effect<A, E, Extract<R, EXCLUDED>>, never, Exclude<R, EXCLUDED>>;
+
+/**
+ * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure
+ **/
+declare function runPromiseUnwrapped<A, E>(effect: Effect.Effect<A, E, never>): Promise<A>;
+
+export { extract, runPromiseUnwrapped };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { Context, Effect } from 'effect';
+
+type InferClass<T> = T extends new (...args: any[]) => infer R ? R : never;
+declare function extract<P extends any[], A, E, R, INFERRED_EXCLUDED extends Context.Tag<any, any> = never, EXCLUDED = InferClass<INFERRED_EXCLUDED>>(effect: (...params: P) => Effect.Effect<A, E, R>, options?: {
+    exclude?: Array<INFERRED_EXCLUDED>;
+}): Effect.Effect<(...params: P) => Effect.Effect<A, E, Extract<R, EXCLUDED>>, never, Exclude<R, EXCLUDED>>;
+
+/**
+ * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure
+ **/
+declare function runPromiseUnwrapped<A, E>(effect: Effect.Effect<A, E, never>): Promise<A>;
+
+export { extract, runPromiseUnwrapped };

package/dist/index.js

@@ -0,0 +1,28 @@
+// src/extract.ts
+import { Context, Effect, pipe } from "effect";
+function extract(effect, options) {
+  return Effect.gen(function* () {
+    const runtime = yield* Effect.runtime();
+    const context = runtime.context.pipe(
+      options?.exclude ? Context.omit(...options.exclude) : (e) => e
+    );
+    return (...params) => pipe(effect(...params), Effect.provide(context));
+  });
+}
+
+// src/run-promise-unwrapped.ts
+import { Cause, Effect as Effect2, Exit } from "effect";
+async function runPromiseUnwrapped(effect) {
+  const exit = await Effect2.runPromiseExit(effect);
+  return Exit.match(exit, {
+    onSuccess: (value) => value,
+    onFailure: (cause) => {
+      throw Cause.isFailType(cause) ? cause.error : cause;
+    }
+  });
+}
+export {
+  extract,
+  runPromiseUnwrapped
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extract.ts","../src/run-promise-unwrapped.ts"],"sourcesContent":["import { Context, Effect, pipe } from \"effect\";\n\ntype InferClass<T> = T extends new (...args: any[]) => infer R ? R : never;\n\n// biome-ignore lint/suspicious/noExplicitAny: intended\nexport function extract<\n\tP extends any[],\n\tA,\n\tE,\n\tR,\n\tINFERRED_EXCLUDED extends Context.Tag<any, any> = never,\n\tEXCLUDED = InferClass<INFERRED_EXCLUDED>,\n>(\n\teffect: (...params: P) => Effect.Effect<A, E, R>,\n\toptions?: { exclude?: Array<INFERRED_EXCLUDED> }\n): Effect.Effect<\n\t(...params: P) => Effect.Effect<A, E, Extract<R, EXCLUDED>>,\n\tnever,\n\tExclude<R, EXCLUDED>\n> {\n\t// @ts-expect-error quite hard to type, check unit test\n\treturn Effect.gen(function* () {\n\t\tconst runtime = yield* Effect.runtime();\n\n\t\tconst context = runtime.context.pipe(\n\t\t\toptions?.exclude ? Context.omit(...options.exclude) : (e) => e\n\t\t) as Context.Context<Exclude<R, EXCLUDED>>;\n\n\t\treturn (...params: P) =>\n\t\t\tpipe(effect(...params), Effect.provide(context));\n\t});\n}\n","import { Cause, Effect, Exit } from \"effect\";\n\n/**\n * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure\n **/\nexport async function runPromiseUnwrapped<A, E>(\n\teffect: Effect.Effect<A, E, never>\n) {\n\tconst exit = await Effect.runPromiseExit(effect);\n\treturn Exit.match(exit, {\n\t\tonSuccess: (value) => value,\n\t\tonFailure: (cause) => {\n\t\t\tthrow Cause.isFailType(cause) ? cause.error : cause;\n\t\t},\n\t});\n}\n"],"mappings":";AAAA,SAAS,SAAS,QAAQ,YAAY;AAK/B,SAAS,QAQf,QACA,SAKC;AAED,SAAO,OAAO,IAAI,aAAa;AAC9B,UAAM,UAAU,OAAO,OAAO,QAAQ;AAEtC,UAAM,UAAU,QAAQ,QAAQ;AAAA,MAC/B,SAAS,UAAU,QAAQ,KAAK,GAAG,QAAQ,OAAO,IAAI,CAAC,MAAM;AAAA,IAC9D;AAEA,WAAO,IAAI,WACV,KAAK,OAAO,GAAG,MAAM,GAAG,OAAO,QAAQ,OAAO,CAAC;AAAA,EACjD,CAAC;AACF;;;AC/BA,SAAS,OAAO,UAAAA,SAAQ,YAAY;AAKpC,eAAsB,oBACrB,QACC;AACD,QAAM,OAAO,MAAMA,QAAO,eAAe,MAAM;AAC/C,SAAO,KAAK,MAAM,MAAM;AAAA,IACvB,WAAW,CAAC,UAAU;AAAA,IACtB,WAAW,CAAC,UAAU;AACrB,YAAM,MAAM,WAAW,KAAK,IAAI,MAAM,QAAQ;AAAA,IAC/C;AAAA,EACD,CAAC;AACF;","names":["Effect"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "ff-effect",
+	"version": "0.0.1",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"scripts": {
+		"build": "tsup",
+		"test": "vitest run",
+		"dev": "tsup --watch"
+	},
+	"devDependencies": {
+		"@total-typescript/tsconfig": "^1.0.4",
+		"@types/bun": "^1.3.2",
+		"tsup": "^8.5.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.10"
+	},
+	"peerDependencies": {
+		"effect": "^3.19.3"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://github.com/fdarian/ff.git",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/fdarian/ff.git"
+	},
+	"bugs": {
+		"url": "https://github.com/fdarian/ff/issues"
+	},
+	"keywords": [
+		"effect",
+		"utils",
+		"tools"
+	]
+}

package/src/extract.test.ts

@@ -0,0 +1,110 @@
+import { Effect, Layer } from 'effect';
+import { expect, expectTypeOf, test } from 'vitest';
+import { extract } from './extract.js';
+
+class ServiceA extends Effect.Service<ServiceA>()('A', {
+	sync: () => ({ val: 'A' as string }),
+}) {}
+
+class ServiceB extends Effect.Service<ServiceB>()('B', {
+	sync: () => ({ val: 'B' as string }),
+}) {}
+
+test('basic', () =>
+	Effect.gen(function* () {
+		const getVal = Effect.fn(function* () {
+			return (yield* ServiceA).val;
+		});
+
+		const Container_effect = Effect.gen(function* () {
+			return {
+				getVal: yield* extract(getVal),
+			};
+		});
+		expectTypeOf(Container_effect).toEqualTypeOf<
+			Effect.Effect<
+				{
+					// ServiceA is moved, no longer here
+					getVal: () => Effect.Effect<string, never, never>;
+				},
+				never,
+				// ServiceA is now here
+				ServiceA
+			>
+		>();
+
+		class Container extends Effect.Service<Container>()('Container', {
+			dependencies: [ServiceA.Default],
+			effect: Container_effect,
+		}) {}
+
+		const main = Effect.gen(function* () {
+			const container = yield* Container;
+
+			expect(yield* container.getVal()).toBe('A');
+		}).pipe(Effect.provide(Container.Default));
+
+		yield* main;
+	}).pipe((e) => Effect.runPromise(e)));
+
+/** Checks whether we have omitted the `excluded` tags in runtime (not type level) */
+test('with excluded', () =>
+	Effect.gen(function* () {
+		const getVal = Effect.fn(function* () {
+			return {
+				a: (yield* ServiceA).val,
+				b: (yield* ServiceB).val,
+			};
+		});
+
+		const Container_effect = Effect.gen(function* () {
+			return {
+				getVal: yield* extract(getVal, { exclude: [ServiceB] }),
+			};
+		});
+		expectTypeOf(Container_effect).toEqualTypeOf<
+			Effect.Effect<
+				{
+					getVal: () => Effect.Effect<
+						{
+							a: string;
+							b: string;
+						},
+						never,
+						// ServiceA is moved, no longer here,
+						// but ServiceB still, because of the `exclude`
+						ServiceB
+					>;
+				},
+				never,
+				// ServiceA is now here
+				ServiceA
+			>
+		>();
+
+		class Container extends Effect.Service<Container>()('Container', {
+			dependencies: [
+				ServiceA.Default,
+				// Assume this is what the service by default provides ServiceB
+				Layer.succeed(ServiceB, ServiceB.make({ val: 'not this' })),
+			],
+			effect: Container_effect,
+		}) {}
+
+		const main = Effect.gen(function* () {
+			const container = yield* Container;
+			const result = yield* container.getVal().pipe(
+				Effect.provideService(
+					ServiceB,
+					// The exclusion should use this instead
+					ServiceB.make({ val: 'this one' }),
+				),
+			);
+
+			expect(result.a).toBe('A');
+			// B is using the new provided
+			expect(result.b).toBe('this one');
+		}).pipe(Effect.provide(Container.Default));
+
+		yield* main;
+	}).pipe((e) => Effect.runPromise(e)));

package/src/extract.ts

@@ -0,0 +1,32 @@
+import { Context, Effect, pipe } from "effect";
+
+type InferClass<T> = T extends new (...args: any[]) => infer R ? R : never;
+
+// biome-ignore lint/suspicious/noExplicitAny: intended
+export function extract<
+	P extends any[],
+	A,
+	E,
+	R,
+	INFERRED_EXCLUDED extends Context.Tag<any, any> = never,
+	EXCLUDED = InferClass<INFERRED_EXCLUDED>,
+>(
+	effect: (...params: P) => Effect.Effect<A, E, R>,
+	options?: { exclude?: Array<INFERRED_EXCLUDED> }
+): Effect.Effect<
+	(...params: P) => Effect.Effect<A, E, Extract<R, EXCLUDED>>,
+	never,
+	Exclude<R, EXCLUDED>
+> {
+	// @ts-expect-error quite hard to type, check unit test
+	return Effect.gen(function* () {
+		const runtime = yield* Effect.runtime();
+
+		const context = runtime.context.pipe(
+			options?.exclude ? Context.omit(...options.exclude) : (e) => e
+		) as Context.Context<Exclude<R, EXCLUDED>>;
+
+		return (...params: P) =>
+			pipe(effect(...params), Effect.provide(context));
+	});
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { extract } from './extract.js';
+export { runPromiseUnwrapped } from './run-promise-unwrapped.js';

package/src/run-promise-unwrapped.ts

@@ -0,0 +1,16 @@
+import { Cause, Effect, Exit } from "effect";
+
+/**
+ * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure
+ **/
+export async function runPromiseUnwrapped<A, E>(
+	effect: Effect.Effect<A, E, never>
+) {
+	const exit = await Effect.runPromiseExit(effect);
+	return Exit.match(exit, {
+		onSuccess: (value) => value,
+		onFailure: (cause) => {
+			throw Cause.isFailType(cause) ? cause.error : cause;
+		},
+	});
+}