@shivaedev/identity 0.4.0 → 0.5.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +19 -13
- package/dist/identity.d.ts +19 -6
- package/dist/identity.d.ts.map +1 -1
- package/dist/identity.js +9 -1
- package/dist/identity.js.map +1 -1
- package/dist/middleware.d.ts +2 -0
- package/dist/middleware.d.ts.map +1 -1
- package/dist/middleware.js +5 -4
- package/dist/middleware.js.map +1 -1
- package/dist/permission.d.ts +7 -8
- package/dist/permission.d.ts.map +1 -1
- package/dist/permission.js +4 -12
- package/dist/permission.js.map +1 -1
- package/dist/server/adapters/betterAuthSessions.d.ts +1 -1
- package/dist/server/adapters/betterAuthSessions.d.ts.map +1 -1
- package/dist/server/adapters/betterAuthSessions.js +4 -7
- package/dist/server/adapters/betterAuthSessions.js.map +1 -1
- package/dist/server/better-auth/admittedSessions.d.ts +14 -0
- package/dist/server/better-auth/admittedSessions.d.ts.map +1 -0
- package/dist/server/better-auth/admittedSessions.js +32 -0
- package/dist/server/better-auth/admittedSessions.js.map +1 -0
- package/dist/server/better-auth/clientIp.d.ts.map +1 -1
- package/dist/server/better-auth/clientIp.js +2 -1
- package/dist/server/better-auth/clientIp.js.map +1 -1
- package/dist/server/better-auth/mount.d.ts +8 -7
- package/dist/server/better-auth/mount.d.ts.map +1 -1
- package/dist/server/better-auth/mount.js +6 -24
- package/dist/server/better-auth/mount.js.map +1 -1
- package/dist/server/better-auth/mountRoutes.d.ts.map +1 -1
- package/dist/server/better-auth/mountRoutes.js +6 -6
- package/dist/server/better-auth/mountRoutes.js.map +1 -1
- package/dist/server/better-auth/mountedSessions.d.ts +9 -5
- package/dist/server/better-auth/mountedSessions.d.ts.map +1 -1
- package/dist/server/better-auth/mountedSessions.js +5 -5
- package/dist/server/better-auth/mountedSessions.js.map +1 -1
- package/dist/server/better-auth/sessionPermissions.d.ts +2 -1
- package/dist/server/better-auth/sessionPermissions.d.ts.map +1 -1
- package/dist/server/better-auth/sessionPermissions.js +6 -5
- package/dist/server/better-auth/sessionPermissions.js.map +1 -1
- package/dist/server/better-auth/signInGate.d.ts +1 -1
- package/dist/server/better-auth/signInGate.d.ts.map +1 -1
- package/dist/server/better-auth/signInGate.js +2 -3
- package/dist/server/better-auth/signInGate.js.map +1 -1
- package/dist/server/better-auth/userProfiles.d.ts +1 -1
- package/dist/server/better-auth/userProfiles.d.ts.map +1 -1
- package/dist/server/better-auth/userProfiles.js +2 -3
- package/dist/server/better-auth/userProfiles.js.map +1 -1
- package/dist/server/commandChanges.d.ts.map +1 -1
- package/dist/server/commandChanges.js +11 -6
- package/dist/server/commandChanges.js.map +1 -1
- package/dist/server/local.d.ts +4 -3
- package/dist/server/local.d.ts.map +1 -1
- package/dist/server/local.js +0 -4
- package/dist/server/local.js.map +1 -1
- package/dist/server/lookupSession.d.ts +8 -0
- package/dist/server/lookupSession.d.ts.map +1 -0
- package/dist/server/lookupSession.js +23 -0
- package/dist/server/lookupSession.js.map +1 -0
- package/dist/server/origin.d.ts +7 -2
- package/dist/server/origin.d.ts.map +1 -1
- package/dist/server/origin.js +14 -5
- package/dist/server/origin.js.map +1 -1
- package/dist/server/permissions.d.ts +1 -1
- package/dist/server/permissions.d.ts.map +1 -1
- package/dist/server/permissions.js +9 -9
- package/dist/server/permissions.js.map +1 -1
- package/dist/server/providerFailure.d.ts +4 -0
- package/dist/server/providerFailure.d.ts.map +1 -0
- package/dist/server/providerFailure.js +10 -0
- package/dist/server/providerFailure.js.map +1 -0
- package/dist/server/recheckSession.d.ts +5 -0
- package/dist/server/recheckSession.d.ts.map +1 -0
- package/dist/server/recheckSession.js +11 -0
- package/dist/server/recheckSession.js.map +1 -0
- package/dist/server/resolveRole.d.ts +4 -5
- package/dist/server/resolveRole.d.ts.map +1 -1
- package/dist/server/resolveRole.js +1 -2
- package/dist/server/resolveRole.js.map +1 -1
- package/dist/server/revalidateStream.d.ts.map +1 -1
- package/dist/server/revalidateStream.js +2 -2
- package/dist/server/revalidateStream.js.map +1 -1
- package/dist/server/session.d.ts +2 -2
- package/dist/server/session.d.ts.map +1 -1
- package/dist/server/session.js +13 -23
- package/dist/server/session.js.map +1 -1
- package/dist/server/socketSession.d.ts +23 -0
- package/dist/server/socketSession.d.ts.map +1 -0
- package/dist/server/socketSession.js +32 -0
- package/dist/server/socketSession.js.map +1 -0
- package/dist/server/tracing.d.ts.map +1 -1
- package/dist/server/tracing.js +6 -2
- package/dist/server/tracing.js.map +1 -1
- package/dist/server/trustedProxy.d.ts +0 -1
- package/dist/server/trustedProxy.d.ts.map +1 -1
- package/dist/server/trustedProxy.js +1 -4
- package/dist/server/trustedProxy.js.map +1 -1
- package/package.json +8 -8
- package/src/identity.ts +10 -8
- package/src/middleware.ts +7 -4
- package/src/permission.ts +5 -17
- package/src/server/adapters/betterAuthSessions.ts +4 -10
- package/src/server/better-auth/admittedSessions.ts +38 -0
- package/src/server/better-auth/clientIp.ts +2 -1
- package/src/server/better-auth/mount.ts +8 -38
- package/src/server/better-auth/mountRoutes.ts +6 -10
- package/src/server/better-auth/mountedSessions.ts +19 -10
- package/src/server/better-auth/sessionPermissions.ts +10 -6
- package/src/server/better-auth/signInGate.ts +3 -10
- package/src/server/better-auth/userProfiles.ts +3 -10
- package/src/server/commandChanges.ts +46 -33
- package/src/server/local.ts +5 -7
- package/src/server/lookupSession.ts +30 -0
- package/src/server/origin.ts +23 -6
- package/src/server/permissions.ts +20 -16
- package/src/server/providerFailure.ts +13 -0
- package/src/server/recheckSession.ts +13 -0
- package/src/server/resolveRole.ts +4 -2
- package/src/server/revalidateStream.ts +2 -2
- package/src/server/session.ts +14 -22
- package/src/server/socketSession.ts +61 -0
- package/src/server/tracing.ts +8 -2
- package/src/server/trustedProxy.ts +1 -5
- package/dist/server/sessionProfile.d.ts +0 -3
- package/dist/server/sessionProfile.d.ts.map +0 -1
- package/dist/server/sessionProfile.js +0 -4
- package/dist/server/sessionProfile.js.map +0 -1
- package/src/server/sessionProfile.ts +0 -5
package/src/permission.ts
CHANGED
|
@@ -1,25 +1,13 @@
|
|
|
1
|
-
import { Effect, Schema } from "effect";
|
|
2
1
|
import { RpcMiddleware } from "effect/rpc";
|
|
3
|
-
import type
|
|
4
|
-
import {
|
|
5
|
-
import {
|
|
6
|
-
import { type Identity, SessionUser, type SessionUserValue } from "./identity.ts";
|
|
7
|
-
|
|
8
|
-
const Failures = Schema.Union([Unauthorized, AuthUnavailable, Forbidden, MissingReadPolicy, QueryReadDenied]);
|
|
2
|
+
import { hasPermission as evaluateGrant, type Permission } from "@shivaedev/access/permission.ts";
|
|
3
|
+
import type { Identity, SessionUser, SessionUserValue } from "./identity.ts";
|
|
4
|
+
import { IdentityFailures } from "./middleware.ts";
|
|
9
5
|
|
|
10
6
|
export function permissionMiddleware<TSelf>() {
|
|
11
7
|
return <const TName extends string>(name: TName, permission: Permission) =>
|
|
12
|
-
Object.assign(RpcMiddleware.Service<TSelf, { provides: Identity | SessionUser }>()(name, { error:
|
|
8
|
+
Object.assign(RpcMiddleware.Service<TSelf, { provides: Identity | SessionUser }>()(name, { error: IdentityFailures }), { permission });
|
|
13
9
|
}
|
|
14
10
|
|
|
15
11
|
export function hasPermission(user: Pick<SessionUserValue, "id" | "permissions">, permission: Permission): boolean {
|
|
16
|
-
return user.permissions
|
|
17
|
-
}
|
|
18
|
-
|
|
19
|
-
export function requirePermission(permission: Permission) {
|
|
20
|
-
return Effect.flatMap(SessionUser, (user) =>
|
|
21
|
-
hasPermission(user, permission)
|
|
22
|
-
? Effect.succeed(user)
|
|
23
|
-
: Effect.fail(new Forbidden({ message: `Permission required: ${permission.name} (${permission.strength})` })),
|
|
24
|
-
);
|
|
12
|
+
return evaluateGrant(user.permissions, permission);
|
|
25
13
|
}
|
|
@@ -1,21 +1,15 @@
|
|
|
1
1
|
import { Effect, Option, Predicate } from "effect";
|
|
2
2
|
import type { Headers } from "effect/http";
|
|
3
3
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
4
|
-
import {
|
|
5
|
-
import { AuthUnavailable, Unauthorized } from "@shivaedev/errors/taxonomy.ts";
|
|
4
|
+
import { type AuthUnavailable, Unauthorized } from "@shivaedev/errors/taxonomy.ts";
|
|
6
5
|
import type { ProviderAccountValue } from "#identity.ts";
|
|
6
|
+
import { providerFailure } from "#server/providerFailure.ts";
|
|
7
7
|
import type { SessionProvider, SessionShape } from "#server/session.ts";
|
|
8
8
|
export type GetSession<TSession extends SessionShape> = (headers: globalThis.Headers) => Promise<TSession | null>;
|
|
9
9
|
export type GetProviderAccounts = (headers: globalThis.Headers) => Promise<readonly ProviderAccountValue[]>;
|
|
10
10
|
export type SessionWithProviderAccounts<TSession extends SessionShape> = TSession & {
|
|
11
11
|
readonly user: TSession["user"] & { readonly providerAccounts: Effect.Effect<readonly ProviderAccountValue[], AuthUnavailable | Unauthorized> };
|
|
12
12
|
};
|
|
13
|
-
function unavailable(cause: unknown) {
|
|
14
|
-
return Effect.andThen(
|
|
15
|
-
Effect.logError("Authentication provider failed", redact(cause)),
|
|
16
|
-
Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
|
|
17
|
-
);
|
|
18
|
-
}
|
|
19
13
|
export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>): SessionProvider<TSession>;
|
|
20
14
|
export function betterAuthSessions<TSession extends SessionShape>(
|
|
21
15
|
getSession: GetSession<TSession>,
|
|
@@ -24,7 +18,7 @@ export function betterAuthSessions<TSession extends SessionShape>(
|
|
|
24
18
|
export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>, getProviderAccounts?: GetProviderAccounts) {
|
|
25
19
|
const betterAuthSession = Effect.fn("PlatformRpc.betterAuthSession")(function* (headers: Headers.Headers) {
|
|
26
20
|
const transport = new globalThis.Headers(headers);
|
|
27
|
-
const session = yield* Effect.tryPromise(() => getSession(transport)).pipe(Effect.catch((error) =>
|
|
21
|
+
const session = yield* Effect.tryPromise(() => getSession(transport)).pipe(Effect.catch((error) => providerFailure(error.cause)));
|
|
28
22
|
if (session === null || getProviderAccounts === undefined) {
|
|
29
23
|
return Option.fromNullishOr(session);
|
|
30
24
|
}
|
|
@@ -36,7 +30,7 @@ export function betterAuthSessions<TSession extends SessionShape>(getSession: Ge
|
|
|
36
30
|
(cause): Effect.Effect<never, AuthUnavailable | Unauthorized> =>
|
|
37
31
|
Predicate.hasProperty(cause, "statusCode") && cause.statusCode === HttpStatus.fromLiteral("Unauthorized")
|
|
38
32
|
? Effect.fail(new Unauthorized({ message: "Authentication required" }))
|
|
39
|
-
:
|
|
33
|
+
: providerFailure(cause),
|
|
40
34
|
),
|
|
41
35
|
);
|
|
42
36
|
return Option.some({ ...session, user: { ...session.user, providerAccounts } });
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import { Effect, Option } from "effect";
|
|
2
|
+
import { Headers as HttpHeaders } from "effect/http";
|
|
3
|
+
import { betterAuthSessions, type GetSession } from "#server/adapters/betterAuthSessions.ts";
|
|
4
|
+
import { providerFailure } from "#server/providerFailure.ts";
|
|
5
|
+
import type { SessionProvider, SessionShape } from "#server/session.ts";
|
|
6
|
+
import { type BearerSessionsOptions, sessionHeaders } from "./bearerSessions.ts";
|
|
7
|
+
import { fromStorage, type PolicyStorage, type SignInGate } from "./signInGate.ts";
|
|
8
|
+
|
|
9
|
+
interface SessionStorage extends PolicyStorage {
|
|
10
|
+
readonly authCookies: { readonly sessionToken: { readonly name: string } };
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
export function admittedSessions<E>(gate: SignInGate<E>, storage: () => Promise<SessionStorage>, bearerSessions?: BearerSessionsOptions) {
|
|
14
|
+
return <TSession extends SessionShape>(getSession: GetSession<TSession>): SessionProvider<TSession> => {
|
|
15
|
+
const provider = betterAuthSessions(getSession);
|
|
16
|
+
return {
|
|
17
|
+
get: Effect.fnUntraced(function* (headers) {
|
|
18
|
+
const auth = gate.active || bearerSessions !== undefined ? yield* fromStorage(storage) : undefined;
|
|
19
|
+
const selected =
|
|
20
|
+
bearerSessions === undefined || auth === undefined
|
|
21
|
+
? headers
|
|
22
|
+
: HttpHeaders.fromInput(sessionHeaders(new Headers(headers), auth.authCookies.sessionToken.name));
|
|
23
|
+
const session = yield* provider.get(selected);
|
|
24
|
+
if (!gate.active || Option.isNone(session) || auth === undefined) {
|
|
25
|
+
return session;
|
|
26
|
+
}
|
|
27
|
+
const userId = session.value.user.id;
|
|
28
|
+
const admitted = yield* gate.admitsUser(auth, userId).pipe(Effect.catch(providerFailure));
|
|
29
|
+
if (admitted) {
|
|
30
|
+
return session;
|
|
31
|
+
}
|
|
32
|
+
yield* fromStorage(() => auth.internalAdapter.deleteUserSessions(userId));
|
|
33
|
+
yield* Effect.logInfo("The sign-in policy revoked a user's sessions").pipe(Effect.annotateLogs({ userId }));
|
|
34
|
+
return Option.none();
|
|
35
|
+
}),
|
|
36
|
+
};
|
|
37
|
+
};
|
|
38
|
+
}
|
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
import { getIP } from "better-auth/api";
|
|
2
2
|
import { Option } from "effect";
|
|
3
3
|
import type { HttpServerRequest } from "effect/http";
|
|
4
|
-
import { trustedProxyPeer
|
|
4
|
+
import { trustedProxyPeer } from "#server/local.ts";
|
|
5
|
+
import { trustedProxyRanges } from "#server/trustedProxyRanges.ts";
|
|
5
6
|
|
|
6
7
|
export const PEER_IP_HEADER = "x-platform-client-ip";
|
|
7
8
|
|
|
@@ -2,15 +2,14 @@ import { type BetterAuthOptions, betterAuth } from "better-auth";
|
|
|
2
2
|
import { Config, Effect, Option, Redacted } from "effect";
|
|
3
3
|
import { Pool, type PoolClient, type PoolConfig } from "pg";
|
|
4
4
|
import type { RoleSet } from "@shivaedev/access/roleSet.ts";
|
|
5
|
-
import type
|
|
6
|
-
import { type BearerSessionsOptions, sessionHeaders, withBearerSessions } from "#server/better-auth/bearerSessions.ts";
|
|
5
|
+
import { type BearerSessionsOptions, withBearerSessions } from "#server/better-auth/bearerSessions.ts";
|
|
7
6
|
import { PEER_IP_HEADER } from "#server/better-auth/clientIp.ts";
|
|
8
7
|
import { memoryRateLimit } from "#server/better-auth/memoryRateLimit.ts";
|
|
9
8
|
import { mountRoutes } from "#server/better-auth/mountRoutes.ts";
|
|
10
|
-
import {
|
|
9
|
+
import { revokeUnadmitted } from "#server/better-auth/revokeUnadmitted.ts";
|
|
11
10
|
import { type PolicyStorage, type SignInPolicy, signInGate } from "#server/better-auth/signInGate.ts";
|
|
12
11
|
import { signInPolicyOptions } from "#server/better-auth/signInPolicy.ts";
|
|
13
|
-
import
|
|
12
|
+
import { admittedSessions } from "./admittedSessions.ts";
|
|
14
13
|
import { mountedSessions } from "./mountedSessions.ts";
|
|
15
14
|
|
|
16
15
|
export interface BetterAuthMountOptions<E = never, R = never> {
|
|
@@ -75,40 +74,11 @@ export const betterAuthMount = Effect.fn("Platform.betterAuthMount")(function* <
|
|
|
75
74
|
roles: mount.roles,
|
|
76
75
|
trustedProxy,
|
|
77
76
|
});
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
run(
|
|
84
|
-
Effect.gen(function* () {
|
|
85
|
-
const { authCookies } = yield* Effect.promise(() => auth.$context);
|
|
86
|
-
const selected = mount.bearerSessions === undefined ? headers : sessionHeaders(headers, authCookies.sessionToken.name);
|
|
87
|
-
const session = yield* Effect.tryPromise(() => getSession(selected));
|
|
88
|
-
if (!gate.active || session === null) {
|
|
89
|
-
return session;
|
|
90
|
-
}
|
|
91
|
-
const storage = yield* Effect.tryPromise(() => auth.$context);
|
|
92
|
-
if (yield* gate.admitsUser(storage, session.user.id)) {
|
|
93
|
-
return session;
|
|
94
|
-
}
|
|
95
|
-
yield* Effect.tryPromise(() => storage.internalAdapter.deleteUserSessions(session.user.id));
|
|
96
|
-
yield* Effect.logInfo("The sign-in policy revoked a user's sessions").pipe(Effect.annotateLogs({ userId: session.user.id }));
|
|
97
|
-
return null;
|
|
98
|
-
}),
|
|
99
|
-
);
|
|
100
|
-
}
|
|
101
|
-
const revoke: RevokeUnadmitted<E> = Effect.provideContext(
|
|
102
|
-
revokeUnadmitted(gate, () => auth.$context),
|
|
103
|
-
context,
|
|
104
|
-
);
|
|
105
|
-
const lookupSession = Reflect.get(auth.api, "getSession");
|
|
106
|
-
const sessions = mountedSessions(
|
|
107
|
-
(headers) => lookupSession({ asResponse: false, headers, query: { disableCookieCache: true }, returnHeaders: false }),
|
|
108
|
-
admittedSessions,
|
|
109
|
-
mount.roles,
|
|
110
|
-
);
|
|
111
|
-
return { admittedSessions, auth, revokeUnadmitted: revoke, routes: authRoutes, sessions };
|
|
77
|
+
const admit = admittedSessions(gate, () => auth.$context, mount.bearerSessions);
|
|
78
|
+
const revoke = revokeUnadmitted(gate, () => auth.$context);
|
|
79
|
+
const lookupSession: unknown = Reflect.get(auth.api, "getSession");
|
|
80
|
+
const sessions = mountedSessions(lookupSession, admit, mount.roles);
|
|
81
|
+
return { admittedSessions: admit, auth, revokeUnadmitted: revoke, routes: authRoutes, sessions };
|
|
112
82
|
});
|
|
113
83
|
|
|
114
84
|
export const authDatabase = Effect.fn("Platform.authDatabase")(function* (
|
|
@@ -2,8 +2,8 @@ import { Effect } from "effect";
|
|
|
2
2
|
import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
|
|
3
3
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
4
4
|
import type { RoleSet } from "@shivaedev/access/roleSet.ts";
|
|
5
|
-
import { redact } from "@shivaedev/errors/redact.ts";
|
|
6
5
|
import { type BearerSessionsOptions, cookieSessionResponse, hasSessionCookie, sessionHeaders } from "#server/better-auth/bearerSessions.ts";
|
|
6
|
+
import { providerFailure } from "#server/providerFailure.ts";
|
|
7
7
|
import { clientIpHeaders } from "./clientIp.ts";
|
|
8
8
|
import { sessionPermissions } from "./sessionPermissions.ts";
|
|
9
9
|
|
|
@@ -46,16 +46,16 @@ async function providerResponse(auth: MountedAuth, web: Request, options: MountR
|
|
|
46
46
|
}
|
|
47
47
|
return native ? response : cookieSessionResponse(response);
|
|
48
48
|
}
|
|
49
|
-
|
|
49
|
+
const authResponse = Effect.fnUntraced(function* (auth: MountedAuth, web: Request, options: MountRouteOptions) {
|
|
50
50
|
const sessionRequest = options.roles !== undefined && new URL(web.url).pathname === "/api/auth/get-session";
|
|
51
51
|
const url = new URL(web.url);
|
|
52
52
|
if (sessionRequest) {
|
|
53
53
|
url.searchParams.set("disableCookieCache", "true");
|
|
54
54
|
}
|
|
55
55
|
const request = sessionRequest ? new Request(url, web) : web;
|
|
56
|
-
const response =
|
|
57
|
-
return sessionRequest && response.ok && options.roles !== undefined ? sessionPermissions(response, options.roles) : response;
|
|
58
|
-
}
|
|
56
|
+
const response = yield* Effect.tryPromise(() => providerResponse(auth, request, options));
|
|
57
|
+
return sessionRequest && response.ok && options.roles !== undefined ? yield* sessionPermissions(response, options.roles) : response;
|
|
58
|
+
});
|
|
59
59
|
export function mountRoutes(auth: MountedAuth, options: MountRouteOptions) {
|
|
60
60
|
const setClientIp = clientIpHeaders(options);
|
|
61
61
|
return HttpRouter.use((router) =>
|
|
@@ -63,11 +63,7 @@ export function mountRoutes(auth: MountedAuth, options: MountRouteOptions) {
|
|
|
63
63
|
Effect.gen(function* () {
|
|
64
64
|
const web = yield* HttpServerRequest.toWeb(request);
|
|
65
65
|
setClientIp(request, web);
|
|
66
|
-
return HttpServerResponse.fromWeb(
|
|
67
|
-
yield* Effect.tryPromise(() => authResponse(auth, web, options)).pipe(
|
|
68
|
-
Effect.tapError((error) => Effect.logError("Authentication provider failed", redact(error.cause))),
|
|
69
|
-
),
|
|
70
|
-
);
|
|
66
|
+
return HttpServerResponse.fromWeb(yield* authResponse(auth, web, options).pipe(Effect.catch(providerFailure)));
|
|
71
67
|
}).pipe(
|
|
72
68
|
Effect.catch(() =>
|
|
73
69
|
Effect.succeed(
|
|
@@ -1,21 +1,30 @@
|
|
|
1
1
|
import { Schema } from "effect";
|
|
2
2
|
import type { RoleSet } from "@shivaedev/access/roleSet.ts";
|
|
3
|
-
import {
|
|
4
|
-
import type {
|
|
3
|
+
import { SessionUserSchema } from "#identity.ts";
|
|
4
|
+
import type { GetSession } from "#server/adapters/betterAuthSessions.ts";
|
|
5
|
+
import type { SessionProvider, SessionShape } from "#server/session.ts";
|
|
5
6
|
|
|
6
|
-
const AuthSession = Schema.NullOr(
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
7
|
+
const AuthSession = Schema.NullOr(Schema.Struct({ user: SessionUserSchema }));
|
|
8
|
+
type SessionLookup = (options: {
|
|
9
|
+
readonly asResponse: false;
|
|
10
|
+
readonly headers: Headers;
|
|
11
|
+
readonly query: { readonly disableCookieCache: true };
|
|
12
|
+
readonly returnHeaders: false;
|
|
13
|
+
}) => Promise<unknown>;
|
|
14
|
+
const SessionLookup = Schema.declare((value): value is SessionLookup => typeof value === "function");
|
|
11
15
|
|
|
12
16
|
export function mountedSessions(
|
|
13
|
-
lookup:
|
|
14
|
-
admit: <TSession extends SessionShape>(getSession: GetSession<TSession>) =>
|
|
17
|
+
lookup: unknown,
|
|
18
|
+
admit: <TSession extends SessionShape>(getSession: GetSession<TSession>) => SessionProvider<TSession>,
|
|
15
19
|
roles?: RoleSet,
|
|
16
20
|
) {
|
|
21
|
+
const getSession = Schema.decodeUnknownSync(SessionLookup)(lookup);
|
|
17
22
|
return {
|
|
18
23
|
...(roles === undefined ? {} : { roles }),
|
|
19
|
-
provider:
|
|
24
|
+
provider: admit(async (headers) =>
|
|
25
|
+
Schema.decodeUnknownSync(AuthSession)(
|
|
26
|
+
await getSession({ asResponse: false, headers, query: { disableCookieCache: true }, returnHeaders: false }),
|
|
27
|
+
),
|
|
28
|
+
),
|
|
20
29
|
};
|
|
21
30
|
}
|
|
@@ -1,18 +1,22 @@
|
|
|
1
|
-
import { Effect, Schema } from "effect";
|
|
1
|
+
import { type Cause, Effect, Schema } from "effect";
|
|
2
2
|
import type { RoleSet } from "@shivaedev/access/roleSet.ts";
|
|
3
|
+
import { SessionUserSchema } from "#identity.ts";
|
|
3
4
|
import { resolveRole } from "#server/resolveRole.ts";
|
|
4
5
|
|
|
5
6
|
const Fields = Schema.Record(Schema.String, Schema.Unknown);
|
|
6
|
-
const SessionPayload = Schema.NullOr(Schema.StructWithRest(Schema.Struct({ user: Fields }), [Fields]));
|
|
7
|
+
const SessionPayload = Schema.NullOr(Schema.StructWithRest(Schema.Struct({ user: Schema.StructWithRest(SessionUserSchema, [Fields]) }), [Fields]));
|
|
7
8
|
|
|
8
|
-
export
|
|
9
|
-
|
|
9
|
+
export const sessionPermissions = Effect.fn("Platform.sessionPermissions")(function* (
|
|
10
|
+
response: Response,
|
|
11
|
+
roles: RoleSet,
|
|
12
|
+
): Effect.fn.Return<Response, Cause.UnknownError | Schema.SchemaError> {
|
|
13
|
+
const payload = yield* Schema.decodeUnknownEffect(SessionPayload)(yield* Effect.tryPromise(() => response.json()));
|
|
10
14
|
if (payload === null) {
|
|
11
15
|
return Response.json(null, response);
|
|
12
16
|
}
|
|
13
|
-
const access =
|
|
17
|
+
const access = yield* resolveRole(roles, payload.user.role);
|
|
14
18
|
const headers = new Headers(response.headers);
|
|
15
19
|
headers.delete("content-length");
|
|
16
20
|
headers.set("cache-control", "private, no-store");
|
|
17
21
|
return Response.json({ ...payload, user: { ...payload.user, ...access } }, { headers, status: response.status });
|
|
18
|
-
}
|
|
22
|
+
});
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { Cache, type Config, Duration, Effect, Exit } from "effect";
|
|
2
|
-
import {
|
|
3
|
-
import { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
|
|
2
|
+
import type { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
|
|
4
3
|
import type { ProviderAccountValue } from "#identity.ts";
|
|
4
|
+
import { providerFailure } from "#server/providerFailure.ts";
|
|
5
5
|
|
|
6
6
|
export interface SignInPolicy<E = never, R = never> {
|
|
7
7
|
readonly accounts?: Config.Config<readonly ProviderAccountValue[]> | undefined;
|
|
@@ -33,14 +33,7 @@ export interface SignInGate<E> {
|
|
|
33
33
|
const RULE_CACHE_CAPACITY = 10_000;
|
|
34
34
|
|
|
35
35
|
export function fromStorage<A>(read: () => Promise<A>) {
|
|
36
|
-
return Effect.tryPromise(read).pipe(
|
|
37
|
-
Effect.catch((error) =>
|
|
38
|
-
Effect.andThen(
|
|
39
|
-
Effect.logError("Sign-in policy storage failed", redact(error.cause)),
|
|
40
|
-
Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
|
|
41
|
-
),
|
|
42
|
-
),
|
|
43
|
-
);
|
|
36
|
+
return Effect.tryPromise(read).pipe(Effect.catch((error) => providerFailure(error.cause)));
|
|
44
37
|
}
|
|
45
38
|
|
|
46
39
|
function sameAccount(left: ProviderAccountValue, right: ProviderAccountValue) {
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import type { Auth } from "better-auth";
|
|
2
2
|
import { Effect } from "effect";
|
|
3
|
-
import {
|
|
4
|
-
import {
|
|
3
|
+
import type { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
|
|
4
|
+
import { providerFailure } from "#server/providerFailure.ts";
|
|
5
5
|
|
|
6
6
|
export interface UserProfile {
|
|
7
7
|
readonly id: string;
|
|
@@ -25,13 +25,6 @@ export const userProfiles = Effect.fn("Platform.userProfiles")(function* (
|
|
|
25
25
|
select: ["id", "name", "image"],
|
|
26
26
|
where: [{ field: "id", operator: "in", value: ids }],
|
|
27
27
|
});
|
|
28
|
-
}).pipe(
|
|
29
|
-
Effect.catch((error) =>
|
|
30
|
-
Effect.andThen(
|
|
31
|
-
Effect.logError("Authentication provider failed", redact(error.cause)),
|
|
32
|
-
Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
|
|
33
|
-
),
|
|
34
|
-
),
|
|
35
|
-
);
|
|
28
|
+
}).pipe(Effect.catch((error) => providerFailure(error.cause)));
|
|
36
29
|
return users.map(({ id, name, image }) => ({ id, image: image ?? null, name }));
|
|
37
30
|
});
|
|
@@ -1,10 +1,11 @@
|
|
|
1
|
-
import { Context, Effect, Option } from "effect";
|
|
1
|
+
import { Context, Effect, Option, Schedule } from "effect";
|
|
2
2
|
import * as Reactivity from "effect/reactivity/Reactivity";
|
|
3
3
|
import type { Rpc } from "effect/rpc";
|
|
4
4
|
import { SqlClient } from "effect/sql";
|
|
5
5
|
import { invalidationKeys } from "@shivaedev/changes/keys.ts";
|
|
6
6
|
import { CurrentViewer } from "@shivaedev/contract/readPolicy.ts";
|
|
7
7
|
import { CommandInvalidation } from "@shivaedev/contract/serverMetadata.ts";
|
|
8
|
+
import { CommandRecovery } from "@shivaedev/sql/internal/CommandRecovery.ts";
|
|
8
9
|
import { ChangeObserver, invalidateOnCommit, transact } from "@shivaedev/sql/transact.ts";
|
|
9
10
|
import { sessionKeyContext } from "#server/sessionKeys.ts";
|
|
10
11
|
|
|
@@ -14,37 +15,49 @@ export function commandChanges<A, E, R>(effect: Effect.Effect<A, E, R>, rpc: Rpc
|
|
|
14
15
|
return effect;
|
|
15
16
|
}
|
|
16
17
|
const declared = invalidates.value.invalidates;
|
|
17
|
-
return Effect.
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
18
|
+
return Effect.uninterruptibleMask((restore) =>
|
|
19
|
+
Effect.gen(function* () {
|
|
20
|
+
const context = yield* sessionKeyContext(rpc);
|
|
21
|
+
const sql = yield* Effect.serviceOption(SqlClient.SqlClient);
|
|
22
|
+
const reactivity = yield* Effect.serviceOption(Reactivity.Reactivity);
|
|
23
|
+
if (Option.isNone(reactivity)) {
|
|
24
|
+
return yield* restore(effect);
|
|
25
|
+
}
|
|
26
|
+
const published = new Set<unknown>();
|
|
27
|
+
const observer = yield* ChangeObserver;
|
|
28
|
+
const result = yield* restore(effect).pipe(
|
|
29
|
+
Effect.provideService(ChangeObserver, (event) => {
|
|
30
|
+
if (event._tag === "Published") {
|
|
31
|
+
for (const key of event.changes) {
|
|
32
|
+
published.add(key);
|
|
33
|
+
}
|
|
31
34
|
}
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
35
|
+
return observer(event);
|
|
36
|
+
}),
|
|
37
|
+
);
|
|
38
|
+
const viewer = yield* CurrentViewer;
|
|
39
|
+
const keys = invalidationKeys(declared(payload, result, viewer), context).filter((key) => !published.has(key));
|
|
40
|
+
if (keys.length > 0) {
|
|
41
|
+
const announce = Option.isNone(sql)
|
|
42
|
+
? reactivity.value.invalidate(keys)
|
|
43
|
+
: invalidateOnCommit(keys).pipe(
|
|
44
|
+
transact({ onSqlError: (error) => error }),
|
|
45
|
+
Effect.provideService(SqlClient.SqlClient, sql.value),
|
|
46
|
+
Effect.provideService(Reactivity.Reactivity, reactivity.value),
|
|
47
|
+
);
|
|
48
|
+
yield* announce.pipe(
|
|
49
|
+
Effect.catchCause(Effect.fail),
|
|
50
|
+
Effect.retry({ schedule: Schedule.exponential("50 millis"), times: 2 }),
|
|
51
|
+
Effect.catch((cause) =>
|
|
52
|
+
Effect.gen(function* () {
|
|
53
|
+
yield* Effect.logError("Committed command invalidation failed; resynchronizing live streams", cause);
|
|
54
|
+
const recover = yield* CommandRecovery;
|
|
55
|
+
yield* recover;
|
|
56
|
+
}),
|
|
57
|
+
),
|
|
58
|
+
);
|
|
59
|
+
}
|
|
60
|
+
return result;
|
|
61
|
+
}),
|
|
62
|
+
);
|
|
50
63
|
}
|
package/src/server/local.ts
CHANGED
|
@@ -3,7 +3,8 @@ import { HttpServerRequest, HttpServerResponse, HttpTraceContext } from "effect/
|
|
|
3
3
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
4
4
|
import { RpcSerialization } from "effect/rpc";
|
|
5
5
|
import { proxyAddresses, proxyMatches } from "./trustedProxy.ts";
|
|
6
|
-
|
|
6
|
+
|
|
7
|
+
type TransportRequest = Pick<HttpServerRequest.HttpServerRequest, "headers" | "remoteAddress">;
|
|
7
8
|
|
|
8
9
|
function loopbackAddress(address: string): boolean {
|
|
9
10
|
const unmapped = unmapAddress(address);
|
|
@@ -23,7 +24,7 @@ function loopbackHost(host: string | undefined): boolean {
|
|
|
23
24
|
const hostname = authority.hostname?.toLowerCase();
|
|
24
25
|
return hostname !== undefined && (hostname === "localhost" || hostname === "[::1]" || loopbackAddress(hostname));
|
|
25
26
|
}
|
|
26
|
-
export function sameOrigin(request:
|
|
27
|
+
export function sameOrigin(request: Pick<TransportRequest, "headers">): boolean {
|
|
27
28
|
const origin = request.headers.origin;
|
|
28
29
|
if (origin === undefined) {
|
|
29
30
|
return true;
|
|
@@ -47,11 +48,8 @@ export function trustedProxyPeer(trustedProxy?: string): (address: string) => bo
|
|
|
47
48
|
const addresses = trustedProxy === undefined ? undefined : proxyAddresses(trustedProxy);
|
|
48
49
|
return (address) => addresses !== undefined && proxyMatches(addresses, address);
|
|
49
50
|
}
|
|
50
|
-
export function trustedProxyRanges(trustedProxy?: string): string[] {
|
|
51
|
-
return normalizedRanges(trustedProxy);
|
|
52
|
-
}
|
|
53
51
|
|
|
54
|
-
function proxyOrigin(request:
|
|
52
|
+
function proxyOrigin(request: TransportRequest, isTrustedProxy: (address: string) => boolean, native: boolean): boolean {
|
|
55
53
|
if (!Option.exists(request.remoteAddress, isTrustedProxy)) {
|
|
56
54
|
return false;
|
|
57
55
|
}
|
|
@@ -69,7 +67,7 @@ function proxyOrigin(request: HttpServerRequest.HttpServerRequest, isTrustedProx
|
|
|
69
67
|
}
|
|
70
68
|
export function localTransport(trustedProxy?: string, nativeOrigins: readonly string[] = []) {
|
|
71
69
|
const isTrustedProxy = trustedProxyPeer(trustedProxy);
|
|
72
|
-
return (request:
|
|
70
|
+
return (request: TransportRequest): boolean => {
|
|
73
71
|
const native = nativeOrigins.includes(request.headers.origin ?? "");
|
|
74
72
|
const local = loopbackHost(request.headers.host) && Option.exists(request.remoteAddress, loopbackAddress);
|
|
75
73
|
return (local && (native || sameOrigin(request))) || proxyOrigin(request, isTrustedProxy, native);
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import { Effect, Option } from "effect";
|
|
2
|
+
import type { Headers } from "effect/http";
|
|
3
|
+
import { Forbidden } from "@shivaedev/errors/taxonomy.ts";
|
|
4
|
+
import { transportOriginRequest } from "./origin.ts";
|
|
5
|
+
import { resolveRole } from "./resolveRole.ts";
|
|
6
|
+
import type { SessionPolicy, SessionShape } from "./session.ts";
|
|
7
|
+
|
|
8
|
+
export const sessionRequest = Effect.fnUntraced(function* (policy: SessionPolicy<SessionShape>, headers: Headers.Headers, rpc: string) {
|
|
9
|
+
const request = yield* transportOriginRequest(headers, rpc);
|
|
10
|
+
if (!policy.origin(request)) {
|
|
11
|
+
return yield* new Forbidden({ message: "Origin not allowed" });
|
|
12
|
+
}
|
|
13
|
+
return request;
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
export const sessionAccess = Effect.fnUntraced(function* <TSession extends SessionShape>(
|
|
17
|
+
policy: SessionPolicy<SessionShape>,
|
|
18
|
+
session: Option.Option<TSession>,
|
|
19
|
+
) {
|
|
20
|
+
if (Option.isNone(session) || policy.roles === undefined) {
|
|
21
|
+
return session;
|
|
22
|
+
}
|
|
23
|
+
const role: unknown = Reflect.get(session.value.user, "role");
|
|
24
|
+
const access = yield* resolveRole(policy.roles, role);
|
|
25
|
+
return Option.some({ ...session.value, user: { ...session.value.user, ...access } });
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
export const lookupSession = Effect.fnUntraced(function* <TSession extends SessionShape>(policy: SessionPolicy<TSession>, headers: Headers.Headers) {
|
|
29
|
+
return yield* sessionAccess(policy, yield* policy.provider.get(headers));
|
|
30
|
+
});
|
package/src/server/origin.ts
CHANGED
|
@@ -1,26 +1,43 @@
|
|
|
1
|
-
import { Option } from "effect";
|
|
2
|
-
import { Headers } from "effect/http";
|
|
1
|
+
import { Effect, Option } from "effect";
|
|
2
|
+
import { Headers, HttpServerRequest } from "effect/http";
|
|
3
|
+
import { localTransport } from "#server/local.ts";
|
|
4
|
+
import { transportHeaders } from "#server/transportHeaders.ts";
|
|
3
5
|
export interface OriginRequest {
|
|
4
6
|
readonly headers: Headers.Headers;
|
|
5
7
|
readonly origin: Option.Option<string>;
|
|
8
|
+
readonly remoteAddress?: Option.Option<string>;
|
|
6
9
|
readonly rpc: string;
|
|
7
10
|
}
|
|
8
11
|
export type OriginPolicy = (request: OriginRequest) => boolean;
|
|
9
12
|
export interface TrustedOriginsOptions {
|
|
10
13
|
readonly allow: readonly string[];
|
|
11
14
|
readonly missing: "allow" | "reject";
|
|
15
|
+
readonly sameOrigin?: { readonly trustedProxy?: string | undefined };
|
|
12
16
|
}
|
|
13
17
|
export function trustedOrigins(options: TrustedOriginsOptions): OriginPolicy {
|
|
14
|
-
|
|
15
|
-
|
|
18
|
+
const sameOrigin = options.sameOrigin === undefined ? undefined : localTransport(options.sameOrigin.trustedProxy);
|
|
19
|
+
return (request) =>
|
|
20
|
+
Option.match(request.origin, {
|
|
16
21
|
onNone: () => options.missing === "allow",
|
|
17
|
-
onSome: (value) =>
|
|
22
|
+
onSome: (value) =>
|
|
23
|
+
options.allow.includes(value) || sameOrigin?.({ headers: request.headers, remoteAddress: request.remoteAddress ?? Option.none() }) === true,
|
|
18
24
|
});
|
|
19
25
|
}
|
|
20
|
-
export function originRequest(headers: Headers.Headers, rpc: string): OriginRequest {
|
|
26
|
+
export function originRequest(headers: Headers.Headers, rpc: string, remoteAddress: Option.Option<string> = Option.none()): OriginRequest {
|
|
21
27
|
return {
|
|
22
28
|
headers,
|
|
23
29
|
origin: Headers.get(headers, "origin"),
|
|
30
|
+
remoteAddress,
|
|
24
31
|
rpc,
|
|
25
32
|
};
|
|
26
33
|
}
|
|
34
|
+
|
|
35
|
+
export const transportOriginRequest = Effect.fn("Identity.transportOriginRequest")(function* (headers: Headers.Headers, rpc: string) {
|
|
36
|
+
const transport = yield* transportHeaders(headers);
|
|
37
|
+
const request = yield* Effect.serviceOption(HttpServerRequest.HttpServerRequest);
|
|
38
|
+
return originRequest(
|
|
39
|
+
transport,
|
|
40
|
+
rpc,
|
|
41
|
+
Option.flatMap(request, (value) => value.remoteAddress),
|
|
42
|
+
);
|
|
43
|
+
});
|
|
@@ -3,33 +3,34 @@ import { type HttpServerRequest, HttpServerResponse } from "effect/http";
|
|
|
3
3
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
4
4
|
import type { RpcMiddleware } from "effect/rpc";
|
|
5
5
|
import type { Permission } from "@shivaedev/access/permission.ts";
|
|
6
|
+
import { forbidden } from "@shivaedev/access/refusal.ts";
|
|
7
|
+
import { requirePermission } from "@shivaedev/access/requirePermission.ts";
|
|
6
8
|
import { authorizeReads } from "@shivaedev/contract/readPolicy.ts";
|
|
7
|
-
import type {
|
|
8
|
-
import {
|
|
9
|
-
import {
|
|
10
|
-
import { hasPermission, type permissionMiddleware
|
|
9
|
+
import type { AuthUnavailable, Forbidden, Unauthorized } from "@shivaedev/errors/taxonomy.ts";
|
|
10
|
+
import { Identity, SessionUser } from "#identity.ts";
|
|
11
|
+
import type { IdentityFailures } from "#middleware.ts";
|
|
12
|
+
import { hasPermission, type permissionMiddleware } from "#permission.ts";
|
|
11
13
|
import { commandChanges } from "#server/commandChanges.ts";
|
|
14
|
+
import { recheckSession } from "./recheckSession.ts";
|
|
12
15
|
import { revalidateStream } from "./revalidateStream.ts";
|
|
13
|
-
import {
|
|
16
|
+
import { type SessionPolicy, type UserSessionShape, withSessionUser } from "./session.ts";
|
|
14
17
|
|
|
15
18
|
export function permissionLayer<TMiddleware, TSession extends UserSessionShape>(
|
|
16
19
|
middleware: ReturnType<ReturnType<typeof permissionMiddleware<TMiddleware>>>,
|
|
17
20
|
policy: SessionPolicy<TSession>,
|
|
18
21
|
) {
|
|
19
22
|
const permission = middleware.permission;
|
|
20
|
-
const guard: RpcMiddleware.RpcMiddleware<
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
never
|
|
24
|
-
> = (effect, { headers, rpc, payload }) => {
|
|
25
|
-
const lookup = Effect.tap(resolveSession(policy, headers, rpc._tag), (session) =>
|
|
26
|
-
Option.isSome(session) && !hasPermission(session.value.user, permission)
|
|
27
|
-
? Effect.fail(new Forbidden({ message: `Permission required: ${permission.name} (${permission.strength})` }))
|
|
28
|
-
: Effect.void,
|
|
23
|
+
const guard: RpcMiddleware.RpcMiddleware<Identity | SessionUser, IdentityFailures, never> = (effect, { headers, rpc, payload }) => {
|
|
24
|
+
const lookup = Effect.tap(recheckSession(policy, headers, rpc._tag), (session) =>
|
|
25
|
+
Option.isSome(session) && !hasPermission(session.value.user, permission) ? Effect.fail(forbidden(permission)) : Effect.void,
|
|
29
26
|
);
|
|
30
27
|
return Effect.flatMap(Identity, (viewer) => authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some(viewer))).pipe(
|
|
31
28
|
(invocation) => Effect.flatMap(Identity, ({ id }) => invocation.pipe(revalidateStream(policy, rpc, id, lookup))),
|
|
32
|
-
(invocation) =>
|
|
29
|
+
(invocation) =>
|
|
30
|
+
Effect.andThen(
|
|
31
|
+
Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
|
|
32
|
+
invocation,
|
|
33
|
+
),
|
|
33
34
|
withSessionUser(policy, headers, rpc._tag),
|
|
34
35
|
);
|
|
35
36
|
};
|
|
@@ -49,7 +50,10 @@ function rejection(error: Unauthorized | Forbidden | AuthUnavailable) {
|
|
|
49
50
|
export function permissionRoute<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>, permission: Permission) {
|
|
50
51
|
return <E, R>(handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) =>
|
|
51
52
|
(request: HttpServerRequest.HttpServerRequest): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Exclude<R, Identity | SessionUser>> =>
|
|
52
|
-
Effect.andThen(
|
|
53
|
+
Effect.andThen(
|
|
54
|
+
Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
|
|
55
|
+
Effect.context<Identity | SessionUser>(),
|
|
56
|
+
).pipe(
|
|
53
57
|
withSessionUser(policy, request.headers, request.url),
|
|
54
58
|
Effect.matchEffect({
|
|
55
59
|
onFailure: (error) => Effect.succeed(rejection(error)),
|