@igstack/app-catalog-backend-core 0.0.1

package/src/modules/assets/assetUtils.ts

@@ -0,0 +1,114 @@
+import { createHash } from 'node:crypto'
+import type { FormatEnum } from 'sharp'
+import sharp from 'sharp'
+import type { ParseAssetParams, ParseAssetReturn } from './assetRestController'
+
+/**
+ * Extract image dimensions from a buffer using sharp
+ */
+export async function getImageDimensions(
+  buffer: Buffer,
+): Promise<{ width?: number; height?: number }> {
+  try {
+    const metadata = await sharp(buffer).metadata()
+    return {
+      width: metadata.width,
+      height: metadata.height,
+    }
+  } catch (error) {
+    console.error('Error extracting image dimensions:', error)
+    return { width: undefined, height: undefined }
+  }
+}
+
+/**
+ * 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')
+}
+
+export async function parseAssetMeta(
+  p: ParseAssetParams,
+): Promise<ParseAssetReturn> {
+  // Get image dimensions using our utility
+  const { width, height, format, size } = await sharp(p.buffer).metadata()
+
+  const formatToMime: Partial<Record<keyof FormatEnum, string>> = {
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    tiff: 'image/tiff',
+    gif: 'image/gif',
+    heif: 'image/heif',
+    raw: 'application/octet-stream',
+  }
+
+  return {
+    checksum: generateChecksum(p.buffer),
+    width,
+    height,
+    mimeType: format
+      ? (formatToMime[format] ?? `image/${format}`)
+      : 'application/octet-stream',
+    fileSize: size || 0,
+  }
+}

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,112 @@
+import { z } from 'zod'
+import { getDbClient } from '../../db'
+import { publicProcedure, router } from '../../server/trpcSetup'
+
+export function createScreenshotRouter() {
+  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,
+          },
+        })
+      }),
+  })
+}

package/src/modules/assets/syncAssets.ts

@@ -0,0 +1,277 @@
+import { readFileSync, readdirSync } from 'node:fs'
+import { extname, join } from 'node:path'
+import { getDbClient } from '../../db'
+import { generateChecksum, getImageDimensions } from './assetUtils'
+
+export interface SyncAssetsConfig {
+  /**
+   * Directory containing icon files to sync
+   */
+  iconsDir?: string
+
+  /**
+   * Directory containing screenshot files to sync
+   */
+  screenshotsDir?: string
+}
+
+/**
+ * Sync local asset files (icons and screenshots) from directories into the database.
+ *
+ * This function allows consuming applications to sync asset files without directly
+ * exposing the Prisma client. It handles:
+ * - Icon files: Assigned to apps by matching filename to icon name patterns
+ * - Screenshot files: Assigned to apps by matching filename to app ID (format: <app-id>_screenshot_<no>.<ext>)
+ *
+ * @param config Configuration with paths to icon and screenshot directories
+ */
+export async function syncAssets(config: SyncAssetsConfig): Promise<{
+  iconsUpserted: number
+  screenshotsUpserted: number
+}> {
+  const prisma = getDbClient()
+  let iconsUpserted = 0
+  let screenshotsUpserted = 0
+
+  // Sync icons from local/icons directory
+  if (config.iconsDir) {
+    console.log(`📁 Syncing icons from ${config.iconsDir}...`)
+    iconsUpserted = await syncIconsFromDirectory(prisma, config.iconsDir)
+    console.log(`   ✓ Upserted ${iconsUpserted} icons`)
+  }
+
+  // Sync screenshots from local/screenshots directory
+  if (config.screenshotsDir) {
+    console.log(`📷 Syncing screenshots from ${config.screenshotsDir}...`)
+    screenshotsUpserted = await syncScreenshotsFromDirectory(
+      prisma,
+      config.screenshotsDir,
+    )
+    console.log(
+      `   ✓ Upserted ${screenshotsUpserted} screenshots and assigned to apps`,
+    )
+  }
+
+  return {
+    iconsUpserted,
+    screenshotsUpserted,
+  }
+}
+
+/**
+ * Sync icon files from a directory
+ */
+async function syncIconsFromDirectory(
+  prisma: ReturnType<typeof getDbClient>,
+  iconsDir: string,
+): Promise<number> {
+  let count = 0
+
+  try {
+    const files = readdirSync(iconsDir)
+
+    for (const file of files) {
+      const filePath = join(iconsDir, file)
+      const ext = extname(file).toLowerCase().slice(1) // Remove leading dot
+
+      // Skip non-image files
+      if (!['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(ext)) {
+        continue
+      }
+
+      try {
+        const content = readFileSync(filePath)
+        const buffer = Buffer.from(content)
+        const checksum = generateChecksum(buffer)
+        const iconName = file.replace(/\.[^/.]+$/, '') // Remove extension
+
+        // Check if asset with same checksum already exists
+        const existing = await prisma.dbAsset.findFirst({
+          where: { checksum, assetType: 'icon' },
+        })
+
+        if (existing) {
+          continue // Already synced
+        }
+
+        // Extract dimensions for raster images
+        let width: number | null = null
+        let height: number | null = null
+        if (!ext.includes('svg')) {
+          const { width: w, height: h } = await getImageDimensions(buffer)
+          width = w ?? null
+          height = h ?? null
+        }
+
+        // Determine MIME type
+        const mimeType =
+          {
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+          }[ext] || 'application/octet-stream'
+
+        await prisma.dbAsset.create({
+          data: {
+            name: iconName,
+            assetType: 'icon',
+            content: new Uint8Array(buffer),
+            checksum,
+            mimeType,
+            fileSize: buffer.length,
+            width,
+            height,
+          },
+        })
+
+        count++
+      } catch (error) {
+        console.warn(`  ⚠ Failed to sync icon ${file}:`, error)
+      }
+    }
+  } catch (error) {
+    console.error(`  ❌ Error reading icons directory:`, error)
+  }
+
+  return count
+}
+
+/**
+ * Sync screenshot files from a directory and assign to apps
+ */
+async function syncScreenshotsFromDirectory(
+  prisma: ReturnType<typeof getDbClient>,
+  screenshotsDir: string,
+): Promise<number> {
+  let count = 0
+
+  try {
+    const files = readdirSync(screenshotsDir)
+
+    // Group screenshots by app ID
+    const screenshotsByApp = new Map<
+      string,
+      Array<{ path: string; ext: string }>
+    >()
+
+    for (const file of files) {
+      // Parse filename: <app-id>_screenshot_<no>.<ext>
+      const match = file.match(/^(.+?)_screenshot_(\d+)\.([^.]+)$/)
+      if (!match || !match[1] || !match[3]) {
+        continue
+      }
+
+      const appId = match[1]
+      const ext = match[3]
+      if (!screenshotsByApp.has(appId)) {
+        screenshotsByApp.set(appId, [])
+      }
+      screenshotsByApp.get(appId)!.push({
+        path: join(screenshotsDir, file),
+        ext,
+      })
+    }
+
+    // Process each app's screenshots
+    for (const [appId, screenshots] of screenshotsByApp) {
+      try {
+        // Check if app exists
+        const app = await prisma.dbAppForCatalog.findUnique({
+          where: { slug: appId },
+          select: { id: true },
+        })
+
+        if (!app) {
+          console.warn(`  ⚠ App not found: ${appId}`)
+          continue
+        }
+
+        // Sync screenshots for this app
+        for (const screenshot of screenshots) {
+          try {
+            const content = readFileSync(screenshot.path)
+            const buffer = Buffer.from(content)
+            const checksum = generateChecksum(buffer)
+
+            // Check if screenshot with same checksum already exists
+            const existing = await prisma.dbAsset.findFirst({
+              where: { checksum, assetType: 'screenshot' },
+            })
+
+            if (existing) {
+              // Link to app via screenshotIds array if not already linked
+              const existingApp = await prisma.dbAppForCatalog.findUnique({
+                where: { slug: appId },
+              })
+              if (
+                existingApp &&
+                !existingApp.screenshotIds.includes(existing.id)
+              ) {
+                await prisma.dbAppForCatalog.update({
+                  where: { slug: appId },
+                  data: {
+                    screenshotIds: [...existingApp.screenshotIds, existing.id],
+                  },
+                })
+              }
+              continue
+            }
+
+            // Extract dimensions
+            const { width, height } = await getImageDimensions(buffer)
+
+            // Determine MIME type
+            const mimeType =
+              {
+                png: 'image/png',
+                jpg: 'image/jpeg',
+                jpeg: 'image/jpeg',
+                gif: 'image/gif',
+                webp: 'image/webp',
+              }[screenshot.ext.toLowerCase()] || 'application/octet-stream'
+
+            // Create screenshot asset
+            const asset = await prisma.dbAsset.create({
+              data: {
+                name: `${appId}-screenshot-${Date.now()}`,
+                assetType: 'screenshot',
+                content: new Uint8Array(buffer),
+                checksum,
+                mimeType,
+                fileSize: buffer.length,
+                width: width ?? null,
+                height: height ?? null,
+              },
+            })
+
+            // Link screenshot to app via screenshotIds array
+            await prisma.dbAppForCatalog.update({
+              where: { slug: appId },
+              data: {
+                screenshotIds: {
+                  push: asset.id,
+                },
+              },
+            })
+
+            count++
+          } catch (error) {
+            console.warn(
+              `  ⚠ Failed to sync screenshot ${screenshot.path}:`,
+              error,
+            )
+          }
+        }
+      } catch (error) {
+        console.warn(`  ⚠ Failed to process app ${appId}:`, error)
+      }
+    }
+  } catch (error) {
+    console.error(`  ❌ Error reading screenshots directory:`, error)
+  }
+
+  return count
+}