From Firebase

import * as admin from 'firebase-admin';
import * as fs from 'fs';

async function listAllTenants(nextPageToken, allTenants = []) {
  const result = await admin.auth().tenantManager().listTenants(100, nextPageToken);
  
  allTenants.push(...result.tenants.map(tenant => tenant.toJSON()));
  
  if (result.pageToken) {
    return await listAllTenants(result.pageToken, allTenants);
  }
  
  return allTenants;
}

async function listAllUsers(tenantId, nextPageToken, allUsers = []) {
  const tenantAuth = admin.auth().tenantManager().authForTenant(tenantId);
  
  try {
    const listUsersResult = await tenantAuth.listUsers(1000, nextPageToken);
    
    // Add users with their tenant ID
    allUsers.push(...listUsersResult.users.map(user => ({
      ...user.toJSON(),
      tenantId: tenantId
    })));
    
    if (listUsersResult.pageToken) {
      return await listAllUsers(tenantId, listUsersResult.pageToken, allUsers);
    }
    
    return allUsers;
  } catch (error) {
    console.error(`Error listing users for tenant ${tenantId}:`, error);
    return allUsers;
  }
}

async function exportAllTenantsAndUsers() {
  try {
    // Get all tenants first
    const tenants = await listAllTenants();
    const allUsers = [];

    // For each tenant, get all users
    for (const tenant of tenants) {
      console.log(`Fetching users for tenant: ${tenant.tenantId}`);
      const tenantUsers = await listAllUsers(tenant.tenantId, null);
      allUsers.push(...tenantUsers);
    }

    // Write tenants and users to separate files
    fs.writeFileSync('firebase-tenants.json', JSON.stringify(tenants, null, 2));
    fs.writeFileSync('firebase-users.json', JSON.stringify(allUsers, null, 2));
    
    console.log('Export completed! Data written to firebase-tenants.json and firebase-users.json');
  } catch (error) {
    console.error('Export failed:', error);
  }
}

// Start the export
exportAllTenantsAndUsers();

import { Nile } from "@niledatabase/server";
import * as fs from 'fs';

interface FirebaseUser {
    tenantId: string;
    uid: string;
    email: string;
    emailVerified: boolean;
    disabled: boolean;
    metadata: {
        lastSignInTime: string;
        lastSignInIp: string;
        lastLoginAt: string;
        lastLoginIp: string;
    };
    password: string;
    "Updated At": string;
}

interface FirebaseOrganization {
    id: string;
    name: string;
    display_name: string;
    metadata?: Record<string, any>;
}

async function migrateUsers(nile: any) {
    try {
        // Read and parse the JSON file
        const rawData = fs.readFileSync('firebase-users.json', 'utf8');
        const users: FirebaseUser[] = JSON.parse(rawData);
        let newUser;

        // Process each user
        for (const user of users) {
            try {
                // Generate a temporary password (you might want to adjust this strategy)
                const tempPassword = `temp-${Math.random().toString(36).slice(-8)}`;

                // Get the tenant id from the organization name
                const tenant = await nile.db.query(`SELECT id FROM tenants WHERE name = $1`, 
                    [user.tenantId]);

                if (!tenant.rows[0]) {
                    console.error(`Tenant ${user.tenantId} not found`);
                    continue;
                }
                nile.tenant_id = tenant.rows[0].id; // Set the tenant id so the user is created in the correct tenant
                newUser = await nile.api.users.createUser({
                    email: user.email,
                    password: tempPassword,
                    preferredName: user.Nickname || user.Name,
                });

                // uncomment this to update the password hash in the credentials table
                // only do this if you exported the password hashes in bcrypt format
                // await nile.db.query(
                //   `UPDATE auth.credentials SET payload = jsonb_build_object('crypt', 'crypt-bf/8', 'hash', $1) 
                //    WHERE user_id = $2 AND method = 'PASSWORD';`,
                //    [user.Password, newUser.Id]
                // )

                console.log(`Successfully migrated user: ${user.email}`);
                // You might want to store the temporary passwords to communicate them to users
                console.log(`Temporary password for ${user.email}: ${tempPassword}`);
            } catch (error) {
                console.error(`Failed to migrate user ${user.email}:`, error);
                // Continue with next user even if one fails
                continue;
            }
        }
        console.log('Migration completed');
    } catch (error) {
        console.error('Migration failed:', error);
    }
}

// This is necessary only if the organizations don't already exist in Nile
async function migrateTenants(nile: any) {
    try {
        // Read and parse the organizations JSON file
        const rawData = fs.readFileSync('firebase-tenants.json', 'utf8');
        const organizations: FirebaseOrganization[] = JSON.parse(rawData);

        // Process each organization
        for (const org of organizations) {
            try {
                const tenant = await nile.api.tenants.createTenant({
                    name: org.name,
                });

                console.log(`Successfully created tenant: ${org.name}`);
            } catch (error) {
                console.error(`Failed to create tenant ${org.name}:`, error);
                // Continue with next organization even if one fails
                continue;
            }
        }

        console.log('Tenant migration completed');
    } catch (error) {
        console.error('Tenant migration failed:', error);
    }
}

// Single initialization of Nile
async function migrateAll() {
    const nile = await Nile({});
    await migrateTenants(nile);
    await migrateUsers(nile);
}

migrateAll();