@env-hopper/backend-core 2.0.1-alpha → 2.0.1-alpha-20260224145405

package/src/modules/icons/iconRouter.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod'
+import { getDbClient } from '../../db'
+import { generateChecksum, getImageDimensions } from '../assets/assetUtils'
+import { getExtensionFromMimeType } from './iconUtils'
+import { adminProcedure, publicProcedure, router } from '../../server/trpcSetup'
+
+export function createIconRouter() {
+  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',
+          },
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            fileSize: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+      }),
+
+    create: adminProcedure
+      .input(
+        z.object({
+          name: z.string().min(1), // Name with extension (e.g., "jira.svg")
+          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)
+
+        let name = input.name
+        // Add extension if not already present in name
+        if (!name.includes('.')) {
+          const extension = getExtensionFromMimeType(input.mimeType)
+          name = `${name}.${extension}`
+        }
+
+        // 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,
+            assetType: 'icon',
+            content: new Uint8Array(buffer),
+            checksum,
+            mimeType: input.mimeType,
+            fileSize: input.fileSize,
+            width,
+            height,
+          },
+        })
+      }),
+
+    update: adminProcedure
+      .input(
+        z.object({
+          id: z.string(),
+          name: z.string().min(1).optional(), // Name with extension (e.g., "jira.svg")
+          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, name, ...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
+        }
+
+        // If name is being updated and doesn't have extension, add it
+        if (name) {
+          if (!name.includes('.') && input.mimeType) {
+            const extension = getExtensionFromMimeType(input.mimeType)
+            data.name = `${name}.${extension}`
+          } else {
+            data.name = name
+          }
+        }
+
+        return prisma.dbAsset.update({
+          where: { id },
+          data,
+        })
+      }),
+
+    delete: adminProcedure
+      .input(z.object({ id: z.string() }))
+      .mutation(async ({ input }) => {
+        const prisma = getDbClient()
+        return prisma.dbAsset.delete({
+          where: { id: input.id },
+        })
+      }),
+
+    deleteMany: adminProcedure
+      .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, name: true },
+        })
+        if (!asset) {
+          throw new Error('Icon not found')
+        }
+        // Return base64 encoded content
+        return {
+          content: Buffer.from(asset.content).toString('base64'),
+          mimeType: asset.mimeType,
+          name: asset.name,
+        }
+      }),
+  })
+}

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: Array<Awaited<ReturnType<typeof upsertIcon>>> = []
+  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/modules/icons/iconUtils.ts

@@ -0,0 +1,46 @@
+/**
+ * Get file extension from MIME type
+ */
+export function getExtensionFromMimeType(mimeType: string): string {
+  const mimeMap: Record<string, string> = {
+    'image/svg+xml': 'svg',
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/jpg': 'jpg',
+    'image/webp': 'webp',
+    'image/gif': 'gif',
+    'image/bmp': 'bmp',
+    'image/tiff': 'tiff',
+    'image/x-icon': 'ico',
+    'image/vnd.microsoft.icon': 'ico',
+  }
+
+  return mimeMap[mimeType.toLowerCase()] || 'bin'
+}
+
+/**
+ * Get file extension from filename
+ */
+export function getExtensionFromFilename(filename: string): string {
+  const match = filename.match(/\.([^.]+)$/)
+  return match?.[1]?.toLowerCase() || ''
+}
+
+/**
+ * Get MIME type from extension
+ */
+export function getMimeTypeFromExtension(extension: string): string {
+  const extMap: Record<string, string> = {
+    svg: 'image/svg+xml',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    webp: 'image/webp',
+    gif: 'image/gif',
+    bmp: 'image/bmp',
+    tiff: 'image/tiff',
+    ico: 'image/x-icon',
+  }
+
+  return extMap[extension.toLowerCase()] || 'application/octet-stream'
+}

package/src/prisma-json-types.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+/**
+ * Prisma JSON Types Declaration
+ *
+ * This file provides type definitions for JSON fields in Prisma models.
+ * The prisma-json-types-generator reads JSDoc comments like `/// [TypeName]`
+ * on JSON fields and references them as `PrismaJson.TypeName`.
+ *
+ * We must declare these types in the global PrismaJson namespace for
+ * TypeScript to properly infer types throughout the tRPC chain.
+ *
+ * @see https://github.com/arthurfiorette/prisma-json-types-generator
+ */
+
+declare global {
+  namespace PrismaJson {
+    // DbApprovalMethod.config - Type-specific configuration
+    type ApprovalMethodConfig = import('./types/index').ApprovalMethodConfig
+
+    // DbAppForCatalog.accessRequest - Per-app approval configuration
+    type AppAccessRequest = import('./types/index').AppAccessRequest
+
+    // DbAppForCatalog.links - Array of links
+    interface AppLink {
+      displayName?: string
+      url: string
+    }
+
+    // AppRole used within accessRequest
+    type AppRole = import('./types/index').AppRole
+  }
+}
+
+export {}

package/src/server/controller.ts

@@ -1,54 +1,113 @@
-import { initTRPC } from '@trpc/server'
 import z from 'zod'
-import type { EhTrpcContext } from './ehTrpcContext'
-import type { TRPCRootObject } from '@trpc/server'
 
