Automatically generate SequelizeJS minimal application via the command line.

Posquelize is a powerful CLI tool that automates the generation of Sequelize applications from PostgreSQL databases. It connects directly to your PostgreSQL instance, analyzes the database schema, and produces production-ready TypeScript boilerplate with comprehensive type definitions.

• ✅ Complete Model Generation: Creates Sequelize models, repositories, and TypeScript type definitions
• 🔄 Comprehensive Migration Support: Generates migrations for tables, functions, domains, views, triggers, indexes, and keys
• 📊 Advanced Type Support: Handles custom user-defined types with automatic conversions
• 📚 Multi-Schema Support: Seamlessly handle multiple database schemas with efficient processing and organization.
• ⚡ Visual Documentation: Creates database ER diagrams in DBML
• 🚀 Selective Generation: Filter by schemas or tables for targeted code generation
• 🔍 Smart Relationship Detection: Identifies and configures table relationships and associations
• 📝 Rich Type Definitions: Generates TypeScript interfaces, enums, and JSONB prototypes
• 🎯 Production-Ready Boilerplate: Creates minimal but complete application structure
• 🛠️ Enhanced Model Options: Configurable model properties including timestamps, paranoid mode
• 🔧 Advanced Migration Control: Granular control over migration generation with selective inclusion/exclusion options
• 📋 JSON/JSONB Support: Automatically detects and generates TypeScript interfaces from column defaults or values, ensuring proper type safety for structured data.
• 🏗️ Composite Type Handling: Support for PostgreSQL composite types with automatic TypeScript interface generation

• 🔐 Secure Authentication: Interactive password prompts to avoid sensitive data in command history
• 📁 Flexible Output: Configurable output directory and Sequelize directory structure
• 🧹 Clean Generation: Automatic directory cleanup with --clean
• 🎨 Template Customization: Support for custom output templates (upcoming)
• ⚙️ Configuration Files: Advanced configuration via posquelize.config.js for complex setups
• 🚀 Programmatic API: Full TypeScript API for integration into build pipelines and custom tools

npm install -g posquelize   # for NPM
pnpm add -g posquelize      # for PNPM
yarn global add posquelize  # for Yarn

posquelize -h localhost -u postgres -d myapp_db -x

For advanced usage and a complete list of all available options, run:

posquelize --help

posquelize -h localhost -u postgres -d myapp_db -x

posquelize -h localhost -u postgres -d myapp_db -x --schemas public,auth

posquelize -h localhost -u postgres -d myapp_db -x --tables users,posts,comments

posquelize -h localhost -u postgres -d myapp_db -x -o ./my-sequelize-app --clean

⚠️ Security Alert: Never include passwords directly in command-line arguments or scripts. Posquelize provides an interactive password prompt when the -x flag is used without a value, ensuring credentials don't appear in shell history or process lists.

The tool generates a complete application structure with:

• TypeScript Models: Fully typed models with validations
• Migration Scripts: Version-controlled database schema changes
• Type Definitions: Comprehensive TypeScript interfaces and types
• Relationship Maps: Automatically configured associations
• Repository Pattern: Abstraction layer for data access

<output-directory>/
│   📄 .env                                          # Environment variables
│   📄 .gitignore                                    # Git ignore rules
│   ⚙️ .sequelizerc                                  # Sequelize configuration
│   📦 package.json                                  # Dependencies and scripts
│   📖 README.md                                     # Project documentation
│   ⚙️ tsconfig.json                                 # TypeScript configuration
└───src/
    │   🚀 server.ts                                 # Application entry point
    └───<sequelize-directory>/                        # Default to `database`
        │    🔗 instance.ts                          # Database connection
        ├───base/                                     # Base classes
        │   ├── 📝 ModelBase.ts
        │   └── 📝 RepositoryBase.ts
        ├───config/                                  # Configuration files
        │   └── ⚙️ config.js
        ├───diagrams/                                # Database documentation
        │   ├── 📊 database.dbml
        │   └── 📖 README.md
        ├── models/                                  # Sequelize model files
        │   ├── 📝 User.ts
        │   ├── 📝 Post.ts
        │   └── ...                                  # Generated model files
        ├── migrations/                              # Sequelize migration files
        │   ├── 📝 20251101000000-create-users.js
        │   ├── 📝 20251101000001-create-posts.js
        │   └── ...                                  # Generated migration files
        ├── repositories/                            # Repository pattern implementations
        │   ├── 📝 UserRepository.ts
        │   ├── 📝 PostRepository.ts
        │   └── ...                                  # Generated repository files
        ├── types/                                   # TypeScript type definitions
        ├───seeders/                                 # Database seeders
        └───typings/                                 # Type definitions
            └──📝 models.d.ts

