[FEATURE] Implement Sequelize's migration system to manage database schema changes

[nanotaboada]

Problem

The application currently uses a pre-seeded SQLite database file (storage/players-sqlite3.db) that is copied into the Docker container and mounted as a persistent volume. While this approach works for a Proof of Concept, it presents several challenges for production-ready development:

1. Manual Schema Changes: Any database schema modification requires manually editing the SQLite file or recreating it from scratch, which is error-prone and not version-controlled.
2. No Version Control for Schema: The database structure is embedded in a binary file (.db), making it impossible to track schema changes through git history.
3. Team Collaboration Issues: Multiple developers cannot easily sync database schema changes. Each dev must manually replicate schema modifications.
4. No Rollback Capability: There's no built-in way to revert schema changes if an update causes issues.
5. Deployment Complexity: Applying schema updates to existing production databases requires custom scripts and manual intervention.
6. Testing Challenges: Integration tests rely on the pre-seeded database state, making it harder to test schema changes independently.

Current Approach:

• Pre-seeded storage/players-sqlite3.db file committed to repository
• Docker entrypoint copies database from /app/hold/ to persistent volume /storage/ on first run
• Schema defined implicitly in Sequelize model (src/models/player-model.ts)
• No automated way to create, update, or rollback schema changes

Problems for Future Development:

• Adding new columns/tables requires manual SQL or full DB recreation
• No audit trail for schema evolution
• Cannot easily support multiple environments (dev, staging, prod) with different schema states
• Difficult to coordinate schema changes with code deployments

Proposed Solution

Implement Sequelize's migration system to manage database schema changes in a version-controlled, automated, and reversible manner. Migrations provide:

1. Version-Controlled Schema: Each migration is a timestamped file in git, providing full schema history
2. Automated Application: Run npx sequelize-cli db:migrate to apply pending migrations
3. Rollback Support: Use db:migrate:undo to revert changes safely
4. Team Synchronization: Developers pull migration files and run migrations locally to sync schemas
5. CI/CD Integration: Migrations can run automatically as part of deployment pipelines
6. Environment Parity: Ensure dev, staging, and prod databases stay in sync

Benefits:

• ✅ Track schema changes in git with commit messages
• ✅ Apply schema updates consistently across environments
• ✅ Rollback problematic changes without data loss
• ✅ Generate initial schema from existing models
• ✅ Support future features (adding columns, indexes, foreign keys)
• ✅ Enable database seeding as separate step from schema creation

Migration Workflow:

1. Developer creates migration: npx sequelize-cli migration:generate --name add-player-nationality
2. Developer writes up() and down() functions in migration file
3. Migration committed to git and pushed
4. Other developers pull and run: npx sequelize-cli db:migrate
5. Production deployment runs migrations automatically

Suggested Approach

1. Install Sequelize CLI and Dependencies

npm install --save-dev sequelize-cli
npm install --save-dev @types/node

Note: sequelize is already installed as a dependency.

2. Create .sequelizerc Configuration File

File: .sequelizerc (root directory)

This tells Sequelize CLI where to find migrations, models, and config files:

const path = require('path');

module.exports = {
    'config': path.resolve('config', 'database.json'),
    'models-path': path.resolve('src', 'models'),
    'seeders-path': path.resolve('database', 'seeders'),
    'migrations-path': path.resolve('database', 'migrations'),
};

Directory Structure:

database/
├── migrations/        # Migration files (timestamped)
└── seeders/          # Seed data files (optional)
config/
└── database.json     # Database configuration for each environment

3. Create Database Configuration File

File: config/database.json

{
  "development": {
    "dialect": "sqlite",
    "storage": "./storage/players-sqlite3.db",
    "logging": console.log
  },
  "test": {
    "dialect": "sqlite",
    "storage": ":memory:",
    "logging": false
  },
  "production": {
    "dialect": "sqlite",
    "storage": "/storage/players-sqlite3.db",
    "logging": false
  }
}

Explanation:

• development: Local SQLite file in storage/ directory
• test: In-memory database for fast test execution
• production: Docker volume mount path (/storage/ in container)

Alternative: Use TypeScript config file (config/database.ts) and export dynamic configuration:

import path from 'node:path';

const storagePath = process.env.STORAGE_PATH ?? path.join(process.cwd(), 'storage', 'players-sqlite3.db');

