@env-hopper/backend-core 2.0.1-alpha.2 → 2.0.1-alpha.4

package/src/middleware/types.ts

@@ -0,0 +1,186 @@
+import type { Router } from 'express'
+import type { LanguageModel, Tool } from 'ai'
+import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth'
+import type { EhBackendCompanySpecificBackend } from '../types/backend/companySpecificBackend'
+import type { BetterAuth } from '../modules/auth/auth'
+import type { TRPCRouter } from '../server/controller'
+
+/**
+ * Database connection configuration.
+ * Supports both connection URL and structured config.
+ */
+export type EhDatabaseConfig =
+  | { url: string }
+  | {
+      host: string
+      port: number
+      database: string
+      username: string
+      password: string
+      schema?: string
+    }
+
+/**
+ * Auth configuration for Better Auth integration.
+ */
+export interface EhAuthConfig {
+  /** Base URL for auth callbacks (e.g., 'http://localhost:4000') */
+  baseURL: string
+  /** Secret for signing sessions (min 32 chars in production) */
+  secret: string
+  /** OAuth providers configuration */
+  providers?: BetterAuthOptions['socialProviders']
+  /** Additional Better Auth plugins (e.g., Okta) */
+  plugins?: Array<BetterAuthPlugin>
+  /** Session expiration in seconds (default: 30 days) */
+  sessionExpiresIn?: number
+  /** Session refresh threshold in seconds (default: 1 day) */
+  sessionUpdateAge?: number
+  /** Application name shown in auth UI */
+  appName?: string
+}
+
+/**
+ * Admin chat (AI) configuration.
+ * When provided, enables the admin/chat endpoint.
+ */
+export interface EhAdminChatConfig {
+  /** AI model instance from @ai-sdk/* packages */
+  model: LanguageModel
+  /** System prompt for the AI assistant */
+  systemPrompt?: string
+  /** Custom tools available to the AI */
+  tools?: Record<string, Tool>
+  /** Validation function called before each request */
+  validateConfig?: () => void
+}
+
+/**
+ * Feature toggles for enabling/disabling specific functionality.
+ * All features are enabled by default.
+ */
+export interface EhFeatureToggles {
+  /** Enable tRPC endpoints (default: true) */
+  trpc?: boolean
+  /** Enable auth endpoints (default: true) */
+  auth?: boolean
+  /** Enable icon REST endpoints (default: true) */
+  icons?: boolean
+  /** Enable asset REST endpoints (default: true) */
+  assets?: boolean
+  /** Enable screenshot REST endpoints (default: true) */
+  screenshots?: boolean
+  /** Enable admin chat endpoint (default: true if adminChat config provided) */
+  adminChat?: boolean
+  /** Enable legacy icon endpoint at /static/icon/:icon (default: false) */
+  legacyIconEndpoint?: boolean
+  /** Enable catalog backup/restore endpoints (default: true) */
+  catalogBackup?: boolean
+}
+
+/**
+ * Company-specific backend can be provided as:
+ * 1. Direct object implementing the interface
+ * 2. Factory function called per-request (for DI integration)
+ * 3. Async factory function
+ */
+export type EhBackendProvider =
+  | EhBackendCompanySpecificBackend
+  | (() => EhBackendCompanySpecificBackend)
+  | (() => Promise<EhBackendCompanySpecificBackend>)
+
+/**
+ * Lifecycle hooks for database and middleware events.
+ */
+export interface EhLifecycleHooks {
+  /** Called after database connection is established */
+  onDatabaseConnected?: () => void | Promise<void>
+  /** Called before database disconnection (for cleanup) */
+  onDatabaseDisconnecting?: () => void | Promise<void>
+  /** Called after all routes are registered - use to add custom routes */
+  onRoutesRegistered?: (router: Router) => void | Promise<void>
+  /** Custom error handler for middleware errors */
+  onError?: (error: Error, context: { path: string }) => void
+}
+
+/**
+ * Main configuration options for the env-hopper middleware.
+ */
+export interface EhMiddlewareOptions {
+  /**
+   * Base path prefix for all routes (default: '/api')
+   * - tRPC: {basePath}/trpc
+   * - Auth: {basePath}/auth (note: auth basePath is hardcoded, this affects where router mounts)
+   * - Icons: {basePath}/icons
+   * - Assets: {basePath}/assets
+   * - Screenshots: {basePath}/screenshots
+   * - Admin Chat: {basePath}/admin/chat
+   */
+  basePath?: string
+
+  /**
+   * Database connection configuration (required).
+   * Backend-core manages the database for all features.
+   */
+  database: EhDatabaseConfig
+
+  /** Auth configuration (required) */
+  auth: EhAuthConfig
+
+  /** Company-specific backend implementation (required) */
+  backend: EhBackendProvider
+
+  /** AI admin chat configuration (optional) */
+  adminChat?: EhAdminChatConfig
+
+  /** Feature toggles (all enabled by default) */
+  features?: EhFeatureToggles
+
+  /** Lifecycle hooks */
+  hooks?: EhLifecycleHooks
+}
+
+/**
+ * Result of middleware initialization.
+ *
+ * @example
+ * ```typescript
+ * const eh = await createEhMiddleware({ ... })
+ *
+ * // Mount routes
+ * app.use(eh.router)
+ *
+ * // Connect to database
+ * await eh.connect()
+ *
+ * // Cleanup on shutdown
+ * process.on('SIGTERM', async () => {
+ *   await eh.disconnect()
+ * })
+ * ```
+ */
+export interface EhMiddlewareResult {
+  /** Express router with all env-hopper routes */
+  router: Router
+  /** Better Auth instance (for extending auth functionality) */
+  auth: BetterAuth
+  /** tRPC router (for extending with custom procedures) */
+  trpcRouter: TRPCRouter
+  /** Connect to database (call during app startup) */
+  connect: () => Promise<void>
+  /** Disconnect from database (call during app shutdown) */
+  disconnect: () => Promise<void>
+  /** Add custom routes to the middleware router */
+  addRoutes: (callback: (router: Router) => void) => void
+}
+
+/**
+ * Internal context passed to feature registration functions.
+ */
+export interface MiddlewareContext {
+  auth: BetterAuth
+  trpcRouter: TRPCRouter
+  createContext: () => Promise<{
+    companySpecificBackend: EhBackendCompanySpecificBackend
+  }>
+}

