ras-stack 2.0.2 → 3.0.0

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

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { loadEnvironment } from './environment'
-
-describe('startup environment', () => {
-  it('requires production state and proxy secrets', () => {
-    expect(() => loadEnvironment({ NODE_ENV: 'production', APP_URL: 'https://example.test', DATA_DIR: 'relative' })).toThrow(
-      'DATA_DIR must be absolute in production',
-    )
-    expect(() =>
-      loadEnvironment({
-        NODE_ENV: 'production',
-        APP_URL: 'https://example.test',
-        DATA_DIR: '/data',
-        CENTRIFUGO_API_URL: 'https://realtime.example.test/api',
-        CENTRIFUGO_API_KEY: 'key',
-      }),
-    ).toThrow('CENTRIFUGO_PROXY_SECRET is required when realtime is enabled in production')
-  })
-
-  it('rejects ambiguous origins and partial realtime credentials', () => {
-    expect(() => loadEnvironment({ APP_URL: 'https://example.test/path' })).toThrow('APP_URL must be an HTTP origin')
-    expect(() => loadEnvironment({ CENTRIFUGO_API_URL: 'http://localhost/api' })).toThrow(
-      'CENTRIFUGO_API_URL and CENTRIFUGO_API_KEY must be configured together',
-    )
-  })
-
-  it.each([
-    ['UPLOAD_GLOBAL_QUOTA_BYTES', '0'],
-    ['UPLOAD_GLOBAL_MAX_FILES', '0'],
-  ])('rejects an invalid %s', (name, value) => {
-    expect(() => loadEnvironment({ [name]: value })).toThrow(`${name} must be a positive integer`)
-  })
-
-  it('requires the global byte cap to accept one maximum-size upload', () => {
-    expect(() => loadEnvironment({ UPLOAD_MAX_BYTES: '10', UPLOAD_GLOBAL_QUOTA_BYTES: '9' })).toThrow(
-      'UPLOAD_GLOBAL_QUOTA_BYTES must be at least UPLOAD_MAX_BYTES',
-    )
-  })
-
-  it('supports production startup with realtime disabled', () => {
-    expect(loadEnvironment({ NODE_ENV: 'production', APP_URL: 'https://example.test', DATA_DIR: '/data' }).realtimeEnabled).toBe(false)
-  })
-})

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

@@ -1,67 +0,0 @@
-import path from 'node:path'
-
-export type AppEnvironment = ReturnType<typeof loadEnvironment>
-
-export function loadEnvironment(environment: NodeJS.ProcessEnv = process.env) {
-  const production = environment.NODE_ENV === 'production'
-  const appUrl = validUrl(environment.APP_URL ?? (production ? '' : 'http://localhost:3100'), 'APP_URL')
-  const dataDirectory = path.resolve(environment.DATA_DIR ?? '.data/example-full-stack')
-  if (production && !path.isAbsolute(environment.DATA_DIR ?? '')) throw new Error('DATA_DIR must be absolute in production')
-  const trustProxy = booleanValue(environment.TRUST_PROXY, 'TRUST_PROXY', false)
-  const requireEmailVerification = booleanValue(environment.EMAIL_REQUIRE_VERIFICATION, 'EMAIL_REQUIRE_VERIFICATION', true)
-  const centrifugoApiUrl = environment.CENTRIFUGO_API_URL?.trim() ?? ''
-  const centrifugoApiKey = environment.CENTRIFUGO_API_KEY?.trim() ?? ''
-  if (Boolean(centrifugoApiUrl) !== Boolean(centrifugoApiKey)) {
-    throw new Error('CENTRIFUGO_API_URL and CENTRIFUGO_API_KEY must be configured together')
-  }
-  const realtimeEnabled = Boolean(centrifugoApiUrl)
-  if (production && realtimeEnabled && !environment.CENTRIFUGO_PROXY_SECRET?.trim()) {
-    throw new Error('CENTRIFUGO_PROXY_SECRET is required when realtime is enabled in production')
-  }
-  const uploadMaxBytes = positiveInteger(environment.UPLOAD_MAX_BYTES ?? '1000000', 'UPLOAD_MAX_BYTES')
-  const uploadQuotaBytes = positiveInteger(environment.UPLOAD_QUOTA_BYTES ?? '5000000', 'UPLOAD_QUOTA_BYTES')
-  const uploadGlobalQuotaBytes = positiveInteger(environment.UPLOAD_GLOBAL_QUOTA_BYTES ?? '100000000', 'UPLOAD_GLOBAL_QUOTA_BYTES')
-  const uploadGlobalMaxFiles = positiveInteger(environment.UPLOAD_GLOBAL_MAX_FILES ?? '1024', 'UPLOAD_GLOBAL_MAX_FILES')
-  if (uploadQuotaBytes < uploadMaxBytes) throw new Error('UPLOAD_QUOTA_BYTES must be at least UPLOAD_MAX_BYTES')
-  if (uploadGlobalQuotaBytes < uploadMaxBytes) throw new Error('UPLOAD_GLOBAL_QUOTA_BYTES must be at least UPLOAD_MAX_BYTES')
-  return {
-    appUrl,
-    centrifugoApiKey,
-    centrifugoApiUrl,
-    dataDirectory,
-    production,
-    realtimeEnabled,
-    requireEmailVerification,
-    trustProxy,
-    uploadGlobalMaxFiles,
-    uploadGlobalQuotaBytes,
-    uploadMaxBytes,
-    uploadQuotaBytes,
-  }
-}
-
-function validUrl(value: string, name: string) {
-  let url: URL
-  try {
-    url = new URL(value)
-  } catch {
-    throw new Error(`${name} must be an absolute HTTP URL`)
-  }
-  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
-    throw new Error(`${name} must be an HTTP origin without credentials, path, query, or fragment`)
-  }
-  return url.origin
-}
-
-function booleanValue(value: string | undefined, name: string, fallback: boolean) {
-  if (value === undefined) return fallback
-  if (value === 'true') return true
-  if (value === 'false') return false
-  throw new Error(`${name} must be true or false`)
-}
-
-function positiveInteger(value: string, name: string) {
-  const parsed = Number(value)
-  if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error(`${name} must be a positive integer`)
-  return parsed
-}

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

