Function makeFumaClient

packages/core/sdk/src/fuma-runtime.ts:294–342

(db: FumaDb, options: MakeFumaClientOptions = {})

};

export const makeFumaClient = (db: FumaDb, options: MakeFumaClientOptions = {}): IFumaClient => {
  const use: IFumaClient["use"] = (label, fn) =>
    Effect.flatMap(Effect.service(activeFumaDbRef), (active) =>
      fumaEffect(label, () => fn(makeSafeFumaQuery(active ?? db, options))),
    ).pipe(Effect.withSpan(`fumadb.${label}`));

  const transaction = <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E | StorageFailure> =>
    Effect.flatMap(Effect.service(activeFumaDbRef), (active) => {
      if (active) return effect as Effect.Effect<unknown, unknown>;

      // The outermost transaction owns the post-commit hook queue; hooks
      // queued anywhere inside (including nested pass-through transactions)
      // run only after THIS commit, and are discarded on rollback.
      const commitHooks: Array<Effect.Effect<void>> = [];
      return Effect.tryPromise({
        try: () =>
          db.transaction(async (transactionDb) => {
            const exit = await Effect.runPromiseExit(
              effect.pipe(
                Effect.provideService(activeFumaDbRef, transactionDb),
                Effect.provideService(pendingCommitHooksRef, commitHooks),
              ),
            );
            if (Exit.isSuccess(exit)) return exit.value;

            const failure = exit.cause.reasons.find(Cause.isFailReason);
            // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: FumaDB transactions roll back when the callback rejects
            if (failure) throw new TransactionEffectFailure(failure.error);
            // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: FumaDB transactions roll back when the callback rejects
            throw new TransactionEffectDefect(exit.cause);
          }),
        catch: (cause): E | StorageFailure => {
          if (cause instanceof TransactionEffectFailure) return cause.error as E;
          if (cause instanceof TransactionEffectDefect) {
            return fumaFailureFromCause("transaction", cause.cause);
          }
          return fumaFailureFromCause("transaction", cause);
        },
      }).pipe(
        Effect.tap(() =>
          Effect.forEach(commitHooks, (hook) => hook.pipe(Effect.ignoreCause({ log: false })), {
            discard: true,
          }),
        ),
      );
    }).pipe(Effect.withSpan("fumadb.transaction")) as Effect.Effect<A, E | StorageFailure>;

  return { use, transaction };
};

export class FumaClient extends Context.Service<FumaClient, IFumaClient>()("executor/FumaClient") {
  static layer = (db: FumaDb) => Layer.succeed(this)(makeFumaClient(db));