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

package/src/modules/icons/iconRestController.ts

@@ -0,0 +1,190 @@
+import type { Request, Response, Router } from 'express'
+import multer from 'multer'
+import { createHash } from 'node:crypto'
+import { getDbClient } from '../../db'
+
+// Configure multer for memory storage
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 10 * 1024 * 1024, // 10MB limit
+  },
+  fileFilter: (_req, file, cb) => {
+    // Accept images only
+    if (!file.mimetype.startsWith('image/')) {
+      cb(new Error('Only image files are allowed'))
+      return
+    }
+    cb(null, true)
+  },
+})
+
+export interface IconRestControllerConfig {
+  /**
+   * Base path for icon endpoints (e.g., '/api/icons')
+   */
+  basePath: string
+}
+
+/**
+ * Registers REST endpoints for icon upload and retrieval
+ *
+ * Endpoints:
+ * - POST {basePath}/upload - Upload a new icon (multipart/form-data with 'icon' field and 'name' field)
+ * - GET {basePath}/:id - Get icon binary by ID
+ * - GET {basePath}/:id/metadata - Get icon metadata only
+ */
+export function registerIconRestController(
+  router: Router,
+  config: IconRestControllerConfig,
+): void {
+  const { basePath } = config
+
+  // Upload endpoint - accepts multipart/form-data
+  router.post(
+    `${basePath}/upload`,
+    upload.single('icon'),
+    async (req: Request, res: Response) => {
+      try {
+        if (!req.file) {
+          res.status(400).json({ error: 'No file uploaded' })
+          return
+        }
+
+        const name = req.body['name'] as string
+        if (!name) {
+          res.status(400).json({ error: 'Name is required' })
+          return
+        }
+
+        const prisma = getDbClient()
+        const checksum = createHash('sha256')
+          .update(req.file.buffer)
+          .digest('hex')
+        const icon = await prisma.dbAsset.create({
+          data: {
+            name,
+            assetType: 'icon',
+            content: new Uint8Array(req.file.buffer),
+            mimeType: req.file.mimetype,
+            fileSize: req.file.size,
+            checksum,
+          },
+        })
+
+        res.status(201).json({
+          id: icon.id,
+          name: icon.name,
+          mimeType: icon.mimeType,
+          fileSize: icon.fileSize,
+          createdAt: icon.createdAt,
+        })
+      } catch (error) {
+        console.error('Error uploading icon:', error)
+        res.status(500).json({ error: 'Failed to upload icon' })
+      }
+    },
+  )
+
+  // Get icon binary by ID
+  router.get(`${basePath}/:id`, async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params
+
+      const prisma = getDbClient()
+      const icon = await prisma.dbAsset.findUnique({
+        where: { id },
+        select: {
+          content: true,
+          mimeType: true,
+          name: true,
+        },
+      })
+
+      if (!icon) {
+        res.status(404).json({ error: 'Icon not found' })
+        return
+      }
+
+      // Set appropriate headers
+      res.setHeader('Content-Type', icon.mimeType)
+      res.setHeader('Content-Disposition', `inline; filename="${icon.name}"`)
+      res.setHeader('Cache-Control', 'public, max-age=86400') // Cache for 1 day
+
+      // Send binary content
+      res.send(icon.content)
+    } catch (error) {
+      console.error('Error fetching icon:', error)
+      res.status(500).json({ error: 'Failed to fetch icon' })
+    }
+  })
+
+  // Get icon metadata only (no binary content)
+  router.get(
+    `${basePath}/:id/metadata`,
+    async (req: Request, res: Response) => {
+      try {
+        const { id } = req.params
+
+        const prisma = getDbClient()
+        const icon = await prisma.dbAsset.findUnique({
+          where: { id },
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            fileSize: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+
+        if (!icon) {
+          res.status(404).json({ error: 'Icon not found' })
+          return
+        }
+
+        res.json(icon)
+      } catch (error) {
+        console.error('Error fetching icon metadata:', error)
+        res.status(500).json({ error: 'Failed to fetch icon metadata' })
+      }
+    },
+  )
+
+  // Get icon binary by name
+  router.get(
+    `${basePath}/by-name/:name`,
+    async (req: Request, res: Response) => {
+      try {
+        const { name } = req.params
+
+        const prisma = getDbClient()
+        const icon = await prisma.dbAsset.findUnique({
+          where: { name },
+          select: {
+            content: true,
+            mimeType: true,
+            name: true,
+          },
+        })
+
+        if (!icon) {
+          res.status(404).json({ error: 'Icon not found' })
+          return
+        }
+
+        // Set appropriate headers
+        res.setHeader('Content-Type', icon.mimeType)
+        res.setHeader('Content-Disposition', `inline; filename="${icon.name}"`)
+        res.setHeader('Cache-Control', 'public, max-age=86400') // Cache for 1 day
+
+        // Send binary content
+        res.send(icon.content)
+      } catch (error) {
+        console.error('Error fetching icon by name:', error)
+        res.status(500).json({ error: 'Failed to fetch icon' })
+      }
+    },
+  )
+}

package/src/modules/icons/iconRouter.ts

@@ -0,0 +1,157 @@
+import type { TRPCRootObject } from '@trpc/server'
+import { z } from 'zod'
+import { getDbClient } from '../../db'
+import type { EhTrpcContext } from '../../server/ehTrpcContext'
+import { generateChecksum, getImageDimensions } from '../assets/assetUtils'
+
+export function createIconRouter(t: TRPCRootObject<EhTrpcContext, {}, {}>) {
+  const router = t.router
+  const publicProcedure = t.procedure
+
+  return router({
+  list: publicProcedure.query(async () => {
+    const prisma = getDbClient()
+    return prisma.dbAsset.findMany({
+      where: { assetType: 'icon' },
+      select: {
+        id: true,
+        name: true,
+        mimeType: true,
+        fileSize: true,
+        createdAt: true,
+        updatedAt: true,
+      },
+      orderBy: { name: 'asc' },
+    })
+  }),
+
+  getOne: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input }) => {
+      const prisma = getDbClient()
+      return prisma.dbAsset.findFirst({
+        where: {
+          id: input.id,
+          assetType: 'icon',
+        },
+      })
+    }),
+
+  create: publicProcedure
+    .input(
+      z.object({
+        name: z.string().min(1),
+        content: z.string(), // base64 encoded binary
+        mimeType: z.string(),
+        fileSize: z.number().int().positive(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      const prisma = getDbClient()
+      // Convert base64 to Buffer
+      const buffer = Buffer.from(input.content, 'base64')
+      
+      // Generate checksum and extract dimensions
+      const checksum = generateChecksum(buffer)
+      const { width, height } = await getImageDimensions(buffer)
+
+      // Check if asset with same checksum already exists
+      const existing = await prisma.dbAsset.findFirst({
+        where: { checksum, assetType: 'icon' },
+      })
+
+      if (existing) {
+        // Return existing asset if content is identical
+        return existing
+      }
+
+      return prisma.dbAsset.create({
+        data: {
+          name: input.name,
+          assetType: 'icon',
+          content: new Uint8Array(buffer),
+          checksum,
+          mimeType: input.mimeType,
+          fileSize: input.fileSize,
+          width,
+          height,
+        },
+      })
+    }),
+
+  update: publicProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        name: z.string().min(1).optional(),
+        content: z.string().optional(), // base64 encoded binary
+        mimeType: z.string().optional(),
+        fileSize: z.number().int().positive().optional(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      const prisma = getDbClient()
+      const { id, content, ...rest } = input
+
+      const data: Record<string, unknown> = { ...rest }
+      
+      if (content) {
+        const buffer = Buffer.from(content, 'base64')
+        data.content = new Uint8Array(buffer)
+        data.checksum = generateChecksum(buffer)
+        
+        const { width, height } = await getImageDimensions(buffer)
+        data.width = width
+        data.height = height
+      }
+
+      return prisma.dbAsset.update({
+        where: { id },
+        data,
+      })
+    }),
+
+  delete: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input }) => {
+      const prisma = getDbClient()
+      return prisma.dbAsset.delete({
+        where: { id: input.id },
+      })
+    }),
+
+  deleteMany: publicProcedure
+    .input(z.object({ ids: z.array(z.string()) }))
+    .mutation(async ({ input }) => {
+      const prisma = getDbClient()
+      return prisma.dbAsset.deleteMany({
+        where: {
+          id: { in: input.ids },
+          assetType: 'icon',
+        },
+      })
+    }),
+
+  // Serve icon binary content
+  getContent: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input }) => {
+      const prisma = getDbClient()
+      const asset = await prisma.dbAsset.findFirst({
+        where: {
+          id: input.id,
+          assetType: 'icon',
+        },
+        select: { content: true, mimeType: true },
+      })
+      if (!asset) {
+        throw new Error('Icon not found')
+      }
+      // Return base64 encoded content
+      return {
+        content: Buffer.from(asset.content).toString('base64'),
+        mimeType: asset.mimeType,
+      }
+    }),
+  })
+}

