ras-stack 2.0.1 → 3.0.0

package/dist/create/template/src/routes/api/uploads.$id.ts

@@ -1,40 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { requireTanStackMutationOrigin } from 'ras-stack/tanstack/server'
-import { app } from '../../server/app'
-import { limitAuthenticatedRequest } from '../../server/rate-limit'
-import { requireCurrentUser } from '../../server/session'
-
-export const Route = createFileRoute('/api/uploads/$id')({
-  server: {
-    handlers: {
-      HEAD: async ({ request, params }) => {
-        const user = await requireCurrentUser(request)
-        const upload = app().uploadStore.getOwned(params.id, user.id)
-        return upload ? new Response(null, { headers: headers(upload.offset, upload.length) }) : new Response(null, { status: 404 })
-      },
-      PATCH: async ({ request, params }) => {
-        requireTanStackMutationOrigin(
-          { configured: [app().environment.appUrl], trustForwardedHeaders: app().environment.trustProxy },
-          request,
-        )
-        const user = await requireCurrentUser(request)
-        await limitAuthenticatedRequest(request, 'upload-chunk', user.id, { window: 60, max: 120 })
-        const declaredLength = Number(request.headers.get('content-length'))
-        if (!Number.isSafeInteger(declaredLength) || declaredLength < 1 || declaredLength > app().environment.uploadMaxBytes) {
-          return new Response('Invalid content length', { status: 400 })
-        }
-        const chunk = new Uint8Array(await request.arrayBuffer())
-        if (chunk.length !== declaredLength) return new Response('Content length mismatch', { status: 400 })
-        const upload = await app().uploadStore.append(params.id, user.id, Number(request.headers.get('upload-offset')), chunk)
-        return new Response(null, { status: 204, headers: headers(upload.offset, upload.length) })
-      },
-    },
-  },
-})
-
-const headers = (offset: number, length: number) => ({
-  'Cache-Control': 'no-store',
-  'Tus-Resumable': '1.0.0',
-  'Upload-Length': String(length),
-  'Upload-Offset': String(offset),
-})

package/dist/create/template/src/routes/api/uploads.ts

@@ -1,25 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { requireTanStackMutationOrigin } from 'ras-stack/tanstack/server'
-import { app } from '../../server/app'
-import { limitAuthenticatedRequest } from '../../server/rate-limit'
-import { requireCurrentUser } from '../../server/session'
-
-export const Route = createFileRoute('/api/uploads')({
-  server: {
-    handlers: {
-      POST: async ({ request }) => {
-        requireTanStackMutationOrigin(
-          { configured: [app().environment.appUrl], trustForwardedHeaders: app().environment.trustProxy },
-          request,
-        )
-        const user = await requireCurrentUser(request)
-        await limitAuthenticatedRequest(request, 'upload-create', user.id, { window: 60, max: 10 })
-        const id = app().uploadStore.create(user.id, Number(request.headers.get('upload-length')), request.headers.get('upload-metadata'))
-        return new Response(null, {
-          status: 201,
-          headers: { Location: `/api/uploads/${id}`, 'Tus-Resumable': '1.0.0', 'Cache-Control': 'no-store' },
-        })
-      },
-    },
-  },
-})

package/dist/create/template/src/routes/index.tsx

