راه‌اندازی بک‌اند Node.js روی اوبونتو؛ از SSH تا HTTPS

$appDir = Join-Path $HOME 'Node Ubuntu Lab'
New-Item -ItemType Directory -Path $appDir -ErrorAction Stop | Out-Null
Set-Location -LiteralPath $appDir
node --version
Get-Location

{
  "name": "darsavand-node-task-lab",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "engines": { "node": ">=24" },
  "scripts": {
    "start": "node server.mjs",
    "start:env": "node --env-file=.env server.mjs",
    "check": "node --check app.mjs && node --check model.mjs && node --check server.mjs && node --check app.test.mjs",
    "test": "node --test app.test.mjs"
  }
}

import { randomUUID } from 'node:crypto';

export class AppError extends Error {
  constructor(status, code) { super(code); this.status = status; }
}

function exactObject(value, key) {
  if (!value || typeof value !== 'object' || Array.isArray(value) ||
      Object.keys(value).length !== 1 || !Object.hasOwn(value, key)) {
    throw new AppError(422, 'INVALID_FIELDS');
  }
}

export function makeStore() {
  const tasks = new Map();
  return {
    list() { return [...tasks.values()].map(task => ({ ...task })); },
    get(id) {
      const task = tasks.get(id);
      if (!task) throw new AppError(404, 'TASK_NOT_FOUND');
      return { ...task };
    },
    create(input) {
      exactObject(input, 'title');
      if (typeof input.title !== 'string') throw new AppError(422, 'INVALID_TITLE');
      const title = input.title.trim();
      if (title.length < 2 || title.length > 100) throw new AppError(422, 'INVALID_TITLE');
      if (tasks.size >= 1000) throw new AppError(409, 'TASK_LIMIT');
      const task = { id: randomUUID(), title, done: false };
      tasks.set(task.id, task);
      return { ...task };
    },
    update(id, input) {
      exactObject(input, 'done');
      if (typeof input.done !== 'boolean') throw new AppError(422, 'INVALID_DONE');
      const current = this.get(id);
      const task = { ...current, done: input.done };
      tasks.set(id, task);
      return { ...task };
    }
  };
}

import { createServer } from 'node:http';
import { AppError, makeStore } from './model.mjs';

