@shivaedev/identity 0.16.0 → 0.18.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 (109) hide show
  1. package/CHANGELOG.md +37 -0
  2. package/README.md +84 -54
  3. package/dist/server/SessionPolicy.d.ts +14 -0
  4. package/dist/server/SessionPolicy.d.ts.map +1 -0
  5. package/dist/server/SessionPolicy.js +4 -0
  6. package/dist/server/SessionPolicy.js.map +1 -0
  7. package/dist/server/adapters/authCall.d.ts +5 -0
  8. package/dist/server/adapters/authCall.d.ts.map +1 -0
  9. package/dist/server/adapters/authCall.js +7 -0
  10. package/dist/server/adapters/authCall.js.map +1 -0
  11. package/dist/server/adapters/betterAuthSessions.d.ts.map +1 -1
  12. package/dist/server/adapters/betterAuthSessions.js +4 -6
  13. package/dist/server/adapters/betterAuthSessions.js.map +1 -1
  14. package/dist/server/better-auth/PasswordReset.d.ts +7 -0
  15. package/dist/server/better-auth/PasswordReset.d.ts.map +1 -0
  16. package/dist/server/better-auth/PasswordReset.js +2 -0
  17. package/dist/server/better-auth/PasswordReset.js.map +1 -0
  18. package/dist/server/better-auth/accountRoleSeed.d.ts +2 -1
  19. package/dist/server/better-auth/accountRoleSeed.d.ts.map +1 -1
  20. package/dist/server/better-auth/accountRoleSeed.js +8 -6
  21. package/dist/server/better-auth/accountRoleSeed.js.map +1 -1
  22. package/dist/server/better-auth/adapters/database.d.ts.map +1 -1
  23. package/dist/server/better-auth/adapters/database.js +18 -3
  24. package/dist/server/better-auth/adapters/database.js.map +1 -1
  25. package/dist/server/better-auth/adapters/hookRuntime.d.ts.map +1 -1
  26. package/dist/server/better-auth/adapters/hookRuntime.js +2 -1
  27. package/dist/server/better-auth/adapters/hookRuntime.js.map +1 -1
  28. package/dist/server/better-auth/adapters/passwordResetOptions.d.ts +6 -0
  29. package/dist/server/better-auth/adapters/passwordResetOptions.d.ts.map +1 -0
  30. package/dist/server/better-auth/adapters/passwordResetOptions.js +17 -0
  31. package/dist/server/better-auth/adapters/passwordResetOptions.js.map +1 -0
  32. package/dist/server/better-auth/adapters/storedRoleOptions.d.ts.map +1 -1
  33. package/dist/server/better-auth/adapters/storedRoleOptions.js +8 -1
  34. package/dist/server/better-auth/adapters/storedRoleOptions.js.map +1 -1
  35. package/dist/server/better-auth/assignRole.d.ts +2 -1
  36. package/dist/server/better-auth/assignRole.d.ts.map +1 -1
  37. package/dist/server/better-auth/assignRole.js +7 -5
  38. package/dist/server/better-auth/assignRole.js.map +1 -1
  39. package/dist/server/better-auth/columnDrift.d.ts.map +1 -1
  40. package/dist/server/better-auth/columnDrift.js +4 -3
  41. package/dist/server/better-auth/columnDrift.js.map +1 -1
  42. package/dist/server/better-auth/migrationPlan.d.ts.map +1 -1
  43. package/dist/server/better-auth/migrationPlan.js +7 -5
  44. package/dist/server/better-auth/migrationPlan.js.map +1 -1
  45. package/dist/server/better-auth/mount.d.ts +3 -0
  46. package/dist/server/better-auth/mount.d.ts.map +1 -1
  47. package/dist/server/better-auth/mount.js +15 -4
  48. package/dist/server/better-auth/mount.js.map +1 -1
  49. package/dist/server/better-auth/sessionPermissions.js +1 -1
  50. package/dist/server/better-auth/signInGate.d.ts.map +1 -1
  51. package/dist/server/better-auth/signInGate.js +2 -1
  52. package/dist/server/better-auth/signInGate.js.map +1 -1
  53. package/dist/server/better-auth/tables.d.ts +19 -0
  54. package/dist/server/better-auth/tables.d.ts.map +1 -0
  55. package/dist/server/better-auth/tables.js +24 -0
  56. package/dist/server/better-auth/tables.js.map +1 -0
  57. package/dist/server/better-auth/userProfiles.js +1 -1
  58. package/dist/server/lookupSession.d.ts +5 -4
  59. package/dist/server/lookupSession.d.ts.map +1 -1
  60. package/dist/server/lookupSession.js +8 -4
  61. package/dist/server/lookupSession.js.map +1 -1
  62. package/dist/server/permissions.d.ts +4 -4
  63. package/dist/server/permissions.d.ts.map +1 -1
  64. package/dist/server/permissions.js +11 -8
  65. package/dist/server/permissions.js.map +1 -1
  66. package/dist/server/providerAccountsUser.d.ts +16 -0
  67. package/dist/server/providerAccountsUser.d.ts.map +1 -0
  68. package/dist/server/providerAccountsUser.js +12 -0
  69. package/dist/server/providerAccountsUser.js.map +1 -0
  70. package/dist/server/recheckSession.d.ts +2 -2
  71. package/dist/server/recheckSession.d.ts.map +1 -1
  72. package/dist/server/recheckSession.js +5 -3
  73. package/dist/server/recheckSession.js.map +1 -1
  74. package/dist/server/revalidateStream.d.ts +3 -2
  75. package/dist/server/revalidateStream.d.ts.map +1 -1
  76. package/dist/server/revalidateStream.js +3 -2
  77. package/dist/server/revalidateStream.js.map +1 -1
  78. package/dist/server/session.d.ts +9 -21
  79. package/dist/server/session.d.ts.map +1 -1
  80. package/dist/server/session.js +30 -28
  81. package/dist/server/session.js.map +1 -1
  82. package/dist/server/tracing.d.ts.map +1 -1
  83. package/dist/server/tracing.js +3 -2
  84. package/dist/server/tracing.js.map +1 -1
  85. package/package.json +12 -12
  86. package/src/server/SessionPolicy.ts +14 -0
  87. package/src/server/adapters/authCall.ts +8 -0
  88. package/src/server/adapters/betterAuthSessions.ts +5 -7
  89. package/src/server/better-auth/PasswordReset.ts +7 -0
  90. package/src/server/better-auth/accountRoleSeed.ts +8 -5
  91. package/src/server/better-auth/adapters/database.ts +21 -4
  92. package/src/server/better-auth/adapters/hookRuntime.ts +2 -1
  93. package/src/server/better-auth/adapters/passwordResetOptions.ts +25 -0
  94. package/src/server/better-auth/adapters/storedRoleOptions.ts +8 -1
  95. package/src/server/better-auth/assignRole.ts +7 -4
  96. package/src/server/better-auth/columnDrift.ts +4 -3
  97. package/src/server/better-auth/migrationPlan.ts +7 -5
  98. package/src/server/better-auth/mount.ts +17 -4
  99. package/src/server/better-auth/sessionPermissions.ts +1 -1
  100. package/src/server/better-auth/signInGate.ts +2 -1
  101. package/src/server/better-auth/tables.ts +28 -0
  102. package/src/server/better-auth/userProfiles.ts +1 -1
  103. package/src/server/lookupSession.ts +9 -8
  104. package/src/server/permissions.ts +29 -21
  105. package/src/server/providerAccountsUser.ts +16 -0
  106. package/src/server/recheckSession.ts +5 -4
  107. package/src/server/revalidateStream.ts +7 -5
  108. package/src/server/session.ts +88 -85
  109. package/src/server/tracing.ts +5 -2
