@starci/hfs 4.2.13 → 4.2.15

package/templates/fe/skeleton-lite/apps/web/src/modules/db/auth/write-sign-in.ts

@@ -1,25 +0,0 @@
-"use server"
-import "server-only"
-
-import { getPrincipal } from "../principal"
-import { createServerDbClient } from "../server"
-import { dbFailure, dbOk, toOutcome } from "../outcome"
-import type { DbOutcome } from "../outcome"
-import { signInInputSchema } from "../validation/validation.mapper"
-
-/** Result exposed to the client boundary after sign-in. */
-export interface SignInResult {
-    readonly userId: string
-}
-
-/** Schema-checks credentials, signs in through the server client and returns a typed outcome. */
-export const writeSignIn = async (input: FormData): Promise<DbOutcome<SignInResult>> => {
-    const principal = await getPrincipal()
-    if (principal.kind === "ok") return dbOk({ userId: principal.value.id })
-    const parsed = signInInputSchema.safeParse(input)
-    if (!parsed.success) return dbFailure("invalid", "sign-in-input")
-    const client = await createServerDbClient()
-    const signedIn = toOutcome(await client.auth.signInWithPassword(parsed.data))
-    if (signedIn.kind !== "ok") return signedIn
-    return signedIn.value.user === null ? dbFailure("refused", "user") : dbOk({ userId: signedIn.value.user.id })
-}

package/templates/fe/skeleton-lite/apps/web/src/modules/db/auth/write-sign-out.ts

@@ -1,17 +0,0 @@
-"use server"
-import "server-only"
-
-import { getPrincipal } from "../principal"
-import { createServerDbClient } from "../server"
-import { dbFailure, dbOk } from "../outcome"
-import type { DbOutcome } from "../outcome"
-
-/** Ends the cookie-backed Supabase session, including an already-anonymous one. */
-export const writeSignOut = async (): Promise<DbOutcome<true>> => {
-    const principal = await getPrincipal()
-    const client = await createServerDbClient()
-    const result = await client.auth.signOut()
-    if (result.error === null) return dbOk(true)
-    if (principal.kind !== "ok" && result.error.status === 401) return dbOk(true)
-    return dbFailure(result.error.status === 401 ? "refused" : "unavailable", result.error.code ?? "sign-out")
-}

package/templates/fe/skeleton-lite/apps/web/src/modules/db/browser.ts

@@ -1,14 +0,0 @@
-import { createBrowserClient } from "@supabase/ssr"
-import type { SupabaseClient } from "@supabase/supabase-js"
-import type { Database } from "../../../../../../supabase/types/database.types"
-import { supabaseAnonKey, supabaseUrl } from "@/modules/config"
-
-/** Creates the typed public client used only by client-side auth lifecycle hooks. */
-const createBrowserDbClient = (): SupabaseClient<Database> =>
-    createBrowserClient<Database>(supabaseUrl(), supabaseAnonKey())
-
-/** Owns the browser Auth subscription and exposes only its lifecycle to client hooks. */
-export const subscribeToAuthRefresh = (refresh: () => void): (() => void) => {
-    const listener = createBrowserDbClient().auth.onAuthStateChange(refresh)
-    return () => listener.data.subscription.unsubscribe()
-}

package/templates/fe/skeleton-lite/apps/web/src/modules/db/index.ts

@@ -1,3 +0,0 @@
-import "server-only"
-
-export { exchangeAuthCode, readSession, refreshSession } from "./auth/read-session"

package/templates/fe/skeleton-lite/apps/web/src/modules/db/outcome.ts

@@ -1,59 +0,0 @@
-/** Failure kinds exposed by the database boundary. */
-export type DbFailureKind = "refused" | "not-found" | "invalid" | "unavailable"
-
-/** A successful database or Auth operation. */
-export interface DbOk<T> {
-    readonly kind: "ok"
-    readonly value: T
-}
-
-/** An expected database or Auth failure. */
-export interface DbFailure {
-    readonly kind: DbFailureKind
-    readonly code: string
-}
-
-/** The app's one result vocabulary, owned by the lite database transport. */
-export type DbOutcome<T> = DbOk<T> | DbFailure
-
-/** The structural part of a Supabase error this boundary interprets. */
-interface SupabaseFailure {
-    readonly code?: string
-    readonly status?: number
-    readonly message: string
-}
-
-/** The common structural pair returned by Supabase data and Auth calls. */
-export interface SupabaseResult {
-    readonly data: unknown
-    readonly error: SupabaseFailure | null
-}
-
-/** The non-null data carried by one concrete SDK result. */
-export type SupabaseData<T extends SupabaseResult> = NonNullable<T["data"]>
-
-/** Wraps a value as a successful outcome. */
-export const dbOk = <T>(value: T): DbOk<T> => ({ kind: "ok", value })
-/** Builds a refusal without throwing across a Server Action boundary. */
-export const dbFailure = (kind: DbFailureKind, code: string): DbFailure => ({ kind, code })
-
-const hasSignal = (error: SupabaseFailure, signals: ReadonlyArray<string>): boolean => {
-    const values = [error.code, error.status === undefined ? undefined : String(error.status)]
-    return values.some((value) => value !== undefined && signals.includes(value))
-}
-
-const hasData = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined
-
-/** Maps Supabase's data/error pair into the app's closed outcome vocabulary. */
-export const toOutcome = <T extends SupabaseResult>(result: T): DbOutcome<SupabaseData<T>> => {
-    if (result.error === null) {
-        return hasData(result.data) ? dbOk(result.data) : dbFailure("not-found", "empty")
-    }
-    const code = result.error.code ?? String(result.error.status ?? "transport")
-    if (hasSignal(result.error, ["42501", "PGRST301", "401", "403", "invalid_credentials"])) {
-        return dbFailure("refused", code)
-    }
-    if (hasSignal(result.error, ["PGRST116"])) return dbFailure("not-found", code)
-    if (result.error.code?.startsWith("23") === true) return dbFailure("invalid", code)
-    return dbFailure("unavailable", code)
-}

package/templates/fe/skeleton-lite/apps/web/src/modules/db/principal.ts

@@ -1,29 +0,0 @@
-import "server-only"
-
-import { cache } from "react"
-import { createServerDbClient } from "./server"
-import { dbFailure, dbOk, toOutcome } from "./outcome"
-import type { DbOutcome } from "./outcome"
-
-/** The trusted caller claims exposed to server readers and writers. */
-export interface Principal {
-    readonly id: string
-    readonly email?: string
-}
-
-/** Keeps only the claims a consumer may trust after `getClaims()` verified the token. */
-export const principalFromClaims = (claims: Readonly<Record<string, unknown>>): DbOutcome<Principal> => {
-    if (typeof claims.sub !== "string") return dbFailure("refused", "claims")
-    return dbOk({
-        id: claims.sub,
-        ...(typeof claims.email === "string" ? { email: claims.email } : {}),
-    })
-}
-
-/** Verifies and memoizes the current request principal. */
-export const getPrincipal = cache(async (): Promise<DbOutcome<Principal>> => {
-    const client = await createServerDbClient()
-    const claims = toOutcome(await client.auth.getClaims())
-    if (claims.kind !== "ok") return claims
-    return principalFromClaims(claims.value.claims)
-})

package/templates/fe/skeleton-lite/apps/web/src/modules/db/server.ts

@@ -1,70 +0,0 @@
-import "server-only"
-
-import { createServerClient } from "@supabase/ssr"
-import type { SupabaseClient } from "@supabase/supabase-js"
-import { cookies } from "next/headers"
-import type { NextRequest, NextResponse } from "next/server"
-import type { Database } from "../../../../../../supabase/types/database.types"
-import { sessionCookieOptions, supabaseAnonKey, supabaseUrl } from "@/modules/config"
-import { toOutcome } from "./outcome"
-import type { DbOutcome, SupabaseData, SupabaseResult } from "./outcome"
-
-interface OwnedRowIdentity {
-    readonly id: string
-    readonly owner_id: string
-}
-
-type InsertOwnedRow<T extends SupabaseResult> = (
-    client: SupabaseClient<Database>,
-    row: OwnedRowIdentity,
-) => PromiseLike<T>
-
-/** Creates the cookie-backed server client; the public key keeps every database call under RLS. */
-export const createServerDbClient = async (): Promise<SupabaseClient<Database>> => {
-    const store = await cookies()
-    return createServerClient<Database>(supabaseUrl(), supabaseAnonKey(), {
-        cookies: {
-            getAll: () => store.getAll(),
-            setAll: (changes) => {
-                try {
-                    for (const change of changes) {
-                        store.set(change.name, change.value, {
-                            ...change.options,
-                            ...sessionCookieOptions,
-                        })
-                    }
-                } catch (cause) {
-                    if (!(cause instanceof Error) || !cause.message.includes("Cookies can only be modified"))
-                        throw cause
-                }
-            },
-        },
-    })
-}
-
-/** Inserts one validated principal-owned row through the typed server client. */
-export const insertRow = async <T extends SupabaseResult>(
-    id: string,
-    ownerId: string,
-    insert: InsertOwnedRow<T>,
-): Promise<DbOutcome<SupabaseData<T>>> => {
-    const client = await createServerDbClient()
-    return toOutcome(await insert(client, { id, owner_id: ownerId }))
-}
-
-/** Creates the proxy client and writes every refreshed cookie onto the response that will be returned. */
-export const createRequestDbClient = (request: NextRequest, response: NextResponse): SupabaseClient<Database> =>
-    createServerClient<Database>(supabaseUrl(), supabaseAnonKey(), {
-        cookies: {
-            getAll: () => request.cookies.getAll(),
-            setAll: (changes) => {
-                for (const change of changes) {
-                    request.cookies.set(change.name, change.value)
-                    response.cookies.set(change.name, change.value, {
-                        ...change.options,
-                        ...sessionCookieOptions,
-                    })
-                }
-            },
-        },
-    })

package/templates/fe/skeleton-lite/apps/web/src/modules/db/validation/validation.mapper.ts

@@ -1,58 +0,0 @@
-interface OwnedRowInput {
-    readonly id: string
-}
-
-type OwnedRowParse = { readonly success: true; readonly data: OwnedRowInput } | { readonly success: false }
-
-interface SignInInput {
-    readonly email: string
-    readonly password: string
-}
-
-type SignInParse = { readonly success: true; readonly data: SignInInput } | { readonly success: false }
-
-const UUID = /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/u
-const ADDRESS = /^[^\s@]+@([^\s@]+)$/u
-
-/** Whether the text is one local part, one `@` and a domain with a dot that has a character on each side; linear in the length. */
-const isEmail = (value: string): boolean => {
-    const domain = ADDRESS.exec(value)?.[1]
-    if (domain === undefined) return false
-    const dot = domain.indexOf(".", 1)
-    return dot !== -1 && dot < domain.length - 1
-}
-
-/** The bounded UUID schema shared by generated table Server Actions. */
-export const rowSchema = {
-    safeParse: (input: unknown): OwnedRowParse => {
-        if (
-            typeof input !== "object" ||
-            input === null ||
-            !("id" in input) ||
-            typeof input.id !== "string" ||
-            !UUID.test(input.id)
-        ) {
-            return { success: false }
-        }
-        return { success: true, data: { id: input.id } }
-    },
-}
-
-/** Bounds credentials before a sign-in request reaches Supabase Auth. */
-export const signInInputSchema = {
-    safeParse: (input: FormData): SignInParse => {
-        const email = input.get("email")
-        const password = input.get("password")
-        if (
-            typeof email !== "string" ||
-            email.length > 254 ||
-            !isEmail(email) ||
-            typeof password !== "string" ||
-            password.length < 8 ||
-            password.length > 256
-        ) {
-            return { success: false }
-        }
-        return { success: true, data: { email, password } }
-    },
-}

package/templates/fe/skeleton-lite/apps/web/src/modules/routes/safe-next-path.ts

@@ -1,26 +0,0 @@
-const INVALID_PATH_CHARACTER = /[\\\u0000-\u001F\u007F]/u
-
-const isSingleSlashPath = (value: string): boolean => value.startsWith("/") && !value.startsWith("//")
-
-/** Normalizes a same-origin callback destination or falls back to the app root. */
-export const safeNextPath = (candidate: string | null, origin: string): string => {
-    if (candidate === null) return "/"
-    let destination: URL
-    let decoded: string
-    try {
-        destination = new URL(candidate, origin)
-        decoded = decodeURIComponent(candidate)
-    } catch {
-        return "/"
-    }
-    if (
-        destination.origin !== origin ||
-        !isSingleSlashPath(candidate) ||
-        !isSingleSlashPath(decoded) ||
-        INVALID_PATH_CHARACTER.test(candidate) ||
-        INVALID_PATH_CHARACTER.test(decoded)
-    ) {
-        return "/"
-    }
-    return `${destination.pathname}${destination.search}${destination.hash}`
-}

package/templates/fe/table/read.ts.tpl

@@ -1,16 +0,0 @@
-import "server-only"
-
-import { cache } from "react"
-import type { Database } from "../../../../../../../supabase/types/database.types"
-import { createServerDbClient } from "../server"
-import { toOutcome } from "../outcome"
-import type { DbOutcome } from "../outcome"
-
-/** One {{table}} row from the generated database contract. */
-type {{Name}}Row = Database["public"]["Tables"]["{{table}}"]["Row"]
-
-/** Reads a bounded page of {{table}} rows visible to the current RLS principal. */
-export const read{{Name}} = cache(async (): Promise<DbOutcome<ReadonlyArray<{{Name}}Row>>> => {
-    const client = await createServerDbClient()
-    return toOutcome(await client.from("{{table}}").select("*").limit(100))
-})

package/templates/fe/table/write.ts.tpl

@@ -1,16 +0,0 @@
-"use server"
-import "server-only"
-
-import { getPrincipal } from "../principal"
-import { dbFailure } from "../outcome"
-import { insertRow } from "../server"
-import { rowSchema } from "../validation/validation.mapper"
-
-/** Writes one validated {{table}} row for the current principal. */
-export const write{{Name}} = async (input: unknown) => {
-    const principal = await getPrincipal()
-    if (principal.kind !== "ok") return dbFailure("refused", "principal")
-    const parsed = rowSchema.safeParse(input)
-    if (!parsed.success) return dbFailure("invalid", "{{table}}-input")
-    return insertRow(parsed.data.id, principal.value.id, (db, row) => db.from("{{table}}").insert(row).select().single())
-}