@@ -1,189 +0,0 @@
-import { useMutation, useQueryClient, useSuspenseQuery } from '@tanstack/react-query'
-import { createFileRoute } from '@tanstack/react-router'
-import { useAuthAction } from 'ras-stack/auth/react'
-import { useEffect, useState } from 'react'
-import { authClient } from '../client/auth'
-import { snapshotQuery } from '../client/queries'
-import { queryErrorMessage } from '../client/queryClient'
-import { useRealtime } from '../client/useRealtime'
-import { addMessage } from '../server/fns'
-
-export const Route = createFileRoute('/')({
-  loader: ({ context }) => context.queryClient.ensureQueryData(snapshotQuery()),
-  component: Home,
-})
-
-function Home() {
-  const { data } = useSuspenseQuery(snapshotQuery())
-  const queryClient = useQueryClient()
-  useRealtime(Boolean(data.user) && data.realtimeEnabled)
-  return (
-    <main>
-      <h1>ras-stack full-stack example</h1>
-      <p className="status">Better Auth, Drizzle migrations, durable uploads, transactional realtime, SMTP, and production lifecycle</p>
-      {data.user ? (
-        <Messages
-          name={data.user.name}
-          signOut={async () => {
-            await authClient.signOut()
-            await queryClient.invalidateQueries()
-          }}
-        />
-      ) : (
-        <Authentication emailConfigured={data.emailConfigured} />
-      )}
-      <MessageList />
-    </main>
-  )
-}
-
-function Authentication({ emailConfigured }: { emailConfigured: boolean }) {
-  const [hydrated, setHydrated] = useState(false)
-  const [mode, setMode] = useState<'sign-up' | 'sign-in'>('sign-up')
-  const [notice, setNotice] = useState('')
-  const queryClient = useQueryClient()
-  const action = useAuthAction()
-  useEffect(() => setHydrated(true), [])
-  return (
-    <form
-      onSubmit={async (event) => {
-        event.preventDefault()
-        setNotice('')
-        const form = new FormData(event.currentTarget)
-        const name = formText(form, 'name')
-        const email = formText(form, 'email')
-        const password = formText(form, 'password')
-        const result = await action.run(async () => {
-          const response =
-            mode === 'sign-up'
-              ? await authClient.signUp.email({ name, email, password })
-              : await authClient.signIn.email({ email, password })
-          return response.error ? { error: { message: response.error.message } } : { data: response.data }
-        })
-        if (!result.error) {
-          if (mode === 'sign-up' && emailConfigured) setNotice('Check your email to verify your account.')
-          await queryClient.invalidateQueries()
-        }
-      }}
-    >
-      <h2>{mode === 'sign-up' ? 'Create account' : 'Sign in'}</h2>
-      {mode === 'sign-up' && (
-        <label>
-          Name
-          <input aria-label="Name" autoComplete="name" name="name" />
-        </label>
-      )}
-      <label>
-        Email
-        <input aria-label="Email" autoComplete="email" name="email" type="email" />
-      </label>
-      <label>
-        Password
-        <input
-          aria-label="Password"
-          autoComplete={mode === 'sign-up' ? 'new-password' : 'current-password'}
-          name="password"
-          type="password"
-        />
-      </label>
-      <button disabled={!hydrated || action.busy}>{mode === 'sign-up' ? 'Create account' : 'Sign in'}</button>
-      <button type="button" onClick={() => setMode(mode === 'sign-up' ? 'sign-in' : 'sign-up')}>
-        {mode === 'sign-up' ? 'Use an existing account' : 'Create a new account'}
-      </button>
-      {emailConfigured && (
-        <button
-          type="button"
-          onClick={async (event) => {
-            const form = event.currentTarget.form
-            if (!form) return
-            const email = formText(new FormData(form), 'email')
-            await authClient.requestPasswordReset({ email, redirectTo: '/' })
-            setNotice('If that account exists, a reset link has been sent.')
-          }}
-        >
-          Reset password
-        </button>
-      )}
-      {notice && <p className="status">{notice}</p>}
-      {action.error && <p className="error">{action.error}</p>}
-    </form>
-  )
-}
-
-function formText(form: FormData, name: string) {
-  const value = form.get(name)
-  return typeof value === 'string' ? value : ''
-}
-
-function Messages({ name, signOut }: { name: string; signOut: () => Promise<void> }) {
-  const [body, setBody] = useState('')
-  const queryClient = useQueryClient()
-  const mutation = useMutation({
-    mutationFn: () => addMessage({ data: { body } }),
-    onSuccess: async () => {
-      setBody('')
-      await queryClient.invalidateQueries({ queryKey: snapshotQuery().queryKey })
-    },
-  })
-  return (
-    <section>
-      <h2>Hello, {name}</h2>
-      <button onClick={() => void signOut()}>Sign out</button>
-      <form
-        onSubmit={(event) => {
-          event.preventDefault()
-          mutation.mutate()
-        }}
-      >
-        <label>
-          Message
-          <input aria-label="Message" value={body} onChange={(event) => setBody(event.target.value)} />
-        </label>
-        <button disabled={mutation.isPending}>Add message</button>
-        {mutation.error && <p className="error">{queryErrorMessage(mutation.error)}</p>}
-      </form>
-      <Upload />
-    </section>
-  )
-}
-
-function Upload() {
-  const [status, setStatus] = useState('No upload yet.')
-  return (
-    <label>
-      Upload a text file
-      <input
-        aria-label="Upload"
-        type="file"
-        accept="text/plain"
-        onChange={async (event) => {
-          const file = event.target.files?.[0]
-          if (!file) return
-          const { uploadWithTus } = await import('ras-stack/uploads')
-          const result = await uploadWithTus(
-            { endpoint: '/api/uploads', file, metadata: { filename: file.name, filetype: file.type } },
-            false,
-          )
-          setStatus(`Uploaded to ${result.uploadUrl}`)
-        }}
-      />
-      <span className="status">{status}</span>
-    </label>
-  )
-}
-
-function MessageList() {
-  const { data } = useSuspenseQuery(snapshotQuery())
-  return (
-    <section>
-      <h2>Messages</h2>
-      <ul>
-        {data.messages.map((message) => (
-          <li key={message.id}>
-            <strong>{message.author}:</strong> {message.body}
-          </li>
-        ))}
-      </ul>
-    </section>
-  )
-}

