kanbanqube 1.0.1 → 1.0.8

package/app.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const express = require("express");
+const path = require("node:path");
+const mimeTypes = require("./config/mimeTypes");
+const { errorHandler } = require("./middleware/errorHandler");
+const { notFound } = require("./middleware/notFound");
+const { createApiRoutes } = require("./routes/apiRoutes");
+const { createBoardService } = require("./services/boardService");
+const { createGitSyncService } = require("./services/gitSyncService");
+const { createImportService } = require("./services/importService");
+const { createUploadService } = require("./services/uploadService");
+
+function createApp(config) {
+  const app = express();
+  const boardService = createBoardService(config);
+  const gitSyncService = createGitSyncService(config);
+  const importService = createImportService(config);
+  const uploadService = createUploadService(config, boardService);
+
+  app.disable("x-powered-by");
+  app.use(express.json({ limit: "5mb", type: "application/json" }));
+  app.use(noStore);
+
+  app.use("/api", createApiRoutes({
+    config,
+    boardService,
+    gitSyncService,
+    importService,
+    uploadService
+  }));
+
+  app.get(`/${config.demoBoardFileName}`, (_request, response) => {
+    response.type("json").sendFile(config.demoBoardFilePath);
+  });
+  app.get(`/${config.uploadsDirName}/:fileName`, (request, response, next) => {
+    let fileName = "";
+    try {
+      fileName = uploadService.safeUploadFileName(request.params.fileName);
+    } catch (error) {
+      error.statusCode = 400;
+      next(error);
+      return;
+    }
+    const filePath = path.join(config.uploadsDir, fileName);
+    response.type(mimeTypes[path.extname(filePath).toLowerCase()] || "application/octet-stream");
+    response.sendFile(filePath, (error) => {
+      if (error) next(error);
+    });
+  });
+  app.use(express.static(config.publicDir, {
+    etag: false,
+    lastModified: false,
+    setHeaders: noStoreHeaders
+  }));
+  app.use(notFound);
+  app.use(errorHandler);
+
+  return {
+    app,
+    services: {
+      boardService,
+      gitSyncService,
+      importService,
+      uploadService
+    }
+  };
+}
+
+function noStore(_request, response, next) {
+  noStoreHeaders(response);
+  next();
+}
+
+function noStoreHeaders(response) {
+  response.setHeader("Cache-Control", "no-store");
+}
+
+module.exports = {
+  createApp
+};

package/config/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const path = require("node:path");
+
+function resolveWorkspaceDirectory(argument) {
+  if (typeof argument === "string" && argument.trim()) {
+    return path.resolve(argument);
+  }
+  return process.cwd();
+}
+
+function createConfig(options = {}) {
+  const appDir = options.appDir || path.resolve(__dirname, "..");
+  const workspaceDir = resolveWorkspaceDirectory(options.workspaceArgument);
+  const boardFileName = "board.json";
+  const demoBoardFileName = "demo_board.json";
+  const boardDirName = "board";
+  const uploadsDirName = "uploads";
+
+  return {
+    appDir,
+    workspaceDir,
+    publicDir: path.join(appDir, "public"),
+    boardFileName,
+    boardFilePath: path.join(workspaceDir, boardFileName),
+    demoBoardFileName,
+    demoBoardFilePath: path.join(appDir, demoBoardFileName),
+    boardDirName,
+    boardDir: path.join(workspaceDir, boardDirName),
+    boardMetaFilePath: path.join(workspaceDir, boardDirName, "meta.json"),
+    uploadsDirName,
+    uploadsDir: path.join(workspaceDir, uploadsDirName),
+    sampleExportDir: path.join(workspaceDir, "trello_export"),
+    port: Number(options.port || process.env.PORT || 3000),
+    gitExecutableCandidates: [
+      "/usr/bin/git",
+      "/bin/git",
+      "/usr/local/bin/git",
+      "/opt/homebrew/bin/git"
+    ],
+    sshExecutableCandidates: [
+      "/usr/bin/ssh",
+      "/bin/ssh",
+      "/usr/local/bin/ssh",
+      "/opt/homebrew/bin/ssh"
+    ],
+    gitSafePath: "/usr/bin:/bin:/usr/local/bin:/opt/homebrew/bin"
+  };
+}
+
+module.exports = {
+  createConfig,
+  resolveWorkspaceDirectory
+};

package/config/mimeTypes.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const mimeTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain; charset=utf-8"
+};
+
+module.exports = mimeTypes;

package/controllers/boardController.js

@@ -0,0 +1,20 @@
+"use strict";
+
+function createBoardController(boardService) {
+  async function getBoard(_request, response) {
+    response.json(await boardService.loadBoard());
+  }
+
+  async function saveBoard(request, response) {
+    response.json(await boardService.saveBoard(request.body || {}));
+  }
+
+  return {
+    getBoard,
+    saveBoard
+  };
+}
+
+module.exports = {
+  createBoardController
+};

package/controllers/configController.js

