342 lines
11 KiB
JavaScript
342 lines
11 KiB
JavaScript
#!/usr/bin/env node
|
|
import { randomBytes } from 'crypto';
|
|
import { writeFileSync, copyFileSync } from 'fs';
|
|
import inquirer from 'inquirer';
|
|
import { spawnSync } from 'child_process';
|
|
import chalk from 'chalk';
|
|
|
|
const genUrlSafeBase64 = (bytes) => {
|
|
return randomBytes(bytes)
|
|
.toString('base64')
|
|
.replace(/\+/g, '-')
|
|
.replace(/\//g, '_')
|
|
.replace(/=+$/g, '');
|
|
}
|
|
|
|
|
|
const genRandomSubdomain = (length = 10) => {
|
|
const chars = 'abcdefghijklmnopqrstuvwxyz';
|
|
let result = '';
|
|
for (let i = 0; i < length; i++) {
|
|
result += chars.charAt(Math.floor(Math.random() * chars.length));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const genAlphanumericPassword = (length = 24) => {
|
|
const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
|
|
let result = '';
|
|
for (let i = 0; i < length; i++) {
|
|
result += chars.charAt(Math.floor(Math.random() * chars.length));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Helper to get or create a Supabase org
|
|
const getOrCreateSupabaseOrg = async () => {
|
|
|
|
// List orgs (table output)
|
|
const orgListResult = spawnSync(
|
|
'npx',
|
|
['supabase', 'orgs', 'list'],
|
|
{ encoding: 'utf-8' }
|
|
);
|
|
if (orgListResult.status !== 0) {
|
|
console.error(chalk.red('❌ Failed to list Supabase orgs.'));
|
|
process.exit(1);
|
|
}
|
|
const lines = orgListResult.stdout.split('\n').map(l => l.trim()).filter(Boolean);
|
|
|
|
// Find separator line (e.g., "------|------")
|
|
const sepIdx = lines.findIndex(line => line.includes('|') && line.includes('-'));
|
|
|
|
// If only header and separator, no orgs exist
|
|
if (lines.length <= sepIdx + 1) {
|
|
console.log(chalk.yellowBright('No Supabase organizations found.'));
|
|
const { createOrg } = await inquirer.prompt([
|
|
{
|
|
type: 'confirm',
|
|
name: 'createOrg',
|
|
message: chalk.cyan('Would you like to create a new Supabase organization now?'),
|
|
default: true,
|
|
},
|
|
]);
|
|
if (!createOrg) {
|
|
console.log(chalk.red('❌ Cannot continue without a Supabase organization. Exiting.'));
|
|
process.exit(1);
|
|
}
|
|
const { orgName } = await inquirer.prompt([
|
|
{
|
|
type: 'input',
|
|
name: 'orgName',
|
|
message: chalk.cyan('Enter a name for your new Supabase organization:'),
|
|
validate: (input) => input && input.length > 2,
|
|
},
|
|
]);
|
|
console.log(chalk.blueBright(`\nCreating Supabase organization '${orgName}'...`));
|
|
const createOrgResult = spawnSync(
|
|
'npx',
|
|
['supabase', 'orgs', 'create', orgName],
|
|
{ stdio: 'inherit', encoding: 'utf-8' }
|
|
);
|
|
if (createOrgResult.status !== 0) {
|
|
console.error(chalk.red('❌ Failed to create Supabase organization.'));
|
|
process.exit(1);
|
|
}
|
|
// Done! Org created, return
|
|
return;
|
|
}
|
|
|
|
// At least one org exists, just proceed
|
|
return;
|
|
};
|
|
|
|
const generateSupabaseDatabaseUrl = async () => {
|
|
// Step 3: Run supabase login
|
|
console.log(chalk.magentaBright('\n================ Supabase Setup ================\n'));
|
|
|
|
console.log(chalk.blueBright('\nLaunching Supabase login...'));
|
|
spawnSync('npx', ['supabase', 'login'], { stdio: 'inherit' });
|
|
|
|
// Step 3.5: Ensure org exists and select one
|
|
await getOrCreateSupabaseOrg();
|
|
|
|
// Step 4: Prompt for project name and region
|
|
const projectName = "autumn-oss-db";
|
|
|
|
// Step 5: Generate DB password (alphanumeric only)
|
|
const dbPassword = genAlphanumericPassword(24); // 24 chars, alphanumeric
|
|
|
|
// Step 6: Create Supabase project
|
|
console.log(chalk.blueBright(`\nCreating Supabase project '${projectName}'...`));
|
|
const createResult = spawnSync(
|
|
'npx',
|
|
['supabase', 'projects', 'create', projectName, '--db-password', dbPassword],
|
|
{ stdio: 'inherit', encoding: 'utf-8' }
|
|
);
|
|
|
|
if (createResult.status !== 0) {
|
|
console.error('❌ Failed to create Supabase project.');
|
|
process.exit(1);
|
|
}
|
|
|
|
// List supabase projects
|
|
const listResult = spawnSync(
|
|
'npx',
|
|
['supabase', 'projects', 'list', '--output', 'json'],
|
|
{ encoding: 'utf-8' }
|
|
);
|
|
|
|
if (listResult.status !== 0) {
|
|
console.error('❌ Failed to list Supabase projects.');
|
|
process.exit(1);
|
|
}
|
|
|
|
const projects = JSON.parse(listResult.stdout);
|
|
const found = projects.find(p => p.name === projectName);
|
|
if (!found) {
|
|
console.error(chalk.red('❌ Failed to find new Supabase project.'));
|
|
process.exit(1);
|
|
}
|
|
const projectId = found.id;
|
|
const region = found.region;
|
|
|
|
// Step 8: Construct DATABASE_URL
|
|
const databaseUrl = `postgresql://postgres.${projectId}:${dbPassword}@aws-0-${region}.pooler.supabase.com:5432/postgres`;
|
|
console.log(chalk.greenBright(`\nGenerated DB password: ${dbPassword}\n`));
|
|
console.log(chalk.greenBright(`\nYour DATABASE_URL is:\n${databaseUrl}\n`));
|
|
console.log(chalk.yellow('--------------------------------'));
|
|
|
|
// Step 9: Prompt to run docker compose up
|
|
console.log(chalk.magentaBright('\nNext steps:'));
|
|
console.log(chalk.yellow('Run "docker compose -f docker-compose.dev.yml up" to start Autumn'));
|
|
|
|
|
|
return databaseUrl;
|
|
}
|
|
|
|
const handleDatabaseSetup = async () => {
|
|
// Step 2: Ask user what to do for DB
|
|
console.log(chalk.magentaBright('\n================ Autumn Database Setup ================\n'));
|
|
const { dbOption } = await inquirer.prompt([
|
|
{
|
|
type: 'list',
|
|
name: 'dbOption',
|
|
message: chalk.cyan('How do you want to set up your database?'),
|
|
choices: [
|
|
{ name: 'Set up Supabase (Cloud) for Autumn', value: 'supabase' },
|
|
{ name: 'Paste in your own DATABASE_URL', value: 'paste' },
|
|
{ name: 'Paste in your own DATABASE_URL later', value: 'later' },
|
|
],
|
|
default: 'supabase',
|
|
},
|
|
]);
|
|
|
|
let databaseUrl = '';
|
|
|
|
if (dbOption === 'supabase') {
|
|
databaseUrl = await generateSupabaseDatabaseUrl();
|
|
} else if (dbOption === 'paste') {
|
|
databaseUrl = await inquirer.prompt([
|
|
{
|
|
type: 'input',
|
|
name: 'databaseUrl',
|
|
message: 'Paste in your DATABASE_URL:',
|
|
validate: (input) => input && input.length > 5,
|
|
},
|
|
]);
|
|
} else if (dbOption === 'later') {
|
|
databaseUrl = '';
|
|
}
|
|
|
|
return databaseUrl;
|
|
}
|
|
|
|
const handleLocalRunSetup = async () => {
|
|
// Step 10: Stripe webhook URL setup
|
|
console.log(chalk.magentaBright('\n================ Stripe Webhook Setup ================\n'));
|
|
const { webhookOption } = await inquirer.prompt([
|
|
{
|
|
type: 'list',
|
|
name: 'webhookOption',
|
|
message:
|
|
chalk.cyan('Stripe requires a public URL to send webhook events to your app.\nThis is read from the STRIPE_WEBHOOK_URL environment variable.\n\nWould you like to:'),
|
|
choices: [
|
|
{ name: '1. Generate a localtunnel URL (recommended for local development)', value: 'localtunnel' },
|
|
{ name: '2. Skip for now and paste in your own URL later', value: 'skip' },
|
|
],
|
|
default: 'localtunnel',
|
|
},
|
|
]);
|
|
|
|
let stripeWebhookVars = [];
|
|
|
|
if (webhookOption === 'localtunnel') {
|
|
const subdomain = genRandomSubdomain(32);
|
|
const webhookUrl = `https://${subdomain}.loca.lt`;
|
|
stripeWebhookVars.push(`STRIPE_WEBHOOK_URL=${webhookUrl}`);
|
|
stripeWebhookVars.push(`LOCALHOST_RUN_SUBDOMAIN=${subdomain}`);
|
|
console.log(chalk.greenBright(`\nTo start your webhook tunnel, run this in another terminal:\n`));
|
|
console.log(chalk.yellowBright(` npx localtunnel --port 8080 --subdomain ${subdomain}\n`));
|
|
console.log(chalk.greenBright(`\nTest your webhook URL with:\n`));
|
|
console.log(chalk.yellowBright(` curl ${webhookUrl}\n`));
|
|
console.log(chalk.cyan('If you need to restart the tunnel in the future, use the same command.'));
|
|
} else if (webhookOption === 'paste') {
|
|
const { stripeWebhookUrl } = await inquirer.prompt([
|
|
{
|
|
type: 'input',
|
|
name: 'stripeWebhookUrl',
|
|
message: chalk.cyan('Paste in your STRIPE_WEBHOOK_URL:'),
|
|
validate: (input) => input && input.length > 5,
|
|
},
|
|
]);
|
|
stripeWebhookVars.push(`STRIPE_WEBHOOK_URL=${stripeWebhookUrl}`);
|
|
} else {
|
|
// skip
|
|
}
|
|
|
|
console.log(chalk.yellow('--------------------------------'));
|
|
|
|
return stripeWebhookVars;
|
|
}
|
|
|
|
async function main() {
|
|
// Step 1: Generate secrets
|
|
console.log(chalk.magentaBright('\n================ Autumn Setup ================\n'));
|
|
const localtunnelReservedKey = genRandomSubdomain(32);
|
|
const secrets = {
|
|
BETTER_AUTH_SECRET: genUrlSafeBase64(64),
|
|
ENCRYPTION_IV: genUrlSafeBase64(16),
|
|
ENCRYPTION_PASSWORD: genUrlSafeBase64(64),
|
|
BETTER_AUTH_URL: 'http://localhost:8080',
|
|
CLIENT_URL: 'http://localhost:3000',
|
|
LOCALTUNNEL_RESERVED_KEY: localtunnelReservedKey,
|
|
STRIPE_WEBHOOK_URL: `https://${localtunnelReservedKey}.loca.lt`,
|
|
};
|
|
|
|
let databaseUrl = "";
|
|
let stripeWebhookVars = [];
|
|
|
|
databaseUrl = await handleDatabaseSetup();
|
|
// stripeWebhookVars = await handleLocalRunSetup();
|
|
|
|
// Step 11: Write to server/.env
|
|
console.log(chalk.magentaBright('\n================ Writing .env ================\n'));
|
|
const envSections = [];
|
|
|
|
// Autumn Auth section
|
|
envSections.push(
|
|
'# Auth',
|
|
`BETTER_AUTH_SECRET=${secrets.BETTER_AUTH_SECRET}`,
|
|
`BETTER_AUTH_URL=${secrets.BETTER_AUTH_URL}`,
|
|
`CLIENT_URL=${secrets.CLIENT_URL}`,
|
|
''
|
|
);
|
|
|
|
// Stripe required section
|
|
envSections.push(
|
|
'# Stripe',
|
|
`LOCALTUNNEL_RESERVED_KEY=${secrets.LOCALTUNNEL_RESERVED_KEY}`,
|
|
`ENCRYPTION_IV=${secrets.ENCRYPTION_IV}`,
|
|
`ENCRYPTION_PASSWORD=${secrets.ENCRYPTION_PASSWORD}`,
|
|
`STRIPE_WEBHOOK_URL=${secrets.STRIPE_WEBHOOK_URL}`,
|
|
''
|
|
);
|
|
|
|
// Database section
|
|
if (databaseUrl) {
|
|
envSections.push(
|
|
'# Database',
|
|
`DATABASE_URL=${databaseUrl}`,
|
|
''
|
|
);
|
|
}
|
|
|
|
// Stripe Webhooks section
|
|
if (stripeWebhookVars.length > 0) {
|
|
envSections.push('# Stripe Webhooks');
|
|
envSections.push(...stripeWebhookVars);
|
|
envSections.push('');
|
|
}
|
|
|
|
const envVars = envSections.join('\n');
|
|
|
|
|
|
writeFileSync('server/.env', envVars);
|
|
try {
|
|
copyFileSync('vite/.env.example', 'vite/.env');
|
|
} catch (error) {
|
|
console.log(chalk.red('❌ Failed to copy vite/.env.example to vite/.env'));
|
|
console.log(chalk.red('❌ Please copy the file manually'));
|
|
}
|
|
|
|
console.log(chalk.greenBright('🎉 Setup complete! 🎉'));
|
|
console.log(chalk.cyan('You can find your env variables in server/.env'));
|
|
|
|
|
|
// Prompt to run pnpm run db:push at the end
|
|
const { runDbPush } = await inquirer.prompt([
|
|
{
|
|
type: 'confirm',
|
|
name: 'runDbPush',
|
|
message: chalk.cyan('Would you like to run "pnpm run db:push" to set up your tables now?'),
|
|
default: true,
|
|
},
|
|
]);
|
|
|
|
if (runDbPush) {
|
|
console.log(chalk.blueBright('\nRunning "pnpm run db:push"...'));
|
|
const dbPushResult = spawnSync('pnpm', ['run', 'db:push'], { stdio: 'inherit', encoding: 'utf-8' });
|
|
if (dbPushResult.status !== 0) {
|
|
console.error(chalk.red('❌ Failed to run "pnpm run db:push". Please check the error above.'));
|
|
process.exit(1);
|
|
}
|
|
console.log(chalk.greenBright('✅ Successfully ran "pnpm run db:push".'));
|
|
}
|
|
|
|
console.log(chalk.cyan('\nNext steps:'));
|
|
console.log(chalk.cyan('Run the following command to start Autumn:'));
|
|
console.log(chalk.cyan(' docker compose -f docker-compose.dev.yml up'));
|
|
}
|
|
|
|
main();
|