At a high-level, ⚡ Storm Stack is a toolchain system that generates code and other artifacts during the build and deploy processes via TypeScript transformers and static code analysis. Many modern code generation tools require you to explicitly define the structure and behavior of your code in separate schema files and/or configurations, which can be time-consuming and error-prone. Some tools even require you to learn a new SDL or write boilerplate code to wire everything together. Storm Stack does not require any extra work - you just write your code the way you normally would, and Storm Stack does the rest.
The goal is to allow the developer to focus on the actual application/business logic, rather than the specifics around technologies, frameworks, or cloud providers. This is achieved by using a set of powerful tools and extensible plugins that are designed to work together.
Storm Stack is largely built on top of Deepkit, so our projects benefit from access to very small bytecode type definitions at runtime. This means you have builtin serialization, deserialization, or validation logic without writing any additional code (with greatly improved performance and reduced bundle sizes when compared to popular packages like Zod, Yup, class-validator, and Valibot).
The Storm Stack monorepo contains the Storm Stack engine package and various plugins and tools to help developers using the toolchain. More details can be found below in the Features section.
Note
Some features of Storm Stack are opinionated to meet the needs of Storm Software; however, it should be simple to customize the behavior to fit any specific requirements you may have. If you believe any plugins include logic that should be split out into separate packages, please feel free to submit a pull request or open an issue, and we will be happy to discuss it.
💻 Visit stormsoftware.com to stay up to date with this developer
Important
This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be available through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.
- Features
- Environment Configuration Help
- Local Development
- Testing
- ☁ Nx Cloud
- Roadmap
- Contributing
- Support
- License
- Contributors
The core functionality of Storm Stack is built around the concept of a "stack" of tools and services that work together seamlessly. This includes everything from code generation and transformation to deployment and monitoring.
The following sections outline some of the features/publishable content included in this repository.
The Storm Stack Engine is an actual class that drives the Storm Stack pipeline's commands; however, the phrase is also often used to describe the base packages containing the core architecture (primarily the @storm-stack/core and @storm-stack/cli packages).
The @storm-stack/core package includes the Storm Stack engine - used to drive the Storm Stack pipeline's commands.
The following features are included in the package:
- The
Engineclass - responsible for orchestrating the various stages of the Storm Stack pipeline. This can be used as a sort of API for driving the processes from an external tool or service. - Extensible architecture that allows for easy integration of new tools and services.
- Utilities and helpers for working with the Storm Stack ecosystem.
- Various build plugins (supported by unplugin) that allow you to benefit from Storm Stack's features, such as code generation, transformation, and deployment, while using an external build system.
Some of the supported build systems with existing plugins are:
This package provides a binary to interact with the Storm Stack engine via a command-line interface.
The following features are included in the package:
- Inclusion of required commands and options for Storm Stack development.
- Utilities for managing local project dependencies and scripts.
- Integration with the Storm Stack ecosystem for seamless project management.
The following Storm Stack plugin packages are included in this repository:
A plugin to generate TypeScript definitions, apply static parameter values, and encourage best practices for managing environment configuration in Storm Stack applications.
The plugin provides a set of utilities for working with configuration files, including:
- TypeScript definition generation for configuration schemas.
$storm.env.<parameter>object is used to apply static configuration values at build time with automatic type generation for improved type safety.- Logic to determine all used environment configurations so that they can be validated and documented later.
- Best practice recommendations for organizing and managing configuration.
- The
storm:envbuiltin runtime module, which contains theStormEnvtype definition and related utilities for working with configuration parameters at runtime.
A plugin package that injects a consistent interface into the application for working with dates across some popular JavaScript libraries, such as date-fns, dayjs, luxon, and moment.js. Never feel the pressure to choose a date library again!
This plugin was inspired by (and largely lifted from) date-io, which provides a similar interface for date manipulation. The key difference is that this plugin will inject the date manipulation logic into the application at build time, rather than at runtime, allowing for more consistent and performant code.
Huge thanks to dmtrKovalenko for their work on date-io.
A plugin to provide a set of utilities and best practices for building Node.js applications with Storm Stack.
The following features are included in the package:
- The
$stormcontext object, which provides access to various utilities and services at runtime. - The
storm:contextbuiltin runtime module, which contains theStormContexttype definition, theuseStormhook to access the context (if using the$stormobject feels uncomfortable), and other related utilities. - The
storm:envbuiltin runtime module, which can be imported directly to access information about the runtime environment. - The
storm:requestbuiltin runtime module, which contains theStormRequestclass to package information about the incoming request. - The
storm:responsebuiltin runtime module, which contains theStormResponseclass to package information about the outgoing response. - The
storm:eventbuiltin runtime module, which contains theStormEventclass to package information about events that occur in the application.
A plugin that provides utilities and best practices for building Cloudflare Worker applications with Storm Stack. Key features include:
The following features are included in the package:
- The
$stormcontext object for accessing runtime utilities and services. - Built-in modules for environment, request, result, and event handling tailored for Cloudflare Workers.
- Preset configuration for seamless deployment to the Cloudflare platform.
A plugin for creating command-line applications using Storm Stack.
The following features are included in the package:
- CLI scaffolding and context management via the
$stormobject. - Utilities for parsing arguments, handling input/output, and managing CLI commands.
- Built-in modules for environment and event handling in CLI contexts.
Provides logging functionality for Storm Stack applications by writing log messages to the console.
The following features are included in the package:
- Console-based log adapter for development and debugging.
- Integration with the Storm Stack logging system for consistent log formatting.
Enables logging to Sentry for error tracking and monitoring.
The following features are included in the package:
- Sentry log adapter for capturing errors and events.
- Configuration options for Sentry DSN and environment.
Provides logging to OpenTelemetry collectors for distributed tracing and monitoring.
The following features are included in the package:
- OpenTelemetry log adapter for exporting traces and metrics.
- Integration with Storm Stack's logging and event system.
Allows log messages to be written to a specified storage type (e.g., file system, cloud storage).
The following features are included in the package:
- Storage log adapter for persistent log management.
- Configurable storage backends and retention policies.
The following packages are included in this repository to assist with the development/repository management process and are available for use in any application.
A set of base plugins, shared templates, and helpful utilities for extending Storm Stack.
The following features are included in the package:
- Multiple base plugins for common functionality that could be extended or customized in a personal plugin to meet your specific needs.
- Shared template files for generating boilerplate code.
An Nx plugin to manage monorepos using Storm Stack for building and deploying applications.
The following features are included in the package:
- Nx generators and executors tailored for Storm Stack workflows.
- Enhanced project graph visualization and dependency management.
An ESLint plugin to enforce code quality and best practices in Storm Stack projects.
The following features are included in the package:
- Custom ESLint rules for Storm Stack conventions.
- Integration with shared configuration for consistency across packages.
A shared ESLint configuration for Storm Stack repositories.
The following features are included in the package:
- Predefined rulesets for JavaScript/TypeScript projects.
- Easy integration with ESLint for consistent code style.
A shared Biome configuration for Storm Stack projects.
The following features are included in the package:
- Pre-configured Biome settings for formatting and linting.
- Inclusion of required globals and rules for Storm Stack development.
A shared TSDoc configuration for Storm Stack projects.
The following features are included in the package:
- Pre-configured TSDoc settings for consistent documentation.
- Inclusion of required tags and rules for Storm Stack development.
A shared TypeScript configuration for Storm Stack projects.
The following features are included in the package:
- Pre-configured TypeScript settings for consistent development.
- Inclusion of required compiler options and rules for Storm Stack development.
If you run into any issues while trying to run any of the monorepo's code locally, please reach out to us on Discord. See the Support section for more information.
Once the code is pulled locally, open a command prompt and run pnpm install in
the root repo directory (/storm-stack).
More information can be found in the Open System documentation.
Run pnpm build to build the project. The build artifacts will be stored in the
dist/ directory. Use the --prod flag for a production build.
Run pnpm serve for a dev server. Navigate to http://localhost:4200/. The app
will automatically reload if you change any of the source files.
Open System uses Jest for unit testing and Cypress for end-to-end testing.
Run pnpm test to execute the unit tests via Jest.
Run pnpm affected:test to execute the unit tests affected by a change.
Run pnpm e2e to execute the end-to-end tests via
Cypress.
Run pnpm affected:e2e to execute the end-to-end tests affected by a change.
Run pnpm graph to see a diagram of the dependencies of the Open System
projects.
Nx caches the output of any previously run command such as testing and building, so it can replay the cached results instead of rerunning it. Nx Cloud allows you to share the computation cache across everyone in your team and CI.
Nx Cloud pairs with Nx in order to enable you to build and test code more rapidly, by up to 10 times. Even teams that are new to Nx can connect to Nx Cloud and start saving time instantly.
Teams using Nx gain the advantage of building full-stack applications with their preferred framework alongside Nx’s advanced code generation and project dependency graph, plus a unified experience for both frontend and backend developers.
Visit Nx Cloud to learn more.
See the open issues for a list of proposed features (and known issues).
- Top Feature Requests (Add your votes using the 👍 reaction)
- Top Bugs (Add your votes using the 👍 reaction)
- Newest Bugs
First off, thanks for taking the time to contribute! Contributions are what makes the open-source community such an amazing place to learn, inspire, and create. Any contributions you make will benefit everybody else and are greatly appreciated.
Please read through the contributing guidelines so you know what to expect in terms of development and code style. We also have a Code of Conduct that we expect all contributors to adhere to. Please read it before contributing.
Before you submit a pull request (PR), please ensure all lefthook hooks pass. These hooks will run automatically when you commit your changes.
If you have not yet signed the Contributor License Agreement (CLA), add a PR comment containing the exact text:
I have read the CLA Document and I hereby sign the CLA
The CLA‑Assistant bot will turn the PR status green once all authors have signed.
Please try to create bug reports that are:
- Reproducible. Include steps to reproduce the problem.
- Specific. Include as much detail as possible: which version, what environment, etc.
- Unique. Do not duplicate existing opened issues.
- Scoped to a Single Bug. One bug per report.
Reach out to the maintainer at one of the following places:
This project is licensed under the Apache License 2.0. Feel free to edit and distribute this template as you like. If you have any specific questions, please reach out to the Storm Software development team.
See LICENSE for more information.
Thanks goes to these wonderful people (emoji key):
 Patrick Sullivan 🎨 💻 🔧 📖 |
 Tyler Benning 🎨 |
 Stormie 🚧 |
||||
Add your contributions
|
||||||
This project follows the all-contributors specification. Contributions of any kind welcome!
Storm Software is an open source software development organization and creator of Acidic, StormStack and StormCloud.
Our mission is to make software development more accessible. Our ideal future is one where anyone can create software without years of prior development experience serving as a barrier to entry. We hope to achieve this via LLMs, Generative AI, and intuitive, high-level data modeling/programming languages.
Join us on Discord to chat with the team, receive release notifications, ask questions, and get involved.
If this sounds interesting, and you would like to help us in creating the next generation of development tools, please reach out on our website or join our Slack channel!
