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

package/src/modules/assets/assetRestController.ts

@@ -0,0 +1,309 @@
+import type { AssetType } from '@prisma/client'
+import type { Request, Response, Router } from 'express'
+import multer from 'multer'
+import sharp from 'sharp'
+import { getDbClient } from '../../db'
+import {
+  generateChecksum,
+  getImageDimensions,
+  getImageFormat,
+  isRasterImage,
+  resizeImage,
+} from './assetUtils'
+
+// 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 AssetRestControllerConfig {
+  /**
+   * Base path for asset endpoints (e.g., '/api/assets')
+   */
+  basePath: string
+}
+
+/**
+ * Registers REST endpoints for universal asset upload and retrieval
+ *
+ * Endpoints:
+ * - POST {basePath}/upload - Upload a new asset (multipart/form-data)
+ * - GET {basePath}/:id - Get asset binary by ID
+ * - GET {basePath}/:id/metadata - Get asset metadata only
+ * - GET {basePath}/by-name/:name - Get asset binary by name
+ */
+export function registerAssetRestController(
+  router: Router,
+  config: AssetRestControllerConfig,
+): void {
+  const { basePath } = config
+
+  // Upload endpoint - accepts multipart/form-data
+  router.post(
+    `${basePath}/upload`,
+    upload.single('asset'),
+    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
+        const assetTypeInput = req.body['assetType']
+        const assetType = (assetTypeInput as AssetType | undefined) ?? 'icon'
+
+        if (!name) {
+          res.status(400).json({ error: 'Name is required' })
+          return
+        }
+
+        const prisma = getDbClient()
+
+        // Compute checksum of the binary for content-based deduplication.
+        const checksum = generateChecksum(req.file.buffer)
+
+        // If an asset with the same checksum already exists, reuse it instead of storing duplicate binary.
+        const existing = await prisma.dbAsset.findUnique({
+          where: { checksum },
+          select: {
+            id: true,
+            name: true,
+            assetType: true,
+            checksum: true,
+            mimeType: true,
+            fileSize: true,
+            width: true,
+            height: true,
+            createdAt: true,
+          },
+        })
+
+        if (existing) {
+          res.status(200).json(existing)
+          return
+        }
+
+        // Get image dimensions using our utility
+        const { width, height } = await getImageDimensions(req.file.buffer)
+
+        const asset = await prisma.dbAsset.create({
+          data: {
+            name,
+            checksum,
+            assetType,
+            content: new Uint8Array(req.file.buffer),
+            mimeType: req.file.mimetype,
+            fileSize: req.file.size,
+            width,
+            height,
+          },
+        })
+
+        res.status(201).json({
+          id: asset.id,
+          name: asset.name,
+          assetType: asset.assetType,
+          mimeType: asset.mimeType,
+          fileSize: asset.fileSize,
+          width: asset.width,
+          height: asset.height,
+          createdAt: asset.createdAt,
+        })
+      } catch (error) {
+        console.error('Error uploading asset:', error)
+        res.status(500).json({ error: 'Failed to upload asset' })
+      }
+    },
+  )
+
+  // Get asset binary by ID
+  router.get(`${basePath}/:id`, async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params
+
+      const prisma = getDbClient()
+      const asset = await prisma.dbAsset.findUnique({
+        where: { id },
+        select: {
+          content: true,
+          mimeType: true,
+          name: true,
+          width: true,
+          height: true,
+        },
+      })
+
+      if (!asset) {
+        res.status(404).json({ error: 'Asset not found' })
+        return
+      }
+
+      const resizeEnabled =
+        String(process.env.EH_ASSETS_RESIZE_ENABLED || 'true') === 'true'
+      const wParam = req.query['w'] as string | undefined
+      const width = wParam ? Number.parseInt(wParam, 10) : undefined
+
+      let outBuffer: Uint8Array = asset.content
+      let outMime = asset.mimeType
+
+      const shouldResize =
+        resizeEnabled &&
+        isRasterImage(asset.mimeType) &&
+        !!width &&
+        Number.isFinite(width) &&
+        width > 0
+
+      if (shouldResize) {
+        const fmt = getImageFormat(asset.mimeType) || 'jpeg'
+        const buf = await resizeImage(
+          Buffer.from(asset.content),
+          width,
+          undefined,
+          fmt,
+        )
+        outBuffer = new Uint8Array(buf)
+        outMime = `image/${fmt}`
+      }
+
+      // Set appropriate headers
+      res.setHeader('Content-Type', outMime)
+      res.setHeader('Content-Disposition', `inline; filename="${asset.name}"`)
+      res.setHeader('Cache-Control', 'public, max-age=86400') // Cache for 1 day
+
+      // Send binary content (resized if requested)
+      res.send(outBuffer)
+    } catch (error) {
+      console.error('Error fetching asset:', error)
+      res.status(500).json({ error: 'Failed to fetch asset' })
+    }
+  })
+
+  // Get asset metadata only (no binary content)
+  router.get(
+    `${basePath}/:id/metadata`,
+    async (req: Request, res: Response) => {
+      try {
+        const { id } = req.params
+
+        const prisma = getDbClient()
+        const asset = await prisma.dbAsset.findUnique({
+          where: { id },
+          select: {
+            id: true,
+            name: true,
+            assetType: true,
+            mimeType: true,
+            fileSize: true,
+            width: true,
+            height: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+
+        if (!asset) {
+          res.status(404).json({ error: 'Asset not found' })
+          return
+        }
+
+        res.json(asset)
+      } catch (error) {
+        console.error('Error fetching asset metadata:', error)
+        res.status(500).json({ error: 'Failed to fetch asset metadata' })
+      }
+    },
+  )
+
+  // Get asset binary by name
+  router.get(
+    `${basePath}/by-name/:name`,
+    async (req: Request, res: Response) => {
+      try {
+        const { name } = req.params
+
+        const prisma = getDbClient()
+        const asset = await prisma.dbAsset.findUnique({
+          where: { name },
+          select: {
+            content: true,
+            mimeType: true,
+            name: true,
+            width: true,
+            height: true,
+          },
+        })
+
+        if (!asset) {
+          res.status(404).json({ error: 'Asset not found' })
+          return
+        }
+
+        const resizeEnabled =
+          String(process.env.EH_ASSETS_RESIZE_ENABLED || 'true') === 'true'
+        const wParam = req.query['w'] as string | undefined
+        const width = wParam ? Number.parseInt(wParam, 10) : undefined
+
+        let outBuffer: Uint8Array = asset.content
+        let outMime = asset.mimeType
+
+        const isRaster =
+          asset.mimeType.startsWith('image/') && !asset.mimeType.includes('svg')
+        const shouldResize =
+          resizeEnabled &&
+          isRaster &&
+          !!width &&
+          Number.isFinite(width) &&
+          width > 0
+
+        if (shouldResize) {
+          const fmt = asset.mimeType.includes('png')
+            ? 'png'
+            : asset.mimeType.includes('webp')
+              ? 'webp'
+              : 'jpeg'
+
+          let buf: Buffer
+          const pipeline = sharp(Buffer.from(asset.content)).resize({
+            width,
+            fit: 'inside',
+            withoutEnlargement: true,
+          })
+          if (fmt === 'png') {
+            buf = await pipeline.png().toBuffer()
+            outMime = 'image/png'
+          } else if (fmt === 'webp') {
+            buf = await pipeline.webp().toBuffer()
+            outMime = 'image/webp'
+          } else {
+            buf = await pipeline.jpeg().toBuffer()
+            outMime = 'image/jpeg'
+          }
+          outBuffer = new Uint8Array(buf)
+        }
+
+        // Set appropriate headers
+        res.setHeader('Content-Type', outMime)
+        res.setHeader('Content-Disposition', `inline; filename="${asset.name}"`)
+        res.setHeader('Cache-Control', 'public, max-age=86400') // Cache for 1 day
+
+        // Send binary content (resized if requested)
+        res.send(outBuffer)
+      } catch (error) {
+        console.error('Error fetching asset by name:', error)
+        res.status(500).json({ error: 'Failed to fetch asset' })
+      }
+    },
+  )
+}

package/src/modules/assets/assetUtils.ts

@@ -0,0 +1,81 @@
+import { createHash } from 'node:crypto';
+import sharp from 'sharp';
+
+/**
+ * Extract image dimensions from a buffer using sharp
+ */
+export async function getImageDimensions(
+  buffer: Buffer,
+): Promise<{ width: number | null; height: number | null }> {
+  try {
+    const metadata = await sharp(buffer).metadata()
+    return {
+      width: metadata.width ?? null,
+      height: metadata.height ?? null,
+    }
+  } catch (error) {
+    console.error('Error extracting image dimensions:', error)
+    return { width: null, height: null }
+  }
+}
+
+/**
+ * Resize an image buffer to the specified dimensions
+ * @param buffer - The image buffer to resize
+ * @param width - Target width (optional)
+ * @param height - Target height (optional)
+ * @param format - Output format ('png', 'jpeg', 'webp'), auto-detected if not provided
+ */
+export async function resizeImage(
+  buffer: Buffer,
+  width?: number,
+  height?: number,
+  format?: 'png' | 'jpeg' | 'webp',
+): Promise<Buffer> {
+  let pipeline = sharp(buffer)
+
+  // Apply resize if dimensions provided
+  if (width || height) {
+    pipeline = pipeline.resize({
+      width,
+      height,
+      fit: 'inside',
+      withoutEnlargement: true,
+    })
+  }
+
+  // Apply format conversion if specified
+  if (format === 'png') {
+    pipeline = pipeline.png()
+  } else if (format === 'webp') {
+    pipeline = pipeline.webp()
+  } else if (format === 'jpeg') {
+    pipeline = pipeline.jpeg()
+  }
+
+  return pipeline.toBuffer()
+}
+
+/**
+ * Generate SHA-256 checksum for a buffer
+ */
+export function generateChecksum(buffer: Buffer): string {
+  return createHash('sha256').update(buffer).digest('hex')
+}
+
+/**
+ * Detect image format from mime type
+ */
+export function getImageFormat(mimeType: string): 'png' | 'webp' | 'jpeg' | null {
+  if (mimeType.includes('png')) return 'png'
+  if (mimeType.includes('webp')) return 'webp'
+  if (mimeType.includes('jpeg') || mimeType.includes('jpg')) return 'jpeg'
+  return null
+}
+
+/**
+ * Check if a mime type represents a raster image (not SVG)
+ */
+export function isRasterImage(mimeType: string): boolean {
+  return mimeType.startsWith('image/') && !mimeType.includes('svg')
+}

package/src/modules/assets/screenshotRestController.ts

@@ -0,0 +1,195 @@
+import type { Request, Response, Router } from 'express'
+import sharp from 'sharp'
+import { getDbClient } from '../../db'
+
+export interface ScreenshotRestControllerConfig {
+  /**
+   * Base path for screenshot endpoints (e.g., '/api/screenshots')
+   */
+  basePath: string
+}
+
+/**
+ * Registers REST endpoints for screenshot retrieval
+ * 
+ * Endpoints:
+ * - GET {basePath}/app/:appId - Get all screenshots for an app
+ * - GET {basePath}/:id - Get screenshot binary by ID
+ * - GET {basePath}/:id/metadata - Get screenshot metadata only
+ */
+export function registerScreenshotRestController(
+  router: Router,
+  config: ScreenshotRestControllerConfig,
+): void {
+  const { basePath } = config
+
+  // Get all screenshots for an app
+  router.get(`${basePath}/app/:appSlug`, async (req: Request, res: Response) => {
+    try {
+      const { appSlug } = req.params
+
+      const prisma = getDbClient()
+      
+      // Find app by slug
+      const app = await prisma.dbAppForCatalog.findUnique({
+        where: { slug: appSlug },
+        select: { screenshotIds: true },
+      })
+
+      if (!app) {
+        res.status(404).json({ error: 'App not found' })
+        return
+      }
+
+      // Fetch all screenshots for the app
+      const screenshots = await prisma.dbAsset.findMany({
+        where: {
+          id: { in: app.screenshotIds },
+          assetType: 'screenshot',
+        },
+        select: {
+          id: true,
+          name: true,
+          mimeType: true,
+          fileSize: true,
+          width: true,
+          height: true,
+          createdAt: true,
+        },
+      })
+
+      res.json(screenshots)
+    } catch (error) {
+      console.error('Error fetching app screenshots:', error)
+      res.status(500).json({ error: 'Failed to fetch screenshots' })
+    }
+  })
+
+  // Get first screenshot for an app (convenience endpoint)
+  router.get(`${basePath}/app/:appSlug/first`, async (req: Request, res: Response) => {
+    try {
+      const { appSlug } = req.params
+
+      const prisma = getDbClient()
+      
+      // Find app by slug
+      const app = await prisma.dbAppForCatalog.findUnique({
+        where: { slug: appSlug },
+        select: { screenshotIds: true },
+      })
+
+      if (!app || app.screenshotIds.length === 0) {
+        res.status(404).json({ error: 'No screenshots found' })
+        return
+      }
+
+      // Fetch first screenshot
+      const screenshot = await prisma.dbAsset.findUnique({
+        where: { id: app.screenshotIds[0] },
+        select: {
+          id: true,
+          name: true,
+          mimeType: true,
+          fileSize: true,
+          width: true,
+          height: true,
+          createdAt: true,
+        },
+      })
+
+      if (!screenshot) {
+        res.status(404).json({ error: 'Screenshot not found' })
+        return
+      }
+
+      res.json(screenshot)
+    } catch (error) {
+      console.error('Error fetching first screenshot:', error)
+      res.status(500).json({ error: 'Failed to fetch screenshot' })
+    }
+  })
+
+  // Get screenshot binary by ID
+  router.get(`${basePath}/:id`, async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params
+      const sizeParam = req.query.size as string | undefined
+      const targetSize = sizeParam ? parseInt(sizeParam, 10) : undefined
+
+      const prisma = getDbClient()
+      const screenshot = await prisma.dbAsset.findUnique({
+        where: { id },
+        select: {
+          content: true,
+          mimeType: true,
+          name: true,
+        },
+      })
+
+      if (!screenshot) {
+        res.status(404).json({ error: 'Screenshot not found' })
+        return
+      }
+
+      let content: Uint8Array | Buffer = screenshot.content
+
+      // Resize if size parameter provided
+      if (targetSize && targetSize > 0) {
+        try {
+          content = await sharp(screenshot.content)
+            .resize(targetSize, targetSize, {
+              fit: 'inside',
+              withoutEnlargement: true,
+            })
+            .toBuffer()
+        } catch (resizeError) {
+          console.error('Error resizing screenshot:', resizeError)
+          // Fall back to original if resize fails
+        }
+      }
+
+      // Set appropriate headers
+      res.setHeader('Content-Type', screenshot.mimeType)
+      res.setHeader('Content-Disposition', `inline; filename="${screenshot.name}"`)
+      res.setHeader('Cache-Control', 'public, max-age=86400') // Cache for 1 day
+
+      // Send binary content
+      res.send(content)
+    } catch (error) {
+      console.error('Error fetching screenshot:', error)
+      res.status(500).json({ error: 'Failed to fetch screenshot' })
+    }
+  })
+
+  // Get screenshot metadata only (no binary content)
+  router.get(`${basePath}/:id/metadata`, async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params
+
+      const prisma = getDbClient()
+      const screenshot = await prisma.dbAsset.findUnique({
+        where: { id },
+        select: {
+          id: true,
+          name: true,
+          mimeType: true,
+          fileSize: true,
+          width: true,
+          height: true,
+          createdAt: true,
+          updatedAt: true,
+        },
+      })
+
+      if (!screenshot) {
+        res.status(404).json({ error: 'Screenshot not found' })
+        return
+      }
+
+      res.json(screenshot)
+    } catch (error) {
+      console.error('Error fetching screenshot metadata:', error)
+      res.status(500).json({ error: 'Failed to fetch screenshot metadata' })
+    }
+  })
+}

