The complete open source platform to run your entire marketplace. Storefront, vendor panel, admin console, and integrations in one enterprise-grade platform you own.
TypeScript b2b-marketplacecomposable-commerceecommerceenterpriseheadless-commercemarketplacemedusamedusajsmulti-vendortypescript
import { getPackageManager } from "./get-package-manager";
import { logger } from "./logger";
import { manageEnvFiles } from "./manage-env-files";
import { markDemoDataSeeded } from "./mark-demo-data";
import { spinner } from "./spinner";
import { execa } from "execa";
import type { Ora } from "ora";
import path from "path";
import pg from "pg";
import prompts from "prompts";
const dbHost = "localhost";
const dbPort = 5432;
const API_DIR = "packages/api";
const ADMIN_EMAIL = "[email protected]";
interface DbSetupArgs {
projectDir: string;
spinner?: Ora;
}
export interface SetupDatabaseResult {
success: boolean;
dbName: string;
connectionString: string | null;
alreadyExists?: boolean;
inviteToken?: string | null;
publishableKey?: string | null;
}
export async function setupDatabase(args: {
projectDir: string;
projectName: string;
dbConnectionString?: string;
dbHost?: string;
dbPort?: number;
spinner?: Ora;
}): Promise<SetupDatabaseResult> {
const dbName = args.projectName.replace(/[^a-zA-Z0-9]/g, "-");
const { client, dbConnectionString } = await getDbClient({
dbConnectionString: args.dbConnectionString,
dbHost: args.dbHost ?? dbHost,
dbPort: args.dbPort ?? dbPort,
dbName,
spinner: args.spinner,
});
if (!client || !dbConnectionString) {
return { success: false, dbName, connectionString: null };
}
try {
if (args.spinner) {
args.spinner.text = "Checking if database exists...";
}
const exists = await doesDbExist(client, dbName);
if (exists) {
await client.end();
return runPostDbSetup({
...args,
dbName,
connectionString: dbConnectionString,
alreadyExists: true,
});
}
if (args.spinner) {
args.spinner.text = `Creating database "${dbName}"...`;
}
await client.query(`CREATE DATABASE "${dbName}"`);
await client.end();
return runPostDbSetup({
...args,
dbName,
connectionString: dbConnectionString,
alreadyExists: false,
});
} catch (err) {
logger.error(
`Error creating database${err instanceof Error ? `: ${err.message}` : ""}.`
);
await client.end().catch(() => {});
return { success: false, dbName, connectionString: null };
}
}
async function runPostDbSetup(args: DbSetupArgs & {
dbName: string;
connectionString: string;
alreadyExists: boolean;
}): Promise<SetupDatabaseResult> {
const { projectDir, spinner, dbName, connectionString, alreadyExists } = args;
// Medusa needs DATABASE_URL in .env before running migrations
await manageEnvFiles({
projectDir,
databaseUri: connectionString,
});
const migrated = await runMigrations({ projectDir, spinner });
if (!migrated) {
return { success: false, dbName, connectionString: null };
}
const seeded = await seedDatabase({ projectDir, spinner });
if (!seeded) {
return { success: false, dbName, connectionString: null };
}
await markDemoDataSeeded({ connectionString });
const inviteToken = await createAdminInvite({ projectDir });
const publishableKey = await getPublishableKey({ connectionString });
// Now that the storefront .env exists, inject the seeded publishable key.
if (publishableKey) {
await manageEnvFiles({
projectDir,
databaseUri: connectionString,
publishableKey,
});
}
return {
success: true,
dbName,
connectionString,
alreadyExists,
inviteToken,
publishableKey,
};
}
async function getPublishableKey({
connectionString,
}: {
connectionString: string;
}): Promise<string | null> {
const client = new pg.Client({ connectionString });
try {
await client.connect();
const result = await client.query(
`SELECT token FROM api_key WHERE type = 'publishable' AND revoked_at IS NULL AND deleted_at IS NULL ORDER BY created_at ASC LIMIT 1;`
);
return result.rows[0]?.token ?? null;
} catch (err) {
logger.error(
`Error reading publishable API key${err instanceof Error ? `: ${err.message}` : ""}.`
);
return null;
} finally {
await client.end().catch(() => {});
}
}
interface DbClientResult {
client: pg.Client | null;
dbConnectionString: string | null;
}
async function getDbClient({
dbConnectionString,
dbHost,
dbPort,
dbName,
spinner: spinnerRef,
}: {
dbConnectionString?: string;
dbHost: string;
dbPort: number;
dbName: string;
spinner?: Ora;
}): Promise<DbClientResult> {
if (dbConnectionString) {
try {
const client = new pg.Client({ connectionString: dbConnectionString });
await client.connect();
return { client, dbConnectionString };
} catch (error) {
logger.error(
`Invalid database connection string${error instanceof Error ? `: ${error.message}` : ""}.`
);
return { client: null, dbConnectionString: null };
}
}
// Step 1: silent default attempt (postgres / no password)
if (spinnerRef) {
spinnerRef.text = `Trying default connection (postgres@${dbHost}:${dbPort})...`;
}
try {
const client = new pg.Client({
user: "postgres",
password: "",
host: dbHost,
port: dbPort,
database: "postgres",
connectionTimeoutMillis: 5000,
});
await client.connect();
return {
client,
dbConnectionString: formatConnectionString({
user: "postgres",
password: "",
host: dbHost,
port: dbPort,
db: dbName,
}),
};
} catch {
// Default connection failed — ask the user for credentials
}
spinnerRef?.stop();
logger.break();
logger.log(`PostgreSQL is required. Make sure it is installed and running on ${dbHost}:${dbPort}.`);
logger.break();
// Step 2: prompt with up to 3 retry attempts
const MAX_ATTEMPTS = 3;
for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
const attemptSuffix = attempt > 1 ? ` (attempt ${attempt}/${MAX_ATTEMPTS})` : "";
const answers = await prompts([
{
type: "text",
name: "postgresUsername",
message: `Enter your Postgres username${attemptSuffix}`,
initial: "postgres",
},
{
type: "password",
name: "postgresPassword",
message: 'Enter your Postgres password (press Enter for "postgres")',
},
]);
// User cancelled (Ctrl+C)
if (!answers.postgresUsername) {
return { client: null, dbConnectionString: null };
}
const username = answers.postgresUsername as string;
const password = (answers.postgresPassword as string) || "postgres";
spinnerRef?.start("Connecting to database...");
try {
const client = new pg.Client({
user: username,
password,
host: dbHost,
port: dbPort,
database: "postgres",
connectionTimeoutMillis: 5000,
});
await client.connect();
return {
client,
dbConnectionString: formatConnectionString({
user: username,
password,
host: dbHost,
port: dbPort,
db: dbName,
}),
};
} catch (err) {
spinnerRef?.stop();
const message = err instanceof Error ? err.message : String(err);
if (attempt < MAX_ATTEMPTS) {
logger.warn(`Attempt ${attempt}/${MAX_ATTEMPTS} failed: ${message}`);
} else {
logger.error(
`Couldn't connect to PostgreSQL: ${message}\n` +
` → Is PostgreSQL running? Try: pg_isready -h ${dbHost} -p ${dbPort}\n` +
` → Check your username, password, and that the server is accessible.`
);
}
}
}
return { client: null, dbConnectionString: null };
}
async function doesDbExist(
client: pg.Client,
dbName: string
): Promise<boolean> {
const result = await client.query(
`SELECT datname FROM pg_catalog.pg_database WHERE datname='${dbName}';`
);
return (result.rowCount ?? 0) > 0;
}
function formatConnectionString({
user,
password,
host,
port = dbPort,
db,
}: {
user: string;
password: string;
host: string;
port?: number;
db: string;
}): string {
const encodedPassword = encodeURIComponent(password);
return `postgresql://${user}:${encodedPassword}@${host}:${port}/${db}`;
}
async function runMigrations({ projectDir, spinner: parentSpinner }: DbSetupArgs): Promise<boolean> {
const apiDir = path.join(projectDir, API_DIR);
const packageManager = await getPackageManager(apiDir);
const migrationSpinner = parentSpinner || spinner("Running migrations...").start();
const buildCmd = packageManager === "yarn"
? ["yarn", "run", "build"]
: packageManager === "pnpm"
? ["pnpm", "run", "build"]
: packageManager === "bun"
? ["bun", "run", "build"]
: ["npm", "run", "build"];
const runnerCmd = packageManager === "yarn"
? ["yarn"]
: packageManager === "pnpm"
? ["pnpm", "exec"]
: packageManager === "bun"
? ["bunx"]
: ["npx"];
try {
// Build first - compiles TypeScript so ts-node is not needed
migrationSpinner.text = "Building project...";
await execa(buildCmd[0], buildCmd.slice(1), { cwd: apiDir });
migrationSpinner.text = "Running database migrations...";
await execa(runnerCmd[0], [...runnerCmd.slice(1), "medusa", "db:migrate"], { cwd: apiDir });
if (!parentSpinner) {
migrationSpinner.succeed("Migrations completed successfully.");
}
return true;
} catch (err) {
migrationSpinner.fail("Failed to run migrations.");
logger.error(
`Error running migrations${err instanceof Error ? `: ${err.message}` : ""}.`
);
return false;
}
}
async function createAdminInvite({ projectDir }: { projectDir: string }): Promise<string | null> {
const apiDir = path.join(projectDir, API_DIR);
const packageManager = await getPackageManager(apiDir);
const runnerCmd = packageManager === "yarn"
? ["yarn"]
: packageManager === "pnpm"
? ["pnpm", "exec"]
: packageManager === "bun"
? ["bunx"]
: ["npx"];
try {
const result = await execa(runnerCmd[0], [...runnerCmd.slice(1), "medusa", "user", "-e", ADMIN_EMAIL, "--invite"], {
cwd: apiDir,
});
// Parse token from stdout - same approach as Medusa CLI
const match = result.stdout.match(/Invite token: (?<token>.+)/);
return match?.groups?.token || null;
} catch (err) {
logger.error(
`Error creating admin invite${err instanceof Error ? `: ${err.message}` : ""}.`
);
return null;
}
}
async function seedDatabase({ projectDir, spinner: parentSpinner }: DbSetupArgs): Promise<boolean> {
const apiDir = path.join(projectDir, API_DIR);
const packageManager = await getPackageManager(apiDir);
const seedSpinner = parentSpinner || spinner("Seeding database...").start();
try {
const seedCmd = packageManager === "yarn"
? ["yarn", "seed"]
: packageManager === "pnpm"
? ["pnpm", "run", "seed"]
: packageManager === "bun"
? ["bun", "run", "seed"]
: ["npm", "run", "seed"];
seedSpinner.text = "Seeding database with demo data...";
await execa(seedCmd[0], seedCmd.slice(1), { cwd: apiDir });
if (!parentSpinner) {
seedSpinner.succeed("Database seeded successfully.");
}
return true;
} catch (err) {
seedSpinner.fail("Failed to seed database.");
logger.error(
`Error seeding database${err instanceof Error ? `: ${err.message}` : ""}.`
);
return false;
}
}