@@ -1,38 +0,0 @@
-import { createServerFn } from '@tanstack/react-start'
-import { getRequest } from '@tanstack/react-start/server'
-import { desc } from 'drizzle-orm'
-import { z } from 'zod'
-import { app } from './app'
-import { writeMessage } from './messages'
-import { messages } from './schema'
-import { currentUser } from './session'
-import { mutationRpc, rpc } from './rpc'
-import { limitAuthenticatedRequest } from './rate-limit'
-
-export const snapshot = createServerFn({ method: 'GET' }).handler(() =>
-  rpc(async () => ({
-    user: await currentUser(),
-    messages: app().database.select().from(messages).orderBy(desc(messages.id)).limit(50).all(),
-    emailConfigured: Boolean(app().email),
-    realtimeEnabled: app().environment.realtimeEnabled,
-  })),
-)
-
-export const addMessage = createServerFn({ method: 'POST' })
-  .validator(z.object({ body: z.string().trim().min(1).max(280) }))
-  .handler(({ data }) =>
-    mutationRpc(async () => {
-      const request = getRequest()
-      const user = await currentUser(request)
-      if (!user) throw new Response('Sign in first', { status: 401 })
-      await limitAuthenticatedRequest(request, 'messages', user.id, { window: 60, max: 30 })
-      const now = new Date()
-      const application = app()
-      return writeMessage(application.database, application.environment.realtimeEnabled, {
-        authorId: user.id,
-        author: user.name,
-        body: data.body,
-        createdAt: now,
-      })
-    }),
-  )

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

@@ -1,38 +0,0 @@
-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, expect, it } from 'vitest'
-import { app, closeApp } from './app'
-import { writeMessage } from './messages'
-import { outboxCapacity } from './outbox'
-import { messages, outbox, user } from './schema'
-
-let directory: string
-
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-messages-'))
-  process.env.DATA_DIR = directory
-  process.env.APP_URL = 'http://localhost:3100'
-  const now = new Date()
-  app().database.insert(user).values({ id: 'alice', name: 'Alice', email: 'alice@example.test', createdAt: now, updatedAt: now }).run()
-})
-
-afterEach(async () => {
-  await clearGlobalSingleton('ras-stack.example.full-stack', closeApp)
-  await rm(directory, { recursive: true, force: true })
-  delete process.env.DATA_DIR
-  delete process.env.APP_URL
-})
-
-it('writes without adding to a full outbox when realtime is disabled', () => {
-  const now = new Date()
-  app().database.transaction((transaction) => {
-    for (let index = 0; index < outboxCapacity; index += 1) {
-      transaction.insert(outbox).values({ channel: 'messages:all', payload: '{}', availableAt: now, createdAt: now }).run()
-    }
-  })
-  writeMessage(app().database, false, { authorId: 'alice', author: 'Alice', body: 'stored without realtime', createdAt: now })
-  expect(app().database.select().from(messages).all()).toHaveLength(1)
-  expect(app().database.select().from(outbox).all()).toHaveLength(outboxCapacity)
-})

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

