@lobb-js/lobb-ext-storage 0.5.8 → 0.8.1

package/extensions/storage/utils.ts

@@ -0,0 +1,87 @@
+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(
+  c: Context,
+): Promise<File | undefined> {
+  const contentType = c.req.header("Content-Type");
+  if (contentType?.startsWith("multipart/form-data")) {
+    const formData = await c.req.formData();
+    const entry = formData.get("file");
+    if (entry instanceof File) {
+      return entry;
+    }
+  }
+  // return undefined if no file or wrong content type
+  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("/");
+    const directory = (await lobb.collectionStore.findAll({
+      collectionName: "storage_fs",
+      params: {
+        filter: {
+          name: directoryName,
+          path: directoryPath,
+        },
+      },
+    })).data[0];
+
+    if (!directory) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `The specified path does not exist. Please create it first.`,
+      });
+    }
+  }
+}
+
+/**
+ * Ensures a directory path exists, creating it if necessary
+ */
+export async function ensurePathExists(path: string, lobb: Lobb): Promise<void> {
+  if (!path || path === "/") {
+    return; // Root always exists
+  }
+
+  // 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
+    const existing = (await lobb.collectionStore.findAll({
+      collectionName: "storage_fs",
+      params: {
+        filter: {
+          name: dirName,
+          path: currentPath,
+          type: "directory",
+        },
+      },
+    })).data;
+
+    // Create the directory if it doesn't exist
+    if (existing.length === 0) {
+      await lobb.collectionStore.createOne({
+        collectionName: "storage_fs",
+        data: {
+          name: dirName,
+          path: currentPath,
+          type: "directory",
+        },
+      });
+    }
+
+    // Update current path for next iteration
+    currentPath = currentPath + dirName + "/";
+  }
+}

package/extensions/storage/workflows/controllers.ts

@@ -0,0 +1,103 @@
+import type { Lobb, Workflow } from "@lobb-js/core";
+import type { Context } from "hono";
+import type { StorageFsCreateOne, StorageFsFindOne } from "../types.ts";
+
+export function getControllersWorkflows(): Workflow[] {
+  return [
+    {
+      name: "storagePreCreateController",
+      eventName: "core.controllers.createOne.override",
+      handler: async (input, ctx) => {
+        if (input.collectionName === "storage_fs") {
+          const context = input.context as Context;
+          const lobb = context.get("lobb") as Lobb;
+          const contentType = context.req.header("Content-Type");
+
+          if (contentType?.startsWith("multipart/form-data")) {
+            const body = await context.req.parseBody({ all: true });
+            const fileEntry = body["file"];
+
+            if (!fileEntry) {
+              throw new ctx.LobbError({
+                code: "BAD_REQUEST",
+                message: "No files were provided.",
+              });
+            }
+
+            if (Array.isArray(fileEntry)) {
+              throw new ctx.LobbError({
+                code: "BAD_REQUEST",
+                message: "Only one file can be uploaded at a time.",
+              });
+            }
+
+            if (!(fileEntry instanceof File)) {
+              throw new ctx.LobbError({
+                code: "BAD_REQUEST",
+                message: "The file shouldnt be a string",
+              });
+            }
+
+            const force = context.req.query("force") === "true";
+
+            const extraData: Record<string, string> = {};
+            for (const [key, val] of Object.entries(body)) {
+              if (key !== "file" && key !== "payload" && typeof val === "string") {
+                extraData[key] = val;
+              }
+            }
+
+            const result = await ctx.lobb.collectionService.createOne<StorageFsCreateOne>({
+              collectionName: "storage_fs",
+              file: fileEntry,
+              force,
+              data: extraData,
+            });
+
+            return context.json(result, 201);
+          }
+        }
+      },
+    },
+    {
+      name: "storageFindOneController",
+      eventName: "core.controllers.findOne.override",
+      handler: async (input, ctx) => {
+        if (input.collectionName === "storage_fs") {
+          const context = input.context as Context;
+          const action = context.req.query("action");
+
+          if (action === "view" || action === "download") {
+            const result = await ctx.lobb.collectionService.findOne<StorageFsFindOne>({
+              collectionName: "storage_fs",
+              id: input.id,
+              readFile: true,
+            });
+
+            if (!result.data) {
+              throw new ctx.LobbError({
+                code: "NOT_FOUND",
+                message: "The record is not found",
+              });
+            }
+
+            const headers: Record<string, string> = {
+              "Content-Type": result.data.file_mime_type,
+            };
+            if (action === "download") {
+              headers["Content-Disposition"] =
+                `attachment; filename="${result.data.name}"`;
+            }
+
+            return new Response(result.file.buffer as ArrayBuffer, { status: 200, headers });
+          } else if (action) {
+            throw new ctx.LobbError({
+              code: "BAD_REQUEST",
+              message: `The passed (${action}) action query param is not supported`,
+            });
+          }
+        }
+      },
+    },
+  ];
+}

