@env-hopper/backend-core 2.0.1-alpha → 2.0.1-alpha.1

package/src/db/syncAppCatalog.ts

@@ -0,0 +1,67 @@
+import type { AppForCatalog } from '../types/common/appCatalogTypes'
+import { getDbClient } from './client'
+import { TABLE_SYNC_MAGAZINE } from './tableSyncMagazine'
+import { tableSyncPrisma } from './tableSyncPrismaAdapter'
+
+export interface SyncAppCatalogResult {
+  created: number
+  updated: number
+  deleted: number
+  total: number
+}
+
+/**
+ * Syncs app catalog data to the database using table sync.
+ * This will create new apps, update existing ones, and delete any that are no longer in the input.
+ *
+ * Note: Call connectDb() before and disconnectDb() after if running in a script.
+ */
+export async function syncAppCatalog(
+  apps: Array<AppForCatalog>,
+): Promise<SyncAppCatalogResult> {
+  const prisma = getDbClient()
+
+  const sync = tableSyncPrisma({
+    prisma,
+    ...TABLE_SYNC_MAGAZINE.DbAppForCatalog,
+  })
+
+  // Transform AppForCatalog to DbAppForCatalog format
+  const dbApps = apps.map((app) => {
+    const slug =
+      app.slug ||
+      app.displayName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+
+    return {
+      slug,
+      displayName: app.displayName,
+      description: app.description,
+      access: app.access,
+      teams: app.teams ?? [],
+      roles: app.roles ?? null,
+      approverName: app.approver?.name ?? null,
+      approverEmail: app.approver?.email ?? null,
+      notes: app.notes ?? null,
+      tags: app.tags ?? [],
+      appUrl: app.appUrl ?? null,
+      links: app.links ?? null,
+      iconName: app.iconName ?? null,
+      screenshotIds: app.screenshotIds ?? [],
+    }
+  })
+
+  const result = await sync.sync(dbApps)
+
+  // Get actual synced data to calculate stats
+  const actual = result.getActual()
+
+  return {
+    created: actual.length - apps.length + (apps.length - actual.length),
+    updated: 0, // TableSync doesn't expose this directly
+    deleted: 0, // TableSync doesn't expose this directly
+    total: actual.length,
+  }
+}

package/src/db/tableSyncMagazine.ts

@@ -0,0 +1,22 @@
+import type { Prisma } from '@prisma/client'
+import type { ObjectKeys, ScalarKeys } from './tableSyncPrismaAdapter'
+
+interface CommonSyncTableInfo<TPrismaModelName extends Prisma.ModelName> {
+  prismaModelName: TPrismaModelName
+  uniqColumns: Array<ScalarKeys<TPrismaModelName>>
+  relationColumns?: Array<ObjectKeys<TPrismaModelName>>
+}
+
+type TableSyncMagazineType = Partial<{
+  [key in Prisma.ModelName]: CommonSyncTableInfo<key>
+}>
+
+export const TABLE_SYNC_MAGAZINE = {
+  DbAppForCatalog: {
+    prismaModelName: 'DbAppForCatalog',
+    uniqColumns: ['slug'],
+  },
+} as const satisfies TableSyncMagazineType
+
+export type TableSyncMagazine = typeof TABLE_SYNC_MAGAZINE
+export type TableSyncMagazineModelNameKey = keyof TableSyncMagazine

package/src/db/tableSyncPrismaAdapter.ts

