javascript-solid-server 0.0.56 → 0.0.57

package/README.md

@@ -6,7 +6,7 @@ A minimal, fast, JSON-LD native Solid server.
 
 ## Features
 
-### Implemented (v0.0.56)
+### Implemented (v0.0.57)
 
 - **LDP CRUD Operations** - GET, PUT, POST, DELETE, HEAD
 - **N3 Patch** - Solid's native patch format for RDF updates
@@ -30,6 +30,7 @@ A minimal, fast, JSON-LD native Solid server.
 - **CORS Support** - Full cross-origin resource sharing
 - **Git HTTP Backend** - Clone and push to containers via `git` protocol
 - **Invite-Only Registration** - CLI-managed invite codes for controlled signups
+- **Storage Quotas** - Per-user storage limits with CLI management
 - **Security** - Blocks access to dotfiles (`.git/`, `.env`, etc.) except Solid-specific ones
 
 ### HTTP Methods
@@ -78,6 +79,7 @@ jss start --port 8443 --ssl-key ./key.pem --ssl-cert ./cert.pem
 jss start [options]    # Start the server
 jss init [options]     # Initialize configuration
 jss invite <cmd>       # Manage invite codes (create, list, revoke)
+jss quota <cmd>        # Manage storage quotas (set, show, reconcile)
 jss --help             # Show help
 ```
 
@@ -102,6 +104,7 @@ jss --help             # Show help
 | `--mashlib-version <ver>` | Mashlib CDN version | 2.0.0 |
 | `--git` | Enable Git HTTP backend | false |
 | `--invite-only` | Require invite code for registration | false |
+| `--default-quota <size>` | Default storage quota per pod (e.g., 50MB) | 50MB |
 | `-q, --quiet` | Suppress logs | false |
 
 ### Environment Variables
@@ -117,6 +120,7 @@ export JSS_SUBDOMAINS=true
 export JSS_BASE_DOMAIN=example.com
 export JSS_MASHLIB=true
 export JSS_INVITE_ONLY=true
+export JSS_DEFAULT_QUOTA=100MB
 jss start
 ```
 
@@ -427,6 +431,43 @@ When `--invite-only` is enabled:
 
 Invite codes are stored in `.server/invites.json` in your data directory.
 
+## Storage Quotas
+
+Limit storage per pod to prevent abuse and manage resources:
+
+```bash
+jss start --default-quota 50MB
+```
+
+### Managing Quotas
+
+```bash
+# Set quota for a user (overrides default)
+jss quota set alice 100MB
+
+# Show quota info
+jss quota show alice
+#   alice:
+#     Used:  12.5 MB
+#     Limit: 100 MB
+#     Free:  87.5 MB
+#     Usage: 12%
+
+# Recalculate from actual disk usage
+jss quota reconcile alice
+```
+
+### How It Works
+
+- Quotas are tracked incrementally on PUT, POST, and DELETE operations
+- When quota is exceeded, the server returns HTTP 507 Insufficient Storage
+- Each pod stores its quota in `/{pod}/.quota.json`
+- Use `reconcile` to fix quota drift from manual file changes
+
+### Size Formats
+
+Supported formats: `50MB`, `1GB`, `500KB`, `1TB`
+
 ## Authentication
 
 ### Simple Tokens (Development)
@@ -688,7 +729,8 @@ src/
 │   ├── container.js      # POST, pod creation
 │   └── git.js            # Git HTTP backend
 ├── storage/
-│   └── filesystem.js     # File operations
+│   ├── filesystem.js     # File operations
+│   └── quota.js          # Storage quota management
 ├── auth/
 │   ├── middleware.js     # Auth hook
 │   ├── token.js          # Simple token auth

package/bin/jss.js

@@ -12,6 +12,8 @@ import { Command } from 'commander';
 import { createServer } from '../src/server.js';
 import { loadConfig, saveConfig, printConfig, defaults } from '../src/config.js';
 import { createInvite, listInvites, revokeInvite } from '../src/idp/invites.js';
+import { setQuotaLimit, getQuotaInfo, reconcileQuota, formatBytes } from '../src/storage/quota.js';
+import { parseSize } from '../src/config.js';
 import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -307,6 +309,92 @@ inviteCmd
     }
   });
 
