@lobb-js/lobb-ext-storage 0.14.0 → 0.15.0

package/dist/index.js

@@ -18,6 +18,7 @@ export default function extension(utils) {
                     href: "/studio/extensions/storage/file_manager",
                     icon: utils.components.Icons.Folders,
                     label: "File Manager",
+                    represents: "storage_fs"
                 },
             ],
         },

package/dist/lib/components/explorerNotSupported.svelte

@@ -2,7 +2,7 @@
   import { FolderX } from "lucide-svelte";
 </script>
 
-<div class="border rounded-md p-4 bg-muted-soft flex items-center flex-col text-muted-foreground gap-2">
+<div class="border rounded-md p-4 bg-muted flex items-center flex-col text-muted-foreground gap-2">
     <FolderX size={35} />
     <div class="flex flex-col justify-center items-center">
         <div class="text-sm font-bold">Storage file system is not supported here</div>

package/dist/lib/components/fileExplorer.svelte

@@ -189,7 +189,7 @@
 <div class="flex h-full w-full flex-col bg-background {className}">
     <!-- file explorer header -->
     <div
-        class="flex h-10 items-center justify-between border-b px-2"
+        class="flex h-12 items-center justify-between border-b px-2"
     >
         <div class="flex items-center justify-between gap-2">
             {@render topLeftHeader?.()}
@@ -199,14 +199,14 @@
             <!-- entries view toggle -->
             <Button
                 variant="outline"
-                class="h-7 px-3 text-xs font-normal"
+                size="sm"
                 Icon={icons.FolderPlus}
                 onclick={handleCreateFolder}
             >
                 New folder
             </Button>
             <Button
-                class="h-7 px-3 text-xs font-normal"
+                size="sm"
                 Icon={icons.FilePlus}
                 onclick={() => { handleFileUpload() }}
             >
@@ -215,7 +215,7 @@
         </div>
     </div>
     <!-- file explorer body -->
-    <div class="flex flex-1 overflow-auto h-[calc(100vh-7.5rem)]">
+    <div class="flex flex-1 overflow-auto h-[calc(100vh-8rem)]">
         <ContextMenu.Root bind:open={contextMenuOpen}>
             <ContextMenu.Trigger
                 class="z-10 flex flex-1 flex-wrap content-start items-start justify-start gap-4 p-4"

package/dist/lib/components/foreignKeyComponent.svelte

@@ -28,7 +28,7 @@
     }
 </script>
 
-<button onclick={handleClick} class="flex flex-col items-center gap-2 w-full border p-4 rounded-md bg-muted-soft">
+<button onclick={handleClick} class="flex flex-col items-center gap-2 w-full border p-4 rounded-md bg-muted">
     {#if value}
         <FileIcon entry={value} {utils} />
     {:else}

package/extensions/storage/collections/fileSystem.ts

@@ -16,6 +16,20 @@ export function getFileSystemCollection(config: ExtensionConfig): CollectionConf
         "length": 255,
         "required": true,
       },