@@ -0,0 +1,202 @@
+import { tableSync } from '@env-hopper/table-sync'
+import type { Prisma, PrismaClient } from '@prisma/client'
+import type * as runtime from '@prisma/client/runtime/library'
+import { mapValues, omit, pick } from 'radashi'
+
+export type ScalarKeys<TPrismaModelName extends Prisma.ModelName> =
+  keyof Prisma.TypeMap['model'][TPrismaModelName]['payload']['scalars']
+export type ObjectKeys<TPrismaModelName extends Prisma.ModelName> =
+  keyof Prisma.TypeMap['model'][TPrismaModelName]['payload']['objects']
+
+export type ScalarFilter<TPrismaModelName extends Prisma.ModelName> = Partial<
+  Prisma.TypeMap['model'][TPrismaModelName]['payload']['scalars']
+>
+
+export type GetOperationFns<TModel extends Prisma.ModelName> = {
+  [TOperation in keyof Prisma.TypeMap['model']['DbAppForCatalog']['operations']]: (
+    args: Prisma.TypeMap['model'][TModel]['operations'][TOperation]['args'],
+  ) => Promise<
+    Prisma.TypeMap['model'][TModel]['operations'][TOperation]['result']
+  >
+}
+
+export interface TableSyncParamsPrisma<
+  TPrismaClient extends PrismaClient,
+  TPrismaModelName extends Prisma.ModelName,
+  TUniqColumns extends ReadonlyArray<ScalarKeys<TPrismaModelName>>,
+  TRelationColumns extends ReadonlyArray<ObjectKeys<TPrismaModelName>>,
+> {
+  prisma: TPrismaClient
+  prismaModelName: TPrismaModelName
+  uniqColumns: TUniqColumns
+  relationColumns?: TRelationColumns
+  where?: ScalarFilter<TPrismaModelName>
+  upsertOnly?: boolean
+}
+
+function getPrismaModelOperations<
+  TPrismaClient extends Omit<PrismaClient, runtime.ITXClientDenyList>,
+  TPrismaModelName extends Prisma.ModelName,
+>(prisma: TPrismaClient, prismaModelName: TPrismaModelName) {
+  const key = (prismaModelName.slice(0, 1).toLowerCase() +
+    prismaModelName.slice(1)) as keyof TPrismaClient
+  return prisma[key] as GetOperationFns<TPrismaModelName>
+}
+
+export type MakeTFromPrismaModel<TPrismaModelName extends Prisma.ModelName> =
+  NonNullable<
+    Prisma.TypeMap['model'][TPrismaModelName]['operations']['findUnique']['result']
+  >
+
+export function tableSyncPrisma<
+  TPrismaClient extends PrismaClient,
+  TPrismaModelName extends Prisma.ModelName,
+  TUniqColumns extends ReadonlyArray<ScalarKeys<TPrismaModelName>>,
+  TRelationColumns extends ReadonlyArray<ObjectKeys<TPrismaModelName>>,
+  TId extends ScalarKeys<TPrismaModelName> & (string | number) = 'id',
+>(
+  params: TableSyncParamsPrisma<
+    TPrismaClient,
+    TPrismaModelName,
+    TUniqColumns,
+    TRelationColumns
+  >,
+) {
+  const {
+    prisma,
+    prismaModelName,
+    uniqColumns,
+    where: whereGlobal,
+    upsertOnly,
+  } = params
+  const prismOperations = getPrismaModelOperations(prisma, prismaModelName)
+
+  // @ts-expect-error This is too difficult for me to come up with right types
+  return tableSync<MakeTFromPrismaModel<TPrismaModelName>, TUniqColumns, TId>({
+    id: 'id' as TId,
+    uniqColumns,
+    readAll: async () => {
+      const findManyArgs = whereGlobal
+        ? {
+            where: whereGlobal,
+          }
+        : {}
+      return (await prismOperations.findMany(findManyArgs)) as Array<
+        MakeTFromPrismaModel<TPrismaModelName>
+      >
+    },
+    writeAll: async (createData, update, deleteIds) => {
+      const prismaUniqKey = params.uniqColumns.join('_')
+      const relationColumnList =
+        params.relationColumns ?? ([] as Array<ObjectKeys<TPrismaModelName>>)
+
+      return prisma.$transaction(async (tx) => {
+        const txOps = getPrismaModelOperations(tx, prismaModelName)
+        for (const { data, where } of update) {
+          const uniqKeyWhere =
+            Object.keys(where).length > 1
+              ? {
+                  [prismaUniqKey]: where,
+                }
+              : where
+
+          const dataScalar = omit(data, relationColumnList)
+          const dataRelations = mapValues(
+            pick(data, relationColumnList),
+            (value) => {
+              return {
+                set: value,
+              }
+            },
+          )
+
+          // @ts-expect-error This is too difficult for me to come up with right types
+          await txOps.update({
+            data: { ...dataScalar, ...dataRelations },
+            where: { ...uniqKeyWhere },
+          })
+        }
+
+        if (upsertOnly !== true) {
+          // @ts-expect-error This is too difficult for me to come up with right types
+          await txOps.deleteMany({
+            where: {
+              id: {
+                in: deleteIds,
+              },
+            },
+          })
+        }
+
+        // Validate uniqueness of uniqColumns before creating records
+        const createDataMapped = createData.map((data) => {
+          // @ts-expect-error This is too difficult for me to come up with right types
+          const dataScalar = omit(data, relationColumnList)
+
+          // @ts-expect-error This is too difficult for me to come up with right types
+          const onlyRelationColumns = pick(data, relationColumnList)
+          const dataRelations = mapValues(onlyRelationColumns, (value) => {
+            return {
+              connect: value,
+            }
+          })
+
+          return { ...dataScalar, ...dataRelations }
+        })
+
+        // Check for duplicates in the data to be created
+        if (createDataMapped.length > 0) {
+          const uniqKeysInCreate = new Set<string>()
+          const duplicateKeys: Array<string> = []
+
+          for (const data of createDataMapped) {
+            const keyParts = params.uniqColumns.map((col) => {
+              const value = data[col as keyof typeof data]
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive: unique columns may be nullable in schemas
+              return value === null || value === undefined
+                ? 'null'
+                : String(value)
+            })
+            const key = keyParts.join(':')
+
+            if (uniqKeysInCreate.has(key)) {
+              duplicateKeys.push(key)
+            } else {
+              uniqKeysInCreate.add(key)
+            }
+          }
+
+          if (duplicateKeys.length > 0) {
+            const uniqColumnsStr = params.uniqColumns.join(', ')
+            throw new Error(
+              `Duplicate unique key values found in data to be created. ` +
+                `Model: ${prismaModelName}, Unique columns: [${uniqColumnsStr}], ` +
+                `Duplicate keys: [${duplicateKeys.join(', ')}]`,
+            )
+          }
+        }
+
+        const results: Array<MakeTFromPrismaModel<TPrismaModelName>> = []
+
+        if (relationColumnList.length === 0) {
+          // @ts-expect-error This is too difficult for me to come up with right types
+          const batchResult = await txOps.createManyAndReturn({
+            data: createDataMapped,
+          })
+
+          results.push(...batchResult)
+        } else {
+          for (const dataMappedElement of createDataMapped) {
+            // @ts-expect-error too difficult for me
+            const newVar = await txOps.create({
+              data: dataMappedElement,
+            })
+            results.push(newVar as MakeTFromPrismaModel<TPrismaModelName>)
+          }
+        }
+
+        return results
+      })
+    },
+  })
+}

