axiodb 22.2.2 → 22.4.2

package/electron/src/store/dbStore.js

@@ -0,0 +1,165 @@
+import { create } from "zustand";
+import apiClient from "../api/client";
+
+export const useDbStore = create((set, get) => ({
+  databases: [],
+  collectionsMap: {}, // { [dbName]: [ { name, count, size } ] }
+  expandedDbs: {}, // { [dbName]: boolean }
+  selectedDatabase: "",
+  selectedCollection: "",
+  activeTab: "documents", // 'documents' | 'query'
+  loadingTree: false,
+  treeError: null,
+
+  setSelectedDatabase: (dbName) => {
+    set({ selectedDatabase: dbName, selectedCollection: "" });
+    if (dbName && !get().collectionsMap[dbName]) {
+      get().fetchCollections(dbName);
+    }
+  },
+
+  setSelectedCollection: (dbName, collName) => {
+    set({
+      selectedDatabase: dbName,
+      selectedCollection: collName,
+      expandedDbs: { ...get().expandedDbs, [dbName]: true },
+    });
+  },
+
+  setActiveTab: (tab) => set({ activeTab: tab }),
+
+  toggleDbExpanded: (dbName) => {
+    const isCurrentlyExpanded = !!get().expandedDbs[dbName];
+    set({
+      expandedDbs: {
+        ...get().expandedDbs,
+        [dbName]: !isCurrentlyExpanded,
+      },
+    });
+
+    if (!isCurrentlyExpanded && !get().collectionsMap[dbName]) {
+      get().fetchCollections(dbName);
+    }
+  },
+
+  fetchDatabases: async () => {
+    try {
+      set({ loadingTree: true, treeError: null });
+      const res = await apiClient.get("/api/db/databases");
+      const data = res.data?.data || {};
+      const list = Array.isArray(data.ListOfDatabases) ? data.ListOfDatabases : [];
+      set({ databases: list, loadingTree: false });
+
+      // Automatically select and expand first database if none selected
+      if (list.length > 0 && !get().selectedDatabase) {
+        const firstDb = list[0];
+        set({
+          selectedDatabase: firstDb,
+          expandedDbs: { [firstDb]: true },
+        });
+        get().fetchCollections(firstDb);
+      }
+      return list;
+    } catch (err) {
+      console.error("Failed to load databases:", err);
+      set({
+        loadingTree: false,
+        treeError: err.response?.data?.message || "Failed to load databases",
+      });
+      return [];
+    }
+  },
+
+  fetchCollections: async (dbName) => {
+    if (!dbName) return [];
+    try {
+      const res = await apiClient.get(`/api/collection/all/?databaseName=${encodeURIComponent(dbName)}`);
+      const data = res.data?.data || {};
+      const list = Array.isArray(data.ListOfCollections) ? data.ListOfCollections : [];
+      const metaStatus = Array.isArray(data.collectionMetaStatus) ? data.collectionMetaStatus : [];
+      const sizeMap = Array.isArray(data.CollectionSizeMap) ? data.CollectionSizeMap : [];
+
+      const formatted = list.map((collName) => {
+        const meta = metaStatus.find((m) => m.name === collName) || {};
+        const sizeEntry = sizeMap.find((s) => s.folderPath?.endsWith(`/${collName}`)) || {};
+        return {
+          name: collName,
+          count: meta.totalDocuments ?? meta.count ?? 0,
+          size: sizeEntry.size ?? meta.size ?? 0,
+        };
+      });
+
+      set({
+        collectionsMap: {
+          ...get().collectionsMap,
+          [dbName]: formatted,
+        },
+      });
+
+      // If this is the active database and no collection is selected yet, select first collection
+      if (get().selectedDatabase === dbName && !get().selectedCollection && formatted.length > 0) {
+        set({ selectedCollection: formatted[0].name });
+      }
+
+      return formatted;
+    } catch (err) {
+      console.error(`Failed to fetch collections for ${dbName}:`, err);
+      set({
+        collectionsMap: {
+          ...get().collectionsMap,
+          [dbName]: [],
+        },
+      });
+      return [];
+    }
+  },
+
+  addDatabaseLocally: (dbName) => {
+    const list = Array.from(new Set([...get().databases, dbName]));
+    set({
+      databases: list,
+      selectedDatabase: dbName,
+      selectedCollection: "",
+      expandedDbs: { ...get().expandedDbs, [dbName]: true },
+      collectionsMap: { ...get().collectionsMap, [dbName]: [] },
+    });
+  },
+
+  removeDatabaseLocally: (dbName) => {
+    const updated = get().databases.filter((d) => d !== dbName);
+    const newCollectionsMap = { ...get().collectionsMap };
+    delete newCollectionsMap[dbName];
+
+    set({
+      databases: updated,
+      collectionsMap: newCollectionsMap,
+      selectedDatabase: updated[0] || "",
+      selectedCollection: "",
+    });
+  },
+
+  addCollectionLocally: (dbName, collName) => {
+    const current = get().collectionsMap[dbName] || [];
+    const updated = [...current.filter((c) => c.name !== collName), { name: collName, count: 0, size: 0 }];
+    set({
+      collectionsMap: {
+        ...get().collectionsMap,
+        [dbName]: updated,
+      },
+      selectedDatabase: dbName,
+      selectedCollection: collName,
+    });
+  },
+
+  removeCollectionLocally: (dbName, collName) => {
+    const current = get().collectionsMap[dbName] || [];
+    const updated = current.filter((c) => c.name !== collName);
+    set({
+      collectionsMap: {
+        ...get().collectionsMap,
+        [dbName]: updated,
+      },
+      selectedCollection: updated[0]?.name || "",
+    });
+  },
+}));

