ras-stack 2.0.2 → 3.0.0

package/dist/create/template/scripts/database.test.ts

@@ -1,121 +0,0 @@
-import Database from 'better-sqlite3'
-import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, beforeEach, expect, it, vi } from 'vitest'
-import { runDatabaseCommand } from './database'
-
-let directory: string
-let source: string
-
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-backup-'))
-  source = path.join(directory, 'example.sqlite')
-  writeValue(source, 'before')
-})
-
-afterEach(async () => {
-  await rm(directory, { recursive: true, force: true })
-})
-
-it('backs up and restores a validated database', async () => {
-  const backup = path.join(directory, 'backup.sqlite')
-  await runDatabaseCommand('backup', backup, { DATA_DIR: directory })
-  writeValue(source, 'after')
-  await runDatabaseCommand('restore', backup, { DATA_DIR: directory })
-  expect(readValue(source)).toBe('before')
-})
-
-it('rejects a corrupt restore candidate without changing the source', async () => {
-  const corrupt = path.join(directory, 'corrupt.sqlite')
-  await writeFile(corrupt, 'not sqlite')
-  await expect(runDatabaseCommand('restore', corrupt, { DATA_DIR: directory })).rejects.toThrow('file is not a database')
-  expect(readValue(source)).toBe('before')
-})
-
-it('restores the original file and removes temporary state when replacement fails', async () => {
-  const backup = path.join(directory, 'backup.sqlite')
-  await runDatabaseCommand('backup', backup, { DATA_DIR: directory })
-  writeValue(source, 'current')
-  const operations = await import('node:fs/promises')
-  let renames = 0
-  const rename = vi.fn(async (from: string, to: string) => {
-    renames += 1
-    if (renames === 2) throw new Error('replacement failed')
-    await operations.rename(from, to)
-  }) as typeof operations.rename
-  await expect(runDatabaseCommand('restore', backup, { DATA_DIR: directory }, { ...operations, rename })).rejects.toThrow(
-    'replacement failed',
-  )
-  expect(readValue(source)).toBe('current')
-  expect((await readdir(directory)).some((file) => file.includes('.restore-'))).toBe(false)
-})
-
-it('restores the original file even when temporary cleanup also fails', async () => {
-  const backup = path.join(directory, 'backup.sqlite')
-  await runDatabaseCommand('backup', backup, { DATA_DIR: directory })
-  writeValue(source, 'current')
-  const operations = await import('node:fs/promises')
-  let renames = 0
-  const rename = vi.fn(async (from: string, to: string) => {
-    renames += 1
-    if (renames === 2) throw new Error('replacement failed')
-    await operations.rename(from, to)
-  }) as typeof operations.rename
-  const failure = await runDatabaseCommand(
-    'restore',
-    backup,
-    { DATA_DIR: directory },
-    {
-      ...operations,
-      rename,
-      rm: vi.fn().mockRejectedValue(new Error('cleanup failed')),
-    },
-  ).catch((error: unknown) => error)
-  expect(failure).toBeInstanceOf(AggregateError)
-  expect((failure as AggregateError).errors.map(String)).toEqual(['Error: replacement failed', 'Error: cleanup failed'])
-  expect(readValue(source)).toBe('current')
-})
-
-it('reports rollback and cleanup failures after a replacement failure', async () => {
-  const backup = path.join(directory, 'backup.sqlite')
-  await runDatabaseCommand('backup', backup, { DATA_DIR: directory })
-  const operations = await import('node:fs/promises')
-  let renames = 0
-  const rename = vi.fn(async (from: string, to: string) => {
-    renames += 1
-    if (renames === 2) throw new Error('replacement failed')
-    if (renames === 3) throw new Error('rollback failed')
-    await operations.rename(from, to)
-  }) as typeof operations.rename
-  const failure = await runDatabaseCommand(
-    'restore',
-    backup,
-    { DATA_DIR: directory },
-    {
-      ...operations,
-      rename,
-      rm: vi.fn().mockRejectedValue(new Error('cleanup failed')),
-    },
-  ).catch((error: unknown) => error)
-  expect((failure as AggregateError).errors.map(String)).toEqual([
-    'Error: replacement failed',
-    'Error: rollback failed',
-    'Error: cleanup failed',
-  ])
-  expect(rename).toHaveBeenCalledTimes(3)
-})
-
-function writeValue(file: string, value: string) {
-  const database = new Database(file)
-  database.exec('DROP TABLE IF EXISTS proof; CREATE TABLE proof (value TEXT NOT NULL)')
-  database.prepare('INSERT INTO proof (value) VALUES (?)').run(value)
-  database.close()
-}
-
-function readValue(file: string) {
-  const database = new Database(file, { readonly: true })
-  const value = database.prepare('SELECT value FROM proof').pluck().get() as string
-  database.close()
-  return value
-}

