@shivaedev/identity 0.3.2 → 0.5.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.
Files changed (118) hide show
  1. package/README.md +44 -14
  2. package/dist/identity.d.ts +19 -6
  3. package/dist/identity.d.ts.map +1 -1
  4. package/dist/identity.js +9 -1
  5. package/dist/identity.js.map +1 -1
  6. package/dist/middleware.d.ts +2 -0
  7. package/dist/middleware.d.ts.map +1 -1
  8. package/dist/middleware.js +5 -4
  9. package/dist/middleware.js.map +1 -1
  10. package/dist/permission.d.ts +7 -8
  11. package/dist/permission.d.ts.map +1 -1
  12. package/dist/permission.js +4 -12
  13. package/dist/permission.js.map +1 -1
  14. package/dist/server/adapters/betterAuthSessions.d.ts +1 -1
  15. package/dist/server/adapters/betterAuthSessions.d.ts.map +1 -1
  16. package/dist/server/adapters/betterAuthSessions.js +4 -7
  17. package/dist/server/adapters/betterAuthSessions.js.map +1 -1
  18. package/dist/server/better-auth/admittedSessions.d.ts +14 -0
  19. package/dist/server/better-auth/admittedSessions.d.ts.map +1 -0
  20. package/dist/server/better-auth/admittedSessions.js +32 -0
  21. package/dist/server/better-auth/admittedSessions.js.map +1 -0
  22. package/dist/server/better-auth/clientIp.d.ts.map +1 -1
  23. package/dist/server/better-auth/clientIp.js +2 -1
  24. package/dist/server/better-auth/clientIp.js.map +1 -1
  25. package/dist/server/better-auth/mount.d.ts +8 -7
  26. package/dist/server/better-auth/mount.d.ts.map +1 -1
  27. package/dist/server/better-auth/mount.js +6 -24
  28. package/dist/server/better-auth/mount.js.map +1 -1
  29. package/dist/server/better-auth/mountRoutes.d.ts.map +1 -1
  30. package/dist/server/better-auth/mountRoutes.js +6 -6
  31. package/dist/server/better-auth/mountRoutes.js.map +1 -1
  32. package/dist/server/better-auth/mountedSessions.d.ts +9 -5
  33. package/dist/server/better-auth/mountedSessions.d.ts.map +1 -1
  34. package/dist/server/better-auth/mountedSessions.js +5 -5
  35. package/dist/server/better-auth/mountedSessions.js.map +1 -1
  36. package/dist/server/better-auth/sessionPermissions.d.ts +2 -1
  37. package/dist/server/better-auth/sessionPermissions.d.ts.map +1 -1
  38. package/dist/server/better-auth/sessionPermissions.js +6 -5
  39. package/dist/server/better-auth/sessionPermissions.js.map +1 -1
  40. package/dist/server/better-auth/signInGate.d.ts +1 -1
  41. package/dist/server/better-auth/signInGate.d.ts.map +1 -1
  42. package/dist/server/better-auth/signInGate.js +2 -3
  43. package/dist/server/better-auth/signInGate.js.map +1 -1
  44. package/dist/server/better-auth/testing.d.ts +25 -0
  45. package/dist/server/better-auth/testing.d.ts.map +1 -1
  46. package/dist/server/better-auth/testing.js +8 -0
  47. package/dist/server/better-auth/testing.js.map +1 -1
  48. package/dist/server/better-auth/userProfiles.d.ts +1 -1
  49. package/dist/server/better-auth/userProfiles.d.ts.map +1 -1
  50. package/dist/server/better-auth/userProfiles.js +2 -3
  51. package/dist/server/better-auth/userProfiles.js.map +1 -1
  52. package/dist/server/better-auth/userReference.d.ts +5 -0
  53. package/dist/server/better-auth/userReference.d.ts.map +1 -0
  54. package/dist/server/better-auth/userReference.js +2 -0
  55. package/dist/server/better-auth/userReference.js.map +1 -0
  56. package/dist/server/commandChanges.d.ts.map +1 -1
  57. package/dist/server/commandChanges.js +11 -6
  58. package/dist/server/commandChanges.js.map +1 -1
  59. package/dist/server/local.d.ts +4 -3
  60. package/dist/server/local.d.ts.map +1 -1
  61. package/dist/server/local.js +2 -5
  62. package/dist/server/local.js.map +1 -1
  63. package/dist/server/origin.d.ts +7 -2
  64. package/dist/server/origin.d.ts.map +1 -1
  65. package/dist/server/origin.js +14 -5
  66. package/dist/server/origin.js.map +1 -1
  67. package/dist/server/permissions.d.ts +1 -1
  68. package/dist/server/permissions.d.ts.map +1 -1
  69. package/dist/server/permissions.js +7 -8
  70. package/dist/server/permissions.js.map +1 -1
  71. package/dist/server/providerFailure.d.ts +4 -0
  72. package/dist/server/providerFailure.d.ts.map +1 -0
  73. package/dist/server/providerFailure.js +10 -0
  74. package/dist/server/providerFailure.js.map +1 -0
  75. package/dist/server/resolveRole.d.ts +4 -5
  76. package/dist/server/resolveRole.d.ts.map +1 -1
  77. package/dist/server/resolveRole.js +1 -2
  78. package/dist/server/resolveRole.js.map +1 -1
  79. package/dist/server/session.d.ts +1 -1
  80. package/dist/server/session.d.ts.map +1 -1
  81. package/dist/server/session.js +10 -11
  82. package/dist/server/session.js.map +1 -1
  83. package/dist/server/tracing.d.ts.map +1 -1
  84. package/dist/server/tracing.js +6 -2
  85. package/dist/server/tracing.js.map +1 -1
  86. package/dist/server/trustedProxy.d.ts +0 -1
  87. package/dist/server/trustedProxy.d.ts.map +1 -1
  88. package/dist/server/trustedProxy.js +1 -4
  89. package/dist/server/trustedProxy.js.map +1 -1
  90. package/package.json +13 -13
  91. package/src/identity.ts +10 -8
  92. package/src/middleware.ts +7 -4
  93. package/src/permission.ts +5 -17
  94. package/src/server/adapters/betterAuthSessions.ts +4 -10
  95. package/src/server/better-auth/admittedSessions.ts +38 -0
  96. package/src/server/better-auth/clientIp.ts +2 -1
  97. package/src/server/better-auth/mount.ts +8 -38
  98. package/src/server/better-auth/mountRoutes.ts +6 -10
  99. package/src/server/better-auth/mountedSessions.ts +19 -10
  100. package/src/server/better-auth/sessionPermissions.ts +10 -6
  101. package/src/server/better-auth/signInGate.ts +3 -10
  102. package/src/server/better-auth/testing.ts +12 -0
  103. package/src/server/better-auth/userProfiles.ts +3 -10
  104. package/src/server/better-auth/userReference.ts +1 -0
  105. package/src/server/commandChanges.ts +46 -33
  106. package/src/server/local.ts +7 -8
  107. package/src/server/origin.ts +23 -6
  108. package/src/server/permissions.ts +17 -14
  109. package/src/server/providerFailure.ts +13 -0
  110. package/src/server/resolveRole.ts +4 -2
  111. package/src/server/session.ts +10 -10
  112. package/src/server/tracing.ts +8 -2
  113. package/src/server/trustedProxy.ts +1 -5
  114. package/dist/server/sessionProfile.d.ts +0 -3
  115. package/dist/server/sessionProfile.d.ts.map +0 -1
  116. package/dist/server/sessionProfile.js +0 -4
  117. package/dist/server/sessionProfile.js.map +0 -1
  118. package/src/server/sessionProfile.ts +0 -5