package/dist/create/template/src/server/app.test.ts

@@ -1,24 +0,0 @@
-import { expect, it, vi } from 'vitest'
-import { app, closeApp } from './app'
-
-it('closes every resource once and reports aggregate shutdown failure', async () => {
-  const failure = new Error('outbox failed')
-  const uploadClose = vi.fn().mockResolvedValue(undefined)
-  const publisherClose = vi.fn().mockResolvedValue(undefined)
-  const telemetryShutdown = vi.fn().mockResolvedValue(undefined)
-  const databaseClose = vi.fn()
-  const resources = {
-    outbox: { close: vi.fn().mockRejectedValue(failure) },
-    uploadStore: { close: uploadClose },
-    publisher: { close: publisherClose },
-    telemetry: { shutdown: telemetryShutdown },
-    database: { $client: { close: databaseClose } },
-  } as unknown as ReturnType<typeof app>
-  const closing = closeApp(resources)
-  expect(closeApp(resources)).toBe(closing)
-  await expect(closing).rejects.toMatchObject({ errors: [failure] })
-  expect(uploadClose).toHaveBeenCalledOnce()
-  expect(publisherClose).toHaveBeenCalledOnce()
-  expect(telemetryShutdown).toHaveBeenCalledOnce()
-  expect(databaseClose).toHaveBeenCalledOnce()
-})

package/dist/create/template/src/server/app.ts

