@shivaedev/identity 0.16.0 → 0.17.0
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/CHANGELOG.md +18 -0
- package/README.md +79 -53
- package/dist/server/SessionPolicy.d.ts +14 -0
- package/dist/server/SessionPolicy.d.ts.map +1 -0
- package/dist/server/SessionPolicy.js +4 -0
- package/dist/server/SessionPolicy.js.map +1 -0
- package/dist/server/adapters/betterAuthSessions.js +1 -1
- package/dist/server/adapters/betterAuthSessions.js.map +1 -1
- package/dist/server/better-auth/PasswordReset.d.ts +7 -0
- package/dist/server/better-auth/PasswordReset.d.ts.map +1 -0
- package/dist/server/better-auth/PasswordReset.js +2 -0
- package/dist/server/better-auth/PasswordReset.js.map +1 -0
- package/dist/server/better-auth/adapters/passwordResetOptions.d.ts +6 -0
- package/dist/server/better-auth/adapters/passwordResetOptions.d.ts.map +1 -0
- package/dist/server/better-auth/adapters/passwordResetOptions.js +17 -0
- package/dist/server/better-auth/adapters/passwordResetOptions.js.map +1 -0
- package/dist/server/better-auth/mount.d.ts +2 -0
- package/dist/server/better-auth/mount.d.ts.map +1 -1
- package/dist/server/better-auth/mount.js +4 -2
- package/dist/server/better-auth/mount.js.map +1 -1
- package/dist/server/better-auth/sessionPermissions.js +1 -1
- package/dist/server/better-auth/userProfiles.js +1 -1
- package/dist/server/lookupSession.d.ts +5 -4
- package/dist/server/lookupSession.d.ts.map +1 -1
- package/dist/server/lookupSession.js +8 -4
- package/dist/server/lookupSession.js.map +1 -1
- package/dist/server/permissions.d.ts +4 -4
- package/dist/server/permissions.d.ts.map +1 -1
- package/dist/server/permissions.js +11 -8
- package/dist/server/permissions.js.map +1 -1
- package/dist/server/providerAccountsUser.d.ts +16 -0
- package/dist/server/providerAccountsUser.d.ts.map +1 -0
- package/dist/server/providerAccountsUser.js +12 -0
- package/dist/server/providerAccountsUser.js.map +1 -0
- package/dist/server/recheckSession.d.ts +2 -2
- package/dist/server/recheckSession.d.ts.map +1 -1
- package/dist/server/recheckSession.js +5 -3
- package/dist/server/recheckSession.js.map +1 -1
- package/dist/server/revalidateStream.d.ts +3 -2
- package/dist/server/revalidateStream.d.ts.map +1 -1
- package/dist/server/revalidateStream.js +3 -2
- package/dist/server/revalidateStream.js.map +1 -1
- package/dist/server/session.d.ts +9 -21
- package/dist/server/session.d.ts.map +1 -1
- package/dist/server/session.js +28 -27
- package/dist/server/session.js.map +1 -1
- package/package.json +7 -7
- package/src/server/SessionPolicy.ts +14 -0
- package/src/server/adapters/betterAuthSessions.ts +1 -1
- package/src/server/better-auth/PasswordReset.ts +7 -0
- package/src/server/better-auth/adapters/passwordResetOptions.ts +25 -0
- package/src/server/better-auth/mount.ts +6 -2
- package/src/server/better-auth/sessionPermissions.ts +1 -1
- package/src/server/better-auth/userProfiles.ts +1 -1
- package/src/server/lookupSession.ts +9 -8
- package/src/server/permissions.ts +29 -21
- package/src/server/providerAccountsUser.ts +16 -0
- package/src/server/recheckSession.ts +5 -4
- package/src/server/revalidateStream.ts +7 -5
- package/src/server/session.ts +87 -85
|
@@ -9,7 +9,7 @@ export interface UserProfile {
|
|
|
9
9
|
readonly name: string;
|
|
10
10
|
}
|
|
11
11
|
|
|
12
|
-
export const userProfiles = Effect.fn("
|
|
12
|
+
export const userProfiles = Effect.fn("Identity.userProfiles")(function* (
|
|
13
13
|
auth: { readonly $context: Promise<{ readonly adapter: Pick<Awaited<Auth["$context"]>["adapter"], "findMany"> }> },
|
|
14
14
|
userIds: readonly string[],
|
|
15
15
|
): Effect.fn.Return<readonly UserProfile[], AuthUnavailable> {
|
|
@@ -3,9 +3,11 @@ import type { Headers } from "effect/http";
|
|
|
3
3
|
import { Forbidden } from "@shivaedev/errors/taxonomy.ts";
|
|
4
4
|
import { transportOriginRequest } from "./origin.ts";
|
|
5
5
|
import { resolveRole } from "./resolveRole.ts";
|
|
6
|
-
import
|
|
6
|
+
import { SessionPolicy } from "./SessionPolicy.ts";
|
|
7
|
+
import type { SessionShape } from "./session.ts";
|
|
7
8
|
|
|
8
|
-
export const sessionRequest = Effect.fnUntraced(function* (
|
|
9
|
+
export const sessionRequest = Effect.fnUntraced(function* (headers: Headers.Headers, rpc: string) {
|
|
10
|
+
const policy = yield* SessionPolicy;
|
|
9
11
|
const request = yield* transportOriginRequest(headers, rpc);
|
|
10
12
|
if (!policy.origin(request)) {
|
|
11
13
|
return yield* new Forbidden({ message: "Origin not allowed" });
|
|
@@ -13,10 +15,8 @@ export const sessionRequest = Effect.fnUntraced(function* (policy: SessionPolicy
|
|
|
13
15
|
return request;
|
|
14
16
|
});
|
|
15
17
|
|
|
16
|
-
export const sessionAccess = Effect.fnUntraced(function* <TSession extends SessionShape>(
|
|
17
|
-
policy
|
|
18
|
-
session: Option.Option<TSession>,
|
|
19
|
-
) {
|
|
18
|
+
export const sessionAccess = Effect.fnUntraced(function* <TSession extends SessionShape>(session: Option.Option<TSession>) {
|
|
19
|
+
const policy = yield* SessionPolicy;
|
|
20
20
|
if (Option.isNone(session) || policy.roles === undefined) {
|
|
21
21
|
return session;
|
|
22
22
|
}
|
|
@@ -25,6 +25,7 @@ export const sessionAccess = Effect.fnUntraced(function* <TSession extends Sessi
|
|
|
25
25
|
return Option.some({ ...session.value, user: { ...session.value.user, ...access } });
|
|
26
26
|
});
|
|
27
27
|
|
|
28
|
-
export const lookupSession = Effect.fnUntraced(function*
|
|
29
|
-
|
|
28
|
+
export const lookupSession = Effect.fnUntraced(function* (headers: Headers.Headers) {
|
|
29
|
+
const policy = yield* SessionPolicy;
|
|
30
|
+
return yield* sessionAccess(yield* policy.provider.get(headers));
|
|
30
31
|
});
|
|
@@ -13,30 +13,36 @@ import { hasPermission } from "#permission.ts";
|
|
|
13
13
|
import { commandChanges } from "#server/commandChanges.ts";
|
|
14
14
|
import { recheckSession } from "./recheckSession.ts";
|
|
15
15
|
import { revalidateStream } from "./revalidateStream.ts";
|
|
16
|
-
import {
|
|
16
|
+
import { SessionPolicy } from "./SessionPolicy.ts";
|
|
17
|
+
import { withSessionUser } from "./session.ts";
|
|
17
18
|
|
|
18
|
-
export function permissionLayer<TMiddleware
|
|
19
|
+
export function permissionLayer<TMiddleware>(
|
|
19
20
|
middleware: Context.Key<TMiddleware, RpcMiddleware.RpcMiddleware<Identity | SessionUser, IdentityFailures, never>> & {
|
|
20
21
|
readonly permission: Permission;
|
|
21
22
|
},
|
|
22
|
-
policy: SessionPolicy<TSession>,
|
|
23
23
|
) {
|
|
24
24
|
const permission = middleware.permission;
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
Effect.
|
|
33
|
-
Effect.flatMap(
|
|
34
|
-
invocation
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
25
|
+
return Layer.effect(
|
|
26
|
+
middleware,
|
|
27
|
+
Effect.map(SessionPolicy, (policy) => {
|
|
28
|
+
const guard: RpcMiddleware.RpcMiddleware<Identity | SessionUser, IdentityFailures, never> = (effect, { headers, rpc, payload }) => {
|
|
29
|
+
const lookup = Effect.tap(recheckSession(headers, rpc._tag), (session) =>
|
|
30
|
+
Option.isSome(session) && !hasPermission(session.value.user, permission) ? Effect.fail(forbidden(permission)) : Effect.void,
|
|
31
|
+
);
|
|
32
|
+
return Effect.flatMap(Identity, (viewer) => authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some(viewer))).pipe(
|
|
33
|
+
(invocation) => Effect.flatMap(Identity, ({ id }) => invocation.pipe(revalidateStream(rpc, id, lookup))),
|
|
34
|
+
(invocation) =>
|
|
35
|
+
Effect.andThen(
|
|
36
|
+
Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
|
|
37
|
+
invocation,
|
|
38
|
+
),
|
|
39
|
+
withSessionUser(headers, rpc._tag),
|
|
40
|
+
Effect.provideService(SessionPolicy, policy),
|
|
41
|
+
);
|
|
42
|
+
};
|
|
43
|
+
return guard;
|
|
44
|
+
}),
|
|
45
|
+
);
|
|
40
46
|
}
|
|
41
47
|
function rejection(error: Unauthorized | Forbidden | AuthUnavailable) {
|
|
42
48
|
return HttpServerResponse.empty({
|
|
@@ -49,14 +55,16 @@ function rejection(error: Unauthorized | Forbidden | AuthUnavailable) {
|
|
|
49
55
|
});
|
|
50
56
|
}
|
|
51
57
|
|
|
52
|
-
export function permissionRoute
|
|
58
|
+
export function permissionRoute(permission: Permission) {
|
|
53
59
|
return <E, R>(handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) =>
|
|
54
|
-
(
|
|
60
|
+
(
|
|
61
|
+
request: HttpServerRequest.HttpServerRequest,
|
|
62
|
+
): Effect.Effect<HttpServerResponse.HttpServerResponse, E, SessionPolicy | Exclude<R, Identity | SessionUser>> =>
|
|
55
63
|
Effect.andThen(
|
|
56
64
|
Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
|
|
57
65
|
Effect.context<Identity | SessionUser>(),
|
|
58
66
|
).pipe(
|
|
59
|
-
withSessionUser(
|
|
67
|
+
withSessionUser(request.headers, request.url),
|
|
60
68
|
Effect.matchEffect({
|
|
61
69
|
onFailure: (error) => Effect.succeed(rejection(error)),
|
|
62
70
|
onSuccess: (context) => Effect.provideContext(handler(request), context),
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { Duration, Effect, Exit, Schema } from "effect";
|
|
2
|
+
import { SessionUserSchema, type SessionUserWithProviderAccountsValue } from "#identity.ts";
|
|
3
|
+
|
|
4
|
+
const AccountUser = Schema.Struct({
|
|
5
|
+
...SessionUserSchema.fields,
|
|
6
|
+
providerAccounts: Schema.declare((value): value is SessionUserWithProviderAccountsValue["providerAccounts"] => Effect.isEffect(value)),
|
|
7
|
+
});
|
|
8
|
+
|
|
9
|
+
export const providerAccountsUser = Effect.fnUntraced(function* (value: unknown) {
|
|
10
|
+
const { providerAccounts, ...user } = Schema.decodeUnknownSync(AccountUser)(value);
|
|
11
|
+
const accounts = yield* Effect.cachedWithTTL(
|
|
12
|
+
Effect.map(providerAccounts, (values) => values.map(({ accountId, providerId }) => ({ accountId, providerId }))),
|
|
13
|
+
(exit) => (Exit.isSuccess(exit) ? Duration.infinity : Duration.zero),
|
|
14
|
+
);
|
|
15
|
+
return { ...user, providerAccounts: accounts };
|
|
16
|
+
});
|
|
@@ -1,13 +1,14 @@
|
|
|
1
1
|
import { Effect, Option } from "effect";
|
|
2
2
|
import type { Headers } from "effect/http";
|
|
3
3
|
import { sessionAccess, sessionRequest } from "./lookupSession.ts";
|
|
4
|
-
import
|
|
4
|
+
import { SessionPolicy } from "./SessionPolicy.ts";
|
|
5
5
|
import { SocketSession } from "./socketSession.ts";
|
|
6
6
|
|
|
7
|
-
export const recheckSession = Effect.fnUntraced(function* (
|
|
8
|
-
const
|
|
7
|
+
export const recheckSession = Effect.fnUntraced(function* (headers: Headers.Headers, rpc: string) {
|
|
8
|
+
const policy = yield* SessionPolicy;
|
|
9
|
+
const request = yield* sessionRequest(headers, rpc);
|
|
9
10
|
const socket = yield* Effect.serviceOption(SocketSession);
|
|
10
11
|
const lookup = Effect.suspend(() => policy.provider.get(request.headers));
|
|
11
12
|
const session = yield* Option.match(socket, { onNone: () => lookup, onSome: (shared) => shared.lookup(policy.provider, lookup) });
|
|
12
|
-
return yield* sessionAccess(
|
|
13
|
+
return yield* sessionAccess(session);
|
|
13
14
|
});
|
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
import { Effect, Option } from "effect";
|
|
2
2
|
import { type Rpc, RpcSchema } from "effect/rpc";
|
|
3
3
|
import { type AuthUnavailable, type Forbidden, Unauthorized } from "@shivaedev/errors/taxonomy.ts";
|
|
4
|
-
import
|
|
4
|
+
import { SessionPolicy } from "./SessionPolicy.ts";
|
|
5
|
+
import type { SessionShape } from "./session.ts";
|
|
5
6
|
import { revalidateSession } from "./socketSession.ts";
|
|
6
7
|
|
|
7
|
-
export function revalidateStream<TSession extends SessionShape>(
|
|
8
|
-
policy: SessionPolicy<TSession>,
|
|
8
|
+
export function revalidateStream<TSession extends SessionShape, TLookupRequirements>(
|
|
9
9
|
rpc: Rpc.AnyWithProps,
|
|
10
10
|
id: string,
|
|
11
|
-
lookup: Effect.Effect<Option.Option<TSession>, AuthUnavailable | Forbidden>,
|
|
11
|
+
lookup: Effect.Effect<Option.Option<TSession>, AuthUnavailable | Forbidden, TLookupRequirements>,
|
|
12
12
|
) {
|
|
13
13
|
return <A, E, R>(effect: Effect.Effect<A, E, R>) => {
|
|
14
14
|
if (!RpcSchema.isStreamSchema(rpc.successSchema)) {
|
|
@@ -20,6 +20,8 @@ export function revalidateStream<TSession extends SessionShape>(
|
|
|
20
20
|
return yield* new Unauthorized({ message: "Authentication required" });
|
|
21
21
|
}
|
|
22
22
|
});
|
|
23
|
-
return Effect.
|
|
23
|
+
return Effect.flatMap(SessionPolicy, (policy) =>
|
|
24
|
+
Effect.raceFirst(effect, revalidateSession(check, policy.streamRevalidationInterval ?? "30 seconds")),
|
|
25
|
+
);
|
|
24
26
|
};
|
|
25
27
|
}
|
package/src/server/session.ts
CHANGED
|
@@ -1,9 +1,7 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { Effect, Layer, Option, Schema } from "effect";
|
|
2
2
|
import type { Headers } from "effect/http";
|
|
3
|
-
import type { Permission } from "@shivaedev/access/permission.ts";
|
|
4
|
-
import type { RoleSet } from "@shivaedev/access/roleSet.ts";
|
|
5
3
|
import { authorizeReads } from "@shivaedev/contract/readPolicy.ts";
|
|
6
|
-
import { type AuthUnavailable,
|
|
4
|
+
import { type AuthUnavailable, Unauthorized } from "@shivaedev/errors/taxonomy.ts";
|
|
7
5
|
import {
|
|
8
6
|
Identity,
|
|
9
7
|
OptionalIdentity,
|
|
@@ -15,7 +13,8 @@ import {
|
|
|
15
13
|
} from "#identity.ts";
|
|
16
14
|
import { Authenticated, AuthenticatedUser, AuthenticatedUserWithProviderAccounts, MaybeAuthenticated } from "#middleware.ts";
|
|
17
15
|
import { commandChanges } from "#server/commandChanges.ts";
|
|
18
|
-
import
|
|
16
|
+
import { providerAccountsUser } from "#server/providerAccountsUser.ts";
|
|
17
|
+
import { SessionPolicy } from "#server/SessionPolicy.ts";
|
|
19
18
|
import { lookupSession, sessionRequest } from "./lookupSession.ts";
|
|
20
19
|
import { recheckSession } from "./recheckSession.ts";
|
|
21
20
|
import { revalidateStream } from "./revalidateStream.ts";
|
|
@@ -27,71 +26,68 @@ export interface SessionShape {
|
|
|
27
26
|
export interface SessionProvider<TSession extends SessionShape> {
|
|
28
27
|
readonly get: (headers: Headers.Headers) => Effect.Effect<Option.Option<TSession>, AuthUnavailable>;
|
|
29
28
|
}
|
|
30
|
-
export
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
readonly streamRevalidationInterval?: Duration.Input | undefined;
|
|
35
|
-
}
|
|
36
|
-
export const resolveSession: <TSession extends SessionShape>(
|
|
37
|
-
policy: SessionPolicy<TSession>,
|
|
38
|
-
headers: Headers.Headers,
|
|
39
|
-
rpc: string,
|
|
40
|
-
) => Effect.Effect<Option.Option<TSession & { readonly user: { readonly permissions?: readonly Permission[] } }>, AuthUnavailable | Forbidden> =
|
|
41
|
-
Effect.fn("PlatformRpc.resolveSession")(function* <TSession extends SessionShape>(
|
|
42
|
-
policy: SessionPolicy<TSession>,
|
|
43
|
-
headers: Headers.Headers,
|
|
44
|
-
rpc: string,
|
|
45
|
-
) {
|
|
46
|
-
const request = yield* sessionRequest(policy, headers, rpc);
|
|
47
|
-
return yield* lookupSession(policy, request.headers);
|
|
48
|
-
});
|
|
29
|
+
export const resolveSession = Effect.fn("Identity.resolveSession")(function* (headers: Headers.Headers, rpc: string) {
|
|
30
|
+
const request = yield* sessionRequest(headers, rpc);
|
|
31
|
+
return yield* lookupSession(request.headers);
|
|
32
|
+
});
|
|
49
33
|
function identified(id: string) {
|
|
50
34
|
return Effect.andThen(Effect.annotateCurrentSpan("user.id", id), Effect.succeed(id));
|
|
51
35
|
}
|
|
52
|
-
export function authenticatedLayer
|
|
53
|
-
return Layer.
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
36
|
+
export function authenticatedLayer() {
|
|
37
|
+
return Layer.effect(
|
|
38
|
+
Authenticated,
|
|
39
|
+
Effect.map(
|
|
40
|
+
SessionPolicy,
|
|
41
|
+
(policy) =>
|
|
42
|
+
(effect, { headers, rpc, payload }) =>
|
|
43
|
+
Effect.gen(function* () {
|
|
44
|
+
const session = yield* resolveSession(headers, rpc._tag);
|
|
45
|
+
if (Option.isNone(session)) {
|
|
46
|
+
return yield* new Unauthorized({ message: "Authentication required" });
|
|
47
|
+
}
|
|
48
|
+
const id = yield* identified(session.value.user.id);
|
|
49
|
+
return yield* authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some({ id })).pipe(
|
|
50
|
+
revalidateStream(rpc, id, recheckSession(headers, rpc._tag)),
|
|
51
|
+
Effect.provideService(Identity, { id }),
|
|
52
|
+
Effect.annotateLogs({ userId: id }),
|
|
53
|
+
);
|
|
54
|
+
}).pipe(Effect.provideService(SessionPolicy, policy)),
|
|
55
|
+
),
|
|
66
56
|
);
|
|
67
57
|
}
|
|
68
|
-
export function maybeAuthenticatedLayer
|
|
69
|
-
return Layer.
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
58
|
+
export function maybeAuthenticatedLayer() {
|
|
59
|
+
return Layer.effect(
|
|
60
|
+
MaybeAuthenticated,
|
|
61
|
+
Effect.map(
|
|
62
|
+
SessionPolicy,
|
|
63
|
+
(policy) =>
|
|
64
|
+
(effect, { headers, rpc, payload }) =>
|
|
65
|
+
Effect.gen(function* () {
|
|
66
|
+
const session = yield* resolveSession(headers, rpc._tag);
|
|
67
|
+
if (Option.isNone(session)) {
|
|
68
|
+
return yield* Effect.provideService(authorizeReads(effect, { payload, rpc }, Option.none()), OptionalIdentity, Option.none());
|
|
69
|
+
}
|
|
70
|
+
const id = yield* identified(session.value.user.id);
|
|
71
|
+
return yield* authorizeReads(effect, { payload, rpc }, Option.some({ id })).pipe(
|
|
72
|
+
revalidateStream(rpc, id, recheckSession(headers, rpc._tag)),
|
|
73
|
+
Effect.provideService(OptionalIdentity, Option.some({ id })),
|
|
74
|
+
Effect.annotateLogs({ userId: id }),
|
|
75
|
+
);
|
|
76
|
+
}).pipe(Effect.provideService(SessionPolicy, policy)),
|
|
77
|
+
),
|
|
82
78
|
);
|
|
83
79
|
}
|
|
84
80
|
export interface UserSessionShape extends SessionShape {
|
|
85
81
|
readonly user: SessionUserValue;
|
|
86
82
|
}
|
|
87
|
-
export function withSessionUser
|
|
83
|
+
export function withSessionUser(headers: Headers.Headers, operation: string) {
|
|
88
84
|
return <A, E, R>(effect: Effect.Effect<A, E, R>) =>
|
|
89
85
|
Effect.gen(function* () {
|
|
90
|
-
const session = yield* resolveSession(
|
|
86
|
+
const session = yield* resolveSession(headers, operation);
|
|
91
87
|
if (Option.isNone(session)) {
|
|
92
88
|
return yield* new Unauthorized({ message: "Authentication required" });
|
|
93
89
|
}
|
|
94
|
-
const user = Schema.
|
|
90
|
+
const user = Schema.decodeUnknownSync(SessionUserSchema)(session.value.user);
|
|
95
91
|
const id = yield* identified(session.value.user.id);
|
|
96
92
|
return yield* effect.pipe(
|
|
97
93
|
Effect.provideService(Identity, { id }),
|
|
@@ -100,12 +96,18 @@ export function withSessionUser<TSession extends UserSessionShape>(policy: Sessi
|
|
|
100
96
|
);
|
|
101
97
|
});
|
|
102
98
|
}
|
|
103
|
-
export function authenticatedUserLayer
|
|
104
|
-
return Layer.
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
99
|
+
export function authenticatedUserLayer() {
|
|
100
|
+
return Layer.effect(
|
|
101
|
+
AuthenticatedUser,
|
|
102
|
+
Effect.map(
|
|
103
|
+
SessionPolicy,
|
|
104
|
+
(policy) =>
|
|
105
|
+
(effect, { headers, rpc, payload }) =>
|
|
106
|
+
Effect.flatMap(Identity, (viewer) => authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some(viewer))).pipe(
|
|
107
|
+
(invocation) => Effect.flatMap(Identity, ({ id }) => invocation.pipe(revalidateStream(rpc, id, recheckSession(headers, rpc._tag)))),
|
|
108
|
+
withSessionUser(headers, rpc._tag),
|
|
109
|
+
Effect.provideService(SessionPolicy, policy),
|
|
110
|
+
),
|
|
109
111
|
),
|
|
110
112
|
);
|
|
111
113
|
}
|
|
@@ -113,29 +115,29 @@ export function authenticatedUserLayer<TSession extends UserSessionShape>(policy
|
|
|
113
115
|
export interface ProviderAccountsSessionShape extends UserSessionShape {
|
|
114
116
|
readonly user: SessionUserWithProviderAccountsValue;
|
|
115
117
|
}
|
|
116
|
-
export function authenticatedUserWithProviderAccountsLayer
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
118
|
+
export function authenticatedUserWithProviderAccountsLayer() {
|
|
119
|
+
return Layer.effect(
|
|
120
|
+
AuthenticatedUserWithProviderAccounts,
|
|
121
|
+
Effect.map(
|
|
122
|
+
SessionPolicy,
|
|
123
|
+
(policy) =>
|
|
124
|
+
(effect, { headers, rpc, payload }) =>
|
|
125
|
+
Effect.gen(function* () {
|
|
126
|
+
const session = yield* resolveSession(headers, rpc._tag);
|
|
127
|
+
if (Option.isNone(session)) {
|
|
128
|
+
return yield* new Unauthorized({ message: "Authentication required" });
|
|
129
|
+
}
|
|
130
|
+
const { providerAccounts, ...user } = yield* providerAccountsUser(session.value.user);
|
|
131
|
+
const { id } = user;
|
|
132
|
+
yield* identified(id);
|
|
133
|
+
return yield* authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some({ id })).pipe(
|
|
134
|
+
revalidateStream(rpc, id, recheckSession(headers, rpc._tag)),
|
|
135
|
+
Effect.provideService(Identity, { id }),
|
|
136
|
+
Effect.provideService(SessionUser, user),
|
|
137
|
+
Effect.provideService(SessionUserWithProviderAccounts, { ...user, providerAccounts }),
|
|
138
|
+
Effect.annotateLogs({ userId: id }),
|
|
139
|
+
);
|
|
140
|
+
}).pipe(Effect.provideService(SessionPolicy, policy)),
|
|
141
|
+
),
|
|
140
142
|
);
|
|
141
143
|
}
|