@crombolo/auth 0.64.0 → 0.65.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/package.json +3 -3
  2. package/src/service.ts +86 -14
  3. package/src/store.ts +109 -44
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@crombolo/auth",
3
- "version": "0.64.0",
3
+ "version": "0.65.1",
4
4
  "description": "Internal to crombolo, with no compatibility promise: use @crombolo/crombolo. OAuth2 authorization server, password hashing, cookies and member tickets for crombolo.",
5
5
  "license": "MIT",
6
6
  "author": "Crombolo",
@@ -28,8 +28,8 @@
28
28
  "access": "public"
29
29
  },
30
30
  "dependencies": {
31
- "@crombolo/core": "0.64.0",
32
- "@crombolo/data": "0.64.0",
31
+ "@crombolo/core": "0.65.1",
32
+ "@crombolo/data": "0.65.1",
33
33
  "jose": "^6.2.12",
34
34
  "uqr": "^0.1.3"
35
35
  }
package/src/service.ts CHANGED
@@ -11,7 +11,7 @@ import {
11
11
  } from './device.ts'
12
12
  import { hashPassword, isNativeHash, passwordConfigJson, verifyPassword } from './password.ts'
13
13
  import { type CodeChallengeMethod, generateToken, verifyChallenge } from './pkce.ts'
14
- import type { AuthStore, UserRow } from './store.ts'
14
+ import type { Authorization, AuthStore, UserRow } from './store.ts'
15
15
 