package/src/modules/appCatalogAdmin/catalogBackupController.ts

@@ -0,0 +1,182 @@
+import type { Request, Response } from 'express'
+import { getDbClient } from '../../db'
+
+/**
+ * Export the complete app catalog as JSON
+ * Includes all fields from DbAppForCatalog
+ */
+export async function exportCatalog(
+  _req: Request,
+  res: Response,
+): Promise<void> {
+  try {
+    const prisma = getDbClient()
+
+    // Fetch all catalog entries
+    const apps = await prisma.dbAppForCatalog.findMany({
+      orderBy: { slug: 'asc' },
+    })
+
+    res.json({
+      version: '1.0',
+      exportDate: new Date().toISOString(),
+      apps,
+    })
+  } catch (error) {
+    console.error('Error exporting catalog:', error)
+    res.status(500).json({ error: 'Failed to export catalog' })
+  }
+}
+
+/**
+ * Import/restore the complete app catalog from JSON
+ * Overwrites existing data
+ */
+export async function importCatalog(
+  req: Request,
+  res: Response,
+): Promise<void> {
+  try {
+    const prisma = getDbClient()
+    const { apps } = req.body
+
+    if (!Array.isArray(apps)) {
+      res
+        .status(400)
+        .json({ error: 'Invalid data format: apps must be an array' })
+      return
+    }
+
+    // Use transaction to ensure atomicity
+    await prisma.$transaction(async (tx) => {
+      // Delete all existing catalog entries
+      await tx.dbAppForCatalog.deleteMany({})
+
+      // Insert new entries
+      for (const app of apps) {
+        // Remove id, createdAt, updatedAt to let Prisma generate new ones
+        const { id, createdAt, updatedAt, ...appData } = app
+
+        await tx.dbAppForCatalog.create({
+          data: appData,
+        })
+      }
+    })
+
+    res.json({ success: true, imported: apps.length })
+  } catch (error) {
+    console.error('Error importing catalog:', error)
+    res.status(500).json({ error: 'Failed to import catalog' })
+  }
+}
+
+/**
+ * Export an asset (icon or screenshot) by name
+ */
+export async function exportAsset(req: Request, res: Response): Promise<void> {
+  try {
+    const { name } = req.params
+    const prisma = getDbClient()
+
+    const asset = await prisma.dbAsset.findUnique({
+      where: { name },
+    })
+
+    if (!asset) {
+      res.status(404).json({ error: 'Asset not found' })
+      return
+    }
+
+    // Set appropriate content type and send binary data
+    res.set('Content-Type', asset.mimeType)
+    res.set('Content-Disposition', `attachment; filename="${name}"`)
+    res.send(Buffer.from(asset.content))
+  } catch (error) {
+    console.error('Error exporting asset:', error)
+    res.status(500).json({ error: 'Failed to export asset' })
+  }
+}
+
+/**
+ * List all assets with metadata
+ */
+export async function listAssets(_req: Request, res: Response): Promise<void> {
+  try {
+    const prisma = getDbClient()
+
+    const assets = await prisma.dbAsset.findMany({
+      select: {
+        id: true,
+        name: true,
+        assetType: true,
+        mimeType: true,
+        fileSize: true,
+        width: true,
+        height: true,
+        checksum: true,
+      },
+      orderBy: { name: 'asc' },
+    })
+
+    res.json({ assets })
+  } catch (error) {
+    console.error('Error listing assets:', error)
+    res.status(500).json({ error: 'Failed to list assets' })
+  }
+}
+
+/**
+ * Import an asset (icon or screenshot)
+ */
+export async function importAsset(req: Request, res: Response): Promise<void> {
+  try {
+    const file = req.file
+    const { name, assetType, mimeType, width, height } = req.body
+
+    if (!file) {
+      res.status(400).json({ error: 'No file uploaded' })
+      return
+    }
+
+    const prisma = getDbClient()
+    const crypto = await import('node:crypto')
+
+    // Calculate checksum
+    const checksum = crypto
+      .createHash('sha256')
+      .update(file.buffer)
+      .digest('hex')
+
+    // Convert Buffer to Uint8Array for Prisma Bytes type
+    const content = new Uint8Array(file.buffer)
+
+    // Upsert asset (update if exists, create if not)
+    await prisma.dbAsset.upsert({
+      where: { name },
+      update: {
+        content,
+        checksum,
+        mimeType: mimeType || file.mimetype,
+        fileSize: file.size,
+        width: width ? parseInt(width) : null,
+        height: height ? parseInt(height) : null,
+        assetType: assetType || 'icon',
+      },
+      create: {
+        name,
+        content,
+        checksum,
+        mimeType: mimeType || file.mimetype,
+        fileSize: file.size,
+        width: width ? parseInt(width) : null,
+        height: height ? parseInt(height) : null,
+        assetType: assetType || 'icon',
+      },
+    })
+
+    res.json({ success: true, name, size: file.size })
+  } catch (error) {
+    console.error('Error importing asset:', error)
+    res.status(500).json({ error: 'Failed to import asset' })
+  }
+}