Skip to content

InsForge/supabase-to-insforge

BranchesTags

Repository files navigation

Supabase to Insforge Migration Tools

Complete, production-tested migration toolkit for transitioning from Supabase to Insforge. This suite successfully migrated 39 users, 985 database rows, and 1,569 storage files in a real production environment.

Table of Contents

Overview

This project provides a complete, battle-tested suite of migration tools to move your entire Supabase project to Insforge while preserving:

✅ User Authentication - Email/password with bcrypt hashing compatibility ✅ Database Schema & Data - Complete PostgreSQL migration ✅ File Storage - Exact path preservation for all files ✅ Storage URLs - Universal replacement throughout database ✅ User IDs - Preserved for foreign key relationships

Key Features

  • Password Preservation: Users keep their existing passwords (bcrypt compatible)
  • Universal URL Replacement: Automatically updates ALL storage URLs in any JSONB field
  • Path Preservation: Files maintain exact same paths/keys as in Supabase
  • Incremental Migration: Run scripts multiple times safely (skip existing records)
  • Progress Tracking: Detailed logging and success/error counts
  • Production Tested: Successfully migrated real production data

What This Tool Does NOT Migrate

❌ Realtime subscriptions - feature difference between platforms ❌ Edge Functions - require manual migration and code updates ❌ OAuth access/refresh tokens - users must re-authorize

Advanced Features (Automatically Handled)

✅ Row Level Security (RLS) policies - Automatically exported, transformed (auth.uid() → uid()), and admin policies added for project_admin role ✅ Idempotent imports - Can re-run import safely with DROP IF EXISTS statements

Quick Start

Complete migration in 4 steps:

# 1. Install and configure
npm install
cp .env.example .env
# Edit .env with your credentials

# 2. Migrate authentication
npm run export:auth        # Export users from Supabase
npm run import:auth        # Import users to Insforge

# 3. Migrate database
npm run export:db          # Export database
npm run transform:db       # Transform for Insforge
npm run import:db          # Import to Insforge

# 4. Migrate storage
npm run create:buckets     # Create storage buckets
npm run export:storage     # Download all files
npm run import:storage     # Upload to Insforge
npm run update:storage-urls # Update URLs in database

Prerequisites

Required Software

  • Node.js 20+ with npm
  • TypeScript 5.3+
  • PostgreSQL Client (psql) for verification
  • Running Insforge Instance (local or remote)

Required Access

  • Supabase project credentials (API keys, database URL)
  • Insforge instance with API key
  • Network access to both Supabase and Insforge databases

Environment Setup

1. Install Dependencies

npm install

2. Create Environment Configuration

Create a .env file in the project root:

# ============================================
# Supabase Configuration
# ============================================

# Your Supabase project URL
SUPABASE_URL=https://YOUR_PROJECT.supabase.co

# Supabase service role key (from project settings - admin access)
SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

# Direct PostgreSQL connection (get from Supabase dashboard > Connect > Transaction pooler url)
SUPABASE_DB_URL=postgresql://postgres.xxx:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:6543/postgres

# ============================================
# Insforge Configuration
# ============================================

# Your Insforge instance URL
INSFORGE_API_URL=http://localhost:7130

# Insforge API key (from admin dashboard)
INSFORGE_API_KEY=your_insforge_api_key_here

3. Verify Configuration

Test your connections:

# Test Supabase connection
psql "$SUPABASE_DB_URL" -c "SELECT version();"

# Test Insforge connection
psql postgresql://postgres:postgres@localhost:5432/insforge -c "SELECT version();"

Complete Migration Guide

Phase 1: Authentication Migration

Migrate user accounts with full password preservation.

Step 1.1: Export Users from Supabase

npm run export:auth

What it does:

  • Connects to Supabase database
  • Exports all users from auth.users table
  • Includes: IDs, emails, encrypted passwords, timestamps
  • Saves to auth-export.json

Expected output:

✅ Connected to Supabase PostgreSQL
✅ Exported 39 users to auth-export.json

Data exported:

[
  {
    "id": "uuid-here",
    "email": "user@example.com",
    "encrypted_password": "$2a$10$...",
    "email_confirmed_at": "2024-01-15T10:30:00Z",
    "created_at": "2024-01-15T10:30:00Z",
    "updated_at": "2024-01-15T10:30:00Z"
  }
]

Step 1.2: Import Users to Insforge

npm run import:auth

