import {
clientRpcRequiredScopes,
sessionGrantsScope,
authScopeRequiredResponse,
EnvironmentAuthorizationError,
type EnvironmentId,
type AuthSessionState,
type AuthEnvironmentScope,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import type { EnvironmentRegistry } from "../connection/registry.ts";
import { createEnvironmentSessionAtoms } from "./session.ts";
function makeCommandPermissions<R, E>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,
method: string,
) {
const sessions = createEnvironmentSessionAtoms(runtime);
const requiredScopes = (input?: unknown) => clientRpcRequiredScopes(method, input);
const atomsByEnvironment = Atom.family((environmentId: EnvironmentId | null) =>
Atom.family((scopeKey: string) =>
Atom.make((get) => {
if (environmentId === null) return false;
const scopes = scopeKey.split(",").filter(Boolean) as AuthEnvironmentScope[];
if (scopes.length === 0) return true;
const result = get(sessions.sessionStateAtom(environmentId));
const session = AsyncResult.getOrElse(result, () => null);
return (
result._tag !== "Failure" &&
session !== null &&
scopes.every((scope) => sessionGrantsScope(session, scope))
);
}),
),
);
const permissionAtom = (environmentId: EnvironmentId | null, input?: unknown) =>
atomsByEnvironment(environmentId)(requiredScopes(input).join(","));
const authorize = (
registry: AtomRegistry.AtomRegistry,
environmentId: EnvironmentId,
input?: unknown,
) =>
Effect.suspend(() => {
const scopes = requiredScopes(input);
if (scopes.length === 0) return Effect.void;
const atom = sessions.sessionStateAtom(environmentId);
return Effect.scoped(
Effect.gen(function* () {
yield* AtomRegistry.mount(registry, atom);
const session = yield* AtomRegistry.getResult(registry, atom, {
suspendOnWaiting: false,
}).pipe(
Effect.timeoutOption(6_000),
Effect.orElseSucceed(() => Option.none<AuthSessionState>()),
);
const missing = scopes.find(
(scope) => Option.isNone(session) || !sessionGrantsScope(session.value, scope),
);
if (missing !== undefined)
return yield* new EnvironmentAuthorizationError({
...authScopeRequiredResponse(missing),
message: `This connection requires ${missing}.`,
});
}),
);
});
return { requiredScopes, permissionAtom, authorize };
}
const permissionsByRuntime = new WeakMap<
object,
Map<string, ReturnType<typeof makeCommandPermissions>>
>();
export function createCommandPermissions<R, E>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,
method: string,
) {
let permissions = permissionsByRuntime.get(runtime);
if (permissions === undefined) {
permissions = new Map();
permissionsByRuntime.set(runtime, permissions);
}
const existing = permissions.get(method);
if (existing !== undefined) return existing;
const created = makeCommandPermissions(runtime, method);
permissions.set(method, created);
return created;
}