@@ -5,6 +5,7 @@ import { type AuthUnavailable, Unauthorized } from "@shivaedev/errors/taxonomy.t
5
5
  import type { ProviderAccountValue } from "#identity.ts";
6
6
  import { providerFailure } from "#server/providerFailure.ts";
7
7
  import type { SessionProvider, SessionShape } from "#server/session.ts";
8
+ import { authCall } from "./authCall.ts";
8
9
 
9
10
  const ExpiringSession = Schema.Struct({ session: Schema.Struct({ expiresAt: Schema.Date }) });
10
11
 
@@ -19,21 +20,18 @@ export function betterAuthSessions<TSession extends SessionShape>(
19
20
  getProviderAccounts: GetProviderAccounts,
20
21
  ): SessionProvider<SessionWithProviderAccounts<TSession>>;
21
22
  export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>, getProviderAccounts?: GetProviderAccounts) {
22
- const betterAuthSession = Effect.fn("PlatformRpc.betterAuthSession")(function* (headers: Headers.Headers) {
23
+ const betterAuthSession = Effect.fn("Identity.betterAuthSession")(function* (headers: Headers.Headers) {
23
24
  const transport = new globalThis.Headers(headers);
24
- const session = yield* Effect.tryPromise(() => getSession(transport)).pipe(Effect.catch((error) => providerFailure(error.cause)));
25
+ const session = yield* authCall(() => getSession(transport)).pipe(Effect.catch((error) => providerFailure(error.cause)));
25
26
  if (Schema.is(ExpiringSession)(session) && session.session.expiresAt.getTime() <= (yield* Clock.currentTimeMillis)) {
26
27
  return Option.none();
27
28
  }
28
29
  if (session === null || getProviderAccounts === undefined) {
29
30
  return Option.fromNullishOr(session);
30
31
  }
31
- const providerAccounts = Effect.tryPromise({
32
- catch: (cause) => cause,
33
- try: () => getProviderAccounts(transport),
34
- }).pipe(
32
+ const providerAccounts = authCall(() => getProviderAccounts(transport)).pipe(
35
33
  Effect.catch(
36
- (cause): Effect.Effect<never, AuthUnavailable | Unauthorized> =>
34
+ ({ cause }): Effect.Effect<never, AuthUnavailable | Unauthorized> =>
37
35
  Predicate.hasProperty(cause, "statusCode") && cause.statusCode === HttpStatus.fromLiteral("Unauthorized")
38
36
  ? Effect.fail(new Unauthorized({ message: "Authentication required" }))
39
37
  : providerFailure(cause),
@@ -0,0 +1,7 @@
1
+ import type { BetterAuthOptions } from "better-auth";
2
+ import type { Effect } from "effect";
3
+ import type { BetterAuthHookError } from "./databaseHooks.ts";
4
+
5
+ type NativePasswordReset = NonNullable<NonNullable<BetterAuthOptions["emailAndPassword"]>["onPasswordReset"]>;
6
+
7
+ export type BetterAuthPasswordReset<R = never> = (data: Parameters<NativePasswordReset>[0]) => Effect.Effect<void, BetterAuthHookError, R>;
@@ -4,6 +4,7 @@ import type { AccessPolicy } from "@shivaedev/access/roleSet.ts";
4
4
  import { AuthUnavailable } from "@shivaedev/errors/taxonomy.ts";
5
5
  import type { ProviderAccountValue } from "#identity.ts";
6
6
  import { assignRole } from "./assignRole.ts";
7
+ import { type AuthTableOptions, tables } from "./tables.ts";
7
8
 
8
9
  export interface AccountRoleSeed<E> {
9
10
  readonly onSignIn: (userId: string) => Effect.Effect<void, E>;
@@ -13,15 +14,17 @@ export const accountRoleSeed = Effect.fn("Identity.accountRoleSeed")(function* <
13
14
  access: Pick<AccessPolicy<TRole>, "Role" | "hasPermission">,
14
15
  role: NoInfer<TRole>,
15
16
  accounts: Config.Config<readonly ProviderAccountValue[]>,
17
+ options?: AuthTableOptions,
16
18
  ) {
17
19
  const listed = yield* accounts;
18
20
  const context = yield* Effect.context<SqlClient.SqlClient>();
19
- const sql = yield* SqlClient.SqlClient;
21
+ const sql = (yield* SqlClient.SqlClient).withoutTransforms();
22
+ const { account: accountTable } = tables(options);
20
23
  const findUsers = SqlSchema.findAll({
21
24
  execute: ({ accountId, providerId, userId }) => sql`
22
- select distinct "userId" as id from "account"
23
- where "providerId" = ${providerId} and "accountId" = ${accountId}
24
- ${userId === undefined ? sql.literal("") : sql`and "userId" = ${userId}`}`,
25
+ select distinct ${sql(accountTable.userId)} as id from ${sql(accountTable.table)}
26
+ where ${sql(accountTable.providerId)} = ${providerId} and ${sql(accountTable.accountId)} = ${accountId}
27
+ ${userId === undefined ? sql.literal("") : sql`and ${sql(accountTable.userId)} = ${userId}`}`,
25
28
  Request: Schema.Struct({ accountId: Schema.String, providerId: Schema.String, userId: Schema.optional(Schema.String) }),
26
29
  Result: Schema.Struct({ id: Schema.String }),
27
30
  });
@@ -31,7 +34,7 @@ export const accountRoleSeed = Effect.fn("Identity.accountRoleSeed")(function* <
31
34
  Effect.mapError(() => new AuthUnavailable({ message: "Could not access provider accounts" })),
32
35
  );
33
36
  for (const user of users) {
34
- yield* assignRole(access, user.id, role);
37
+ yield* assignRole(access, user.id, role, options);
35
38
  }
36
39
  }
37
40
  });
@@ -1,6 +1,8 @@
1
1
  import type { BetterAuthOptions } from "better-auth";
2
- import { Effect, Exit, Option, Schema, Scope } from "effect";
2
+ import { APIError } from "better-auth/api";
3
+ import { Cause, Effect, Exit, Option, Schema, Scope } from "effect";
3
4
  import { SqlClient } from "effect/sql";
5
+ import { authCallSignal } from "#server/adapters/authCall.ts";
4
6
  import { betterAuthTransaction } from "./transaction.ts";
5
7
 
6
8
  type PostgresPool = Extract<NonNullable<BetterAuthOptions["database"]>, { connect: unknown }>;
@@ -17,21 +19,33 @@ interface QueryResult<R> {
17
19
  rows: R[];
18
20
  }
19
21
 
22
+ function databaseResult<A, E>(exit: Exit.Exit<A, E>): A {
23
+ if (Exit.isSuccess(exit)) {
24
+ return exit.value;
25
+ }
26
+ if (Cause.hasInterruptsOnly(exit.cause)) {
27
+ throw new APIError("REQUEST_TIMEOUT", { code: "REQUEST_CANCELLED", message: "Authentication request was cancelled" });
28
+ }
29
+ throw Cause.squash(exit.cause);
30
+ }
31
+
20
32
  export const betterAuthDatabase = Effect.fn("Identity.betterAuthDatabase")(function* () {
21
33
  const sql = yield* SqlClient.SqlClient;
22
34
  const transaction = yield* Effect.serviceOption(sql.transactionService);
23
35
  const parent = yield* Scope.Scope;
24
36
  const context = yield* Effect.context<SqlClient.SqlClient>();
25
37
  const run = Effect.runPromiseWith(context);
38
+ const runQuery = Effect.runPromiseExitWith(context);
26
39
  const pool: PostgresPool = {
27
40
  async connect(): Promise<PoolClient> {
28
41
  const scope = await run(Scope.fork(parent));
29
- const connection = await run(
42
+ const connection = await runQuery(
30
43
  (Option.isSome(transaction) ? Effect.succeed(transaction.value[0]) : sql.reserve).pipe(
31
44
  Scope.provide(scope),
32
45
  Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))),
33
46
  ),
34
- );
47
+ { signal: authCallSignal.getStore() },
48
+ ).then(databaseResult);
35
49
  const control = Option.isSome(transaction) ? await run(betterAuthTransaction.pipe(Scope.provide(scope))) : undefined;
36
50
  function query<R>(text: string, parameters: readonly unknown[]): Promise<QueryResult<R>>;
37
51
  function query<R>(cursor: Cursor<R>): Cursor<R>;
@@ -43,8 +57,11 @@ export const betterAuthDatabase = Effect.fn("Identity.betterAuthDatabase")(funct
43
57
  throw new Error("Better Auth database does not support cursors");
44
58
  }
45
59
  const nested = control?.(text);
60
+ const signal = text === "begin" || text === "commit" || text === "rollback" ? undefined : authCallSignal.getStore();
46
61
  return (
47
- nested === undefined ? run(connection.executeRaw(text, parameters)) : nested.then(() => ({ command: text, rowCount: 0, rows: [] }))
62
+ nested === undefined
63
+ ? runQuery(connection.executeRaw(text, parameters), { signal }).then(databaseResult)
64
+ : nested.then(() => ({ command: text, rowCount: 0, rows: [] }))
48
65
  ).then(Schema.decodeUnknownSync(Result));
49
66
  }
50
67
  return {
@@ -1,6 +1,7 @@
1
1
  import { AsyncLocalStorage } from "node:async_hooks";
2
2
  import { APIError } from "better-auth/api";
3
3
  import { type Cause, Context, Effect, Result } from "effect";
4
+ import { authCall } from "#server/adapters/authCall.ts";
4
5
  import type { BetterAuthHookError } from "#server/better-auth/databaseHooks.ts";
5
6
 
6
7
  export const hookRuntime = Effect.fnUntraced(function* <R>() {
@@ -30,7 +31,7 @@ export const hookRuntime = Effect.fnUntraced(function* <R>() {
30
31
  const state: { readonly context: Context.Context<R>; cause?: Cause.Cause<never> } = {
31
32
  context: Context.merge(context, fiber.context),
32
33
  };
33
- const exit = yield* Effect.exit(Effect.tryPromise((signal) => requests.run(state, () => request(signal))));
34
+ const exit = yield* Effect.exit(authCall((signal) => requests.run(state, () => request(signal))));
34
35
  if (state.cause !== undefined) {
35
36
  return yield* Effect.failCause(state.cause);
36
37
  }
@@ -0,0 +1,25 @@
1
+ import type { BetterAuthOptions } from "better-auth";
2
+ import type { Effect } from "effect";
3
+ import type { BetterAuthPasswordReset } from "#server/better-auth/PasswordReset.ts";
4
+ import type { hookRuntime } from "./hookRuntime.ts";
5
+
6
+ export function passwordResetOptions<TOptions extends BetterAuthOptions, R>(
7
+ options: TOptions,
8
+ hook: BetterAuthPasswordReset<R> | undefined,
9
+ runtime: Effect.Success<ReturnType<typeof hookRuntime<R>>>,
10
+ ): TOptions {
11
+ if (hook === undefined) {
12
+ return options;
13
+ }
14
+ return {
15
+ ...options,
16
+ emailAndPassword: {
17
+ ...options.emailAndPassword,
18
+ enabled: options.emailAndPassword?.enabled ?? false,
19
+ onPasswordReset: async (data, request) => {
20
+ await options.emailAndPassword?.onPasswordReset?.(data, request);
21
+ await runtime.runHook(() => hook(data), request?.signal);
22
+ },
23
+ },
24
+ };
25
+ }
@@ -1,4 +1,5 @@
1
1
  import type { BetterAuthOptions } from "better-auth";
2
+ import { tables } from "#server/better-auth/tables.ts";
2
3
 
3
4
  export interface StoredRoleOptions {
4
5
  readonly defaultRole: string;
@@ -14,7 +15,13 @@ export function storedRoleOptions<TOptions extends BetterAuthOptions>(options: T
14
15
  ...options.user,
15
16
  additionalFields: {
16
17
  ...options.user?.additionalFields,
17
- role: { defaultValue: role.defaultRole, input: false, required: true, type: "string" },
18
+ role: {
19
+ defaultValue: role.defaultRole,
20
+ fieldName: tables(options).user.role,
21
+ input: false,
22
+ required: true,
23
+ type: "string",
24
+ },
18
25
  },
19
26
  },
20
27
  };
@@ -5,6 +5,7 @@ import type { AccessPolicy } from "@shivaedev/access/roleSet.ts";
5
5
  import { AssignRoles, LastRoleAssigner } from "@shivaedev/access/roles.ts";
6
6
  import { AuthUnavailable, NotFound } from "@shivaedev/errors/taxonomy.ts";
7
7
  import { invalidateOnCommit, transact } from "@shivaedev/sql/transact.ts";
8
+ import { type AuthTableOptions, tables } from "./tables.ts";
8
9
 
9
10
  function unavailable() {
10
11
  return new AuthUnavailable({ message: "Could not access app users" });
@@ -14,14 +15,16 @@ export const assignRole = Effect.fn("Identity.assignRole")(function* <TRole exte
14
15
  access: Pick<AccessPolicy<TRole>, "Role" | "hasPermission">,
15
16
  userId: string,
16
17
  role: NoInfer<TRole>,
18
+ options?: AuthTableOptions,
17
19
  ) {
18
- const sql = yield* SqlClient.SqlClient;
20
+ const sql = (yield* SqlClient.SqlClient).withoutTransforms();
21
+ const { user } = tables(options);
19
22
  const existing = yield* Effect.serviceOption(Reactivity.Reactivity);
20
23
  const reactivity = Option.isSome(existing) ? existing.value : yield* Reactivity.make;
21
24
  return yield* Effect.gen(function* () {
22
25
  yield* sql`select pg_advisory_xact_lock(hashtext('platform.auth.user-roles'))`;
23
26
  const readTarget = SqlSchema.findOneOption({
24
- execute: (id) => sql`select id, role from "user" where id = ${id} for update`,
27
+ execute: (id) => sql`select id, ${sql(user.role)} as role from ${sql(user.table)} where id = ${id} for update`,
25
28
  Request: Schema.String,
26
29
  Result: Schema.Struct({ id: Schema.String, role: Schema.NullOr(Schema.String) }),
27
30
  });
@@ -35,7 +38,7 @@ export const assignRole = Effect.fn("Identity.assignRole")(function* <TRole exte
35
38
  const assigners = access.Role.literals.filter((candidate) => access.hasPermission(candidate, AssignRoles));
36
39
  if (assigners.some((candidate) => candidate === target.value.role) && !access.hasPermission(role, AssignRoles)) {
37
40
  const readHolders = SqlSchema.findAll({
38
- execute: () => sql`select id from "user" where role in ${sql.in(assigners)}`,
41
+ execute: () => sql`select id from ${sql(user.table)} where ${sql(user.role)} in ${sql.in(assigners)}`,
39
42
  Request: Schema.Void,
40
43
  Result: Schema.Struct({ id: Schema.String }),
41
44
  });
@@ -44,7 +47,7 @@ export const assignRole = Effect.fn("Identity.assignRole")(function* <TRole exte
44
47
  return yield* Effect.fail(new LastRoleAssigner({ userId }));
45
48
  }
46
49
  }
47
- yield* sql`update "user" set role = ${role}, "updatedAt" = now() where id = ${userId}`;
50
+ yield* sql`update ${sql(user.table)} set ${sql(user.role)} = ${role}, ${sql(user.updatedAt)} = now() where id = ${userId}`;
48
51
  yield* invalidateOnCommit(["admin.users"]);
49
52
  return true;
50
53
  }).pipe(transact({ onSqlError: unavailable }), Effect.provideService(Reactivity.Reactivity, reactivity));
@@ -4,6 +4,7 @@ import { matchType } from "better-auth/db/migration";
4
4
  import { Effect, Schema } from "effect";
5
5
  import { SqlClient } from "effect/sql";
6
6
  import type { StoredRoleOptions } from "#server/better-auth/adapters/storedRoleOptions.ts";
7
+ import { tables } from "./tables.ts";
7
8
 
8
9
  const Column = Schema.Struct({
9
10
  column: Schema.String,
@@ -56,11 +57,11 @@ export const authColumnDrift = Effect.fnUntraced(function* (options: BetterAuthO
56
57
  }
57
58
  }
58
59
  if (role !== undefined) {
59
- const table = options.user?.modelName ?? "user";
60
- const column = columns.find((entry) => entry.table === table && entry.column === "role");
60
+ const { user } = tables(options);
61
+ const column = columns.find((entry) => entry.table === user.table && entry.column === user.role);
61
62
  const value = `'${role.defaultRole.replaceAll("'", "''")}'`;
62
63
  if (column !== undefined && column.default !== `${value}::text`) {
63
- missing.push(`column ${table}.role requires DEFAULT ${value}`);
64
+ missing.push(`column ${user.table}.${user.role} requires DEFAULT ${value}`);
64
65
  }
65
66
  }
66
67
  return missing;
@@ -4,6 +4,7 @@ import { Effect } from "effect";
4
4
  import { SqlClient } from "effect/sql";
5
5
  import { betterAuthDatabase } from "#server/better-auth/adapters/database.ts";
6
6
  import { type StoredRoleOptions, storedRoleOptions } from "#server/better-auth/adapters/storedRoleOptions.ts";
7
+ import { tables } from "./tables.ts";
7
8
 
8
9
  export const betterAuthMigrationPlan = Effect.fn("Identity.betterAuthMigrationPlan")(function* (
9
10
  options: Omit<BetterAuthOptions, "database">,
@@ -23,12 +24,13 @@ export const betterAuthMigrationPlan = Effect.fn("Identity.betterAuthMigrationPl
23
24
  let ddl = compiled === ";" ? "" : compiled;
24
25
  if (role !== undefined) {
25
26
  const sql = (yield* SqlClient.SqlClient).withoutTransforms();
26
- const table = options.user?.modelName ?? "user";
27
+ const { user } = tables(options);
27
28
  const value = `'${role.defaultRole.replaceAll("'", "''")}'`;
28
- const identifier = sql`${sql(table)}`.compile()[0];
29
- ddl += `\nalter table ${identifier} alter column role set default ${value};\n`;
30
- ddl += `update ${identifier} set role = ${value} where role is null;\n`;
31
- ddl += `alter table ${identifier} alter column role set not null;`;
29
+ const identifier = sql`${sql(user.table)}`.compile()[0];
30
+ const column = sql`${sql(user.role)}`.compile()[0];
31
+ ddl += `\nalter table ${identifier} alter column ${column} set default ${value};\n`;
32
+ ddl += `update ${identifier} set ${column} = ${value} where ${column} is null;\n`;
33
+ ddl += `alter table ${identifier} alter column ${column} set not null;`;
32
34
  }
33
35
  return { ddl, missing };
34
36
  });
@@ -5,6 +5,7 @@ import { effectHookOptions } from "#server/better-auth/adapters/effectHookOption
5
5
  import { emailOptions } from "#server/better-auth/adapters/emailOptions.ts";
6
6
  import { type BetterAuthHardeningOptions, withHardening } from "#server/better-auth/adapters/hardening.ts";
7
7
  import { hookRuntime } from "#server/better-auth/adapters/hookRuntime.ts";
8
+ import { passwordResetOptions } from "#server/better-auth/adapters/passwordResetOptions.ts";
8
9
  import { roleSeedOptions } from "#server/better-auth/adapters/roleSeedOptions.ts";
9
10
  import { signInPolicyOptions } from "#server/better-auth/adapters/signInPolicyOptions.ts";
10
11
  import { type StoredRoleOptions, storedRoleOptions } from "#server/better-auth/adapters/storedRoleOptions.ts";
@@ -13,26 +14,29 @@ import { PEER_IP_HEADER } from "#server/better-auth/clientIp.ts";
13
14
  import { memoryRateLimit } from "#server/better-auth/memoryRateLimit.ts";
14
15
  import { mountRoutes } from "#server/better-auth/mountRoutes.ts";
15
16
  import { revokeUnadmitted } from "#server/better-auth/revokeUnadmitted.ts";
16
- import { type PolicyStorage, type SignInPolicy, signInGate } from "#server/better-auth/signInGate.ts";
17
+ import { fromStorage, type PolicyStorage, type SignInPolicy, signInGate } from "#server/better-auth/signInGate.ts";
18
+ import { providerFailure } from "#server/providerFailure.ts";
17
19
  import type { AccountRoleSeed } from "./accountRoleSeed.ts";
18
20
  import { admittedSessions } from "./admittedSessions.ts";
19
21
  import { closeRoleEndpoints } from "./closeRoleEndpoints.ts";
20
22
  import type { BetterAuthDatabaseHooks } from "./databaseHooks.ts";
21
23
  import type { BetterAuthEmails } from "./emails.ts";
22
24
  import { mountedSessions } from "./mountedSessions.ts";
25
+ import type { BetterAuthPasswordReset } from "./PasswordReset.ts";
23
26
 
24
27
  export type BetterAuthMountOptions<E = never, R = never> = {
25
28
  readonly bearerSessions?: BearerSessionsOptions | undefined;
26
29
  readonly databaseHooks?: BetterAuthDatabaseHooks<R> | undefined;
27
30
  readonly emails?: BetterAuthEmails<R> | undefined;
28
31
  readonly hardening?: BetterAuthHardeningOptions;
32
+ readonly onPasswordReset?: BetterAuthPasswordReset<R> | undefined;
29
33
  readonly signIn?: SignInPolicy<E, R> | undefined;
30
34
  } & (
31
35
  | { readonly roles?: undefined; readonly roleSeed?: undefined }
32
36
  | (StoredRoleOptions & { readonly roles: RoleSet; readonly roleSeed?: Effect.Effect<AccountRoleSeed<E>, E, R> })
33
37
  );
34
38
 
35
- export const betterAuthMount = Effect.fn("Platform.betterAuthMount")(function* <const TOptions extends BetterAuthOptions, E = never, R = never>(
39
+ export const betterAuthMount = Effect.fn("Identity.betterAuthMount")(function* <const TOptions extends BetterAuthOptions, E = never, R = never>(
36
40
  options: TOptions,
37
41
  mount: BetterAuthMountOptions<E, R> = {},
38
42
  ) {
@@ -48,7 +52,8 @@ export const betterAuthMount = Effect.fn("Platform.betterAuthMount")(function* <
48
52
  }
49
53
  const gate = yield* signInGate(policy);
50
54
  const runtime = yield* hookRuntime<R>();
51
- const hooked = effectHookOptions(yield* emailOptions(options, mount.emails, runtime), mount.databaseHooks, runtime);
55
+ const reset = passwordResetOptions(options, mount.onPasswordReset, runtime);
56
+ const hooked = effectHookOptions(yield* emailOptions(reset, mount.emails, runtime), mount.databaseHooks, runtime);
52
57
  const configured = mount.roles === undefined ? hooked : storedRoleOptions(closeRoleEndpoints(hooked), mount);
53
58
  const gated = yield* signInPolicyOptions(configured, gate, (): Promise<PolicyStorage> => auth.$context);
54
59
  const seed = mount.roleSeed === undefined ? undefined : yield* mount.roleSeed;
@@ -93,8 +98,16 @@ export const betterAuthMount = Effect.fn("Platform.betterAuthMount")(function* <
93
98
  trustedProxy,
94
99
  });
95
100
  const admit = admittedSessions(gate, () => auth.$context, mount.bearerSessions);
101
+ const admission = yield* signInGate({ ...policy, recheckInterval: 0 });
102
+ const admitsUser = Effect.fn("Identity.admitsUser")(function* (userId: string) {
103
+ if (!admission.active) {
104
+ return true;
105
+ }
106
+ const storage = yield* fromStorage(() => auth.$context);
107
+ return yield* admission.admitsUser(storage, userId).pipe(Effect.catch(providerFailure));
108
+ });
96
109
  const revoke = revokeUnadmitted(gate, () => auth.$context);
97
110
  const lookupSession: unknown = Reflect.get(auth.api, "getSession");
98
111
  const sessions = mountedSessions(lookupSession, admit, mount.roles);
99
- return { admittedSessions: admit, auth, revokeUnadmitted: revoke, routes: authRoutes, sessions };
112
+ return { admitsUser, admittedSessions: admit, auth, revokeUnadmitted: revoke, routes: authRoutes, sessions };
100
113
  });
@@ -7,7 +7,7 @@ import { resolveRole } from "#server/resolveRole.ts";
7
7
  const Fields = Schema.Record(Schema.String, Schema.Unknown);
8
8
  const SessionPayload = Schema.NullOr(Schema.StructWithRest(Schema.Struct({ user: Schema.StructWithRest(SessionUserSchema, [Fields]) }), [Fields]));
9
9
 
10
- export const sessionPermissions = Effect.fn("Platform.sessionPermissions")(function* (
10
+ export const sessionPermissions = Effect.fn("Identity.sessionPermissions")(function* (
11
11
  response: Response,
12
12
  roles: RoleSet,
13
13
  ): Effect.fn.Return<Response, Cause.UnknownError | Schema.SchemaError | Forbidden> {
@@ -50,6 +50,7 @@ export const signInGate = Effect.fnUntraced(function* <E, R>(policy: SignInPolic
50
50
  capacity: RULE_CACHE_CAPACITY,
51
51
  timeToLive: (exit) => (Exit.isSuccess(exit) ? recheckInterval : Duration.zero),
52
52
  });
53
+ const checkRule = Duration.isZero(recheckInterval) ? Cache.refresh : Cache.get;
53
54
  const admits = Effect.fnUntraced(function* (candidates: readonly ProviderAccountValue[]) {
54
55
  const allowed = accounts === undefined ? undefined : yield* accounts;
55
56
  const listed = allowed === undefined ? candidates : candidates.filter((candidate) => allowed.some((entry) => sameAccount(entry, candidate)));
@@ -57,7 +58,7 @@ export const signInGate = Effect.fnUntraced(function* <E, R>(policy: SignInPolic
57
58
  return listed.length > 0;
58
59
  }
59
60
  for (const { accountId, providerId } of listed) {
60
- if (yield* Cache.get(verdicts, { accountId, providerId })) {
61
+ if (yield* checkRule(verdicts, { accountId, providerId })) {
61
62
  return true;
62
63
  }
63
64
  }
@@ -0,0 +1,28 @@
1
+ import type { BetterAuthOptions } from "better-auth";
2
+ import { type BetterAuthDBSchema, getAuthTables } from "better-auth/db";
3
+
4
+ export type AuthTableOptions = Pick<BetterAuthOptions, "user" | "account" | "plugins">;
5
+
6
+ function field(table: BetterAuthDBSchema[string] | undefined, name: string) {
7
+ return table?.fields[name]?.fieldName ?? name;
8
+ }
9
+
10
+ export function tables(options: AuthTableOptions = {}) {
11
+ const schema = getAuthTables(options);
12
+ return {
13
+ account: {
14
+ accountId: field(schema.account, "accountId"),
15
+ providerId: field(schema.account, "providerId"),
16
+ table: schema.account?.modelName ?? "account",
17
+ userId: field(schema.account, "userId"),
18
+ },
19
+ user: {
20
+ createdAt: field(schema.user, "createdAt"),
21
+ email: field(schema.user, "email"),
22
+ name: field(schema.user, "name"),
23
+ role: field(schema.user, "role"),
24
+ table: schema.user?.modelName ?? "user",
25
+ updatedAt: field(schema.user, "updatedAt"),
26
+ },
27
+ };
28
+ }
@@ -9,7 +9,7 @@ export interface UserProfile {
9
9
  readonly name: string;
10
10
  }
11
11
 
12
- export const userProfiles = Effect.fn("Platform.userProfiles")(function* (
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 type { SessionPolicy, SessionShape } from "./session.ts";
6
+ import { SessionPolicy } from "./SessionPolicy.ts";
7
+ import type { SessionShape } from "./session.ts";
7
8
 
8
- export const sessionRequest = Effect.fnUntraced(function* (policy: SessionPolicy<SessionShape>, headers: Headers.Headers, rpc: string) {
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: SessionPolicy<SessionShape>,
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* <TSession extends SessionShape>(policy: SessionPolicy<TSession>, headers: Headers.Headers) {
29
- return yield* sessionAccess(policy, yield* policy.provider.get(headers));
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 { type SessionPolicy, type UserSessionShape, withSessionUser } from "./session.ts";
16
+ import { SessionPolicy } from "./SessionPolicy.ts";
17
+ import { withSessionUser } from "./session.ts";
17
18
 
18
- export function permissionLayer<TMiddleware, TSession extends UserSessionShape>(
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
- const guard: RpcMiddleware.RpcMiddleware<Identity | SessionUser, IdentityFailures, never> = (effect, { headers, rpc, payload }) => {
26
- const lookup = Effect.tap(recheckSession(policy, headers, rpc._tag), (session) =>
27
- Option.isSome(session) && !hasPermission(session.value.user, permission) ? Effect.fail(forbidden(permission)) : Effect.void,
28
- );
29
- return Effect.flatMap(Identity, (viewer) => authorizeReads(commandChanges(effect, rpc, payload), { payload, rpc }, Option.some(viewer))).pipe(
30
- (invocation) => Effect.flatMap(Identity, ({ id }) => invocation.pipe(revalidateStream(policy, rpc, id, lookup))),
31
- (invocation) =>
32
- Effect.andThen(
33
- Effect.flatMap(SessionUser, (user) => requirePermission(user, permission)),
34
- invocation,
35
- ),
36
- withSessionUser(policy, headers, rpc._tag),
37
- );
38
- };
39
- return Layer.succeed(middleware, guard);
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<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>, permission: Permission) {
58
+ export function permissionRoute(permission: Permission) {
53
59
  return <E, R>(handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) =>
54
- (request: HttpServerRequest.HttpServerRequest): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Exclude<R, Identity | SessionUser>> =>
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(policy, request.headers, request.url),
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 type { SessionPolicy, SessionShape } from "./session.ts";
4
+ import { SessionPolicy } from "./SessionPolicy.ts";
5
5
  import { SocketSession } from "./socketSession.ts";
6
6
 
7
- export const recheckSession = Effect.fnUntraced(function* (policy: SessionPolicy<SessionShape>, headers: Headers.Headers, rpc: string) {
8
- const request = yield* sessionRequest(policy, headers, rpc);
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(policy, session);
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 type { SessionPolicy, SessionShape } from "./session.ts";
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.raceFirst(effect, revalidateSession(check, policy.streamRevalidationInterval ?? "30 seconds"));
23
+ return Effect.flatMap(SessionPolicy, (policy) =>
24
+ Effect.raceFirst(effect, revalidateSession(check, policy.streamRevalidationInterval ?? "30 seconds")),
25
+ );
24
26
  };
25
27
  }