@starci/hfs 4.7.23 → 4.7.25

package/templates/fe/auth/supabase-client.ts.tpl

@@ -4,7 +4,11 @@ const sessionOf = (session: Session | null): AuthSession | undefined =>
         : { userId: session.user.id, ...(session.user.email === undefined ? {} : { email: session.user.email }) }
 
 /** A Supabase Auth error as the provider reports it: its HTTP status, its code and its message. */
-type ProviderError = { readonly status?: number; readonly code?: string; readonly message: string }
+type ProviderError = {
+    readonly status: number | undefined
+    readonly code: string | undefined
+    readonly message: string
+}
 
 /** The failure kind of a Supabase Auth error: refused credentials, rejected input, or the provider unavailable. */
 const kindOf = (status: number | undefined): string => {
@@ -20,15 +24,15 @@ const failureOf = (error: ProviderError | null): AuthFailure | undefined =>
 
 /** The Supabase Auth adapter shared by browser and cookie-backed PKCE flows. */
 export const authClient: AuthClient = {
-    session: async () => sessionOf((await supabase().auth.getSession()).data.session),
-    accessToken: async () => (await supabase().auth.getSession()).data.session?.access_token,
-    refreshAccessToken: async () => (await supabase().auth.refreshSession()).data.session?.access_token,
+    session: async () => sessionOf((await authOf().getSession()).data.session),
+    accessToken: async () => (await authOf().getSession()).data.session?.access_token,
+    refreshAccessToken: async () => (await authOf().refreshSession()).data.session?.access_token,
     signInWithPassword: async (email, password) =>
-        failureOf((await supabase().auth.signInWithPassword({ email, password })).error),
-    signOut: async () => failureOf((await supabase().auth.signOut()).error),
+        failureOf((await authOf().signInWithPassword({ email, password })).error),
+    signOut: async () => failureOf((await authOf().signOut()).error),
     // Supabase reports INITIAL_SESSION on subscribe, then every change: the subscription alone keeps the session current.
     onChange: (listener) => {
-        const { data } = supabase().auth.onAuthStateChange((_event, session) => listener(sessionOf(session)))
+        const { data } = authOf().onAuthStateChange((_event, session) => listener(sessionOf(session)))
         return () => data.subscription.unsubscribe()
     },
 }

package/templates/fe/skeleton/apps/__app__/src/components/blocks/SignInForm/component.tsx

@@ -8,7 +8,7 @@ export interface SignInFormBaseProps {
         readonly emailLabel: string
         readonly passwordLabel: string
         readonly submitLabel: string
-        readonly failure?: string
+        readonly failure: string | undefined
     }
     readonly on: { readonly submit: (input: FormData) => void }
 }

package/templates/fe/skeleton/apps/app/src/modules/i18n/index.ts

@@ -1,4 +1,4 @@
 import { createAppI18n } from "@{{project}}/i18n"
 
 /** The product app's i18n: the product's one next-intl stack (the i18n package), with this app's own catalogs under `messages/`. */
-export const appI18n = createAppI18n("app", async (locale) => (await import(`./messages/${locale}.json`)).default)
+export const appI18n = createAppI18n("app", (locale) => import(`./messages/${locale}.json`))

package/templates/fe/skeleton/apps/landing/src/modules/i18n/index.ts

@@ -1,7 +1,4 @@
 import { createAppI18n } from "@{{project}}/i18n"
 
 /** The landing's i18n: the product's one next-intl stack (the i18n package), with this app's own catalogs under `messages/`. */
-export const landingI18n = createAppI18n(
-    "landing",
-    async (locale) => (await import(`./messages/${locale}.json`)).default,
-)
+export const landingI18n = createAppI18n("landing", (locale) => import(`./messages/${locale}.json`))

package/templates/fe/skeleton/packages/__project__-i18n/src/index.ts

@@ -1,5 +1,6 @@
 import "server-only"
 import { hasLocale } from "next-intl"
+import type { AbstractIntlMessages } from "next-intl"
 import { createNavigation } from "next-intl/navigation"
 import { getMessages, getRequestConfig } from "next-intl/server"
 import { notFound } from "next/navigation"
@@ -7,11 +8,25 @@ import { locale as routeLocale } from "next/root-params"
 import { PRODUCT_TIME_ZONE, routing } from "./routing"
 
 /** Loads one app's own catalog for a served locale. */
-type LoadMessages = (locale: string) => Promise<Record<string, unknown>>
+type LoadMessages = (locale: string) => Promise<unknown>
 
 /** The missing message next-intl asks a fallback for. */
 type MissingMessage = { readonly namespace?: string; readonly key: string }
 