package/dist/create/template/scripts/database.ts

@@ -1,105 +0,0 @@
-import Database from 'better-sqlite3'
-import { existsSync } from 'node:fs'
-import { copyFile, mkdir, rename, rm } from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-type FileOperations = { copyFile: typeof copyFile; mkdir: typeof mkdir; rename: typeof rename; rm: typeof rm }
-const defaultFileOperations: FileOperations = { copyFile, mkdir, rename, rm }
-
-export async function runDatabaseCommand(
-  command: 'backup' | 'restore',
-  suppliedPath: string | undefined,
-  environment: NodeJS.ProcessEnv = process.env,
-  fileOperations: FileOperations = defaultFileOperations,
-) {
-  const dataDirectory = path.resolve(environment.DATA_DIR ?? '.data/example-full-stack')
-  const source = path.join(dataDirectory, 'example.sqlite')
-  if (command === 'backup') {
-    const backupDirectory = path.join(dataDirectory, 'backups')
-    await fileOperations.mkdir(backupDirectory, { recursive: true })
-    const destination = suppliedPath
-      ? path.resolve(suppliedPath)
-      : path.join(backupDirectory, `example-${new Date().toISOString().replaceAll(':', '-')}.sqlite`)
-    const database = new Database(source, { readonly: true, fileMustExist: true })
-    try {
-      integrity(database, 'source')
-      await database.backup(destination)
-      const copy = new Database(destination, { readonly: true, fileMustExist: true })
-      try {
-        integrity(copy, 'backup')
-      } finally {
-        copy.close()
-      }
-      return destination
-    } finally {
-      database.close()
-    }
-  }
-
-  if (!suppliedPath) throw new Error('restore requires a backup file')
-  const candidate = path.resolve(suppliedPath)
-  const backup = new Database(candidate, { readonly: true, fileMustExist: true })
-  try {
-    integrity(backup, 'backup')
-  } finally {
-    backup.close()
-  }
-  await fileOperations.mkdir(dataDirectory, { recursive: true })
-  for (const sidecar of [`${source}-wal`, `${source}-shm`]) {
-    if (existsSync(sidecar)) throw new Error(`Refusing to restore while SQLite sidecar exists: ${sidecar}`)
-  }
-  const temporary = `${source}.restore-${process.pid}`
-  await fileOperations.copyFile(candidate, temporary)
-  const restored = new Database(temporary, { readonly: true, fileMustExist: true })
-  try {
-    integrity(restored, 'restored')
-  } finally {
-    restored.close()
-  }
-  const previous = `${source}.before-restore-${Date.now()}`
-  const hasPrevious = existsSync(source)
-  if (hasPrevious) await fileOperations.rename(source, previous)
-  try {
-    await fileOperations.rename(temporary, source)
-  } catch (error) {
-    const failures = [error]
-    if (hasPrevious) {
-      try {
-        await fileOperations.rename(previous, source)
-      } catch (rollbackError) {
-        failures.push(rollbackError)
-      }
-    }
-    try {
-      await fileOperations.rm(temporary, { force: true })
-    } catch (cleanupError) {
-      failures.push(cleanupError)
-    }
-    if (failures.length === 1) throw error
-    const failure = new AggregateError(failures, 'Restore replacement failed and recovery was incomplete')
-    failure.cause = error
-    throw failure
-  }
-  return source
-}
-
-function integrity(database: Database.Database, label: string) {
-  const result = database.pragma('quick_check', { simple: true })
-  if (result !== 'ok') throw new Error(`${label} database failed quick_check: ${String(result)}`)
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  const [command, suppliedPath] = process.argv.slice(2)
-  if (command !== 'backup' && command !== 'restore') {
-    console.error('usage: database.mjs <backup [destination]|restore backup-file>')
-    process.exitCode = 2
-  } else {
-    try {
-      console.log(await runDatabaseCommand(command, suppliedPath))
-    } catch (error) {
-      console.error(error)
-      process.exitCode = 1
-    }
-  }
-}

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

