ff-effect 0.0.7 → 0.0.10

package/dist/for/drizzle/index.cjs

@@ -0,0 +1,129 @@
+"use strict";
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/for/drizzle/index.ts
+var drizzle_exports = {};
+__export(drizzle_exports, {
+  ChannelTypeId: () => ChannelTypeId2,
+  DrizzleError: () => DrizzleError,
+  EffectTypeId: () => EffectTypeId,
+  NodeInspectSymbol: () => NodeInspectSymbol2,
+  STMTypeId: () => STMTypeId2,
+  SinkTypeId: () => SinkTypeId2,
+  StreamTypeId: () => StreamTypeId2,
+  TagTypeId: () => TagTypeId2,
+  Unify: () => Unify,
+  createDatabase: () => createDatabase
+});
+module.exports = __toCommonJS(drizzle_exports);
+var import_effect = require("effect");
+var Channel = __toESM(require("effect/Channel"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Inspectable = __toESM(require("effect/Inspectable"), 1);
+var Sink = __toESM(require("effect/Sink"), 1);
+var STM = __toESM(require("effect/STM"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var EUnify = __toESM(require("effect/Unify"), 1);
+var TagTypeId2 = Context.TagTypeId;
+var ChannelTypeId2 = Channel.ChannelTypeId;
+var EffectTypeId = import_effect.Effect.EffectTypeId;
+var NodeInspectSymbol2 = Inspectable.NodeInspectSymbol;
+var STMTypeId2 = STM.STMTypeId;
+var SinkTypeId2 = Sink.SinkTypeId;
+var StreamTypeId2 = Stream.StreamTypeId;
+var Unify = EUnify;
+var DrizzleError = class extends import_effect.Data.TaggedError("ff-effect/DrizzleError") {
+};
+var WrappedTxError = class extends Error {
+};
+var defaultPrefix = "@ff-effect/Drizzle";
+function createDatabase(createClient, opts) {
+  const tagId = opts?.tagId ?? defaultPrefix;
+  const Drizzle = Context.Tag(tagId)();
+  const drizzleTxTagId = `${tagId}.tx`;
+  const DrizzleTx = Context.Tag(drizzleTxTagId)();
+  const db = (fn) => import_effect.Effect.gen(function* () {
+    const client = yield* Drizzle;
+    return yield* import_effect.Effect.tryPromise({
+      try: () => fn(client),
+      catch: (cause) => new DrizzleError({ message: "Database operation failed", cause })
+    });
+  });
+  const tx = (fn) => import_effect.Effect.gen(function* () {
+    const client = yield* DrizzleTx;
+    return yield* import_effect.Effect.tryPromise({
+      try: () => fn(client),
+      catch: (cause) => new DrizzleError({ message: "Database operation failed", cause })
+    });
+  });
+  const withTransaction = (effect) => import_effect.Effect.gen(function* () {
+    const client = yield* Drizzle;
+    const runFork = yield* import_effect.FiberSet.makeRuntimePromise();
+    return yield* import_effect.Effect.tryPromise({
+      try: () => client.transaction(
+        (txClient) => runFork(
+          effect.pipe(
+            import_effect.Effect.provideService(Drizzle, txClient),
+            import_effect.Effect.provideService(DrizzleTx, txClient),
+            import_effect.Effect.mapError((e) => new WrappedTxError("", { cause: e }))
+          )
+        )
+      ),
+      catch: (error) => {
+        if (error instanceof WrappedTxError) return error.cause;
+        return new DrizzleError({
+          message: "Transaction failed",
+          cause: error
+        });
+      }
+    });
+  }).pipe(import_effect.Effect.scoped);
+  return {
+    db,
+    tx,
+    Drizzle,
+    DrizzleTx,
+    withTransaction,
+    layer: import_effect.Layer.effect(Drizzle, createClient)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChannelTypeId,
+  DrizzleError,
+  EffectTypeId,
+  NodeInspectSymbol,
+  STMTypeId,
+  SinkTypeId,
+  StreamTypeId,
+  TagTypeId,
+  Unify,
+  createDatabase
+});
+//# sourceMappingURL=index.cjs.map

package/dist/for/drizzle/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/for/drizzle/index.ts"],"sourcesContent":["import { Data, Effect, FiberSet, Layer } from 'effect';\nimport * as Channel from 'effect/Channel';\nimport * as Context from 'effect/Context';\nimport * as Inspectable from 'effect/Inspectable';\nimport * as Sink from 'effect/Sink';\nimport * as STM from 'effect/STM';\nimport * as Stream from 'effect/Stream';\nimport * as EUnify from 'effect/Unify';\n\n// TypeScript issue where the return type of createDatabase\n// contains internal Effect types (TagTypeId) that aren't exported\n// from this module,\n// so TypeScript can't \"name\" them in the declaration file.\nexport const TagTypeId = Context.TagTypeId;\nexport const ChannelTypeId = Channel.ChannelTypeId;\nexport const EffectTypeId = Effect.EffectTypeId;\nexport const NodeInspectSymbol = Inspectable.NodeInspectSymbol;\nexport const STMTypeId = STM.STMTypeId;\nexport const SinkTypeId = Sink.SinkTypeId;\nexport const StreamTypeId = Stream.StreamTypeId;\nexport const Unify = EUnify;\n\nexport class DrizzleError extends Data.TaggedError('ff-effect/DrizzleError')<{\n\tmessage: string;\n\tcause?: unknown;\n}> {}\n\ntype AnyDrizzleClient = {\n\ttransaction: (fn: (tx: any) => Promise<any>) => Promise<any>;\n};\n\ntype TxClient<TClient extends AnyDrizzleClient> = Parameters<\n\tParameters<TClient['transaction']>[0]\n>[0];\n\nclass WrappedTxError extends Error {}\n\nconst defaultPrefix = '@ff-effect/Drizzle' as const;\n\nexport function createDatabase<\n\tTClient extends AnyDrizzleClient,\n\tE,\n\tR,\n\tT extends string = typeof defaultPrefix,\n>(createClient: Effect.Effect<TClient, E, R>, opts?: { tagId?: T }) {\n\ttype Client = TClient | TxClient<TClient>;\n\ttype Tx = TxClient<TClient>;\n\n\tconst tagId = (opts?.tagId ?? defaultPrefix) as T;\n\n\ttype Drizzle = typeof tagId;\n\tconst Drizzle = Context.Tag(tagId)<Drizzle, Client>();\n\n\tconst drizzleTxTagId = `${tagId}.tx` as const;\n\ttype DrizzleTx = typeof drizzleTxTagId;\n\tconst DrizzleTx = Context.Tag(drizzleTxTagId)<DrizzleTx, Tx>();\n\n\tconst db = <T>(fn: (client: Client) => Promise<T>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* Drizzle;\n\t\t\treturn yield* Effect.tryPromise({\n\t\t\t\ttry: () => fn(client),\n\t\t\t\tcatch: (cause) =>\n\t\t\t\t\tnew DrizzleError({ message: 'Database operation failed', cause }),\n\t\t\t});\n\t\t});\n\n\t/** Requires being inside withTransaction - enforces transaction at compile time */\n\tconst tx = <T>(fn: (client: Tx) => Promise<T>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* DrizzleTx;\n\t\t\treturn yield* Effect.tryPromise({\n\t\t\t\ttry: () => fn(client),\n\t\t\t\tcatch: (cause) =>\n\t\t\t\t\tnew DrizzleError({ message: 'Database operation failed', cause }),\n\t\t\t});\n\t\t});\n\n\tconst withTransaction = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* Drizzle;\n\t\t\tconst runFork =\n\t\t\t\tyield* FiberSet.makeRuntimePromise<Exclude<R, DrizzleTx>>();\n\n\t\t\treturn yield* Effect.tryPromise<A, E | DrizzleError>({\n\t\t\t\ttry: () =>\n\t\t\t\t\t(client as TClient).transaction((txClient) =>\n\t\t\t\t\t\trunFork(\n\t\t\t\t\t\t\teffect.pipe(\n\t\t\t\t\t\t\t\tEffect.provideService(Drizzle, txClient as Client),\n\t\t\t\t\t\t\t\tEffect.provideService(DrizzleTx, txClient as Tx),\n\t\t\t\t\t\t\t\tEffect.mapError((e) => new WrappedTxError('', { cause: e })),\n\t\t\t\t\t\t\t) as Effect.Effect<A, WrappedTxError, Exclude<R, DrizzleTx>>,\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\tcatch: (error) => {\n\t\t\t\t\tif (error instanceof WrappedTxError) return error.cause as E;\n\t\t\t\t\treturn new DrizzleError({\n\t\t\t\t\t\tmessage: 'Transaction failed',\n\t\t\t\t\t\tcause: error,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t});\n\t\t}).pipe(Effect.scoped);\n\n\treturn {\n\t\tdb,\n\t\ttx,\n\t\tDrizzle,\n\t\tDrizzleTx,\n\t\twithTransaction,\n\t\tlayer: Layer.effect(Drizzle, createClient),\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,uBAAAA;AAAA,EAAA;AAAA;AAAA,2BAAAC;AAAA,EAAA,iBAAAC;AAAA,EAAA,kBAAAC;AAAA,EAAA,oBAAAC;AAAA,EAAA,iBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,oBAA8C;AAC9C,cAAyB;AACzB,cAAyB;AACzB,kBAA6B;AAC7B,WAAsB;AACtB,UAAqB;AACrB,aAAwB;AACxB,aAAwB;AAMjB,IAAMA,aAAoB;AAC1B,IAAML,iBAAwB;AAC9B,IAAM,eAAe,qBAAO;AAC5B,IAAMC,qBAAgC;AACtC,IAAMC,aAAgB;AACtB,IAAMC,cAAkB;AACxB,IAAMC,gBAAsB;AAC5B,IAAM,QAAQ;AAEd,IAAM,eAAN,cAA2B,mBAAK,YAAY,wBAAwB,EAGxE;AAAC;AAUJ,IAAM,iBAAN,cAA6B,MAAM;AAAC;AAEpC,IAAM,gBAAgB;AAEf,SAAS,eAKd,cAA4C,MAAsB;AAInE,QAAM,QAAS,MAAM,SAAS;AAG9B,QAAM,UAAkB,YAAI,KAAK,EAAmB;AAEpD,QAAM,iBAAiB,GAAG,KAAK;AAE/B,QAAM,YAAoB,YAAI,cAAc,EAAiB;AAE7D,QAAM,KAAK,CAAI,OACd,qBAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,WAAO,OAAO,qBAAO,WAAW;AAAA,MAC/B,KAAK,MAAM,GAAG,MAAM;AAAA,MACpB,OAAO,CAAC,UACP,IAAI,aAAa,EAAE,SAAS,6BAA6B,MAAM,CAAC;AAAA,IAClE,CAAC;AAAA,EACF,CAAC;AAGF,QAAM,KAAK,CAAI,OACd,qBAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,WAAO,OAAO,qBAAO,WAAW;AAAA,MAC/B,KAAK,MAAM,GAAG,MAAM;AAAA,MACpB,OAAO,CAAC,UACP,IAAI,aAAa,EAAE,SAAS,6BAA6B,MAAM,CAAC;AAAA,IAClE,CAAC;AAAA,EACF,CAAC;AAEF,QAAM,kBAAkB,CAAU,WACjC,qBAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,UAAM,UACL,OAAO,uBAAS,mBAA0C;AAE3D,WAAO,OAAO,qBAAO,WAAgC;AAAA,MACpD,KAAK,MACH,OAAmB;AAAA,QAAY,CAAC,aAChC;AAAA,UACC,OAAO;AAAA,YACN,qBAAO,eAAe,SAAS,QAAkB;AAAA,YACjD,qBAAO,eAAe,WAAW,QAAc;AAAA,YAC/C,qBAAO,SAAS,CAAC,MAAM,IAAI,eAAe,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAAA,UAC5D;AAAA,QACD;AAAA,MACD;AAAA,MACD,OAAO,CAAC,UAAU;AACjB,YAAI,iBAAiB,eAAgB,QAAO,MAAM;AAClD,eAAO,IAAI,aAAa;AAAA,UACvB,SAAS;AAAA,UACT,OAAO;AAAA,QACR,CAAC;AAAA,MACF;AAAA,IACD,CAAC;AAAA,EACF,CAAC,EAAE,KAAK,qBAAO,MAAM;AAEtB,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO,oBAAM,OAAO,SAAS,YAAY;AAAA,EAC1C;AACD;","names":["ChannelTypeId","NodeInspectSymbol","STMTypeId","SinkTypeId","StreamTypeId","TagTypeId"]}

package/dist/for/drizzle/index.d.cts

@@ -0,0 +1,40 @@
+import * as effect_Scope from 'effect/Scope';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as EUnify from 'effect/Unify';
+
+declare const TagTypeId: symbol;
+declare const ChannelTypeId: symbol;
+declare const EffectTypeId: symbol;
+declare const NodeInspectSymbol: symbol;
+declare const STMTypeId: symbol;
+declare const SinkTypeId: symbol;
+declare const StreamTypeId: symbol;
+declare const Unify: typeof EUnify;
+declare const DrizzleError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ff-effect/DrizzleError";
+} & Readonly<A>;
+declare class DrizzleError extends DrizzleError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+type AnyDrizzleClient = {
+    transaction: (fn: (tx: any) => Promise<any>) => Promise<any>;
+};
+type TxClient<TClient extends AnyDrizzleClient> = Parameters<Parameters<TClient['transaction']>[0]>[0];
+declare const defaultPrefix: "@ff-effect/Drizzle";
+declare function createDatabase<TClient extends AnyDrizzleClient, E, R, T extends string = typeof defaultPrefix>(createClient: Effect.Effect<TClient, E, R>, opts?: {
+    tagId?: T;
+}): {
+    db: <T_1>(fn: (client: TClient | TxClient<TClient>) => Promise<T_1>) => Effect.Effect<T_1, DrizzleError, T>;
+    tx: <T_1>(fn: (client: TxClient<TClient>) => Promise<T_1>) => Effect.Effect<T_1, DrizzleError, `${T}.tx`>;
+    Drizzle: Context.TagClass<T, T, TClient | TxClient<TClient>>;
+    DrizzleTx: Context.TagClass<`${T}.tx`, `${T}.tx`, TxClient<TClient>>;
+    withTransaction: <A, E_1, R_1>(effect: Effect.Effect<A, E_1, R_1>) => Effect.Effect<A, DrizzleError | E_1, Exclude<T, effect_Scope.Scope> | Exclude<Exclude<R_1, `${T}.tx`>, effect_Scope.Scope>>;
+    layer: Layer.Layer<T, E, R>;
+};
+
+export { ChannelTypeId, DrizzleError, EffectTypeId, NodeInspectSymbol, STMTypeId, SinkTypeId, StreamTypeId, TagTypeId, Unify, createDatabase };

package/dist/for/drizzle/index.d.ts

@@ -0,0 +1,40 @@
+import * as effect_Scope from 'effect/Scope';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as EUnify from 'effect/Unify';
+
+declare const TagTypeId: symbol;
+declare const ChannelTypeId: symbol;
+declare const EffectTypeId: symbol;
+declare const NodeInspectSymbol: symbol;
+declare const STMTypeId: symbol;
+declare const SinkTypeId: symbol;
+declare const StreamTypeId: symbol;
+declare const Unify: typeof EUnify;
+declare const DrizzleError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ff-effect/DrizzleError";
+} & Readonly<A>;
+declare class DrizzleError extends DrizzleError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+type AnyDrizzleClient = {
+    transaction: (fn: (tx: any) => Promise<any>) => Promise<any>;
+};
+type TxClient<TClient extends AnyDrizzleClient> = Parameters<Parameters<TClient['transaction']>[0]>[0];
+declare const defaultPrefix: "@ff-effect/Drizzle";
+declare function createDatabase<TClient extends AnyDrizzleClient, E, R, T extends string = typeof defaultPrefix>(createClient: Effect.Effect<TClient, E, R>, opts?: {
+    tagId?: T;
+}): {
+    db: <T_1>(fn: (client: TClient | TxClient<TClient>) => Promise<T_1>) => Effect.Effect<T_1, DrizzleError, T>;
+    tx: <T_1>(fn: (client: TxClient<TClient>) => Promise<T_1>) => Effect.Effect<T_1, DrizzleError, `${T}.tx`>;
+    Drizzle: Context.TagClass<T, T, TClient | TxClient<TClient>>;
+    DrizzleTx: Context.TagClass<`${T}.tx`, `${T}.tx`, TxClient<TClient>>;
+    withTransaction: <A, E_1, R_1>(effect: Effect.Effect<A, E_1, R_1>) => Effect.Effect<A, DrizzleError | E_1, Exclude<T, effect_Scope.Scope> | Exclude<Exclude<R_1, `${T}.tx`>, effect_Scope.Scope>>;
+    layer: Layer.Layer<T, E, R>;
+};
+
+export { ChannelTypeId, DrizzleError, EffectTypeId, NodeInspectSymbol, STMTypeId, SinkTypeId, StreamTypeId, TagTypeId, Unify, createDatabase };

package/dist/for/drizzle/index.js

@@ -0,0 +1,85 @@
+// src/for/drizzle/index.ts
+import { Data, Effect, FiberSet, Layer } from "effect";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Inspectable from "effect/Inspectable";
+import * as Sink from "effect/Sink";
+import * as STM from "effect/STM";
+import * as Stream from "effect/Stream";
+import * as EUnify from "effect/Unify";
+var TagTypeId2 = Context.TagTypeId;
+var ChannelTypeId2 = Channel.ChannelTypeId;
+var EffectTypeId = Effect.EffectTypeId;
+var NodeInspectSymbol2 = Inspectable.NodeInspectSymbol;
+var STMTypeId2 = STM.STMTypeId;
+var SinkTypeId2 = Sink.SinkTypeId;
+var StreamTypeId2 = Stream.StreamTypeId;
+var Unify = EUnify;
+var DrizzleError = class extends Data.TaggedError("ff-effect/DrizzleError") {
+};
+var WrappedTxError = class extends Error {
+};
+var defaultPrefix = "@ff-effect/Drizzle";
+function createDatabase(createClient, opts) {
+  const tagId = opts?.tagId ?? defaultPrefix;
+  const Drizzle = Context.Tag(tagId)();
+  const drizzleTxTagId = `${tagId}.tx`;
+  const DrizzleTx = Context.Tag(drizzleTxTagId)();
+  const db = (fn) => Effect.gen(function* () {
+    const client = yield* Drizzle;
+    return yield* Effect.tryPromise({
+      try: () => fn(client),
+      catch: (cause) => new DrizzleError({ message: "Database operation failed", cause })
+    });
+  });
+  const tx = (fn) => Effect.gen(function* () {
+    const client = yield* DrizzleTx;
+    return yield* Effect.tryPromise({
+      try: () => fn(client),
+      catch: (cause) => new DrizzleError({ message: "Database operation failed", cause })
+    });
+  });
+  const withTransaction = (effect) => Effect.gen(function* () {
+    const client = yield* Drizzle;
+    const runFork = yield* FiberSet.makeRuntimePromise();
+    return yield* Effect.tryPromise({
+      try: () => client.transaction(
+        (txClient) => runFork(
+          effect.pipe(
+            Effect.provideService(Drizzle, txClient),
+            Effect.provideService(DrizzleTx, txClient),
+            Effect.mapError((e) => new WrappedTxError("", { cause: e }))
+          )
+        )
+      ),
+      catch: (error) => {
+        if (error instanceof WrappedTxError) return error.cause;
+        return new DrizzleError({
+          message: "Transaction failed",
+          cause: error
+        });
+      }
+    });
+  }).pipe(Effect.scoped);
+  return {
+    db,
+    tx,
+    Drizzle,
+    DrizzleTx,
+    withTransaction,
+    layer: Layer.effect(Drizzle, createClient)
+  };
+}
+export {
+  ChannelTypeId2 as ChannelTypeId,
+  DrizzleError,
+  EffectTypeId,
+  NodeInspectSymbol2 as NodeInspectSymbol,
+  STMTypeId2 as STMTypeId,
+  SinkTypeId2 as SinkTypeId,
+  StreamTypeId2 as StreamTypeId,
+  TagTypeId2 as TagTypeId,
+  Unify,
+  createDatabase
+};
+//# sourceMappingURL=index.js.map

package/dist/for/drizzle/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/for/drizzle/index.ts"],"sourcesContent":["import { Data, Effect, FiberSet, Layer } from 'effect';\nimport * as Channel from 'effect/Channel';\nimport * as Context from 'effect/Context';\nimport * as Inspectable from 'effect/Inspectable';\nimport * as Sink from 'effect/Sink';\nimport * as STM from 'effect/STM';\nimport * as Stream from 'effect/Stream';\nimport * as EUnify from 'effect/Unify';\n\n// TypeScript issue where the return type of createDatabase\n// contains internal Effect types (TagTypeId) that aren't exported\n// from this module,\n// so TypeScript can't \"name\" them in the declaration file.\nexport const TagTypeId = Context.TagTypeId;\nexport const ChannelTypeId = Channel.ChannelTypeId;\nexport const EffectTypeId = Effect.EffectTypeId;\nexport const NodeInspectSymbol = Inspectable.NodeInspectSymbol;\nexport const STMTypeId = STM.STMTypeId;\nexport const SinkTypeId = Sink.SinkTypeId;\nexport const StreamTypeId = Stream.StreamTypeId;\nexport const Unify = EUnify;\n\nexport class DrizzleError extends Data.TaggedError('ff-effect/DrizzleError')<{\n\tmessage: string;\n\tcause?: unknown;\n}> {}\n\ntype AnyDrizzleClient = {\n\ttransaction: (fn: (tx: any) => Promise<any>) => Promise<any>;\n};\n\ntype TxClient<TClient extends AnyDrizzleClient> = Parameters<\n\tParameters<TClient['transaction']>[0]\n>[0];\n\nclass WrappedTxError extends Error {}\n\nconst defaultPrefix = '@ff-effect/Drizzle' as const;\n\nexport function createDatabase<\n\tTClient extends AnyDrizzleClient,\n\tE,\n\tR,\n\tT extends string = typeof defaultPrefix,\n>(createClient: Effect.Effect<TClient, E, R>, opts?: { tagId?: T }) {\n\ttype Client = TClient | TxClient<TClient>;\n\ttype Tx = TxClient<TClient>;\n\n\tconst tagId = (opts?.tagId ?? defaultPrefix) as T;\n\n\ttype Drizzle = typeof tagId;\n\tconst Drizzle = Context.Tag(tagId)<Drizzle, Client>();\n\n\tconst drizzleTxTagId = `${tagId}.tx` as const;\n\ttype DrizzleTx = typeof drizzleTxTagId;\n\tconst DrizzleTx = Context.Tag(drizzleTxTagId)<DrizzleTx, Tx>();\n\n\tconst db = <T>(fn: (client: Client) => Promise<T>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* Drizzle;\n\t\t\treturn yield* Effect.tryPromise({\n\t\t\t\ttry: () => fn(client),\n\t\t\t\tcatch: (cause) =>\n\t\t\t\t\tnew DrizzleError({ message: 'Database operation failed', cause }),\n\t\t\t});\n\t\t});\n\n\t/** Requires being inside withTransaction - enforces transaction at compile time */\n\tconst tx = <T>(fn: (client: Tx) => Promise<T>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* DrizzleTx;\n\t\t\treturn yield* Effect.tryPromise({\n\t\t\t\ttry: () => fn(client),\n\t\t\t\tcatch: (cause) =>\n\t\t\t\t\tnew DrizzleError({ message: 'Database operation failed', cause }),\n\t\t\t});\n\t\t});\n\n\tconst withTransaction = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n\t\tEffect.gen(function* () {\n\t\t\tconst client = yield* Drizzle;\n\t\t\tconst runFork =\n\t\t\t\tyield* FiberSet.makeRuntimePromise<Exclude<R, DrizzleTx>>();\n\n\t\t\treturn yield* Effect.tryPromise<A, E | DrizzleError>({\n\t\t\t\ttry: () =>\n\t\t\t\t\t(client as TClient).transaction((txClient) =>\n\t\t\t\t\t\trunFork(\n\t\t\t\t\t\t\teffect.pipe(\n\t\t\t\t\t\t\t\tEffect.provideService(Drizzle, txClient as Client),\n\t\t\t\t\t\t\t\tEffect.provideService(DrizzleTx, txClient as Tx),\n\t\t\t\t\t\t\t\tEffect.mapError((e) => new WrappedTxError('', { cause: e })),\n\t\t\t\t\t\t\t) as Effect.Effect<A, WrappedTxError, Exclude<R, DrizzleTx>>,\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\tcatch: (error) => {\n\t\t\t\t\tif (error instanceof WrappedTxError) return error.cause as E;\n\t\t\t\t\treturn new DrizzleError({\n\t\t\t\t\t\tmessage: 'Transaction failed',\n\t\t\t\t\t\tcause: error,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t});\n\t\t}).pipe(Effect.scoped);\n\n\treturn {\n\t\tdb,\n\t\ttx,\n\t\tDrizzle,\n\t\tDrizzleTx,\n\t\twithTransaction,\n\t\tlayer: Layer.effect(Drizzle, createClient),\n\t};\n}\n"],"mappings":";AAAA,SAAS,MAAM,QAAQ,UAAU,aAAa;AAC9C,YAAY,aAAa;AACzB,YAAY,aAAa;AACzB,YAAY,iBAAiB;AAC7B,YAAY,UAAU;AACtB,YAAY,SAAS;AACrB,YAAY,YAAY;AACxB,YAAY,YAAY;AAMjB,IAAMA,aAAoB;AAC1B,IAAMC,iBAAwB;AAC9B,IAAM,eAAe,OAAO;AAC5B,IAAMC,qBAAgC;AACtC,IAAMC,aAAgB;AACtB,IAAMC,cAAkB;AACxB,IAAMC,gBAAsB;AAC5B,IAAM,QAAQ;AAEd,IAAM,eAAN,cAA2B,KAAK,YAAY,wBAAwB,EAGxE;AAAC;AAUJ,IAAM,iBAAN,cAA6B,MAAM;AAAC;AAEpC,IAAM,gBAAgB;AAEf,SAAS,eAKd,cAA4C,MAAsB;AAInE,QAAM,QAAS,MAAM,SAAS;AAG9B,QAAM,UAAkB,YAAI,KAAK,EAAmB;AAEpD,QAAM,iBAAiB,GAAG,KAAK;AAE/B,QAAM,YAAoB,YAAI,cAAc,EAAiB;AAE7D,QAAM,KAAK,CAAI,OACd,OAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,WAAO,OAAO,OAAO,WAAW;AAAA,MAC/B,KAAK,MAAM,GAAG,MAAM;AAAA,MACpB,OAAO,CAAC,UACP,IAAI,aAAa,EAAE,SAAS,6BAA6B,MAAM,CAAC;AAAA,IAClE,CAAC;AAAA,EACF,CAAC;AAGF,QAAM,KAAK,CAAI,OACd,OAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,WAAO,OAAO,OAAO,WAAW;AAAA,MAC/B,KAAK,MAAM,GAAG,MAAM;AAAA,MACpB,OAAO,CAAC,UACP,IAAI,aAAa,EAAE,SAAS,6BAA6B,MAAM,CAAC;AAAA,IAClE,CAAC;AAAA,EACF,CAAC;AAEF,QAAM,kBAAkB,CAAU,WACjC,OAAO,IAAI,aAAa;AACvB,UAAM,SAAS,OAAO;AACtB,UAAM,UACL,OAAO,SAAS,mBAA0C;AAE3D,WAAO,OAAO,OAAO,WAAgC;AAAA,MACpD,KAAK,MACH,OAAmB;AAAA,QAAY,CAAC,aAChC;AAAA,UACC,OAAO;AAAA,YACN,OAAO,eAAe,SAAS,QAAkB;AAAA,YACjD,OAAO,eAAe,WAAW,QAAc;AAAA,YAC/C,OAAO,SAAS,CAAC,MAAM,IAAI,eAAe,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAAA,UAC5D;AAAA,QACD;AAAA,MACD;AAAA,MACD,OAAO,CAAC,UAAU;AACjB,YAAI,iBAAiB,eAAgB,QAAO,MAAM;AAClD,eAAO,IAAI,aAAa;AAAA,UACvB,SAAS;AAAA,UACT,OAAO;AAAA,QACR,CAAC;AAAA,MACF;AAAA,IACD,CAAC;AAAA,EACF,CAAC,EAAE,KAAK,OAAO,MAAM;AAEtB,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO,MAAM,OAAO,SAAS,YAAY;AAAA,EAC1C;AACD;","names":["TagTypeId","ChannelTypeId","NodeInspectSymbol","STMTypeId","SinkTypeId","StreamTypeId"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ff-effect",
-	"version": "0.0.7",
+	"version": "0.0.10",
 	"type": "module",
 	"exports": {
 		".": {
@@ -20,23 +20,35 @@
 	],
 	"scripts": {
 		"build": "tsup",
-		"test": "vitest run",
+		"test": "bun -b vitest run",
 		"dev": "tsup --watch"
 	},
 	"devDependencies": {
+		"@effect/platform": "^0.94.2",
+		"@effect/platform-bun": "^0.87.1",
+		"@effect/platform-node": "^0.104.1",
 		"@effect/vitest": "^0.27.0",
+		"@electric-sql/pglite": "^0.3.15",
+		"@libsql/client": "^0.17.0",
 		"@orpc/contract": "^1.11.3",
 		"@orpc/server": "^1.11.3",
 		"@total-typescript/tsconfig": "^1.0.4",
 		"@types/bun": "^1.3.2",
+		"@typescript/native-preview": "^7.0.0-dev.20260122.4",
 		"tsup": "^8.5.0",
 		"typescript": "^5.9.3",
 		"valibot": "^1.1.0",
 		"vitest": "^4.0.10"
 	},
 	"peerDependencies": {
+		"drizzle-orm": "^0.44.7",
 		"effect": "^3.19.3"
 	},
+	"peerDependenciesMeta": {
+		"drizzle-orm": {
+			"optional": true
+		}
+	},
 	"publishConfig": {
 		"access": "public"
 	},

package/src/for/drizzle/index.test.ts

@@ -0,0 +1,209 @@
+import * as BunContext from '@effect/platform-bun/BunContext';
+import { describe, expect, layer } from '@effect/vitest';
+import { PGlite } from '@electric-sql/pglite';
+import { pgTable, text } from 'drizzle-orm/pg-core';
+import { drizzle } from 'drizzle-orm/pglite';
+import { Effect, Layer } from 'effect';
+import { expectTypeOf } from 'vitest';
+import { createDatabase, DrizzleError } from './index.js';
+
+const users = pgTable('users', {
+	id: text('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const schema = { users };
+
+export class TestDb extends Effect.Service<TestDb>()('TestDb', {
+	accessors: true,
+	scoped: Effect.gen(function* () {
+		const db = new PGlite();
+		yield* Effect.promise(async () => {
+			await db.query('DROP TABLE IF EXISTS users');
+			await db.query(
+				'CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT NOT NULL)',
+			);
+		});
+
+		const dump = yield* Effect.promise(() => db.dumpDataDir());
+
+		return {
+			get: () =>
+				Effect.gen(function* () {
+					const db = new PGlite('memory://', { loadDataDir: dump });
+					return drizzle(db, { schema });
+				}),
+		};
+	}),
+}) {}
+
+layer(Layer.mergeAll(BunContext.layer, TestDb.Default))((it) => {
+	describe('db', () => {
+		it.scoped('wraps promises and returns correct data', () =>
+			Effect.gen(function* () {
+				const testDb = yield* TestDb.get();
+				yield* Effect.promise(() =>
+					testDb.insert(users).values({ id: '1', name: 'Alice' }),
+				);
+
+				const database = createDatabase(Effect.succeed(testDb));
+
+				const result = yield* database
+					.db((d) => d.select().from(users))
+					.pipe(Effect.provide(database.layer));
+
+				expect(result).toEqual([{ id: '1', name: 'Alice' }]);
+			}),
+		);
+
+		it.scoped('surfaces errors as DrizzleError', () =>
+			Effect.gen(function* () {
+				const testDb = yield* TestDb.get();
+
+				const database = createDatabase(Effect.succeed(testDb));
+
+				const result = yield* database
+					.db(() => Promise.reject(new Error('DB failure')))
+					.pipe(Effect.provide(database.layer), Effect.flip);
+
+				expect(result).toBeInstanceOf(DrizzleError);
+				expect(result.message).toBe('Database operation failed');
+				expect(result.cause).toBeInstanceOf(Error);
+				expect((result.cause as Error).message).toBe('DB failure');
+			}),
+		);
+	});
+
+	describe('withTransaction', () => {
+		it.scoped('provides transaction context to nested db calls', () =>
+			Effect.gen(function* () {
+				const testDb = yield* TestDb.get();
+
+				const database = createDatabase(Effect.succeed(testDb));
+
+				yield* Effect.gen(function* () {
+					const ok = 'ok' as const;
+					const txResult = yield* database.withTransaction(
+						Effect.gen(function* () {
+							yield* database.db((d) =>
+								d.insert(users).values({ id: '1', name: 'Bob' }),
+							);
+							yield* database.db((d) =>
+								d.insert(users).values({ id: '2', name: 'Carol' }),
+							);
+							return ok;
+						}),
+					);
+					expectTypeOf(txResult).toEqualTypeOf<typeof ok>();
+
+					const result = yield* database.db((d) => d.select().from(users));
+					expect(result).toHaveLength(2);
+					expect(result).toEqual([
+						{ id: '1', name: 'Bob' },
+						{ id: '2', name: 'Carol' },
+					]);
+				}).pipe(Effect.provide(database.layer));
+			}),
+		);
+
+		it.scoped('rolls back on error', () =>
+			Effect.gen(function* () {
+				const testDb = yield* TestDb.get();
+
+				const database = createDatabase(Effect.succeed(testDb));
+
+				const result = yield* Effect.gen(function* () {
+					const txResult = yield* database
+						.withTransaction(
+							Effect.gen(function* () {
+								yield* database.db((d) =>
+									d.insert(users).values({ id: '1', name: 'Dave' }),
+								);
+
+								yield* database.tx((d) =>
+									d.insert(users).values({ id: '2', name: 'Bob' }),
+								);
+								return yield* Effect.fail(new Error('Intentional failure'));
+							}),
+						)
+						.pipe(Effect.either);
+
+					expect(txResult._tag).toBe('Left');
+
+					return yield* database.db((d) => d.select().from(users));
+				}).pipe(Effect.provide(database.layer));
+
+				expect(result).toEqual([]);
+			}),
+		);
+	});
+
+	describe('multiple database', () => {
+		it.scoped(
+			'allows creating multiple database instances with different tagIds',
+			() =>
+				Effect.gen(function* () {
+					const testDb = yield* TestDb;
+					const database1 = createDatabase(testDb.get());
+
+					const database2Identifier = 'custom-db' as const;
+					const database2 = createDatabase(testDb.get(), {
+						tagId: database2Identifier,
+					});
+
+					const firstDbEffect = Effect.gen(function* () {
+						yield* database1.db((d) =>
+							d.insert(users).values({ id: '1', name: 'Eve' }),
+						);
+					});
+					expectTypeOf(firstDbEffect).toEqualTypeOf<
+						Effect.Effect<
+							void,
+							DrizzleError,
+							typeof database1.Drizzle.Identifier
+						>
+					>();
+
+					const secondDbEffect = Effect.gen(function* () {
+						yield* database2.db((d) =>
+							d.insert(users).values({ id: '2', name: 'Frank' }),
+						);
+					});
+					expectTypeOf(secondDbEffect).toEqualTypeOf<
+						Effect.Effect<void, DrizzleError, typeof database2Identifier>
+					>();
+
+					const main = Effect.gen(function* () {
+						yield* firstDbEffect;
+						yield* secondDbEffect;
+
+						yield* database1
+							.db((d) => d.select().from(users))
+							.pipe(
+								Effect.flatMap((result) =>
+									Effect.sync(() => {
+										expect(result).toEqual([{ id: '1', name: 'Eve' }]);
+									}),
+								),
+							);
+
+						yield* database2
+							.db((d) => d.select().from(users))
+							.pipe(
+								Effect.flatMap((result) =>
+									Effect.sync(() => {
+										expect(result).toEqual([{ id: '2', name: 'Frank' }]);
+									}),
+								),
+							);
+					}).pipe(
+						Effect.provide(database1.layer),
+						Effect.provide(database2.layer),
+					);
+
+					yield* main;
+					expectTypeOf(main).toEqualTypeOf<Effect.Effect<void, DrizzleError>>();
+				}),
+		);
+	});
+});

package/src/for/drizzle/index.ts

@@ -0,0 +1,114 @@
+import { Data, Effect, FiberSet, Layer } from 'effect';
+import * as Channel from 'effect/Channel';
+import * as Context from 'effect/Context';
+import * as Inspectable from 'effect/Inspectable';
+import * as Sink from 'effect/Sink';
+import * as STM from 'effect/STM';
+import * as Stream from 'effect/Stream';
+import * as EUnify from 'effect/Unify';
+
+// TypeScript issue where the return type of createDatabase
+// contains internal Effect types (TagTypeId) that aren't exported
+// from this module,
+// so TypeScript can't "name" them in the declaration file.
+export const TagTypeId = Context.TagTypeId;
+export const ChannelTypeId = Channel.ChannelTypeId;
+export const EffectTypeId = Effect.EffectTypeId;
+export const NodeInspectSymbol = Inspectable.NodeInspectSymbol;
+export const STMTypeId = STM.STMTypeId;
+export const SinkTypeId = Sink.SinkTypeId;
+export const StreamTypeId = Stream.StreamTypeId;
+export const Unify = EUnify;
+
+export class DrizzleError extends Data.TaggedError('ff-effect/DrizzleError')<{
+	message: string;
+	cause?: unknown;
+}> {}
+
+type AnyDrizzleClient = {
+	transaction: (fn: (tx: any) => Promise<any>) => Promise<any>;
+};
+
+type TxClient<TClient extends AnyDrizzleClient> = Parameters<
+	Parameters<TClient['transaction']>[0]
+>[0];
+
+class WrappedTxError extends Error {}
+
+const defaultPrefix = '@ff-effect/Drizzle' as const;
+
+export function createDatabase<
+	TClient extends AnyDrizzleClient,
+	E,
+	R,
+	T extends string = typeof defaultPrefix,
+>(createClient: Effect.Effect<TClient, E, R>, opts?: { tagId?: T }) {
+	type Client = TClient | TxClient<TClient>;
+	type Tx = TxClient<TClient>;
+
+	const tagId = (opts?.tagId ?? defaultPrefix) as T;
+
+	type Drizzle = typeof tagId;
+	const Drizzle = Context.Tag(tagId)<Drizzle, Client>();
+
+	const drizzleTxTagId = `${tagId}.tx` as const;
+	type DrizzleTx = typeof drizzleTxTagId;
+	const DrizzleTx = Context.Tag(drizzleTxTagId)<DrizzleTx, Tx>();
+
+	const db = <T>(fn: (client: Client) => Promise<T>) =>
+		Effect.gen(function* () {
+			const client = yield* Drizzle;
+			return yield* Effect.tryPromise({
+				try: () => fn(client),
+				catch: (cause) =>
+					new DrizzleError({ message: 'Database operation failed', cause }),
+			});
+		});
+
+	/** Requires being inside withTransaction - enforces transaction at compile time */
+	const tx = <T>(fn: (client: Tx) => Promise<T>) =>
+		Effect.gen(function* () {
+			const client = yield* DrizzleTx;
+			return yield* Effect.tryPromise({
+				try: () => fn(client),
+				catch: (cause) =>
+					new DrizzleError({ message: 'Database operation failed', cause }),
+			});
+		});
+
+	const withTransaction = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+		Effect.gen(function* () {
+			const client = yield* Drizzle;
+			const runFork =
+				yield* FiberSet.makeRuntimePromise<Exclude<R, DrizzleTx>>();
+
+			return yield* Effect.tryPromise<A, E | DrizzleError>({
+				try: () =>
+					(client as TClient).transaction((txClient) =>
+						runFork(
+							effect.pipe(
+								Effect.provideService(Drizzle, txClient as Client),
+								Effect.provideService(DrizzleTx, txClient as Tx),
+								Effect.mapError((e) => new WrappedTxError('', { cause: e })),
+							) as Effect.Effect<A, WrappedTxError, Exclude<R, DrizzleTx>>,
+						),
+					),
+				catch: (error) => {
+					if (error instanceof WrappedTxError) return error.cause as E;
+					return new DrizzleError({
+						message: 'Transaction failed',
+						cause: error,
+					});
+				},
+			});
+		}).pipe(Effect.scoped);
+
+	return {
+		db,
+		tx,
+		Drizzle,
+		DrizzleTx,
+		withTransaction,
+		layer: Layer.effect(Drizzle, createClient),
+	};
+}