GMK Launchpad

Opinionated project scaffolding for modern web applications and APIs.

Built by GMK Dynamics.

GMK Dynamics

Overview

GMK Launchpad is a command-line project generation toolkit developed by GMK Dynamics.

It provides production-oriented application scaffolding based on the conventions and architecture used across GMK software projects.

Launchpad is intentionally opinionated.

Instead of generating generic starter projects that immediately require restructuring, it creates applications with predefined tooling, folder structures, scripts, configuration, development conventions, code generators, optional integrations, and project diagnostics.

Project Status

GMK Launchpad 1.0.0 is the first stable public release of the CLI.

The 1.0.0 release includes the completed Foundation, Generator Improvements, and Project Diagnostics milestones, providing project scaffolding, project-aware code generation, optional Docker and AWS integrations, project metadata, and gmk doctor diagnostics for generated projects.

GMK Launchpad follows Semantic Versioning. Future releases will build on the stable 1.x package while preserving the documented public CLI behavior wherever possible.

Installation

GMK Launchpad requires Node.js 20 or newer.

Install the CLI globally from npm:

npm install -g @gmkdynamics/launchpad

Verify the installation:

gmk --version

CLI

Launchpad exposes the:

gmk

command.

View available commands:

gmk --help

Check the installed version:

gmk --version

Diagnose the current Launchpad project:

gmk doctor

Create a Project

Run:

gmk create

Launchpad will ask for a project name and project type.

? Project name: Customer Portal

? Project type:

  React + Vite

  Express API

❯ Full Stack

React + Vite

Generates:

customer-portal-web/

with:

• React

• Vite

• TypeScript

• Tailwind CSS

• React Router

• ESLint

• Prettier

• Path aliases

• GMK project structure

• Development and validation scripts

• GMK Launchpad starter landing page

• Branded project documentation

Express API

Generates:

customer-portal-api/

with:

• Node.js

• Express

• TypeScript

• PostgreSQL

• Prisma

• Zod

• Helmet

• CORS

• ESLint

• Prettier

• Health endpoint

• Centralized error handling

• Validation middleware

• Node server entry point

• AWS Lambda-compatible entry point

• GMK backend architecture

• Branded project documentation

Full Stack

Generates two independent applications:

customer-portal-web/

customer-portal-api/

Launchpad does not create a monorepo or wrapper directory.

The frontend and API remain independent projects with their own dependencies, configuration, Git history, and deployment lifecycle.

Generated Frontend Structure

src/

├── assets/

├── enums/

├── interfaces/

├── models/

├── navigation/

├── pages/

├── services/

├── shared/

│   ├── components/

│   │   ├── ui/

│   │   ├── layout/

│   │   ├── navigation/

│   │   ├── modals/

│   │   └── forms/

│   ├── constants/

│   ├── containers/

│   ├── contexts/

│   ├── data/

│   ├── hooks/

│   ├── mocks/

│   ├── props/

│   ├── providers/

│   ├── styles/

│   └── utils/

└── types/

New web projects include a starter landing page registered at /, with React Router wired through the application template.

Generated API Structure

prisma/

└── schema.prisma

src/

├── config/

├── middlewares/

├── modules/

├── routes/

├── shared/

│   ├── constants/

│   ├── errors/

│   ├── services/

│   ├── types/

│   └── utils/

├── types/

├── app.ts

├── lambda.ts

└── server.ts

The runtime architecture intentionally separates the Express application from its execution environment:

server.ts ──┐

            ├──> app.ts

lambda.ts ──┘

This allows the same application to run through a standard Node.js process or an AWS Lambda handler without restructuring application code.

Code Generation

Launchpad can generate application code inside existing GMK Launchpad projects.

Run the project-aware interactive generator:

gmk generate

Launchpad detects whether the current project is a web or API project and presents only the relevant generators.

Direct commands remain available for scripting and automation.

Web Generators

gmk generate component <name> --type <type>

gmk generate page <name>

gmk generate service <name>

gmk generate context <name>

gmk generate provider <name>

gmk generate hook <name>

Components

Supported component types:

ui

layout

navigation

modals

forms

For example:

gmk generate component navbar --type navigation

generates:

src/shared/components/navigation/navbar/

├── navbar.component.tsx

└── index.ts

Generated React .tsx artifacts follow the GMK Launchpad React component convention using React.FC.

