@dotdo/postgres 0.1.0

package/src/worker/concerns/auth-concern.ts

@@ -0,0 +1,179 @@
+/**
+ * Authentication Concern for PostgresDO decomposition
+ * @module worker/concerns/auth-concern
+ */
+
+import { TokenCache } from '@dotdo/postgres-shared'
+import { constantTimeCompare } from '@dotdo/postgres-shared/crypto'
+import { extractBearerToken, type AuthenticatedUser, type TokenValidationResult } from '../auth'
+import { WorkerAuthError } from '../errors'
+
+export interface IAuthConcern {
+  validateToken(token: string): Promise<{
+    valid: boolean
+    user?: { id: string; email?: string }
+    error?: string
+  }>
+  authenticateRequest(request: Request): Promise<{ id: string; email?: string } | null>
+  isEnabled(): boolean
+  setUserId(userId: string): void
+  getUserId(): string | undefined
+  clearCache(): void
+}
+
+export interface AuthConcernConfig {
+  enabled?: boolean
+  oauthUrl?: string
+  tokenCacheTTL?: number
+  validateToken?: (token: string) => Promise<TokenValidationResult>
+  allowAnonymous?: boolean
+  userId?: string
+}
+
+const DEFAULT_TOKEN_CACHE_CONFIG = {
+  maxSize: 100,
+  defaultTTL: 60000,
+  cleanupInterval: 0,
+}
+
+export class AuthConcern implements IAuthConcern {
+  private config: AuthConcernConfig
+  private tokenCache: TokenCache
+
+  constructor(config: AuthConcernConfig = {}) {
+    // Build config without undefined values for exactOptionalPropertyTypes
+    this.config = {
+      enabled: config.enabled ?? false,
+      oauthUrl: config.oauthUrl ?? 'https://oauth.do',
+      tokenCacheTTL: config.tokenCacheTTL ?? 60000,
+      allowAnonymous: config.allowAnonymous ?? false,
+    }
+    if (config.validateToken !== undefined) {
+      this.config.validateToken = config.validateToken
+    }
+    if (config.userId !== undefined) {
+      this.config.userId = config.userId
+    }
+    this.tokenCache = new TokenCache(DEFAULT_TOKEN_CACHE_CONFIG)
+  }
+
+  getConfig(): AuthConcernConfig {
+    return { ...this.config }
+  }
+
+  isEnabled(): boolean {
+    return this.config.enabled ?? false
+  }
+
+  setUserId(userId: string): void {
+    this.config.userId = userId
+  }
+
+  getUserId(): string | undefined {
+    return this.config.userId
+  }
+
+  clearCache(): void {
+    this.tokenCache.clear()
+  }
+
+  async validateToken(token: string): Promise<TokenValidationResult> {
+    const cached = this.tokenCache.get(token)
+    if (cached) {
+      return cached
+    }
+
+    if (this.config.validateToken) {
+      const result = await this.config.validateToken(token)
+      if (result.valid) {
+        this.tokenCache.set(token, result, this.config.tokenCacheTTL ?? 60000)
+      }
+      return result
+    }
+
+    const oauthUrl = this.config.oauthUrl ?? 'https://oauth.do'
+
+    try {
+      const response = await fetch(`${oauthUrl}/api/auth/session`, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+      })
+
+      if (!response.ok) {
+        return {
+          valid: false,
+          error: `Token validation failed: ${response.status}`,
+        }
+      }
+
+      const data = (await response.json()) as { user?: AuthenticatedUser; expires?: string }
+
+      if (!data.user) {
+        return {
+          valid: false,
+          error: 'No user in session response',
+        }
+      }
+
+      // Build result without undefined values for exactOptionalPropertyTypes
+      const result: TokenValidationResult = {
+        valid: true,
+        user: data.user,
+      }
+      if (data.expires) {
+        result.expiresAt = new Date(data.expires)
+      }
+
+      this.tokenCache.set(token, result, this.config.tokenCacheTTL ?? 60000)
+
+      return result
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Token validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      }
+    }
+  }
+
+  async authenticateRequest(request: Request): Promise<AuthenticatedUser | null> {
+    if (!this.config.enabled) {
+      return null
+    }
+
+    const token = extractBearerToken(request)
+
+    if (!token) {
+      if (this.config.allowAnonymous) {
+        return null
+      }
+      throw new WorkerAuthError('Authentication required', { reason: 'missing_token' })
+    }
+
+    const result = await this.validateToken(token)
+
+    if (!result.valid) {
+      throw new WorkerAuthError(result.error ?? 'Invalid token', { reason: 'invalid_token' })
+    }
+
+    if (this.config.userId && !constantTimeCompare(result.user?.id ?? '', this.config.userId)) {
+      throw new WorkerAuthError('User ID mismatch - access denied', { reason: 'user_mismatch' })
+    }
+
+    return result.user ?? null
+  }
+
+  getCacheStats(): { size: number; hits: number; misses: number } {
+    const stats = this.tokenCache.stats
+    return {
+      size: stats.size,
+      hits: stats.hitCount,
+      misses: stats.missCount,
+    }
+  }
+}
+
+export function createAuthConcern(config?: AuthConcernConfig): AuthConcern {
+  return new AuthConcern(config)
+}

package/src/worker/concerns/cdc-concern.ts

@@ -0,0 +1,247 @@
+/**
+ * CDC (Change Data Capture) Concern for PostgresDO decomposition
+ * @module worker/concerns/cdc-concern
+ */
+
+export interface ICDCConcern {
+  isEnabled(): boolean
+  setEnabled(enabled: boolean): void
+  captureChange(operation: {
+    sql: string
+    table: string
+    operation: 'INSERT' | 'UPDATE' | 'DELETE'
+    oldRow?: Record<string, unknown>
+    newRow?: Record<string, unknown>
+  }): { lsn: bigint; timestamp: number } | null
+  getCurrentLsn(): bigint
+  flush(): Promise<{ entriesFlushed: number; newLsn: bigint }>
+  readEntries(
+    fromLsn: bigint,
+    limit?: number
+  ): Promise<
+    Array<{
+      lsn: bigint
+      table: string
+      operation: string
+      timestamp: number
+    }>
+  >
+  onEntry(
+    listener: (entry: { lsn: bigint; table: string; operation: string }) => void
+  ): () => void
+}
+
+export interface CDCEntry {
+  lsn: bigint
+  table: string
+  operation: 'INSERT' | 'UPDATE' | 'DELETE'
+  timestamp: number
+  sql: string
+  oldRow?: Record<string, unknown>
+  newRow?: Record<string, unknown>
+}
+
+export interface CDCStorage {
+  get<T>(key: string): Promise<T | undefined>
+  put(key: string, value: unknown): Promise<void>
+  list<T>(options?: { prefix?: string; limit?: number }): Promise<Map<string, T>>
+}
+
+export interface CDCConcernConfig {
+  storage: CDCStorage
+  enabled?: boolean
+  maxBufferSize?: number
+  autoFlushIntervalMs?: number
+}
+
+export interface CDCFlushResult {
+  entriesFlushed: number
+  newLsn: bigint
+}
+
+export class CDCConcern implements ICDCConcern {
+  private config: CDCConcernConfig
+  private enabled: boolean
+  private currentLsn: bigint = 1n
+  private buffer: CDCEntry[] = []
+  private listeners: Set<(entry: { lsn: bigint; table: string; operation: string }) => void> =
+    new Set()
+
+  constructor(config: CDCConcernConfig) {
+    this.config = {
+      ...config,
+      maxBufferSize: config.maxBufferSize ?? 1000,
+      autoFlushIntervalMs: config.autoFlushIntervalMs ?? 0,
+    }
+    this.enabled = config.enabled ?? false
+  }
+
+  isEnabled(): boolean {
+    return this.enabled
+  }
+
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled
+  }
+
+  getCurrentLsn(): bigint {
+    return this.currentLsn
+  }
+
+  captureChange(operation: {
+    sql: string
+    table: string
+    operation: 'INSERT' | 'UPDATE' | 'DELETE'
+    oldRow?: Record<string, unknown>
+    newRow?: Record<string, unknown>
+  }): { lsn: bigint; timestamp: number } | null {
+    if (!this.enabled) {
+      return null
+    }
+
+    const lsn = this.currentLsn
+    const timestamp = Date.now()
+
+    // Build entry without undefined values for exactOptionalPropertyTypes
+    const entry: CDCEntry = {
+      lsn,
+      table: operation.table,
+      operation: operation.operation,
+      timestamp,
+      sql: operation.sql,
+    }
+    if (operation.oldRow !== undefined) {
+      entry.oldRow = operation.oldRow
+    }
+    if (operation.newRow !== undefined) {
+      entry.newRow = operation.newRow
+    }
+
+    this.buffer.push(entry)
+    this.currentLsn++
+
+    for (const listener of this.listeners) {
+      try {
+        listener({
+          lsn: entry.lsn,
+          table: entry.table,
+          operation: entry.operation,
+        })
+      } catch {
+        // Ignore listener errors
+      }
+    }
+
+    return { lsn, timestamp }
+  }
+
+  async flush(): Promise<CDCFlushResult> {
+    const entriesToFlush = [...this.buffer]
+    this.buffer = []
+
+    if (entriesToFlush.length === 0) {
+      return { entriesFlushed: 0, newLsn: this.currentLsn }
+    }
+
+    for (const entry of entriesToFlush) {
+      const key = `cdc:${entry.lsn.toString().padStart(20, '0')}`
+      await this.config.storage.put(key, {
+        lsn: entry.lsn.toString(),
+        table: entry.table,
+        operation: entry.operation,
+        timestamp: entry.timestamp,
+        sql: entry.sql,
+        oldRow: entry.oldRow,
+        newRow: entry.newRow,
+      })
+    }
+
+    await this.config.storage.put('cdc:lsn', this.currentLsn.toString())
+
+    return { entriesFlushed: entriesToFlush.length, newLsn: this.currentLsn }
+  }
+
+  async readEntries(
+    fromLsn: bigint,
+    limit?: number
+  ): Promise<
+    Array<{
+      lsn: bigint
+      table: string
+      operation: string
+      timestamp: number
+    }>
+  > {
+    const prefix = 'cdc:'
+    // Build options without undefined values for exactOptionalPropertyTypes
+    const listOptions: { prefix: string; limit?: number } = { prefix }
+    if (limit !== undefined) {
+      listOptions.limit = limit
+    }
+    const entries = await this.config.storage.list<{
+      lsn: string
+      table: string
+      operation: string
+      timestamp: number
+    }>(listOptions)
+
+    const result: Array<{
+      lsn: bigint
+      table: string
+      operation: string
+      timestamp: number
+    }> = []
+
+    for (const [key, value] of entries) {
+      if (key === 'cdc:lsn') continue
+
+      const entryLsn = BigInt(value.lsn)
+      if (entryLsn >= fromLsn) {
+        result.push({
+          lsn: entryLsn,
+          table: value.table,
+          operation: value.operation,
+          timestamp: value.timestamp,
+        })
+      }
+    }
+
+    result.sort((a, b) => (a.lsn < b.lsn ? -1 : a.lsn > b.lsn ? 1 : 0))
+
+    if (limit !== undefined && result.length > limit) {
+      return result.slice(0, limit)
+    }
+
+    return result
+  }
+
+  onEntry(
+    listener: (entry: { lsn: bigint; table: string; operation: string }) => void
+  ): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  getBufferedEntries(): CDCEntry[] {
+    return [...this.buffer]
+  }
+
+  clearBuffer(): number {
+    const count = this.buffer.length
+    this.buffer = []
+    return count
+  }
+
+  async initialize(): Promise<void> {
+    const storedLsn = await this.config.storage.get<string>('cdc:lsn')
+    if (storedLsn) {
+      this.currentLsn = BigInt(storedLsn)
+    }
+  }
+}
+
+export function createCDCConcern(config: CDCConcernConfig): CDCConcern {
+  return new CDCConcern(config)
+}