16
16
  /**
17
17
  * The `client_id` the vendored backoffice sends, which `routes.ts` checks an
@@ -87,6 +87,15 @@ export type TokenResult =
87
87
  | { ok: true; grant: TokenGrant }
88
88
  | { ok: false; error: TokenError; description: string }
89
89
 
90
+ /** How long an administrator's session views as groups before it ends by itself (story 314). */
91
+ export const VIEW_AS_MS = 3_600_000
92
+
93
+ /** The groups a session is viewing as, and when that ends. */
94
+ export interface ViewingAs {
95
+ groups: Array<{ key: string; name: string }>
96
+ until: Date
97
+ }
98
+
90
99
  export interface ResolvedIdentity {
91
100
  user: UserRow
92
101
  sessionId: string
@@ -95,8 +104,28 @@ export interface ResolvedIdentity {
95
104
  isAdmin: boolean
96
105
  hasAccessToAllLanguages: boolean
97
106
  permissions: string[]
107
+ /**
108
+ * Set while this session views as groups: everything above is theirs. Only
109
+ * ever set for a user who is an administrator in their own right.
110
+ */
111
+ viewingAs?: ViewingAs
98
112
  }
99
113
 
114
+ const identityFrom = (
115
+ user: UserRow,
116
+ authorization: Authorization,
117
+ ): Omit<ResolvedIdentity, 'sessionId'> => ({
118
+ user,
119
+ allowedSections: toSectionAliases(authorization.appAliases),
120
+ groupKeys: authorization.groupKeys,
121
+ isAdmin: authorization.isAdmin,
122
+ hasAccessToAllLanguages: authorization.hasAccessToAllLanguages,
123
+ permissions: authorization.permissions,
124
+ })
125
+
126
+ const groupsOf = (authorization: Authorization) =>
127
+ authorization.groupKeys.map((key, i) => ({ key, name: authorization.groupNames[i] ?? key }))
128
+
100
129
  /**
101
130
  * Normalises login timing so a valid username with a wrong password takes the
102
131
  * same time as an unknown username. Without this, response time reveals which
@@ -349,14 +378,31 @@ export class AuthService {
349
378
  }
350
379
  }
351
380
 
352
- /** Resolves a reference access token to an identity, or undefined. */
353
- async resolveAccessToken(accessToken: string): Promise<ResolvedIdentity | undefined> {
381
+ /**
382
+ * Resolves a reference access token to an identity, or undefined. A session
383
+ * viewing as groups (story 314) resolves to theirs until the view ends.
384
+ */
385
+ async resolveAccessToken(
386
+ accessToken: string,
387
+ now = new Date(),
388
+ ): Promise<ResolvedIdentity | undefined> {
354
389
  const token = await this.#store.findToken(accessToken, 'access')
355
- if (!token || token.revokedAt || token.expiresAt.getTime() < Date.now()) return undefined
390
+ if (!token || token.revokedAt || token.expiresAt.getTime() < now.getTime()) return undefined
356
391
  const session = await this.#store.findSession(token.sessionId)
357
392
  if (!session) return undefined
358
- const identity = await this.identityOf(token.userId)
359
- return identity && { ...identity, sessionId: token.sessionId }
393
+ const user = await this.#activeUser(token.userId)
394
+ if (!user) return undefined
395
+ const own = await this.#store.loadAuthorization(user.id)
396
+ const view = session.view
397
+ if (view && view.until.getTime() > now.getTime() && own.isAdmin) {
398
+ const theirs = await this.#store.loadGroupAuthorization(view.groupKeys)
399
+ return {
400
+ ...identityFrom(user, theirs),
401
+ sessionId: token.sessionId,
402
+ viewingAs: { groups: groupsOf(theirs), until: view.until },
403
+ }
404
+ }
405
+ return { ...identityFrom(user, own), sessionId: token.sessionId }
360
406
  }
361
407
 
362
408
  /**
@@ -365,16 +411,42 @@ export class AuthService {
365
411
  * are locked out or not approved.
366
412
  */
367
413
  async identityOf(userId: number): Promise<Omit<ResolvedIdentity, 'sessionId'> | undefined> {
414
+ const user = await this.#activeUser(userId)
415
+ return user && identityFrom(user, await this.#store.loadAuthorization(user.id))
416
+ }
417
+
418
+ async #activeUser(userId: number): Promise<UserRow | undefined> {
368
419
  const user = await this.#store.findUserById(userId)
369
- if (!user || user.isLockedOut || !user.isApproved) return undefined
370
- const authorization = await this.#store.loadAuthorization(user.id)
420
+ return user && !user.isLockedOut && user.isApproved ? user : undefined
421
+ }
422
+
423
+ /**
424
+ * Turns a session to the given groups' rights for an hour (story 314), for an
425
+ * administrator in their own right only, whatever the session views as now.
426
+ */
427
+ async startViewing(
428
+ sessionId: string,
429
+ groupKeys: readonly string[],
430
+ now = new Date(),
431
+ ): Promise<ViewingAs | 'refused' | 'no-groups'> {
432
+ const session = await this.#store.findSession(sessionId)
433
+ const user = session && (await this.#activeUser(session.userId))
434
+ if (!user || !(await this.#store.loadAuthorization(user.id)).isAdmin) return 'refused'
435
+ const groups = await this.#store.loadGroupAuthorization(groupKeys)
436
+ if (groups.groupKeys.length === 0) return 'no-groups'
437
+ const until = new Date(now.getTime() + VIEW_AS_MS)
438
+ await this.#store.setSessionView(sessionId, { groupKeys: groups.groupKeys, until })
439
+ return { groups: groupsOf(groups), until }
440
+ }
441
+
442
+ /** Turns a session back to its user's own rights; answers what it was viewing as, if anything. */
443
+ async stopViewing(sessionId: string, now = new Date()): Promise<ViewingAs | undefined> {
444
+ const view = (await this.#store.findSession(sessionId))?.view
445
+ await this.#store.setSessionView(sessionId, undefined)
446
+ if (!view || view.until.getTime() <= now.getTime()) return undefined
371
447
  return {
372
- user,
373
- allowedSections: toSectionAliases(authorization.appAliases),
374
- groupKeys: authorization.groupKeys,
375
- isAdmin: authorization.isAdmin,
376
- hasAccessToAllLanguages: authorization.hasAccessToAllLanguages,
377
- permissions: authorization.permissions,
448
+ groups: groupsOf(await this.#store.loadGroupAuthorization(view.groupKeys)),
449
+ until: view.until,
378
450
  }
379
451
  }
380
452
 
package/src/store.ts CHANGED
@@ -4,6 +4,7 @@
4
4
  * Everything bearer-shaped is stored hashed, so a database read cannot yield a
5
5
  * usable credential.
6
6
  */
7
+ import { normaliseUuid } from '@crombolo/core'
7
8
  import { type Db, DbDate, fromDbBool, Locks } from '@crombolo/data'
8
9
  import { DeviceStore } from './device.ts'
9
10
  import { hashToken } from './pkce.ts'
@@ -26,6 +27,48 @@ export interface UserRow {
26
27
  kind: 'Default' | 'Api'
27
28
  }
28
29
 
30
+ /** A session viewing as user groups (story 314): their keys, and when it ends. */
31
+ export interface SessionView {
32
+ groupKeys: string[]
33
+ until: Date
34
+ }
35
+
36
+ export interface SessionRow {
37
+ userId: number
38
+ view?: SessionView
39
+ }
40
+
41
+ /** What a set of groups allows, unioned across them. */
42
+ export interface Authorization {
43
+ appAliases: string[]
44
+ groupKeys: string[]
45
+ groupNames: string[]
46
+ isAdmin: boolean
47
+ hasAccessToAllLanguages: boolean
48
+ permissions: string[]
49
+ granular: Array<{ nodeKey: string; permission: string; context: string }>
50
+ }
51
+
52
+ const NO_AUTHORIZATION: Authorization = {
53
+ appAliases: [],
54
+ groupKeys: [],
55
+ groupNames: [],
56
+ isAdmin: false,
57
+ hasAccessToAllLanguages: false,
58
+ permissions: [],
59
+ granular: [],
60
+ }
61
+
62
+ const parseKeys = (json: string | null): string[] => {
63
+ if (!json) return []
64
+ try {
65
+ const parsed: unknown = JSON.parse(json)
66
+ return Array.isArray(parsed) ? parsed.filter((k): k is string => typeof k === 'string') : []
67
+ } catch {
68
+ return []
69
+ }
70
+ }
71
+
29
72
  export interface AuthorizationCodeInit {
30
73
  code: string
31
74
  userId: number
@@ -250,14 +293,34 @@ export class AuthStore {
250
293
  .execute()
251
294
  }
252
295
 
253
- async findSession(sessionId: string): Promise<{ userId: number } | undefined> {
296
+ async findSession(sessionId: string): Promise<SessionRow | undefined> {
254
297
  const row = await this.#db.q
255
298
  .selectFrom('user_login_session')
256
- .select('user_id')
299
+ .select(['user_id', 'view_as_groups', 'view_as_until'])
257
300
  .where('session_id', '=', sessionId)
258
301
  .where('logged_out_utc', 'is', null)
259
302
  .executeTakeFirst()
260
- return row ? { userId: Number(row.user_id) } : undefined
303
+ if (!row) return undefined
304
+ const until = DbDate.fromDb(row.view_as_until)
305
+ return {
306
+ userId: Number(row.user_id),
307
+ ...(row.view_as_groups && until
308
+ ? { view: { groupKeys: parseKeys(row.view_as_groups), until } }
309
+ : {}),
310
+ }
311
+ }
312
+
313
+ /** Sets, or with undefined clears, what an open session is viewing as. */
314
+ async setSessionView(sessionId: string, view: SessionView | undefined): Promise<void> {
315
+ await this.#db.q
316
+ .updateTable('user_login_session')
317
+ .set({
318
+ view_as_groups: view ? JSON.stringify(view.groupKeys) : null,
319
+ view_as_until: view ? DbDate.toDb(view.until) : null,
320
+ })
321
+ .where('session_id', '=', sessionId)
322
+ .where('logged_out_utc', 'is', null)
323
+ .execute()
261
324
  }
262
325
 
263
326
  async endSession(sessionId: string): Promise<void> {
@@ -404,65 +467,67 @@ export class AuthStore {
404
467
  await this.#db.q.deleteFrom('auth_token').where('expires_at', '<', cutoff).execute()
405
468
  }
406
469
 
407
- /** Section aliases and admin membership, unioned across the user's groups. */
408
- async loadAuthorization(userId: number): Promise<{
409
- appAliases: string[]
410
- groupKeys: string[]
411
- isAdmin: boolean
412
- hasAccessToAllLanguages: boolean
413
- permissions: string[]
414
- granular: Array<{ nodeKey: string; permission: string; context: string }>
415
- }> {
470
+ /** What the user's own groups allow. */
471
+ async loadAuthorization(userId: number): Promise<Authorization> {
416
472
  const groups = await this.#db.q
417
473
  .selectFrom('user_group as g')
418
474
  .innerJoin('user_group_member as m', 'm.user_group_id', 'g.id')
419
- .select(['g.id', 'g.key', 'g.alias', 'g.has_access_to_all_languages'])
475
+ .select(['g.id', 'g.key', 'g.alias', 'g.name', 'g.has_access_to_all_languages'])
420
476
  .where('m.user_id', '=', userId)
421
477
  .execute()
422
- const groupKeys = groups.map((g) => String(g.key))
423
- const isAdmin = groups.some((g) => String(g.alias) === 'admin')
424
- const hasAccessToAllLanguages = groups.some((g) => fromDbBool(g.has_access_to_all_languages))
478
+ return this.#authorizationOf(groups)
479
+ }
425
480
 
426
- if (groups.length === 0) {
427
- return {
428
- appAliases: [],
429
- groupKeys: [],
430
- isAdmin: false,
431
- hasAccessToAllLanguages: false,
432
- permissions: [],
433
- granular: [],
434
- }
435
- }
481
+ /** What the groups with these keys allow, as if someone were a member of exactly them. */
482
+ async loadGroupAuthorization(groupKeys: readonly string[]): Promise<Authorization> {
483
+ const keys = groupKeys.filter((k) => /^[0-9a-f-]{32,36}$/i.test(k)).map(normaliseUuid)
484
+ if (keys.length === 0) return NO_AUTHORIZATION
485
+ const groups = await this.#db.q
486
+ .selectFrom('user_group as g')
487
+ .select(['g.id', 'g.key', 'g.alias', 'g.name', 'g.has_access_to_all_languages'])
488
+ .where('g.key', 'in', keys)
489
+ .orderBy('g.name')
490
+ .execute()
491
+ return this.#authorizationOf(groups)
492
+ }
436
493
 
494
+ async #authorizationOf(
495
+ groups: Array<{
496
+ id: number
497
+ key: string
498
+ alias: string
499
+ name: string | null
500
+ has_access_to_all_languages: unknown
501
+ }>,
502
+ ): Promise<Authorization> {
503
+ if (groups.length === 0) return NO_AUTHORIZATION
504
+ const ids = groups.map((g) => Number(g.id))
505
+ const keys = groups.map((g) => String(g.key))
437
506
  const sections = await this.#db.q
438
- .selectFrom('user_group_section as s')
439
- .innerJoin('user_group_member as m', 'm.user_group_id', 's.user_group_id')
440
- .select('s.app_alias')
507
+ .selectFrom('user_group_section')
508
+ .select('app_alias')
441
509
  .distinct()
442
- .where('m.user_id', '=', userId)
510
+ .where('user_group_id', 'in', ids)
443
511
  .execute()
444
512
  const permissions = await this.#db.q
445
- .selectFrom('user_group_permission as p')
446
- .innerJoin('user_group as g', 'g.key', 'p.user_group_key')
447
- .innerJoin('user_group_member as m', 'm.user_group_id', 'g.id')
448
- .select('p.permission')
513
+ .selectFrom('user_group_permission')
514
+ .select('permission')
449
515
  .distinct()
450
- .where('m.user_id', '=', userId)
516
+ .where('user_group_key', 'in', keys)
451
517
  .execute()
452
518
  const granular = await this.#db.q
453
- .selectFrom('user_group_granular_permission as gp')
454
- .innerJoin('user_group as g', 'g.key', 'gp.user_group_key')
455
- .innerJoin('user_group_member as m', 'm.user_group_id', 'g.id')
456
- .select(['gp.unique_id', 'gp.permission', 'gp.context'])
457
- .where('m.user_id', '=', userId)
458
- .where('gp.unique_id', 'is not', null)
519
+ .selectFrom('user_group_granular_permission')
520
+ .select(['unique_id', 'permission', 'context'])
521
+ .where('user_group_key', 'in', keys)
522
+ .where('unique_id', 'is not', null)
459
523
  .execute()
460
524
 
461
525
  return {
462
526
  appAliases: sections.map((s) => String(s.app_alias)),
463
- groupKeys,
464
- isAdmin,
465
- hasAccessToAllLanguages,
527
+ groupKeys: keys,
528
+ groupNames: groups.map((g) => String(g.name ?? g.alias)),
529
+ isAdmin: groups.some((g) => String(g.alias) === 'admin'),
530
+ hasAccessToAllLanguages: groups.some((g) => fromDbBool(g.has_access_to_all_languages)),
466
531
  permissions: permissions.map((p) => String(p.permission)),
467
532
  granular: granular.map((g) => ({
468
533
  nodeKey: String(g.unique_id),