@@ -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 { redact } from "@shivaedev/errors/redact.ts";
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) => unavailable(error.cause)));
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
- : unavailable(cause),
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, trustedProxyRanges } from "#server/local.ts";
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 { GetSession } from "#server/adapters/betterAuthSessions.ts";
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 { type RevokeUnadmitted, revokeUnadmitted } from "#server/better-auth/revokeUnadmitted.ts";
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 type { SessionShape } from "#server/session.ts";
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
- function admittedSessions<TSession extends SessionShape>(getSession: GetSession<TSession>): GetSession<TSession> {
79
- if (!gate.active && mount.bearerSessions === undefined) {
80
- return getSession;
81
- }
82
- return (headers) =>
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
- async function authResponse(auth: MountedAuth, web: Request, options: MountRouteOptions) {
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 = await providerResponse(auth, request, options);
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 { betterAuthSessions, type GetSession } from "#server/adapters/betterAuthSessions.ts";
4
- import type { SessionShape } from "#server/session.ts";
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
- Schema.Struct({
8
- user: Schema.Struct({ email: Schema.String, id: Schema.String, name: Schema.String, role: Schema.optionalKey(Schema.NullOr(Schema.String)) }),
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: (headers: Headers) => Promise<unknown>,
14
- admit: <TSession extends SessionShape>(getSession: GetSession<TSession>) => 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: betterAuthSessions(admit(async (headers) => Schema.decodeUnknownSync(AuthSession)(await lookup(headers)))),
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 async function sessionPermissions(response: Response, roles: RoleSet): Promise<Response> {
9
- const payload = Schema.decodeUnknownSync(SessionPayload)(await response.json());
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 = await Effect.runPromise(resolveRole(roles, payload.user.role));
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 { redact } from "@shivaedev/errors/redact.ts";
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,5 +1,6 @@
1
1
  import type { AuthContext } from "better-auth";
2
2
  import type { testUtils } from "better-auth/plugins";
3
+ import { Effect } from "effect";
3
4
 
4
5
  type TestContext = ReturnType<ReturnType<typeof testUtils>["init"]>["context"];
5
6
  type AccountContext = Pick<AuthContext, "internalAdapter">;
@@ -33,3 +34,14 @@ export async function storedProviderAccounts(auth: { readonly $context: Promise<
33
34
  providerId,
34
35
  }));
35
36
  }
37
+
38
+ export const passwordUser = Effect.fnUntraced(function* (
39
+ auth: { readonly $context: Promise<TestContext & AccountContext & { readonly password: Pick<AuthContext["password"], "hash"> }> },
40
+ { password, ...fields }: Parameters<TestContext["test"]["createUser"]>[0] & { readonly email: string; readonly password: string },
41
+ ) {
42
+ const { test, internalAdapter, password: credential } = yield* Effect.promise(() => auth.$context);
43
+ const user = yield* Effect.promise(() => test.saveUser(test.createUser(fields)));
44
+ const hash = yield* Effect.promise(() => credential.hash(password));
45
+ yield* Effect.promise(() => internalAdapter.createAccount({ accountId: user.id, password: hash, providerId: "credential", userId: user.id }));
46
+ return user;
47
+ });
@@ -1,7 +1,7 @@
1
1
  import type { Auth } from "better-auth";
2
2
  import { Effect } from "effect";
3
- import { redact } from "@shivaedev/errors/redact.ts";
4
- import { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
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
  });
@@ -0,0 +1 @@
1
+ export const userReference = { column: "id", table: "user" } as const;
@@ -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.gen(function* () {
18
- const context = yield* sessionKeyContext(rpc);
19
- const sql = yield* Effect.serviceOption(SqlClient.SqlClient);
20
- const reactivity = yield* Effect.serviceOption(Reactivity.Reactivity);
21
- if (Option.isNone(reactivity)) {
22
- return yield* effect;
23
- }
24
- const published = new Set<unknown>();
25
- const observer = yield* ChangeObserver;
26
- const result = yield* effect.pipe(
27
- Effect.provideService(ChangeObserver, (event) => {
28
- if (event._tag === "Published") {
29
- for (const key of event.changes) {
30
- published.add(key);
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
- return observer(event);
34
- }),
35
- );
36
- const viewer = yield* CurrentViewer;
37
- const keys = invalidationKeys(declared(payload, result, viewer), context).filter((key) => !published.has(key));
38
- if (keys.length > 0) {
39
- const announce = Option.isNone(sql)
40
- ? reactivity.value.invalidate(keys)
41
- : invalidateOnCommit(keys).pipe(
42
- transact({ onSqlError: (error) => error }),
43
- Effect.provideService(SqlClient.SqlClient, sql.value),
44
- Effect.provideService(Reactivity.Reactivity, reactivity.value),
45
- );
46
- yield* announce.pipe(Effect.catchCause((cause) => Effect.logError("Committed command invalidation failed", cause)));
47
- }
48
- return result;
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
  }
@@ -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
- import { trustedProxyRanges as normalizedRanges } from "./trustedProxyRanges.ts";
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: HttpServerRequest.HttpServerRequest): boolean {
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: HttpServerRequest.HttpServerRequest, isTrustedProxy: (address: string) => boolean, native: boolean): boolean {
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: HttpServerRequest.HttpServerRequest): boolean => {
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);
@@ -85,7 +83,8 @@ export function localRpcGuard<E, R>(
85
83
  const request = yield* HttpServerRequest.HttpServerRequest;
86
84
  const serialization = yield* RpcSerialization.RpcSerialization;
87
85
  const contentType = request.headers["content-type"]?.split(";")[0]?.trim().toLowerCase();
88
- return allowed(request) && contentType === serialization.contentType
86
+ const legacyNdjson = serialization.contentType === RpcSerialization.ndjson.contentType && contentType === "application/ndjson";
87
+ return allowed(request) && (contentType === serialization.contentType || legacyNdjson)
89
88
  ? yield* continueHttpTrace(effect, request)
90
89
  : HttpServerResponse.text("Local same-origin requests only", { status: HttpStatus.fromLiteral("Forbidden") });
91
90
  });
@@ -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
- return ({ origin }) =>
15
- Option.match(origin, {
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) => options.allow.includes(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,11 +3,13 @@ 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 { MissingReadPolicy, QueryReadDenied } from "@shivaedev/contract/readPolicyErrors.ts";
8
- import { type AuthUnavailable, Forbidden, type Unauthorized } from "@shivaedev/errors/taxonomy.ts";
9
- import { Identity, type SessionUser } from "#identity.ts";
10
- import { hasPermission, type permissionMiddleware, requirePermission } from "#permission.ts";
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";
12
14
  import { revalidateStream } from "./revalidateStream.ts";
13
15
  import { resolveSession, type SessionPolicy, type UserSessionShape, withSessionUser } from "./session.ts";
@@ -17,19 +19,17 @@ export function permissionLayer<TMiddleware, TSession extends UserSessionShape>(
17
19
  policy: SessionPolicy<TSession>,
18
20
  ) {
19
21
  const permission = middleware.permission;
20
- const guard: RpcMiddleware.RpcMiddleware<
21
- Identity | SessionUser,
22
- Unauthorized | AuthUnavailable | Forbidden | MissingReadPolicy | QueryReadDenied,
23
- never
24
- > = (effect, { headers, rpc, payload }) => {
22
+ const guard: RpcMiddleware.RpcMiddleware<Identity | SessionUser, IdentityFailures, never> = (effect, { headers, rpc, payload }) => {
25
23
  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,
24
+ Option.isSome(session) && !hasPermission(session.value.user, permission) ? Effect.fail(forbidden(permission)) : Effect.void,
29
25
  );
30
26
  return Effect.flatMap(Identity, (viewer) => authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some(viewer))).pipe(
31
27
  (invocation) => Effect.flatMap(Identity, ({ id }) => invocation.pipe(revalidateStream(policy, rpc, id, lookup))),
32
- (invocation) => Effect.andThen(requirePermission(permission), invocation),
28
+ (invocation) =>
29
+ Effect.andThen(
30
+ Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
31
+ invocation,
32
+ ),
33
33
  withSessionUser(policy, headers, rpc._tag),
34
34
  );
35
35
  };
@@ -49,7 +49,10 @@ function rejection(error: Unauthorized | Forbidden | AuthUnavailable) {
49
49
  export function permissionRoute<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>, permission: Permission) {
50
50
  return <E, R>(handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) =>
51
51
  (request: HttpServerRequest.HttpServerRequest): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Exclude<R, Identity | SessionUser>> =>
52
- Effect.andThen(requirePermission(permission), Effect.context<Identity | SessionUser>()).pipe(
52
+ Effect.andThen(
53
+ Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
54
+ Effect.context<Identity | SessionUser>(),
55
+ ).pipe(
53
56
  withSessionUser(policy, request.headers, request.url),
54
57
  Effect.matchEffect({
55
58
  onFailure: (error) => Effect.succeed(rejection(error)),
@@ -0,0 +1,13 @@
1
+ import { Cause, Effect, Schema } from "effect";
2
+ import { redact } from "@shivaedev/errors/redact.ts";
3
+ import { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
4
+
5
+ export function providerFailure(cause: unknown) {
6
+ if (Schema.is(AuthUnavailable)(cause)) {
7
+ return Effect.fail(cause);
8
+ }
9
+ return Effect.andThen(
10
+ Effect.logError("Authentication provider failed", redact(Cause.isUnknownError(cause) ? cause.cause : cause)),
11
+ Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
12
+ );
13
+ }
@@ -1,7 +1,9 @@
1
1
  import { Effect } from "effect";
2
2
  import type { RoleSet } from "@shivaedev/access/roleSet.ts";
3
- import { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
4
3
 
5
4
  export function resolveRole(roles: RoleSet, stored: unknown) {
6
- return roles.resolve(stored).pipe(Effect.mapError(() => new AuthUnavailable({ message: "Stored user role is not declared by the application" })));
5
+ return roles.resolve(stored).pipe(
6
+ Effect.mapError((cause) => new Error(`Stored user role is not declared by the application: ${String(stored)}`, { cause })),
7
+ Effect.orDie,
8
+ );
7
9
  }