export default {
    development: {
        dialect: 'sqlite',
        storage: storagePath,
        logging: console.log,
    },
    // ... other environments
};

4. Generate Initial Migration from Existing Schema

Create a migration that reflects the current Player model schema:

npx sequelize-cli migration:generate --name create-players-table

File: database/migrations/YYYYMMDDHHMMSS-create-players-table.js

'use strict';

module.exports = {
    async up(queryInterface, Sequelize) {
        await queryInterface.createTable('players', {
            id: {
                type: Sequelize.INTEGER,
                autoIncrement: true,
                primaryKey: true,
                allowNull: false,
            },
            firstName: {
                type: Sequelize.STRING,
                allowNull: false,
            },
            middleName: {
                type: Sequelize.STRING,
                allowNull: true,
            },
            lastName: {
                type: Sequelize.STRING,
                allowNull: false,
            },
            dateOfBirth: {
                type: Sequelize.DATE,
                allowNull: true,
            },
            squadNumber: {
                type: Sequelize.INTEGER,
                allowNull: false,
                unique: true,
            },
            position: {
                type: Sequelize.STRING,
                allowNull: false,
            },
            abbrPosition: {
                type: Sequelize.STRING,
                allowNull: true,
            },
            team: {
                type: Sequelize.STRING,
                allowNull: true,
            },
            league: {
                type: Sequelize.STRING,
                allowNull: true,
            },
            starting11: {
                type: Sequelize.BOOLEAN,
                allowNull: true,
            },
        });

        // Add index on squadNumber for faster lookups
        await queryInterface.addIndex('players', ['squadNumber'], {
            unique: true,
            name: 'players_squad_number_unique',
        });
    },

    async down(queryInterface, Sequelize) {
        await queryInterface.dropTable('players');
    },
};

Key Points:

• up() creates the table and indexes
• down() reverts changes (drops table)
• Sequelize CLI tracks which migrations have run in a SequelizeMeta table

5. Create Seed Data Migration (Optional)

Generate a seeder to populate initial player data:

npx sequelize-cli seed:generate --name seed-initial-players

File: database/seeders/YYYYMMDDHHMMSS-seed-initial-players.js

'use strict';

module.exports = {
    async up(queryInterface, Sequelize) {
        await queryInterface.bulkInsert('players', [
            {
                id: 1,
                firstName: 'Emiliano',
                middleName: 'Viviano',
                lastName: 'Martínez',
                dateOfBirth: '1992-08-02',
                squadNumber: 23,
                position: 'Goalkeeper',
                abbrPosition: 'GK',
                team: 'Aston Villa',
                league: 'Premier League',
                starting11: true,
            },
            // ... more players
        ], {});
    },

    async down(queryInterface, Sequelize) {
        await queryInterface.bulkDelete('players', null, {});
    },
};

Run Seeds:

npx sequelize-cli db:seed:all

6. Update npm Scripts

Add migration commands to package.json:

"scripts": {
    "db:migrate": "sequelize-cli db:migrate",
    "db:migrate:undo": "sequelize-cli db:migrate:undo",
    "db:migrate:undo:all": "sequelize-cli db:migrate:undo:all",
    "db:seed": "sequelize-cli db:seed:all",
    "db:seed:undo": "sequelize-cli db:seed:undo:all",
    "db:create": "sequelize-cli db:create",
    "db:drop": "sequelize-cli db:drop",
    "db:reset": "npm run db:migrate:undo:all && npm run db:migrate && npm run db:seed"
}

Usage:

• npm run db:migrate - Apply pending migrations
• npm run db:migrate:undo - Revert last migration
• npm run db:seed - Populate seed data
• npm run db:reset - Reset and rebuild database

7. Update Docker Entrypoint Script

Modify scripts/entrypoint.sh to run migrations instead of copying pre-seeded DB:

#!/bin/sh
set -e

echo "✔ Executing entrypoint script..."

VOLUME_STORAGE_PATH="/storage/players-sqlite3.db"

echo "✔ Starting container..."

# Check if database exists, create if not
if [ ! -f "$VOLUME_STORAGE_PATH" ]; then
  echo "⚠️ No existing database file found in volume."
  echo "Running migrations to create schema..."
  NODE_ENV=production npx sequelize-cli db:migrate
  echo "✔ Database initialized at $VOLUME_STORAGE_PATH"