package/src/modules/icons/iconService.ts

@@ -0,0 +1,73 @@
+import { getDbClient } from '../../db'
+import { generateChecksum, getImageDimensions } from '../assets/assetUtils'
+
+export interface UpsertIconInput {
+  name: string
+  content: Buffer
+  mimeType: string
+  fileSize: number
+}
+
+/**
+ * Upsert an icon to the database.
+ * If an icon with the same name exists, it will be updated.
+ * Otherwise, a new icon will be created.
+ */
+export async function upsertIcon(input: UpsertIconInput) {
+  const prisma = getDbClient()
+  
+  const checksum = generateChecksum(input.content)
+  const { width, height } = await getImageDimensions(input.content)
+  
+  return prisma.dbAsset.upsert({
+    where: { name: input.name },
+    update: {
+      content: new Uint8Array(input.content),
+      checksum,
+      mimeType: input.mimeType,
+      fileSize: input.fileSize,
+      width,
+      height,
+    },
+    create: {
+      name: input.name,
+      assetType: 'icon',
+      content: new Uint8Array(input.content),
+      checksum,
+      mimeType: input.mimeType,
+      fileSize: input.fileSize,
+      width,
+      height,
+    },
+  })
+}
+
+/**
+ * Upsert multiple icons to the database.
+ * This is more efficient than calling upsertIcon multiple times.
+ */
+export async function upsertIcons(icons: Array<UpsertIconInput>) {
+  const results = []
+  for (const icon of icons) {
+    const result = await upsertIcon(icon)
+    results.push(result)
+  }
+  return results
+}
+
+/**
+ * Get an asset (icon or screenshot) by name from the database.
+ * Returns the asset content, mimeType, and name if found.
+ */
+export async function getAssetByName(name: string) {
+  const prisma = getDbClient()
+  
+  return prisma.dbAsset.findUnique({
+    where: { name },
+    select: {
+      content: true,
+      mimeType: true,
+      name: true,
+    },
+  })
+}

