Composing Functionality within Services in Effect

export type Operation<R, E, A, B> = {
    tag: Context.Tag<Operation<R, E, A, B>, Operation<R, E, A, B>>;
    readonly execute: (input: A) => Effect.Effect<R, E, B>;
};

export const GetUserById = Context.Tag<
    Operation<never, Error, string, User>
>("Operation/GetUserById");

export const GetUserByIdLive = Layer.effect(
    GetUserById,
    Effect.gen(function* (_) {
        const userService = yield* _(UserService);

        return GetUserById.of({
            tag: GetUserById,
            execute: (userId: string) => {
                return userService.findById(userId);
            },
        });
    })
);

export const DeleteUser = Context.Tag<
    Operation<Transaction, Error, User, void>
>("Operation/DeleteUser");

export const DeleteUserLive = Layer.effect(
    DeleteUser,
    Effect.gen(function* (_) {
        const userService = yield* _(UserService);

        return DeleteUser.of({
            tag: DeleteUser,
            execute: (user: User) => {
                return userService.delete(user.id);
            },
        });
    })
);

export const DeleteUserById = Context.Tag<
    Operation<Transaction, Error, string, void>
>("Operation/DeleteUserById");

export const DeleteUserByIdLive = Layer.effect(
    DeleteUserById,
    Effect.gen(function* (_) {
        const getUser = yield* _(GetUserById);
        const deleteUser = yield* _(DeleteUser);

        return DeleteUserById.of({
            tag: DeleteUserById,
            execute: (userId: string) => {
                return pipe(
                    getUser.execute(userId),
                    Effect.flatMap(deleteUser.execute)
                );
            },
        });
    })
);

const deleteUserById = pipe(
    getUser.execute(userId),
    RTE.flatMap(deleteUser.execute)
)

const result = deleteUserById(deps)();