@nutin/cli 1.3.0 → 2.0.0

package/templates/base/tools/utils/print.js.hbs

@@ -12,20 +12,26 @@ export const chalk = {
   boldYellow: (s) => `\x1b[1;33m${s}\x1b[0m`,
   boldCyan: (s) => `\x1b[1;36m${s}\x1b[0m`,
   boldPurple: (s) => `\x1b[1;35m${s}\x1b[0m`,
+  boldGray: (s) => `\x1b[1;90m${s}\x1b[0m`,
 };
 
 export const print = {
-	head: (s) => console.log(`${chalk.purple(s)}`),  
-	boldHead : (s) => console.log(`${chalk.boldPurple(s)}`),
-	section: (s) => console.log(`${chalk.yellow(s)}`),
-	boldSection: (s) => console.log(`${chalk.boldYellow(s)}`),
-	info: (s) => console.log(`${chalk.green(s)}`),
-  boldInfo: (s) => console.log(`${chalk.boldGreen(s)}`),
-	success: (s) => console.log(`${chalk.cyan(s)}`),
-	boldSuccess: (s) => console.log(`${chalk.boldCyan(s)}`),
-	error: (s) => console.error(`${chalk.red(s)}`),
-	boldError: (s) => console.error(`${chalk.boldRed(s)}`),
-  grayError: (s) => console.error(`${chalk.gray(s)}`),
-  blue: (s) => console.log(`${chalk.blue(s)}`),
-  boldBlue: (s) => console.log(`${chalk.boldBlue(s)}`),
+  head: (s) => console.info(`${chalk.purple(s)}`),  
+  boldHead : (s) => console.info(`${chalk.boldPurple(s)}`),
+  section: (s) => console.info(`${chalk.yellow(s)}`),
+  boldSection: (s) => console.info(`${chalk.boldYellow(s)}`),
+  info: (s) => console.info(`${chalk.green(s)}`),
+  boldInfo: (s) => console.info(`${chalk.boldGreen(s)}`),
+  success: (s) => console.log(`${chalk.cyan(s)}`),
+  boldSuccess: (s) => console.log(`${chalk.boldCyan(s)}`),
+  gray: (s) => console.info(`${chalk.gray(s)}`),
+  boldGray: (s) => console.info(`${chalk.boldGray(s)}`),
+  blue: (s) => console.info(`${chalk.blue(s)}`),
+  boldBlue: (s) => console.info(`${chalk.boldBlue(s)}`),
+  error: (s) => console.error(`${chalk.red(s)}`),
+  boldError: (s) => console.error(`${chalk.boldRed(s)}`),
+  grayError: (s) => console.error(`${chalk.boldGray(s)}`),
+  warn: (s) => console.warn(`${chalk.yellow(s)}`),
+  boldWarn: (s) => console.warn(`${chalk.yellow(s)}`),
+  debug: (s) => console.debug(`${chalk.gray(s)}`),
 }

package/templates/base/tools/utils/print.test.js.hbs

