الـ Object Storage والـ Media: presigned URLs و uploads مباشرة

// media.js: الـ uploads بتروح للـ storage مباشرة بـ presigned URLs، والـ server بيتأكد ويعمل processing في background
import { createHmac, createHash, randomUUID } from "node:crypto";

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

export function presign({ base, bucket, secret, method, key, ttlMs, contentType = null, maxBytes = null, now = Date.now }) {
  const expires = now() + ttlMs;
  const toSign = [method, bucket, key, expires, contentType ?? "", maxBytes ?? ""].join("\n");
  const sig = createHmac("sha256", secret).update(toSign).digest("hex");
  const q = new URLSearchParams({ "X-Method": method, "X-Expires": String(expires) });
  if (contentType) q.set("X-Content-Type", contentType);
  if (maxBytes != null) q.set("X-Max-Bytes", String(maxBytes));
  q.set("X-Signature", sig);
  const path = key.split("/").map(encodeURIComponent).join("/");
  return { url: `${base}/${bucket}/${path}?${q}`, expiresAt: expires };
}

const MAGIC = {
  "image/png": [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
  "image/jpeg": [0xff, 0xd8, 0xff],
};

export function sniff(buf) {
  for (const [type, sig] of Object.entries(MAGIC)) if (sig.every((b, i) => buf[i] === b)) return type;
  return null;
}

export function pngSize(buf) {
  if (sniff(buf) !== "image/png" || buf.length < 24) return null;
  return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
}

export function safeFilename(name) {
  const base = String(name ?? "").split(/[\\/]/).pop().normalize("NFKC");
  const clean = base.replace(/[^\p{L}\p{N}._-]+/gu, "_").replace(/^\.+/, "").slice(0, 100);
  return clean || "file";
}

export function createMediaService({
  storage, bucket, secret, now = Date.now,
  maxBytes = 5 * 1024 * 1024, allowed = ["image/png", "image/jpeg"],
  uploadTtl = 300000, downloadTtl = 60000,
}) {
  const records = new Map();
  const queue = [];
  const sign = (method, key, ttlMs, extra = {}) => presign({ base: storage.url, bucket, secret, method, key, ttlMs, now, ...extra });

  function mine(userId, id) {
    const r = records.get(id);
    if (!r || r.userId !== userId) throw new MediaError("NOT_FOUND");
    return r;
  }

  function createUpload(userId, { filename, contentType, size } = {}) {
    if (!allowed.includes(contentType)) throw new MediaError("UNSUPPORTED_TYPE");
    if (!Number.isInteger(size) || size <= 0 || size > maxBytes) throw new MediaError("TOO_LARGE");
    const id = randomUUID();
    const key = `uploads/${userId}/${id}`;
    const rec = { id, userId, key, filename: safeFilename(filename), contentType, size, status: "pending", createdAt: now() };
    records.set(id, rec);
    const { url, expiresAt } = sign("PUT", key, uploadTtl, { contentType, maxBytes: size });
    return { id, key, url, expiresAt };
  }

  async function completeUpload(userId, id) {
    const rec = mine(userId, id);
    if (rec.status !== "pending") return { ...rec };
    const head = await stora
…

$ node lab.js
— 1) الـ client بيطلب upload، والـ file بيروح للـ storage على طول —
  الـ server رجّع key: uploads/sara/bdef5ca7-5472-46fc-9379-cbbefa4a6506
  والـ URL صالح لحد: 14:51:35 وفيه: X-Method X-Expires X-Content-Type X-Max-Bytes X-Signature
  PUT للـ storage: 200 تمام
  الـ server استلم كام byte من الـ file؟ صفر. الـ storage استلم: 150000

— 2) محاولات غلط —
  نفس الـ URL على key تاني: 403 SignatureDoesNotMatch
  file أكبر من اللي اتقال: 413 EntityTooLarge
  content-type تاني: 403 ContentTypeMismatch
  بعد ما الـ URL انتهى: 403 RequestExpired
  HTML على إنه PNG، الـ PUT نفسه: 200 تمام
  بس الـ complete: BAD_CONTENT ، والـ object اتمسح: true

— 3) complete، والـ processing في background —
  بعد الـ complete: processing ، والـ filename المتنضّف: صورة_البروفايل.png
  download قبل ما يخلص: NOT_READY
  الـ worker خلّص: ready 1080x720 sha256 2e269eef766d
  الـ objects: [
  'derived/bdef5ca7-5472-46fc-9379-cbbefa4a6506/meta.json',
  'uploads/sara/bdef5ca7-5472-46fc-9379-cbbefa4a6506'
]

— 4) الـ download: private، و URL قصير العمر —
  GET: 200 image/png 150000 bytes
  omar بيحاول ياخد URL لصورة سارة: NOT_FOUND
  الـ path من غير signature: 403
  نفس الـ URL بعد دقيقة: 403