To use a configuration file for more complex setups:

1. Create a posquelize.config.js file in your project's root directory.

   Note: If a config file doesn't exist, will be created in the current directory.

2. Configure your options using the JavaScript configuration object.

3. Run the generator with the --use-config.

posquelize --use-config

module.exports = {
  connection: {             // Database connection configuration
    host: 'localhost',      // Host name / IP
    username: 'postgres',   // Username for database
    password: '<password>', // The password
    database: 'test_db',    // The database name
    port: 5432,             // The port to connect
  },

  outputDir: __dirname + '/my_app', // Output directory
  cleanRootDir: true,       // Clean output directory before generation
  dirname: 'db',            // Sequelize subdirectory name

  schemas: [/*'public'*/],  // Specific schemas to process
  tables:  [/*'tags', 'products'*/], // Specific tables to generate

  // Migration configuration
  migrations: {
    indexes: true,    // Generate index migrations
    seeders: true,    // Generate seeder files
    functions: true,  // Generate function migrations
    domains: true,    // Generate domain migrations
    composites: true, // Generate composite type migrations
    tables: true,     // Generate table migrations
    views: true,      // Generate view migrations
    triggers: true,   // Generate trigger migrations
    foreignKeys: true // Generate foreign key migrations
  },

  diagram: false,       // Skip DBML diagram generation
  repositories: false,  // Skip repository file generation

  generator: {
    model: {
      addNullTypeForNullable: true, // Controls whether nullable typed property
      replaceEnumsWithTypes: false, // Replace enum with String Union types
    },
    // Configurable enums for table columns, (generate enums instead of plain value)
    enums: [{
      path: 'public.products.status', // schemaName.tableName.columnName
      values: {active: 10, inactive: 5, deleted: 0, suspended: 3}, // key:value map
      defaultValue: 10, // Default value to be set in init -> options -> column definition
    }, {
      path: 'public.products.visibility',
      values: ['public', 'private'], // list of values
      // defaultValue: 'private', // Default Value is set in DDL
    }],
  },
  
  // Path to directory containing custom templates for code generation
  templatesDir: __dirname + '/templates',
};

The Posquelize programmatic API allows you to integrate database generation directly into your TypeScript/JavaScript applications. This provides greater flexibility and automation capabilities compared to using the CLI alone.

import { PosquelizeGenerator } from 'posquelize';

// Define your PostgreSQL connection string
// Format: postgresql://<user>:<pass>@<host>:<port>/<database>
const connectionString = 'postgresql://user:pass@localhost:5432/test_db';

// Initialize the generator with connection string and output path
const posquelize = PosquelizeGenerator.create(connectionString, __dirname + '/myapp', {
  cleanRootDir: true, // Clean output directory before generation

  // other configuration goes here
});

// Execute the generation process
await posquelize.generate();

The programmatic API supports all configuration options available in the CLI tool, allowing for fine-grained control over the generation process:

import { PosquelizeGenerator, GeneratorOptions } from 'posquelize';

const options: GeneratorOptions = {
  cleanRootDir: true,
  dirname: 'database',
  schemas: ['public', 'auth'],
  tables: ['users', 'posts', 'comments'],
  migrations: {
    tables: true,
    foreignKeys: true,
    indexes: false
  },
  diagram: false,
  repositories: true
};

const posquelize = PosquelizeGenerator.create(connectionString, './output', options);

await posquelize.generate();

Always wrap the generation process in try-catch blocks to handle potential connection or generation errors:

try {
  await posquelize.generate();
  console.log('Database generation completed successfully!');
} catch (error) {
  console.error('Generation failed:', error.message);
  // Handle error appropriately for your application
}

1. Fork the project repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Implement your changes with proper testing
4. Commit your changes (git commit -m 'Add amazing feature')
5. Push to the branch (git push origin feature/amazing-feature)
6. Submit a Pull Request for review

• Machine: Legion Pro 7 16IAX10H
• Development Environment: Windows 11
• Primary IDE: JetBrains PhpStorm
• Alternative Editor: Zed with AI assistance
• AI Tools: Qwen, Ollama (GLM 4.6, Qwen 3 Coder)

This project builds upon concepts and implementations from Sequelize Models Generator, with significant enhancements for TypeScript support and application generation.

This project draws inspiration from innovative tools in the Sequelize ecosystem:

• Sequelize UI - A comprehensive web-based solution for generating TypeScript Sequelize code with flexible database configurations and customizable outputs.

• Sequelize-Auto - A command-line utility that automates the creation of Sequelize models by analyzing existing database structures.

Posquelize is released under the MIT License. See LICENSE file for details.