package/src/server/controller.ts

@@ -1,15 +1,37 @@
 import { initTRPC } from '@trpc/server'
 import z from 'zod'
-import type { EhTrpcContext } from './ehTrpcContext'
+
+import { getAppCatalogData } from '../modules/appCatalog/service'
+import type { AppCatalogData, BootstrapConfigData, ResourceJumpsData } from '../types'
+
 import type { TRPCRootObject } from '@trpc/server'
 
+import { createAppCatalogAdminRouter } from '../modules/appCatalogAdmin/appCatalogAdminRouter.js'
+import { createScreenshotRouter } from '../modules/assets/screenshotRouter.js'
+import type { BetterAuth } from '../modules/auth/auth'
+import { createAuthRouter } from '../modules/auth/authRouter.js'
+import { createIconRouter } from '../modules/icons/iconRouter.js'
+import type { EhTrpcContext } from './ehTrpcContext'
+
 /**
  * Initialization of tRPC backend
  * Should be done only once per backend!
  */
 const t: TRPCRootObject<EhTrpcContext, {}, {}> = initTRPC
   .context<EhTrpcContext>()
-  .create()
+  .create({
+    errorFormatter({ error, shape }: { error: unknown; shape: unknown }) {
+      // Log all tRPC errors to console
+      console.error('[tRPC Error]', {
+        path: (shape as { data?: { path?: string } }).data?.path,
+        code: (error as { code?: string }).code,
+        message: (error as { message?: string }).message,
+        cause: (error as { cause?: unknown }).cause,
+        stack: (error as { stack?: string }).stack,
+      })
+      return shape
+    },
+  })
 
 /**
  * Export reusable router and procedure helpers
@@ -18,37 +40,88 @@ const t: TRPCRootObject<EhTrpcContext, {}, {}> = initTRPC
 const router: typeof t.router = t.router
 const publicProcedure: typeof t.procedure = t.procedure
 
-export const trpcRouter = router({
-  bootstrap: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.companySpecificBackend.getBootstrapData()
-  }),
+/**
+ * Create the main tRPC router with optional auth instance
+ * @param auth - Optional Better Auth instance for auth-related queries
+ */
+export function createTrpcRouter(auth?: BetterAuth) {
+  return router({
+    bootstrap: publicProcedure.query(
+      async ({ ctx }): Promise<BootstrapConfigData> => {
+        return await ctx.companySpecificBackend.getBootstrapData()
+      },
+    ),
+
+    availabilityMatrix: publicProcedure.query(async ({ ctx }) => {
+      return await ctx.companySpecificBackend.getAvailabilityMatrix()
+    }),
+
+    tryFindRenameRule: publicProcedure
+      .input(
+        z.object({
+          envSlug: z.string().optional(),
+          resourceSlug: z.string().optional(),
+        }),
+      )
+      .query(async ({ input, ctx }) => {
+        return await ctx.companySpecificBackend.getNameMigrations(input)
+      }),
 
-  availabilityMatrix: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.companySpecificBackend.getAvailabilityMatrix()
-  }),
+    resourceJumps: publicProcedure.query(async ({ ctx }) => {
+      return await ctx.companySpecificBackend.getResourceJumps()
+    }),
 
-  tryFindRenameRule: publicProcedure
-    .input(
-      z.object({
-        envSlug: z.string().optional(),
-        resourceSlug: z.string().optional(),
+    resourceJumpsExtended: publicProcedure.query(async ({ ctx }) => {
+      return await ctx.companySpecificBackend.getResourceJumpsExtended()
+    }),
+    resourceJumpBySlugAndEnv: publicProcedure
+      .input(
+        z.object({
+          jumpResourceSlug: z.string(),
+          envSlug: z.string(),
+        }),
+      )
+      .query(async ({ input, ctx }) => {
+        return filterSingleResourceJump(
+          await ctx.companySpecificBackend.getResourceJumps(),
+          input.jumpResourceSlug,
+          input.envSlug,
+        )
       }),
-    )
-    .query(async ({ input, ctx }) => {
-      return await ctx.companySpecificBackend.getNameMigrations(input)
+
+    appCatalog: publicProcedure.query(async ({ ctx }): Promise<AppCatalogData> => {
+      return await getAppCatalogData(ctx.companySpecificBackend.getApps)
     }),
 
-  resourceJumps: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.companySpecificBackend.getResourceJumps()
-  }),
+    // Icon management routes
+    icon: createIconRouter(t),
+
+    // Screenshot management routes
+    screenshot: createScreenshotRouter(t),
+
+    // App catalog admin routes
+    appCatalogAdmin: createAppCatalogAdminRouter(t),
+
+    // Auth routes (requires auth instance)
+    auth: createAuthRouter(t, auth),
+  })
+}
+
+function filterSingleResourceJump(
+  resourceJumps: ResourceJumpsData,
+  jumpResourceSlug: string,
+  envSlug: string,
+): ResourceJumpsData {
+  const filteredResourceJump = resourceJumps.resourceJumps.find(
+    (item) => item.slug === jumpResourceSlug,
+  )
+  const filteredEnv = resourceJumps.envs.find((item) => item.slug === envSlug)
 
-  // specificEnvs: publicProcedure
-  //   .query(async ({ctx}) => {
-  //     return await ctx.companySpecificBackend.getDeployments({
-  //       envNames: ['dev', 'prod'],
-  //       appNames: ['app1', 'app2'],
-  //     })
-  //   }),
-})
+  return {
+    resourceJumps: filteredResourceJump ? [filteredResourceJump] : [],
+    envs: filteredEnv ? [filteredEnv] : [],
+    lateResolvableParams: resourceJumps.lateResolvableParams,
+  }
+}
 
-export type TRPCRouter = typeof trpcRouter
+export type TRPCRouter = ReturnType<typeof createTrpcRouter>

package/src/server/ehStaticControllerContract.ts

@@ -1,5 +1,8 @@
 export interface EhStaticControllerContract {
-  methods: { getIcon: { method: string; url: string } }
+  methods: { 
+    getIcon: { method: string; url: string }
+    getScreenshot: { method: string; url: string }
+  }
 }
 
 export const staticControllerContract: EhStaticControllerContract = {
@@ -8,5 +11,9 @@ export const staticControllerContract: EhStaticControllerContract = {
       method: 'get',
       url: 'icon/:icon',
     },
+    getScreenshot: {
+      method: 'get',
+      url: 'screenshot/:id',
+    },
   },
 }

package/src/server/ehTrpcContext.ts

@@ -15,9 +15,3 @@ export function createEhTrpcContext({
     companySpecificBackend,
   }
 }
-
-// const createContext = ({
-//                          req,
-//                          res
-//                        }: trpcExpress.CreateExpressContextOptions) => ({}); // no context
-// type Context = Awaited<ReturnType<typeof createContext>>;

package/src/types/backend/api.ts

@@ -1,8 +1,3 @@
-import type {
-  AvailiabilityMatrixData,
-  BootstrapConfigData,
-  ResourceJumpsData,
-} from '../common/dataRootTypes'
 import type { EhAppIndexed } from '../common/app/appTypes'
 import type {
   EhAppPageIndexed,
@@ -37,8 +32,7 @@ export interface EhBackendAppUIBaseInput {
 }
 
 export interface EhBackendAppUIInput
-  extends EhBackendAppUIBaseInput,
-    EhAppUiIndexed {
+  extends EhBackendAppUIBaseInput, EhAppUiIndexed {
   pages: Array<EhBackendPageInput>
 }
 
@@ -88,10 +82,3 @@ export interface RenameRule {
   oldSlug: string
   targetSlug: string
 }
-
-export interface EhBackendCompanySpecificBackend {
-  getBootstrapData: () => Promise<BootstrapConfigData>
-  getAvailabilityMatrix: () => Promise<AvailiabilityMatrixData>
-  getNameMigrations: (params: RenameRuleParams) => Promise<RenameRule | false>
-  getResourceJumps: () => Promise<ResourceJumpsData>
-}

package/src/types/backend/companySpecificBackend.ts

@@ -0,0 +1,17 @@
+import type { AppForCatalog } from '../common/appCatalogTypes'
+import type {
+  AvailabilityMatrixData,
+  BootstrapConfigData,
+  ResourceJumpsData,
+  ResourceJumpsExtendedData,
+} from '../common/dataRootTypes'
+import type { RenameRule, RenameRuleParams } from './api'
+
+export interface EhBackendCompanySpecificBackend {
+  getBootstrapData: () => Promise<BootstrapConfigData>
+  getAvailabilityMatrix: () => Promise<AvailabilityMatrixData>
+  getNameMigrations: (params: RenameRuleParams) => Promise<RenameRule | false>
+  getResourceJumps: () => Promise<ResourceJumpsData>
+  getResourceJumpsExtended: () => Promise<ResourceJumpsExtendedData>
+  getApps?: () => Promise<Array<AppForCatalog>>
+}