@@ -1,172 +0,0 @@
-import { existsSync, mkdirSync } from 'node:fs'
-import path from 'node:path'
-import { persistedSecret, standardRateLimitOptions, standardSessionOptions } from 'ras-stack/auth'
-import { openDrizzleSqlite, openSqliteClient, type OpenDrizzleSqliteOptions } from 'ras-stack/database/sqlite'
-import { createSmtpDelivery, smtpConfigFromEnvironment } from 'ras-stack/email'
-import { postHogEnvironment } from 'ras-stack/posthog'
-import { createManagedPostHogServerTelemetry } from 'ras-stack/posthog/server'
-import { CentrifugoPublisher } from 'ras-stack/realtime'
-import { globalSingleton } from 'ras-stack/server'
-import { createAuth } from './auth'
-import { loadEnvironment } from './environment'
-import { OutboxWorker } from './outbox'
-import * as schema from './schema'
-import { UploadStore } from './uploads'
-
-export function app() {
-  return globalSingleton('ras-stack.example.full-stack', createApp)
-}
-
-function createApp() {
-  const environment = loadEnvironment()
-  mkdirSync(environment.dataDirectory, { recursive: true })
-  const databaseFile = path.join(environment.dataDirectory, 'example.sqlite')
-  prepareLegacyMessages(databaseFile)
-  const options: OpenDrizzleSqliteOptions<typeof schema> = {
-    file: databaseFile,
-    schema,
-    migrationsFolder: migrationsDirectory(),
-  }
-  const database = openDrizzleSqlite(options)
-  importLegacyMessages(database.$client)
-  const smtp = smtpConfigFromEnvironment()
-  const email = smtp ? createSmtpDelivery(smtp) : undefined
-  let publishFailure: unknown
-  const publisher = new CentrifugoPublisher({
-    apiUrl: environment.centrifugoApiUrl,
-    apiKey: environment.centrifugoApiKey,
-    maxConcurrentChannels: 1,
-    maxPendingChannels: 32,
-    onError: (error, channel) => {
-      publishFailure = error
-      console.error({ event: 'example_realtime_publish_failed', channel, error })
-    },
-  })
-  const telemetry = createManagedPostHogServerTelemetry({
-    environment: postHogEnvironment({
-      projectToken: process.env.VITE_POSTHOG_PROJECT_TOKEN,
-      host: process.env.VITE_POSTHOG_HOST,
-    }),
-    serviceName: 'ras-stack-example',
-    deploymentEnvironment: process.env.NODE_ENV,
-    onError: (error) => console.error({ event: 'example_telemetry_failed', error }),
-  })
-  const auth = createAuth({
-    database,
-    email,
-    environment,
-    secret: process.env.BETTER_AUTH_SECRET ?? persistedSecret({ directory: environment.dataDirectory, filename: 'auth.secret' }),
-  })
-  const outbox = new OutboxWorker({
-    database,
-    enabled: environment.realtimeEnabled,
-    onError: (error) => console.error({ event: 'example_outbox_drain_failed', error }),
-    publish: async (channel, payload) => {
-      publishFailure = undefined
-      if (!publisher.publish(channel, payload)) throw new Error('Realtime publisher rejected the outbox item')
-      await publisher.idle()
-      if (publishFailure) throw publishFailure
-    },
-  })
-  const uploadStore = new UploadStore({
-    database,
-    directory: path.join(environment.dataDirectory, 'uploads'),
-    globalMaxFiles: environment.uploadGlobalMaxFiles,
-    globalQuotaBytes: environment.uploadGlobalQuotaBytes,
-    maxBytes: environment.uploadMaxBytes,
-    onError: (error) => console.error({ event: 'example_upload_cleanup_failed', error }),
-    quotaBytes: environment.uploadQuotaBytes,
-  })
-  void telemetry.start()
-  outbox.start()
-  uploadStore.startCleanup()
-  const application = { auth, database, email, environment, outbox, publisher, telemetry, uploadStore }
-  if (!process.env.VITEST) installShutdown(application)
-  return application
-}
-
-function prepareLegacyMessages(file: string) {
-  const client = openSqliteClient(file)
-  try {
-    if (!tableExists(client, 'messages')) return
-    const columns = client.pragma('table_info(messages)') as Array<{ name: string }>
-    if (columns.some((column) => column.name === 'author_id')) return
-    if (tableExists(client, 'messages_legacy')) throw new Error('Both messages and messages_legacy exist; refusing ambiguous migration')
-    client.exec('ALTER TABLE messages RENAME TO messages_legacy')
-  } finally {
-    client.close()
-  }
-}
-
-function importLegacyMessages(client: ReturnType<typeof openSqliteClient>) {
-  if (!tableExists(client, 'messages_legacy')) return
-  client.transaction(() => {
-    const now = Date.now()
-    client
-      .prepare('INSERT OR IGNORE INTO user (id, name, email, email_verified, created_at, updated_at) VALUES (?, ?, ?, false, ?, ?)')
-      .run('legacy-import', 'Legacy import', 'legacy-import@invalid.example', now, now)
-    client.exec(`INSERT INTO messages (id, author_id, author, body, created_at)
-      SELECT id, 'legacy-import', author, body, created_at FROM messages_legacy;
-      DROP TABLE messages_legacy;`)
-  })()
-}
-
-function tableExists(client: ReturnType<typeof openSqliteClient>, name: string) {
-  return Boolean(client.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name))
-}
-
-function migrationsDirectory() {
-  const directories = [
-    path.resolve(import.meta.dirname, 'drizzle'),
-    path.resolve(import.meta.dirname, '..', 'drizzle'),
-    path.resolve(process.cwd(), 'drizzle'),
-  ]
-  const directory = directories.find((candidate) => existsSync(path.join(candidate, 'meta', '_journal.json')))
-  if (!directory) throw new Error(`Drizzle migrations are missing from ${directories.join(', ')}`)
-  return directory
-}
-
-const closing = new WeakMap<object, Promise<void>>()
-
-export function closeApp(value = app()) {
-  const existing = closing.get(value)
-  if (existing) return existing
-  const promise = (async () => {
-    const failures: unknown[] = []
-    try {
-      await value.outbox.close()
-    } catch (error) {
-      failures.push(error)
-    }
-    for (const result of await Promise.allSettled([value.uploadStore.close(), value.publisher.close(), value.telemetry.shutdown()])) {
-      if (result.status === 'rejected') failures.push(result.reason)
-    }
-    try {
-      value.database.$client.close()
-    } catch (error) {
-      failures.push(error)
-    }
-    if (failures.length) throw new AggregateError(failures, 'Failed to close the full-stack example cleanly')
-  })()
-  closing.set(value, promise)
-  return promise
-}
-
-export { standardRateLimitOptions, standardSessionOptions }
-
-function installShutdown(application: ReturnType<typeof createApp>) {
-  let started = false
-  for (const signal of ['SIGINT', 'SIGTERM'] as const) {
-    process.once(signal, () => {
-      if (started) return
-      started = true
-      void closeApp(application).then(
-        () => process.exit(0),
-        (error) => {
-          console.error({ event: 'example_shutdown_failed', error })
-          process.exit(1)
-        },
-      )
-    })
-  }
-}