@@ -0,0 +1,60 @@
+import { print, chalk } from './print.js';
+
+describe('print', () => {
+  let infoSpy;
+  let logSpy;
+  let errorSpy;
+  let warnSpy;
+  let debugSpy;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, 'info').andCallFake(() => {});
+    logSpy = spyOn(console, 'log').andCallFake(() => {});
+    errorSpy = spyOn(console, 'error').andCallFake(() => {});
+    warnSpy = spyOn(console, 'warn').andCallFake(() => {});
+    debugSpy = spyOn(console, 'debug').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    infoSpy.restore();
+    logSpy.restore();
+    errorSpy.restore();
+    warnSpy.restore();
+    debugSpy.restore();
+  });
+
+  it('info() writes to console.info, colorized green', () => {
+    print.info('hello');
+    expect(infoSpy.callCount).toBe(1);
+    expect(infoSpy.lastCall).toEqual([chalk.green('hello')]);
+  });
+
+  it('success() writes to console.log, colorized cyan', () => {
+    print.success('done');
+    expect(logSpy.callCount).toBe(1);
+    expect(logSpy.lastCall).toEqual([chalk.cyan('done')]);
+  });
+
+  it('error() writes to console.error, colorized red', () => {
+    print.error('oops');
+    expect(errorSpy.callCount).toBe(1);
+    expect(errorSpy.lastCall).toEqual([chalk.red('oops')]);
+  });
+
+  it('warn() writes to console.warn, colorized yellow', () => {
+    print.warn('careful');
+    expect(warnSpy.callCount).toBe(1);
+    expect(warnSpy.lastCall).toEqual([chalk.yellow('careful')]);
+  });
+
+  it('debug() writes to console.debug, colorized gray', () => {
+    print.debug('trace');
+    expect(debugSpy.callCount).toBe(1);
+    expect(debugSpy.lastCall).toEqual([chalk.gray('trace')]);
+  });
+
+  it('chalk wraps text in the matching ANSI escape codes', () => {
+    expect(chalk.red('x')).toBe('\x1b[31mx\x1b[0m');
+    expect(chalk.boldGreen('x')).toBe('\x1b[1;32mx\x1b[0m');
+  });
+});

package/templates/base/tools/utils/prompt-boolean.js.hbs

@@ -7,9 +7,16 @@ export const promptBoolean = (question) => {
   });
 
   return new Promise((resolve) => {
+    let answered = false;
+
     rl.question(`${question} (y/n): `, (answer) => {
+      answered = true;
       rl.close();
       resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
     });
+
+    rl.on('close', () => {
+      if (!answered) resolve(false);
+    });
   });
 };

package/templates/base/tools/utils/prompt-boolean.test.js.hbs