else
  echo "✔ Existing database file found."
  echo "Running pending migrations..."
  NODE_ENV=production npx sequelize-cli db:migrate
fi

echo "✔ Ready!"
echo "🚀 Launching app..."
exec "$@"

Key Changes:

• Remove pre-seeded database copy logic
• Run db:migrate on every container start (safe: applies only pending migrations)
• Use NODE_ENV=production to use correct database config

8. Update Dockerfile to Include Migration Files

Modify Dockerfile to copy migration files and CLI:

# Stage 1: Builder
FROM node:krypton-alpine AS builder

WORKDIR /app

COPY package.json package-lock.json tsconfig.json ./
RUN npm ci

COPY src/ ./src/
COPY database/ ./database/        # Add migrations and seeders
COPY config/ ./config/            # Add database config
COPY .sequelizerc ./              # Add Sequelize CLI config

RUN npm run build && \
    npm run swagger:docs && \
    npm prune --omit=dev

# Stage 2: Runtime
FROM node:krypton-alpine AS runtime

# ... existing runtime setup ...

# Copy migrations and config for runtime execution
COPY --from=builder     /app/database/              ./database/
COPY --from=builder     /app/config/                ./config/
COPY --from=builder     /app/.sequelizerc           ./.sequelizerc

# ... rest of Dockerfile ...

Important: Keep sequelize-cli as a regular dependency (not dev-only) or install it globally in the runtime image:

RUN npm install -g sequelize-cli

9. Remove Pre-Seeded Database from Repository

After migration setup is complete and tested:

# Remove pre-seeded database (keep directory)
git rm storage/players-sqlite3.db
echo "players-sqlite3.db" >> storage/.gitignore
git add storage/.gitignore
git commit -m "chore: migrate to Sequelize migrations, remove pre-seeded DB"

Note: Keep storage/ directory with a .gitkeep file for local development:

touch storage/.gitkeep
git add storage/.gitkeep

10. Update Documentation

File: README.md

Add section on database setup:

## Database Setup

This project uses Sequelize migrations to manage the database schema.

### Initial Setup (First Time)