— 5) upl
…

// upload.naive.js: الـ file بيعدّي على الـ server، وبيتحفظ على الـ disk بتاعه
import { createServer } from "node:http";
import { writeFileSync, mkdirSync } from "node:fs";

mkdirSync("public/uploads", { recursive: true });
createServer(async (req, res) => {
  if (req.method !== "POST" || req.url !== "/upload") return res.writeHead(404).end();
  let raw = "";
  for await (const c of req) raw += c; // الـ file كله في الـ memory، وكمان base64 يعني أكبر بالتلت
  const { filename, data } = JSON.parse(raw);
  // الاسم من الـ user زي ما هو: ../../server.js ؟
  writeFileSync(`public/uploads/${filename}`, Buffer.from(data, "base64"));
  // وبعدين resize هنا، والـ request مستني
  res.end(JSON.stringify({ url: `/uploads/${filename}` })); // public لأي حد يعرف الاسم
}).listen(3000);
// والمشاكل:
// - كل upload واخد memory و bandwidth و connection من الـ server طول ما هو بيترفع
// - الـ disk بتاع instance واحد: الـ instance التاني مش شايف الـ file، والـ deploy بيمسحه
// - الاسم من الـ user ← path traversal، والنوع ما اتشافش ← HTML متخبّي على إنه صورة
// - مفيش حد للحجم، والـ processing جُوّه الـ request

// storage.js: object storage صغير زي S3، في الـ memory. ما تعدّلش فيه.
// - HTTP: PUT و GET على /bucket/key بـ presigned URL بس، وبيتأكد من الـ signature والوقت والـ method والـ content-type والحجم
// - وللـ server نفسه (زي الـ SDK بالـ credentials): head و get و put و delete و list
import { createServer } from "node:http";
import { createHmac, createHash, timingSafeEqual } from "node:crypto";

export async function startStorage({ secret, now = Date.now } = {}) {
  const objects = new Map(); // "bucket/key" -> { body, contentType, size, etag }
  const stats = { puts: 0, gets: 0, rejected: 0 };
  const save = (bucket, key, body, contentType) => {
    const etag = createHash("md5").update(body).digest("hex");
    objects.set(`${bucket}/${key}`, { body, contentType, size: body.length, etag });
    return etag;
  };
  const deny = (res, status, code) => {
    stats.rejected++;
    res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify({ error: code }));
  };

  const server = createServer(async (req, res) => {
    const url = new URL(req.url, "http://x");
    const [, bucket, ...rest] = url.pathname.split("/");
    const key = decodeURIComponent(rest.join("/"));
    const q = Object.fromEntries(url.searchParams);
    const toSign = [q["X-Method"], bucket, key, q["X-Expires"], q["X-Content-Type"] ?? "", q["X-Max-Bytes"] ?? ""].join("\n");
    const want = createHmac("sha256", secret).update(toSign).digest();
    const got = Buffer.from(q["X-Signature"] ?? "", "hex");
    if (got.length !== want.length || !timingSafeEqual(got, want)) return deny(res, 403, "SignatureDoesNotMatch");
    if (Number(q["X-Expires"]) <= now()) return deny(res, 403, "RequestExpired");
    if (q["X-Method"] !== req.method) return deny(res, 403, "MethodNotAllowed");

    if (req.method === "PUT") {
      const ct = req.headers["content-type"] ?? "";
      if (q["X-Content-Type"] && ct !== q["X-Content-Type"]) return deny(res, 403, "ContentTypeMismatch");
      const max = q["X-Max-Bytes"] ? Number(q["X-Max-Bytes"]) : Infinity;
      const chunks = [];
      let size = 0;
      for await (const c of req) {
        size += c.length;
        if (size > max) return deny(res, 413, "EntityTooLarge");
        chunks.push(c);
      }
      stats.puts++;
      const etag = save(bucket, key, Buffer.concat(chunks), ct);
      return res.writeHead(200, { etag }).end();
    }
    if (req.method === "GET") {
      const o = objects.get(`${bucket}/${key}`);
      if (!o) return deny(res, 404, "NoSuchKey");
      stats.gets++;
      return res.writeHead(200, { "content-type": o.contentType, "content-length": o.size, etag: o.etag }).end(o.body);
    }
    deny(res, 405, "MethodNotAllowed");
  });
  await new Promise((r) => server.listen(0, "127.0.0.1", r));

  return {
    url: `http://127.0.0.1:${server.address().port}`,
    stats,
    async head(bucket, key) {
      const o = objects.get(`${bucket}/${key}`);
      return o ? { size: o.size, contentType: o.contentTyp
…