Dockmate NPM | npm.io

Dockmate

Dockmate is a versatile CLI tool designed to simplify Docker workflows for JavaScript-based projects. It streamlines tasks like generating Dockerfiles, building Docker images, and running containers. With support for frameworks such as React, Angular, Next.js, Vue.js, and more, Dockmate is your go-to helper for containerizing applications effortlessly.

Installation

npm i dockmate

OR If dockmate doesn't work then install it globally.

npm i -g dockmate

Features

Framework Detection: Automatically detects the framework of your project and generates a tailored Dockerfile.
Interactive UI: Step-by-step guided Dockerfile creation for users new to Docker.
Custom Dockerfile Generation: Supports React, Angular, Node.js, Next.js, Vue.js, and other major JavaScript frameworks.
Live Dockerfile Generation: Supports on fly Dockerfile generation. It checks changes in the repository and generates Dockerfile.
Docker Image Management: Build Docker images directly from your project’s Dockerfile or generate one if missing.
Container Management: Easily run Docker containers with custom configurations for ports, environment variables, and more.
Extensibility: Plugin architecture allows adding new features effortlessly.

Commands

CLI Usage

Dockmate offers several commands to manage Docker workflows. Below is a list of commands, their descriptions, and example outputs:

1. Interactive Dockerfile Initialization

Guides you through an interactive setup to generate a Dockerfile.

Command :

dockmate init

Output :

? What framework does your project use? (Use arrow keys)
  react
  angular
  vuejs
  nextjs
  node
? What port does your application listen on? 3000
? What is the entry point for your application? index.js
? What version of Node.js should be used? 18
? Does your project use a .env file? Yes
? Do you want to take backup of the Dockerfile? Yes
? Do you want to preview the Dockerfile content? Yes
--- Dockerfile Preview ---
## DOCKERFILE CONTENT
? Do you want to save this Dockerfile? Yes
[INFO] Dockerfile created successfully!

2. Generate Dockerfile

Automatically generates a Dockerfile based on project dependencies.

Command :

dockmate generate

Options

--framework Specify the framework (react, angular, node, nextjs, vuejs, sevelte, gatsby).
--nodeVersion Specify Node.js version (default: 18).
--port Specify application port (default: 3000).
--entryPoint Specify entry point file (default: index.js).
--preview Specify to Preview the Dockerfile content or not (default: false).
--backup Specify whether to backup the Dockerfile (default: false).

Example

dockmate generate --framework=node --nodeVersion=16 --port=4000 --entryPoint=app.js --preview

Output

[INFO] Generating Dockerfile for node...
[INFO] Dockerfile created successfully!

3. Backup Dockerfiles

You can take backup of your dockerfiles under /.dockmate/backups directory.

Command :

dockmate backup

Output :

[INFO] Backup saved: /yourpath/.dockmate/backups/Dockerfile-2025-01-07T10-28-11-145Z.bak

4. Undo/Restore Dockerfile

This will restore the Dockerfile to its latest or specific Dockerfile backup.

Command :

dockmate undo
// OR
dockmate undo Dockerfile-2025-01-07T10-28-11-145Z.bak

Output :

[INFO] Restored backup: /yourpath/.dockmate/backups/Dockerfile-2025-01-07T10-28-11-145Z.bak

5. Delete all Backups

This will delete the Backup files from /.dockmate/backups/ directory

Command :

dockmate delete-backups

6. Build Docker Image

Builds a Docker image for your project.

Command :

dockmate build

Options

--tag Specify image tag (default: latest).
--framework Specify framework for the Dockerfile.
--dockerfilePresent Indicate if the Dockerfile is already present (default: true).
--name Specify Docker image name (default: dockmate-image-).

Example

dockmate build --tag=myapp:1.0 --framework=react --name=myapp-image

Output

[INFO] Building Docker image with tag: myapp:1.0...
[INFO] Docker image built successfully!

7. Run Docker Container

Command :

