Skip to content

Releases

VaultBox API v2.5.0: Reliability, Security, Performance and Folder APIs

Choose a tag to compare

@github-actions github-actions released this 12 Nov 02:16
3761f69

VaultBox v2.5.0

Version: v2.5.0. Production deployment and source commit must be verified independently via live health and the Render dashboard; a published tag alone does not establish durable file storage. v2.3.0 and v2.4.0 were implementation groupings and were not separately tagged.

Cumulative changes since v2.2.0

  • v2.3 reliability: S3-compatible shared adapter and checksum-safe dry-run migration tooling (#53); durable physical-deletion outbox (#54); bounded, crash-recoverable temporary-byte admission and orphan reconciliation (#55); cancel-safe storage streams (#56); retention and pruning of terminal session metadata (#57).
  • v2.4 scalability and security: real HTTP/database load profiles (#58); ordered, fenced, leased cleanup workers and measured terminal-session indexing (#59); keyset/summarized 10,000-part progress (#60); independent-process, SIGKILL, BOLA, fuzz, audit and secret scanning gates (#61); exact-SHA/manual release approval and pinned migration stage (#62); profiled PostgreSQL count-free optional pages (#63).
  • Developer tooling: replace vulnerable nodemon/minimatch with native Node 24 watch mode.
  • v2.5 API: secure folder-assigned one-shot/resumable uploads and moves (#64); reserved quota and actually allocatable bytes reported to clients (#65).

All existing v2.2.0 security, account, rate-limit, audit and quota contracts remain mandatory.

Render Free compatibility

The existing free Render service can deploy the complete v2.5.0 code using npm install --omit=dev, Render-only postinstall Prisma generation/verification and opt-in VAULTBOX_RENDER_FREE_MODE=1 migration before npm start. The version-specific API and security features are unchanged. The Free service has one instance, no pre-deploy command and no persistent disk; it loses local file bytes on restarts, redeploys and idle spin-down. Database metadata may remain even if bytes disappear. This deployment is an ephemeral-file demo, not verified durable user storage. See deployment guide.

Compatibility

  • GET /files, GET /folders, admin pagination preserve original count responses unless the caller requests includeTotal=false.
  • Upload progress preserves the legacy response by default; bounded summary/page modes are opt-in.
  • Uploads can specify an owned folder; cross-user folder/file identifiers remain rejected.
  • One-shot writes may now return HTTP 507 if temporary/disk capacity cannot safely admit them; declared and headerless limits are enforced.
  • Run additive Prisma migrations before starting the new API and execute Prisma generation at build time. The runtime startup no longer downloads executables or runs database migration.

CodeRabbit review remediations

The review corrective batch addresses temporary ASSEMBLY concurrency-slot deadlocks, S3 orphan-claim fencing and deferred remote verification, stable legacy File ID + stored-name hashing for optional S3 migration (with dry-run File ID reporting), deterministic conditional-write readiness tests, accurate ranged-download throughput accounting, and documentation/.env examples. S3 remains optional and unconfigured, and production-specific S3 acceptance remains UNVERIFIED. Added the CodeQL flagged fixed-field file sorting, production-safe profiling opt-in, release-heading validation, credential scanner hardening, guaranteed raw CI-log deletion and a concurrent stored-name index; operational index-window and code-scanning ruleset requirements remain documented in the deployment guide.

Explicit unverified provider exception

No production S3 provider is configured or planned for this review. The optional S3 adapter was tested only against a disposable emulator; production IAM, checksum migration/cutover, S3 multipart concurrency guarantees and real multi-host durability remain UNVERIFIED. Continue single-instance local storage only with a genuinely persistent, separately backed-up volume; Render's ephemeral disk must never be described as durable object storage. This is a deliberate review-scope exception, not a completed #53 provider acceptance.

Performance evidence

The exact PR-head CI benchmark results (Node 24.22.2, PostgreSQL 16.15, Redis 7, local storage) include 26,711.43 in-process health requests/s with 0 errors, 37.704 MiB/s one-shot uploads at concurrency 32, and 8,000-file count-free pagination p50 0.225 ms, compared with 1.182 ms when obtaining the exact count. See complete scores, p95/p99, raw artifact and replication commands. These are not public production benchmarks. Actual historical v1.0.0–v2.2.0 checkout scores (health/system/plans), including the restored legacy v1 runner, and current v2.5.0 capability measurements are documented with reproducible evidence in the full benchmark report.

Release verification evidence and operator acceptance

  • Verify complete local Node 24.22.2, PostgreSQL 16, Redis 7, lint, audit, integration, fault, performance and rollback/forward compatibility evidence on the exact final commit.
  • Run CodeQL v4 security-extended analysis on the exact reviewed commit; this is configured in the existing single CI verify runner and skipped while the PR is draft (CodeQL cannot be accurately claimed as locally executed). Complete CodeRabbit/human review and reconcile every linked issue's acceptance criteria except the explicitly documented provider exception.
  • Configure Render's separate build-time Prisma generate and approved migration stage before any merge (current production uses npm start migrations).
  • Configure required human reviewers for the GitHub vaultbox-release environment, disable unintended automatic deployment for this migration, take backups, rehearse rollback and live smoke tests.
  • After explicit approval: merge, run protected-main CI at the exact SHA, intentionally dispatch the release gate, verify production deployment and record evidence in epic #66 and tracker #68. No automated publishing from a draft PR.

Full protected-main CI verification

The consolidated PR workflow on its exact head runs Node 24.22.2, PostgreSQL 16, Redis 7, locked npm ci, moderate-severity-or-higher npm dependency audit, Prisma schema validation and migrations, strict TypeScript checking of generated data-model contracts plus checked security JavaScript, a real Prisma/runtime module build smoke, ESLint, syntax checking, static secret scanning, the full integration suite with coverage, explicit independent-process/BOLA/failure corpus, 10k-session cleanup stress, three benchmark suites and CodeQL security-extended. One runner handles verification and CodeQL; redundant SHA runs are cancelled. The final green CI run, review threads and any operational exceptions must be inspected before merge approval.

The complete CI workflow is part of this release. A one-time GitHub Actions workflow can publish only v2.5.0, after the exact merged-main SHA passes CI and the public Render health endpoints report v2.5.0 with PostgreSQL/Redis operational. The manual exact-SHA release gate remains available for future releases. The user explicitly selected Render Free ephemeral-storage deployment, not a durable S3 or persistent-disk provider.

Historical version notes

v1.0.0 · v2.0.0 · v2.1.0 · v2.1.1 · v2.2.0 · v2.3 grouping · v2.4 grouping. All original core APIs remain, subject to documented security and operational compatibility changes.

VaultBox API v2.2.0 — Authorization, Concurrency and Abuse-Resistance Release

Choose a tag to compare

@github-actions github-actions released this 05 Nov 15:47
f6f8b8a

VaultBox API v2.2.0 — Authorization, Concurrency and Abuse-Resistance Release

Phase 1 of the v2.5.0 program (issues #39–#52). Security and correctness hardening of the existing API: no endpoint was removed or renamed and no stored data is rewritten. Seven additive migrations. Several behaviors are stricter than v2.1.x (listed below) — read "Behavior changes" before upgrading clients.

What changed

Authorization and account state

  • Cross-tenant regression matrix (#50). Two-tenant tests prove that another user's files, folders, upload sessions/parts and download sessions are indistinguishable from unknown IDs, that admin routes reject ordinary accounts and forged tokens, and that suspended/deleted accounts are blocked.
  • Plan entitlements (#39). Selecting a paid plan requires a server-side entitlement granted by an HMAC-signed, idempotent POST /billing/webhook event; the entitlement check, quota fit and plan switch are one statement under a per-user row lock.
  • Immediate revocation (#44). Authentication reads status, role and a per-account session version from PostgreSQL on every request (the 10-second Redis cache is gone). Suspension, deletion, demotion and session revocation take effect on the next request on every instance, independent of Redis.
  • Commit-time account fence (#45). Every transaction that creates usage re-checks the owner is ACTIVE under the owner's row lock, so a request authenticated before a suspension cannot finish creating data afterwards.

Upload and quota integrity

  • Completion vs expiry (#40) uses a renewable, fenced lease; part writes (#41) are fenced against completion/abort/expiry; one-shot reservations (#42) are durable and recovered after worker crashes (tested with SIGKILL injection). Lock order is always user, then upload session.
  • Idempotency (#43) for POST /folders is actor-scoped, durable in PostgreSQL and fair per account.

Abuse resistance and operations

  • Rate limits (#46) for login, registration and download-token issuance stay global across replicas through a PostgreSQL fallback and fail closed (503 + Retry-After) when neither Redis nor PostgreSQL can answer; login also has per-account and per-address caps.
  • Client IP (#47) comes only from an explicit trusted-proxy policy (TRUST_PROXY), not from a client-controlled X-Forwarded-For; new admin GET /admin/network-diagnostics shows how an address was derived.
  • Audit (#48). Audit rows are written in the same transaction as the change they describe (no more committed-change/500 ambiguity); details of new rows contain identifiers and sizes, never file names or e-mail addresses. Existing audit rows are not rewritten and may still contain file names or e-mail addresses.
  • Password verification (#49). Uniform login failures (no account enumeration by response), and one bcrypt comparison per attempt at cost 12 in a bounded worker-thread pool (503 + Retry-After when saturated instead of stalling the API). Timing is uniform for accounts whose stored hash is cost 12 (the dummy hash used for unknown e-mails is cost 12); an account with an older, lower-cost hash still verifies faster, so such accounts should be re-seeded or have their passwords reset (the hash format is unchanged and hashes are not upgraded on login).
  • Download sessions (#51, #52). Revocable (DELETE /download-sessions/:id, DELETE /files/:id/download-sessions, and revoked by "log out everywhere"); revoked/expired sessions cannot begin transfers (410) while open streams finish; the bearer value never reaches logs, audit rows or metrics; every response, including refusals, is no-store with Referrer-Policy: no-referrer. HEAD no longer starts a session, and refusals that used to surface as 500 (missing bytes, unsatisfiable range) are proper 404/416 JSON errors.

Behavior changes (client and operator impact)

Change Impact
Paid plans need an entitlement POST plan selection for paid plans is refused without one. Set PLAN_SWITCH_MODE=demo to keep the old self-service behavior explicitly (e.g. a public demo).
Malformed Idempotency-Key 400 (was silently truncated). Valid keys: 1–128 chars of A-Za-z0-9._:~-.
Older tokens after reactivation/demotion 401, sign in again. Tokens issued before v2.2.0 stay valid until the account is next revoked.
In-flight writes by a suspended account 403 ACCOUNT_NOT_ACTIVE; bytes removed, reservation returned.
Busy POST /folders for an account 429 IDEMPOTENCY_BUSY (identical in-flight request is still 409).
Login failures One 401 for unknown e-mail, wrong password, and suspended/deleted account with a wrong password; 403 only after a correct password. New caps (30 per account / 15 min, 120 per address / 5 min); 503 when rate-limit storage is unavailable.
Download first use Only a GET that opened its stream sets usedAt / emits DOWNLOAD_SESSION_STARTED.
Download session creation Response includes the non-secret session id; a request authenticated before a revocation gets 401 SESSION_REVOKED.
npm test Runs files serially (shared database); about 40 s.

Operator actions before/after deploy

  1. TRUST_PROXY (important). Unset in production means "private-network proxies". After deploying, call GET /admin/network-diagnostics as an admin: if clientIp is a proxy address, add the proxy's range to TRUST_PROXY, otherwise all clients share one rate-limit bucket (including the 120 / 5 min login cap).
  2. Decide PLAN_SWITCH_MODE (demo for the public demo) and set BILLING_WEBHOOK_SECRET if you will grant entitlements (the webhook answers 503 while it is unset).
  3. Optionally tune PASSWORD_HASH_CONCURRENCY / _QUEUE / _WAIT_MS (defaults 2 / 64 / 5000) and IDEMPOTENCY_*.
  4. Configure your edge/CDN/APM to mask the path after /download/ (see docs/DEPLOYMENT.md, "Download token lifecycle and URL exposure").
  5. Runtime stays Node.js 24.22.2 (.node-version); keep any NODE_VERSION override off.

Migrations (all additive; run automatically by npm start)

20261104210000_plan_entitlements, 20261104220000_upload_completion_lease, 20261104230000_upload_reservations, 20261104240000_idempotency_keys, 20261104250000_user_auth_version, 20261105100000_rate_limit_windows, 20261105200000_download_token_revocation. Tables/columns added only; no existing data is rewritten.

Rollback

Leave the migrations in place: older builds ignore the new tables and columns. Do not roll back to a build with Node.js 24.19.0. Builds before this release lack the entitlement check (paid plans become self-selectable again), the commit-time account fence, the DB-authoritative authentication and download-session revocation (a URL revoked under v2.2.0 works again until its stored expiry, for as long as the older build runs; lowering DOWNLOAD_TOKEN_EXPIRES_MINUTES does not shorten URLs that already exist, see the rollback section of docs/DEPLOYMENT.md); roll back only if you accept that, otherwise fix forward.

Verification

Every change merged with verify green on its exact head and review findings answered on-thread. On main (9645b28): npm test 201/201 on two consecutive runs against real PostgreSQL and Redis (deterministic interleavings, held row locks, SIGKILL crash injection, multi-process workers, per-guard mutation checks), npm audit --audit-level=high clean (two moderate dev-only nodemon → minimatch advisories remain), all 14 migrations apply to a fresh database, benchmark 0 errors. See issue #68 for per-PR evidence.

VaultBox API v2.1.1 — Node.js Security Maintenance Release

Choose a tag to compare

@github-actions github-actions released this 04 Nov 20:24
da3dfec

VaultBox API v2.1.1 — Node.js Security Maintenance Release

Out-of-band patch release (issue #67). No API, behavior, or database schema changes.

Security

  • Node.js runtime 24.19.0 → 24.22.2 (Node.js 24 LTS). Includes the 2026-10-21 security release (24.22.1) covering, among others, CVE-2026-111497 (Brotli), CVE-2026-105482 (DNS resolve* NUL-byte truncation), CVE-2026-105483 / CVE-2026-106069 / CVE-2026-106072 (TLS / IP normalization and validation), CVE-2026-105481 (HTTP agent) and CVE-2026-106074 (crypto random cache). Minimum security-fixed baseline: 24.22.1.
    • Exploitability of each CVE in VaultBox depends on whether the affected API is reachable; no exploitation is asserted.
  • Dependency refresh (lockfile only). npm audit --audit-level=high had begun failing on the v2.1.0 lockfile (advisories for fast-jwt, fastify, @fastify/busboy, fast-uri, brace-expansion). In-range updates were applied with npm audit fix; package.json ranges are unchanged. Two moderate dev-tool-only findings (nodemon → minimatch) remain; the only fix is a breaking downgrade of nodemon and they do not affect the production runtime.

Operational changes

  • CI asserts node --version equals .node-version.
  • The release workflow is no longer hardcoded to v2.1.0: it reads the version from package.json, requires docs/RELEASE_NOTES_vX.Y.Z.md, and runs only after CI succeeded on the exact commit. (Full release hardening remains tracked in #62.)

Upgrade requirements

  • Render: ensure no NODE_VERSION environment override pins an older Node; verify the effective version after deploy.
  • No migrations.

Rollback

No data rollback is needed. Do not return to Node 24.19.0; roll back to a previous commit with the .node-version pin kept at 24.22.2 or later.

VaultBox API v2.1.0 — Resumable Upload & Efficiency Release

Choose a tag to compare

@github-actions github-actions released this 09 Sep 05:35
1734d5a

VaultBox API v2.1.0 — Resumable Upload & Efficiency Release

VaultBox API v2.1.0 turns the v2 transfer foundation into a bidirectional resumable transfer system and completes a repository-wide efficiency pass across database access, Redis coordination, filesystem I/O, quota accounting, pagination, search, and deployment safety.

The provider architecture remains unchanged: Render + Neon PostgreSQL + Upstash Redis.

Headline feature: durable resumable uploads

VaultBox now supports interruption-safe, chunked uploads in addition to the resumable HTTP range downloads introduced in v2.0.0.

The resumable upload lifecycle is:

  1. POST /upload-sessions creates a durable upload session and atomically reserves the expected file size against the user's current plan.
  2. PUT /upload-sessions/:id/parts/:partNumber streams one exact, bounded part using Content-Range and optional x-chunk-sha256 verification.
  3. GET /upload-sessions/:id reports uploaded and missing parts so clients resume only the data that is still absent.
  4. POST /upload-sessions/:id/complete atomically claims completion, streams parts into final storage in deterministic order, verifies final size and optional SHA-256, creates one File, and converts reserved bytes into committed storageUsed exactly once.
  5. DELETE /upload-sessions/:id aborts an unfinished upload, deletes temporary part bytes, and releases the reservation.

Upload session and part metadata lives in PostgreSQL, not Redis, so restart recovery, ownership checks, idempotency, and quota state remain durable. Temporary bytes stay behind the storage-adapter boundary so a future multipart object-storage implementation can replace local part files without redesigning the public protocol.

Concurrency and integrity guarantees

  • Upload ownership is enforced in every session operation.
  • Part numbers are unique per session.
  • Exact byte geometry prevents overlapping or duplicated ranges.
  • Replaying the same part is idempotent when the checksum matches.
  • Conflicting retries are rejected instead of silently replacing bytes.
  • Whole files are never concatenated in Node memory.
  • Concurrent completion requests can create at most one final file and charge quota once.
  • Expired or aborted sessions release reserved capacity.
  • Cleanup reconciles stale sessions left by process interruption.

One-shot uploads now reject known quota failures before file I/O

The existing POST /files/upload path remains compatible.

Clients that know the exact file payload size can send:

x-upload-size: <bytes>

VaultBox atomically reserves that amount before reading the multipart file or opening a storage file. A request that cannot fit the account's current plan returns 413 before full network, hashing, and disk work is wasted.

The declaration is an admission bound only. The streamed byte count remains authoritative:

  • a shorter body returns 422;
  • a body beyond the declaration is bounded and returns 413;
  • parser, pipeline, truncation, mismatch, and database failures release the reservation;
  • successful uploads convert the reservation to storageUsed in the same transaction that creates file metadata.

Clients that omit x-upload-size retain the existing safe final quota-check behavior.

Atomic quota and file lifecycle invariants

The quota path was rewritten around database-enforced state transitions rather than stale application snapshots.

  • Upload admission evaluates the plan that is current when the database statement executes.
  • Active resumable-upload reservations count against plan capacity.
  • Plan downgrades cannot race an upload into an invalid over-limit state.
  • File deletion changes ACTIVE -> DELETED and decrements storage in one ownership-scoped PostgreSQL statement.
  • Duplicate or concurrent deletes cannot decrement storage twice.
  • Successful upload responses reuse UPDATE ... RETURNING instead of issuing another user lookup solely to display storageUsed.

The committed invariant is that admitted upload/plan transitions cannot leave storageUsed + reservedUploadBytes above the current plan limit.

Database and collection efficiency

Cursor pagination

Large file, folder, admin-user, and audit-log collections now support stable cursor pagination using a deterministic (sort value, id) tie-breaker.

Cursor mode fetches limit + 1 and does not issue an exact COUNT(*). Legacy page-number pagination remains for compatibility but is bounded to prevent pathological offsets.

Search and sort indexes

  • PostgreSQL pg_trgm powers indexable substring search for file names and admin user name/email lookup.
  • GIN trigram indexes preserve case-insensitive contains semantics.
  • Composite indexes align with supported file sort modes and cursor access paths.

Admin reporting

GET /admin/storage-report now computes total users, status buckets, and total storage in one PostgreSQL aggregate query instead of separate group/aggregate scans.

Redis and process-memory efficiency

  • Distributed throttle decisions now use one Lua EVAL round trip instead of separate INCR, EXPIRE, and TTL calls.
  • CI includes a real Redis service and proves one Redis command per throttle decision.
  • Process-local Redis fallbacks are bounded, TTL-aware stores rather than unbounded Maps.
  • Dead file-cache invalidations were removed where no matching cache read path existed.

Redis remains an optimization and coordination layer; PostgreSQL remains the source of truth.

Download hot-path efficiency

Parallel/range downloads retain v2.0.0 semantics while reducing repeated control-plane work:

  • already-started download sessions skip pointless usedAt IS NULL updates;
  • concurrent first ranges still emit at most one first-download audit event;
  • GET opens the file directly instead of doing access() followed by a second open;
  • missing or unreadable bytes still map to a controlled not-found response;
  • HEAD stays metadata-only;
  • Range, ETag, and If-Range semantics are unchanged.

Storage lifecycle efficiency

Local storage readiness is now a process startup invariant. The storage adapter is initialized once during Fastify readiness instead of issuing mkdir(..., { recursive: true }) on every upload request.

A storage initialization failure prevents normal startup rather than failing later inside a user upload.

Quality and CI gate

The repository now requires a full verification pipeline with:

  • PostgreSQL service
  • Redis service
  • dependency security audit
  • Prisma client generation
  • Prisma migration deployment
  • JavaScript syntax checks
  • ESLint static analysis
  • unit and integration tests
  • concurrency tests against real PostgreSQL
  • filesystem-backed transfer tests
  • repeatable control-plane benchmark
  • retained engineering evidence artifacts

No PR in the v2.1.0 efficiency/resumability run was merged before this gate was green.

Deployment hardening

The production start contract now applies committed Prisma migrations before the Fastify process starts:

prisma migrate deploy -> node src/server.js

This closes the gap where GitHub Actions validated migrations against its PostgreSQL service but the existing Render build command did not apply them to the production Neon database.

The release deploy must therefore reach a schema-current state before the application binds its public port.

Compatibility

  • Existing one-shot uploads remain supported.
  • Existing range/resumable download behavior remains supported.
  • The provider set remains Render, Neon PostgreSQL, and Upstash Redis.
  • Existing v1-compatible stored filenames remain readable through the constrained storage compatibility boundary.
  • The API remains backed by Render-local file storage; resumability does not change the durability or horizontal-sharing limits of node-local bytes.

Upgrade checklist

  1. Use Node.js 24.x.
  2. Deploy the v2.1.0 release from main.
  3. Allow startup to apply all committed Prisma migrations before Fastify starts.
  4. Confirm /health returns healthy.
  5. Confirm /infra/health reports PostgreSQL and Redis operational state.
  6. Confirm Swagger/OpenAPI reports version 2.1.0 and exposes the upload-session routes plus x-upload-size.
  7. Exercise one declared-size one-shot upload and one interrupted/resumed chunked upload.
  8. Confirm quota reservation is released after abort/failure and converted exactly once after completion.

Release scope

v2.1.0 includes the merged work from the efficiency and resumable-upload run, including PRs #23 through #36 and their associated issues/tests.

VaultBox API v2.0.0 — Resumable Transfer Engine

Choose a tag to compare

@github-actions github-actions released this 29 Aug 20:45
36ce035

VaultBox API v2.0.0 — Resumable Transfer Engine

VaultBox v2 is a provider-preserving infrastructure and transfer-engine upgrade built on the existing Render, Neon PostgreSQL, and Upstash Redis stack.

Highlights

Resumable and parallel downloads

VaultBox now supports standard HTTP byte-range transfer semantics for large-file reliability and higher practical throughput:

  • HEAD metadata requests without transferring file bodies
  • Accept-Ranges: bytes
  • 206 Partial Content
  • Content-Range
  • Range and If-Range
  • SHA-256-backed strong ETags
  • 416 Range Not Satisfiable handling
  • reusable short-lived download sessions
  • hashed download credentials instead of plaintext token storage
  • a reference multi-part downloader that writes ranges directly to final offsets, persists completed-part state, resumes after interruption, and verifies the final SHA-256 checksum

This makes network interruption recoverable without restarting a large download from byte zero and allows clients to fetch independent segments concurrently.

Streaming upload pipeline

  • SHA-256 is computed while the upload stream is written instead of rereading the complete file afterwards.
  • Quota reservation is atomic in PostgreSQL to prevent concurrent uploads from racing past account limits.
  • New objects use opaque storage keys rather than embedding user-controlled filenames in storage paths.
  • Legacy v1 file paths remain readable through a constrained compatibility boundary.

Redis reliability fix

The Redis offline state was traced to two application regressions rather than a provider replacement requirement:

  1. the Redis module changed to export { redis, connectRedis }, while the infrastructure health route continued calling .ping() on the wrapper object;
  2. application startup never called connectRedis() after the explicit client lifecycle was introduced.

v2 fixes both issues while keeping Upstash. Redis now connects explicitly at startup, closes gracefully on shutdown, reports actual client/ping state through infrastructure health, and safely degrades for ephemeral coordination when unavailable.

Security and correctness

  • current account state is revalidated after JWT verification, preventing suspended or deleted accounts from relying indefinitely on old tokens
  • short-lived Redis authorization caching reduces database overhead while preserving account-state enforcement
  • stronger password validation and bcrypt cost
  • normalized email identities
  • production CORS allowlisting
  • fail-closed production configuration for critical secrets and database connectivity
  • credential-aware request-log redaction
  • response security headers
  • safe attachment filename handling
  • Redis-backed throttling with process-local fallback
  • idempotency primitives
  • safe plan-downgrade checks
  • safer folder-deletion semantics that preserve contained files
  • bounded pagination/search/sorting for collection endpoints
  • database indexes for common access paths
  • aggregation-based administrative storage reporting

Runtime and dependency hardening

  • Node.js 24 LTS runtime
  • GitHub Actions upgraded to Node-24-native action releases
  • deterministic npm ci
  • CI fails on high-severity dependency advisories
  • Dependabot enabled for npm and GitHub Actions maintenance
  • validated dependency graph: 0 known vulnerabilities at release time

Engineering evidence

Final branch verification ran on GitHub Actions Ubuntu 24.04 with Node.js 24.19.0.

Measurement Result
Requests 5,000
Concurrency 32
Throughput 17,058.63 req/s
p50 latency 1.634 ms
p95 latency 3.809 ms
p99 latency 8.361 ms
Average latency 1.873 ms
Maximum latency 12.650 ms
Benchmark errors 0
Unit tests 13/13 passing
Dependency vulnerabilities 0

The benchmark uses Fastify in-process injection against /health; these figures represent application control-plane overhead and deliberately exclude public Internet latency, Render cold starts, Neon/Upstash network latency, filesystem throughput, and actual file-transfer bandwidth.

Real transfer throughput can be measured with scripts/parallel-download.js, which reports observed MiB/s for the specific host/client network path.

Observability

  • request IDs
  • Server-Timing response data
  • process/request metrics endpoint
  • database and Redis dependency latency in infrastructure health
  • CI-retained benchmark and dependency-audit artifacts

Upgrade notes

  1. Deploy with Node.js 24.x.
  2. Apply the included Prisma migration with npx prisma migrate deploy.
  3. Confirm production DATABASE_URL, JWT_SECRET, REDIS_URL, and CORS_ORIGINS values.
  4. Regenerate any outstanding pre-v2 download token because v2 stores download credentials as hashes.
  5. After deployment, validate /health and /infra/health.
  6. Exercise upload, ranged download, interrupted/resumed download, deletion, quota enforcement, suspension, and reactivation flows.

Provider compatibility

No infrastructure provider was replaced in this release. VaultBox v2 continues to use:

  • Render for the application runtime and current local storage adapter
  • Neon PostgreSQL as the persistent source of truth
  • Upstash Redis for ephemeral coordination

The storage adapter introduced in v2 creates a clean future boundary for durable object storage/CDN integration without changing the public download protocol.

Compatibility note

Render-local storage remains the physical throughput and durability boundary of the current deployment. Parallel HTTP ranges improve transfer utilization and resumability, but they do not remove the bandwidth, disk, or persistence limitations of a single Render-hosted storage node.

VaultBox API v1.0.0 — Initial Production Release

Choose a tag to compare

@wbizmo wbizmo released this 18 Jun 00:49

VaultBox API v1.0.0 — Initial Production Release

VaultBox API v1.0.0 marks the first stable production release of VaultBox, a secure cloud storage backend designed around storage management, quota enforcement, file lifecycle operations, administration tooling, and infrastructure observability.

Built with Fastify, Prisma, PostgreSQL, Redis, and JWT authentication, VaultBox provides a production-ready foundation for cloud storage platforms and storage-centric SaaS applications.

What's Included

Authentication & Access Control

  • User registration
  • User login
  • JWT authentication
  • Password hashing with bcrypt
  • Role-based access control
  • Protected API endpoints
  • Administrator permissions

Storage Management

  • Storage plans
  • Plan subscriptions
  • Storage quota enforcement
  • Usage tracking
  • File metadata management
  • Storage accounting

File Operations

  • File uploads
  • File listing
  • File deletion
  • Checksum generation
  • Upload auditing
  • Storage usage monitoring

Folder Operations

  • Folder creation
  • Folder listing
  • Folder updates
  • Folder deletion

Secure Downloads

  • Signed download tokens
  • Expiring download URLs
  • Download auditing
  • Controlled file access

Administration

  • User management
  • Account suspension
  • Account reactivation
  • Account deletion
  • Storage reporting
  • Audit log visibility

Billing Simulation

  • Failed payment simulation
  • Automatic account suspension workflows
  • Account recovery workflows

Infrastructure & Reliability

  • PostgreSQL persistence
  • Prisma ORM integration
  • Redis integration
  • Rate limiting
  • Health monitoring
  • Infrastructure diagnostics
  • Swagger / OpenAPI documentation

Production Deployment

VaultBox API has been successfully deployed using:

  • Render
  • Neon PostgreSQL
  • Upstash Redis

Live API:

https://vaultbox-api-ucff.onrender.com/

Swagger Documentation:

https://vaultbox-api-ucff.onrender.com/docs

Demo Accounts

Administrator

Email: [admin@vaultbox.dev](mailto:admin@vaultbox.dev)

Password: Admin123!

Standard User

Email: [user@vaultbox.dev](mailto:user@vaultbox.dev)

Password: User123!

Technology Stack

  • Node.js
  • Fastify
  • Prisma ORM
  • PostgreSQL
  • Neon PostgreSQL
  • Redis
  • Upstash Redis
  • JWT
  • bcrypt
  • Swagger/OpenAPI

Repository

https://github.com/wbizmo/vaultbox-api

Author

Williams Ashibuogwu (wbizmo)

GitHub: https://github.com/wbizmo

Portfolio: https://my-portfolio-website-three-ebon.vercel.app/


VaultBox API v1.0.0 establishes the core platform foundation and introduces secure storage management, administrative controls, infrastructure monitoring, and production deployment support as the baseline for future releases.