@starci/hfs 5.3.0 → 5.5.0

package/templates/be/auth-lite/src/modules/domain/identity/account-directory.service.spec.ts

@@ -32,6 +32,21 @@ describe("IdentityAccountDirectoryService.find", () => {
         expect(await addressless.directory.find("u-1")).toEqual({ id: "u-1", email: null, disabled: false })
     })
 
+    it("answers the full name the profile keys hold, and none for an empty or a missing one", async () => {
+        const named = await build([accountByIdRow("named")])
+        const blank = await build([{ ...accountByIdRow(), meta: { full_name: "" } }])
+        const raw = await build([{ ...accountByIdRow(), meta: null }])
+
+        expect(await named.directory.find("u-1")).toEqual({
+            id: "u-1",
+            email: "a@example.test",
+            disabled: false,
+            name: "Ada Lovelace",
+        })
+        expect((await blank.directory.find("u-1"))?.name).toBeUndefined()
+        expect((await raw.directory.find("u-1"))?.name).toBeUndefined()
+    })
+
     it("answers undefined for an account that does not exist", async () => {
         const { directory } = await build([])
 

package/templates/be/auth-lite/src/modules/domain/identity/account-directory.service.ts

@@ -3,10 +3,10 @@ import { Injectable } from "@nestjs/common"
 import type { EntityManager } from "typeorm"
 import type { AccountDirectory, AccountStanding } from "@modules/integrations/passport"
 import { InjectPrimaryEntityManager } from "@modules/platform/database"
-import { accountDoors } from "./persistence/account-doors.port"
+import { accountDoors, fullNameOf } from "./persistence/account-doors.port"
 
 @Injectable()
-/** The package's account directory over the account doors: whether an account still stands, for a refresh to go on. */
+/** The package's account directory over the account doors: whether an account still stands, for a refresh to go on, and the person's full name. */
 export class IdentityAccountDirectoryService implements AccountDirectory {
     constructor(@InjectPrimaryEntityManager() private readonly entityManager: EntityManager) {}
 
@@ -14,6 +14,12 @@ export class IdentityAccountDirectoryService implements AccountDirectory {
     async find(userId: string): Promise<AccountStanding | undefined> {
         const account = await accountDoors.userById(this.entityManager, userId)
         if (account === undefined) return undefined
-        return { id: account.id, email: account.email, disabled: account.disabled }
+        const name = fullNameOf(account.meta)
+        return {
+            id: account.id,
+            email: account.email,
+            disabled: account.disabled,
+            ...(name === undefined ? {} : { name }),
+        }
     }
 }

package/templates/be/auth-lite/src/modules/domain/identity/authenticator.service.spec.ts

@@ -40,7 +40,8 @@ const profile = (patch: Partial<GoogleProfile> = {}): GoogleProfile => ({
 type Stubs = ReadonlyArray<readonly [string, unknown]>
 
 const build = async (answers: Stubs, matches = true) => {
-    const entityManager: MockEntityManager = answers.length === 0 ? mockEntityManager() : mockEntityManager({ query: answers })
+    const entityManager: MockEntityManager =
+        answers.length === 0 ? mockEntityManager() : mockEntityManager({ query: answers })
     fakeTransaction(entityManager)
     const passwords = mock<AuthPasswords>()
     passwords.verify.mockResolvedValue(matches)
@@ -70,7 +71,10 @@ describe("IdentityAuthenticatorService.verifyPassword", () => {
             [TOUCH_USER, []],
         ])
 
-        expect(await subject.verifyPassword("  A@Example.test ", "correct horse")).toEqual({ userId: "u-1", email: "a@example.test" })
+        expect(await subject.verifyPassword("  A@Example.test ", "correct horse")).toEqual({
+            userId: "u-1",
+            email: "a@example.test",
+        })
 
         expect(budget.counted).toHaveBeenCalledWith("login", "a@example.test", expect.any(Function))
         expect(passwords.verify).toHaveBeenCalledWith("correct horse", "hash")
@@ -82,7 +86,9 @@ describe("IdentityAuthenticatorService.verifyPassword", () => {
         const unknown = await build([[USER_BY_EMAIL, []]])
         const wrong = await build([[USER_BY_EMAIL, [accountByEmailRow()]]], false)
 
-        await expect(unknown.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(refusal(IdentityErrorCode.PairRefused))
+        await expect(unknown.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(
+            refusal(IdentityErrorCode.PairRefused),
+        )
         await expect(wrong.subject.verifyPassword("a@example.test", "pw")).rejects.toBeInstanceOf(IdentityError)
         expect(unknown.passwords.verify).toHaveBeenCalledWith("pw", "")
         expect(wrong.entityManager.query).not.toHaveBeenCalledWith(TOUCH_USER, expect.anything())
@@ -100,8 +106,12 @@ describe("IdentityAuthenticatorService.verifyPassword", () => {
         const disabled = await build([[USER_BY_EMAIL, [accountByEmailRow("disabled")]]])
         const unconfirmed = await build([[USER_BY_EMAIL, [accountByEmailRow("unconfirmed")]]])
 
-        await expect(disabled.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(refusal(IdentityErrorCode.AccountDisabled))
-        await expect(unconfirmed.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(refusal(IdentityErrorCode.EmailNotConfirmed))
+        await expect(disabled.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(
+            refusal(IdentityErrorCode.AccountDisabled),
+        )
+        await expect(unconfirmed.subject.verifyPassword("a@example.test", "pw")).rejects.toEqual(
+            refusal(IdentityErrorCode.EmailNotConfirmed),
+        )
         expect(disabled.entityManager.query).not.toHaveBeenCalledWith(TOUCH_USER, expect.anything())
         expect(unconfirmed.entityManager.query).not.toHaveBeenCalledWith(TOUCH_USER, expect.anything())
     })
@@ -111,8 +121,12 @@ describe("IdentityAuthenticatorService.signInWithGoogle", () => {
     it("refuses a profile without a verified address, and calls no door", async () => {
         const { subject, entityManager } = await build([])
 
-        await expect(subject.signInWithGoogle(profile({ emailVerified: false }))).rejects.toEqual(refusal(PassportErrorCode.GoogleRejected))
-        await expect(subject.signInWithGoogle(profile({ email: null }))).rejects.toEqual(refusal(PassportErrorCode.GoogleRejected))
+        await expect(subject.signInWithGoogle(profile({ emailVerified: false }))).rejects.toEqual(
+            refusal(PassportErrorCode.GoogleRejected),
+        )
+        await expect(subject.signInWithGoogle(profile({ email: null }))).rejects.toEqual(
+            refusal(PassportErrorCode.GoogleRejected),
+        )
         expect(entityManager.query).not.toHaveBeenCalled()
     })
 
@@ -128,7 +142,27 @@ describe("IdentityAuthenticatorService.signInWithGoogle", () => {
 
         expect(entityManager.query).not.toHaveBeenCalledWith(USER_BY_EMAIL, expect.anything())
         expect(entityManager.query).not.toHaveBeenCalledWith(CREATE_USER, expect.anything())
-        expect(entityManager.query).toHaveBeenCalledWith(TOUCH_USER, ["u-1", NOW, true, expect.stringContaining('"full_name":"A"')])
+        expect(entityManager.query).toHaveBeenCalledWith(TOUCH_USER, [
+            "u-1",
+            NOW,
+            true,
+            expect.stringContaining('"full_name":"A"'),
+        ])
+    })
+
+    it("answers the full name the account's profile keys hold with the person", async () => {
+        const { subject } = await build([
+            [USER_BY_GOOGLE, [{ be_auth_user_by_google: "u-1" }]],
+            [LINK_GOOGLE, []],
+            [TOUCH_USER, []],
+            [USER_BY_ID, [accountByIdRow("named")]],
+        ])
+
+        expect(await subject.signInWithGoogle(profile())).toEqual({
+            userId: "u-1",
+            email: "a@example.test",
+            name: "Ada Lovelace",
+        })
     })
 
     it("links an existing account by its verified address", async () => {
@@ -143,10 +177,14 @@ describe("IdentityAuthenticatorService.signInWithGoogle", () => {
         expect(await subject.signInWithGoogle(profile())).toEqual({ userId: "u-1", email: "a@example.test" })
 
         expect(entityManager.query).toHaveBeenCalledWith(USER_BY_EMAIL, ["a@example.test"])
-        expect(entityManager.query).toHaveBeenCalledWith(LINK_GOOGLE, ["u-1", "g-1", expect.stringContaining('"sub":"g-1"'), NOW])
+        expect(entityManager.query).toHaveBeenCalledWith(LINK_GOOGLE, [
+            "u-1",
+            "g-1",
+            expect.stringContaining('"sub":"g-1"'),
+            NOW,
+        ])
         expect(entityManager.query).not.toHaveBeenCalledWith(CREATE_USER, expect.anything())
     })
-
 })
 
 describe("IdentityAuthenticatorService.signInWithGoogle (new accounts and refusals)", () => {
@@ -162,8 +200,20 @@ describe("IdentityAuthenticatorService.signInWithGoogle (new accounts and refusa
 
         expect(await subject.signInWithGoogle(profile())).toEqual({ userId: NEW_ID, email: "a@example.test" })
 
-        expect(entityManager.query).toHaveBeenCalledWith(CREATE_USER, [NEW_ID, "a@example.test", null, true, expect.stringContaining('"full_name":"A"'), NOW])
-        expect(entityManager.query).toHaveBeenCalledWith(LINK_GOOGLE, [NEW_ID, "g-1", expect.stringContaining("g-1"), NOW])
+        expect(entityManager.query).toHaveBeenCalledWith(CREATE_USER, [
+            NEW_ID,
+            "a@example.test",
+            null,
+            true,
+            expect.stringContaining('"full_name":"A"'),
+            NOW,
+        ])
+        expect(entityManager.query).toHaveBeenCalledWith(LINK_GOOGLE, [
+            NEW_ID,
+            "g-1",
+            expect.stringContaining("g-1"),
+            NOW,
+        ])
         expect(logger.info).toHaveBeenCalledWith(IdentitySignInLogEvent.AccountCreated, { userId: NEW_ID })
     })
 
@@ -177,10 +227,17 @@ describe("IdentityAuthenticatorService.signInWithGoogle (new accounts and refusa
 
         await subject.signInWithGoogle(profile({ name: null, picture: "https://img.example.test/a.png" }))
 
-        const keys = { avatar_url: "https://img.example.test/a.png", picture: "https://img.example.test/a.png", email: "A@Example.test", email_verified: true }
+        const keys = {
+            avatar_url: "https://img.example.test/a.png",
+            picture: "https://img.example.test/a.png",
+            email: "A@Example.test",
+            email_verified: true,
+        }
         expect(entityManager.query).toHaveBeenCalledWith(TOUCH_USER, ["u-1", NOW, true, JSON.stringify(keys)])
     })
+})
 
+describe("IdentityAuthenticatorService.signInWithGoogle (refusals of a new account)", () => {
     it("refuses when the create door answers no account", async () => {
         const { subject, entityManager } = await build([
             [USER_BY_GOOGLE, [{ be_auth_user_by_google: null }]],
@@ -202,8 +259,14 @@ describe("IdentityAuthenticatorService.signInWithGoogle (new accounts and refusa
         const gone = await build([...linked, [USER_BY_ID, []]])
         const addressless = await build([...linked, [USER_BY_ID, [accountByIdRow("addressless")]]])
 
-        await expect(disabled.subject.signInWithGoogle(profile())).rejects.toEqual(refusal(IdentityErrorCode.AccountDisabled))
-        await expect(gone.subject.signInWithGoogle(profile())).rejects.toEqual(refusal(PassportErrorCode.GoogleRejected))
-        await expect(addressless.subject.signInWithGoogle(profile())).rejects.toEqual(refusal(PassportErrorCode.GoogleRejected))
+        await expect(disabled.subject.signInWithGoogle(profile())).rejects.toEqual(
+            refusal(IdentityErrorCode.AccountDisabled),
+        )
+        await expect(gone.subject.signInWithGoogle(profile())).rejects.toEqual(
+            refusal(PassportErrorCode.GoogleRejected),
+        )
+        await expect(addressless.subject.signInWithGoogle(profile())).rejects.toEqual(
+            refusal(PassportErrorCode.GoogleRejected),
+        )
     })
 })

package/templates/be/auth-lite/src/modules/domain/identity/authenticator.service.ts

@@ -2,7 +2,13 @@
 import { Injectable } from "@nestjs/common"
 import type { EntityManager } from "typeorm"
 import { PassportError, PassportErrorCode, isPresentablePassword, normalizeEmail } from "@modules/integrations/passport"
-import type { AuthAuthenticator, AuthPasswords, AuthSubject, GoogleProfile, SignInBudget } from "@modules/integrations/passport"
+import type {
+    AuthAuthenticator,
+    AuthPasswords,
+    AuthSubject,
+    GoogleProfile,
+    SignInBudget,
+} from "@modules/integrations/passport"
 import { InjectClock } from "@modules/platform/clock"
 import type { Clock } from "@modules/platform/clock"
 import { InjectPrimaryEntityManager } from "@modules/platform/database"
@@ -13,7 +19,7 @@ import type { Logger } from "@modules/platform/logging"
 import { IdentityError, IdentityErrorCode } from "./errors/identity.error"
 import { InjectAuthPasswords, InjectSignInBudget } from "./identity.decorators"
 import { IdentitySignInLogEvent } from "./identity-sign-in.log-events"
-import { accountDoors } from "./persistence/account-doors.port"
+import { accountDoors, fullNameOf } from "./persistence/account-doors.port"
 
 /** A Google profile whose email Google verified, so it has one. */
 type VerifiedProfile = GoogleProfile & { readonly email: string }
@@ -43,7 +49,10 @@ export class IdentityAuthenticatorService implements AuthAuthenticator {
         const address = normalizeEmail(email)
         const account = await this.budget.counted("login", address, async () => {
             const found = await accountDoors.userByEmail(this.entityManager, address)
-            const matches = await this.passwords.verify(isPresentablePassword(password) ? password : "", found?.encrypted_password ?? "")
+            const matches = await this.passwords.verify(
+                isPresentablePassword(password) ? password : "",
+                found?.encrypted_password ?? "",
+            )
             return { passed: found !== undefined && matches, value: found !== undefined && matches ? found : undefined }
         })
         if (account === undefined) throw new IdentityError({ code: IdentityErrorCode.PairRefused })
@@ -55,7 +64,8 @@ export class IdentityAuthenticatorService implements AuthAuthenticator {
 
     /** Finds the account a Google subject is linked to, else links by a verified email, else creates the account. */
     async signInWithGoogle(profile: GoogleProfile): Promise<AuthSubject> {
-        if (profile.email === null || !profile.emailVerified) throw new PassportError({ code: PassportErrorCode.GoogleRejected })
+        if (profile.email === null || !profile.emailVerified)
+            throw new PassportError({ code: PassportErrorCode.GoogleRejected })
         const address = normalizeEmail(profile.email)
         const verified: VerifiedProfile = { ...profile, email: profile.email }
         const now = this.clock.now()
@@ -63,20 +73,40 @@ export class IdentityAuthenticatorService implements AuthAuthenticator {
             const linked = await accountDoors.userByGoogle(scoped, profile.subject)
             const byEmail = linked === null ? await accountDoors.userByEmail(scoped, address) : undefined
             const id = linked ?? byEmail?.id ?? (await this.createFor(scoped, address, verified, now))
-            const identityData = { sub: profile.subject, email: address, name: profile.name, picture: profile.picture, email_verified: true }
+            const identityData = {
+                sub: profile.subject,
+                email: address,
+                name: profile.name,
+                picture: profile.picture,
+                email_verified: true,
+            }
             await accountDoors.linkGoogle(scoped, id, profile.subject, JSON.stringify(identityData), now)
             await accountDoors.touchUser(scoped, id, now, true, JSON.stringify(profileKeysOf(verified)))
             return id
         })
         const account = await accountDoors.userById(this.entityManager, userId)
-        if (account?.email === undefined || account.email === null) throw new PassportError({ code: PassportErrorCode.GoogleRejected })
+        if (account?.email === undefined || account.email === null)
+            throw new PassportError({ code: PassportErrorCode.GoogleRejected })
         if (account.disabled) throw new IdentityError({ code: IdentityErrorCode.AccountDisabled })
-        return { userId: account.id, email: account.email }
+        const name = fullNameOf(account.meta)
+        return { userId: account.id, email: account.email, ...(name === undefined ? {} : { name }) }
     }
 
-    private async createFor(scoped: EntityManager, address: string, profile: VerifiedProfile, now: Date): Promise<string> {
+    private async createFor(
+        scoped: EntityManager,
+        address: string,
+        profile: VerifiedProfile,
+        now: Date,
+    ): Promise<string> {
         const id = this.ids.next()
-        const created = await accountDoors.createUser(scoped, { id, email: address, hash: null, confirmed: true, meta: JSON.stringify(profileKeysOf(profile)), now })
+        const created = await accountDoors.createUser(scoped, {
+            id,
+            email: address,
+            hash: null,
+            confirmed: true,
+            meta: JSON.stringify(profileKeysOf(profile)),
+            now,
+        })
         if (created === undefined) throw new PassportError({ code: PassportErrorCode.GoogleRejected })
         this.logger.info(IdentitySignInLogEvent.AccountCreated, { userId: created })
         return created

package/templates/be/auth-lite/src/modules/domain/identity/identity-email.service.spec.ts

@@ -38,7 +38,15 @@ const SETTINGS = {
 } as unknown as MailOptions
 
 const refusal = (code: string): unknown => expect.objectContaining({ code })
-const tokenRow = (purpose: string): IdentityEmailTokenEntity => ({ id: "t-1", userId: "u-1", purpose, tokenHash: "h", expiresAt: new Date("2026-02-04T00:00:00.000Z"), usedAt: null, createdAt: NOW })
+const tokenRow = (purpose: string): IdentityEmailTokenEntity => ({
+    id: "t-1",
+    userId: "u-1",
+    purpose,
+    tokenHash: "h",
+    expiresAt: new Date("2026-02-04T00:00:00.000Z"),
+    usedAt: null,
+    createdAt: NOW,
+})
 
 const build = async (entityManager: MockEntityManager) => {
     const passwords = mock<AuthPasswords>()
@@ -68,42 +76,85 @@ const build = async (entityManager: MockEntityManager) => {
 
 describe("IdentityEmailService.signup", () => {
     it("creates an unconfirmed account through the door, stores only the digest of the link token and mails the link", async () => {
-        const entityManager = mockEntityManager({ query: [[USER_BY_EMAIL, []], [CREATE_USER, [{ be_auth_create_user: NEW_ID }]]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+        const entityManager = mockEntityManager({
+            query: [
+                [USER_BY_EMAIL, []],
+                [CREATE_USER, [{ be_auth_create_user: NEW_ID }]],
+            ],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(entityManager)
         const { subject, budget, mailer } = await build(entityManager)
 
         await subject.signup(" New@Example.test ", "correct horse")
 
         expect(budget.admit).toHaveBeenCalledWith("signup", "new@example.test")
-        expect(entityManager.query).toHaveBeenCalledWith(CREATE_USER, [NEW_ID, "new@example.test", "new-hash", false, "{}", NOW])
+        expect(entityManager.query).toHaveBeenCalledWith(CREATE_USER, [
+            NEW_ID,
+            "new@example.test",
+            "new-hash",
+            false,
+            "{}",
+            NOW,
+        ])
         const sent = mailer.send.mock.calls[0]?.[0]
         const url = /https:\/\/[^\s"<]+/u.exec(sent?.message.text ?? "")?.[0] ?? ""
         const token = new URL(url).searchParams.get("token") ?? ""
         expect(new URL(url).pathname).toBe("/auth/confirm")
         expect(token).toHaveLength(64)
-        expect(entityManager.insert).toHaveBeenCalledWith(IdentityEmailTokenEntity, expect.objectContaining({ userId: NEW_ID, purpose: "confirm", tokenHash: digestOf(token), usedAt: null }))
+        expect(entityManager.insert).toHaveBeenCalledWith(
+            IdentityEmailTokenEntity,
+            expect.objectContaining({ userId: NEW_ID, purpose: "confirm", tokenHash: digestOf(token), usedAt: null }),
+        )
         expect(sent?.to).toBe("new@example.test")
     })
 
-    it("keeps the generated id when the create door answers no row", async () => {
-        const entityManager = mockEntityManager({ query: [[USER_BY_EMAIL, []], [CREATE_USER, []]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+    it("keeps the generated id when the create door answers no row, and the full name in the profile keys", async () => {
+        const entityManager = mockEntityManager({
+            query: [
+                [USER_BY_EMAIL, []],
+                [CREATE_USER, []],
+            ],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(entityManager)
         const { subject } = await build(entityManager)
 
-        await subject.signup("new@example.test", "correct horse")
-
-        expect(entityManager.insert).toHaveBeenCalledWith(IdentityEmailTokenEntity, expect.objectContaining({ userId: NEW_ID }))
+        await subject.signup("new@example.test", "correct horse", "en", "Ada Lovelace")
+
+        expect(entityManager.query).toHaveBeenCalledWith(CREATE_USER, [
+            NEW_ID,
+            "new@example.test",
+            "new-hash",
+            false,
+            JSON.stringify({ full_name: "Ada Lovelace", name: "Ada Lovelace" }),
+            NOW,
+        ])
+        expect(entityManager.insert).toHaveBeenCalledWith(
+            IdentityEmailTokenEntity,
+            expect.objectContaining({ userId: NEW_ID }),
+        )
     })
 
     it("refuses a password the policy rejects before it touches an account", async () => {
         const { subject, mailer } = await build(mockEntityManager())
 
-        await expect(subject.signup("a@example.test", "short")).rejects.toEqual(refusal(IdentityErrorCode.PasswordInvalid))
+        await expect(subject.signup("a@example.test", "short")).rejects.toEqual(
+            refusal(IdentityErrorCode.PasswordInvalid),
+        )
         expect(mailer.send).not.toHaveBeenCalled()
     })
+})
 
+describe("IdentityEmailService.signup (an address already known, a failing mail server, a spent budget)", () => {
     it("mails a new link to an unconfirmed account and says nothing about a confirmed one", async () => {
-        const unconfirmed = mockEntityManager({ query: [USER_BY_EMAIL, [account("unconfirmed")]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+        const unconfirmed = mockEntityManager({
+            query: [USER_BY_EMAIL, [account("unconfirmed")]],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(unconfirmed)
         const confirmed = mockEntityManager({ query: [USER_BY_EMAIL, [account()]] })
         const first = await build(unconfirmed)
@@ -118,7 +169,14 @@ describe("IdentityEmailService.signup", () => {
     })
 
     it("answers as if the mail was sent when the mail server fails, and logs the failure", async () => {
-        const entityManager = mockEntityManager({ query: [[USER_BY_EMAIL, []], [CREATE_USER, [{ be_auth_create_user: NEW_ID }]]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+        const entityManager = mockEntityManager({
+            query: [
+                [USER_BY_EMAIL, []],
+                [CREATE_USER, [{ be_auth_create_user: NEW_ID }]],
+            ],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(entityManager)
         const { subject, mailer, logger } = await build(entityManager)
         mailer.send.mockRejectedValue(new Error("down"))
@@ -131,7 +189,9 @@ describe("IdentityEmailService.signup", () => {
         const { subject, budget } = await build(mockEntityManager())
         budget.admit.mockRejectedValue(new AuthError(IdentityErrorCode.TooManyAttempts))
 
-        await expect(subject.signup("a@example.test", "correct horse")).rejects.toEqual(refusal(IdentityErrorCode.TooManyAttempts))
+        await expect(subject.signup("a@example.test", "correct horse")).rejects.toEqual(
+            refusal(IdentityErrorCode.TooManyAttempts),
+        )
         budget.admit.mockRejectedValue(new Error("store down"))
         await expect(subject.resend("a@example.test")).rejects.toThrow("store down")
     })
@@ -139,7 +199,11 @@ describe("IdentityEmailService.signup", () => {
 
 describe("IdentityEmailService.resend", () => {
     it("mails only an unconfirmed password account", async () => {
-        const entityManager = mockEntityManager({ query: [USER_BY_EMAIL, [account("unconfirmed")]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+        const entityManager = mockEntityManager({
+            query: [USER_BY_EMAIL, [account("unconfirmed")]],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(entityManager)
         const { subject, mailer } = await build(entityManager)
         await subject.resend("a@example.test")
@@ -155,13 +219,20 @@ describe("IdentityEmailService.resend", () => {
 
 describe("IdentityEmailService.confirm", () => {
     it("spends a live link and stamps the confirmation through the door", async () => {
-        const entityManager = mockEntityManager({ findOne: [IdentityEmailTokenEntity, tokenRow("confirm")], update: [IdentityEmailTokenEntity, {}], query: [CONFIRM_USER, []] })
+        const entityManager = mockEntityManager({
+            findOne: [IdentityEmailTokenEntity, tokenRow("confirm")],
+            update: [IdentityEmailTokenEntity, {}],
+            query: [CONFIRM_USER, []],
+        })
         fakeTransaction(entityManager)
         const { subject } = await build(entityManager)
 
         await subject.confirm("the-token-of-the-link")
 
-        expect(entityManager.findOne).toHaveBeenCalledWith(IdentityEmailTokenEntity, expect.objectContaining({ lock: { mode: "pessimistic_write" } }))
+        expect(entityManager.findOne).toHaveBeenCalledWith(
+            IdentityEmailTokenEntity,
+            expect.objectContaining({ lock: { mode: "pessimistic_write" } }),
+        )
         expect(entityManager.query).toHaveBeenCalledWith(CONFIRM_USER, ["u-1", NOW])
     })
 
@@ -176,12 +247,18 @@ describe("IdentityEmailService.confirm", () => {
 
 describe("IdentityEmailService.forgot", () => {
     it("mails a reset link to a live account and to nobody else, with the same answer", async () => {
-        const entityManager = mockEntityManager({ query: [USER_BY_EMAIL, [account()]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+        const entityManager = mockEntityManager({
+            query: [USER_BY_EMAIL, [account()]],
+            insert: [IdentityEmailTokenEntity, {}],
+            update: [IdentityEmailTokenEntity, {}],
+        })
         fakeTransaction(entityManager)
         const known = await build(entityManager)
         await known.subject.forgot("a@example.test", "vi")
         expect(known.budget.admit).toHaveBeenCalledWith("reset", "a@example.test")
-        expect(known.mailer.send.mock.calls[0]?.[0].message.text).toContain("https://app.example.test/auth/reset?token=")
+        expect(known.mailer.send.mock.calls[0]?.[0].message.text).toContain(
+            "https://app.example.test/auth/reset?token=",
+        )
         await known.subject.forgot("a@example.test")
         expect(known.mailer.send).toHaveBeenCalledTimes(2)
 
@@ -195,7 +272,11 @@ describe("IdentityEmailService.forgot", () => {
 
 describe("IdentityEmailService.reset", () => {
     it("sets the new password and confirms the mailbox its link proved through the door, then ends every session of the person", async () => {
-        const entityManager = mockEntityManager({ findOne: [IdentityEmailTokenEntity, tokenRow("reset")], update: [IdentityEmailTokenEntity, {}], query: [SET_PASSWORD, []] })
+        const entityManager = mockEntityManager({
+            findOne: [IdentityEmailTokenEntity, tokenRow("reset")],
+            update: [IdentityEmailTokenEntity, {}],
+            query: [SET_PASSWORD, []],
+        })
         fakeTransaction(entityManager)
         const { subject, sessions } = await build(entityManager)
 
@@ -219,7 +300,14 @@ describe("IdentityEmailService.reset", () => {
 describe("IdentityEmailService language", () => {
     it("writes the mail in the language the request names, and in the default one when it names none the mails are written in", async () => {
         const subjectFor = async (language?: string): Promise<string | undefined> => {
-            const entityManager = mockEntityManager({ query: [[USER_BY_EMAIL, []], [CREATE_USER, [{ be_auth_create_user: NEW_ID }]]], insert: [IdentityEmailTokenEntity, {}], update: [IdentityEmailTokenEntity, {}] })
+            const entityManager = mockEntityManager({
+                query: [
+                    [USER_BY_EMAIL, []],
+                    [CREATE_USER, [{ be_auth_create_user: NEW_ID }]],
+                ],
+                insert: [IdentityEmailTokenEntity, {}],
+                update: [IdentityEmailTokenEntity, {}],
+            })
             fakeTransaction(entityManager)
             const { subject, mailer } = await build(entityManager)
             await subject.signup("a@example.test", "correct horse", language)

package/templates/be/auth-lite/src/modules/domain/identity/identity-email.service.ts

@@ -51,8 +51,11 @@ export class IdentityEmailService {
         private readonly sessions: IdentitySessionStoreService,
     ) {}
 
-    /** Creates an unconfirmed password account and mails the confirmation link; an address that already has an account is answered the same way. */
-    async signup(email: string, password: string, language?: string): Promise<void> {
+    /**
+     * Creates an unconfirmed password account, its full name (when given) in the profile keys a Google sign-in fills too, and mails the
+     * confirmation link; an address that already has an account is answered the same way and its profile is left as it is.
+     */
+    async signup(email: string, password: string, language?: string, name?: string): Promise<void> {
         const address = normalizeEmail(email)
         await this.admit("signup", address)
         if (!isAcceptablePassword(password)) throw new IdentityError({ code: IdentityErrorCode.PasswordInvalid })
@@ -64,7 +67,14 @@ export class IdentityEmailService {
         const now = this.clock.now()
         const id = this.ids.next()
         const hash = await this.passwords.hash(password)
-        const created = await accountDoors.createUser(this.entityManager, { id, email: address, hash, confirmed: false, meta: "{}", now })
+        const created = await accountDoors.createUser(this.entityManager, {
+            id,
+            email: address,
+            hash,
+            confirmed: false,
+            meta: JSON.stringify(name === undefined ? {} : { full_name: name, name }),
+            now,
+        })
         await this.sendConfirmation(created ?? id, address, language)
     }
 
@@ -82,7 +92,11 @@ export class IdentityEmailService {
         const now = this.clock.now()
         await this.entityManager.transaction(async (scoped) => {
             const row = await this.spendable(scoped, token, CONFIRM, now)
-            await scoped.update(IdentityEmailTokenEntity, { userId: row.userId, purpose: CONFIRM, usedAt: IsNull() }, { usedAt: now })
+            await scoped.update(
+                IdentityEmailTokenEntity,
+                { userId: row.userId, purpose: CONFIRM, usedAt: IsNull() },
+                { usedAt: now },
+            )
             await accountDoors.confirmUser(scoped, row.userId, now)
         })
     }
@@ -95,7 +109,11 @@ export class IdentityEmailService {
         if (user === undefined || user.disabled) return
         const token = await this.mint(user.id, RESET, this.options.resetTtlSeconds)
         const url = `${this.options.webOrigin}/auth/reset?token=${encodeURIComponent(token)}`
-        const mail = resetPasswordMail(this.languageOf(language), { brand: this.options.brandName, url, hours: this.hoursOf(this.options.resetTtlSeconds) })
+        const mail = resetPasswordMail(this.languageOf(language), {
+            brand: this.options.brandName,
+            url,
+            hours: this.hoursOf(this.options.resetTtlSeconds),
+        })
         await this.deliver(address, mail, RESET)
     }
 
@@ -122,7 +140,12 @@ export class IdentityEmailService {
         }
     }
 
-    private async spendable(scoped: EntityManager, token: string, purpose: Purpose, now: Date): Promise<IdentityEmailTokenEntity> {
+    private async spendable(
+        scoped: EntityManager,
+        token: string,
+        purpose: Purpose,
+        now: Date,
+    ): Promise<IdentityEmailTokenEntity> {
         const row = await scoped.findOne(IdentityEmailTokenEntity, {
             where: { tokenHash: digestOf(token), purpose, usedAt: IsNull(), expiresAt: MoreThan(now) },
             lock: { mode: "pessimistic_write" },
@@ -139,7 +162,11 @@ export class IdentityEmailService {
     private async sendConfirmation(userId: string, address: string, language: string | undefined): Promise<void> {
         const token = await this.mint(userId, CONFIRM, this.options.confirmTtlSeconds)
         const url = `${this.options.webOrigin}/auth/confirm?token=${encodeURIComponent(token)}`
-        const mail = confirmEmailMail(this.languageOf(language), { brand: this.options.brandName, url, hours: this.hoursOf(this.options.confirmTtlSeconds) })
+        const mail = confirmEmailMail(this.languageOf(language), {
+            brand: this.options.brandName,
+            url,
+            hours: this.hoursOf(this.options.confirmTtlSeconds),
+        })
         await this.deliver(address, mail, CONFIRM)
     }