const BODY_LIMIT = 8192;
function readJson(req) {
  const type = (req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase();
  if (type !== 'application/json' ||
      (req.headers['content-encoding'] && req.headers['content-encoding'] !== 'identity')) {
    req.resume();
    return Promise.reject(new AppError(415, 'JSON_REQUIRED'));
  }
  return new Promise((resolve, reject) => {
    const chunks = [];
    let size = 0;
    let settled = false;
    const fail = error => { if (!settled) { settled = true; reject(error); } };
    req.on('data', chunk => {
      if (settled) return;
      size += chunk.length;
      if (size > BODY_LIMIT) {
        chunks.length = 0;
        fail(new AppError(413, 'BODY_TOO_LARGE'));
      } else chunks.push(chunk);
    });
    req.on('error', () => fail(new AppError(400, 'BODY_INTERRUPTED')));
    req.on('aborted', () => fail(new AppError(400, 'BODY_INTERRUPTED')));
    req.on('end', () => {
      if (settled) return;
      try {
        const text = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
        const value = JSON.parse(text);
        settled = true;
        resolve(value);
      } catch { fail(new AppError(400, 'INVALID_JSON')); }
    });
  });
}

function json(res, status, body, headers = {}) {
  const data = JSON.stringify(body);
  res.writeHead(status, {
    'Content-Type': 'application/json; charset=utf-8',
    'Content-Length': Buffer.byteLength(data),
    'Cache-Control': 'no-store',
    'X-Content-Type-Options': 'nosniff',
    ...headers
  });
  res.end(data);
}

export function makeServer() {
  const store = makeStore();
  return createServer({ requestTimeout: 15000, headersTimeout: 10000, maxHeaderSize: 8192 },
    async (req, res) => {
      try {
        const path = new URL(req.url, 'http://127.0.0.1').pathname;
        const match = /^\/tasks\/([0-9a-f-]{36})$/.exec(path);
        const allow = path === '/health' ? 'GET' : path === '/tasks' ? 'GET, POST' : match ? 'GET, PATCH' : '';
        if (!allow) throw new AppError(404, 'ROUTE_NOT_FOUND');
        if (!allow.split(', ').includes(req.method)) {
          req.resume();
          return json(res, 405, { error: 'METHOD_NOT_ALLOWED' }, { Allow: allow, Connection: 'close' });
        }
        if (path === '/health') return json(res, 200, { ok: true });
        if (path === '/tasks' && req.method === 'GET') return json(res, 200, { tasks: store.list() });
        if (path === '/tasks') {
          const task = store.create(await readJson(req));
          return json(res, 201, { task }, { Location: `/tasks/${task.id}` });
        }
        if (req.method === 'GET') return json(res, 200, { task: store.get(match[1]) });
        const task = store.update(match[1], await readJson(req));
        return json(res, 200, { task });
      } catch (error) {
        if (res.destroyed || res.writableEnded) return;
        const known = error instanceof AppError;
        json(res, known ? error.status : 500,
          { error: known ? error.message : 'INTERNAL_ERROR' }, { Connection: 'close' });
      }
    });
}

import { makeServer } from './app.mjs';

const raw = process.env.PORT ?? '3000';
if (!/^\d{1,5}$/.test(raw) || Number(raw) < 1 || Number(raw) > 65535) {
  console.error('PORT must be an integer from 1 to 65535');
  process.exitCode = 1;
} else {
  const server = makeServer();
  server.on('error', error => {
    console.error(`Cannot start: ${error.code ?? 'UNKNOWN'}`);
    process.exitCode = 1;
  });
  server.listen(Number(raw), '127.0.0.1', () => {
    console.log(`Task API: http://127.0.0.1:${Number(raw)}/health`);
  });
  let stopping = false;
  const stop = () => {
    if (stopping) return;
    stopping = true;
    server.close();
    const deadline = setTimeout(() => server.closeAllConnections(), 3000);
    deadline.unref();
  };
  process.on('SIGINT', stop);
  process.on('SIGTERM', stop);
}

import test from 'node:test';
import assert from 'node:assert/strict';
import { once } from 'node:events';
import { request } from 'node:http';
import { makeServer } from './app.mjs';
import { makeStore } from './model.mjs';

async function withServer(run) {
  const server = makeServer();
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  const base = `http://127.0.0.1:${server.address().port}`;
  try { await run(base); }
  finally { await new Promise(resolve => server.close(resolve)); }
}
const post = (base, body, headers = { 'Content-Type': 'application/json' }) =>
  fetch(`${base}/tasks`, { method: 'POST', headers, body });

test('health, JSON type and no-store', () => withServer(async base => {
  const response = await fetch(`${base}/health`);
  assert.equal(response.status, 200);
  assert.match(response.headers.get('content-type'), /application\/json/);
  assert.equal(response.headers.get('cache-control'), 'no-store');
  assert.deepEqual(await response.json(), { ok: true });
}));
test('new server starts with empty list', () => withServer(async base => {
  assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] });
}));
test('create, list, read and update a Persian task', () => withServer(async base => {
  const created = await post(base, JSON.stringify({ title: '  یادگیری سرور  ' }));
  assert.equal(created.status, 201);
  const { task } = await created.json();
  assert.equal(task.title, 'یادگیری سرور');
  assert.equal(task.done, false);
  assert.match(task.id, /^[0-9a-f-]{36}$/);
  assert.equal(created.headers.get('location'), `/tasks/${task.id}`);
  assert.deepEqual((await (await fetch(base + created.headers.get('location'))).json()).task, task);
  const changed = await fetch(`${base}/tasks/${task.id}`, {
    method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: '{"done":true}'
  });
  assert.equal(changed.status, 200);
  assert.equal((await changed.json()).task.done, true);
  assert.equal((await (await fetch(`${base}/tasks`)).json()).tasks[0].done, true);
}));
test('malformed JSON is 400 and does not create data', () => withServer(async base => {
  assert.equal((await post(base, '{')).status, 400);
  assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] });
}));
test('empty JSON body is 400', () => withServer(async base => {
  assert.equal((await post(base, '')).status, 400);
}));
test('invalid UTF-8 is 400', () => withServer(async base => {
  assert.equal((await post(base, Buffer.from([0xff]))).status, 400);
}));
test('wrong content type is 415', () => withServer(async base => {
  assert.equal((await post(base, '{"title":"hello"}', { 'Content-Type': 'text/plain' })).status, 415);
}));
test('compressed body is outside this contract', () => withServer(async base => {
  assert.equal((await post(base, '{}', {
    'Content-Type': 'application/json', 'Content-Encoding': 'gzip'
  })).status, 415);
}));
test('body limit is bytes, including multibyte Persian', () => withServer(async base => {
  const body = JSON.stringify({ title: 'س'.repeat(5000) });
  assert.ok(Buffer.byteLength(body) > 8192);
  assert.equal((await post(base, body)).status, 413);
}));
test('chunked oversized body receives 413 JSON', () => withServer(base => new Promise((resolve, reject) => {
  const req = request(`${base}/tasks`, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }
  }, response => {
    let body = '';
    response.setEncoding('utf8');
    response.on('data', chunk => { body += chunk; });
    response.on('end', () => {
      try {
        assert.equal(response.statusCode, 413);
        assert.equal(JSON.parse(body).error, 'BODY_TOO_LARGE');
        resolve();
      } catch (error) { reject(error); }
    });
  });
  req.on('error', reject);
  req.write('x'.repeat(5000));
  req.end('x'.repeat(5000));
})));
for (const [name, input] of [
  ['array', []], ['null', null], ['number title', { title: 42 }],
  ['blank title', { title: '   ' }], ['long title', { title: 'x'.repeat(101) }],
  ['extra field', { title: 'hello', admin: true }]
]) {
  test(`reject ${name} with 422`, () => withServer(async base => {
    assert.equal((await post(base, JSON.stringify(input))).status, 422);
  }));
}
test('unknown route is 404', () => withServer(async base => {
  assert.equal((await fetch(`${base}/unknown`)).status, 404);
}));
test('unsupported method has 405 and Allow header', () => withServer(async base => {
  const response = await fetch(`${base}/tasks`, { method: 'DELETE' });
  assert.equal(response.status, 405);
  assert.equal(response.headers.get('allow'), 'GET, POST');
}));
test('missing task is 404', () => withServer(async base => {
  assert.equal((await fetch(`${base}/tasks/00000000-0000-0000-0000-000000000000`)).status, 404);
}));
test('done must be boolean, rejected update preserves task', () => withServer(async base => {
  const { task } = await (await post(base, '{"title":"hello"}')).json();
  const response = await fetch(`${base}/tasks/${task.id}`, {
    method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: '{"done":"true"}'
  });
  assert.equal(response.status, 422);
  assert.equal((await (await fetch(`${base}/tasks/${task.id}`)).json()).task.done, false);
}));
test('each server owns its own in-memory state', async () => {
  await withServer(async base => { assert.equal((await post(base, '{"title":"hello"}')).status, 201); });
  await withServer(async base => { assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] }); });
});
test('store returns copies and enforces maximum count', () => {
  const store = makeStore();
  const first = store.create({ title: 'hello' });
  first.title = 'changed outside';
  assert.equal(store.get(first.id).title, 'hello');
  const list = store.list(); list[0].done = true;
  assert.equal(store.get(first.id).done, false);
  for (let i = 1; i < 1000; i++) store.create({ title: `task ${i}` });
  assert.throws(() => store.create({ title: 'overflow' }), error => error.status === 409);
});