package/extensions/storage/workflows/index.ts

@@ -0,0 +1,10 @@
+import type { ExtensionConfig } from "../config/extensionConfigSchema.ts";
+import { getControllersWorkflows } from "./controllers.ts";
+import { getServicesWorkflows } from "./services.ts";
+
+export function getWorkflows(extensionConfig: ExtensionConfig) {
+  return [
+    ...getServicesWorkflows(extensionConfig),
+    ...getControllersWorkflows(),
+  ];
+}

package/extensions/storage/workflows/services.ts

@@ -0,0 +1,182 @@
+import type { Workflow } from "@lobb-js/core";
+import type { ExtensionConfig } from "../config/extensionConfigSchema.ts";
+import { initStorageAdapter } from "../adapters/index.ts";
+import { validatePathExists, ensurePathExists } from "../utils.ts";
+
+export function getServicesWorkflows(extensionConfig: ExtensionConfig): Workflow[] {
+  return [
+    {
+      name: "storageFindOneService",
+      eventName: "core.service.findOne.override",
+      handler: async (input, ctx) => {
+        if (input.collectionName === "storage_fs") {
+          const result = await ctx.lobb.collectionStore.findOne({
+            collectionName: "storage_fs",
+            id: input.id,
+          });
+
+          if (result.data?.type === "file" && input.readFile) {
+            const adapter = initStorageAdapter(extensionConfig);
+            const file = await adapter.readFile(result.data.id);
+            return { ...result, file: new Uint8Array(file) };
+          }
+
+          return result;
+        }
+      },
+    },
+    {
+      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.force) {
+              await ensurePathExists(filePath, ctx.lobb);
+            } else if (filePath !== "/") {
+              await validatePathExists(filePath, ctx.lobb);
+            }
+
+            const { path: _path, name: _name, type: _type, file_mime_type: _mime, file_size: _size, ...extraData } = input.data ?? {};
+
+            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 adapter = initStorageAdapter(extensionConfig);
+            await adapter.createFile(result.data.id, input.file);
+
+            return result;
+          } else {
+            if (input.data?.path) {
+              await validatePathExists(input.data.path, ctx.lobb);
+            }
+          }
+        }
+      },
+    },
+    {
+      name: "storageDeleteOneService",
+      eventName: "core.service.deleteOne.override",
+      handler: async (input, ctx) => {
+        if (input.collectionName === "storage_fs") {
+          const entry = (await ctx.lobb.collectionStore.findOne({
+            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 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);
+              }
+            }
+
+            await ctx.lobb.collectionStore.deleteMany({
+              collectionName: "storage_fs",
+              filter: {
+                path: {
+                  $starts_with: directoryPath,
+                },
+              },
+            });
+          }
+
+          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;
+
+          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;
+
+              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);
+            }
+          }
+
+          return ctx.lobb.collectionStore.deleteMany({
+            collectionName: "storage_fs",
+            filter: input.filter,
+          });
+        }
+      },
+    },
+    {
+      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);
+          }
+
+          return ctx.lobb.collectionStore.updateOne({
+            collectionName: "storage_fs",
+            id: input.id,
+            data: input.data,
+          });
+        }
+      },
+    },
+  ];
+}

package/lobb.ts

