New Research: Supply Chain Attack on Axios Pulls Malicious Dependency from npm.Details →
Socket
Book a DemoSign in
Socket

tryappstack

Package Overview
Dependencies
Maintainers
1
Versions
12
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

tryappstack

Enterprise-grade CLI to bootstrap production-ready Node.js applications with TypeScript/JavaScript, MongoDB, Redis, Docker, CI/CD, and world-class patterns

latest
Source
npmnpm
Version
2.0.0
Version published
Maintainers
1
Created
Source

TryAppStack

CLI for scaffolding production-ready Node.js applications

npm version downloads license

Website · npm · GitHub

What's New in v2.0.0

v2.0.0 is a major release that adds TypeScript support and significantly expands the generated project structure. Here's what changed:

  • TypeScript and JavaScript templates
  • Redis caching layer with type-safe implementation
  • Structured logging via Pino (correlation IDs, JSON output)
  • Health check endpoints (Kubernetes liveness/readiness probes)
  • Database seeders
  • Docker multi-stage builds (~100MB images)
  • GitHub Actions CI/CD pipeline
  • Pre-commit hooks using Husky + lint-staged
  • Swagger/OpenAPI documentation
  • Graceful shutdown handling
  • Project-level docs: SKILLS.md, SEEDERS.md, CONTRIBUTING.md

Full Changelog

Overview

TryAppStack is a CLI that generates Node.js project boilerplates with a well-defined folder structure, pre-configured dependencies, and sensible defaults.

Instead of spending time wiring up auth, logging, Docker, linting, and CI/CD from scratch, you run one command and get a working project that's ready to build on.

Learn more

Quick Start

Installation

Install globally:

npm install -g tryappstack

Or use npx without installing:

npx tryappstack init

Create a Project

# Start the interactive setup
tas init

# You'll be prompted to:
# 1. Pick a stack (JavaScript or TypeScript)
# 2. Enter a project name
# 3. Set port, database URL, etc.
# 4. Choose a package manager (npm/yarn)

# Then:
cd my-project
npm run dev

# API runs at http://localhost:5000

What Gets Generated

After tas init, your project includes:

  • A complete folder structure following standard conventions
  • All dependencies installed
  • Environment variables configured (.env)
  • An initialized Git repository
  • Docker and Docker Compose setup
  • A CI/CD pipeline (GitHub Actions)
  • Project documentation

Common Next Steps

# Seed the database with sample data
npm run db:seed

# Generate a new module (controller + model + router)
tas add-module Product

# Run the app in Docker
npm run docker:run

# View the API docs
# http://localhost:5000/api-docs

Features

Authentication and Security

  • JWT-based authentication
  • OTP verification (email/phone)
  • Password reset flow
  • Role-based access control (RBAC)
  • Helmet security headers
  • Rate limiting
  • XSS protection
  • MongoDB query sanitization

Logging and Monitoring

  • Structured JSON logging with Pino
  • Correlation IDs for request tracing
  • Request/response logging
  • Error tracking
  • Health check endpoints: /health, /health/liveness, /health/readiness

Performance

  • Redis caching layer
  • Response compression
  • Connection pooling
  • Small Docker images (~100MB)

DevOps

  • Multi-stage Docker builds
  • Docker Compose for local orchestration
  • GitHub Actions CI/CD
  • Pre-commit hooks (Husky + lint-staged)
  • Conventional commits via commitlint
  • Container health checks

Documentation (Auto-Generated)

  • Swagger/OpenAPI docs
  • Architecture overview
  • TypeScript guide (TS template only)
  • Database seeding guide
  • Contributing guidelines
  • Coding standards (SKILLS.md)

Database

  • Mongoose ODM with TypeScript support
  • Seeders for bootstrapping data
  • Migration-ready structure
  • Indexed schemas

Developer Experience

  • Hot reload via nodemon
  • ESLint + Prettier pre-configured
  • Path aliases for TypeScript (@/)
  • Auto-formatting on commit
  • Type-safe environment variables
  • Centralized error handling

