Repository navigation
Releases
VaultBox API v2.5.0: Reliability, Security, Performance and Folder APIs
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 requestsincludeTotal=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 startmigrations). - Configure required human reviewers for the GitHub
vaultbox-releaseenvironment, 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
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/webhookevent; 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
ACTIVEunder 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 /foldersis 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-controlledX-Forwarded-For; new adminGET /admin/network-diagnosticsshows 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-Afterwhen 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, isno-storewithReferrer-Policy: no-referrer.HEADno longer starts a session, and refusals that used to surface as500(missing bytes, unsatisfiable range) are proper404/416JSON 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
TRUST_PROXY(important). Unset in production means "private-network proxies". After deploying, callGET /admin/network-diagnosticsas an admin: ifclientIpis a proxy address, add the proxy's range toTRUST_PROXY, otherwise all clients share one rate-limit bucket (including the 120 / 5 min login cap).- Decide
PLAN_SWITCH_MODE(demofor the public demo) and setBILLING_WEBHOOK_SECRETif you will grant entitlements (the webhook answers503while it is unset). - Optionally tune
PASSWORD_HASH_CONCURRENCY/_QUEUE/_WAIT_MS(defaults 2 / 64 / 5000) andIDEMPOTENCY_*. - Configure your edge/CDN/APM to mask the path after
/download/(seedocs/DEPLOYMENT.md, "Download token lifecycle and URL exposure"). - Runtime stays Node.js 24.22.2 (
.node-version); keep anyNODE_VERSIONoverride 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
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=highhad begun failing on the v2.1.0 lockfile (advisories forfast-jwt,fastify,@fastify/busboy,fast-uri,brace-expansion). In-range updates were applied withnpm audit fix;package.jsonranges 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 --versionequals.node-version. - The release workflow is no longer hardcoded to v2.1.0: it reads the version from
package.json, requiresdocs/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_VERSIONenvironment 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
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:
POST /upload-sessionscreates a durable upload session and atomically reserves the expected file size against the user's current plan.PUT /upload-sessions/:id/parts/:partNumberstreams one exact, bounded part usingContent-Rangeand optionalx-chunk-sha256verification.GET /upload-sessions/:idreports uploaded and missing parts so clients resume only the data that is still absent.POST /upload-sessions/:id/completeatomically claims completion, streams parts into final storage in deterministic order, verifies final size and optional SHA-256, creates oneFile, and converts reserved bytes into committedstorageUsedexactly once.DELETE /upload-sessions/:idaborts 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
storageUsedin 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 ... RETURNINGinstead of issuing another user lookup solely to displaystorageUsed.
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_trgmpowers indexable substring search for file names and admin user name/email lookup. - GIN trigram indexes preserve case-insensitive
containssemantics. - 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
EVALround trip instead of separateINCR,EXPIRE, andTTLcalls. - 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 NULLupdates; - 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
- Use Node.js 24.x.
- Deploy the v2.1.0 release from
main. - Allow startup to apply all committed Prisma migrations before Fastify starts.
- Confirm
/healthreturns healthy. - Confirm
/infra/healthreports PostgreSQL and Redis operational state. - Confirm Swagger/OpenAPI reports version
2.1.0and exposes the upload-session routes plusx-upload-size. - Exercise one declared-size one-shot upload and one interrupted/resumed chunked upload.
- 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
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:
HEADmetadata requests without transferring file bodiesAccept-Ranges: bytes206 Partial ContentContent-RangeRangeandIf-Range- SHA-256-backed strong ETags
416 Range Not Satisfiablehandling- 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:
- the Redis module changed to export
{ redis, connectRedis }, while the infrastructure health route continued calling.ping()on the wrapper object; - 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-Timingresponse data- process/request metrics endpoint
- database and Redis dependency latency in infrastructure health
- CI-retained benchmark and dependency-audit artifacts
Upgrade notes
- Deploy with Node.js 24.x.
- Apply the included Prisma migration with
npx prisma migrate deploy. - Confirm production
DATABASE_URL,JWT_SECRET,REDIS_URL, andCORS_ORIGINSvalues. - Regenerate any outstanding pre-v2 download token because v2 stores download credentials as hashes.
- After deployment, validate
/healthand/infra/health. - 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
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.