@digiko-npm/cms 0.1.1 → 0.2.0

package/src/r2/media-crud.ts

@@ -0,0 +1,157 @@
+import { DeleteObjectCommand } from '@aws-sdk/client-s3'
+import type { SupabaseClient } from '@supabase/supabase-js'
+import type { R2Config } from '../types/config'
+import type { MediaRecord, MediaInsert } from '../types/media'
+import { createR2Client } from './client'
+
+/* -------------------------------------------------------------------------- */
+/*  Types                                                                     */
+/* -------------------------------------------------------------------------- */
+
+export interface MediaListOptions {
+  /** 1-based page number. Default: 1 */
+  page?: number
+  /** Items per page. Default: 24 */
+  limit?: number
+  /** Filter by MIME type prefix: 'image' or 'video' */
+  type?: string
+  /** Search query (matches original_name and alt_text) */
+  search?: string
+}
+
+export interface MediaListResult {
+  items: MediaRecord[]
+  total: number
+  page: number
+  limit: number
+  totalPages: number
+}
+
+/* -------------------------------------------------------------------------- */
+/*  List                                                                      */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * List media records with pagination and filtering.
+ * Requires a Supabase admin client (service role) for full access.
+ */
+export async function listMedia(
+  supabase: SupabaseClient,
+  tableName: string,
+  options: MediaListOptions = {}
+): Promise<MediaListResult> {
+  const { page = 1, limit = 24, type, search } = options
+  const offset = (page - 1) * limit
+
+  let query = supabase
+    .from(tableName)
+    .select('*', { count: 'exact' })
+    .order('created_at', { ascending: false })
+    .range(offset, offset + limit - 1)
+
+  if (type) {
+    query = query.like('mime_type', `${type}/%`)
+  }
+
+  if (search) {
+    query = query.or(`original_name.ilike.%${search}%,alt_text.ilike.%${search}%`)
+  }
+
+  const { data, error, count } = await query
+
+  if (error) {
+    throw new Error(`Failed to list media: ${error.message}`)
+  }
+
+  return {
+    items: (data ?? []) as MediaRecord[],
+    total: count ?? 0,
+    page,
+    limit,
+    totalPages: Math.ceil((count ?? 0) / limit),
+  }
+}
+
+/* -------------------------------------------------------------------------- */
+/*  Insert                                                                    */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Register a completed upload in the database.
+ * Called after the browser finishes uploading to R2.
+ */
+export async function insertMedia(
+  supabase: SupabaseClient,
+  tableName: string,
+  data: MediaInsert
+): Promise<MediaRecord> {
+  const { data: record, error } = await supabase
+    .from(tableName)
+    .insert({
+      filename: data.filename,
+      original_name: data.original_name,
+      mime_type: data.mime_type,
+      size_bytes: data.size_bytes,
+      url: data.url,
+      width: data.width ?? null,
+      height: data.height ?? null,
+      alt_text: data.alt_text ?? null,
+    })
+    .select()
+    .single()
+
+  if (error) {
+    throw new Error(`Failed to insert media: ${error.message}`)
+  }
+
+  return record as MediaRecord
+}
+
+/* -------------------------------------------------------------------------- */
+/*  Delete                                                                    */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Delete a media record and its R2 object.
+ * Attempts R2 deletion first but always cleans up the DB record.
+ */
+export async function deleteMedia(
+  supabase: SupabaseClient,
+  tableName: string,
+  r2Config: R2Config,
+  id: string
+): Promise<void> {
+  // Get the record to extract the R2 key
+  const { data: media, error: fetchError } = await supabase
+    .from(tableName)
+    .select('*')
+    .eq('id', id)
+    .single()
+
+  if (fetchError || !media) {
+    throw new Error('Media not found')
+  }
+
+  // Extract key from public URL
+  const record = media as MediaRecord
+  const key = record.url.replace(`${r2Config.publicUrl}/`, '')
+
+  // Delete from R2 (best-effort)
+  try {
+    const r2 = createR2Client(r2Config)
+    await r2.send(new DeleteObjectCommand({ Bucket: r2Config.bucketName, Key: key }))
+  } catch {
+    // Log but don't fail — DB record should still be cleaned up
+    console.error(`Failed to delete R2 object: ${key}`)
+  }
+
+  // Delete from DB
+  const { error: deleteError } = await supabase
+    .from(tableName)
+    .delete()
+    .eq('id', id)
+
+  if (deleteError) {
+    throw new Error(`Failed to delete media record: ${deleteError.message}`)
+  }
+}

package/src/r2/presign.ts

@@ -0,0 +1,61 @@
+import { PutObjectCommand } from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import type { R2Config } from '../types/config'
+import { createR2Client } from './client'
+
+export interface PresignOptions {
+  /** Original filename (will be sanitized) */
+  filename: string
+  /** MIME type of the file */
+  contentType: string
+  /** Storage folder (e.g. 'media', 'shots', 'projects') */
+  folder?: string
+  /** Presigned URL expiration in seconds. Default: 600 (10 min) */
+  expiresIn?: number
+}
+
+export interface PresignResult {
+  /** Presigned PUT URL for direct browser upload */
+  uploadUrl: string
+  /** Public URL where the file will be accessible */
+  publicUrl: string
+  /** R2 object key */
+  key: string
+}
+
+/**
+ * Sanitize a filename for safe R2 storage.
+ * Lowercases, replaces non-alphanumeric chars with hyphens, deduplicates hyphens.
+ */
+function sanitizeFilename(filename: string): string {
+  return filename
+    .toLowerCase()
+    .replace(/[^a-z0-9.\-_]/g, '-')
+    .replace(/-+/g, '-')
+}
+
+/**
+ * Generate a presigned PUT URL for direct browser-to-R2 upload.
+ * The server never handles file bytes — Vercel/edge-friendly.
+ */
+export async function createPresignedUploadUrl(
+  config: R2Config,
+  options: PresignOptions
+): Promise<PresignResult> {
+  const { filename, contentType, folder = 'media', expiresIn = 600 } = options
+
+  const sanitized = sanitizeFilename(filename)
+  const key = `${folder}/${crypto.randomUUID()}-${sanitized}`
+
+  const r2 = createR2Client(config)
+  const command = new PutObjectCommand({
+    Bucket: config.bucketName,
+    Key: key,
+    ContentType: contentType,
+  })
+
+  const uploadUrl = await getSignedUrl(r2, command, { expiresIn })
+  const publicUrl = `${config.publicUrl}/${key}`
+
+  return { uploadUrl, publicUrl, key }
+}