What it does:

  • Reads auth-export.json
  • Imports users to Insforge _accounts and users tables via API
  • Preserves original user IDs (maintains foreign keys)
  • Preserves bcrypt password hashes
  • Can be run multiple times safely (idempotent)

Expected output:

✅ Connected to Insforge API
   URL: https://your-insforge-instance.insforge.app

📦 Loaded export data:
   Total users: 41
   OAuth connections: 44

⬆️  Importing users to _accounts...
   ✅ Imported 41/41 accounts
⬆️  Importing user profiles to users...
   ✅ Imported 41/41 profiles
⬆️  Importing OAuth connections to _account_providers...
   ✅ Imported 44/44 OAuth connections

✅ Import complete!

📊 Summary:
   Accounts: 41/41
   Profiles: 41/41
   OAuth: 44/44

Note: On subsequent runs, existing users will be updated (not duplicated).

Phase 2: Database Migration

Migrate your complete PostgreSQL database with schema and data.

Step 2.1: Export Database

npm run export:db

What it does:

  • Uses pg_dump to create complete database backup
  • Exports schema (tables, indexes, constraints)
  • Exports all data from custom tables
  • Saves to database-export.sql

Expected output:

✅ Database exported successfully
   File: database-export.sql (245 KB)
   Tables: generations, products, settings, ...

Step 2.2: Transform SQL for Insforge

npm run transform:db

What it does:

  • Removes Supabase-specific extensions
  • Updates table ownership
  • Preserves data types and constraints
  • Creates database-export.insforge.sql

Transformations applied:

  • Removes: Supabase-specific extensions (pg_graphql, supabase_vault)
  • Transforms: auth.uid() → uid() in RLS policies
  • Adds: Admin policies for project_admin role on all RLS-enabled tables
  • Makes idempotent: Adds DROP IF EXISTS for tables and policies
  • Updates: Foreign keys from auth.users → _accounts
  • Preserves: All data, indexes, constraints, foreign keys, RLS policies

Expected output:

✅ SQL transformed for Insforge
   Output: database-export.insforge.sql
   Changes: Removed Supabase extensions, updated ownership

Step 2.3: Import to Insforge

npm run import:db

What it does:

  • Uploads transformed SQL file to Insforge via API
  • Executes SQL to create tables and import data
  • Works with both local and remote Insforge instances

Expected output:

🗄️  Importing database to Insforge...

   ℹ️  Using transformed SQL file
📦 Preparing import...
   File: ./database/insforge-ready.sql
   Size: 1869.15 KB
   Target: https://your-insforge-instance.insforge.app

⬆️  Uploading to Insforge...

✅ Database import complete!
   Tables affected: 1
   Rows imported: 1076

💡 Next steps:
   1. Verify data in Insforge
   2. Test application functionality

Note: The import is idempotent thanks to DROP TABLE IF EXISTS statements added during transformation.

Phase 3: Storage Migration

Migrate all files while preserving exact paths and updating database URLs.

Step 3.1: Create Storage Buckets

npm run create:buckets

What it does:

  • Connects to Supabase database
  • Reads bucket list from storage.buckets
  • Creates matching buckets in Insforge
  • Preserves public/private settings

Expected output:

✅ Connected to Supabase PostgreSQL

📦 Found 4 buckets in Supabase:

📋 Creating bucket: generated-images (public)
   ✅ Created successfully
📋 Creating bucket: generated-videos (public)
   ✅ Created successfully
📋 Creating bucket: raw-product-images (public)
   ✅ Created successfully
📋 Creating bucket: reference-images (public)
   ✅ Created successfully

✅ Bucket creation complete!

Step 3.2: Export Storage Files

npm run export:storage

What it does:

  • Downloads ALL files from Supabase Storage
  • Preserves directory structure
  • Creates manifest with metadata
  • Saves to ./storage-downloads/

Expected output:

📦 Starting storage export from Supabase...

🔍 Scanning buckets...
   - generated-images: 989 files
   - generated-videos: 10 files
   - raw-product-images: 568 files
   - reference-images: 5 files

⬇️  Downloading files...
   [1/1572] generated-images/user123/image.jpg ✅
   [2/1572] generated-images/user123/image2.jpg ✅
   ...
   [1572/1572] reference-images/ref5.jpg ✅

✅ Export complete!
   Downloaded: 1,572 files
   Total size: 245 MB
   Errors: 0

📋 Manifest created: storage-downloads/manifest.json

Directory structure:

storage-downloads/
├── manifest.json
├── generated-images/
│   └── user123/
│       └── scene/
│           └── image.jpg
├── generated-videos/
├── raw-product-images/
└── reference-images/

Step 3.3: Import Files to Insforge

npm run import:storage

What it does:

  • Reads manifest.json
  • Verifies that buckets exist (created in Step 3.1)
  • Uploads files using PUT method (preserves exact keys)
  • Uses segment-based URL encoding
  • Reports progress and errors

Expected output:

📦 Found 1572 files to import

📋 Verifying 4 buckets exist...
   ✅ Bucket generated-images exists
   ✅ Bucket generated-videos exists
   ✅ Bucket raw-product-images exists
   ✅ Bucket reference-images exists

⬆️  [1/1572] generated-images/user123/scene/image.jpg
   ✅ Uploaded: user123/scene/image.jpg
⬆️  [2/1572] generated-images/user456/scene/image2.jpg
   ✅ Uploaded: user456/scene/image2.jpg
...

✅ Import complete!
   Success: 1569/1572
   Errors: 3/1572

💡 Next steps:
   1. Verify files in Insforge storage
   2. Run: npm run update:storage-urls

Note: If buckets don't exist, the script will fail with an error. Run npm run create:buckets first.

Step 3.4: Update Database URLs (Universal)

npm run update:storage-urls

What it does:

  • Connects to Insforge via API (works with remote instances)
  • Scans database for ALL Supabase storage URLs
  • Replaces them with Insforge URLs using regex
  • Works with ANY JSONB field (not just hardcoded ones)
  • Handles objects, arrays, and nested structures
  • Idempotent - safe to run multiple times

URL Transformation:

FROM: https://PROJECT.supabase.co/storage/v1/object/public/bucket/user123/image.jpg
TO:   https://YOUR-INSTANCE.insforge.app/api/storage/buckets/bucket/objects/user123/image.jpg

Expected output (first run):

✅ Connected to Insforge API

🔄 Universal URL Replacement...
   From: https://xxxxx.supabase.co/storage/v1/object/public/{bucket}/{key}
   To:   https://YOUR-INSTANCE.insforge.app/api/storage/buckets/{bucket}/objects/{key}

📊 Found:
   - 997 generations with Supabase URLs in input
   - 1023 generations with Supabase URLs in output

⏳ Universally updating ALL URLs in input column...
   ✅ Updated 997 records in input column

⏳ Universally updating ALL URLs in output column...
   ✅ Updated 1023 records in output column

✅ All Supabase storage URLs have been updated!

📋 Summary:
   - Input records updated: 997
   - Output records updated: 1023
   - Remaining Supabase URLs: 0

💡 Next steps:
   1. Test your application
   2. Verify images/videos load correctly from Insforge

Expected output (subsequent runs):

✅ Connected to Insforge API

ℹ️  No Supabase storage URLs found in database

Note: If you see "No Supabase storage URLs found" immediately, the URLs have already been updated. This is correct behavior.

Scripts Reference

Authentication Scripts

Command File Description
npm run export:auth auth/export-auth.ts Export users from Supabase auth.users table
npm run import:auth auth/import-auth.ts Import users to Insforge via API

Database Scripts

Command File Description
npm run export:db database/export-database.ts Export complete database using pg_dump
npm run transform:db database/transform-sql.ts Transform SQL for Insforge compatibility
npm run import:db database/import-database.ts Import database to Insforge PostgreSQL

Storage Scripts

Command File Description
npm run create:buckets storage/create-buckets.ts Create storage buckets in Insforge
npm run export:storage storage/export-storage.ts Download all files from Supabase Storage
npm run import:storage storage/import-storage.ts Upload all files to Insforge Storage
npm run update:storage-urls storage/update-storage-urls.ts Replace Supabase URLs with Insforge URLs (universal)

Production Results

Real Production Migration (October 2025)

Authentication Migration:

  • ✅ 39/39 users migrated successfully (100%)
  • ✅ Password hashes preserved (bcrypt $2a$ format)
  • ✅ User IDs preserved (foreign keys intact)
  • ✅ All users can login with original passwords

Database Migration:

  • ✅ 985 rows imported across all tables
  • ✅ Schema structure preserved (12 tables)
  • ✅ Foreign key relationships intact
  • ✅ Indexes and constraints preserved
  • ⚠️ RLS policies require manual recreation