PORT=3000

node_modules/
.env
*.log

npm.cmd run check
if ($LASTEXITCODE -ne 0) { throw 'Syntax check failed; stop here.' }
npm.cmd test
if ($LASTEXITCODE -ne 0) { throw 'Tests failed; stop here.' }
$files = @('package.json','model.mjs','app.mjs','server.mjs','app.test.mjs','.env.example','.gitignore')
$lines = $files | ForEach-Object {
  $hash = (Get-FileHash -LiteralPath $_ -Algorithm SHA256).Hash.ToLowerInvariant()
  '{0}  {1}' -f $hash, $_
}
[System.IO.File]::WriteAllLines((Join-Path $appDir 'SHA256SUMS'), [string[]]$lines, [System.Text.UTF8Encoding]::new($false))
Get-Content -LiteralPath .\SHA256SUMS

mkdir -p "$HOME/node-upload"
mkdir -m 700 "$HOME/node-upload/r1"

$serverHost = '203.0.113.10'
$serverUser = 'ubuntu'
$sshPort = 22
scp.exe -P $sshPort .\package.json .\model.mjs .\app.mjs .\server.mjs .\app.test.mjs .\.env.example .\.gitignore .\SHA256SUMS "${serverUser}@${serverHost}:node-upload/r1/"
if ($LASTEXITCODE -ne 0) { throw 'Transfer failed; inspect the error before continuing.' }