@@ -1,28 +0,0 @@
-import type { app } from './app'
-import { assertOutboxCapacity } from './outbox'
-import { messages, outbox } from './schema'
-
-type Database = ReturnType<typeof app>['database']
-
-export function writeMessage(
-  database: Database,
-  realtimeEnabled: boolean,
-  values: { authorId: string; author: string; body: string; createdAt: Date },
-) {
-  return database.transaction((transaction) => {
-    if (realtimeEnabled) assertOutboxCapacity(transaction)
-    const [message] = transaction.insert(messages).values(values).returning().all()
-    if (realtimeEnabled) {
-      transaction
-        .insert(outbox)
-        .values({
-          channel: 'messages:all',
-          payload: JSON.stringify({ type: 'message-added', id: message!.id }),
-          availableAt: values.createdAt,
-          createdAt: values.createdAt,
-        })
-        .run()
-    }
-    return message!
-  })
-}

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

@@ -1,34 +0,0 @@
-import Database from 'better-sqlite3'
-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, expect, it } from 'vitest'
-import { app, closeApp } from './app'
-import { messages } from './schema'
-
-let directory: string | undefined
-
-afterEach(async () => {
-  await clearGlobalSingleton('ras-stack.example.full-stack', closeApp)
-  if (directory) await rm(directory, { recursive: true, force: true })
-  delete process.env.DATA_DIR
-  delete process.env.APP_URL
-})
-
-it('preserves rows from the pre-migration messages table', async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-legacy-'))
-  process.env.DATA_DIR = directory
-  process.env.APP_URL = 'http://localhost:3100'
-  const legacy = new Database(path.join(directory, 'example.sqlite'))
-  legacy.exec(`CREATE TABLE messages (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    author TEXT NOT NULL,
-    body TEXT NOT NULL,
-    created_at INTEGER NOT NULL
-  ); INSERT INTO messages (author, body, created_at) VALUES ('Ada', 'legacy row', 1234);`)
-  legacy.close()
-  expect(app().database.select().from(messages).all()).toEqual([
-    { id: 1, authorId: 'legacy-import', author: 'Ada', body: 'legacy row', createdAt: new Date(1234) },
-  ])
-})

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