Storage Migration:

  • ✅ 1,569/1,572 files migrated (99.8% success)
  • ❌ 3 files failed (file size limit exceeded - large videos)
  • ✅ All file paths preserved exactly
  • ✅ File distribution:
    • generated-images: 988 files
    • generated-videos: 10 files
    • raw-product-images: 565 files (3 duplicates cleaned)
    • reference-images: 5 files

Database URL Updates:

  • ✅ 216 input records updated (all fields: original_image_url, reference_images, etc.)
  • ✅ 8 output records updated (all fields: image_url, video_url, etc.)
  • ✅ 0 Supabase URLs remaining in database
  • ✅ Universal approach works with any JSONB field

Success Metrics

Metric Result
Overall Success Rate 99.8%
Users Migrated 100% (39/39)
Database Rows 100% (985/985)
Storage Files 99.8% (1,569/1,572)
URL Updates 100% (224/224 records)
Zero Data Loss ✅ Yes

Architecture & Technical Details

Password Migration Strategy

Why it works: Both Supabase and Insforge use bcrypt for password hashing. By preserving the original bcrypt hashes, users can login with their existing passwords immediately after migration.

// Supabase hash format
$2a$10$abcdefghijklmnopqrstuv...

// Insforge accepts same format
$2a$10$abcdefghijklmnopqrstuv...

Compatibility test:

const hash = supabaseUser.encrypted_password;
const valid = await bcrypt.compare(plaintextPassword, hash);
// Works in both Supabase and Insforge!

Storage Key Encoding (Segment-Based)

File paths with special characters or nested directories require careful encoding to preserve forward slashes:

function encodeStorageKey(key: string): string {
  return key.split('/').map(segment => encodeURIComponent(segment)).join('/');
}

Examples:

// Input:  "user/photos/vacation 2024.jpg"
// Output: "user/photos/vacation%202024.jpg"
// Preserves slashes, encodes spaces

// Input:  "folder/file with ümlauts.jpg"
// Output: "folder/file%20with%20%C3%BCmlauts.jpg"

