From Auth0

var myHeaders = new Headers();
myHeaders.append("Accept", "application/json");

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

const allUsers = [];
const response = await fetch("https://login.auth0.com/api/v2/organizations", requestOptions);
const organizations = await response.json();

// Write organizations to a file
fs.writeFileSync('auth0-organizations.json', JSON.stringify(organizations, null, 2));

for (const organization of organizations) {
    const response = await fetch(`https://login.auth0.com/api/v2/organizations/${organization.id}/users`, requestOptions);
    const users = await response.json();
    // Add organization name to each user and collect them
    users.forEach(user => {
        allUsers.push({
            ...user,
            organizationName: organization.name
        });
    });
}

// Write all users to a file
const fs = require('fs');
fs.writeFileSync('auth0-users.json', JSON.stringify(allUsers, null, 2));

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

interface Auth0User {
    Id: string;
    Nickname: string;
    Name: string;
    email: string;
    Connection: string;
    "Created At": string;
    "Updated At": string;
}

interface Auth0Organization {
    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('auth0-users.json', 'utf8');
        const users: Auth0User[] = 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.organizationName]);

                if (!tenant.rows[0]) {
                    console.error(`Tenant ${user.organizationName} 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('auth0-organizations.json', 'utf8');
        const organizations: Auth0Organization[] = 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();