@@ -1,130 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { eq } from 'drizzle-orm'
-import { clearGlobalSingleton } from 'ras-stack/server'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { app, closeApp } from './app'
-import { assertOutboxCapacity, OutboxWorker, outboxCapacity, outboxStatus } from './outbox'
-import { outbox } from './schema'
-
-let directory: string
-
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-outbox-'))
-  process.env.DATA_DIR = directory
-  process.env.APP_URL = 'http://localhost:3100'
-})
-
-afterEach(async () => {
-  vi.useRealTimers()
-  await clearGlobalSingleton('ras-stack.example.full-stack', closeApp)
-  await rm(directory, { recursive: true, force: true })
-  delete process.env.DATA_DIR
-  delete process.env.APP_URL
-})
-
-describe('transactional outbox worker', () => {
-  it('retains a failed publication and deletes it only after delivery', async () => {
-    const now = new Date()
-    app()
-      .database.insert(outbox)
-      .values({ channel: 'messages:all', payload: JSON.stringify({ id: 1 }), availableAt: now, createdAt: now })
-      .run()
-    const publish = vi.fn().mockRejectedValueOnce(new Error('offline')).mockResolvedValueOnce(undefined)
-    const worker = new OutboxWorker({ database: app().database, enabled: false, publish, batchSize: 1 })
-    await worker.drain()
-    const retained = app().database.select().from(outbox).get()!
-    expect(retained.attempts).toBe(1)
-    app()
-      .database.update(outbox)
-      .set({ availableAt: new Date(0) })
-      .where(eq(outbox.id, retained.id))
-      .run()
-    await worker.drain()
-    expect(app().database.select().from(outbox).all()).toEqual([])
-  })
-
-  it('does not overtake the oldest item while it waits for retry', async () => {
-    const now = new Date()
-    app()
-      .database.insert(outbox)
-      .values([
-        { channel: 'messages:all', payload: JSON.stringify({ id: 1 }), availableAt: now, createdAt: now },
-        { channel: 'messages:all', payload: JSON.stringify({ id: 2 }), availableAt: now, createdAt: now },
-      ])
-      .run()
-    const publish = vi.fn().mockRejectedValueOnce(new Error('offline')).mockResolvedValue(undefined)
-    const worker = new OutboxWorker({ database: app().database, enabled: false, publish })
-    await worker.drain()
-    await worker.drain()
-    expect(publish).toHaveBeenCalledTimes(1)
-    app()
-      .database.update(outbox)
-      .set({ availableAt: new Date(0) })
-      .run()
-    await worker.drain()
-    expect(publish.mock.calls.map(([, payload]) => payload)).toEqual([{ id: 1 }, { id: 1 }, { id: 2 }])
-  })
-
-  it('dead-letters terminal failures and exposes degraded status', async () => {
-    const now = new Date()
-    app()
-      .database.insert(outbox)
-      .values({ channel: 'messages:all', payload: JSON.stringify({ id: 1 }), availableAt: now, createdAt: now })
-      .run()
-    const worker = new OutboxWorker({
-      database: app().database,
-      enabled: false,
-      publish: vi.fn().mockRejectedValue(new Error('offline')),
-      maxAttempts: 2,
-    })
-    await worker.drain()
-    app()
-      .database.update(outbox)
-      .set({ availableAt: new Date(0) })
-      .run()
-    await worker.drain()
-    expect(outboxStatus(app().database)).toEqual({ pending: 0, failed: 1 })
-  })
-
-  it('rejects new work when pending and dead-lettered items reach capacity', () => {
-    const now = new Date()
-    app().database.transaction((transaction) => {
-      for (let index = 0; index < outboxCapacity - 1; index += 1) {
-        transaction.insert(outbox).values({ channel: 'messages:all', payload: '{}', availableAt: now, createdAt: now }).run()
-      }
-      transaction.insert(outbox).values({ channel: 'messages:all', payload: '{}', availableAt: now, createdAt: now, failedAt: now }).run()
-    })
-    expect(capture(() => assertOutboxCapacity(app().database))).toMatchObject({ status: 503 })
-  })
-
-  it('reports a scheduled drain failure and keeps scheduling', async () => {
-    vi.useFakeTimers()
-    const onError = vi.fn()
-    const worker = new OutboxWorker({ database: app().database, enabled: true, publish: vi.fn(), intervalMs: 10, onError })
-    const drain = vi.spyOn(worker, 'drain').mockRejectedValueOnce(new Error('database unavailable')).mockResolvedValue()
-    worker.start()
-    await vi.advanceTimersByTimeAsync(10)
-    expect({ calls: drain.mock.calls.length, errors: onError.mock.calls }).toEqual({
-      calls: 2,
-      errors: [[expect.objectContaining({ message: 'database unavailable' })]],
-    })
-    await worker.close()
-  })
-
-  it('propagates the final drain failure during close', async () => {
-    const worker = new OutboxWorker({ database: app().database, enabled: true, publish: vi.fn() })
-    vi.spyOn(worker, 'drain').mockRejectedValue(new Error('database unavailable'))
-    await expect(worker.close()).rejects.toThrow('database unavailable')
-  })
-})
-
-function capture(operation: () => unknown) {
-  try {
-    operation()
-  } catch (error) {
-    return error
-  }
-  throw new Error('Expected operation to fail')
-}

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