+/**
+ * Quota command - manage storage quotas
+ */
+const quotaCmd = program
+  .command('quota')
+  .description('Manage storage quotas for pods');
+
+quotaCmd
+  .command('set <username> <size>')
+  .description('Set quota limit for a user (e.g., 50MB, 1GB)')
+  .option('-r, --root <path>', 'Data directory')
+  .action(async (username, size, options) => {
+    try {
+      if (options.root) {
+        process.env.DATA_ROOT = path.resolve(options.root);
+      }
+
+      const bytes = parseSize(size);
+      if (bytes === 0) {
+        console.error('Invalid size format. Use e.g., 50MB, 1GB');
+        process.exit(1);
+      }
+
+      const quota = await setQuotaLimit(username, bytes);
+      console.log(`\nQuota set for ${username}: ${formatBytes(quota.limit)}`);
+      console.log(`Current usage: ${formatBytes(quota.used)} (${Math.round(quota.used / quota.limit * 100)}%)\n`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+quotaCmd
+  .command('show <username>')
+  .description('Show quota info for a user')
+  .option('-r, --root <path>', 'Data directory')
+  .action(async (username, options) => {
+    try {
+      if (options.root) {
+        process.env.DATA_ROOT = path.resolve(options.root);
+      }
+
+      const quota = await getQuotaInfo(username);
+
+      if (quota.limit === 0) {
+        console.log(`\n${username}: No quota set (unlimited)\n`);
+      } else {
+        console.log(`\n${username}:`);
+        console.log(`  Used:  ${formatBytes(quota.used)}`);
+        console.log(`  Limit: ${formatBytes(quota.limit)}`);
+        console.log(`  Free:  ${formatBytes(quota.limit - quota.used)}`);
+        console.log(`  Usage: ${quota.percent}%\n`);
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+quotaCmd
+  .command('reconcile <username>')
+  .description('Recalculate quota usage from actual disk usage')
+  .option('-r, --root <path>', 'Data directory')
+  .action(async (username, options) => {
+    try {
+      if (options.root) {
+        process.env.DATA_ROOT = path.resolve(options.root);
+      }
+
+      console.log(`Calculating actual disk usage for ${username}...`);
+      const quota = await reconcileQuota(username);
+
+      if (quota.limit === 0) {
+        console.log(`\n${username}: No quota configured\n`);
+      } else {
+        console.log(`\nReconciled ${username}:`);
+        console.log(`  Used:  ${formatBytes(quota.used)}`);
+        console.log(`  Limit: ${formatBytes(quota.limit)}`);
+        console.log(`  Usage: ${Math.round(quota.used / quota.limit * 100)}%\n`);
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
 /**
  * Helper: Prompt for input
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.56",
+  "version": "0.0.57",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",

package/src/config.js

@@ -48,6 +48,9 @@ export const defaults = {
   // Invite-only registration
   inviteOnly: false,
 
+  // Storage quota (bytes) - 50MB default
+  defaultQuota: 50 * 1024 * 1024,
+
   // Logging
   logger: true,
   quiet: false,
@@ -79,8 +82,22 @@ const envMap = {
   JSS_MASHLIB_VERSION: 'mashlibVersion',
   JSS_GIT: 'git',
   JSS_INVITE_ONLY: 'inviteOnly',
+  JSS_DEFAULT_QUOTA: 'defaultQuota',
 };
 
+/**
+ * Parse a size string like "50MB" or "1GB" to bytes
+ */
+export function parseSize(str) {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)?$/i);
+  if (!match) return parseInt(str, 10) || 0;
+
+  const num = parseFloat(match[1]);
+  const unit = (match[2] || 'B').toUpperCase();
+  const multipliers = { B: 1, KB: 1024, MB: 1024**2, GB: 1024**3, TB: 1024**4 };
+  return Math.floor(num * (multipliers[unit] || 1));
+}
+
 /**
  * Parse a value from environment variable string
  */
@@ -96,6 +113,11 @@ function parseEnvValue(value, key) {
     return parseInt(value, 10);
   }
 
+  // Size values (quota)
+  if (key === 'defaultQuota') {
+    return parseSize(value);
+  }
+
   return value;
 }
 

package/src/handlers/container.js

@@ -1,6 +1,7 @@
 import * as storage from '../storage/filesystem.js';
+import { initializeQuota, checkQuota, updateQuotaUsage } from '../storage/quota.js';
 import { getAllHeaders } from '../ldp/headers.js';
-import { isContainer, getEffectiveUrlPath } from '../utils/url.js';
+import { isContainer, getEffectiveUrlPath, getPodName } from '../utils/url.js';
 import { generateProfile, generatePreferences, generateTypeIndex, serialize } from '../webid/profile.js';
 import { generateOwnerAcl, generatePrivateAcl, generateInboxAcl, generatePublicFolderAcl, serializeAcl } from '../wac/parser.js';
 import { createToken } from '../auth/token.js';
@@ -106,7 +107,21 @@ export async function handlePost(request, reply) {
       }
     }
 
+    // Check storage quota before writing
+    const podName = getPodName(request);
+    if (podName) {
+      const { allowed, error } = await checkQuota(podName, content.length, request.defaultQuota || 0);
+      if (!allowed) {
+        return reply.code(507).send({ error: 'Insufficient Storage', message: error });
+      }
+    }
+
     success = await storage.write(newStoragePath, content);
+
+    // Update quota usage after successful write
+    if (success && podName) {
+      await updateQuotaUsage(podName, content.length);
+    }
   }
 
   if (!success) {
@@ -139,8 +154,9 @@ export async function handlePost(request, reply) {
  * @param {string} webId - User's WebID URI
  * @param {string} podUri - Pod root URI (e.g., https://alice.example.com/ or https://example.com/alice/)
  * @param {string} issuer - OIDC issuer URI
+ * @param {number} defaultQuota - Default storage quota in bytes (optional)
  */
-export async function createPodStructure(name, webId, podUri, issuer) {
+export async function createPodStructure(name, webId, podUri, issuer, defaultQuota = 0) {
   const podPath = `/${name}/`;
 
   // Create pod directory structure
@@ -193,6 +209,11 @@ export async function createPodStructure(name, webId, podUri, issuer) {
   const profileAcl = generatePublicFolderAcl(`${podUri}profile/`, webId);
   await storage.write(`${podPath}profile/.acl`, serializeAcl(profileAcl));
 
+  // Initialize storage quota if configured
+  if (defaultQuota > 0) {
+    await initializeQuota(name, defaultQuota);
+  }
+
   return { podPath, podUri };
 }
 

package/src/handlers/resource.js

@@ -1,7 +1,8 @@
 import * as storage from '../storage/filesystem.js';
+import { checkQuota, updateQuotaUsage } from '../storage/quota.js';
 import { getAllHeaders, getNotFoundHeaders } from '../ldp/headers.js';
 import { generateContainerJsonLd, serializeJsonLd } from '../ldp/container.js';
-import { isContainer, getContentType, isRdfContentType, getEffectiveUrlPath, safeJsonParse } from '../utils/url.js';
+import { isContainer, getContentType, isRdfContentType, getEffectiveUrlPath, safeJsonParse, getPodName } from '../utils/url.js';
 import { parseN3Patch, applyN3Patch, validatePatch } from '../patch/n3-patch.js';
 import { parseSparqlUpdate, applySparqlUpdate } from '../patch/sparql-update.js';
 import {
@@ -504,11 +505,28 @@ export async function handlePut(request, reply) {
     }
   }
 
+  // Check storage quota before writing
+  const podName = getPodName(request);
+  const oldSize = stats?.size || 0;
+  const sizeDelta = content.length - oldSize;
+
+  if (podName && sizeDelta > 0) {
+    const { allowed, error } = await checkQuota(podName, sizeDelta, request.defaultQuota || 0);
+    if (!allowed) {
+      return reply.code(507).send({ error: 'Insufficient Storage', message: error });
+    }
+  }
+
   const success = await storage.write(storagePath, content);
   if (!success) {
     return reply.code(500).send({ error: 'Write failed' });
   }
 
+  // Update quota usage after successful write
+  if (podName && sizeDelta !== 0) {
+    await updateQuotaUsage(podName, sizeDelta);
+  }
+
   const origin = request.headers.origin;
   const headers = getAllHeaders({ isContainer: false, origin, resourceUrl, connegEnabled });
   headers['Location'] = resourceUrl;
@@ -549,11 +567,20 @@ export async function handleDelete(request, reply) {
     }
   }
 
+  // Get file size before deletion for quota update
+  const fileSize = stats.size || 0;
+
   const success = await storage.remove(storagePath);
   if (!success) {
     return reply.code(500).send({ error: 'Delete failed' });
   }
 
+  // Update quota usage (subtract deleted file size)
+  const podName = getPodName(request);
+  if (podName && fileSize > 0) {
+    await updateQuotaUsage(podName, -fileSize);
+  }
+
   const origin = request.headers.origin;
   const headers = getAllHeaders({ isContainer: false, origin, resourceUrl });
   Object.entries(headers).forEach(([k, v]) => reply.header(k, v));

package/src/server.js

@@ -48,6 +48,8 @@ export function createServer(options = {}) {
   const gitEnabled = options.git ?? false;
   // Invite-only registration is OFF by default - open registration
   const inviteOnly = options.inviteOnly ?? false;
+  // Default storage quota per pod (50MB default, 0 = unlimited)
+  const defaultQuota = options.defaultQuota ?? 50 * 1024 * 1024;
 
   // Set data root via environment variable if provided
   if (options.root) {
@@ -95,6 +97,7 @@ export function createServer(options = {}) {
   fastify.decorateRequest('mashlibEnabled', null);
   fastify.decorateRequest('mashlibCdn', null);
   fastify.decorateRequest('mashlibVersion', null);
+  fastify.decorateRequest('defaultQuota', null);
   fastify.addHook('onRequest', async (request) => {
     request.connegEnabled = connegEnabled;
     request.notificationsEnabled = notificationsEnabled;
@@ -104,6 +107,7 @@ export function createServer(options = {}) {
     request.mashlibEnabled = mashlibEnabled;
     request.mashlibCdn = mashlibCdn;
     request.mashlibVersion = mashlibVersion;
+    request.defaultQuota = defaultQuota;
 
     // Extract pod name from subdomain if enabled
     if (subdomainsEnabled && baseDomain) {

package/src/storage/quota.js

@@ -0,0 +1,202 @@
+/**
+ * Storage quota management
+ * Tracks and enforces per-pod storage limits
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { getDataRoot } from '../utils/url.js';
+
+const QUOTA_FILE = '.quota.json';
+
+/**
+ * Get quota file path for a pod
+ */
+function getQuotaPath(podName) {
+  return join(getDataRoot(), podName, QUOTA_FILE);
+}
+
+/**
+ * Load quota data for a pod
+ * @param {string} podName - The pod name
+ * @returns {Promise<{limit: number, used: number}>}
+ */
+export async function loadQuota(podName) {
+  try {
+    const data = await fs.readFile(getQuotaPath(podName), 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      // No quota file - return defaults (will be initialized on first write)
+      return { limit: 0, used: 0 };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Save quota data for a pod
+ * @param {string} podName - The pod name
+ * @param {object} quota - Quota data
+ */
+export async function saveQuota(podName, quota) {
+  await fs.writeFile(getQuotaPath(podName), JSON.stringify(quota, null, 2));
+}
+
+/**
+ * Initialize quota for a new pod
+ * @param {string} podName - The pod name
+ * @param {number} limit - Quota limit in bytes
+ */
+export async function initializeQuota(podName, limit) {
+  const quota = { limit, used: 0 };
+  await saveQuota(podName, quota);
+  return quota;
+}
+
+/**
+ * Calculate actual disk usage for a pod (for reconciliation)
+ * @param {string} podName - The pod name
+ * @returns {Promise<number>} Total bytes used
+ */
+export async function calculatePodSize(podName) {
+  const podPath = join(getDataRoot(), podName);
+  return calculateDirSize(podPath);
+}
+
+/**
+ * Recursively calculate directory size
+ */
+async function calculateDirSize(dirPath) {
+  let total = 0;
+
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+
+      // Skip quota file itself
+      if (entry.name === QUOTA_FILE) continue;
+
+      if (entry.isDirectory()) {
+        total += await calculateDirSize(fullPath);
+      } else if (entry.isFile()) {
+        const stat = await fs.stat(fullPath);
+        total += stat.size;
+      }
+    }
+  } catch (err) {
+    // Directory might not exist or be inaccessible
+    if (err.code !== 'ENOENT') {
+      throw err;
+    }
+  }
+
+  return total;
+}
+
+/**
+ * Check if a write operation would exceed quota
+ * @param {string} podName - The pod name
+ * @param {number} additionalBytes - Bytes to be added
+ * @param {number} defaultQuota - Default quota limit
+ * @returns {Promise<{allowed: boolean, quota: object, error?: string}>}
+ */
+export async function checkQuota(podName, additionalBytes, defaultQuota) {
+  let quota = await loadQuota(podName);
+
+  // Initialize if no quota set
+  if (quota.limit === 0 && defaultQuota > 0) {
+    quota = await initializeQuota(podName, defaultQuota);
+  }
+
+  // No quota enforcement if limit is 0
+  if (quota.limit === 0) {
+    return { allowed: true, quota };
+  }
+
+  const projectedUsage = quota.used + additionalBytes;
+
+  if (projectedUsage > quota.limit) {
+    const usedMB = (quota.used / (1024 * 1024)).toFixed(2);
+    const limitMB = (quota.limit / (1024 * 1024)).toFixed(2);
+    return {
+      allowed: false,
+      quota,
+      error: `Storage quota exceeded. Used: ${usedMB}MB / ${limitMB}MB`
+    };
+  }
+
+  return { allowed: true, quota };
+}
+
+/**
+ * Update quota usage after a write
+ * @param {string} podName - The pod name
+ * @param {number} bytesChange - Bytes added (positive) or removed (negative)
+ */
+export async function updateQuotaUsage(podName, bytesChange) {
+  const quota = await loadQuota(podName);
+
+  // Skip if no quota initialized
+  if (quota.limit === 0) return quota;
+
+  quota.used = Math.max(0, quota.used + bytesChange);
+  await saveQuota(podName, quota);
+  return quota;
+}
+
+/**
+ * Set quota limit for a pod
+ * @param {string} podName - The pod name
+ * @param {number} limit - New limit in bytes
+ */
+export async function setQuotaLimit(podName, limit) {
+  let quota = await loadQuota(podName);
+
+  // If no quota exists, calculate current usage
+  if (quota.limit === 0) {
+    quota.used = await calculatePodSize(podName);
+  }
+
+  quota.limit = limit;
+  await saveQuota(podName, quota);
+  return quota;
+}
+
+/**
+ * Get quota info for a pod
+ * @param {string} podName - The pod name
+ * @returns {Promise<{limit: number, used: number, percent: number}>}
+ */
+export async function getQuotaInfo(podName) {
+  const quota = await loadQuota(podName);
+  const percent = quota.limit > 0 ? Math.round((quota.used / quota.limit) * 100) : 0;
+  return { ...quota, percent };
+}
+
+/**
+ * Reconcile quota with actual disk usage
+ * @param {string} podName - The pod name
+ */
+export async function reconcileQuota(podName) {
+  const quota = await loadQuota(podName);
+  if (quota.limit === 0) return quota;
+
+  const actualUsed = await calculatePodSize(podName);
+  quota.used = actualUsed;
+  await saveQuota(podName, quota);
+  return quota;
+}
+
+/**
+ * Format bytes as human-readable string
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}

package/src/utils/url.js

@@ -143,6 +143,43 @@ export function getResourceName(urlPath) {
   return parts[parts.length - 1];
 }
 
+/**
+ * Extract pod name from URL path or request
+ * @param {string|object} pathOrRequest - URL path string or Fastify request object
+ * @returns {string|null} - Pod name or null if not found
+ */
+export function getPodName(pathOrRequest) {
+  // If it's a request object
+  if (typeof pathOrRequest === 'object') {
+    // Subdomain mode: pod name from hostname
+    if (pathOrRequest.subdomainsEnabled && pathOrRequest.podName) {
+      return pathOrRequest.podName;
+    }
+    // Path mode: extract from URL
+    const urlPath = pathOrRequest.url?.split('?')[0] || '';
+    return getPodNameFromPath(urlPath);
+  }
+
+  // If it's a string path
+  return getPodNameFromPath(pathOrRequest);
+}
+
+/**
+ * Extract pod name from URL path
+ * @param {string} urlPath - URL path (e.g., /alice/public/file.txt)
+ * @returns {string|null} - Pod name or null
+ */
+function getPodNameFromPath(urlPath) {
+  const parts = urlPath.split('/').filter(Boolean);
+  if (parts.length === 0) return null;
+
+  // First segment is the pod name (skip system paths)
+  const firstPart = parts[0];
+  if (firstPart.startsWith('.')) return null; // .well-known, .acl, etc.
+
+  return firstPart;
+}
+
 /**
  * Determine content type from file extension
  * @param {string} filePath