+      // Source of truth for the hierarchy. null = root entry.
+      // The directory itself is referenced; deleting a directory cascades
+      // through the storage service (see services.ts) so the FK doesn't need
+      // to model ON DELETE — the service handles it.
+      "parent_id": {
+        "type": "integer",
+        "references": {
+          "collection": "storage_fs",
+          "field": "id",
+        },
+      },
+      // Derived cache, NOT the source of truth. Maintained on every write by
+      // the storage service so subtree queries and breadcrumbs stay O(1).
+      // Invariant: path === parent.path + parent.name + "/" (or "/" at root).
       "path": {
         "type": "string",
         "length": 255,

package/extensions/storage/migrations.ts

@@ -1,3 +1,67 @@
-import type { MigrationProps, Migrations } from "@lobb-js/core";
+import type { Migrations } from "@lobb-js/core";
+import { Lobb } from "@lobb-js/core";
 
-export const migrations: Migrations = {};
+/**
+ * Backfill `parent_id` for any row in storage_fs that still has it null.
+ * Resolves the parent by walking the existing `path` string and matching
+ * the (parent_path, name) of every directory record. Idempotent — running
+ * it twice is safe; rows that already have parent_id are skipped.
+ */
+export async function backfillStorageFsParentId(lobb: Lobb): Promise<void> {
+  const rows = (await lobb.collectionService.findAll({
+    collectionName: "storage_fs",
+    params: { limit: 1000000 },
+  })).data;
+  if (rows.length === 0) return;
+
+  // Index every directory by (path, name) so we can resolve any child's
+  // parent in one lookup. This is the same key that resolveParentIdFromPath
+  // walks at runtime, just precomputed.
+  const dirByKey = new Map<string, number>();
+  for (const r of rows as any[]) {
+    if (r.type === "directory") {
+      dirByKey.set(`${r.path}::${r.name}`, r.id);
+    }
+  }
+
+  function parentIdFor(row: any): number | null {
+    const path: string = row.path ?? "/";
+    if (path === "/" || path === "") return null;
+    const segments = path.split("/").filter(Boolean);
+    if (segments.length === 0) return null;
+    const lastName = segments[segments.length - 1];
+    // No-trailing-slash convention: root is "/", deeper levels are
+    // "/foo" or "/foo/bar". Older data may have either form; this
+    // resolves only the normalized one. Loose-format rows get retried
+    // on the next pass.
+    const parentDirPath =
+      segments.length > 1 ? "/" + segments.slice(0, -1).join("/") : "/";
+    const key = `${parentDirPath}::${lastName}`;
+    return dirByKey.get(key) ?? null;
+  }
+
+  for (const row of rows as any[]) {
+    if (row.parent_id != null) continue;
+    const pid = parentIdFor(row);
+    if (pid != null) {
+      await lobb.collectionStore.updateOne({
+        collectionName: "storage_fs",
+        id: row.id,
+        data: { parent_id: pid },
+      });
+    }
+  }
+}
+
+export const migrations: Migrations = {
+  // The storage_fs schema gained `parent_id` (FK → storage_fs.id). It is now
+  // the source of truth for the hierarchy; `path` is a derived cache. For
+  // existing rows, walk the old path strings and stamp each row's parent_id
+  // with the directory that already represents its parent path. Rows whose
+  // path is "/" stay at parent_id = null (root entries).
+  "backfill_storage_fs_parent_id": {
+    up: async () => {
+      await backfillStorageFsParentId(Lobb.instance);
+    },
+  },
+};

package/extensions/storage/studio/index.ts

@@ -21,6 +21,7 @@ export default function extension(utils: ExtensionUtils): Extension {
           href: "/studio/extensions/storage/file_manager",
           icon: utils.components.Icons.Folders,
           label: "File Manager",
+          represents: "storage_fs"
         },
       ],
     },

package/extensions/storage/studio/lib/components/explorerNotSupported.svelte

@@ -2,7 +2,7 @@
   import { FolderX } from "lucide-svelte";
 </script>
 
-<div class="border rounded-md p-4 bg-muted-soft flex items-center flex-col text-muted-foreground gap-2">
+<div class="border rounded-md p-4 bg-muted flex items-center flex-col text-muted-foreground gap-2">
     <FolderX size={35} />
     <div class="flex flex-col justify-center items-center">
         <div class="text-sm font-bold">Storage file system is not supported here</div>

package/extensions/storage/studio/lib/components/fileExplorer.svelte

@@ -189,7 +189,7 @@
 <div class="flex h-full w-full flex-col bg-background {className}">
     <!-- file explorer header -->
     <div
-        class="flex h-10 items-center justify-between border-b px-2"
+        class="flex h-12 items-center justify-between border-b px-2"
     >
         <div class="flex items-center justify-between gap-2">
             {@render topLeftHeader?.()}
@@ -199,14 +199,14 @@
             <!-- entries view toggle -->
             <Button
                 variant="outline"
-                class="h-7 px-3 text-xs font-normal"
+                size="sm"
                 Icon={icons.FolderPlus}
                 onclick={handleCreateFolder}
             >
                 New folder
             </Button>
             <Button