```bash
# Run migrations to create schema
npm run db:migrate

# (Optional) Seed initial data
npm run db:seed

Creating New Migrations

# Generate migration file
npx sequelize-cli migration:generate --name add-nationality-column

# Edit migration file in database/migrations/
# Run migration
npm run db:migrate

Rollback Migrations

# Undo last migration
npm run db:migrate:undo

# Undo all migrations
npm run db:migrate:undo:all

Docker

Migrations run automatically on container startup via entrypoint.sh.

Acceptance Criteria

1. ✅ Sequelize CLI Installed: sequelize-cli and @types/node installed as dev dependencies
2. ✅ Configuration Files Created: .sequelizerc and config/database.json exist with correct paths
3. ✅ Initial Migration Created: Migration file exists in database/migrations/ that creates players table matching current schema
4. ✅ Migration Scripts Added: npm scripts (db:migrate, db:migrate:undo, db:seed) added to package.json
5. ✅ Migrations Run Successfully: npm run db:migrate creates database from scratch without errors
6. ✅ Rollback Works: npm run db:migrate:undo successfully reverts the last migration
7. ✅ Docker Integration: Dockerfile and entrypoint script updated to run migrations on container startup
8. ✅ Local Development Works: Developers can clone repo, run npm run db:migrate, and start app without manual DB setup
9. ✅ CI/CD Compatible: Migrations run successfully in GitHub Actions workflow
10. ✅ Documentation Updated: README.md includes clear instructions for migration usage
11. ✅ Pre-Seeded DB Removed: storage/players-sqlite3.db removed from git (with proper .gitignore)
12. ✅ Seed Data Optional: Seed data extracted to separate seeder file (optional step)

References

Sequelize Documentation

• 🔗 Sequelize Migrations - Official migration guide
• 🔗 Sequelize CLI - CLI tool documentation
• 🔗 Query Interface API - Migration methods reference
• 🔗 Sequelize Configuration - Config file structure

Related Issues

• [FEATURE] Add test coverage for Service and Database layers with Jest Mock Functions #20 - Test coverage for Service/Database layers (integration tests may need migration setup)
• [FEATURE] Refactor by adding an interface to decouple from ORM Model #104 - Interface to decouple from ORM (migrations work with or without interface)
• Migrate Player id from INTEGER to UUID #23 - UUID migration (future: add UUID column via migration)

Migration Best Practices

• Database Migrations Best Practices - General principles
• Sequelize Migration Examples - Community examples
• Zero-Downtime Migrations - Production deployment strategies

TypeScript Integration

• Use .sequelizerc to specify TypeScript paths
• Consider using ts-node for TypeScript migration files (optional advanced setup)
• Example: Sequelize + TypeScript + Migrations

Testing with Migrations

• Integration tests can use :memory: database with migrations applied before each test suite
• Ensures tests always run against correct schema
• Example pattern:

  beforeAll(async () => {
      await sequelize.sync({ force: true }); // Or run migrations
  });

CI/CD Integration Examples

• Run migrations in GitHub Actions before running tests

• Use separate database configs for test environment

• Example workflow step:

  - name: Run Database Migrations
    run: npm run db:migrate
    env:
      NODE_ENV: test

[coderabbitai]

🤖 CodeRabbit Planning

Planning is in progress. This will take a moment...

[coderabbitai]

Coding Plan

Approach

Implement Sequelize's migration system to replace the pre-seeded SQLite database file with version-controlled, automated database schema management. This enables schema versioning, rollback capabilities, team synchronization, and CI/CD integration.

Observations

The project is a Node.js/Express/TypeScript application using Sequelize v6.37.7 with SQLite. The current database initialization relies on a pre-seeded storage/players-sqlite3.db file that gets copied from /app/hold/ to the persistent volume /storage/ on first Docker container run. The Player model in src/models/player-model.ts defines 11 fields. The Docker setup uses a two-stage build process with scripts/entrypoint.sh handling database initialization. There are no existing migration scripts or database management npm commands.

Assumptions

Assumption 1: sequelize-cli as regular vs dev dependency

Options Considered:

• Keep as dev dependency and install globally in Docker runtime image
• Move to regular dependency so it's available after npm prune --omit=dev

Chosen Option: 2

Rationale: Moving to regular dependency is simpler and ensures CLI availability in production without additional Docker configuration.

Assumption 2: Test environment database storage

Options Considered:

• Switch tests to in-memory database with migration setup
• Keep file-based test database, run migrations to initialize

Chosen Option: 2

Rationale: Keep file-based test database for now to avoid breaking existing tests. In-memory database can be a future enhancement once migration system is stable.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Sequelize CLI Infrastructure Setup

Establish the foundation for the migration system by installing dependencies, creating configuration files, and setting up the required directory structure.

Task 1: Install Sequelize CLI Dependency

Install the Sequelize CLI package required for migration management.

• Add sequelize-cli as a regular dependency (not dev) in package.json to ensure availability in production Docker image
• Verify @types/node is already present in devDependencies (typically included with TypeScript projects)

Task 2: Create Sequelize CLI Configuration

Create the .sequelizerc configuration file that tells the CLI where to find project files.

• Create .sequelizerc in project root directory
• Configure paths: config pointing to config/database.json, migrations-path to database/migrations, seeders-path to database/seeders, models-path to src/models
• Use CommonJS syntax (module.exports) as required by sequelize-cli

Task 3: Create Database Configuration File

Create environment-specific database configuration for the CLI.

• Create config/ directory if it doesn't exist
• Create config/database.json with three environment configurations:
  • development: SQLite dialect with storage at ./storage/players-sqlite3.db, logging enabled
  • test: SQLite dialect with storage at ./storage/players-sqlite3.db (file-based to match current test behavior), logging disabled
  • production: SQLite dialect with storage at /storage/players-sqlite3.db (Docker volume path), logging disabled

Task 4: Create Migration Directory Structure

Set up the directory structure for migrations and seeders.

• Create database/migrations/ directory with .gitkeep file
• Create database/seeders/ directory with .gitkeep file
• Ensure storage/ directory has .gitkeep for local development after pre-seeded DB removal

🤖 Prompt for AI agents

Set up Sequelize CLI infrastructure for migration system. This establishes the
foundation for database version control.

Install sequelize-cli as a regular dependency in package.json

Create .sequelizerc configuration file in project root:
- Set config path to config/database.json
- Set migrations-path to database/migrations
- Set seeders-path to database/seeders
- Set models-path to src/models
- Use CommonJS module.exports syntax

Create config/database.json with environment-specific configurations:
- development: SQLite dialect, storage at ./storage/players-sqlite3.db, logging
enabled
- test: SQLite dialect, storage at ./storage/players-sqlite3.db, logging
disabled
- production: SQLite dialect, storage at /storage/players-sqlite3.db, logging
disabled

Create directory structure:
- database/migrations/ with .gitkeep
- database/seeders/ with .gitkeep
- Ensure storage/ has .gitkeep

Phase 2: Initial Migration and Seeder Creation

Create the migration file that establishes the players table schema and a seeder file for initial data population.

Task 1: Create Initial Players Table Migration

Write the migration file that creates the players table matching the current Player model schema.

• Create migration file in database/migrations/ with timestamp prefix and name create-players-table.js
• Implement up() function using queryInterface.createTable() to create players table with all 11 columns matching src/models/player-model.ts:
  • id: INTEGER, autoIncrement, primaryKey, allowNull: false
  • firstName: STRING, allowNull: false
  • middleName: STRING, allowNull: true
  • lastName: STRING, allowNull: false
  • dateOfBirth: DATE, allowNull: true
  • squadNumber: INTEGER, allowNull: false, unique: true
  • position: STRING, allowNull: false
  • abbrPosition: STRING, allowNull: true
  • team: STRING, allowNull: true
  • league: STRING, allowNull: true
  • starting11: BOOLEAN, allowNull: true
• Add unique index on squadNumber column for query performance
• Implement down() function using queryInterface.dropTable() to enable rollback

Task 2: Create Initial Players Seeder

Create a seeder file to populate the database with initial player data.

• Create seeder file in database/seeders/ with timestamp prefix and name seed-initial-players.js
• Implement up() function using queryInterface.bulkInsert() to insert the 11 players currently in the pre-seeded database
• Extract player data from existing storage/players-sqlite3.db or tests/player-stub.ts as reference for the seed data
• Implement down() function using queryInterface.bulkDelete() to remove all seeded players

🤖 Prompt for AI agents

Create migration and seeder files to establish the players table and populate
initial data. This replaces the pre-seeded database file with version-controlled
schema.

Create migration file database/migrations/[timestamp]-create-players-table.js:
- Implement up() function to create players table with 11 columns matching
Player model
- Define all column types, constraints (id as primary key, squadNumber as
unique)
- Add unique index on squadNumber
- Implement down() function to drop players table

Create seeder file database/seeders/[timestamp]-seed-initial-players.js:
- Implement up() function to bulk insert 11 players from existing database
- Extract player data from storage/players-sqlite3.db or tests/player-stub.ts
- Implement down() function to bulk delete all seeded players

Phase 3: Integration, Docker Updates, and Cleanup

Integrate the migration system into the development workflow and Docker deployment pipeline, then clean up the legacy pre-seeded database approach.

Task 1: Add Database Management npm Scripts

Add npm scripts to package.json for convenient migration and seed commands.

• Update package.json scripts section with:
  • db:migrate: Run pending migrations
  • db:migrate:undo: Revert last migration
  • db:migrate:undo:all: Revert all migrations
  • db:seed: Run all seeders
  • db:seed:undo: Revert all seeders
  • db:reset: Combined command to undo all, migrate, and seed

Task 2: Update Dockerfile for Migration Support

Modify the Dockerfile to include migration files and configuration in the runtime image.

• Update builder stage to copy database/, config/, and .sequelizerc before build
• Update runtime stage to copy migration-related files from builder:
  • database/ directory (migrations and seeders)
  • config/ directory (database.json)
  • .sequelizerc configuration file
• Remove the COPY storage/ ./hold/ line that copies the pre-seeded database
• Remove creation of /app/hold/ directory since it's no longer needed

Task 3: Update Docker Entrypoint Script

Replace the pre-seeded database copy logic with migration execution.

• Update scripts/entrypoint.sh to remove the database file copy logic from /app/hold/ to /storage/
• Add migration execution logic: run npx sequelize-cli db:migrate with NODE_ENV=production
• Migrations are idempotent (only apply pending), so safe to run on every container start
• Optionally add conditional seeding for first-time database initialization
• Maintain proper error handling with set -e

Task 4: Remove Pre-Seeded Database and Update .gitignore

Clean up the legacy database file and prevent future database files from being committed.

• Remove storage/players-sqlite3.db from git tracking using git rm
• Update or create storage/.gitignore to ignore *.db files
• Ensure storage/.gitkeep exists to preserve the directory for local development
• The directory structure should remain for local migration runs

Task 5: Update Project Documentation

Add database setup instructions to the README for developers.

• Update README.md with a new "Database Setup" section covering:
  • Initial setup instructions (npm run db:migrate and optional npm run db:seed)
  • How to create new migrations using sequelize-cli
  • How to rollback migrations
  • Docker behavior (automatic migration on startup)
• Document the migration workflow for team collaboration
• Note that the pre-seeded database has been replaced with migrations

🤖 Prompt for AI agents

Integrate migration system into development and Docker workflows, then remove
legacy pre-seeded database. This completes the transition to version-controlled
schema management.

Add npm scripts to package.json:
- db:migrate, db:migrate:undo, db:migrate:undo:all
- db:seed, db:seed:undo
- db:reset (combined undo all, migrate, and seed)

Update Dockerfile:
- Copy database/, config/, and .sequelizerc to builder and runtime stages
- Remove COPY storage/ ./hold/ line
- Remove /app/hold/ directory creation

Update scripts/entrypoint.sh:
- Remove database file copy logic from /app/hold/ to /storage/
- Add npx sequelize-cli db:migrate execution with NODE_ENV=production
- Optionally add conditional seeding for first-time initialization
- Maintain error handling with set -e

Clean up legacy database:
- Remove storage/players-sqlite3.db from git tracking
- Create/update storage/.gitignore to ignore *.db files
- Ensure storage/.gitkeep exists

Update README.md with Database Setup section:
- Document initial setup, migration creation, rollback commands
- Explain Docker automatic migration behavior
- Note replacement of pre-seeded database

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Set up Sequelize CLI infrastructure for migration system. This establishes the
foundation for database version control.

Install sequelize-cli as a regular dependency in package.json

Create .sequelizerc configuration file in project root:
- Set config path to config/database.json
- Set migrations-path to database/migrations
- Set seeders-path to database/seeders
- Set models-path to src/models
- Use CommonJS module.exports syntax

Create config/database.json with environment-specific configurations:
- development: SQLite dialect, storage at ./storage/players-sqlite3.db, logging
enabled
- test: SQLite dialect, storage at ./storage/players-sqlite3.db, logging
disabled
- production: SQLite dialect, storage at /storage/players-sqlite3.db, logging
disabled

Create directory structure:
- database/migrations/ with .gitkeep
- database/seeders/ with .gitkeep
- Ensure storage/ has .gitkeep
===============================================================================

Task: 2

Create migration and seeder files to establish the players table and populate
initial data. This replaces the pre-seeded database file with version-controlled
schema.

Create migration file database/migrations/[timestamp]-create-players-table.js:
- Implement up() function to create players table with 11 columns matching
Player model
- Define all column types, constraints (id as primary key, squadNumber as
unique)
- Add unique index on squadNumber
- Implement down() function to drop players table

Create seeder file database/seeders/[timestamp]-seed-initial-players.js:
- Implement up() function to bulk insert 11 players from existing database
- Extract player data from storage/players-sqlite3.db or tests/player-stub.ts
- Implement down() function to bulk delete all seeded players
===============================================================================

Task: 3

Integrate migration system into development and Docker workflows, then remove
legacy pre-seeded database. This completes the transition to version-controlled
schema management.

Add npm scripts to package.json:
- db:migrate, db:migrate:undo, db:migrate:undo:all
- db:seed, db:seed:undo
- db:reset (combined undo all, migrate, and seed)

Update Dockerfile:
- Copy database/, config/, and .sequelizerc to builder and runtime stages
- Remove COPY storage/ ./hold/ line
- Remove /app/hold/ directory creation

Update scripts/entrypoint.sh:
- Remove database file copy logic from /app/hold/ to /storage/
- Add npx sequelize-cli db:migrate execution with NODE_ENV=production
- Optionally add conditional seeding for first-time initialization
- Maintain error handling with set -e

Clean up legacy database:
- Remove storage/players-sqlite3.db from git tracking
- Create/update storage/.gitignore to ignore *.db files
- Ensure storage/.gitkeep exists

Update README.md with Database Setup section:
- Document initial setup, migration creation, rollback commands
- Explain Docker automatic migration behavior
- Note replacement of pre-seeded database

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!