Function makeFumaClient

packages/core/sdk/src/fuma-runtime.ts:355–401

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

};

export const makeFumaClient = (db: FumaDb, options: MakeFumaClientOptions = {}): IFumaClient => {
  const rebind = (handle: FumaDb): FumaDb =>
    options.context === undefined ? handle : withQueryContext(handle, options.context);
  const use: IFumaClient["use"] = (label, fn) =>
    Effect.flatMap(Effect.service(activeFumaDbRef), (active) =>
      fumaEffect(label, () => fn(makeSafeFumaQuery(rebind(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: PendingCommitHook[] = [];
      return Effect.contextWith((context) =>
        Effect.tryPromise({
          try: () =>
            db.transaction(async (transactionDb) => {
              const exit = await Effect.runPromiseExitWith(context)(
                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(() => runCommitHooks(commitHooks))),
      );
    }).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));