@@ -1,3 +0,0 @@
-import { createAuthClient } from 'better-auth/react'
-
-export const authClient = createAuthClient()

package/dist/create/template/src/client/queries.ts

@@ -1,4 +0,0 @@
-import { queryOptions } from '@tanstack/react-query'
-import { snapshot } from '../server/fns'
-
-export const snapshotQuery = () => queryOptions({ queryKey: ['example', 'snapshot'], queryFn: () => snapshot() })

package/dist/create/template/src/client/queryClient.ts

@@ -1 +0,0 @@
-export { createStackQueryClient as createQueryClient, queryErrorMessage } from 'ras-stack/tanstack/query'

package/dist/create/template/src/client/useRealtime.ts

@@ -1,20 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query'
-import { createSameOriginRealtimeClient } from 'ras-stack/realtime/client'
-import { useConnectedRealtimeClient, useRealtimeSubscription } from 'ras-stack/realtime/react'
-import { useCallback } from 'react'
-import { snapshotQuery } from './queries'
-
-export function useRealtime(enabled: boolean) {
-  const queryClient = useQueryClient()
-  const create = useCallback(() => createSameOriginRealtimeClient({}), [])
-  const client = useConnectedRealtimeClient(create, enabled)
-  const configure = useCallback(
-    (subscription: NonNullable<ReturnType<typeof useRealtimeSubscription>>) => {
-      const refresh = () => void queryClient.invalidateQueries({ queryKey: snapshotQuery().queryKey })
-      subscription.on('publication', refresh)
-      return () => subscription.off('publication', refresh)
-    },
-    [queryClient],
-  )
-  useRealtimeSubscription({ client, channel: 'messages:all', enabled, configure })
-}

package/dist/create/template/src/posthog.ts

@@ -1,21 +0,0 @@
-import { definePostHogCoverage } from 'ras-stack/posthog'
-
-export const postHogCoverage = definePostHogCoverage({
-  browser: {
-    analytics: true,
-    errorTracking: true,
-    identity: true,
-    logs: true,
-    metrics: true,
-    sessionReplay: { disabled: 'The example does not handle user data worth replaying' },
-    featureFlags: { disabled: 'The example has no rollout-controlled behavior' },
-  },
-  server: {
-    analytics: true,
-    errorTracking: true,
-    logs: true,
-    metrics: true,
-    tracing: true,
-  },
-  sourceMaps: { disabled: 'The example is not deployed as a user-facing application' },
-})

package/dist/create/template/src/routeTree.gen.ts

@@ -1,230 +0,0 @@
-/* eslint-disable */
-
-// @ts-nocheck
-
-// noinspection JSUnusedGlobalSymbols
-
-// This file was automatically generated by TanStack Router.
-// You should NOT make any changes in this file as it will be overwritten.
-// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
-
-import { Route as rootRouteImport } from './routes/__root'
-import { Route as IndexRouteImport } from './routes/index'
-import { Route as ApiHealthRouteImport } from './routes/api/health'
-import { Route as ApiLiveRouteImport } from './routes/api/live'
-import { Route as ApiReadyRouteImport } from './routes/api/ready'
-import { Route as ApiUploadsRouteImport } from './routes/api/uploads'
-import { Route as ApiAuthSplatRouteImport } from './routes/api/auth.$'
-import { Route as ApiCentrifugoConnectRouteImport } from './routes/api/centrifugo.connect'
-import { Route as ApiUploadsIdRouteImport } from './routes/api/uploads.$id'
-
-const IndexRoute = IndexRouteImport.update({
-  id: '/',
-  path: '/',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiHealthRoute = ApiHealthRouteImport.update({
-  id: '/api/health',
-  path: '/api/health',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiLiveRoute = ApiLiveRouteImport.update({
-  id: '/api/live',
-  path: '/api/live',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiReadyRoute = ApiReadyRouteImport.update({
-  id: '/api/ready',
-  path: '/api/ready',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiUploadsRoute = ApiUploadsRouteImport.update({
-  id: '/api/uploads',
-  path: '/api/uploads',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiAuthSplatRoute = ApiAuthSplatRouteImport.update({
-  id: '/api/auth/$',
-  path: '/api/auth/$',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiCentrifugoConnectRoute = ApiCentrifugoConnectRouteImport.update({
-  id: '/api/centrifugo/connect',
-  path: '/api/centrifugo/connect',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const ApiUploadsIdRoute = ApiUploadsIdRouteImport.update({
-  id: '/$id',
-  path: '/$id',
-  getParentRoute: () => ApiUploadsRoute,
-} as any)
-
-export interface FileRoutesByFullPath {
-  '/': typeof IndexRoute
-  '/api/health': typeof ApiHealthRoute
-  '/api/live': typeof ApiLiveRoute
-  '/api/ready': typeof ApiReadyRoute
-  '/api/uploads': typeof ApiUploadsRouteWithChildren
-  '/api/auth/$': typeof ApiAuthSplatRoute
-  '/api/centrifugo/connect': typeof ApiCentrifugoConnectRoute
-  '/api/uploads/$id': typeof ApiUploadsIdRoute
-}
-export interface FileRoutesByTo {
-  '/': typeof IndexRoute
-  '/api/health': typeof ApiHealthRoute
-  '/api/live': typeof ApiLiveRoute
-  '/api/ready': typeof ApiReadyRoute
-  '/api/uploads': typeof ApiUploadsRouteWithChildren
-  '/api/auth/$': typeof ApiAuthSplatRoute
-  '/api/centrifugo/connect': typeof ApiCentrifugoConnectRoute
-  '/api/uploads/$id': typeof ApiUploadsIdRoute
-}
-export interface FileRoutesById {
-  __root__: typeof rootRouteImport
-  '/': typeof IndexRoute
-  '/api/health': typeof ApiHealthRoute
-  '/api/live': typeof ApiLiveRoute
-  '/api/ready': typeof ApiReadyRoute
-  '/api/uploads': typeof ApiUploadsRouteWithChildren
-  '/api/auth/$': typeof ApiAuthSplatRoute
-  '/api/centrifugo/connect': typeof ApiCentrifugoConnectRoute
-  '/api/uploads/$id': typeof ApiUploadsIdRoute
-}
-export interface FileRouteTypes {
-  fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths:
-    | '/'
-    | '/api/health'
-    | '/api/live'
-    | '/api/ready'
-    | '/api/uploads'
-    | '/api/auth/$'
-    | '/api/centrifugo/connect'
-    | '/api/uploads/$id'
-  fileRoutesByTo: FileRoutesByTo
-  to:
-    | '/'
-    | '/api/health'
-    | '/api/live'
-    | '/api/ready'
-    | '/api/uploads'
-    | '/api/auth/$'
-    | '/api/centrifugo/connect'
-    | '/api/uploads/$id'
-  id:
-    | '__root__'
-    | '/'
-    | '/api/health'
-    | '/api/live'
-    | '/api/ready'
-    | '/api/uploads'
-    | '/api/auth/$'
-    | '/api/centrifugo/connect'
-    | '/api/uploads/$id'
-  fileRoutesById: FileRoutesById
-}
-export interface RootRouteChildren {
-  IndexRoute: typeof IndexRoute
-  ApiHealthRoute: typeof ApiHealthRoute
-  ApiLiveRoute: typeof ApiLiveRoute
-  ApiReadyRoute: typeof ApiReadyRoute
-  ApiUploadsRoute: typeof ApiUploadsRouteWithChildren
-  ApiAuthSplatRoute: typeof ApiAuthSplatRoute
-  ApiCentrifugoConnectRoute: typeof ApiCentrifugoConnectRoute
-}
-
-declare module '@tanstack/react-router' {
-  interface FileRoutesByPath {
-    '/': {
-      id: '/'
-      path: '/'
-      fullPath: '/'
-      preLoaderRoute: typeof IndexRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/health': {
-      id: '/api/health'
-      path: '/api/health'
-      fullPath: '/api/health'
-      preLoaderRoute: typeof ApiHealthRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/live': {
-      id: '/api/live'
-      path: '/api/live'
-      fullPath: '/api/live'
-      preLoaderRoute: typeof ApiLiveRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/ready': {
-      id: '/api/ready'
-      path: '/api/ready'
-      fullPath: '/api/ready'
-      preLoaderRoute: typeof ApiReadyRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/uploads': {
-      id: '/api/uploads'
-      path: '/api/uploads'
-      fullPath: '/api/uploads'
-      preLoaderRoute: typeof ApiUploadsRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/auth/$': {
-      id: '/api/auth/$'
-      path: '/api/auth/$'
-      fullPath: '/api/auth/$'
-      preLoaderRoute: typeof ApiAuthSplatRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/centrifugo/connect': {
-      id: '/api/centrifugo/connect'
-      path: '/api/centrifugo/connect'
-      fullPath: '/api/centrifugo/connect'
-      preLoaderRoute: typeof ApiCentrifugoConnectRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/api/uploads/$id': {
-      id: '/api/uploads/$id'
-      path: '/$id'
-      fullPath: '/api/uploads/$id'
-      preLoaderRoute: typeof ApiUploadsIdRouteImport
-      parentRoute: typeof ApiUploadsRoute
-    }
-  }
-}
-
-interface ApiUploadsRouteChildren {
-  ApiUploadsIdRoute: typeof ApiUploadsIdRoute
-}
-
-const ApiUploadsRouteChildren: ApiUploadsRouteChildren = {
-  ApiUploadsIdRoute: ApiUploadsIdRoute,
-}
-
-const ApiUploadsRouteWithChildren = ApiUploadsRoute._addFileChildren(
-  ApiUploadsRouteChildren,
-)
-
-const rootRouteChildren: RootRouteChildren = {
-  IndexRoute: IndexRoute,
-  ApiHealthRoute: ApiHealthRoute,
-  ApiLiveRoute: ApiLiveRoute,
-  ApiReadyRoute: ApiReadyRoute,
-  ApiUploadsRoute: ApiUploadsRouteWithChildren,
-  ApiAuthSplatRoute: ApiAuthSplatRoute,
-  ApiCentrifugoConnectRoute: ApiCentrifugoConnectRoute,
-}
-export const routeTree = rootRouteImport
-  ._addFileChildren(rootRouteChildren)
-  ._addFileTypes<FileRouteTypes>()
-
-import type { getRouter } from './router.tsx'
-import type { startInstance } from './start.ts'
-declare module '@tanstack/react-start' {
-  interface Register {
-    ssr: true
-    router: Awaited<ReturnType<typeof getRouter>>
-    config: Awaited<ReturnType<typeof startInstance.getOptions>>
-  }
-}

package/dist/create/template/src/router.tsx

@@ -1,17 +0,0 @@
-import { createRouter } from '@tanstack/react-router'
-import { setupRouterSsrQueryIntegration } from '@tanstack/react-router-ssr-query'
-import { createQueryClient } from './client/queryClient'
-import { routeTree } from './routeTree.gen'
-
-export function getRouter() {
-  const queryClient = createQueryClient()
-  const router = createRouter({ routeTree, context: { queryClient }, defaultPreload: 'intent' })
-  setupRouterSsrQueryIntegration({ router, queryClient })
-  return router
-}
-
-declare module '@tanstack/react-router' {
-  interface Register {
-    router: ReturnType<typeof getRouter>
-  }
-}

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

@@ -1,40 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query'
-import { HeadContent, Outlet, Scripts, createRootRouteWithContext } from '@tanstack/react-router'
-import { postHogEnvironment } from 'ras-stack/posthog'
-import { PostHogIntegration } from 'ras-stack/posthog/react'
-import styles from '../styles.css?url'
-
-const posthog = postHogEnvironment({
-  projectToken: import.meta.env.VITE_POSTHOG_PROJECT_TOKEN,
-  host: import.meta.env.VITE_POSTHOG_HOST,
-})
-
-const posthogService = { name: 'ras-stack-example-web', environment: import.meta.env.MODE }
-
-export const Route = createRootRouteWithContext<{ queryClient: QueryClient }>()({
-  head: () => ({
-    meta: [
-      { charSet: 'utf-8' },
-      { name: 'viewport', content: 'width=device-width, initial-scale=1' },
-      { title: 'ras-stack full-stack example' },
-    ],
-    links: [{ rel: 'stylesheet', href: styles }],
-  }),
-  component: Root,
-})
-
-function Root() {
-  return (
-    <html lang="en">
-      <head>
-        <HeadContent />
-      </head>
-      <body>
-        <PostHogIntegration environment={posthog} service={posthogService}>
-          <Outlet />
-        </PostHogIntegration>
-        <Scripts />
-      </body>
-    </html>
-  )
-}

package/dist/create/template/src/routes/api/auth.$.ts

@@ -1,8 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { app } from '../../server/app'
-
-const handler = ({ request }: { request: Request }) => app().auth.handler(request)
-
-export const Route = createFileRoute('/api/auth/$')({
-  server: { handlers: { GET: handler, POST: handler } },
-})

package/dist/create/template/src/routes/api/centrifugo.connect.ts

@@ -1,29 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import crypto from 'node:crypto'
-import { requireTanStackMutationOrigin } from 'ras-stack/tanstack/server'
-import { currentUser } from '../../server/session'
-
-export const Route = createFileRoute('/api/centrifugo/connect')({
-  server: {
-    handlers: {
-      POST: async ({ request }) => {
-        if (!proxySecret(request)) return Response.json({ disconnect: { code: 4501, reason: 'unauthorized' } })
-        try {
-          requireTanStackMutationOrigin({ configured: [process.env.APP_URL], trustForwardedHeaders: true }, request)
-        } catch {
-          return Response.json({ disconnect: { code: 4501, reason: 'unauthorized' } })
-        }
-        const user = await currentUser(request)
-        return user
-          ? Response.json({ result: { user: user.id, info: { name: user.name } } })
-          : Response.json({ disconnect: { code: 4501, reason: 'unauthorized' } })
-      },
-    },
-  },
-})
-
-function proxySecret(request: Request) {
-  const expected = Buffer.from(process.env.CENTRIFUGO_PROXY_SECRET ?? '')
-  const received = Buffer.from(request.headers.get('x-proxy-secret') ?? '')
-  return expected.length > 0 && expected.length === received.length && crypto.timingSafeEqual(expected, received)
-}

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

@@ -1,6 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { readinessHandler } from './ready'
-
-export const Route = createFileRoute('/api/health')({
-  server: { handlers: { GET: readinessHandler } },
-})

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

@@ -1,5 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-
-export const Route = createFileRoute('/api/live')({
-  server: { handlers: { GET: () => Response.json({ status: 'ok' }, { headers: { 'Cache-Control': 'no-store' } }) } },
-})

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

@@ -1,30 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { sql } from 'drizzle-orm'
-import { infrastructureFailure } from 'ras-stack/server'
-import { tanStackHealthHandler } from 'ras-stack/tanstack/server'
-import { app } from '../../server/app'
-import { outboxStatus } from '../../server/outbox'
-
-export const readinessHandler = tanStackHealthHandler(
-  async () => {
-    try {
-      app().database.get(sql`SELECT 1`)
-      const status = outboxStatus(app().database)
-      if (status.failed > 0) throw new Error(`Realtime outbox has ${status.failed} dead-lettered item(s)`)
-      await app().email?.verify()
-    } catch (error) {
-      console.error({ event: 'example_readiness_failed', error })
-      throw error
-    }
-  },
-  {
-    failure: (error) =>
-      infrastructureFailure(error, { code: 'dependency_unavailable', message: 'required dependency unavailable', retryable: true }),
-  },
-)
-
-export const Route = createFileRoute('/api/ready')({
-  server: {
-    handlers: { GET: readinessHandler },
-  },
-})