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

$3

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

$3

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

$3

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

$3

`bash
posquelize -h localhost -u postgres -d myapp_db -x --dry-run
`

$3

`bash
posquelize -h localhost -u postgres -d myapp_db -x --dry-run-diff
`


$3

`bash


Generate models with camelCase names, properties, and files

`bash


Full naming convention overhaul for a specific style guide

`bash


Create a basic config file and use it

`bash


Step 1: Extract templates to current directory

⚠️ 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.

Generated Project Structure

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

`text
/
│ 📄 .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
└───/ # 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
├───seeders/ # Database seeders
└───typings/ # TypeScript type definitions
└──📝 models.d.ts
`

Configuration File

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.

`bash
posquelize --use-config
`

#### Available configuration via posquelize.config.js file:

`javascript
module.exports = {
connection: { // Database connection configuration
host: 'localhost', // Host name / IP
username: 'postgres', // Username for database
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: {
migration: {
/**
* Determines whether migration files should be generated using CommonJS module
* syntax instead of ECMAScript modules (ESM)
*/
useCommonJs: true,
},
model: {
addNullTypeForNullable: true, // Controls whether nullable typed property
replaceEnumsWithTypes: false, // Replace enum with String Union types
/**
* Configuration options for naming conventions used in code generation.
* Controls how models, properties, and files are named to match
* specific project coding standards and preferences.
*/
naming: {
// Naming convention for model names
model: 'pascal',
// Naming convention for property names
property: 'camel',
// Naming convention for file names
file: 'pascal',
// Model singularization
singularizeModel: 'singular',
},
},
// 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',

// Preview of changes without actually writing files to disk.
dryRun: true,

// Interactive HTML comparison of changes without actually writing files to disk.
dryRunDiff: true,
};
`

Programmatic API

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.

$3

`ts
import { PosquelizeGenerator } from 'posquelize';

// Define your PostgreSQL connection string
// Format: postgresql://:@:/
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();
`

$3

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

`ts
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();
`

$3

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

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

Development Setup

`bash
git clone https://github.com/blacksmoke26/posquelize.git
cd posquelize
npm install


Edit the connection string in 'samples/generate.ts', and run

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

Tech Stack & Tools

- 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)

Acknowledgments

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

Inspirations

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.

License

Posquelize is released under the MIT License.

Copyright ©️

Developed with ❤️ by Junaid Atari