-/**
- * Initialization of tRPC backend
- * Should be done only once per backend!
- */
-const t: TRPCRootObject<EhTrpcContext, {}, {}> = initTRPC
-  .context<EhTrpcContext>()
-  .create()
+import { getAppCatalogData } from '../modules/appCatalog/service'
+import type {
+  AppCatalogData,
+  BootstrapConfigData,
+  ResourceJumpsData,
+} from '../types'
+
+import { createAppCatalogAdminRouter } from '../modules/appCatalogAdmin/appCatalogAdminRouter.js'
+import { createApprovalMethodRouter } from '../modules/approvalMethod/approvalMethodRouter.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 { publicProcedure, router, t } from './trpcSetup'
 
 /**
- * Export reusable router and procedure helpers
- * that can be used throughout the router
+ * Create the main tRPC router with optional auth instance
+ * @param auth - Optional Better Auth instance for auth-related queries
  */
-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()
-  }),
-
-  availabilityMatrix: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.companySpecificBackend.getAvailabilityMatrix()
-  }),
-
-  tryFindRenameRule: publicProcedure
-    .input(
-      z.object({
-        envSlug: z.string().optional(),
-        resourceSlug: z.string().optional(),
+export function createTrpcRouter(auth?: BetterAuth) {
+  return router({
+    bootstrap: publicProcedure.query(
+      async ({ ctx }): Promise<BootstrapConfigData> => {
+        return await ctx.companySpecificBackend.getBootstrapData()
+      },
+    ),
+
+    authConfig: publicProcedure.query(async ({ ctx }) => {
+      return {
+        adminGroups: ctx.adminGroups,
+      }
+    }),
+
+    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)
       }),
-    )
-    .query(async ({ input, ctx }) => {
-      return await ctx.companySpecificBackend.getNameMigrations(input)
+
+    resourceJumps: publicProcedure.query(async ({ ctx }) => {
+      return await ctx.companySpecificBackend.getResourceJumps()
     }),
 
-  resourceJumps: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.companySpecificBackend.getResourceJumps()
-  }),
+    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,
+        )
+      }),
+
+    appCatalog: publicProcedure.query(
+      async ({ ctx }): Promise<AppCatalogData> => {
+        return await getAppCatalogData(ctx.companySpecificBackend.getApps)
+      },
+    ),
+
+    // Icon management routes
+    icon: createIconRouter(),
+
+    // Screenshot management routes
+    screenshot: createScreenshotRouter(),
+
+    // App catalog admin routes
+    appCatalogAdmin: createAppCatalogAdminRouter(),
+
+    // Approval method routes
+    approvalMethod: createApprovalMethodRouter(),
+
+    // 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

@@ -1,23 +1,26 @@
 import type { EhBackendCompanySpecificBackend } from '../types'
+import type { User } from 'better-auth/types'
 
 export interface EhTrpcContext {
   companySpecificBackend: EhBackendCompanySpecificBackend
+  user: User | null
+  adminGroups: Array<string>
 }
 
 export interface EhTrpcContextOptions {
   companySpecificBackend: EhBackendCompanySpecificBackend
+  user?: User | null
+  adminGroups: Array<string>
 }
 
 export function createEhTrpcContext({
   companySpecificBackend,
+  user = null,
+  adminGroups,
 }: EhTrpcContextOptions): EhTrpcContext {
   return {
     companySpecificBackend,
+    user,
+    adminGroups,
   }
 }
-
-// const createContext = ({
-//                          req,
-//                          res
-//                        }: trpcExpress.CreateExpressContextOptions) => ({}); // no context
-// type Context = Awaited<ReturnType<typeof createContext>>;

package/src/server/trpcSetup.ts

@@ -0,0 +1,89 @@
+import { TRPCError, initTRPC } from '@trpc/server'
+import type { EhTrpcContext } from './ehTrpcContext'
+import { isAdmin } from '../modules/auth/authorizationUtils'
+
+/**
+ * Initialization of tRPC backend
+ * Should be done only once per backend!
+ */
+export const t = initTRPC.context<EhTrpcContext>().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
+ */
+export const router = t.router
+export const publicProcedure = t.procedure
+
+/**
+ * Middleware to check if user is authenticated
+ */
+const isAuthenticated = t.middleware(({ ctx, next }) => {
+  if (!ctx.user) {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'You must be logged in to access this resource',
+    })
+  }
+  return next({
+    ctx: {
+      ...ctx,
+      user: ctx.user,
+    },
+  })
+})
+
+/**
+ * Middleware to check if user is an admin
+ */
+const isAdminMiddleware = t.middleware(({ ctx, next }) => {
+  if (!ctx.user) {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'You must be logged in to access this resource',
+    })
+  }
+
+  console.log('[isAdminMiddleware] === ADMIN CHECK DEBUG ===')
+  console.log('[isAdminMiddleware] User:', ctx.user.email)
+  console.log('[isAdminMiddleware] Required admin groups:', ctx.adminGroups)
+  console.log('[isAdminMiddleware] Calling isAdmin()...')
+
+  const hasAdminAccess = isAdmin(ctx.user, ctx.adminGroups)
+  console.log('[isAdminMiddleware] Has admin access:', hasAdminAccess)
+
+  if (!hasAdminAccess) {
+    throw new TRPCError({
+      code: 'FORBIDDEN',
+      message: `You must be an admin to access this resource. Required groups: ${ctx.adminGroups.join(', ') || 'env_hopper_ui_super_admins'}`,
+    })
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      user: ctx.user,
+    },
+  })
+})
+
+/**
+ * Admin procedure that requires admin permissions
+ */
+export const adminProcedure = t.procedure.use(isAdminMiddleware)
+
+/**
+ * Protected procedure that requires authentication (but not admin)
+ */
+export const protectedProcedure = t.procedure.use(isAuthenticated)

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>>
+}