CLI Commands

Project Setup

CommandAliasDescription
tas initiCreate a new project (interactive)
tas --version-vShow CLI version
tas --help-hShow help

Code Generation

These commands detect whether your project uses TypeScript or JavaScript and generate the right files accordingly.

CommandAliasDescription
tas add-module <name>modGenerate controller + model + router
tas add-controller <name>cGenerate a controller
tas add-model <name>mGenerate a Mongoose model
tas add-router <name>rGenerate an Express router
tas add-service <name>sGenerate a service
tas add-middleware <name>midGenerate middleware
tas add-utils <name>uGenerate a utility module
tas add-templates <name>tplGenerate an HTML template

Environment Management

CommandAliasDescription
tas setup-envenvSet up environment variables
tas add-var-env <name>addenvAdd a new env variable

Note: All add-* commands must be run inside a project created with tas init.

Template Detection

The CLI figures out which template your project uses and generates code accordingly:

# In a TypeScript project
tas add-router Product
# Output: src/routes/ProductRoutes.ts (with types and interfaces)

# In a JavaScript project
tas add-router Product
# Output: Src/Routes/ProductRoutes.js (ES6+ syntax)

Available Templates

Node.js + MongoDB + Express (JavaScript)

A complete JavaScript API project with JWT auth, OTP verification, Pino logging, Redis caching, Docker + Compose, GitHub Actions CI/CD, Swagger docs, database seeders, pre-commit hooks, and project documentation.

Node.js + MongoDB + Express (TypeScript)

Everything from the JavaScript template, plus: TypeScript with generics and utility types, DTOs using class-validator, path aliases (@/), type-safe environment validation, a TypeScript best practices guide, and architecture documentation.

Planned

  • Node API with PostgreSQL + TypeORM
  • Node API with MySQL + TypeORM
  • GraphQL API
  • React SPA
  • Next.js Fullstack
  • Microservices architecture

Deployment

Docker

# Build and start everything (app + MongoDB + Redis)
npm run docker:build
npm run docker:run

# App:          http://localhost:5000
# Mongo Express: http://localhost:8081 (dev only)

Cloud

Both templates are configured for deployment to AWS (EC2, ECS, Fargate), Google Cloud (Cloud Run, GKE), Azure (ACI, AKS), DigitalOcean, Heroku, Railway, and Render.

Kubernetes-specific setup is included: health check endpoints, graceful shutdown, non-root Docker user, and small image sizes.

See the template-specific READMEs for deployment details.

Documentation

Each generated project includes:

  • README.md — Setup and usage
  • SKILLS.md — Coding standards and conventions
  • SEEDERS.md — Database seeding guide
  • CONTRIBUTING.md — Development workflow
  • ARCHITECTURE.md — System design overview (TypeScript only)
  • TYPESCRIPT_GUIDE.md — TypeScript patterns and practices (TypeScript only)

Contributing

Contributions are welcome. See CONTRIBUTING.md for guidelines on submitting changes, adding templates, and improving CLI commands.

Roadmap

v2.x (Current)

  • TypeScript and JavaScript templates
  • Redis caching
  • Docker and CI/CD
  • Database seeders
  • Template-aware code generation

v3.0

  • PostgreSQL + TypeORM template
  • MySQL + TypeORM template
  • GraphQL API template
  • Microservices architecture
  • WebSocket support
  • Message queue integration (RabbitMQ/Kafka)
  • Elasticsearch integration
  • Multi-tenancy support

v4.0

  • Next.js fullstack template
  • React SPA template
  • React Native template
  • Electron desktop template
  • Serverless templates (AWS Lambda, Vercel)

Acknowledgments

Project structure and conventions are influenced by patterns used at Vercel, Linear, GitHub, and Google.

License

MIT — Dushyant Khoda

See LICENSE for details.

Made with ❤️ for developers who value quality and speed

⭐ Star on GitHub · 🐛 Report Bug · 💡 Request Feature

Keywords

nodejs cli

FAQs

Package last updated on 24 Mar 2026

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts