@moifort/stack 0.0.0-stage → 0.1.0

package/templates/backend/server/domain/changelog/business-rules.ts

@@ -0,0 +1,60 @@
+import { ChangelogVersion } from '~/domain/changelog/primitives'
+import type { ChangelogEntry } from '~/domain/changelog/types'
+
+const headingPattern = /^##\s+(.+?)\s*$/
+const bulletPattern = /^[-*]\s+(.+?)\s*$/
+// Heading forms: "1.1 (2026.07.15)" (version + date), a bare "2026.07.15" (legacy),
+// or a plain label such as "Unreleased" (no date).
+const versionedPattern = /^(.+?)\s*\((\d{4})\.(\d{2})\.(\d{2})\)$/
+const datedPattern = /^(\d{4})\.(\d{2})\.(\d{2})$/
+
+const toUtcDate = (year: string, month: string, day: string): Date =>
+  new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)))
+
+const parseHeading = (line: string): { version: string; date: Date | null } | null => {
+  const match = headingPattern.exec(line.trim())
+  if (!match) return null
+  const text = match[1].trim()
+  const versioned = versionedPattern.exec(text)
+  if (versioned)
+    return {
+      version: versioned[1].trim(),
+      date: toUtcDate(versioned[2], versioned[3], versioned[4]),
+    }
+  const dated = datedPattern.exec(text)
+  if (dated) return { version: text, date: toUtcDate(dated[1], dated[2], dated[3]) }
+  return { version: text, date: null }
+}
+
+const isHeading = (line: string) => line.trimStart().startsWith('## ')
+
+export const parseChangelog = (markdown: string): ChangelogEntry[] => {
+  const entries: ChangelogEntry[] = []
+  const lines = markdown.split(/\r?\n/)
+
+  let current: ChangelogEntry | null = null
+
+  for (const raw of lines) {
+    const line = raw.trimEnd()
+    if (isHeading(line)) {
+      if (current) entries.push(current)
+      const heading = parseHeading(line)
+      if (!heading) {
+        current = null
+        continue
+      }
+      current = {
+        version: ChangelogVersion(heading.version),
+        date: heading.date,
+        notes: [],
+      }
+      continue
+    }
+    if (!current) continue
+    const bullet = bulletPattern.exec(line)
+    if (bullet) current.notes.push(bullet[1])
+  }
+
+  if (current) entries.push(current)
+  return entries
+}

package/templates/backend/server/domain/changelog/business-rules.unit.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test'
+import { parseChangelog } from '~/domain/changelog/business-rules'
+import { ChangelogVersion } from '~/domain/changelog/primitives'
+
+describe('parseChangelog', () => {
+  test('returns an empty list for an empty document', () => {
+    expect(parseChangelog('')).toEqual([])
+  })
+
+  test('returns an empty list when no version heading exists', () => {
+    expect(parseChangelog('# Changelog\n\nIntro paragraph.\n')).toEqual([])
+  })
+
+  test('parses a versioned heading into a version and a date', () => {
+    const md = ['# Changelog', '', '## 1.1 (2026.04.26)', '- First note', '- Second note', ''].join(
+      '\n',
+    )
+    const result = parseChangelog(md)
+    expect(result).toHaveLength(1)
+    expect(result[0].version).toBe(ChangelogVersion('1.1'))
+    expect(result[0].date?.toISOString()).toBe('2026-04-26T00:00:00.000Z')
+    expect(result[0].notes).toEqual(['First note', 'Second note'])
+  })
+
+  test('parses a legacy bare-date heading (version equals the date)', () => {
+    const md = ['# Changelog', '', '## 2026.04.26', '- Note', ''].join('\n')
+    const result = parseChangelog(md)
+    expect(result).toHaveLength(1)
+    expect(result[0].version).toBe(ChangelogVersion('2026.04.26'))
+    expect(result[0].date?.toISOString()).toBe('2026-04-26T00:00:00.000Z')
+  })
+
+  test('parses an Unreleased section with a null date', () => {
+    const md = '# Changelog\n\n## Unreleased\n- Pending note\n'
+    const result = parseChangelog(md)
+    expect(result).toHaveLength(1)
+    expect(result[0].version).toBe(ChangelogVersion('Unreleased'))
+    expect(result[0].date).toBeNull()
+    expect(result[0].notes).toEqual(['Pending note'])
+  })
+
+  test('preserves the order of versions as written', () => {
+    const md = [
+      '# Changelog',
+      '',
+      '## Unreleased',
+      '- A',
+      '',
+      '## 1.1 (2026.04.26)',
+      '- B',
+      '',
+      '## 1.0 (2026.04.20)',
+      '- C',
+    ].join('\n')
+    const result = parseChangelog(md)
+    expect(result.map((entry) => entry.version)).toEqual([
+      ChangelogVersion('Unreleased'),
+      ChangelogVersion('1.1'),
+      ChangelogVersion('1.0'),
+    ])
+  })
+
+  test('accepts both dash and asterisk bullets', () => {
+    const md = '## 2026.04.26\n- Dash note\n* Asterisk note\n'
+    expect(parseChangelog(md)[0].notes).toEqual(['Dash note', 'Asterisk note'])
+  })
+
+  test('ignores non-bullet lines under a version heading', () => {
+    const md = '## 2026.04.26\nSome paragraph.\n- Real note\nAnother paragraph.\n'
+    expect(parseChangelog(md)[0].notes).toEqual(['Real note'])
+  })
+
+  test('ignores the level-1 title heading', () => {
+    const md = '# Changelog\n\n## 2026.04.26\n- Note\n'
+    expect(parseChangelog(md)).toHaveLength(1)
+  })
+
+  test('rejects malformed dates by rejecting the version itself', () => {
+    expect(() => parseChangelog('## 2026/04/26\n- Note\n')).toThrow()
+  })
+
+  test('handles CRLF line endings', () => {
+    const md = '# Changelog\r\n\r\n## 2026.04.26\r\n- Note\r\n'
+    const result = parseChangelog(md)
+    expect(result).toHaveLength(1)
+    expect(result[0].notes).toEqual(['Note'])
+  })
+})

