boltstore 0.5.0

package/README.md

@@ -0,0 +1,39 @@
+# Boltstore
+
+**Single-binary, self-hosted Backend-as-a-Service.**
+
+Offline sync + S3-compatible storage + realtime + extensible JS hooks + Row-Level Security. Runs on a 512MB VPS. Built on **Bun**.
+
+Zero production dependencies. Everything uses Bun built-ins: `bun:sqlite`, `Bun.serve()`, `Bun.password`, Web Crypto API.
+
+## Quick Start
+
+```bash
+bun install
+bun run dev
+```
+
+## Packages
+
+This repo is the main `boltstore` package (published on npm). The admin UI (Vue SPA) lives at `src/admin-ui/` and is built into the binary.
+
+Companion packages published separately:
+- **[@boltstore/utils](https://www.npmjs.com/package/@boltstore/utils)** — Shared types, validation, filter parser (used by client SDK)
+- **[@boltstore/client](https://www.npmjs.com/package/@boltstore/client)** — TypeScript SDK for Bun, Node 18+, browsers
+
+## Features
+
+- SQLite with dual-pool concurrency and WAL mode
+- REST API auto-generated from collection schemas
+- JWT + bcrypt + OAuth2 (Google, GitHub) + API keys
+- Row-Level Security (SQL policy injection)
+- WebSocket pub/sub with RLS-aware fan-out
+- Offline sync (4 strategies, per-field override)
+- LocalDisk + S3-compatible file storage
+- Lifecycle hooks + custom routes/WS/CLI extensions
+- Vue admin UI embedded in binary
+- Standard SQLite backups + full-instance archives
+
+## License
+
+MIT

package/bin/cli.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env bun
+// ── Boltstore CLI ──
+// Usage: boltstore <command> [options]
+//
+// Commands:
+//   start         Start the Boltstore server
+//   backup        Create a backup (--full for full-instance)
+//   restore       Restore from a backup archive
+//   version       Print version
+
+import { parseArgs } from "node:util";
+
+const VERSION = "0.3.0";
+
+function printHelp(): void {
+  console.log(`
+Boltstore v${VERSION} — Self-hosted Backend-as-a-Service
+
+Usage:
+  boltstore <command> [options]
+
+Commands:
+  start              Start the Boltstore server
+  backup             Create a backup
+    --full           Full-instance backup (all applications + uploads + config)
+    --application <id>   Backup a specific application
+  restore --from <path>   Restore from a backup archive
+  version            Print version information
+
+Options:
+  --port <n>         Server port (default: 8090)
+  --host <host>      Server hostname (default: 127.0.0.1)
+  --config <path>    Path to config file (default: boltstore.yaml)
+  --data-dir <path>  Data directory (default: data)
+  --log-level <lvl>  Log level: debug, info, warn, error (default: info)
+
+Examples:
+  boltstore start
+  boltstore start --port 3000
+  boltstore backup --full
+  boltstore restore --from data/backups/full-2026-06-09.zip
+`);
+}
+
+async function main(): Promise<void> {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      port: { type: "string" },
+      host: { type: "string" },
+      config: { type: "string" },
+      "data-dir": { type: "string" },
+      "log-level": { type: "string" },
+      full: { type: "boolean" },
+      application: { type: "string" },
+      from: { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+    strict: false,
+    allowPositionals: true,
+  });
+
+  const command = positionals[0] ?? "start";
+
+  if (values.help) {
+    printHelp();
+    return;
+  }
+
+  switch (command) {
+    case "version": {
+      console.log(`Boltstore v${VERSION}`);
+      return;
+    }
+
+    case "start": {
+      // Dynamic import so the config loader can apply CLI flags
+      const { createServer } = await import("../src/app");
+      const app = createServer({
+        ...(values.port ? { port: parseInt(values.port as string, 10) } : {}),
+        ...(values.host ? { host: values.host as string } : {}),
+        ...(values["data-dir"] ? { dataDir: values["data-dir"] as string } : {}),
+      });
+
+      // Graceful shutdown
+      process.on("SIGINT", () => { app.stop().then(() => process.exit(0)); });
+      process.on("SIGTERM", () => { app.stop().then(() => process.exit(0)); });
+
+      app.start();
+      return;
+    }
+
+    case "backup": {
+      const { createServer } = await import("../src/app");
+      const app = createServer();
+      const config = app.config;
+
+      console.log("📦 Creating backup...");
+
+      const { snapshotProjectDb, fullBackup } = await import("../src/backup/manager");
+      const backupConfig = {
+        backupDir: `${config.dataDir}/backups`,
+        dataDir: config.dataDir,
+        retentionCount: config.backup?.retentionCount ?? 48,
+      };
+
+      if (values.full) {
+        console.log("   Full-instance backup (all applications, uploads, hooks, config)");
+        const path = await fullBackup(backupConfig);
+        console.log(`   ✅ Full backup created: ${path}`);
+      } else if (values.application) {
+        console.log(`   Application: ${values.application}`);
+        const { Database } = await import("bun:sqlite");
+        const dbFile = `${config.dataDir}/application/${values.application}/data.db`;
+        const db = new Database(dbFile);
+        const path = await snapshotProjectDb(db, values.application as string, backupConfig);
+        db.close();
+        console.log(`   ✅ Snapshot created: ${path}`);
+      } else {
+        console.log("   Per-application SQLite snapshots");
+        const { Database } = await import("bun:sqlite");
+        const { readdirSync, existsSync } = await import("node:fs");
+        const appsDir = `${config.dataDir}/application`;
+        if (existsSync(appsDir)) {
+          const appDirs = readdirSync(appsDir);
+          for (const appId of appDirs) {
+            const dbFile = `${appsDir}/${appId}/data.db`;
+            if (!existsSync(dbFile)) continue;
+            const db = new Database(dbFile);
+            const path = await snapshotProjectDb(db, appId, backupConfig);
+            db.close();
+            console.log(`   ✅ ${appId}: ${path}`);
+          }
+        } else {
+          console.log("   No applications found.");
+        }
+      }
+      await app.stop();
+      return;
+    }
+
+    case "restore": {
+      if (!values.from) {
+        console.error("Error: --from <path> is required for restore");
+        console.error("Usage: boltstore restore --from <backup.zip>");
+        process.exit(1);
+      }
+      console.log(`📥 Restoring from ${values.from}...`);
+
+      const { createServer } = await import("../src/app");
+      const app = createServer();
+      const config = app.config;
+
+      const { restoreFromBackup } = await import("../src/backup/manager");
+      const backupConfig = {
+        backupDir: `${config.dataDir}/backups`,
+        dataDir: config.dataDir,
+        retentionCount: config.backup?.retentionCount ?? 48,
+      };
+
+      await restoreFromBackup(values.from as string, backupConfig);
+      console.log("   ✅ Restore complete");
+      await app.stop();
+      return;
+    }
+
+    default: {
+      // Try extension CLI commands
+      const { createServer } = await import("../src/app");
+      const app = createServer();
+      const extCmd = app.server ? undefined : undefined;
+      // We can't access extensions here easily since createServer returns an interface.
+      // Extensions should register their CLI commands via the registry.
+      // For now, print unknown command.
+      console.error(`Unknown command: ${command}`);
+      console.error("Run 'boltstore --help' for usage.");
+      process.exit(1);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "boltstore",
+  "version": "0.5.0",
+  "description": "Boltstore — single-binary, self-hosted Backend-as-a-Service",
+  "type": "module",
+  "main": "./src/index.ts",
+  "bin": {
+    "boltstore": "./bin/cli.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./config": "./src/config.ts",
+    "./app": "./src/app.ts"
+  },
+  "files": [
+    "src/",
+    "bin/"
+  ],
+  "scripts": {
+    "dev": "bun run scripts/dev.ts",
+    "build": "bun run scripts/build.ts",
+    "start": "bun run bin/cli.ts start",
+    "test": "bun test",
+    "check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@boltstore/utils": "^0.5.2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/dompurify": "^3.2.0",
+    "@vitejs/plugin-vue": "^5.2.0",
+    "dompurify": "^3.4.8",
+    "pinia": "^2.3.0",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0",
+    "vue": "^3.5.0",
+    "vue-router": "^4.5.0",
+    "vue-tsc": "^2.2.0"
+  },
+  "keywords": [
+    "boltstore",
+    "baas",
+    "backend",
+    "sqlite",
+    "realtime",
+    "sync"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/boltstore/boltstore"
+  }
+}