Media storage with ImageKit.io

npm install imagekit @neondatabase/serverless @hono/node-server hono dotenv

# ImageKit.io Credentials
IMAGEKIT_PUBLIC_KEY=your_imagekit_public_key
IMAGEKIT_PRIVATE_KEY=your_imagekit_private_key
IMAGEKIT_URL_ENDPOINT=your_imagekit_url_endpoint

# Neon Connection String
DATABASE_URL=your_neon_database_connection_string

import { serve } from '@hono/node-server';
import { Hono } from 'hono';
import ImageKit from 'imagekit';
import { neon } from '@neondatabase/serverless';
import 'dotenv/config';

const imagekit = new ImageKit({
  publicKey: process.env.IMAGEKIT_PUBLIC_KEY,
  privateKey: process.env.IMAGEKIT_PRIVATE_KEY,
  urlEndpoint: process.env.IMAGEKIT_URL_ENDPOINT,
});

const sql = neon(process.env.DATABASE_URL);
const app = new Hono();

// Replace this with your actual user authentication logic
const authMiddleware = async (c, next) => {
  // Example: Validate JWT, session, etc. and set user ID
  c.set('userId', 'user_123'); // Static ID for demonstration
  await next();
};

// 1. Generate authentication parameters for client-side upload
app.get('/generate-auth-params', authMiddleware, (c) => {
  try {
    const authParams = imagekit.getAuthenticationParameters();
    // These params (token, expire, signature) are sent to the client
    // The client uses these + public key to upload directly to ImageKit
    return c.json({ success: true, ...authParams });
  } catch (error) {
    console.error('Auth Param Generation Error:', error);
    return c.json({ success: false, error: 'Failed to generate auth params' }, 500);
  }
});

// 2. Save metadata after client confirms successful upload to ImageKit
app.post('/save-metadata', authMiddleware, async (c) => {
  try {
    const userId = c.get('userId');
    // Client sends metadata received from ImageKit after upload
    const { fileId, url } = await c.req.json();

    if (!fileId || !url) {
      throw new Error('fileId and url are required from ImageKit response');
    }

    // Insert metadata into Neon database
    await sql`
      INSERT INTO imagekit_files (file_id, file_url, user_id)
      VALUES (${fileId}, ${url}, ${userId})
    `;

    console.log(`Metadata saved for ImageKit file: ${fileId}`);
    return c.json({ success: true });
  } catch (error) {
    console.error('Metadata Save Error:', error.message);
    return c.json({ success: false, error: 'Failed to save metadata' }, 500);
  }
});

const port = 3000;
serve({ fetch: app.fetch, port }, (info) => {
  console.log(`Server running at http://localhost:${info.port}`);
});

pip install Flask imagekitio psycopg2-binary python-dotenv

# ImageKit.io Credentials
IMAGEKIT_PUBLIC_KEY=your_imagekit_public_key
IMAGEKIT_PRIVATE_KEY=your_imagekit_private_key
IMAGEKIT_URL_ENDPOINT=your_imagekit_url_endpoint # for example, https://ik.imagekit.io/your_instance_id

# Neon Connection String
DATABASE_URL=your_neon_database_connection_string

import os

import psycopg2
from dotenv import load_dotenv
from flask import Flask, jsonify, request
from imagekitio.client import ImageKit

load_dotenv()

imagekit = ImageKit(
    public_key=os.getenv("IMAGEKIT_PUBLIC_KEY"),
    private_key=os.getenv("IMAGEKIT_PRIVATE_KEY"),
    url_endpoint=os.getenv("IMAGEKIT_URL_ENDPOINT"),
)

app = Flask(__name__)

# Use a global PostgreSQL connection pool in production instead of connecting per request
def get_db_connection():
    return psycopg2.connect(os.getenv("DATABASE_URL"))

# Replace this with your actual user authentication logic
def get_authenticated_user_id(request):
    # Example: Validate Authorization header, session cookie, etc.
    return "user_123"  # Static ID for demonstration

# 1. Generate authentication parameters for client-side upload
@app.route("/generate-auth-params", methods=["GET"])
def generate_auth_params_route():
    try:
        user_id = get_authenticated_user_id(request)
        if not user_id:
            return jsonify({"success": False, "error": "Unauthorized"}), 401

        # Generate token, expire timestamp, and signature
        auth_params = imagekit.get_authentication_parameters()
        return jsonify(
            {
                "success": True,
                "token": auth_params["token"],
                "expire": auth_params["expire"],
                "signature": auth_params["signature"]
            }
        ), 200

    except Exception as e:
        print(f"Auth Param Generation Error: {e}")
        return (
            jsonify({"success": False, "error": "Failed to generate auth params"}),
            500,
        )

# 2. Save metadata after client confirms successful upload to ImageKit
@app.route("/save-metadata", methods=["POST"])
def save_metadata_route():
    conn = None
    cursor = None
    try:
        user_id = get_authenticated_user_id(request)
        if not user_id:
            return jsonify({"success": False, "error": "Unauthorized"}), 401

        data = request.get_json()
        file_id = data.get("fileId")
        url = data.get("url")

        if not file_id or not url:
            raise ValueError("fileId and url are required from ImageKit response")

        # Insert metadata into Neon database
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute(
            """
            INSERT INTO imagekit_files (file_id, file_url, user_id)
            VALUES (%s, %s, %s)
            """,
            (file_id, url, user_id),
        )
        conn.commit()
        print(f"Metadata saved for ImageKit file: {file_id}")
        return jsonify({"success": True}), 201

    except (psycopg2.Error, ValueError) as e:
        print(f"Metadata Save Error: {e}")
        return (
            jsonify({"success": False, "error": "Failed to save metadata"}),
            500,
        )
    except Exception as e:
        print(f"Unexpected Metadata Save Error: {e}")
        return jsonify({"success": False, "error": "Server error"}), 500
    finally:
        if cursor:
            cursor.close()
        if conn:
            conn.close()

if __name__ == "__main__":
    app.run(port=3000, debug=True)