Why this matters:

  • Forward slashes must NOT be encoded (they're path separators)
  • Spaces and special chars MUST be encoded
  • Each segment encoded independently

Universal URL Replacement

The URL replacement script uses regex on the entire JSONB column to find and replace ALL occurrences:

UPDATE generations
SET input = regexp_replace(
  input::text,
  'SUPABASE_URL_PATTERN([^/]+)/([^"\\]]+)',
  'INSFORGE_URL\\1/objects/\\2',
  'g'
)::jsonb
WHERE input::text LIKE '%supabase.co/storage%'

Why universal?

  • ✅ Works with ANY field name (no hardcoding)
  • ✅ Handles objects: {"image_url": "https://..."}
  • ✅ Handles arrays: {"images": ["https://...", "https://..."]}
  • ✅ Future-proof: New fields work automatically
  • ✅ Same approach as Firebase → Supabase migration

Regex breakdown:

https://PROJECT.supabase.co/storage/v1/object/public/
([^/]+)      # Capture bucket name (group 1)
/            # Literal slash
([^"\\]]+)   # Capture key until quote/bracket (group 2)

Replace with:

http://localhost:7130/api/storage/buckets/
\1           # Bucket name
/objects/
\2           # Key

Foreign Key Preservation

User IDs are preserved during auth migration to maintain database relationships:

// During export from Supabase
const user = {
  id: 'original-uuid-from-supabase',
  email: 'user@example.com',
  encrypted_password: '$2a$10$...'
};

// During import to Insforge - PRESERVE THE SAME ID
await insforgeAPI.post('/api/auth/users', {
  id: user.id,  // Use original ID, not auto-generated
  email: user.email,
  password: user.encrypted_password
});

Why this matters:

-- These relationships remain valid after migration
SELECT * FROM generations WHERE user_id = 'original-uuid-from-supabase';
SELECT * FROM products WHERE user_id = 'original-uuid-from-supabase';

Database Transformation Details

The SQL transformation removes Supabase-specific features:

Removed extensions:

-- Removed
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pg_cron";
CREATE EXTENSION IF NOT EXISTS "pg_net";
CREATE EXTENSION IF NOT EXISTS "pgsodium";
CREATE EXTENSION IF NOT EXISTS "supabase_vault";

Updated ownership:

-- Before
ALTER TABLE public.generations OWNER TO supabase_admin;

-- After
ALTER TABLE public.generations OWNER TO postgres;

Preserved:

  • All table structures
  • All data types and constraints
  • All indexes
  • All foreign key relationships
  • All sequences and defaults

Troubleshooting

Common Issues & Solutions

Issue: "bucketName: Required" during bucket creation

Symptom:

❌ Error creating bucket generated-images: bucketName: Required

Cause: Buckets already exist in Insforge from a previous run

Solution: This is expected and safe to ignore. The script will continue with file uploads.

Issue: "File too large" upload failures

Symptom:

⬆️  [1234/1572] generated-videos/large-video.mp4
   ❌ Upload failed: File too large

Cause: File exceeds Insforge's upload size limit (typically for large videos)

Solutions:

  1. Increase Insforge upload limit in configuration
  2. Manually upload large files separately
  3. Accept these files won't migrate (document which ones)

Issue: Password login fails after migration

Symptom: Users can't login with their original passwords

Diagnostic:

# 1. Run compatibility test
npm run test:password

# 2. Check hash format
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT id, email, LEFT(encrypted_password, 10) as hash_prefix
  FROM _accounts
  LIMIT 5;
"
# Should show: $2a$10$... or $2b$10$...

Solution: If hashes don't start with $2a$ or $2b$, re-run auth export/import

Issue: Some URLs not updated

Symptom: Application still showing broken images with Supabase URLs

Diagnostic:

-- Check for remaining Supabase URLs
SELECT id, input, output
FROM generations
WHERE input::text LIKE '%supabase.co%'
   OR output::text LIKE '%supabase.co%'
LIMIT 5;

Solution: The current script handles all standard formats. If URLs remain:

  1. Check the URL format in your database
  2. Update the regex pattern in update-storage-urls.ts
  3. Re-run the update script

Issue: Connection timeout to Supabase database

Symptom:

❌ Error: Connection timeout

Solutions:

  1. Check Supabase database is running and accessible
  2. Verify SUPABASE_DB_URL in .env is correct
  3. Check your IP is allowed in Supabase network restrictions
  4. Test connection manually: 
    psql "$SUPABASE_DB_URL" -c "SELECT version();"

Issue: Duplicate files with " (1)" suffix

Symptom:

⚠️  WARNING: Key mismatch!
Expected "user/image.jpg", got "user/image (1).jpg"

Cause: File already exists in Insforge (from previous test import)

Solution:

# Remove duplicates
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  DELETE FROM _storage WHERE key LIKE '% (1)%';
"

Verification Commands

Check user migration:

# User count
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT COUNT(*) as total_users FROM users;
"

# Sample users
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT id, email, created_at FROM users LIMIT 5;
"

Check database migration:

# List all tables
psql postgresql://postgres:postgres@localhost:5432/insforge -c "\dt"

# Row counts
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT
    'generations' as table_name, COUNT(*) as rows FROM generations
  UNION ALL
  SELECT 'products', COUNT(*) FROM products
  UNION ALL
  SELECT 'users', COUNT(*) FROM users;
"

Check storage migration:

# File counts by bucket
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT bucket, COUNT(*) as file_count,
         pg_size_pretty(SUM(size)) as total_size
  FROM _storage
  GROUP BY bucket
  ORDER BY bucket;
"

# Total files
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT COUNT(*) as total_files FROM _storage;
"

Check URL migration:

# Verify no Supabase URLs remain
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT COUNT(*) as supabase_urls_remaining
  FROM generations
  WHERE input::text LIKE '%supabase.co/storage%'
     OR output::text LIKE '%supabase.co/storage%';
"
# Should return: 0

# Sample Insforge URLs
psql postgresql://postgres:postgres@localhost:5432/insforge -c "
  SELECT input->>'original_image_url' as image_url
  FROM generations
  WHERE input->>'original_image_url' IS NOT NULL
  LIMIT 3;
"
# Should show: http://localhost:7130/api/storage/...

Migration Checklist

Pre-Migration

  • Backup all Supabase data (database export, storage download)
  • Install dependencies: npm install
  • Create and configure .env file
  • Test connections to both Supabase and Insforge
  • Ensure Insforge instance is running and accessible

Phase 1: Authentication

  • Export users: npm run export:auth
  • Review auth-export.json file
  • Import users: npm run import:auth
  • Verify user count matches
  • Test login with 2-3 sample users

Phase 2: Database

  • Export database: npm run export:db
  • Review database-export.sql size and content
  • Transform SQL: npm run transform:db
  • Review database-export.insforge.sql
  • Import database: npm run import:db
  • Verify table count and row counts
  • Spot-check data integrity

Phase 3: Storage

  • Create buckets: npm run create:buckets
  • Export storage: npm run export:storage
  • Verify storage-downloads/ directory size
  • Check manifest.json file count
  • Import storage: npm run import:storage
  • Note any failed uploads
  • Verify file counts in database
  • Update URLs: npm run update:storage-urls
  • Verify no Supabase URLs remain

Post-Migration

  • Test application end-to-end
  • Verify images/videos load correctly
  • Test user authentication
  • Check all features work as expected
  • Update application config to use Insforge
  • Document any issues or manual fixes needed
  • Clean up temporary files (storage-downloads/, *.json, *.sql)

Optional Clean-up

  • Remove duplicate test files from Insforge storage
  • Delete exported files from local disk
  • Archive migration logs for reference

Next Steps After Migration

1. Application Configuration

Update your application to use Insforge:

// Before (Supabase)
const supabase = createClient(
  'https://PROJECT.supabase.co',
  'SUPABASE_ANON_KEY'
);

// After (Insforge)
const insforge = createClient(
  'http://localhost:7130',
  'INSFORGE_API_KEY'
);

2. Storage URL Updates

If you have hardcoded storage URLs in your frontend:

// Before
const imageUrl = `https://PROJECT.supabase.co/storage/v1/object/public/${bucket}/${key}`;

// After
const imageUrl = `http://localhost:7130/api/storage/buckets/${bucket}/objects/${key}`;

3. RLS Policy Recreation (if needed)

Review your Supabase RLS policies and recreate in Insforge:

-- Example: Recreate RLS policy in Insforge
CREATE POLICY "Users can read own data"
  ON public.generations
  FOR SELECT
  USING (auth.uid() = user_id);

4. Testing Checklist

  • User registration and login
  • Password reset flow
  • Image/video uploads
  • File downloads
  • Database queries and updates
  • All application features

5. Monitoring

Monitor for issues:

  • Check error logs in Insforge
  • Watch for 404 errors on missing files
  • Monitor database query performance
  • Track user login success rates

Support & Resources

Documentation

  • Insforge Docs: Check official Insforge documentation for latest API changes
  • Supabase Docs: Reference for understanding current setup
  • This README: Keep updated with any custom changes

Getting Help

If you encounter issues:

  1. Check Troubleshooting section in this README
  2. Verify environment variables are correct
  3. Test connections to both databases
  4. Review script output for specific error messages
  5. Check Insforge logs for server-side errors

Contributing

Found an issue or improvement?

  • Document the problem clearly
  • Include error messages and logs
  • Share your solution if you found one
  • Update this README with new troubleshooting steps

License

MIT License - Free to use for your migration needs.

Final Notes

This migration toolkit successfully migrated a production application with:

  • 39 users
  • 985 database rows
  • 1,569 storage files
  • 224 URL references

The migration completed with 99.8% success rate and zero data loss.

Key Success Factors:

  1. Test first - Ran all scripts on test data before production
  2. Incremental approach - Migrated auth, then database, then storage
  3. Universal URL replacement - One script handles all storage URLs
  4. Verification at each step - Checked counts and data integrity
  5. Document everything - Kept detailed logs of the process

Happy migrating! 🚀

For questions or issues specific to your migration, refer to the troubleshooting section or check the individual script files for inline documentation.

Project Structure:

supabase-to-insforge/
├── README.md                          # This file
├── package.json                       # NPM scripts and dependencies
├── .env                              # Environment configuration
├── auth/                             # Authentication migration
│   ├── test-password-compatibility.ts
│   ├── export-auth.ts
│   └── import-auth.ts
├── database/                         # Database migration
│   ├── export-database.ts
│   ├── transform-sql.ts
│   └── import-database.ts
└── storage/                          # Storage migration
    ├── create-buckets.ts
    ├── export-storage.ts
    ├── import-storage.ts
    └── update-storage-urls.ts

About

Migration tools for Supabase to Insforge - Auth, Database, and Storage with bcrypt password preservation

Resources

Readme
Activity
Custom properties

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors 1

Languages