@@ -0,0 +1,23 @@
+"use strict";
+
+function createConfigController(config, gitService) {
+  async function getConfig(_request, response) {
+    response.json({
+      boardFile: config.boardFileName,
+      storagePath: config.boardDirName,
+      workspacePath: config.workspaceDir,
+      hasGitRepo: await gitService.hasGitRepository(config.workspaceDir),
+      gitRemote: await gitService.gitRemoteOrigin(config.workspaceDir),
+      gitUserName: await gitService.gitUserName(config.workspaceDir),
+      gitUserEmail: await gitService.gitUserEmail(config.workspaceDir)
+    });
+  }
+
+  return {
+    getConfig
+  };
+}
+
+module.exports = {
+  createConfigController
+};

package/controllers/importController.js

@@ -0,0 +1,34 @@
+"use strict";
+
+function createImportController(boardService, importService) {
+  async function importBoard(request, response) {
+    const currentBoard = await boardService.loadBoard();
+    if ((currentBoard.cards || []).length > 0) {
+      response.status(409).json({ error: "Import is only available when the board has no cards." });
+      return;
+    }
+
+    const importedBoard = await importService.readImportedBoard(request);
+    response.json(await boardService.saveBoard(importedBoard));
+  }
+
+  async function importDemoBoard(_request, response) {
+    const currentBoard = await boardService.loadBoard();
+    if ((currentBoard.cards || []).length > 0) {
+      response.status(409).json({ error: "Demo board can only be loaded when the board has no cards." });
+      return;
+    }
+
+    const demoBoard = await importService.readDemoBoard();
+    response.json(await boardService.saveBoard(demoBoard));
+  }
+
+  return {
+    importBoard,
+    importDemoBoard
+  };
+}
+
+module.exports = {
+  createImportController
+};

package/controllers/syncController.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const { getSyncStatus } = require("../models/syncStatusStore");
+
+function createSyncController(gitSyncService) {
+  return {
+    syncStatus,
+    syncBoard: (request, response) => syncBoard(request, response, gitSyncService)
+  };
+}
+
+function syncStatus(_request, response) {
+  response.json(getSyncStatus());
+}
+
+async function syncBoard(_request, response, gitSyncService) {
+  const status = getSyncStatus();
+  if (status.running) {
+    response.status(409).json({
+      ok: false,
+      output: status.output || "A git sync is already in progress.",
+      startedAt: status.startedAt,
+      finishedAt: status.finishedAt
+    });
+    return;
+  }
+
+  const result = await gitSyncService.syncBoardRepository();
+  response.status(result.ok ? 200 : 500).json(result);
+}
+
+module.exports = {
+  createSyncController,
+  syncStatus
+};

package/controllers/uploadController.js

@@ -0,0 +1,21 @@
+"use strict";
+
+function createUploadController(uploadService) {
+  async function uploadFiles(request, response) {
+    const files = await uploadService.saveUploadedFiles(request);
+    response.json({ files });
+  }
+
+  async function deleteUpload(request, response) {
+    response.json(await uploadService.deleteUploadedFile(request.params.fileName));
+  }
+
+  return {
+    uploadFiles,
+    deleteUpload
+  };
+}
+
+module.exports = {
+  createUploadController
+};

package/middleware/asyncHandler.js

@@ -0,0 +1,11 @@
+"use strict";
+
+function asyncHandler(handler) {
+  return (request, response, next) => {
+    Promise.resolve(handler(request, response, next)).catch(next);
+  };
+}
+
+module.exports = {
+  asyncHandler
+};

package/middleware/errorHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+
+function errorHandler(error, _request, response, _next) {
+  if (response.headersSent) return;
+  response.status(error.statusCode || 500).json({
+    error: error.message || "Unexpected server error."
+  });
+}
+
+module.exports = {
+  errorHandler
+};

package/middleware/notFound.js

@@ -0,0 +1,9 @@
+"use strict";
+
+function notFound(_request, response) {
+  response.status(405).json({ error: "Method not allowed." });
+}
+
+module.exports = {
+  notFound
+};

package/models/boardRepository.js