-                class="h-7 px-3 text-xs font-normal"
+                size="sm"
                 Icon={icons.FilePlus}
                 onclick={() => { handleFileUpload() }}
             >
@@ -215,7 +215,7 @@
         </div>
     </div>
     <!-- file explorer body -->
-    <div class="flex flex-1 overflow-auto h-[calc(100vh-7.5rem)]">
+    <div class="flex flex-1 overflow-auto h-[calc(100vh-8rem)]">
         <ContextMenu.Root bind:open={contextMenuOpen}>
             <ContextMenu.Trigger
                 class="z-10 flex flex-1 flex-wrap content-start items-start justify-start gap-4 p-4"

package/extensions/storage/studio/lib/components/foreignKeyComponent.svelte

@@ -28,7 +28,7 @@
     }
 </script>
 
-<button onclick={handleClick} class="flex flex-col items-center gap-2 w-full border p-4 rounded-md bg-muted-soft">
+<button onclick={handleClick} class="flex flex-col items-center gap-2 w-full border p-4 rounded-md bg-muted">
     {#if value}
         <FileIcon entry={value} {utils} />
     {:else}

package/extensions/storage/types.ts

@@ -1,7 +1,7 @@
 import type { ExposedServiceOutput, ServiceOp } from "@lobb-js/core";
 
 export type StorageFsCreateOne = ServiceOp<
-  { file: File; data?: { path?: string }; force?: boolean },
+  { file: File; data?: { path?: string; parent_id?: number | null }; force?: boolean },
   ExposedServiceOutput
 >;
 

package/extensions/storage/utils.ts

@@ -1,6 +1,5 @@
 import type { Context } from "hono";
 import type { Lobb } from "@lobb-js/core";
-import { StorageAdapter } from "./adapters/index.ts";
 import { LobbError } from "@lobb-js/core";
 
 export async function getFileFromRequestBody(
@@ -18,18 +17,49 @@ export async function getFileFromRequestBody(
   return undefined;
 }
 
-export async function validatePathExists(path: string, lobb: Lobb) {
-  const pathArray = path.split("/").filter(Boolean);
-  if (pathArray.length > 0) {
-    const directoryName = pathArray[pathArray.length - 1];
-    pathArray.pop();
-    const directoryPath = "/" + pathArray.join("/");
+// ── parent_id / path helpers ──────────────────────────────────────────────
+//
+// The storage_fs table uses parent_id as the source of truth for the
+// hierarchy. `path` is a derived cache, maintained by the service layer on
+// every write so subtree queries and breadcrumbs stay O(1). These helpers
+// keep both sides in sync — see services.ts for the actual write paths.
+//
+// `path` is the directory the entry lives in (e.g. "/imports/risks/" for a
+// file named "out.csv" placed inside /imports/risks/). The entry's own name
+// is NOT appended to its `path` — that matches the existing convention used
+// by every test in the suite.
+
+// Path convention: root is "/", every other directory is "/foo" or
+// "/foo/bar" (no trailing slash). The `path` column stores the parent
+// directory's full path — so an entry at the root has path "/", and an
+// entry inside /foo has path "/foo".
+function buildPath(segments: string[]): string {
+  return segments.length === 0 ? "/" : "/" + segments.join("/");
+}
+
+/**
+ * Resolve a directory path string to the id of the record representing it.
+ * Returns null for "/" (root). Throws BAD_REQUEST if any segment of the
+ * path doesn't exist.
+ */
+export async function resolveParentIdFromPath(
+  path: string,
+  lobb: Lobb,
+): Promise<number | null> {
+  const segments = (path ?? "/").split("/").filter(Boolean);
+  if (segments.length === 0) return null;
+
+  let parentId: number | null = null;
+  const walked: string[] = [];
+  for (const segment of segments) {
+    const parentPath = buildPath(walked);
     const directory = (await lobb.collectionStore.findAll({
       collectionName: "storage_fs",
       params: {
         filter: {
-          name: directoryName,
-          path: directoryPath,
+          name: segment,
+          path: parentPath,
+          type: "directory",
         },
       },
     })).data[0];
@@ -40,48 +70,112 @@ export async function validatePathExists(path: string, lobb: Lobb) {
         message: `The specified path does not exist. Please create it first.`,
       });
     }
+
+    parentId = directory.id;
+    walked.push(segment);
   }
+
+  return parentId;
 }
 
 /**
- * Ensures a directory path exists, creating it if necessary
+ * Like resolveParentIdFromPath, but creates any missing directories along
+ * the way (used by force=true uploads).
  */
-export async function ensurePathExists(path: string, lobb: Lobb): Promise<void> {
-  if (!path || path === "/") {
-    return; // Root always exists
-  }
+export async function ensureParentIdForPath(
+  path: string,
+  lobb: Lobb,
+): Promise<number | null> {
+  const segments = (path ?? "/").split("/").filter(Boolean);
+  if (segments.length === 0) return null;
 
-  // Parse the path into segments
-  const pathArray = path.split("/").filter(Boolean);
-
-  // Check and create each directory in the path
-  let currentPath = "/";
-  for (const dirName of pathArray) {
-    // Check if this directory exists
+  let parentId: number | null = null;
+  const walked: string[] = [];
+  for (const segment of segments) {
+    const parentPath = buildPath(walked);
     const existing = (await lobb.collectionStore.findAll({
       collectionName: "storage_fs",
       params: {
         filter: {
-          name: dirName,
-          path: currentPath,
+          name: segment,
+          path: parentPath,
           type: "directory",
         },
       },
-    })).data;
+    })).data[0];
 
-    // Create the directory if it doesn't exist
-    if (existing.length === 0) {
-      await lobb.collectionStore.createOne({
+    if (existing) {
+      parentId = existing.id;
+    } else {
+      const created = await lobb.collectionStore.createOne({
         collectionName: "storage_fs",
         data: {
-          name: dirName,
-          path: currentPath,
+          name: segment,
+          path: parentPath,
+          parent_id: parentId,
           type: "directory",
         },
       });
+      parentId = created.data.id;
+    }
+    walked.push(segment);
+  }
+
+  return parentId;
+}
+
+/**
+ * Compute the path string for an entry whose parent is `parentId`. Walks up
+ * the parent chain to the root. Used on insert and whenever a record's
+ * parent_id changes.
+ */
+export async function computePathForParent(
+  parentId: number | null,
+  lobb: Lobb,
+): Promise<string> {
+  if (parentId == null) return "/";
+
+  const segments: string[] = [];
+  let currentId: number | null = parentId;
+  // Defensive depth cap — guards against accidental cycles. Real hierarchies
+  // don't get this deep; if we somehow do, throw rather than infinite-loop.
+  for (let depth = 0; depth < 1024; depth++) {
+    if (currentId == null) break;
+    const row: any = (await lobb.collectionStore.findOne({
+      collectionName: "storage_fs",
+      id: String(currentId),
+    })).data;
+    if (!row) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `Parent directory ${currentId} not found.`,
+      });
     }
+    segments.unshift(row.name);
+    currentId = row.parent_id ?? null;
+  }
+  return buildPath(segments);
+}
 
-    // Update current path for next iteration
-    currentPath = currentPath + dirName + "/";
+/**
+ * Return every descendant of `parentId`, breadth-first. Used by cascading
+ * deletes and by rename/move to recompute paths for the whole subtree in
+ * one pass.
+ */
+export async function findDescendants(
+  parentId: number,
+  lobb: Lobb,
+): Promise<any[]> {
+  const out: any[] = [];
+  let frontier: number[] = [parentId];
+  while (frontier.length > 0) {
+    const children = (await lobb.collectionStore.findAll({
+      collectionName: "storage_fs",
+      params: { filter: { parent_id: { $in: frontier } } },
+    })).data;
+    if (children.length === 0) break;
+    out.push(...children);
+    frontier = children.map((c: any) => c.id);
   }
+  return out;
 }