Database Setup

/**
 * Database connection configuration
 */
interface DatabaseInfo {
  /** Database client type */
  client?: string;
  /** Connection configuration object */
  connection: {
    /** Database host address */
    host?: string;
    /** Database port number */
    port?: string;
    /** Database name */
    database?: string;
    /** Database username */
    username?: string;
    /** Database password */
    password?: string;
    /** SQLite database file path */
    filename?: string;
    /** Enable SSL connection */
    ssl?: boolean;
  };
  /** Use NULL as default value for SQLite */
  useNullAsDefault?: boolean;
}

/**
 * Supported database client names
 */
type ClientName = 'mysql' | 'mysql2' | 'postgres' | 'sqlite' | 'sqlite-legacy';

/**
 * Complete database configuration for project generation
 */
interface Configuration {
  /** Database client identifier */
  client: string;
  /** Database connection information */
  connection: DatabaseInfo;
  /** Required database client dependencies */
  dependencies: Record<string, string>;
}

/**
 * Default database configurations for each client type
 * Includes optimized settings for development environments
 */
const defaultConfigs: Record<ClientName, DatabaseInfo>;

// SQLite (default)
{
  client: 'sqlite',
  connection: {
    filename: '.tmp/data.db'
  },
  useNullAsDefault: true
}

// PostgreSQL
{
  client: 'postgres',
  connection: {
    host: 'localhost',
    port: '5432',
    database: 'strapi',
    username: 'strapi',
    password: 'strapi'
  }
}

// MySQL
{
  client: 'mysql',
  connection: {
    host: 'localhost',
    port: '3306',
    database: 'strapi',
    username: 'strapi',
    password: 'strapi'
  }
}

/**
 * Gets required dependencies for a database client
 * @param options - Object containing client type
 * @returns Object with dependency names and versions
 */
function clientDependencies(options: { client: string }): Record<string, string>;

// SQLite
{ 'better-sqlite3': '^8.0.0' }

// PostgreSQL  
{ 'pg': '^8.8.0' }

// MySQL
{ 'mysql2': '^2.3.0' }

/**
 * Interactive database configuration questions for each client type
 * Provides client-specific prompts for connection details
 */
const dbQuestions: Record<string, Array<Function>>;

/**
 * Prompts user for database client selection
 * @returns Selected database client ('sqlite' | 'postgres' | 'mysql')
 */
function askDatabaseClient(): Promise<string>;

/**
 * Prompts for database connection details based on selected client
 * @param client - Selected database client type
 * @param scope - Project configuration scope
 * @returns Database connection configuration
 */
function askDatabaseConnection(client: string, scope: Scope): Promise<DatabaseInfo>;

/**
 * Creates database configuration file content
 * @param options - Configuration options including TypeScript flag
 * @returns Database configuration file content as string
 */
function createDatabaseConfig(options: { useTypescript: boolean }): string;

export default ({ env }) => ({
  connection: {
    client: env('DATABASE_CLIENT', 'sqlite'),
    connection:
      env('DATABASE_CLIENT', 'sqlite') === 'sqlite'
        ? {
            filename: path.join(__dirname, '..', env('DATABASE_FILENAME', '.tmp/data.db')),
          }
        : {
            host: env('DATABASE_HOST', 'localhost'),
            port: env.int('DATABASE_PORT', 5432),
            database: env('DATABASE_NAME', 'strapi'),
            user: env('DATABASE_USERNAME', 'strapi'),
            password: env('DATABASE_PASSWORD', 'strapi'),
            ssl: env.bool('DATABASE_SSL', false),
          },
  },
});

/**
 * Generates database environment variables for .env file
 * @param params - Database client and connection configuration
 * @returns Environment variable declarations as string
 */
function generateDbEnvariables(params: {
  client: string;
  connection: DatabaseInfo;
}): string;

# Database
DATABASE_CLIENT=postgres
DATABASE_HOST=localhost
DATABASE_PORT=5432
DATABASE_NAME=myapp
DATABASE_USERNAME=postgres
DATABASE_PASSWORD=password
DATABASE_SSL=false

/**
 * Resolves database client name to standardized format
 * @param client - Raw client name from user input
 * @returns Standardized client name
 */
function resolveClientName(client: string): ClientName;

/**
 * Validates if a client name is supported
 * @param client - Client name to validate
 * @returns true if client is supported
 */
function isValidClient(client: string): boolean;

import { generateNewApp } from "@strapi/generate-new";

// SQLite (default)
await generateNewApp("./my-app", {
  quickstart: true
});

// PostgreSQL
await generateNewApp("./my-app", {
  dbclient: "postgres",
  dbhost: "localhost",
  dbport: "5432",
  dbname: "myapp",
  dbusername: "postgres",
  dbpassword: "password"
});

// MySQL with SSL
await generateNewApp("./my-app", {
  dbclient: "mysql",
  dbhost: "mysql.example.com",
  dbport: "3306",
  dbname: "production_db",
  dbusername: "app_user",
  dbpassword: "secure_password",
  dbssl: "true"
});

// Using environment variables
await generateNewApp("./my-app", {
  dbclient: process.env.DB_CLIENT || "postgres",
  dbhost: process.env.DB_HOST || "localhost",
  dbport: process.env.DB_PORT || "5432",
  dbname: process.env.DB_NAME || "strapi",
  dbusername: process.env.DB_USER || "strapi",
  dbpassword: process.env.DB_PASS || "strapi"
});