@@ -0,0 +1,54 @@
+import { Lobb } from "@lobb-js/core";
+import { storage } from "./extensions/storage/index.ts";
+
+Lobb.init({
+  project: {
+    name: "Storage Extension Test",
+    force_sync: true,
+  },
+  database: {
+    host: Bun.env.DATABASE_HOST ?? "localhost",
+    port: Number(Bun.env.DATABASE_PORT ?? 5432),
+    username: Bun.env.DATABASE_USER ?? "test",
+    password: Bun.env.DATABASE_PASSWORD ?? "test",
+    database: Bun.env.DATABASE_NAME ?? "storage_ext",
+  },
+  web_server: {
+    host: Bun.env.WEB_SERVER_HOST ?? "0.0.0.0",
+    port: Number(Bun.env.WEB_SERVER_PORT ?? 3000),
+    cors: {
+      origin: "*",
+    },
+  },
+  extensions: [
+    storage({
+      adapter: "local",
+      storagePath: "./storage",
+    }),
+  ],
+  collections: {
+    articles: {
+      indexes: {},
+      fields: {
+        id: {
+          type: "integer",
+        },
+        image: {
+          type: "string",
+          length: 255,
+        },
+        title: {
+          type: "string",
+          length: 255,
+          validators: {
+            required: true,
+          },
+        },
+        body: {
+          type: "string",
+          length: 255,
+        },
+      },
+    },
+  },
+});

package/package.json