package/templates/backend/server/domain/changelog/infrastructure/graphql/queries.ts

@@ -0,0 +1,17 @@
+import * as ChangelogQuery from '~/domain/changelog/query'
+import { builder } from '~/domain/shared/graphql/builder'
+import { languageFrom } from '~/domain/shared/language'
+import { ChangelogEntryType } from './types'
+
+builder.queryField('changelog', (t) =>
+  t.field({
+    type: [ChangelogEntryType],
+    description:
+      'Application release notes, one entry per version, most recent first.\n\n' +
+      "Served from the published changelog asset in the caller's language (from `Accept-Language`, " +
+      'English fallback). Global (not user-scoped); the app uses it to show what changed in each ' +
+      'release.',
+    resolve: (_root, _args, { event }) =>
+      ChangelogQuery.list(languageFrom(event && getHeader(event, 'accept-language'))),
+  }),
+)

package/templates/backend/server/domain/changelog/infrastructure/graphql/types.ts

@@ -0,0 +1,23 @@
+import type { ChangelogEntry } from '~/domain/changelog/types'
+import { builder } from '~/domain/shared/graphql/builder'
+
+export const ChangelogEntryType = builder.objectRef<ChangelogEntry>('ChangelogEntry').implement({
+  description:
+    'One version section of the application release notes.\n\n' +
+    'Parsed from the served changelog document: a version heading, its release date, and the ' +
+    'flat list of note lines under it. The app renders it as a row titled by `version` with the ' +
+    'formatted `date` on the right and `notes` as bullet points.',
+  fields: (t) => ({
+    version: t.exposeString('version', {
+      description: 'App Store version this section documents (e.g. "1.3")',
+    }),
+    date: t.expose('date', {
+      type: 'DateTime',
+      nullable: true,
+      description: 'Release date of the version; null for a pending (unreleased) section',
+    }),
+    notes: t.exposeStringList('notes', {
+      description: 'Release note lines for this version, shown as a flat bullet list',
+    }),
+  }),
+})

package/templates/backend/server/domain/changelog/primitives.ts

@@ -0,0 +1,19 @@
+import { make } from 'ts-brand'
+import { z } from 'zod'
+import type { ChangelogVersion as ChangelogVersionType } from '~/domain/changelog/types'
+
+const versionSchema = z
+  .string()
+  .min(1)
+  .refine(
+    (v) =>
+      v === 'Unreleased' ||
+      /^\d+\.\d+(\.\d+)?$/.test(v) || // semantic version, e.g. 1.1
+      /^\d{4}\.\d{2}\.\d{2}$/.test(v), // legacy bare date heading
+    { message: 'Expected Unreleased, a semantic version (1.1), or YYYY.MM.DD' },
+  )
+
+export const ChangelogVersion = (value: unknown) => {
+  const v = versionSchema.parse(value)
+  return make<ChangelogVersionType>()(v)
+}