@@ -0,0 +1,99 @@
+"use strict";
+
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { createHexId } = require("../utils/idUtils");
+const { readJsonFile, writeJsonIfChanged } = require("../utils/fileUtils");
+const { nonEmptyString } = require("../utils/stringUtils");
+
+function createBoardRepository(config) {
+  async function readSplitBoard() {
+    const meta = await readJsonFile(config.boardMetaFilePath, {});
+    return {
+      ...meta,
+      lists: await readJsonCollection("lists"),
+      labels: await readJsonCollection("labels"),
+      members: await readJsonCollection("members"),
+      cards: await readJsonCollection("cards"),
+      checklists: await readJsonCollection("checklists"),
+      actions: await readJsonCollection("actions")
+    };
+  }
+
+  async function writeSplitBoard(board) {
+    await fs.mkdir(config.boardDir, { recursive: true });
+    const {
+      lists,
+      labels,
+      members,
+      cards,
+      checklists,
+      actions,
+      ...meta
+    } = board;
+
+    await writeJsonIfChanged(config.boardMetaFilePath, meta);
+    await writeJsonCollection("lists", lists || []);
+    await writeJsonCollection("labels", labels || []);
+    await writeJsonCollection("members", members || []);
+    await writeJsonCollection("cards", cards || []);
+    await writeJsonCollection("checklists", checklists || []);
+    await writeJsonCollection("actions", actions || []);
+  }
+
+  async function readJsonCollection(name) {
+    const directory = path.join(config.boardDir, name);
+    let entries = [];
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+
+    const items = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      items.push(await readJsonFile(path.join(directory, entry.name), null));
+    }
+    return items.filter(Boolean);
+  }
+
+  async function writeJsonCollection(name, items) {
+    const directory = path.join(config.boardDir, name);
+    await fs.mkdir(directory, { recursive: true });
+    const desiredFiles = new Set();
+
+    for (const item of items) {
+      if (!item || typeof item !== "object") continue;
+      const id = nonEmptyString(item.id) || createHexId();
+      item.id = id;
+      const fileName = `${encodeURIComponent(id)}.json`;
+      desiredFiles.add(fileName);
+      await writeJsonIfChanged(path.join(directory, fileName), item);
+    }
+
+    let entries = [];
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json") && !desiredFiles.has(entry.name)) {
+        await fs.unlink(path.join(directory, entry.name));
+      }
+    }
+  }
+
+  return {
+    readSplitBoard,
+    writeSplitBoard
+  };
+}
+
+module.exports = {
+  createBoardRepository
+};

package/models/syncStatusStore.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const syncStatus = {
+  running: false,
+  startedAt: "",
+  finishedAt: "",
+  ok: null,
+  output: ""
+};
+
+function getSyncStatus() {
+  return { ...syncStatus };
+}
+
+function updateSyncStatus(values) {
+  Object.assign(syncStatus, values);
+  return getSyncStatus();
+}
+
+module.exports = {
+  getSyncStatus,
+  updateSyncStatus
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kanbanqube",
-  "version": "1.0.1",
+  "version": "1.0.8",
   "description": "Local-first Kanban board backed by normal files",
   "license": "Apache-2.0",
   "author": "Mathias Conradt",
@@ -25,6 +25,14 @@
   },
   "files": [
     "server.js",
+    "app.js",
+    "config/",
+    "controllers/",
+    "middleware/",
+    "models/",
+    "routes/",
+    "services/",
+    "utils/",
     "public/",
     "demo_board.json",
     "promo.jpg",
@@ -33,14 +41,18 @@
     "LICENSE"
   ],
   "bin": {
-    "kanbanqube": "./server.js"
+    "kanbanqube": "server.js"
   },
   "scripts": {
     "start": "node server.js",
-    "test": "node --check server.js && node --check --input-type=module < public/app.js",
+    "test": "npm run check:registry && node --check server.js && node --check app.js && find config controllers middleware models routes services utils -name '*.js' -exec node --check {} \\; && node --check --input-type=module < public/app.js",
+    "check:registry": "node -e \"const fs=require('fs'); const lock=fs.readFileSync('package-lock.json','utf8'); if(/repox|jfrog/i.test(lock)){ console.error('package-lock.json must use public npm registry URLs, not local Repox/JFrog URLs.'); process.exit(1); }\"",
     "prepublishOnly": "npm test"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "express": "^5.2.1"
   }
 }

package/public/app.js

@@ -217,11 +217,14 @@ function isBoardEmpty() {
 }
 
 async function loadDemoBoard() {
-  const response = await fetch(DEMO_BOARD_PATH);
+  const response = await fetch("/api/demo-board", {
+    method: "POST"
+  });
+  const payload = await response.json();
   if (!response.ok) {
-    throw new Error("Could not load demo board.");
+    throw new Error(payload.error || "Could not load demo board.");
   }
-  return response.json();
+  return payload;
 }
 
 function wireEvents() {

package/routes/apiRoutes.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const express = require("express");
+const { createBoardController } = require("../controllers/boardController");
+const { createConfigController } = require("../controllers/configController");
+const { createImportController } = require("../controllers/importController");
+const { createSyncController } = require("../controllers/syncController");
+const { createUploadController } = require("../controllers/uploadController");
+const { asyncHandler } = require("../middleware/asyncHandler");
+
+function createApiRoutes(services) {
+  const router = express.Router();
+  const boardController = createBoardController(services.boardService);
+  const configController = createConfigController(services.config, services.gitSyncService.gitService);
+  const importController = createImportController(services.boardService, services.importService);
+  const syncController = createSyncController(services.gitSyncService);
+  const uploadController = createUploadController(services.uploadService);
+
+  router.get("/board", asyncHandler(boardController.getBoard));
+  router.put("/board", asyncHandler(boardController.saveBoard));
+  router.get("/config", asyncHandler(configController.getConfig));
+  router.post("/uploads", asyncHandler(uploadController.uploadFiles));
+  router.delete("/uploads/:fileName", asyncHandler(uploadController.deleteUpload));
+  router.post("/import", asyncHandler(importController.importBoard));
+  router.post("/demo-board", asyncHandler(importController.importDemoBoard));
+  router.post("/sync", asyncHandler(syncController.syncBoard));
+  router.get("/sync-status", syncController.syncStatus);
+
+  return router;
+}
+
+module.exports = {
+  createApiRoutes
+};