package/electron/src/store/store.js

@@ -0,0 +1,8 @@
+import { create } from "zustand";
+
+const DBInfoStore = create((set) => ({
+  Rootname: "AxioDB",
+  setRootname: (name) => set({ Rootname: name }),
+}));
+
+export { DBInfoStore };

package/electron/src/utils/format.js

@@ -0,0 +1,39 @@
+export function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0 || !bytes) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+
+export function formatStorage(val, unit = "MB") {
+  if (val === undefined || val === null) return "0 MB";
+  if (typeof val === "number") {
+    return `${val.toLocaleString()} ${unit}`;
+  }
+  return `${val} ${unit}`;
+}
+
+export function formatUptime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "—";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${secs}s`;
+  return `${secs}s`;
+}
+
+export function formatDate(dateString) {
+  if (!dateString) return "—";
+  try {
+    const date = new Date(dateString);
+    return date.toLocaleString();
+  } catch {
+    return String(dateString);
+  }
+}

package/electron/vite.config.js

@@ -0,0 +1,28 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react-swc";
+import tailwindcss from "@tailwindcss/vite";
+import path from "path";
+
+export default defineConfig({
+  plugins: [
+    tailwindcss(),
+    react()
+  ],
+  base: "./",
+  root: "./src",
+  publicDir: "../public",
+  build: {
+    outDir: "../dist",
+    emptyOutDir: true,
+    sourcemap: false
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src")
+    }
+  },
+  server: {
+    port: 5173,
+    strictPort: true
+  }
+});

package/lib/Services/Indexation.operation.js

@@ -125,7 +125,7 @@ class AxioDB {
                     Logger_helper_1.default.info(`AxioDB folder created at: ${this.currentPATH}`);
                 }
             }
-            if (this.GUI || (this.TCP && this.TCPAuth)) {
+            if (this.GUI || this.HTTP || (this.TCP && this.TCPAuth)) {
                 yield new AuthSeeder_service_1.default(this).seedIfNeeded();
                 LoginRateLimiter_service_1.default.startCleanupSweep();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axiodb",
-  "version": "22.2.2",
+  "version": "22.4.2",
   "description": "The embedded database for Node.js. Replaces SQLite, LowDB, NeDB & raw JSON files with MongoDB-style queries, ACID transactions, zero native dependencies, and built-in InMemoryCache. No compilation, no platform issues. Perfect for desktop apps, CLI tools, and embedded systems.",
   "main": "./lib/config/DB.js",
   "types": "./lib/config/DB.d.ts",