package/templates/backend/server/domain/changelog/query.ts

@@ -0,0 +1,13 @@
+import { parseChangelog } from '~/domain/changelog/business-rules'
+import type { Language } from '~/domain/shared/language'
+import { changelogMarkdownByLanguage } from '~/system/changelog-content'
+
+/** Served in the caller's language, falling back to English then French for a
+ *  language whose changelog asset is missing. */
+export const list = async (language: Language) =>
+  parseChangelog(
+    changelogMarkdownByLanguage[language] ??
+      changelogMarkdownByLanguage.en ??
+      changelogMarkdownByLanguage.fr ??
+      '',
+  )

package/templates/backend/server/domain/changelog/query.unit.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, mock, test } from 'bun:test'
+
+// A tiny per-language asset stands in for the generated changelog content, so the
+// test asserts the language dispatch, not the real release notes.
+mock.module('~/system/changelog-content', () => ({
+  changelogMarkdownByLanguage: {
+    en: '## 1.0 (2026.01.01)\n- English note',
+    fr: '## 1.0 (2026.01.01)\n- Note française',
+  },
+}))
+
+const ChangelogQuery = await import('~/domain/changelog/query')
+
+describe('ChangelogQuery.list', () => {
+  test('serves the notes in the requested language', async () => {
+    expect((await ChangelogQuery.list('fr'))[0]?.notes).toEqual(['Note française'])
+    expect((await ChangelogQuery.list('en'))[0]?.notes).toEqual(['English note'])
+  })
+})

package/templates/backend/server/domain/changelog/types.ts

@@ -0,0 +1,9 @@
+import type { Brand } from 'ts-brand'
+
+export type ChangelogVersion = Brand<string, 'ChangelogVersion'>
+
+export type ChangelogEntry = {
+  version: ChangelogVersion
+  date: Date | null
+  notes: string[]
+}

package/templates/backend/server/domain/shared/graphql/builder.ts

@@ -0,0 +1,52 @@
+import SchemaBuilder from '@pothos/core'
+import { GraphQLScalarType } from 'graphql'
+import type { H3Event } from 'h3'
+import type {
+  Count,
+  Day,
+  Eur,
+  Month,
+  Percentage,
+  PersonName,
+  UserId,
+  Year,
+} from '~/domain/shared/types'
+
+/** What every resolver is handed. No loader map on purpose: a nested field that
+ *  needs another document is either denormalised on the parent or served by a
+ *  per-request loader added when that field ships. */
+export type GraphQLContext = {
+  event: H3Event
+  userId: UserId
+}
+
+const DateTimeScalar = new GraphQLScalarType({
+  name: 'DateTime',
+  description:
+    'A date and time serialized as an ISO 8601 string in UTC. ' +
+    'Example: "2026-09-14T09:30:00.000Z".',
+  serialize: (value: unknown) => (value instanceof Date ? value.toISOString() : value),
+  parseValue: (value: unknown) => new Date(value as string),
+})
+
+export const builder = new SchemaBuilder<{
+  Context: GraphQLContext
+  DefaultFieldNullability: false
+  Scalars: {
+    DateTime: { Input: Date; Output: Date }
+    UserId: { Input: UserId; Output: UserId }
+    PersonName: { Input: PersonName; Output: PersonName }
+    Count: { Input: Count; Output: Count }
+    Percentage: { Input: Percentage; Output: Percentage }
+    Eur: { Input: Eur; Output: Eur }
+    Year: { Input: Year; Output: Year }
+    Month: { Input: Month; Output: Month }
+    Day: { Input: Day; Output: Day }
+  }
+}>({
+  defaultFieldNullability: false,
+})
+
+builder.addScalarType('DateTime', DateTimeScalar, {})
+builder.queryType({ description: 'Every read of the API. Scoped to the signed-in user.' })
+builder.mutationType({ description: 'Every write of the API. Scoped to the signed-in user.' })

package/templates/backend/server/domain/shared/graphql/errors.ts