package/src/worker/concerns/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Concerns module for PostgresDO decomposition
+ * @module worker/concerns
+ */
+
+// Import types for use in ConcernsConfig
+import type { IAuthConcern as _IAuthConcern } from './auth-concern'
+import type { IQueryExecutionConcern as _IQueryExecutionConcern } from './query-execution-concern'
+import type { ICDCConcern as _ICDCConcern } from './cdc-concern'
+import type { IStorageOrchestrationConcern as _IStorageOrchestrationConcern } from './storage-orchestration-concern'
+
+// Auth Concern
+export {
+  AuthConcern,
+  createAuthConcern,
+  type IAuthConcern,
+  type AuthConcernConfig,
+} from './auth-concern'
+
+// Query Execution Concern
+export {
+  QueryExecutionConcern,
+  createQueryExecutionConcern,
+  type IQueryExecutionConcern,
+  type QueryExecutionConcernConfig,
+  type QueryPGliteLike,
+} from './query-execution-concern'
+
+// CDC (Change Data Capture) Concern
+export {
+  CDCConcern,
+  createCDCConcern,
+  type ICDCConcern,
+  type CDCConcernConfig,
+  type CDCEntry,
+  type CDCStorage,
+  type CDCFlushResult,
+} from './cdc-concern'
+
+// Storage Orchestration Concern
+export {
+  StorageOrchestrationConcern,
+  createStorageOrchestrationConcern,
+  type IStorageOrchestrationConcern,
+  type StorageOrchestrationConcernConfig,
+  type StorageLayer,
+  type StorageTier,
+} from './storage-orchestration-concern'
+
+/**
+ * Concerns configuration for PostgresDO
+ */
+export interface ConcernsConfig {
+  auth?: _IAuthConcern
+  queryExecution?: _IQueryExecutionConcern
+  cdc?: _ICDCConcern
+  storageOrchestration?: _IStorageOrchestrationConcern
+}