+/** The message tree a catalog module exports as its default: the module is read as `unknown` and checked, never trusted as `any`. */
+const isMessages = (value: unknown): value is AbstractIntlMessages => typeof value === "object" && value !== null
+
+const messagesOf = (loaded: unknown): AbstractIntlMessages => {
+    const messages = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : undefined
+    if (!isMessages(messages)) throw new TypeError("A message catalog module must export its messages as default")
+    return messages
+}
+
+/** `next/root-params` is typed only after Next generates its types, so the reader is checked before it is called. */
+const isLocaleReader = (value: unknown): value is () => Promise<unknown> => typeof value === "function"
+
+const readRouteLocale = async (): Promise<unknown> => (isLocaleReader(routeLocale) ? routeLocale() : undefined)
+
 /**
  * The next-intl stack of one app of the product, written once here and called once by each app's `modules/i18n` (R59): the
  * product's one routing with its locale-aware navigation, the request config next-intl's plugin loads (the app's
@@ -27,12 +42,12 @@ export const createAppI18n = (app: string, loadMessages: LoadMessages) => ({
      * missing catalog file is never imported.
      */
     requestConfig: getRequestConfig(async () => {
-        const requested: unknown = await routeLocale()
+        const requested = await readRouteLocale()
         const locale = hasLocale(routing.locales, requested) ? requested : routing.defaultLocale
         return {
             locale,
             timeZone: PRODUCT_TIME_ZONE,
-            messages: await loadMessages(locale),
+            messages: messagesOf(await loadMessages(locale)),
             getMessageFallback: ({ namespace, key }: MissingMessage) => `${app}:${namespace ?? ""}.${key}`,
         }
     }),

package/templates/fe/skeleton-lite/apps/__app__/src/modules/auth/client.ts

@@ -3,16 +3,16 @@ import type { Session, SupabaseClient } from "@supabase/supabase-js"
 import { supabaseAnonKey, supabaseUrl } from "@/modules/config"
 import type { AuthClient, AuthFailure, AuthSession } from "./contracts"
 
-let client: SupabaseClient | undefined
+let authentication: SupabaseClient["auth"] | undefined
 
 /**
  * The one Supabase client of the front end, used for Supabase Auth only (the PKCE flow runs in the browser: a returning
  * redirect's code is exchanged by `detectSessionInUrl`, no route handler). It never calls `.from()`, `.rpc()` or storage:
  * data goes through modules/api to the back end, which verifies the access token.
  */
-const supabase = (): SupabaseClient =>
-    (client ??= createClient(supabaseUrl(), supabaseAnonKey(), {
+const authOf = (): SupabaseClient["auth"] =>
+    (authentication ??= createClient(supabaseUrl(), supabaseAnonKey(), {
         auth: { flowType: "pkce", detectSessionInUrl: true, persistSession: true, autoRefreshToken: true },
-    }))
+    }).auth)
 
 // {{> fe/auth/supabase-client.ts.tpl}}

package/templates/fe/skeleton-lite/apps/web/src/modules/i18n/request.ts

@@ -1,9 +1,19 @@
 import "server-only"
 import { hasLocale } from "next-intl"
+import type { AbstractIntlMessages } from "next-intl"
 import { getRequestConfig } from "next-intl/server"
 import { headers } from "next/headers"
 import { PRODUCT_TIME_ZONE, routing } from "./routing"
 
+/** The message tree a catalog module exports as its default: the module is read as `unknown` and checked, never trusted as `any`. */
+const isMessages = (value: unknown): value is AbstractIntlMessages => typeof value === "object" && value !== null
+
+const messagesOf = (loaded: unknown): AbstractIntlMessages => {
+    const messages = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : undefined
+    if (!isMessages(messages)) throw new TypeError("A message catalog module must export its messages as default")
+    return messages
+}
+
 /** The header the next-intl middleware sets on the request with the locale it negotiated. */
 const LOCALE_HEADER = "x-next-intl-locale"
 
@@ -17,7 +27,7 @@ export default getRequestConfig(async () => {
     return {
         locale,
         timeZone: PRODUCT_TIME_ZONE,
-        messages: (await import(`./messages/${locale}.json`)).default,
+        messages: messagesOf(await import(`./messages/${locale}.json`)),
         getMessageFallback: ({ namespace, key }) => `web:${namespace ?? ""}.${key}`,
     }
 })

package/templates/fe/transport/graphql/clients/clients/auth.ts

@@ -14,7 +14,7 @@ import type { ErrorReporter } from "../links/error"
 
 /** What the authenticated client takes: the abort signal of its operations and where the error link reports (none: it stays silent). */
 export interface CreateAuthApolloClientOptions {
-    readonly signal?: AbortSignal
+    readonly signal: AbortSignal | undefined
     readonly report?: ErrorReporter
 }
 
