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

package/extensions/storage/workflows/services.ts

@@ -1,7 +1,22 @@
 import type { Workflow } from "@lobb-js/core";
+import { LobbError } from "@lobb-js/core";
 import type { ExtensionConfig } from "../config/extensionConfigSchema.ts";
 import { initStorageAdapter } from "../adapters/index.ts";
-import { validatePathExists, ensurePathExists } from "../utils.ts";
+import {
+  computePathForParent,
+  ensureParentIdForPath,
+  findDescendants,
+  resolveParentIdFromPath,
+} from "../utils.ts";
+
+// All writes funnel through these service overrides so the invariant
+// `path === parent.path + parent.name + "/"` is maintained on every change.
+// Reads stay free — both `parent_id` and `path` are on the row.
+//
+// `parent_id` is the source of truth for the hierarchy; `path` is a cached
+// view used for fast subtree queries and breadcrumbs. Callers may pass
+// either (or both) to create/update — we resolve to parent_id and recompute
+// path from the tree.
 
 export function getServicesWorkflows(extensionConfig: ExtensionConfig): Workflow[] {
   return [
@@ -29,153 +44,263 @@ export function getServicesWorkflows(extensionConfig: ExtensionConfig): Workflow
       name: "storageCreateOneServiceOverride",
       eventName: "core.service.createOne.override",
       handler: async (input, ctx) => {
-        if (input.collectionName === "storage_fs") {
-          if (input.file) {
-            const filePath = input.data?.path ?? "/";
+        if (input.collectionName !== "storage_fs") return;
 
-            if (input.force) {
-              await ensurePathExists(filePath, ctx.lobb);
-            } else if (filePath !== "/") {
-              await validatePathExists(filePath, ctx.lobb);
-            }
+        const raw = input.data ?? {};
+        const explicitParentId = raw.parent_id ?? null;
+        const pathInput: string = raw.path ?? "/";
 
-            const { path: _path, name: _name, type: _type, file_mime_type: _mime, file_size: _size, ...extraData } = input.data ?? {};
+        // Resolve parent_id: explicit wins, else derive from the path.
+        // `force` (uploads) creates missing directories along the way.
+        const parentId = explicitParentId != null
+          ? Number(explicitParentId)
+          : input.force
+            ? await ensureParentIdForPath(pathInput, ctx.lobb)
+            : await resolveParentIdFromPath(pathInput, ctx.lobb);
 
-            const result = await ctx.lobb.collectionStore.createOne({
-              collectionName: "storage_fs",
-              data: {
-                ...extraData,
-                name: input.file.name,
-                path: filePath,
-                type: "file",
-                file_mime_type: input.file.type,
-                file_size: input.file.size,
-              },
-            });
+        const cachedPath = await computePathForParent(parentId, ctx.lobb);
 
-            const adapter = initStorageAdapter(extensionConfig);
-            await adapter.createFile(result.data.id, input.file);
+        const {
+          path: _path,
+          parent_id: _pid,
+          name: _name,
+          type: _type,
+          file_mime_type: _mime,
+          file_size: _size,
+          ...extraData
+        } = raw;
 
-            return result;
-          } else {
-            if (input.data?.path) {
-              await validatePathExists(input.data.path, ctx.lobb);
-            }
-          }
+        if (input.file) {
+          const result = await ctx.lobb.collectionStore.createOne({
+            collectionName: "storage_fs",
+            data: {
+              ...extraData,
+              name: input.file.name,
+              parent_id: parentId,
+              path: cachedPath,
+              type: "file",
+              file_mime_type: input.file.type,
+              file_size: input.file.size,
+            },
+          });
+
+          const adapter = initStorageAdapter(extensionConfig);
+          await adapter.createFile(result.data.id, input.file);
+          return result;
         }
+
+        // Non-file writes (directories or pure metadata records) — let the
+        // generic store handle it after we stamp parent_id + path.
+        return await ctx.lobb.collectionStore.createOne({
+          collectionName: "storage_fs",
+          data: {
+            ...extraData,
+            name: raw.name,
+            parent_id: parentId,
+            path: cachedPath,
+            type: raw.type ?? "directory",
+            ...(raw.icon !== undefined ? { icon: raw.icon } : {}),
+            ...(raw.is_pinned_sidebar !== undefined ? { is_pinned_sidebar: raw.is_pinned_sidebar } : {}),
+          },
+        });
       },
     },
     {
       name: "storageDeleteOneService",
       eventName: "core.service.deleteOne.override",
       handler: async (input, ctx) => {
-        if (input.collectionName === "storage_fs") {
-          const entry = (await ctx.lobb.collectionStore.findOne({
+        if (input.collectionName !== "storage_fs") return;
+
+        const entry = (await ctx.lobb.collectionStore.findOne({
+          collectionName: "storage_fs",
+          id: input.id,
+        })).data;
+        if (!entry) {
+          return ctx.lobb.collectionStore.deleteOne({
             collectionName: "storage_fs",
             id: input.id,
-          })).data;
+          });
+        }
 
-          const adapter = initStorageAdapter(extensionConfig);
-          if (entry.type === "file") {
-            await adapter.removeFile(entry.id);
-          } else if (entry.type === "directory") {
-            const directoryPath = entry.path + entry.name;
+        const adapter = initStorageAdapter(extensionConfig);
 
-            const entries = (await ctx.lobb.collectionService.findAll({
-              collectionName: "storage_fs",
-              params: {
-                filter: {
-                  path: {
-                    $starts_with: directoryPath,
-                  },
-                },
-              },
-            })).data;
-
-            for (let index = 0; index < entries.length; index++) {
-              const entry = entries[index];
-              if (entry.type === "file") {
-                await adapter.removeFile(entry.id);
-              }
+        if (entry.type === "file") {
+          await adapter.removeFile(entry.id);
+        } else if (entry.type === "directory") {
+          // Cascade leaf-first so each deleted row has no remaining children
+          // referencing it — Lobb's core FK-children check would otherwise
+          // block the delete. findDescendants returns BFS (shallow → deep);
+          // reverse to walk deep → shallow.
+          const descendants = await findDescendants(entry.id, ctx.lobb);
+          for (const d of [...descendants].reverse()) {
+            if (d.type === "file") {
+              await adapter.removeFile(d.id);
             }
-
-            await ctx.lobb.collectionStore.deleteMany({
+            await ctx.lobb.collectionStore.deleteOne({
               collectionName: "storage_fs",
-              filter: {
-                path: {
-                  $starts_with: directoryPath,
-                },
-              },
+              id: String(d.id),
             });
           }
-
-          return ctx.lobb.collectionStore.deleteOne({
-            collectionName: "storage_fs",
-            id: input.id,
-          });
         }
+
+        return ctx.lobb.collectionStore.deleteOne({
+          collectionName: "storage_fs",
+          id: input.id,
+        });
       },
     },
     {
       name: "storageDeleteManyService",
       eventName: "core.service.deleteMany.override",
       handler: async (input, ctx) => {
-        if (input.collectionName === "storage_fs") {
-          const matchedEntries = (await ctx.lobb.collectionStore.findAll({
-            collectionName: "storage_fs",
-            params: { filter: input.filter },
-          })).data;
+        if (input.collectionName !== "storage_fs") return;
 
-          const adapter = initStorageAdapter(extensionConfig);
-
-          for (const entry of matchedEntries) {
-            if (entry.type === "directory") {
-              const directoryPath = entry.path + entry.name;
-
-              const nestedEntries = (await ctx.lobb.collectionStore.findAll({
-                collectionName: "storage_fs",
-                params: {
-                  filter: { path: { $starts_with: directoryPath } },
-                },
-              })).data;
+        const matched = (await ctx.lobb.collectionStore.findAll({
+          collectionName: "storage_fs",
+          params: { filter: input.filter },
+        })).data;
 
-              for (const nested of nestedEntries) {
-                if (nested.type === "file") {
-                  await adapter.removeFile(nested.id);
-                }
-              }
-
-              await ctx.lobb.collectionStore.deleteMany({
-                collectionName: "storage_fs",
-                filter: { path: { $starts_with: directoryPath } },
-              });
-            } else if (entry.type === "file") {
-              await adapter.removeFile(entry.id);
+        const adapter = initStorageAdapter(extensionConfig);
+        // Collect every row to remove, BFS shallow→deep. We delete in
+        // reverse order so leaves are dropped before their parents — that
+        // keeps Lobb's children FK check happy.
+        const ordered: any[] = [];
+        const seen = new Set<number>();
+        for (const entry of matched) {
+          if (seen.has(entry.id)) continue;
+          seen.add(entry.id);
+          ordered.push(entry);
+          if (entry.type === "directory") {
+            for (const d of await findDescendants(entry.id, ctx.lobb)) {
+              if (seen.has(d.id)) continue;
+              seen.add(d.id);
+              ordered.push(d);
             }
           }
+        }
 
-          return ctx.lobb.collectionStore.deleteMany({
+        for (const row of [...ordered].reverse()) {
+          if (row.type === "file") await adapter.removeFile(row.id);
+          await ctx.lobb.collectionStore.deleteOne({
             collectionName: "storage_fs",
-            filter: input.filter,
+            id: String(row.id),
           });
         }
+
+        // affectedCount reflects what the caller asked to delete (the
+        // matched rows). Cascaded descendants are an implementation detail.
+        return { affectedCount: matched.length };
       },
     },
     {
       name: "storageUpdateOneService",
       eventName: "core.service.updateOne.override",
       handler: async (input, ctx) => {
-        if (input.collectionName === "storage_fs") {
-          if (input.data.path) {
-            await validatePathExists(input.data.path, ctx.lobb);
-          }
+        if (input.collectionName !== "storage_fs") return;
 
+        const current = (await ctx.lobb.collectionStore.findOne({
+          collectionName: "storage_fs",
+          id: input.id,
+        })).data;
+        if (!current) {
           return ctx.lobb.collectionStore.updateOne({
             collectionName: "storage_fs",
             id: input.id,
             data: input.data,
           });
         }
+
+        const data: any = { ...input.data };
+
+        // Translate any path-based reparenting into a parent_id update so
+        // the rest of this handler has a single canonical signal to work
+        // with. Explicit parent_id wins if both are present.
+        if (data.path != null && data.parent_id == null) {
+          data.parent_id = await resolveParentIdFromPath(data.path, ctx.lobb);
+        }
+        // The path field is derived — never let a caller overwrite it raw.
+        delete data.path;
+
+        // If the row's location in the tree is changing (name or parent),
+        // recompute its own path and cascade the change to every descendant.
+        const nameChanged = data.name != null && data.name !== current.name;
+        const parentChanged =
+          Object.prototype.hasOwnProperty.call(data, "parent_id") &&
+          (data.parent_id ?? null) !== (current.parent_id ?? null);
+
+        if (nameChanged || parentChanged) {
+          const newParentId = parentChanged ? (data.parent_id ?? null) : current.parent_id;
+          const newName = nameChanged ? data.name : current.name;
+
+          // Cycle prevention: the new parent must not be the row itself,
+          // and walking up from it must never hit the row's own id.
+          if (parentChanged && newParentId != null) {
+            if (Number(newParentId) === Number(input.id)) {
+              throw new LobbError({
+                code: "BAD_REQUEST",
+                message: "A directory cannot be its own parent.",
+              });
+            }
+            let cur: number | null = Number(newParentId);
+            while (cur != null) {
+              if (cur === Number(input.id)) {
+                throw new LobbError({
+                  code: "BAD_REQUEST",
+                  message: "Cannot move a directory into one of its own descendants.",
+                });
+              }
+              const row: any = (await ctx.lobb.collectionStore.findOne({
+                collectionName: "storage_fs",
+                id: String(cur),
+              })).data;
+              if (!row) break;
+              cur = row.parent_id ?? null;
+            }
+          }
+
+          const newSelfPath = await computePathForParent(newParentId, ctx.lobb);
+
+          const result = await ctx.lobb.collectionStore.updateOne({
+            collectionName: "storage_fs",
+            id: input.id,
+            data: { ...data, path: newSelfPath },
+          });
+
+          // Cascade: for a directory, every descendant's `path` is anchored
+          // to this row's name + its own path. Recompute by walking the
+          // tree once in memory — no DB round trip per descendant.
+          if (current.type === "directory") {
+            const descendants = await findDescendants(Number(input.id), ctx.lobb);
+            const byId = new Map<number, any>();
+            for (const d of descendants) byId.set(d.id, d);
+            // The directory's OWN full path (= its parent's path + its name)
+            // is what every direct child stores in `path`.
+            const newDirFullPath = newSelfPath === "/" ? "/" + newName : newSelfPath + "/" + newName;
+            const pathOf = (id: number | null): string => {
+              if (id == null) return "/";
+              if (id === Number(input.id)) return newDirFullPath;
+              const r = byId.get(id);
+              if (!r) return "/";
+              const parentFull = pathOf(r.parent_id ?? null);
+              return parentFull === "/" ? "/" + r.name : parentFull + "/" + r.name;
+            };
+            for (const d of descendants) {
+              await ctx.lobb.collectionStore.updateOne({
+                collectionName: "storage_fs",
+                id: String(d.id),
+                data: { path: pathOf(d.parent_id ?? null) },
+              });
+            }
+          }
+
+          return result;
+        }
+
+        return ctx.lobb.collectionStore.updateOne({
+          collectionName: "storage_fs",
+          id: input.id,
+          data,
+        });
       },
     },
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobb-js/lobb-ext-storage",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "license": "UNLICENSED",
   "type": "module",
   "publishConfig": {
@@ -18,8 +18,8 @@
     }
   },
   "scripts": {
-    "test": "bun test extensions/storage/tests",
-    "test:lobb": "bun test extensions/storage/tests",
+    "test": "bun test tests",
+    "test:lobb": "bun test tests",
     "dev": "bun run --watch lobb.ts",
     "dev:studio": "vite dev",
     "build": "vite build",
@@ -32,14 +32,14 @@
     "package": "svelte-package --input extensions/storage/studio"
   },
   "dependencies": {
-    "@lobb-js/core": "^0.32.1",
+    "@lobb-js/core": "^0.38.1",
     "browser-fs-access": "^0.35.0",
     "hono": "^4.7.0",
     "openapi-types": "^12.1.3",
     "path-browserify": "^1.0.1"
   },
   "devDependencies": {
-    "@lobb-js/studio": "^0.29.1",
+    "@lobb-js/studio": "^0.44.1",
     "@lucide/svelte": "^0.563.1",
     "@sveltejs/adapter-node": "^5.5.4",
     "@sveltejs/kit": "^2.60.1",

package/extensions/storage/tests/configs/simple.ts

@@ -1,85 +0,0 @@
-import type { Config } from "@lobb-js/core";
-import storage from "../../index.ts";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-export function createSimpleConfig(uploadsPath?: string): Config & { uploadsPath: string } {
-  const resolvedUploadsPath = uploadsPath ?? join(tmpdir(), "lobb_storage_" + crypto.randomUUID());
-  return {
-    uploadsPath: resolvedUploadsPath,
-    project: {
-      name: "Lobb",
-      force_sync: true,
-    },
-    database: {
-      host: "localhost",
-      port: 5432,
-      username: "test",
-      password: "test",
-      database: "*",
-    },
-    web_server: {
-      host: "0.0.0.0",
-      port: 0,
-      cors: {
-        origin: "*",
-      },
-    },
-    extensions: [
-      storage({
-        adapter: "local",
-        uploadsPath: resolvedUploadsPath,
-      }),
-    ],
-    collections: {
-      articles: {
-        indexes: {},
-        fields: {
-          id: {
-            type: "integer",
-          },
-          image: {
-            type: "string",
-            length: 255,
-          },
-          title: {
-            type: "string",
-            length: 255,
-            required: true,
-          },
-          description: {
-            type: "string",
-            length: 255,
-          },
-          body: {
-            type: "string",
-            length: 255,
-            required: true,
-          },
-          status: {
-            type: "string",
-            length: 255,
-            enum: ["public", "private"],
-          },
-        },
-      },
-      comments: {
-        indexes: {},
-        fields: {
-          id: {
-            type: "integer",
-          },
-          body: {
-            type: "string",
-            length: 255,
-            required: true,
-          },
-          article_id: {
-            type: "integer",
-            required: true,
-          },
-        },
-      },
-    },
-  };
-}

package/extensions/storage/tests/directories.test.ts

@@ -1,156 +0,0 @@
-import { Lobb } from "@lobb-js/core";
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { createSimpleConfig } from "./configs/simple.ts";
-
-describe("Directories Operations", () => {
-  let lobb: Lobb;
-  let baseUrl: string;
-  let createdRecordId: number;
-
-  beforeAll(async () => {
-    const config = createSimpleConfig();
-    lobb = await Lobb.init(config);
-    baseUrl = `http://127.0.0.1:${lobb.webServer.port}`;
-  });
-
-  afterAll(async () => {
-    await lobb.close();
-  });
-
-  it("should create a directory successfully", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs`,
-      {
-        method: "POST",
-        body: JSON.stringify({
-          data: {
-            name: "test_directory",
-            path: "/",
-          },
-        }),
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toMatchObject({
-      data: {
-        name: "test_directory",
-        path: "/",
-        type: "directory",
-      },
-    });
-
-    createdRecordId = data.data.id;
-  });
-
-  it("should prevent creating a directory in a non existing path", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs`,
-      {
-        method: "POST",
-        body: JSON.stringify({
-          data: {
-            name: "another_dir",
-            path: "/none_existing_directory",
-          },
-        }),
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toEqual({
-      code: "BAD_REQUEST",
-      status: 400,
-      message: "The specified path does not exist. Please create it first.",
-    });
-  });
-
-  it("should respond with the record of the requested directory entry", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs/${createdRecordId}`,
-      {
-        method: "GET",
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toMatchObject({
-      data: {
-        name: "test_directory",
-        path: "/",
-        type: "directory",
-      },
-    });
-  });
-
-  it("should list all file system entries", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs`,
-      {
-        method: "GET",
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toMatchObject({
-      data: [
-        {
-          name: "test_directory",
-          path: "/",
-          type: "directory",
-        },
-      ],
-      meta: {
-        totalCount: 1,
-      },
-    });
-  });
-
-  it("should list all file system entries using a filter", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs/search`,
-      {
-        method: "POST",
-        body: JSON.stringify({
-          filter: {
-            path: {
-              $starts_with: "/",
-            },
-          },
-        }),
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toMatchObject({
-      data: [
-        {
-          name: "test_directory",
-          path: "/",
-          type: "directory",
-        },
-      ],
-      meta: {
-        totalCount: 1,
-      },
-    });
-  });
-
-  it("should delete the directory successully", async () => {
-    const response = await fetch(
-      `${baseUrl}/api/collections/storage_fs/${createdRecordId}`,
-      {
-        method: "DELETE",
-      },
-    );
-    const data = await response.json();
-
-    expect(data).toMatchObject({
-      data: {
-        name: "test_directory",
-        path: "/",
-        type: "directory",
-      },
-    });
-  });
-});