@@ -1,31 +1,54 @@
 {
   "name": "@lobb-js/lobb-ext-storage",
-  "version": "0.5.8",
+  "version": "0.8.1",
+  "license": "AGPL-3.0-only",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./extensions/storage/index.ts",
+    "./studio": {
+      "svelte": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "scripts": {
-    "dev": "vite",
-    "build": "vite build",
+    "test": "bun run test:lobb && bun run test:studio",
+    "test:lobb": "bun test extensions/storage/tests",
+    "test:studio": "bun --bun playwright test --config extensions/storage/studio/tests/playwright.config.cjs",
+    "dev": "bun run lobb.ts",
+    "start": "LOBB_MODE=prod bun run lobb.ts",
+    "prepare": "svelte-kit sync || echo ''",
     "preview": "vite preview",
-    "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "postinstall": "bun --bun playwright install chromium",
+    "prepublishOnly": "./scripts/prepublish.sh",
+    "postpublish": "./scripts/postpublish.sh",
+    "package": "svelte-package --input extensions/storage/studio",
+    "dev:studio": "vite dev",
+    "build:studio": "vite build"
   },
   "dependencies": {
-    "path-browserify": "^1.0.1",
-    "browser-fs-access": "^0.35.0"
+    "@lobb-js/core": "0.13.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.5.0",
+    "@lobb-js/studio": "0.7.1",
     "@lucide/svelte": "^0.563.1",
+    "@playwright/test": "^1.58.2",
+    "@sveltejs/adapter-node": "^5.5.4",
+    "@sveltejs/kit": "^2.55.0",
     "@sveltejs/vite-plugin-svelte": "6.2.1",
+    "@sveltejs/package": "^2.5.7",
     "@tailwindcss/vite": "^4.1.18",
     "@tsconfig/svelte": "^5.0.6",
-    "@types/path-browserify": "^1.0.3",
     "@types/node": "^24.10.1",
+    "@types/path-browserify": "^1.0.3",
+    "bun-types": "latest",
     "clsx": "^2.1.1",
     "svelte": "^5.49.1",
     "svelte-check": "^4.3.4",

package/scripts/postpublish.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Postpublish script for @lobb-js/lobb-ext-storage
+# Reverts package.json exports and cleans dist to avoid uncommitted changes
+
+echo "📝 Reverting package.json exports to development mode..."
+jq '."exports"["./studio"] = "./extensions/storage/studio/index.ts"' package.json > package.json.tmp && mv package.json.tmp package.json
+
+echo "🧹 Cleaning dist directory..."
+rm -rf dist
+
+echo "✅ Postpublish complete"

package/scripts/prepublish.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Prepublish script for @lobb-js/lobb-ext-storage
+# Builds the studio package and updates exports for publishing
+
+echo "📦 Building studio package..."
+bun run package
+
+if [ $? -ne 0 ]; then
+    echo "❌ Build failed"
+    exit 1
+fi
+
+echo "📝 Updating package.json exports for publishing..."
+jq '."exports"["./studio"] = {"svelte": "./dist/index.js", "types": "./dist/index.d.ts"}' package.json > package.json.tmp && mv package.json.tmp package.json
+
+echo "✅ Prepublish complete"

package/studio/app.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<link rel="icon" href="%sveltekit.assets%/vite.svg" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div style="display: contents">%sveltekit.body%</div>
+	</body>
+</html>

package/studio/routes/+layout.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+	import "@lobb-js/studio/app.css";
+
+	let { children } = $props();
+</script>
+
+{@render children()}

package/studio/routes/+layout.ts

@@ -0,0 +1 @@
+export const ssr = false;

package/studio/routes/[...path]/+page.svelte

@@ -0,0 +1,6 @@
+<script lang="ts">
+	import { Studio } from "@lobb-js/studio";
+	import { env } from "$env/dynamic/public";
+</script>
+
+<Studio lobbUrl={env.PUBLIC_LOBB_URL} />

package/svelte.config.js

@@ -1,8 +1,24 @@
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
+import adapter from '@sveltejs/adapter-node';
 
-/** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
-export default {
-  // Consult https://svelte.dev/docs#compile-time-svelte-preprocess
-  // for more information about preprocessors
-  preprocess: vitePreprocess(),
-}
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+	kit: {
+		adapter: adapter(),
+		paths: {
+			base: '/studio'
+		},
+		files: {
+			lib: 'studio/lib',
+			routes: 'studio/routes',
+			appTemplate: 'studio/app.html',
+			assets: 'public',
+			hooks: {
+				server: 'studio/hooks.server',
+				client: 'studio/hooks.client',
+			},
+			params: 'studio/params',
+		}
+	}
+};
+
+export default config;

package/todo.md

@@ -0,0 +1,36 @@
+# high priority
+
+- move the validation logic that checks if the directory of uploaded file path exists or not in the service level and not in the controller level.
+
+- a better way to implement this extension is to update or overright the collectionService. so that you can use the same exsting CollectionService class normally but with the ability to adjust the params of that service funciton. so the storage extension version of the normal collection overright will have different params set. for example it should have a param of type blob or File. so you shouldnt really expose services. in the mod.ts. the services already exists why expose. we shouldnt really have at all the services property
+  - remove services from this extension and from everywhere
+  - instead of creating your own service method. you can just overwrite or update the existing method
+    - for example to upload a file you can just use the collectionService mutated create version instead of creating your own function
+  - you need to also overwrite the controllers to call the new service function correctly
+  - this way is much better from exposing a bunch of service functions and more consistant
+  - you should use workflows to overwrite the controllers and the services
+  - make sure the tests work correctly
+  - remove totally the services from this extension and from the extensionSystem totally
+  - go to the `social_to_courier` and fix the storage update part.
+
+- remove the unique index of (location, name)
+- implement uploading a file by drag and drop
+- implement the listview
+
+# low priority
+
+- you need to add a refresh button
+- when the user tries to upload a file or a directory in a non existing.
+  directory you have to respond with a 400 Error
+- check if a file exists by sending a GET request instead of reading the
+  directory. because thats a unit test specific to local adapter. but the first
+  way would work in all kinds of adapters. and it will make the unit tests more
+  adaptable
+- prevent the user from not adding a / at the beggining of the path or adding a
+  / at the end of the path when inserting or updating a storage record and make
+  sure the path is not empty
+- implement a validation mechanism at the instatiating of the storage extension
+  that checks of all operations are successfully doable in that specific adapter
+  without issues. (really important)
+- Allow multiple versions of a file to be stored, enabling users to access
+  previous versions if needed.

package/tsconfig.app.json

@@ -19,9 +19,9 @@
     "moduleDetection": "force",
     "baseUrl": ".",
     "paths": {
-      "$lib": ["./src/lib"],
-      "$lib/*": ["./src/lib/*"]
+      "$lib": ["./studio/lib"],
+      "$lib/*": ["./studio/lib/*"]
     }
   },
-  "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
+  "include": ["studio/**/*.ts", "studio/**/*.js", "studio/**/*.svelte"]
 }

package/tsconfig.json

@@ -1,7 +1,13 @@
 {
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
-  ]
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true
+  }
 }