@forgedevstack/harbor 1.0.0 → 1.5.0

package/dist/upload-DUjQiuq7.mjs

@@ -0,0 +1,619 @@
+import { c as P } from "./logger-CZn7QxCl.mjs";
+import { H as L } from "./http.const-BKHG1Lsj.mjs";
+import { existsSync as F, mkdirSync as I, createWriteStream as A } from "fs";
+import { extname as z, join as G } from "path";
+const E = P("rate-limit");
+class K {
+  hits = /* @__PURE__ */ new Map();
+  windowMs;
+  constructor(e) {
+    this.windowMs = e, setInterval(() => this.cleanup(), e);
+  }
+  async increment(e) {
+    const t = Date.now(), s = this.hits.get(e);
+    if (s && s.resetTime > t)
+      return s.count++, s;
+    const i = {
+      count: 1,
+      resetTime: t + this.windowMs
+    };
+    return this.hits.set(e, i), i;
+  }
+  async decrement(e) {
+    const t = this.hits.get(e);
+    t && t.count > 0 && t.count--;
+  }
+  async resetKey(e) {
+    this.hits.delete(e);
+  }
+  async get(e) {
+    return this.hits.get(e) || null;
+  }
+  cleanup() {
+    const e = Date.now();
+    for (const [t, s] of this.hits.entries())
+      s.resetTime <= e && this.hits.delete(t);
+  }
+}
+class ce {
+  client;
+  windowMs;
+  prefix;
+  constructor(e, t, s = "rl:") {
+    this.client = e, this.windowMs = t, this.prefix = s;
+  }
+  async increment(e) {
+    const t = this.prefix + e, s = this.client.multi();
+    s.incr(t), s.pttl(t);
+    const i = await s.exec(), r = i[0][1];
+    let a = i[1][1];
+    return a === -1 && (await this.client.pexpire(t, this.windowMs), a = this.windowMs), {
+      count: r,
+      resetTime: Date.now() + a
+    };
+  }
+  async decrement(e) {
+    await this.client.decr(this.prefix + e);
+  }
+  async resetKey(e) {
+    await this.client.del(this.prefix + e);
+  }
+  async get(e) {
+    const t = this.prefix + e, [s, i] = await Promise.all([
+      this.client.get(t),
+      this.client.pttl(t)
+    ]);
+    return s === null ? null : {
+      count: parseInt(s, 10),
+      resetTime: Date.now() + Math.max(i, 0)
+    };
+  }
+}
+function le(n = {}) {
+  const {
+    windowMs: e = 15 * 60 * 1e3,
+    // 15 minutes
+    max: t = 100,
+    message: s = "Too many requests, please try again later.",
+    statusCode: i = L.TOO_MANY_REQUESTS,
+    keyGenerator: r = (l) => l.ip || l.connection?.remoteAddress || "unknown",
+    skip: a = () => !1,
+    onLimitReached: c,
+    headers: u = !0,
+    store: h = new K(e)
+  } = n;
+  return async (l, f, m) => {
+    if (a(l))
+      return m();
+    const p = r(l);
+    try {
+      const o = await h.increment(p), g = Math.max(0, t - o.count);
+      if (u && (f.setHeader("X-RateLimit-Limit", t), f.setHeader("X-RateLimit-Remaining", g), f.setHeader("X-RateLimit-Reset", Math.ceil(o.resetTime / 1e3))), o.count > t)
+        return E.warn(`Rate limit exceeded for ${p}`), c?.(l, f), u && f.setHeader("Retry-After", Math.ceil((o.resetTime - Date.now()) / 1e3)), f.status(i).json({
+          success: !1,
+          error: {
+            message: s,
+            retryAfter: Math.ceil((o.resetTime - Date.now()) / 1e3)
+          }
+        });
+      m();
+    } catch (o) {
+      const g = o;
+      E.error(`Rate limit error: ${g.message}`), m(g);
+    }
+  };
+}
+function ue(n = {}) {
+  const {
+    windowMs: e = 15 * 60 * 1e3,
+    max: t = 100,
+    message: s = "Too many requests, please try again later.",
+    statusCode: i = L.TOO_MANY_REQUESTS,
+    keyGenerator: r = (h) => h.ip || "unknown",
+    skip: a = () => !1,
+    headers: c = !0
+  } = n, u = /* @__PURE__ */ new Map();
+  return (h, l, f) => {
+    if (a(h))
+      return f();
+    const m = r(h), p = Date.now(), o = p - e;
+    let g = u.get(m) || [];
+    g = g.filter((M) => M > o), g.push(p), u.set(m, g);
+    const w = Math.max(0, t - g.length);
+    if (c && (l.setHeader("X-RateLimit-Limit", t), l.setHeader("X-RateLimit-Remaining", w), l.setHeader("X-RateLimit-Reset", Math.ceil((p + e) / 1e3))), g.length > t)
+      return E.warn(`Sliding window rate limit exceeded for ${m}`), l.status(i).json({
+        success: !1,
+        error: {
+          message: s,
+          retryAfter: Math.ceil(e / 1e3)
+        }
+      });
+    f();
+  };
+}
+const X = Date.now();
+function he(n = {}) {
+  const {
+    checks: e = [],
+    timeout: t = 5e3,
+    onHealthCheck: s
+  } = n;
+  return async (i, r) => {
+    const a = [];
+    let c = "healthy";
+    const u = e.map(async (m) => {
+      const p = Date.now();
+      try {
+        const o = await Promise.race([
+          m.check(),
+          new Promise(
+            (g, w) => setTimeout(() => w(new Error("Timeout")), m.timeout || t)
+          )
+        ]);
+        return o.latency = Date.now() - p, o;
+      } catch (o) {
+        return {
+          name: m.name,
+          status: "unhealthy",
+          latency: Date.now() - p,
+          message: o instanceof Error ? o.message : "Unknown error"
+        };
+      }
+    }), h = await Promise.all(u);
+    a.push(...h);
+    for (const m of a)
+      if (m.status === "unhealthy")
+        if (e.find((o) => o.name === m.name)?.critical !== !1) {
+          c = "unhealthy";
+          break;
+        } else
+          c = "degraded";
+      else m.status === "degraded" && c === "healthy" && (c = "degraded");
+    const l = {
+      status: c,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Math.floor((Date.now() - X) / 1e3),
+      checks: a
+    };
+    s?.(a);
+    const f = c === "healthy" || c === "degraded" ? 200 : 503;
+    r.status(f).json(l);
+  };
+}
+function me(n, e = "mongodb") {
+  return {
+    name: e,
+    critical: !0,
+    check: async () => {
+      try {
+        return n.readyState === 1 ? (await n.db?.admin().ping(), { name: e, status: "healthy", message: "Connected" }) : { name: e, status: "unhealthy", message: "Not connected" };
+      } catch (t) {
+        return {
+          name: e,
+          status: "unhealthy",
+          message: t instanceof Error ? t.message : "Connection failed"
+        };
+      }
+    }
+  };
+}
+function fe(n, e = "redis") {
+  return {
+    name: e,
+    critical: !1,
+    check: async () => {
+      try {
+        return await n.ping() === "PONG" ? { name: e, status: "healthy", message: "Connected" } : { name: e, status: "unhealthy", message: "Invalid response" };
+      } catch (t) {
+        return {
+          name: e,
+          status: "unhealthy",
+          message: t instanceof Error ? t.message : "Connection failed"
+        };
+      }
+    }
+  };
+}
+function de(n = 512, e = "memory") {
+  return {
+    name: e,
+    critical: !1,
+    check: async () => {
+      const t = process.memoryUsage(), s = Math.round(t.heapUsed / 1024 / 1024), i = Math.round(t.heapTotal / 1024 / 1024), r = Math.round(t.rss / 1024 / 1024), a = s > n ? "degraded" : "healthy";
+      return {
+        name: e,
+        status: a,
+        message: `Heap: ${s}MB / ${i}MB`,
+        details: {
+          heapUsed: s,
+          heapTotal: i,
+          rss: r,
+          external: Math.round(t.external / 1024 / 1024)
+        }
+      };
+    }
+  };
+}
+function pe(n = "/", e = 1, t = "disk") {
+  return {
+    name: t,
+    critical: !1,
+    check: async () => ({
+      name: t,
+      status: "healthy",
+      message: "Disk check requires check-disk-space package"
+    })
+  };
+}
+function ge(n, e, t = !1) {
+  return {
+    name: n,
+    critical: t,
+    check: async () => {
+      try {
+        const s = await e();
+        return typeof s == "boolean" ? {
+          name: n,
+          status: s ? "healthy" : "unhealthy"
+        } : {
+          name: n,
+          status: s.healthy ? "healthy" : "unhealthy",
+          message: s.message
+        };
+      } catch (s) {
+        return {
+          name: n,
+          status: "unhealthy",
+          message: s instanceof Error ? s.message : "Check failed"
+        };
+      }
+    }
+  };
+}
+class Q {
+  metrics = /* @__PURE__ */ new Map();
+  prefix;
+  defaultLabels;
+  constructor(e = "harbor_", t = {}) {
+    this.prefix = e, this.defaultLabels = t;
+  }
+  // Counter - only goes up
+  counter(e, t) {
+    const s = this.prefix + e;
+    return this.metrics.has(s) || this.metrics.set(s, {
+      name: s,
+      help: t,
+      type: "counter",
+      values: /* @__PURE__ */ new Map()
+    }), new Y(this.metrics.get(s), this.defaultLabels);
+  }
+  // Gauge - can go up and down
+  gauge(e, t) {
+    const s = this.prefix + e;
+    return this.metrics.has(s) || this.metrics.set(s, {
+      name: s,
+      help: t,
+      type: "gauge",
+      values: /* @__PURE__ */ new Map()
+    }), new W(this.metrics.get(s), this.defaultLabels);
+  }
+  // Histogram - observations in buckets
+  histogram(e, t, s = [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]) {
+    const i = this.prefix + e;
+    return this.metrics.has(i) || this.metrics.set(i, {
+      name: i,
+      help: t,
+      type: "histogram",
+      values: /* @__PURE__ */ new Map(),
+      buckets: s
+    }), new J(this.metrics.get(i), this.defaultLabels);
+  }
+  // Get all metrics in Prometheus format
+  getMetrics() {
+    const e = [];
+    for (const t of this.metrics.values())
+      if (e.push(`# HELP ${t.name} ${t.help}`), e.push(`# TYPE ${t.name} ${t.type}`), t.type === "histogram") {
+        const s = /* @__PURE__ */ new Map();
+        for (const [i, r] of t.values.entries()) {
+          const [a, c] = i.split("|");
+          s.has(a) || s.set(a, { sum: 0, count: 0, buckets: /* @__PURE__ */ new Map() });
+          const u = s.get(a);
+          c === "sum" ? u.sum = r : c === "count" ? u.count = r : u.buckets.set(parseFloat(c), r);
+        }
+        for (const [i, r] of s.entries()) {
+          const a = i ? `{${i}}` : "";
+          let c = 0;
+          for (const h of t.buckets || []) {
+            c += r.buckets.get(h) || 0;
+            const l = i ? `{${i},le="${h}"}` : `{le="${h}"}`;
+            e.push(`${t.name}_bucket${l} ${c}`);
+          }
+          const u = i ? `{${i},le="+Inf"}` : '{le="+Inf"}';
+          e.push(`${t.name}_bucket${u} ${r.count}`), e.push(`${t.name}_sum${a} ${r.sum}`), e.push(`${t.name}_count${a} ${r.count}`);
+        }
+      } else
+        for (const [s, i] of t.values.entries()) {
+          const r = s ? `{${s}}` : "";
+          e.push(`${t.name}${r} ${i}`);
+        }
+    return e.join(`
+`);
+  }
+  reset() {
+    for (const e of this.metrics.values())
+      e.values.clear();
+  }
+}
+class Y {
+  metric;
+  defaultLabels;
+  constructor(e, t) {
+    this.metric = e, this.defaultLabels = t;
+  }
+  inc(e = {}, t = 1) {
+    const s = this.labelsToString({ ...this.defaultLabels, ...e }), i = this.metric.values.get(s) || 0;
+    this.metric.values.set(s, i + t);
+  }
+  labelsToString(e) {
+    return Object.entries(e).map(([t, s]) => `${t}="${s}"`).join(",");
+  }
+}
+class W {
+  metric;
+  defaultLabels;
+  constructor(e, t) {
+    this.metric = e, this.defaultLabels = t;
+  }
+  set(e, t = {}) {
+    const s = this.labelsToString({ ...this.defaultLabels, ...t });
+    this.metric.values.set(s, e);
+  }
+  inc(e = {}, t = 1) {
+    const s = this.labelsToString({ ...this.defaultLabels, ...e }), i = this.metric.values.get(s) || 0;
+    this.metric.values.set(s, i + t);
+  }
+  dec(e = {}, t = 1) {
+    const s = this.labelsToString({ ...this.defaultLabels, ...e }), i = this.metric.values.get(s) || 0;
+    this.metric.values.set(s, i - t);
+  }
+  labelsToString(e) {
+    return Object.entries(e).map(([t, s]) => `${t}="${s}"`).join(",");
+  }
+}
+class J {
+  metric;
+  defaultLabels;
+  constructor(e, t) {
+    this.metric = e, this.defaultLabels = t;
+  }
+  observe(e, t = {}) {
+    const s = this.labelsToString({ ...this.defaultLabels, ...t }), i = `${s}|sum`, r = this.metric.values.get(i) || 0;
+    this.metric.values.set(i, r + e);
+    const a = `${s}|count`, c = this.metric.values.get(a) || 0;
+    this.metric.values.set(a, c + 1);
+    for (const u of this.metric.buckets || [])
+      if (e <= u) {
+        const h = `${s}|${u}`, l = this.metric.values.get(h) || 0;
+        this.metric.values.set(h, l + 1);
+      }
+  }
+  startTimer(e = {}) {
+    const t = process.hrtime.bigint();
+    return () => {
+      const s = process.hrtime.bigint(), i = Number(s - t) / 1e9;
+      this.observe(i, e);
+    };
+  }
+  labelsToString(e) {
+    return Object.entries(e).map(([t, s]) => `${t}="${s}"`).join(",");
+  }
+}
+const $ = new Q(), V = $.counter(
+  "http_requests_total",
+  "Total number of HTTP requests"
+), Z = $.histogram(
+  "http_request_duration_seconds",
+  "HTTP request duration in seconds"
+), q = $.histogram(
+  "http_request_size_bytes",
+  "HTTP request size in bytes",
+  [100, 1e3, 1e4, 1e5, 1e6]
+), ee = $.histogram(
+  "http_response_size_bytes",
+  "HTTP response size in bytes",
+  [100, 1e3, 1e4, 1e5, 1e6]
+);
+function ye() {
+  return (n, e, t) => {
+    const s = Z.startTimer({
+      method: n.method,
+      path: n.route?.path || n.path
+    }), i = parseInt(n.get("content-length") || "0", 10);
+    i > 0 && q.observe(i, { method: n.method }), e.on("finish", () => {
+      s(), V.inc({
+        method: n.method,
+        path: n.route?.path || n.path,
+        status: e.statusCode.toString()
+      });
+      const r = parseInt(e.get("content-length") || "0", 10);
+      r > 0 && ee.observe(r, {
+        method: n.method,
+        status: e.statusCode.toString()
+      });
+    }), t();
+  };
+}
+function we(n = $) {
+  return (e, t) => {
+    t.set("Content-Type", "text/plain; version=0.0.4; charset=utf-8"), t.send(n.getMetrics());
+  };
+}
+const R = P("upload");
+function te(n) {
+  const e = n.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+  return e ? e[1] || e[2] : null;
+}
+function se(n, e) {
+  const t = [], s = Buffer.from(`--${e}`), i = Buffer.from(`--${e}--`);
+  let r = n.indexOf(s) + s.length + 2;
+  for (; r < n.length; ) {
+    const a = n.indexOf(s, r);
+    if (a === -1) break;
+    const c = n.slice(r, a - 2), u = c.indexOf(`\r
+\r
+`);
+    if (u !== -1) {
+      const h = c.slice(0, u).toString(), l = c.slice(u + 4), f = h.match(/Content-Disposition:\s*form-data;\s*name="([^"]+)"(?:;\s*filename="([^"]+)")?/i), m = h.match(/Content-Type:\s*([^\r\n]+)/i), p = h.match(/Content-Transfer-Encoding:\s*([^\r\n]+)/i);
+      f && t.push({
+        fieldName: f[1],
+        filename: f[2],
+        mimeType: m ? m[1] : "application/octet-stream",
+        encoding: p ? p[1] : "7bit",
+        data: [l]
+      });
+    }
+    if (r = a + s.length + 2, n.slice(a, a + i.length).equals(i))
+      break;
+  }
+  return t;
+}
+function ne(n) {
+  const e = z(n), t = Date.now(), s = Math.random().toString(36).substring(2, 8);
+  return `${t}-${s}${e}`;
+}
+function be(n = {}) {
+  const {
+    dest: e = "./uploads",
+    limits: t = {},
+    allowedMimeTypes: s,
+    allowedExtensions: i,
+    filename: r = ne,
+    storage: a = "disk",
+    onFileBegin: c,
+    onFileEnd: u,
+    onError: h
+  } = n, {
+    fileSize: l = 10 * 1024 * 1024,
+    // 10MB default
+    files: f = 10,
+    fields: m = 100,
+    fieldSize: p = 1024 * 1024
+    // 1MB default
+  } = t;
+  return a === "disk" && !F(e) && I(e, { recursive: !0 }), async (o, g, w) => {
+    const M = o.get("content-type") || "";
+    if (!M.includes("multipart/form-data"))
+      return w();
+    const _ = te(M);
+    if (!_)
+      return g.status(L.BAD_REQUEST).json({
+        success: !1,
+        error: { message: "Missing boundary in content-type" }
+      });
+    const C = [];
+    let H = 0;
+    o.on("data", (y) => {
+      if (H += y.length, H > l * f) {
+        o.destroy();
+        return;
+      }
+      C.push(y);
+    }), o.on("end", async () => {
+      try {
+        const y = Buffer.concat(C), T = se(y, _), S = [], D = {};
+        let j = 0, B = 0;
+        for (const d of T)
+          if (d.filename) {
+            if (j >= f)
+              throw new Error(`Too many files. Maximum: ${f}`);
+            const b = Buffer.concat(d.data);
+            if (b.length > l)
+              throw new Error(`File too large: ${d.filename}. Maximum: ${l} bytes`);
+            if (s && !s.includes(d.mimeType))
+              throw new Error(`Invalid file type: ${d.mimeType}`);
+            if (i) {
+              const v = z(d.filename).toLowerCase().slice(1);
+              if (!i.includes(v))
+                throw new Error(`Invalid file extension: ${v}`);
+            }
+            const k = {
+              fieldName: d.fieldName,
+              originalName: d.filename,
+              mimeType: d.mimeType,
+              size: b.length,
+              encoding: d.encoding
+            };
+            if (c?.(d.fieldName, k), a === "disk") {
+              const v = r(d.filename, d.mimeType), N = G(e, v);
+              await new Promise((O, U) => {
+                const x = A(N);
+                x.write(b), x.end(), x.on("finish", O), x.on("error", U);
+              }), k.path = N;
+            } else
+              k.buffer = b;
+            u?.(d.fieldName, k), S.push(k), j++;
+          } else {
+            if (B >= m)
+              throw new Error(`Too many fields. Maximum: ${m}`);
+            const b = Buffer.concat(d.data).toString();
+            if (b.length > p)
+              throw new Error(`Field too large: ${d.fieldName}`);
+            D[d.fieldName] = b, B++;
+          }
+        o.files = S, o.file = S[0], o.body = { ...o.body, ...D }, R.debug(`Uploaded ${S.length} files`), w();
+      } catch (y) {
+        const T = y;
+        R.error(`Upload error: ${T.message}`), h?.(T), g.status(L.BAD_REQUEST).json({
+          success: !1,
+          error: { message: T.message }
+        });
+      }
+    }), o.on("error", (y) => {
+      R.error("Request error:", y), h?.(y), w(y);
+    });
+  };
+}
+function Te(n, e) {
+  return e.includes(n.mimeType);
+}
+function ke(n) {
+  return {
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/csv": "csv",
+    "application/zip": "zip",
+    "application/x-rar-compressed": "rar"
+  }[n] || "bin";
+}
+export {
+  Y as C,
+  W as G,
+  J as H,
+  Q as M,
+  ce as R,
+  fe as a,
+  de as b,
+  ge as c,
+  pe as d,
+  $ as e,
+  V as f,
+  Z as g,
+  he as h,
+  q as i,
+  ee as j,
+  ye as k,
+  we as l,
+  me as m,
+  ke as n,
+  le as r,
+  ue as s,
+  be as u,
+  Te as v
+};
+//# sourceMappingURL=upload-DUjQiuq7.mjs.map