package/src/worker/concerns/query-execution-concern.ts

@@ -0,0 +1,194 @@
+/**
+ * Query Execution Concern for PostgresDO decomposition
+ * @module worker/concerns/query-execution-concern
+ */
+
+import { preserveCase } from '../sql-transform'
+
+export interface IQueryExecutionConcern {
+  executeQuery<T>(request: {
+    sql: string
+    params?: unknown[]
+    preserveCase?: boolean
+  }): Promise<{
+    rows: T[]
+    fields: { name: string; dataTypeID: number }[]
+    rowCount: number
+    durationMs: number
+  }>
+  executeBatch(request: {
+    queries: Array<{ sql: string; params?: unknown[] }>
+    transaction?: boolean
+  }): Promise<{
+    results: Array<{
+      rows: unknown[]
+      fields: { name: string; dataTypeID: number }[]
+      rowCount: number
+      durationMs: number
+    }>
+    durationMs: number
+  }>
+  getStats(): {
+    queryCount: number
+    successCount: number
+    errorCount: number
+    totalDurationMs: number
+    avgDurationMs: number
+  }
+}
+
+export interface QueryPGliteLike {
+  query<T = unknown>(
+    sql: string,
+    params?: unknown[]
+  ): Promise<{
+    rows: T[]
+    fields: { name: string; dataTypeID: number }[]
+    affectedRows?: number
+  }>
+}
+
+export interface QueryExecutionConcernConfig {
+  getPGlite: () => QueryPGliteLike
+  preserveCase?: boolean
+}
+
+interface QueryStats {
+  queryCount: number
+  successCount: number
+  errorCount: number
+  totalDurationMs: number
+}
+
+export class QueryExecutionConcern implements IQueryExecutionConcern {
+  private config: QueryExecutionConcernConfig
+  private stats: QueryStats = {
+    queryCount: 0,
+    successCount: 0,
+    errorCount: 0,
+    totalDurationMs: 0,
+  }
+
+  constructor(config: QueryExecutionConcernConfig) {
+    this.config = config
+  }
+
+  async executeQuery<T>(request: {
+    sql: string
+    params?: unknown[]
+    preserveCase?: boolean
+  }): Promise<{
+    rows: T[]
+    fields: { name: string; dataTypeID: number }[]
+    rowCount: number
+    durationMs: number
+  }> {
+    const startTime = performance.now()
+    this.stats.queryCount++
+
+    try {
+      let sql = request.sql
+      if (request.preserveCase ?? this.config.preserveCase) {
+        sql = preserveCase(sql)
+      }
+
+      const pglite = this.config.getPGlite()
+      const result = await pglite.query<T>(sql, request.params)
+      const durationMs = performance.now() - startTime
+
+      this.stats.successCount++
+      this.stats.totalDurationMs += durationMs
+
+      return {
+        rows: result.rows,
+        fields: result.fields,
+        rowCount: result.affectedRows ?? result.rows.length,
+        durationMs,
+      }
+    } catch (error) {
+      const durationMs = performance.now() - startTime
+      this.stats.errorCount++
+      this.stats.totalDurationMs += durationMs
+      throw error
+    }
+  }
+
+  async executeBatch(request: {
+    queries: Array<{ sql: string; params?: unknown[] }>
+    transaction?: boolean
+  }): Promise<{
+    results: Array<{
+      rows: unknown[]
+      fields: { name: string; dataTypeID: number }[]
+      rowCount: number
+      durationMs: number
+    }>
+    durationMs: number
+  }> {
+    const startTime = performance.now()
+    const results: Array<{
+      rows: unknown[]
+      fields: { name: string; dataTypeID: number }[]
+      rowCount: number
+      durationMs: number
+    }> = []
+    const pglite = this.config.getPGlite()
+
+    if (request.transaction) {
+      await pglite.query('BEGIN')
+      try {
+        for (const query of request.queries) {
+          const result = await this.executeQuery(query)
+          results.push(result)
+        }
+        await pglite.query('COMMIT')
+      } catch (error) {
+        await pglite.query('ROLLBACK')
+        throw error
+      }
+    } else {
+      for (const query of request.queries) {
+        const result = await this.executeQuery(query)
+        results.push(result)
+      }
+    }
+
+    const durationMs = performance.now() - startTime
+
+    return {
+      results,
+      durationMs,
+    }
+  }
+
+  getStats(): {
+    queryCount: number
+    successCount: number
+    errorCount: number
+    totalDurationMs: number
+    avgDurationMs: number
+  } {
+    return {
+      queryCount: this.stats.queryCount,
+      successCount: this.stats.successCount,
+      errorCount: this.stats.errorCount,
+      totalDurationMs: this.stats.totalDurationMs,
+      avgDurationMs: this.stats.queryCount > 0 ? this.stats.totalDurationMs / this.stats.queryCount : 0,
+    }
+  }
+
+  resetStats(): void {
+    this.stats = {
+      queryCount: 0,
+      successCount: 0,
+      errorCount: 0,
+      totalDurationMs: 0,
+    }
+  }
+}
+
+export function createQueryExecutionConcern(
+  config: QueryExecutionConcernConfig
+): QueryExecutionConcern {
+  return new QueryExecutionConcern(config)
+}