Pages

Generate a page with:

gmk generate page dashboard

which creates:

src/pages/dashboard/

├── dashboard.page.tsx

└── index.ts

Pages can optionally be registered with React Router:

gmk generate page dashboard --route /dashboard

The interactive generator can also ask whether the page should be registered automatically.

Services

Generate a frontend service with:

gmk generate service invoices

which creates:

src/services/invoices.service.ts

Context Bundles

Context, provider, and hook generation operate as a single bundle.

Any of these commands:

gmk generate context auth

gmk generate provider auth

gmk generate hook auth

generate:

src/shared/contexts/auth.context.ts

src/shared/providers/auth.provider.tsx

src/shared/hooks/use-auth.hook.ts

Inputs such as auth, AuthContext, auth-provider, use-auth, and useAuth are normalized to the same bundle name.

API Generators

gmk generate module <name>

gmk generate middleware <name>

gmk generate service <name>

Modules

Generated backend modules follow the GMK nine-file module convention:

src/modules/example/

├── example.constants.ts

├── example.controller.ts

├── example.mapper.ts

├── example.repository.ts

├── example.routes.ts

├── example.service.ts

├── example.types.ts

├── example.validation.ts

└── index.ts

Generate a module with:

gmk generate module sales-order

Modules can optionally register their router automatically:

gmk generate module client --route /clients

The interactive generator can also ask whether the module router should be registered.

Middleware

Generate API middleware with:

gmk generate middleware request-id

which creates:

src/middlewares/request-id.middleware.ts

Services

Generate a shared API service with:

gmk generate service email

which creates:

src/shared/services/email.service.ts

Feature Commands

Launchpad can add capabilities to existing generated projects without rebuilding them from scratch.

Docker

Add Docker support with:

gmk add docker

For web projects, this adds a production Nginx container configuration and docker:build / docker:run scripts.

For API projects, this adds the API container plus a Docker Compose environment with PostgreSQL for local development. The generated scripts include docker:build, docker:run, docker:up, docker:down, docker:logs, and docker:reset.

Before starting the API Compose environment, create the local Docker environment file from .env.docker.example, then run:

npm run docker:up

The PostgreSQL service persists data in a named Docker volume and exposes port 5433 by default to avoid colliding with a typical host PostgreSQL installation on 5432.

AWS Cognito

AWS Cognito integration is available for both web and API projects:

gmk add cognito

For API projects, Launchpad adds Cognito JWT verification, authentication middleware, request typing, and the required environment variable placeholders.

For web projects, Launchpad adds a Cognito authentication service and client configuration.

Launchpad prepares the application integration only; it does not provision Cognito resources in AWS.

AWS Lambda

AWS Lambda deployment support is available for API projects:

gmk add lambda

This adds a basic Serverless Framework configuration and package/deploy/remove scripts around the existing src/lambda.ts handler.

Project-specific infrastructure such as VPCs, RDS, S3, IAM policies, Route 53, and Secrets Manager remains intentionally outside Launchpad's automatic configuration.

Project Diagnostics

Launchpad can inspect an existing generated project with:

gmk doctor

Doctor is project-aware and can resolve the Launchpad project root even when it is run from a nested directory.

It validates the project without modifying it.

Checks include:

• Launchpad metadata

• Project type

• Launchpad version compatibility

• Metadata schema compatibility

• Node.js runtime support

• npm availability

• Core project dependencies

• Expected web or API project structure

• Environment files

• Required environment variables

• Docker feature files

• AWS Cognito feature files and dependencies

• AWS Lambda feature files and dependencies

Example output:

◆ GMK Launchpad Doctor

Project

✔  Launchpad metadata

   .gmk-launchpad.json found.

✔  Project type

   Web

✔  Metadata schema

   Schema version 1 is supported.

Runtime

✔  Node.js

   Node.js 22.x is supported.

✔  npm

   npm is available.

Environment

✔  Environment template

   .env.example found.

⚠  Environment file

   .env was not found.

Result

✔  30 passed

⚠  2 warnings

○  3 skipped

Diagnostic statuses are:

✔  pass

⚠  warning

✖  error

○  skipped

Warnings identify configuration that may still require attention but does not necessarily make the project invalid.

Errors cause gmk doctor to set a non-zero process exit code, allowing the command to also be used in automated validation workflows.