@@ -0,0 +1,54 @@
+import readline from 'readline';
+import { promptBoolean } from './prompt-boolean.js';
+
+describe('promptBoolean', () => {
+  let createInterfaceSpy;
+  let answer;
+
+  beforeEach(() => {
+    createInterfaceSpy = spyOn(readline, 'createInterface').andCallFake(() => ({
+      question: (_question, callback) => callback(answer),
+      close: () => {},
+      on: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    createInterfaceSpy.restore();
+  });
+
+  it('resolves true for "y"', async () => {
+    answer = 'y';
+    expect(await promptBoolean('continue?')).toBe(true);
+  });
+
+  it('resolves true for "yes", case-insensitively', async () => {
+    answer = 'YES';
+    expect(await promptBoolean('continue?')).toBe(true);
+  });
+
+  it('resolves false for "n"', async () => {
+    answer = 'n';
+    expect(await promptBoolean('continue?')).toBe(false);
+  });
+
+  it('resolves false for anything else', async () => {
+    answer = 'maybe';
+    expect(await promptBoolean('continue?')).toBe(false);
+  });
+
+  it('resolves false instead of hanging if stdin closes before an answer', async () => {
+    createInterfaceSpy.restore();
+    let closeHandler;
+    createInterfaceSpy = spyOn(readline, 'createInterface').andCallFake(() => ({
+      question: () => {},
+      close: () => {},
+      on: (event, handler) => { if (event === 'close') closeHandler = handler; },
+    }));
+
+    const resultPromise = promptBoolean('continue?');
+    closeHandler();
+
+    expect(await resultPromise).toBe(false);
+  });
+});

package/templates/base/tools/utils/run-command.js.hbs

@@ -1,8 +1,10 @@
 import { spawn } from 'child_process';
 
-export function runCommand(command, args = []) {
+export function runCommand(command, args = [], options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: 'inherit', shell: true });
+    const child = spawn([command, ...args].join(' '), { stdio: 'inherit', shell: true, ...options });
+
+    child.on('error', (err) => reject(err));
 
     child.on('close', (code) => {
       if (code === 0) resolve();

package/templates/base/tools/utils/run-command.test.js.hbs

@@ -0,0 +1,19 @@
+import { runCommand } from './run-command.js';
+
+describe('runCommand', () => {
+  it('resolves when the child process exits with code 0', async () => {
+    const result = await runCommand('node', ['-e', 'process.exitCode=0']);
+    expect(result).toBe(undefined);
+  });
+
+  it('rejects with the exit code when the child process exits non-zero', async () => {
+    let error;
+    try {
+      await runCommand('node', ['-e', 'process.exitCode=7']);
+    } catch (err) {
+      error = err;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toContain('7');
+  });
+});

package/templates/base/tools/utils/run-script.js.hbs

@@ -4,17 +4,28 @@ import process from 'process';
 import { print } from './index.js';
 
 export function runScript(path, message) {
-  print.boldSection(message);
+  if (!message) print.boldSection(`Running ${path}...`);
+  else print.boldSection(`${message}`);
 
-  const args = [resolve(path)];
+  const args = [resolve(path), '--silent'];
 
-  const result = spawnSync('node', args, 
+  const result = spawnSync('node', args,
     { 
       stdio: 'inherit',
       env: { ...process.env }, 
     }
   );
 
+  if (result.error) {
+    print.boldError(`\nScript ${path} could not be started: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.signal) {
+    print.boldError(`\nScript ${path} was terminated by signal ${result.signal}.`);
+    process.exit(1);
+  }
+
   if (result.status !== 0) {
     print.boldError(`\nScript ${path} failed.`);
     process.exit(result.status ?? 1);

package/templates/base/tools/utils/run-script.test.js.hbs

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { runScript } from './run-script.js';
+
+describe('runScript', () => {
+  let tmpDir;
+  let exitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-run-script-'));
+    exitSpy = spyOn(process, 'exit').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.restore();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('does not call process.exit when the script exits 0', () => {
+    const scriptPath = path.join(tmpDir, 'ok.js');
+    fs.writeFileSync(scriptPath, '// no-op, exits 0 by default\n');
+
+    // runScript prints its status message via console.info as part of its real behavior
+    silenceConsole('info', () => runScript(scriptPath, 'running ok script'));
+
+    expect(exitSpy.callCount).toBe(0);
+  });
+
+  it('calls process.exit with the script status when it exits non-zero', () => {
+    const scriptPath = path.join(tmpDir, 'fail.js');
+    fs.writeFileSync(scriptPath, 'process.exitCode = 3;\n');
+
+    // runScript prints its status message and a failure message via console.info/console.error
+    silenceConsole(['info', 'error'], () => runScript(scriptPath, 'running failing script'));
+
+    expect(exitSpy.callCount).toBe(1);
+    expect(exitSpy.lastCall).toEqual([3]);
+  });
+});

package/templates/features/{deployHelper → docker}/.dockerignore.hbs

@@ -8,13 +8,13 @@ dist-build
 *.md
 .env
 *.txt
-{{#if testinNutin}}
 *.test.js
-testin-nutin
-{{/if}}
 *.log
 
-npm-debug.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
 .nyc_output
 coverage
 .DS_Store

package/templates/features/docker/tools/docker/Dockerfile.template.hbs

@@ -0,0 +1,51 @@
+ARG NODE_VERSION=22.23.2
+ARG ALPINE_VERSION=3.20
+ARG PORT="__PORTS_PLACEHOLDER__"
+
+FROM node:${NODE_VERSION}-alpine AS builder
+WORKDIR /usr/src/app
+RUN corepack enable
+{{#if (eq packageManager "npm")}}
+COPY package.json package-lock.json* .
+{{/if}}
+{{#if (eq packageManager "pnpm")}}
+COPY package.json pnpm-lock.yaml .
+{{/if}}
+{{#if (eq packageManager "yarn")}}
+COPY package.json yarn.lock .
+{{/if}}
+{{#if (eq packageManager "bun")}}
+COPY package.json bun.lock* bun.lockb* .
+RUN npm install -g bun
+{{/if}}
+{{#if (eq packageManager "pnpm")}}
+RUN {{ciCommand}} || pnpm approve-builds --all
+{{else}}
+RUN {{ciCommand}}
+{{/if}}
+COPY tsconfig.json .
+COPY ./src ./src
+COPY ./public ./public
+COPY ./nutin.config.js .
+COPY ./config ./config
+COPY ./tools/builder ./tools/builder
+COPY ./tools/docker ./tools/docker
+COPY ./tools/utils ./tools/utils
+RUN {{packageManager}} run build:prod
+
+FROM alpine:${ALPINE_VERSION}
+ARG PORT
+ENV PORT=${PORT}
+
+RUN apk add --no-cache nginx nginx-mod-http-brotli
+
+RUN rm -f /etc/nginx/http.d/default.conf
+COPY --from=builder /usr/src/app/tools/docker/nginx.conf /etc/nginx/http.d/default.conf
+COPY --from=builder /usr/src/app/dist/src /usr/share/nginx/html
+
+EXPOSE ${PORT}
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://127.0.0.1:__PRIMARY_PORT_PLACEHOLDER__/health || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]

package/templates/features/{deployHelper/tools/deployment/nginx.conf.hbs → docker/tools/docker/nginx.conf.template}

@@ -30,14 +30,16 @@ map $uri $csp_policy {
 # ---------------------------
 gzip on;
 gzip_static on;
-gzip_vary on;
 gzip_proxied any;
 
+brotli on;
+brotli_static on;
+
 server {
     # ---------------------------
     # LISTEN PORTS
     # ---------------------------
-    listen 9090;
+    __PORTS_PLACEHOLDER__
     server_name _;
 
     # ---------------------------

package/templates/features/docker/tools/docker/scripts/docker-build.js.hbs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { readFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { print, runScript } from '../../utils/index.js';
+
+const { name: projectName } = JSON.parse(readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
+
+runScript(path.join(process.cwd(), 'tools', 'docker', 'scripts', 'validate-docker.js'), 'Validating Docker configuration...');
+
+const args = ['build', '-t', projectName, '-f', 'tools/docker/Dockerfile', '.'];
+print.boldSection(`Running: docker ${args.join(' ')}`);
+
+const child = spawn('docker', args, { stdio: 'inherit' });
+child.on('error', (err) => {
+  print.boldError(`Failed to start docker: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code) => process.exit(code ?? 1));

package/templates/features/docker/tools/docker/scripts/docker-ports.js.hbs

@@ -0,0 +1,48 @@
+// Registered/user port range only — excludes privileged ports (<1024, may need
+// elevated host privileges to bind) and the OS ephemeral range (>=49152, reserved
+// for outgoing/dynamic connections, not meant for fixed service ports).
+const MIN_PORT = 1024;
+const MAX_PORT = 49151;
+
+export function validateDockerPorts(rawPorts) {
+  if (rawPorts === undefined) {
+    throw new Error('nutin.config.js: "dockerPorts" not found. It must be an array of integers (e.g. [9090, 6969])');
+  }
+
+  if (!Array.isArray(rawPorts)) {
+    throw new Error('nutin.config.js: "dockerPorts" must be an array of integers (e.g. [9090, 6969]).');
+  }
+
+  if (rawPorts.length === 0) {
+    throw new Error('nutin.config.js: "dockerPorts" must contain at least one port (e.g. [9090]).');
+  }
+
+  const seen = new Set();
+
+  for (let i = 0; i < rawPorts.length; i++) {
+    const port = rawPorts[i];
+
+    if (typeof port !== 'number' || !Number.isInteger(port)) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" must be an integer; ports must be numbers, e.g. 9090 not "9090".`);
+    }
+
+    if (port < MIN_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is a privileged port (<1024) — use a registered port between ${MIN_PORT} and ${MAX_PORT}.`);
+    }
+
+    if (port > MAX_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is in the OS ephemeral port range (49152-65535) — use a registered port between ${MIN_PORT} and ${MAX_PORT}.`);
+    }
+
+    if (port < MIN_PORT || port > MAX_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is outside of port range (${MIN_PORT} / ${MAX_PORT} .`);
+    }
+
+    if (seen.has(port)) {
+      throw new Error(`nutin.config.js: "dockerPorts" contains duplicate port ${port} — each port must be listed once.`);
+    }
+    seen.add(port);
+  }
+
+  return rawPorts;
+}

package/templates/features/docker/tools/docker/scripts/docker-ports.test.js.hbs

@@ -0,0 +1,52 @@
+import { validateDockerPorts } from './docker-ports.js';
+
+describe('validateDockerPorts', () => {
+  it('throws when dockerPorts is not set', () => {
+    expect(() => validateDockerPorts(undefined)).toThrow('"dockerPorts" not found');
+  });
+
+  it('throws when dockerPorts is not an array', () => {
+    expect(() => validateDockerPorts(9090)).toThrow('must be an array of integers');
+    expect(() => validateDockerPorts('9090')).toThrow('must be an array of integers');
+    expect(() => validateDockerPorts({ port: 9090 })).toThrow('must be an array of integers');
+  });
+
+  it('throws when dockerPorts is empty', () => {
+    expect(() => validateDockerPorts([])).toThrow('must contain at least one port');
+  });
+
+  it('throws when an entry is not an integer', () => {
+    expect(() => validateDockerPorts(['8080'])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([8080.5])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([NaN])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([true])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([null])).toThrow('must be an integer');
+  });
+
+  it('throws for privileged ports below 1024', () => {
+    expect(() => validateDockerPorts([80])).toThrow('privileged port');
+    expect(() => validateDockerPorts([1023])).toThrow('privileged port');
+  });
+
+  it('throws for ephemeral ports at or above 49152', () => {
+    expect(() => validateDockerPorts([49152])).toThrow('ephemeral port range');
+    expect(() => validateDockerPorts([60000])).toThrow('ephemeral port range');
+  });
+
+  it('throws for duplicate ports', () => {
+    expect(() => validateDockerPorts([8080, 8080])).toThrow('duplicate port');
+  });
+
+  it('identifies the invalid entry by index in the error message', () => {
+    expect(() => validateDockerPorts([8080, 80])).toThrow('dockerPorts[1]');
+  });
+
+  it('accepts the registered-port range boundaries', () => {
+    expect(validateDockerPorts([1024])).toEqual([1024]);
+    expect(validateDockerPorts([49151])).toEqual([49151]);
+  });
+
+  it('returns a valid multi-port array unchanged', () => {
+    expect(validateDockerPorts([8080, 8081, 3000])).toEqual([8080, 8081, 3000]);
+  });
+});

package/templates/features/docker/tools/docker/scripts/docker-run.js.hbs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { print, errorExit } from '../../utils/index.js';
+import nutinConfig from '../../../nutin.config.js';
+import { validateDockerPorts } from './docker-ports.js';
+
+const { name: projectName } = JSON.parse(readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
+
+let ports;
+try {
+  ports = validateDockerPorts(nutinConfig.dockerPorts);
+} catch (err) {
+  errorExit(err.message);
+}
+
+const portArgs = ports.flatMap((port) => ['-p', `${port}:${port}`]);
+const args = ['run', ...portArgs, `${projectName}:latest`];
+print.boldSection(`Running: docker ${args.join(' ')}`);
+
+const child = spawn('docker', args, { stdio: 'inherit' });
+child.on('error', (err) => {
+  print.boldError(`Failed to start docker: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code) => process.exit(code ?? 1));

package/templates/features/docker/tools/docker/scripts/render-docker-template.js.hbs

@@ -0,0 +1,23 @@
+import { readFile, writeFile } from 'fs/promises';
+import path from 'path';
+
+export async function renderFromTemplate(dockerDir, templateName, outputName, replacements) {
+  const templatePath = path.join(dockerDir, templateName);
+  const outputPath = path.join(dockerDir, outputName);
+
+  let content;
+  try {
+    content = await readFile(templatePath, 'utf-8');
+  } catch {
+    throw new Error(`tools/docker/${templateName} not found — re-run "nutin-add docker" or restore the file.`);
+  }
+
+  for (const [placeholder, value] of replacements) {
+    if (!content.includes(placeholder)) {
+      throw new Error(`tools/docker/${templateName} is missing the "${placeholder}" token — validate-docker has nothing to substitute. Restore the token or re-run "nutin-add docker".`);
+    }
+    content = content.replace(placeholder, value);
+  }
+
+  await writeFile(outputPath, content);
+}

package/templates/features/docker/tools/docker/scripts/render-docker-template.test.js.hbs

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { renderFromTemplate } from './render-docker-template.js';
+
+describe('renderFromTemplate', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-render-docker-template-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('substitutes a single placeholder and writes the output file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'nginx.conf.template'), '__PORTS_PLACEHOLDER__;\n');
+
+    await renderFromTemplate(tmpDir, 'nginx.conf.template', 'nginx.conf', [
+      ['__PORTS_PLACEHOLDER__', 'listen 8080;'],
+    ]);
+
+    const output = fs.readFileSync(path.join(tmpDir, 'nginx.conf'), 'utf-8');
+    expect(output).toBe('listen 8080;;\n');
+  });
+
+  it('substitutes multiple placeholders in one call', async () => {
+    fs.writeFileSync(
+      path.join(tmpDir, 'Dockerfile.template'),
+      'ARG PORT="__PORTS_PLACEHOLDER__"\nCMD wget http://127.0.0.1:__PRIMARY_PORT_PLACEHOLDER__/health\n'
+    );
+
+    await renderFromTemplate(tmpDir, 'Dockerfile.template', 'Dockerfile', [
+      ['__PORTS_PLACEHOLDER__', '8080 8081 3000'],
+      ['__PRIMARY_PORT_PLACEHOLDER__', '8080'],
+    ]);
+
+    const output = fs.readFileSync(path.join(tmpDir, 'Dockerfile'), 'utf-8');
+    expect(output).toBe('ARG PORT="8080 8081 3000"\nCMD wget http://127.0.0.1:8080/health\n');
+  });
+
+  it('throws when the template file does not exist', async () => {
+    await expect(() =>
+      renderFromTemplate(tmpDir, 'missing.template', 'missing', [['__X__', 'y']])
+    ).toThrow('missing.template');
+  });
+
+  it('throws when a placeholder token is missing from the template, without writing the output', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'nginx.conf.template'), 'listen 9090;\n');
+
+    await expect(() =>
+      renderFromTemplate(tmpDir, 'nginx.conf.template', 'nginx.conf', [
+        ['__PORTS_PLACEHOLDER__', 'listen 8080;'],
+      ])
+    ).toThrow('__PORTS_PLACEHOLDER__');
+
+    expect(fs.existsSync(path.join(tmpDir, 'nginx.conf'))).toBeFalsy();
+  });
+});

package/templates/features/docker/tools/docker/scripts/validate-docker.js.hbs

@@ -0,0 +1,30 @@
+import path from 'path';
+import { errorExit } from '../../utils/index.js';
+import nutinConfig from '../../../nutin.config.js';
+import { validateDockerPorts } from './docker-ports.js';
+import { renderFromTemplate } from './render-docker-template.js';
+
+const DOCKER_DIR = path.join(process.cwd(), 'tools', 'docker');
+const PLACEHOLDER = '__PORTS_PLACEHOLDER__';
+
+async function validateDocker() {
+  let ports;
+  try {
+    ports = validateDockerPorts(nutinConfig.dockerPorts);
+  } catch (err) {
+    errorExit(err.message);
+  }
+
+  await renderFromTemplate(DOCKER_DIR, 'Dockerfile.template', 'Dockerfile', [
+    [PLACEHOLDER, ports.join(' ')],
+    ['__PRIMARY_PORT_PLACEHOLDER__', String(ports[0])],
+  ]).catch((err) => errorExit(err.message));
+
+  await renderFromTemplate(DOCKER_DIR, 'nginx.conf.template', 'nginx.conf', [
+    [PLACEHOLDER, ports.map((port) => `listen ${port};`).join('\n    ')],
+  ]).catch((err) => errorExit(err.message));
+}
+
+validateDocker().catch((err) => {
+  errorExit(err, 'validate-docker');
+});