package/src/modules/assets/screenshotRouter.ts

@@ -0,0 +1,116 @@
+import type { TRPCRootObject } from '@trpc/server'
+import { z } from 'zod'
+import { getDbClient } from '../../db'
+import type { EhTrpcContext } from '../../server/ehTrpcContext'
+
+export function createScreenshotRouter(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: 'screenshot' },
+        select: {
+          id: true,
+          name: true,
+          mimeType: true,
+          fileSize: true,
+          width: true,
+          height: true,
+          createdAt: true,
+          updatedAt: true,
+        },
+        orderBy: { createdAt: 'desc' },
+      })
+    }),
+
+    getOne: publicProcedure
+      .input(z.object({ id: z.string() }))
+      .query(async ({ input }) => {
+        const prisma = getDbClient()
+        return prisma.dbAsset.findFirst({
+          where: {
+            id: input.id,
+            assetType: 'screenshot',
+          },
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            fileSize: true,
+            width: true,
+            height: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+      }),
+
+    getByAppSlug: publicProcedure
+      .input(z.object({ appSlug: z.string() }))
+      .query(async ({ input }) => {
+        const prisma = getDbClient()
+        
+        // Find app by slug
+        const app = await prisma.dbAppForCatalog.findUnique({
+          where: { slug: input.appSlug },
+          select: { screenshotIds: true },
+        })
+
+        if (!app) {
+          return []
+        }
+
+        // Fetch all screenshots for the app
+        return prisma.dbAsset.findMany({
+          where: {
+            id: { in: app.screenshotIds },
+            assetType: 'screenshot',
+          },
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            fileSize: true,
+            width: true,
+            height: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+      }),
+
+    getFirstByAppSlug: publicProcedure
+      .input(z.object({ appSlug: z.string() }))
+      .query(async ({ input }) => {
+        const prisma = getDbClient()
+        
+        // Find app by slug
+        const app = await prisma.dbAppForCatalog.findUnique({
+          where: { slug: input.appSlug },
+          select: { screenshotIds: true },
+        })
+
+        if (!app || app.screenshotIds.length === 0) {
+          return null
+        }
+
+        // Fetch first screenshot
+        return prisma.dbAsset.findUnique({
+          where: { id: app.screenshotIds[0] },
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            fileSize: true,
+            width: true,
+            height: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+        })
+      }),
+  })
+}