package/dist/create/template/src/server/auth-flow.test.ts

@@ -1,150 +0,0 @@
-import { createServer, type Server, type Socket } from 'node:net'
-import { mkdtemp, rm } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { clearGlobalSingleton } from 'ras-stack/server'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { app, closeApp } from './app'
-import { currentUser } from './session'
-
-let directory: string
-let smtp: TestSmtp | undefined
-
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-auth-flow-'))
-  process.env.DATA_DIR = directory
-})
-
-afterEach(async () => {
-  await clearGlobalSingleton('ras-stack.example.full-stack', closeApp)
-  await smtp?.close()
-  smtp = undefined
-  await rm(directory, { recursive: true, force: true })
-  for (const name of ['APP_URL', 'SMTP_HOST', 'SMTP_PORT', 'EMAIL_FROM', 'EMAIL_REQUIRE_VERIFICATION']) delete process.env[name]
-})
-
-describe('production auth flows', () => {
-  it('verifies an email over SMTP and completes a password reset', async () => {
-    smtp = await TestSmtp.start()
-    process.env.APP_URL = 'http://localhost:3100'
-    process.env.SMTP_HOST = '127.0.0.1'
-    process.env.SMTP_PORT = String(smtp.port)
-    process.env.EMAIL_FROM = 'auth@example.test'
-    process.env.EMAIL_REQUIRE_VERIFICATION = 'true'
-
-    expect(
-      (
-        await authRequest('/sign-up/email', {
-          name: 'Ada',
-          email: 'ada@example.test',
-          password: 'correct horse battery staple',
-        })
-      ).status,
-    ).toBe(200)
-    expect((await authRequest('/sign-in/email', { email: 'ada@example.test', password: 'correct horse battery staple' })).status).toBe(403)
-
-    const verification = await app().auth.handler(new Request(messageUrl(smtp.messages[0]!)))
-    const cookie = verification.headers.get('set-cookie')
-    expect(cookie).toContain('ras_stack_example.session_token=')
-    expect((await currentUser(new Request('http://localhost:3100', { headers: { cookie: cookie! } })))?.email).toBe('ada@example.test')
-
-    expect((await authRequest('/request-password-reset', { email: 'ada@example.test', redirectTo: '/' })).status).toBe(200)
-    const resetLink = new URL(messageUrl(smtp.messages[1]!))
-    const token = resetLink.pathname.split('/').at(-1)
-    expect((await authRequest('/reset-password', { newPassword: 'new correct horse battery staple', token })).status).toBe(200)
-    expect(await currentUser(new Request('http://localhost:3100', { headers: { cookie: cookie! } }))).toBeUndefined()
-    expect((await authRequest('/reset-password', { newPassword: 'replayed password', token })).status).toBe(400)
-    expect((await authRequest('/sign-in/email', { email: 'ada@example.test', password: 'correct horse battery staple' })).status).toBe(401)
-    expect((await authRequest('/sign-in/email', { email: 'ada@example.test', password: 'new correct horse battery staple' })).status).toBe(
-      200,
-    )
-  })
-
-  it('marks session cookies Secure for an HTTPS origin', async () => {
-    process.env.APP_URL = 'https://example.test'
-    const response = await authRequest('/sign-up/email', {
-      name: 'Grace',
-      email: 'grace@example.test',
-      password: 'correct horse battery staple',
-    })
-    expect(response.headers.get('set-cookie')).toContain('; Secure')
-  })
-})
-
-function authRequest(endpoint: string, body: object) {
-  const origin = process.env.APP_URL!
-  return app().auth.handler(
-    new Request(`${origin}/api/auth${endpoint}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Origin: origin },
-      body: JSON.stringify(body),
-    }),
-  )
-}
-
-function messageUrl(message: string) {
-  const decoded = message
-    .replace(/=\r?\n/g, '')
-    .replace(/=([\dA-F]{2})/gi, (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)))
-  const match = decoded.match(/https?:\/\/[^\s]+/)
-  if (!match) throw new Error(`SMTP message contains no URL: ${decoded}`)
-  return match[0]
-}
-
-class TestSmtp {
-  private constructor(
-    private readonly server: Server,
-    readonly port: number,
-    readonly messages: string[],
-  ) {}
-
-  static async start() {
-    const messages: string[] = []
-    const server = createServer((socket) => acceptSmtp(socket, messages))
-    await new Promise<void>((resolve, reject) => server.listen(0, '127.0.0.1', resolve).once('error', reject))
-    const address = server.address()
-    if (!address || typeof address === 'string') throw new Error('SMTP sink did not bind a TCP port')
-    return new TestSmtp(server, address.port, messages)
-  }
-
-  close() {
-    return new Promise<void>((resolve, reject) => this.server.close((error) => (error ? reject(error) : resolve())))
-  }
-}
-
-function acceptSmtp(socket: Socket, messages: string[]) {
-  socket.setEncoding('utf8')
-  socket.write('220 localhost ESMTP\r\n')
-  let buffer = ''
-  let data = false
-  let message = ''
-  socket.on('data', (chunk: string) => {
-    buffer += chunk
-    while (buffer.includes('\n')) {
-      const index = buffer.indexOf('\n')
-      const line = buffer.slice(0, index).replace(/\r$/, '')
-      buffer = buffer.slice(index + 1)
-      if (data) {
-        if (line === '.') {
-          messages.push(message)
-          message = ''
-          data = false
-          socket.write('250 queued\r\n')
-        } else {
-          message += `${line.startsWith('..') ? line.slice(1) : line}\r\n`
-        }
-      } else if (/^(EHLO|HELO)/i.test(line)) {
-        socket.write('250-localhost\r\n250 PIPELINING\r\n')
-      } else if (/^(MAIL FROM|RCPT TO|RSET|NOOP)/i.test(line)) {
-        socket.write('250 ok\r\n')
-      } else if (/^DATA/i.test(line)) {
-        data = true
-        socket.write('354 end with .\r\n')
-      } else if (/^QUIT/i.test(line)) {
-        socket.end('221 bye\r\n')
-      } else {
-        socket.write('502 unsupported\r\n')
-      }
-    }
-  })
-}

package/dist/create/template/src/server/auth.ts

@@ -1,56 +0,0 @@
-import { drizzleAdapter } from '@better-auth/drizzle-adapter'
-import { betterAuth } from 'better-auth'
-import { tanstackStartCookies } from 'better-auth/tanstack-start'
-import { standardAccountOptions, standardEmailAndPasswordOptions, standardRateLimitOptions, standardSessionOptions } from 'ras-stack/auth'
-import { createAuthEmailHandler, type EmailDelivery } from 'ras-stack/email'
-import type { AppEnvironment } from './environment'
-import * as schema from './schema'
-
-type Database = Parameters<typeof drizzleAdapter>[0]
-
-export function createAuth(options: { database: Database; email?: EmailDelivery; environment: AppEnvironment; secret: string }) {
-  const email = options.email
-  const sendVerificationEmail = email
-    ? createAuthEmailHandler(email, ({ user, url }) => ({
-        to: user.email,
-        subject: 'Verify your ras-stack example account',
-        text: `Verify your email: ${url}`,
-      }))
-    : undefined
-  const sendResetPassword = email
-    ? createAuthEmailHandler(email, ({ user, url }) => ({
-        to: user.email,
-        subject: 'Reset your ras-stack example password',
-        text: `Reset your password: ${url}`,
-      }))
-    : undefined
-  return betterAuth({
-    appName: 'ras-stack full-stack example',
-    baseURL: options.environment.appUrl,
-    secret: options.secret,
-    trustedOrigins: [options.environment.appUrl],
-    database: drizzleAdapter(options.database, { provider: 'sqlite', schema }),
-    account: standardAccountOptions(),
-    emailAndPassword: standardEmailAndPasswordOptions({
-      requireEmailVerification: Boolean(email) && options.environment.requireEmailVerification,
-      ...(sendResetPassword ? { sendResetPassword } : {}),
-    }),
-    ...(sendVerificationEmail
-      ? {
-          emailVerification: {
-            sendOnSignUp: true,
-            autoSignInAfterVerification: true,
-            sendVerificationEmail,
-          },
-        }
-      : {}),
-    session: standardSessionOptions(),
-    rateLimit: standardRateLimitOptions(),
-    advanced: {
-      cookiePrefix: 'ras_stack_example',
-      useSecureCookies: options.environment.appUrl.startsWith('https://'),
-      disableOriginCheck: false,
-    },
-    plugins: [tanstackStartCookies()],
-  })
-}