@@ -0,0 +1,19 @@
+import { GraphQLError } from 'graphql'
+
+// Throwing helpers for resolvers: the `never` return type lets them sit in
+// match() arms while the success arms keep the resolver's inferred type.
+export const domainError = (code: string, message: string): never => {
+  throw new GraphQLError(message, { extensions: { code } })
+}
+
+export const notFound = (message: string): never => domainError('NOT_FOUND', message)
+
+/** The model cannot be asked: our Gemini credit is spent. Its own code, so the
+ *  app tells the reader to come back later rather than that their book was not
+ *  found. */
+export const aiUnavailable = (): never =>
+  domainError('AI_UNAVAILABLE', 'The AI is unavailable for now; nothing was spent')
+
+export const forbidden = (message: string): never => domainError('FORBIDDEN', message)
+
+export const badUserInput = (message: string): never => domainError('BAD_USER_INPUT', message)

package/templates/backend/server/domain/shared/graphql/scalars.ts

@@ -0,0 +1,51 @@
+import { GraphQLError } from 'graphql'
+import { ZodError } from 'zod'
+import {
+  Count,
+  Day,
+  Eur,
+  Month,
+  Percentage,
+  PersonName,
+  UserId,
+  Year,
+} from '~/domain/shared/primitives'
+import { builder } from './builder'
+
+// A brand's Zod constructor is the single definition of what the value may be, so
+// the scalar reuses it rather than restating the rule. A rejection becomes a
+// BAD_USER_INPUT the client can show, not a 500.
+export const validatedParse =
+  <T>(name: string, parse: (value: unknown) => T) =>
+  (value: unknown): T => {
+    try {
+      return parse(value)
+    } catch (error) {
+      const message =
+        error instanceof ZodError
+          ? error.issues.map(({ message }) => message).join(', ')
+          : `Invalid ${name}`
+      throw new GraphQLError(`Invalid value for ${name}: ${message}`, {
+        extensions: { code: 'BAD_USER_INPUT' },
+      })
+    }
+  }
+
+const scalar = <T>(name: string, description: string, parse: (value: unknown) => T) =>
+  builder.scalarType(
+    name as never,
+    {
+      description,
+      serialize: (value: unknown) => value,
+      parseValue: validatedParse(name, parse),
+    } as never,
+  )
+
+scalar('UserId', 'A Firebase Auth user identifier, an opaque non-empty string.', UserId)
+scalar('PersonName', 'A person the user knows by name, 1 to 200 characters.', PersonName)
+scalar('Count', 'A non-negative whole number of things. Example: 12.', Count)
+scalar('Percentage', 'A percentage from 0 to 100. Example: 42.5.', Percentage)
+scalar('Eur', 'An amount in euros, never negative. Example: 2.99.', Eur)
+scalar('Year', 'A four-digit year. Example: 2026.', Year)
+scalar('Month', 'A calendar month. Example: "2026-10".', Month)
+scalar('Day', 'A calendar day, UTC. Example: "2026-10-04".', Day)

package/templates/backend/server/domain/shared/graphql/schema.ts

@@ -0,0 +1,21 @@
+import { builder } from './builder'
+
+// Custom scalars must be registered before any type that references them.
+import './scalars'
+
+// Domain GraphQL layers, imported as they come online. Each domain owns its
+// enums.ts, types.ts, inputs.ts, queries.ts and mutations.ts under
+// infrastructure/graphql/. Order matters when a domain borrows another's scalar
+// or enum: register the lender first.
+
+// User (profile, onboarding state, account deletion)
+import '~/domain/user/infrastructure/graphql/types'
+import '~/domain/user/infrastructure/graphql/inputs'
+import '~/domain/user/infrastructure/graphql/queries'
+import '~/domain/user/infrastructure/graphql/mutations'
+
+// Changelog (the app's "What's new" list, served from the committed changelogs)
+import '~/domain/changelog/infrastructure/graphql/types'
+import '~/domain/changelog/infrastructure/graphql/queries'
+
+export const schema = builder.toSchema()

package/templates/backend/server/domain/shared/language.ts

@@ -0,0 +1,26 @@
+// The languages the app is localized into. French and English ship at launch; the
+// machinery is sized for more, so adding a market is filling in strings rather
+// than reworking anything. Used to pick the language of whatever the backend
+// renders for the client (AI scan text, the served changelog), driven by the
+// request's `Accept-Language`.
+export const SUPPORTED_LANGUAGES = ['fr', 'en'] as const
+
+export type Language = (typeof SUPPORTED_LANGUAGES)[number]
+
+// Resolve an `Accept-Language` header to a supported language. Reads only the
+// primary subtag of the first listed language (`fr-CH,fr;q=0.9` -> `fr`) and falls
+// back to English for anything unsupported.
+export const languageFrom = (acceptLanguage: string | undefined): Language => {
+  const primary = acceptLanguage?.split(',')[0]?.trim().split('-')[0]?.toLowerCase()
+  return SUPPORTED_LANGUAGES.includes(primary as Language) ? (primary as Language) : 'en'
+}
+
+/** The language of a request, read straight off the event.
+ *
+ *  Reads the header itself rather than through `getHeader`, a Nitro auto-import
+ *  that the schema executed outside a server — the feature tests — does not
+ *  have. An event with no request, which is what those tests pass, answers
+ *  English like a request with no header. */
+export const languageOf = (
+  event: { node?: { req?: { headers?: { 'accept-language'?: string } } } } | undefined,
+): Language => languageFrom(event?.node?.req?.headers?.['accept-language'])