dockmate run --image=<imageName>

Options

--port Specify port mapping (host:container format).
--env Set environment variables (KEY=value format).
--name Specify container name.

Example

dockmate run --image=myapp:1.0 --port=8080:3000 --env=NODE_ENV=production --name=myapp-container

Output

[INFO] Starting container myapp-container...
[INFO] Container started successfully!

8. Development Mode (Live Reload)

Command :

dockmate dev

Interactive Options :

? Enter the files or directories to watch: ./src, ./index.js
? Enter the path to the Dockerfile: ./Dockerfile
? Enter the Docker image name: dockmate-dev
? Enter the name of the Docker container: dockmate-dev-container
? Should the container restart automatically on changes? Yes
[INFO] Development mode started. Watching files for changes...

Programmatic Usage

Dockmate provides several utility functions that can be integrated into your projects. Below is a structured way to use them programmatically:

1. Detect Framework

Automatically detect the framework your project uses.

// import module
const { detectFramework } = require('dockmate');

// detect the framework of the working project
(async () => {
  try {
    const framework = await detectFramework();
    console.log(`Detected Framework: ${framework}`);
  } catch (error) {
    console.error(`[ERROR] Framework detection failed: ${error.message}`);
  }
})();

2. Generate Dockerfile

Generate a Dockerfile for your project based on options.

// import module
const { generateDockerfile } = require('dockmate');

// generate the dockerfile based on the framework and options
(async () => {
  try {
    const options = {
      nodeVersion: '18',          // Node.js version
      port: 3000,                // Application port
      entryPoint: 'index.js',    // Application entry point
      useEnv: true,              // Whether to include .env file
    };

    await generateDockerfile('react', options);
    console.log('[INFO] Dockerfile created successfully!');
  } catch (error) {
    console.error(`[ERROR] Dockerfile generation failed: ${error.message}`);
  }
})();

3. Build Docker Image

Build a Docker image for your project.

// import module
const { buildImage } = require('dockmate');

// build docker image using the options
(async () => {
  try {
    const options = {
      tag: 'myapp:1.0',          // Image tag
      framework: 'react',        // Framework used
      dockerfilePresent: true,   // Whether Dockerfile already exists
      imageName: 'myapp-image',  // Image name
    };

    await buildImage(options);
    console.log('[INFO] Docker image built successfully!');
  } catch (error) {
    console.error(`[ERROR] Image build failed: ${error.message}`);
  }
})();

4. Run Docker Container

Run a Docker container from an image with customizable options.

// import module
const { runContainer } = require('dockmate');

// runContainer using options
(async () => {
  try {
    const options = {
      imageName: 'myapp:1.0',              // Image name
      ports: [{ host: 8080, container: 3000 }], // Port mapping
      env: { NODE_ENV: 'production' },    // Environment variables
      containerName: 'myapp-container',   // Name of the container
    };

    await runContainer(options);
    console.log('[INFO] Docker container started successfully!');
  } catch (error) {
    console.error(`[ERROR] Container start failed: ${error.message}`);
  }
})();

5. Development Mode (Live Reload)

Run a Docker container in development mode with live reload for specified paths.

// import module
const { startDevMode } = require('dockmate');

// use options to start the dev mode
(async () => {
  try {
    const options = {
      watchPaths: ['./src', './index.js'], // Files or directories to watch
      dockerfilePath: './Dockerfile',      // Path to Dockerfile
      imageName: 'dev-image',             // Image name for development
      containerName: 'dev-container',     // Container name
      autoRestart: true,                  // Auto-restart on changes
    };

    await startDevMode(options);
    console.log('[INFO] Development mode started. Watching for changes...');
  } catch (error) {
    console.error(`[ERROR] Development mode failed: ${error.message}`);
  }
})();

Again prefer using dockmate CLI

Contributing

Contributions are welcome! Here’s how you can help, read the Contribution-guide.md file. Feel free to report bugs or suggest new features by opening an issue.