What is Anzen?

'use server'

import { object, string, datelike } from 'decoders'
import { createSafeServerAction } from '@sugardarius/anzen'

import { auth } from '~/lib/auth'
import { db } from '~/lib/db'

// Factory wires validation, auth, and handler with a stable result shape
export const createThread = createSafeServerAction(
  {
    id: 'create-thread-action',
    // One Standard Schema object — input is inferred + validated together
    input: object({
      spaceId: string,
      createdAt: datelike,
      comment: object({
        createdAt: datelike,
        content: string,
      }),
    }),
    // Authorization separated from the business handler
    authorize: async ({ input }) => {
      const session = await auth()
      if (!session.user) {
        throw new Error('user is not authenticated')
      }
      if (!session.access.includes(input.spaceId)) {
        throw new Error('user has not access')
      }
      return { user: session.user }
    },
  },
  // Typed `input` + `auth`; callers get `{ success, output | error }`
  async ({ auth, input, id }) => {
    const inserted = await db.createThread({
      thread: { ...input, authorId: auth.user.id },
    })
    return { inserted, actionId: id }
  }
)

import { createSafeRouteHandler } from '@sugardarius/anzen'
import { auth } from '~/lib/auth'

// Route is a factory — shared behavior (e.g. auth) lives in one place
export const POST = createSafeRouteHandler(
  {
    // Same 401 logic, but declared as a reusable authorize step
    authorize: async ({ req }) => {
      const session = await auth.getSession(req)
      if (!session) {
        return new Response(null, { status: 401 })
      }
      return { user: session.user }
    },
  },
  // `auth` is injected; handler focuses on the response
  async ({ auth, body }, req): Promise<Response> => {
    return Response.json({ user: auth.user, body }, { status: 200 })
  }
)

import { unauthorized } from 'next/navigation'
import { string } from 'decoders'
import { createSafePageServerComponent } from '@sugardarius/anzen/server-components'

import { auth } from '~/lib/auth'
import { getAccount } from '~/lib/db'

import { AccountSummary } from '~/components/account-summary'

// Segments + authorize + page body composed by the factory
export default createSafePageServerComponent(
  {
    authorize: async ({ segments }) => {
      const session = await auth.getSession()
      if (!session) {
        unauthorized()
      }

      return { user: session.user }
    },
    // Route params validated as one Standard Schema dictionary
    segments: {
      accountId: string,
    },
  },
  async ({ auth, segments }) => {
    const account = await getAccount({ id: segments.accountId })
    return <AccountSummary user={auth.user} account={account} />
  }
)

import { unauthorized } from 'next/navigation'
import { string } from 'decoders'
import { createSafeLayoutServerComponent } from '@sugardarius/anzen/server-components'

import { auth } from '~/lib/auth'
import { getAccount } from '~/lib/db'

import { AccountHeader } from '~/components/account-header'

export default createSafeLayoutServerComponent(
  {
    authorize: async ({ segments }) => {
      const session = await auth.getSession()
      if (!session) {
        unauthorized()
      }

      return { user: session.user }
    },
    segments: {
      accountId: string,
    },
  },
  async ({ auth, segments, children }) => {
    const account = await getAccount({ id: segments.accountId })
    return (
      <div>
        <AccountHeader user={auth.user} accountId={segments.accountId} />
        {children}
      </div>
    )
  }
)