package/templates/backend/server/domain/shared/page.ts

@@ -0,0 +1,25 @@
+/** A page cut from a list already in memory, by the cursor of the row before
+ *  it or, for the builds that still send one, by an offset.
+ *
+ *  The cursor names a row rather than counting rows: a row added or removed
+ *  between two pages shifts an offset, showing a row twice or skipping one,
+ *  while the row named stays where it is. A cursor naming a row no longer
+ *  there restarts from the top, as the library's does. `endCursor` is the
+ *  page's last row, for the next page to start after; null on an empty page. */
+export const pageAfter = <Row>(
+  rows: readonly Row[],
+  page: { limit: number; after?: string; offset?: number },
+  cursorOf: (row: Row) => string,
+): { items: Row[]; hasMore: boolean; endCursor: string | null } => {
+  const start =
+    page.after !== undefined
+      ? rows.findIndex((row) => cursorOf(row) === page.after) + 1
+      : (page.offset ?? 0)
+  const items = rows.slice(start, start + page.limit)
+  const last = items.at(-1)
+  return {
+    items,
+    hasMore: start + page.limit < rows.length,
+    endCursor: last === undefined ? null : cursorOf(last),
+  }
+}

package/templates/backend/server/domain/shared/page.unit.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from 'bun:test'
+import { pageAfter } from './page'
+
+const rows = ['a', 'b', 'c', 'd', 'e']
+const cursorOf = (row: string) => row
+
+describe('pageAfter', () => {
+  test('starts from the top without a cursor', () => {
+    expect(pageAfter(rows, { limit: 2 }, cursorOf)).toEqual({
+      items: ['a', 'b'],
+      hasMore: true,
+      endCursor: 'b',
+    })
+  })
+
+  test('starts after the row the cursor names', () => {
+    expect(pageAfter(rows, { limit: 2, after: 'b' }, cursorOf)).toEqual({
+      items: ['c', 'd'],
+      hasMore: true,
+      endCursor: 'd',
+    })
+  })
+
+  test('says when the last page is reached', () => {
+    expect(pageAfter(rows, { limit: 2, after: 'd' }, cursorOf)).toEqual({
+      items: ['e'],
+      hasMore: false,
+      endCursor: 'e',
+    })
+  })
+
+  test('restarts from the top on a cursor naming a row no longer there', () => {
+    expect(pageAfter(rows, { limit: 2, after: 'gone' }, cursorOf).items).toEqual(['a', 'b'])
+  })
+
+  test('keeps the offset for the builds that still send one', () => {
+    expect(pageAfter(rows, { limit: 2, offset: 3 }, cursorOf).items).toEqual(['d', 'e'])
+  })
+
+  test('the cursor wins over an offset', () => {
+    expect(pageAfter(rows, { limit: 1, after: 'a', offset: 3 }, cursorOf).items).toEqual(['b'])
+  })
+
+  test('an empty page has no cursor', () => {
+    expect(pageAfter([], { limit: 2 }, cursorOf)).toEqual({
+      items: [],
+      hasMore: false,
+      endCursor: null,
+    })
+  })
+})

package/templates/backend/server/domain/shared/primitives.ts