When .env is missing, Launchpad reports the file as a warning and skips checks for variables that cannot be validated. When .env exists but a required value is missing or empty, the missing variable is reported as an error.

Feature-aware checks run only when the corresponding Launchpad feature is installed.

Doctor is intentionally diagnostic only. It does not:

• Rewrite project configuration

• Automatically repair files

• Provision AWS infrastructure

• Validate live AWS account resources

• Change Docker infrastructure

• Run database migrations

• Upgrade or migrate older Launchpad projects

Project Metadata

Launchpad identifies generated projects through:

.gmk-launchpad.json

The CLI can resolve the project root when commands are run from nested directories.

Project metadata tracks the Launchpad schema version, the version used to generate the project, the project type, and installed Launchpad features.

A project generated with an older Launchpad version can still be diagnosed when its metadata schema remains supported.

Version differences are reported separately from schema incompatibility:

older Launchpad version + supported schema

→ warning

unsupported metadata schema

→ error

Launchpad does not automatically migrate older projects.

Development

Clone the repository and install dependencies:

npm install

Start the CLI directly from source:

npm run dev -- create

Build Launchpad:

npm run build

Validate the project:

npm run check

Format the codebase:

npm run format

Local CLI Testing

Build the package:

npm run build

Link it locally:

npm link

Launchpad can then be used like an installed CLI:

gmk create

Run project diagnostics:

gmk doctor

Remove the global development link when necessary with:

npm unlink -g @gmkdynamics/launchpad

Package Testing

GMK Launchpad is distributed publicly through npm as @gmkdynamics/launchpad.

For local release testing, create a package archive with:

npm pack

This produces a .tgz archive containing the distributable package and can be installed on another machine to test the exact package contents without publishing to npm.

Inspect the package contents without creating the final archive:

npm pack --dry-run

Architecture

Launchpad separates CLI concerns into focused layers:

src/

├── commands/

├── diagnostics/

├── features/

├── generators/

├── prompts/

├── shared/

│   ├── constants/

│   ├── filesystem/

│   ├── logger/

│   ├── project/

│   └── utils/

├── templates/

│   ├── api/

│   ├── features/

│   ├── generators/

│   ├── module/

│   └── web/

├── types/

└── cli.ts

The diagnostic layer contains reusable project checks and report handling used by gmk doctor.

Templates are copied into the build output and distributed with the CLI.

Generated projects are created from GMK-owned templates rather than delegating project creation to external framework generators.

Roadmap

Launchpad follows Semantic Versioning.

The planned pre-release milestones are complete, and 1.0.0 marks the first stable public release.

0.1.0 — Foundation

• [x] React + Vite project generation
• [x] Express + Prisma API generation
• [x] Full-stack project generation
• [x] Docker support
• [x] PostgreSQL Docker Compose
• [x] AWS Lambda support
• [x] AWS Cognito integration
• [x] API module generation
• [x] Project metadata and feature detection

0.2.0 — Generator Improvements

• [x] API middleware generation
• [x] API shared service generation
• [x] Web component generation
• [x] Web component categories
• [x] Web page generation
• [x] Web service generation
• [x] Context, provider, and hook bundle generation
• [x] Project-aware interactive generation
• [x] Optional API module route registration
• [x] React Router web foundation
• [x] Optional web page route registration
• [x] GMK Launchpad starter landing page

0.3.0 — Project Diagnostics

• [x] gmk doctor
• [x] Project metadata validation
• [x] Launchpad version and schema compatibility checks
• [x] Runtime validation
• [x] Dependency validation
• [x] Project structure validation
• [x] Environment variable validation
• [x] Feature-aware diagnostics
• [x] Actionable warning and error guidance
• [x] Non-zero exit code when diagnostic errors are detected

1.0.0 — Public Release

• [x] Final release QA
• [x] Public npm package metadata
• [x] External tarball installation testing
• [x] npm organization and public package configuration
• [x] Public npm release preparation

Future

• [ ] Dedicated GMK Launchpad documentation website
• [ ] Automated project migrations and upgrades
• [ ] Plugin and extension architecture
• [ ] Additional templates based on GMK projects

License

GMK Launchpad is licensed under the MIT License.

See LICENSE for details.

Build faster with GMK Dynamics.

Visit gmkdynamics.com

GMK Launchpad · GMK Dynamics