@@ -1,110 +0,0 @@
-import { asc, eq, isNull, sql } from 'drizzle-orm'
-import type { app } from './app'
-import { outbox } from './schema'
-
-type Database = ReturnType<typeof app>['database']
-export const outboxCapacity = 1_000
-
-export class OutboxWorker {
-  private timer?: NodeJS.Timeout
-  private draining?: Promise<void>
-  private scheduled?: Promise<void>
-
-  constructor(
-    private readonly options: {
-      database: Database
-      enabled: boolean
-      publish: (channel: string, payload: unknown) => Promise<void>
-      intervalMs?: number
-      batchSize?: number
-      maxAttempts?: number
-      onError?: (error: unknown) => void
-    },
-  ) {}
-
-  start() {
-    if (!this.options.enabled || this.timer) return
-    this.timer = setInterval(() => this.scheduleDrain(), this.options.intervalMs ?? 500)
-    this.timer.unref()
-    this.scheduleDrain()
-  }
-
-  drain() {
-    if (this.draining) return this.draining
-    this.draining = this.drainBatch().finally(() => {
-      this.draining = undefined
-    })
-    return this.draining
-  }
-
-  async close() {
-    if (this.timer) clearInterval(this.timer)
-    this.timer = undefined
-    await this.draining
-    if (this.options.enabled) await this.drain()
-  }
-
-  private scheduleDrain() {
-    if (this.scheduled) return
-    const scheduled = this.drain()
-      .catch((error: unknown) => {
-        if (this.options.onError) this.options.onError(error)
-        else console.error({ event: 'example_outbox_drain_failed', error })
-      })
-      .finally(() => {
-        if (this.scheduled === scheduled) this.scheduled = undefined
-      })
-    this.scheduled = scheduled
-  }
-
-  private async drainBatch() {
-    const items = this.options.database
-      .select()
-      .from(outbox)
-      .where(isNull(outbox.failedAt))
-      .orderBy(asc(outbox.id))
-      .limit(this.options.batchSize ?? 20)
-      .all()
-    for (const item of items) {
-      if (item.availableAt.getTime() > Date.now()) break
-      try {
-        const payload: unknown = JSON.parse(item.payload)
-        // oxlint-disable-next-line no-await-in-loop
-        await this.options.publish(item.channel, payload)
-        this.options.database.delete(outbox).where(eq(outbox.id, item.id)).run()
-      } catch (error) {
-        const attempts = item.attempts + 1
-        const failed = attempts >= (this.options.maxAttempts ?? 8)
-        const delay = Math.min(60_000, 500 * 2 ** Math.min(attempts, 7))
-        this.options.database
-          .update(outbox)
-          .set({
-            attempts,
-            availableAt: new Date(Date.now() + delay),
-            failedAt: failed ? new Date() : null,
-            lastError: error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500),
-          })
-          .where(eq(outbox.id, item.id))
-          .run()
-        console.error({ event: 'example_outbox_delivery_failed', outboxId: item.id, attempts, error })
-        break
-      }
-    }
-  }
-}
-
-export function outboxStatus(database: Pick<Database, 'select'>): { pending: number; failed: number } {
-  const status = database
-    .select({
-      pending: sql<number>`coalesce(sum(case when ${outbox.failedAt} is null then 1 else 0 end), 0)`,
-      failed: sql<number>`coalesce(sum(case when ${outbox.failedAt} is not null then 1 else 0 end), 0)`,
-    })
-    .from(outbox)
-    .get()
-  return status ?? { pending: 0, failed: 0 }
-}
-
-export function assertOutboxCapacity(database: Pick<Database, 'select'>) {
-  const status = outboxStatus(database)
-  if (status.pending + status.failed >= outboxCapacity) throw new Response('Realtime queue is full', { status: 503 })
-}

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

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { postHogEnvironment, postHogRequestContext } from 'ras-stack/posthog'
-import { createManagedPostHogServerTelemetry, createPostHogServerClient } from 'ras-stack/posthog/server'
-import { postHogCoverage } from '../posthog'
-
-describe('PostHog integration boundary', () => {
-  it('stays disabled without deployment configuration', async () => {
-    expect(await createPostHogServerClient(postHogEnvironment({}))).toBeUndefined()
-    expect(postHogCoverage.browser.errorTracking).toBe(true)
-  })
-
-  it('propagates a browser session only with the authenticated identity', () => {
-    const request = new Request('https://example.test/action', {
-      headers: { 'x-posthog-distinct-id': 'person-123', 'x-posthog-session-id': 'session-456' },
-    })
-    expect(postHogRequestContext(request, { authenticatedDistinctId: 'person-123' })).toEqual({
-      distinctId: 'person-123',
-      sessionId: 'session-456',
-      properties: { $session_id: 'session-456' },
-    })
-  })
-
-  it('keeps the managed server lifecycle optional', async () => {
-    const telemetry = createManagedPostHogServerTelemetry({ environment: postHogEnvironment({}), serviceName: 'example' })
-    await telemetry.start()
-    await telemetry.log({ body: 'request completed', severityText: 'info' })
-    await telemetry.metrics.count('request.completed')
-    expect(await telemetry.withSpan('request', () => 'completed')).toBe('completed')
-    await telemetry.shutdown()
-    expect(postHogCoverage.server.logs).toBe(true)
-    expect(postHogCoverage.server.metrics).toBe(true)
-    expect(postHogCoverage.server.tracing).toBe(true)
-  })
-})

package/dist/create/template/src/server/rate-limit.test.ts

@@ -1,32 +0,0 @@
-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, expect, it } from 'vitest'
-import { closeApp } from './app'
-import { limitAuthenticatedRequest } from './rate-limit'
-
-let directory: string
-
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(os.tmpdir(), 'ras-stack-example-rate-limit-'))
-  process.env.DATA_DIR = directory
-  process.env.APP_URL = 'http://localhost:3100'
-})
-
-afterEach(async () => {
-  await clearGlobalSingleton('ras-stack.example.full-stack', closeApp)
-  await rm(directory, { recursive: true, force: true })
-  delete process.env.DATA_DIR
-  delete process.env.APP_URL
-})
-
-it('keeps authenticated user budgets separate', async () => {
-  await limitAuthenticatedRequest(request(), 'messages', 'alice', { window: 60, max: 1 })
-  await expect(limitAuthenticatedRequest(request(), 'messages', 'alice', { window: 60, max: 1 })).rejects.toMatchObject({ status: 429 })
-  await expect(limitAuthenticatedRequest(request(), 'messages', 'bob', { window: 60, max: 1 })).resolves.toMatchObject({ remaining: 0 })
-})
-
-function request() {
-  return new Request('http://localhost:3100/messages')
-}

package/dist/create/template/src/server/rate-limit.ts

@@ -1,29 +0,0 @@
-import { sqliteRateLimitStore } from 'ras-stack/database/sqlite'
-import { createRateLimit } from 'ras-stack/server'
-import type { RateLimitRule } from 'ras-stack/auth'
-import { app } from './app'
-
-const limiters = new WeakMap<object, Map<string, ReturnType<typeof createRateLimit>>>()
-const identities = new WeakMap<Request, string>()
-
-export function limitAuthenticatedRequest(request: Request, scope: string, userId: string, rule: RateLimitRule) {
-  const database = app().database
-  let databaseLimiters = limiters.get(database)
-  if (!databaseLimiters) {
-    databaseLimiters = new Map()
-    limiters.set(database, databaseLimiters)
-  }
-  let limiter = databaseLimiters.get(scope)
-  if (!limiter) {
-    limiter = createRateLimit({
-      store: sqliteRateLimitStore(database.$client, 'app_rate_limit'),
-      rule,
-      scope,
-      identify: (candidate) => identities.get(candidate),
-      onUnavailable: 'reject',
-    })
-    databaseLimiters.set(scope, limiter)
-  }
-  identities.set(request, userId)
-  return limiter(request).finally(() => identities.delete(request))
-}

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

@@ -1,16 +0,0 @@
-import { createTanStackRpc, requireTanStackMutationOrigin } from 'ras-stack/tanstack/server'
-import { createPostHogRpcLogger } from 'ras-stack/posthog/server'
-import { app } from './app'
-import { currentUser } from './session'
-
-const reportRpcError = createPostHogRpcLogger(app().telemetry, {
-  logError: (error, context) => console.error({ event: 'example_server_function_failed', ...context, error }),
-  resolveAuthenticatedDistinctId: async (request) => (await currentUser(request))?.id,
-  allowAnonymousDistinctId: true,
-})
-
-export const { rpc, mutationRpc } = createTanStackRpc({
-  requireMutation: (request) =>
-    requireTanStackMutationOrigin({ configured: [app().environment.appUrl], trustForwardedHeaders: app().environment.trustProxy }, request),
-  logError: reportRpcError,
-})