@@ -0,0 +1,50 @@
+import { make } from 'ts-brand'
+import { z } from 'zod'
+import type {
+  Count as CountType,
+  Day as DayType,
+  Eur as EurType,
+  Month as MonthType,
+  Percentage as PercentageType,
+  PersonName as PersonNameType,
+  UserId as UserIdType,
+  Year as YearType,
+} from '~/domain/shared/types'
+
+const number = z.preprocess((v) => (typeof v === 'string' ? Number(v) : v), z.number())
+
+export const UserId = (value: unknown) => make<UserIdType>()(z.string().min(1).parse(value))
+export const PersonName = (value: unknown) =>
+  make<PersonNameType>()(z.string().trim().min(1).max(200).parse(value))
+export const Count = (value: unknown) =>
+  make<CountType>()(number.pipe(z.number().int().nonnegative()).parse(value))
+export const Percentage = (value: unknown) =>
+  make<PercentageType>()(number.pipe(z.number().min(0).max(100)).parse(value))
+export const Eur = (value: unknown) =>
+  make<EurType>()(number.pipe(z.number().nonnegative()).parse(value))
+export const Year = (value: unknown) =>
+  make<YearType>()(
+    number
+      .pipe(
+        z
+          .number()
+          .int()
+          .min(1000)
+          .max(new Date().getUTCFullYear() + 10),
+      )
+      .parse(value),
+  )
+export const Month = (value: unknown) =>
+  make<MonthType>()(
+    z
+      .string()
+      .regex(/^\d{4}-\d{2}$/)
+      .parse(value),
+  )
+export const Day = (value: unknown) =>
+  make<DayType>()(
+    z
+      .string()
+      .regex(/^\d{4}-\d{2}-\d{2}$/)
+      .parse(value),
+  )

package/templates/backend/server/domain/shared/primitives.unit.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from 'bun:test'
+import { Count, Day, PersonName, UserId, Year } from '~/domain/shared/primitives'
+
+describe('shared primitives', () => {
+  test('a user id is any non-empty string', () => {
+    expect(UserId('abc') as string).toBe('abc')
+    expect(() => UserId('')).toThrow()
+  })
+  test('a person name is trimmed and bounded', () => {
+    expect(PersonName('  Ada ') as string).toBe('Ada')
+    expect(() => PersonName('x'.repeat(201))).toThrow()
+  })
+  test('a count accepts a numeric string and refuses a negative', () => {
+    expect(Count('3') as number).toBe(3)
+    expect(() => Count(-1)).toThrow()
+  })
+  test('a year stays within a plausible range', () => {
+    expect(() => Year(999)).toThrow()
+    expect(Year(2026) as number).toBe(2026)
+  })
+  test('a day is a UTC date string', () => {
+    expect(Day('2026-10-04') as string).toBe('2026-10-04')
+    expect(() => Day('04/10/2026')).toThrow()
+  })
+})

package/templates/backend/server/domain/shared/types.ts

@@ -0,0 +1,14 @@
+import type { Brand } from 'ts-brand'
+
+/** A Firebase Auth user id: the owner named on every private document. */
+export type UserId = Brand<string, 'UserId'>
+/** A person the user knows by name: themselves, asked once during onboarding. */
+export type PersonName = Brand<string, 'PersonName'>
+export type Count = Brand<number, 'Count'>
+export type Percentage = Brand<number, 'Percentage'>
+export type Eur = Brand<number, 'Eur'>
+export type Year = Brand<number, 'Year'>
+/** A calendar month, `"2026-10"`. */
+export type Month = Brand<string, 'Month'>
+/** A calendar day in UTC, `"2026-10-04"`. */
+export type Day = Brand<string, 'Day'>

package/templates/backend/server/domain/user/command.ts

@@ -0,0 +1,16 @@
+import type { PersonName, UserId } from '~/domain/shared/types'
+import * as repository from '~/domain/user/infrastructure/repository'
+
+/** Persist the profile that marks onboarding done. Reachable again afterwards, so
+ *  a user can change the name they are addressed by. */
+export const completeOnboarding = (userId: UserId, firstName: PersonName) =>
+  repository.saveProfile({ userId, firstName, onboardingCompletedAt: new Date() })
+
+export const deleteProfile = async (userId: UserId) => {
+  await repository.removeProfile(userId)
+}
+
+/** The last step of an account deletion, after every trace of its data is gone. */
+export const deleteAuthAccount = async (userId: UserId) => {
+  await repository.removeAuthUser(userId)
+}

package/templates/backend/server/domain/user/infrastructure/graphql/inputs.ts

@@ -0,0 +1,12 @@
+import { builder } from '~/domain/shared/graphql/builder'
+
+export const CompleteOnboardingInput = builder.inputType('CompleteOnboardingInput', {
+  description: 'What the onboarding collects: a first name, so the app can address the user.',
+  fields: (t) => ({
+    firstName: t.field({
+      type: 'PersonName',
+      required: true,
+      description: "The user's first name.",
+    }),
+  }),
+})