@@ -23,7 +23,7 @@ export interface CreateAuthApolloClientOptions {
  * retry (transient network failures) -> error (report) -> timeout -> refresh (one token refresh and replay on
  * UNAUTHENTICATED) -> locale (`Accept-Language`) -> access token (`Authorization: Bearer`, from modules/auth) -> http (terminal).
  */
-export const createAuthApolloClient = ({ signal, report }: CreateAuthApolloClientOptions = {}) =>
+export const createAuthApolloClient = ({ signal, report }: CreateAuthApolloClientOptions) =>
     new ApolloClient({
         link: ApolloLink.from([
             createRetryLink(),

package/templates/fe/transport/graphql/clients/clients/no-auth.ts

@@ -11,7 +11,7 @@ import type { ErrorReporter } from "../links/error"
 
 /** What the anonymous client takes: the abort signal of its operations and where the error link reports (none: it stays silent). */
 export interface CreateNoAuthApolloClientOptions {
-    readonly signal?: AbortSignal
+    readonly signal: AbortSignal | undefined
     readonly report?: ErrorReporter
 }
 
@@ -19,7 +19,7 @@ export interface CreateNoAuthApolloClientOptions {
  * The anonymous Apollo client for public operations: retry -> error -> timeout -> locale -> http. It never attaches a
  * token, so a public operation stays public even for a signed-in reader.
  */
-export const createNoAuthApolloClient = ({ signal, report }: CreateNoAuthApolloClientOptions = {}) =>
+export const createNoAuthApolloClient = ({ signal, report }: CreateNoAuthApolloClientOptions) =>
     new ApolloClient({
         link: ApolloLink.from([
             createRetryLink(),

package/templates/fe/transport/graphql/clients/links/attach-access-token.ts

@@ -1,9 +1,10 @@
 import { SetContextLink } from "@apollo/client/link/context"
+import { contextHeaders } from "./context-headers"
 
 /** Attaches `Authorization: Bearer <access token>` from modules/auth when a session exists; an anonymous call goes out without it. */
 export const createAttachAccessTokenLink = (accessToken: () => Promise<string | undefined>) =>
     new SetContextLink(async (context) => {
         const token = await accessToken()
         if (token === undefined) return {}
-        return { headers: { ...context.headers, authorization: `Bearer ${token}` } }
+        return { headers: { ...contextHeaders(context), authorization: `Bearer ${token}` } }
     })

package/templates/fe/transport/graphql/clients/links/context-headers.ts

@@ -0,0 +1,9 @@
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null
+
+/** The string headers an earlier link put on the operation context. Apollo types the context `any`, so they are read as `unknown` and only strings are kept. */
+export const contextHeaders = (context: Readonly<Record<string, unknown>>): Record<string, string> => {
+    const kept: Record<string, string> = {}
+    if (!isRecord(context.headers)) return kept
+    for (const [name, value] of Object.entries(context.headers)) if (typeof value === "string") kept[name] = value
+    return kept
+}

package/templates/fe/transport/graphql/clients/links/http.ts

@@ -4,13 +4,13 @@ import { graphqlUrl } from "@/modules/config"
 /** What the terminal link takes: whether cookies travel and the abort signal of every operation of the client. */
 export interface CreateHttpLinkParams {
     readonly withCredentials?: boolean
-    readonly signal?: AbortSignal
+    readonly signal: AbortSignal | undefined
 }
 
 /** The terminal link: POSTs the operation to the back end's GraphQL endpoint (modules/config). */
-export const createHttpLink = ({ withCredentials = false, signal }: CreateHttpLinkParams = {}) =>
+export const createHttpLink = ({ withCredentials = false, signal }: CreateHttpLinkParams) =>
     new HttpLink({
         uri: graphqlUrl(),
         credentials: withCredentials ? "include" : "same-origin",
-        fetchOptions: { signal },
+        fetchOptions: signal === undefined ? {} : { signal },
     })

package/templates/fe/transport/graphql/clients/links/locale.ts

@@ -1,4 +1,5 @@
 import { SetContextLink } from "@apollo/client/link/context"
+import { contextHeaders } from "./context-headers"
 
 /** The language of the document the reader is on (`<html lang>`, set by the locale layout); undefined outside a browser. */
 const documentLocale = (): string | undefined =>
@@ -9,5 +10,5 @@ export const createAttachLocaleLink = (locale: () => string | undefined = docume
     new SetContextLink((context) => {
         const value = locale()
         if (value === undefined) return {}
-        return { headers: { ...context.headers, "Accept-Language": value } }
+        return { headers: { ...contextHeaders(context), "Accept-Language": value } }
     })

package/templates/fe/transport/graphql/clients/response.ts

@@ -6,7 +6,7 @@ const TRANSPORT_FAILED = "TRANSPORT_FAILED"
 
 /** What an Apollo query or mutation resolves to under the `all` error policy: the data it got and the error it met. */
 export interface ApolloOutcome<TData> {
-    readonly data?: TData | null
+    readonly data: TData | null | undefined
     readonly error?: unknown
 }