package/src/index.ts

@@ -1,11 +1,11 @@
 // common
 
-export { trpcRouter } from './server/controller'
+export { createTrpcRouter } from './server/controller'
 export type { TRPCRouter } from './server/controller'
 export { createEhTrpcContext } from './server/ehTrpcContext'
 export type {
-  EhTrpcContext,
-  EhTrpcContextOptions,
+    EhTrpcContext,
+    EhTrpcContextOptions
 } from './server/ehTrpcContext'
 
 export { staticControllerContract } from './server/ehStaticControllerContract'
@@ -15,4 +15,97 @@ export type { EhStaticControllerContract } from './server/ehStaticControllerCont
 
 // backend-only
 
+export type { AppForCatalog } from './types/common/appCatalogTypes'
 export * from './types/index'
+
+// Auth
+export {
+    createAuth,
+    type AuthConfig,
+    type BetterAuth
+} from './modules/auth/auth'
+
+export {
+    registerAuthRoutes
+} from './modules/auth/registerAuthRoutes'
+
+export {
+    createAuthRouter,
+    type AuthRouter
+} from './modules/auth/authRouter'
+
+export {
+    getAuthProvidersFromEnv,
+    getAuthPluginsFromEnv,
+    validateAuthConfig
+} from './modules/auth/authProviders'
+
+export {
+    getUserGroups,
+    isMemberOfAnyGroup,
+    isMemberOfAllGroups,
+    getAdminGroupsFromEnv,
+    isAdmin,
+    requireAdmin,
+    requireGroups,
+    type UserWithGroups
+} from './modules/auth/authorizationUtils'
+
+// Admin
+export {
+    createAdminChatHandler,
+    tool,
+    type AdminChatHandlerOptions
+} from './modules/admin/chat/createAdminChatHandler'
+
+export {
+    createDatabaseTools,
+    createPrismaDatabaseClient, DEFAULT_ADMIN_SYSTEM_PROMPT, type DatabaseClient
+} from './modules/admin/chat/createDatabaseTools'
+
+// Icon management
+export {
+    registerIconRestController,
+    type IconRestControllerConfig
+} from './modules/icons/iconRestController'
+
+export {
+    getAssetByName,
+    upsertIcon,
+    upsertIcons,
+    type UpsertIconInput
+} from './modules/icons/iconService'
+
+// Asset management (universal for icons, screenshots, etc.)
+export {
+    registerAssetRestController,
+    type AssetRestControllerConfig
+} from './modules/assets/assetRestController'
+
+export {
+    registerScreenshotRestController,
+    type ScreenshotRestControllerConfig
+} from './modules/assets/screenshotRestController'
+
+export {
+    createScreenshotRouter
+} from './modules/assets/screenshotRouter'
+
+export {
+    syncAssets,
+    type SyncAssetsConfig
+} from './modules/assets/syncAssets'
+
+// App Catalog Admin
+export {
+    createAppCatalogAdminRouter
+} from './modules/appCatalogAdmin/appCatalogAdminRouter'
+
+// Database utilities
+export {
+    connectDb,
+    disconnectDb, getDbClient, syncAppCatalog, TABLE_SYNC_MAGAZINE, tableSyncPrisma, type MakeTFromPrismaModel, type ObjectKeys,
+    type ScalarFilter, type ScalarKeys, type SyncAppCatalogResult, type TableSyncMagazine,
+    type TableSyncMagazineModelNameKey, type TableSyncParamsPrisma
+} from './db'
+

package/src/modules/admin/chat/createAdminChatHandler.ts

@@ -0,0 +1,152 @@
+import { stepCountIs, streamText, tool } from 'ai'
+import type { LanguageModel, Tool } from 'ai'
+
+import type { Request, Response } from 'express'
+
+export interface AdminChatHandlerOptions {
+  /** The AI model to use (from @ai-sdk/openai, @ai-sdk/anthropic, etc.) */
+  model: LanguageModel
+  /** System prompt for the AI assistant */
+  systemPrompt?: string
+  /** Tools available to the AI assistant */
+  tools?: Record<string, Tool>
+  /**
+   * Optional function to validate configuration before processing requests.
+   * Should throw an error if configuration is invalid (e.g., missing API key).
+   * @example
+   * validateConfig: () => {
+   *   if (!process.env.OPENAI_API_KEY) {
+   *     throw new Error('OPENAI_API_KEY is not configured')
+   *   }
+   * }
+   */
+  validateConfig?: () => void
+}
+
+interface TextPart {
+  type: 'text'
+  text: string
+}
+
+interface UIMessageInput {
+  role: 'user' | 'assistant' | 'system'
+  content?: string
+  parts?: Array<TextPart | { type: string }>
+}
+
+interface CoreMessage {
+  role: 'user' | 'assistant' | 'system'
+  content: string
+}
+
+function convertToCoreMessages(
+  messages: Array<UIMessageInput>,
+): Array<CoreMessage> {
+  return messages.map((msg) => {
+    if (msg.content) {
+      return { role: msg.role, content: msg.content }
+    }
+    // Extract text from parts array (AI SDK v3 format)
+    const textContent =
+      msg.parts
+        ?.filter((part): part is TextPart => part.type === 'text')
+        .map((part) => part.text)
+        .join('') ?? ''
+    return { role: msg.role, content: textContent }
+  })
+}
+
+/**
+ * Creates an Express handler for the admin chat endpoint.
+ *
+ * Usage in thin wrappers:
+ *
+ * ```typescript
+ * // With OpenAI
+ * import { openai } from '@ai-sdk/openai'
+ * app.post('/api/admin/chat', createAdminChatHandler({
+ *   model: openai('gpt-4o-mini'),
+ * }))
+ *
+ * // With Claude
+ * import { anthropic } from '@ai-sdk/anthropic'
+ * app.post('/api/admin/chat', createAdminChatHandler({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ * }))
+ * ```
+ */
+export function createAdminChatHandler(options: AdminChatHandlerOptions) {
+  const {
+    model,
+    systemPrompt = 'You are a helpful admin assistant for the Env Hopper application. Help users manage apps, data sources, and MCP server configurations.',
+    tools = {},
+    validateConfig,
+  } = options
+
+  return async (req: Request, res: Response) => {
+    try {
+      // Validate configuration if validator provided
+      if (validateConfig) {
+        validateConfig()
+      }
+
+      const { messages } = req.body as { messages: Array<UIMessageInput> }
+      const coreMessages = convertToCoreMessages(messages)
+
+      console.log(
+        '[Admin Chat] Received messages:',
+        JSON.stringify(coreMessages, null, 2),
+      )
+      console.log('[Admin Chat] Available tools:', Object.keys(tools))
+
+      const result = streamText({
+        model,
+        system: systemPrompt,
+        messages: coreMessages,
+        tools,
+        // Allow up to 5 steps so the model can call tools and then generate a response
+        stopWhen: stepCountIs(5),
+        onFinish: (event) => {
+          console.log('[Admin Chat] Finished:', {
+            finishReason: event.finishReason,
+            usage: event.usage,
+            hasText: !!event.text,
+            textLength: event.text.length,
+          })
+        },
+      })
+
+      // Use UI message stream response which is compatible with AI SDK React hooks
+      const response = result.toUIMessageStreamResponse()
+
+      // Copy headers from the response
+      response.headers.forEach((value, key) => {
+        res.setHeader(key, value)
+      })
+
+      // Pipe the stream to the response
+      if (response.body) {
+        const reader = response.body.getReader()
+        const pump = async (): Promise<void> => {
+          const { done, value } = await reader.read()
+          if (done) {
+            res.end()
+            return
+          }
+          res.write(value)
+          return pump()
+        }
+        await pump()
+      } else {
+        console.error('[Admin Chat] No response body')
+        res.status(500).json({ error: 'No response from AI model' })
+      }
+    } catch (error) {
+      console.error('[Admin Chat] Error:', error)
+      res.status(500).json({ error: 'Failed to process chat request' })
+    }
+  }
+}
+
+// Re-export tool helper for convenience
+export { tool }