@objectstack/service-storage 4.0.5 → 4.1.1

package/dist/index.js

@@ -480,6 +480,9 @@ var LocalStorageAdapter = class {
   }
 };
 
+// src/storage-service-plugin.ts
+init_s3_storage_adapter();
+
 // src/metadata-store.ts
 var StorageMetadataStore = class {
   constructor(engine) {
@@ -496,7 +499,7 @@ var StorageMetadataStore = class {
     this.files.set(full.id, full);
     if (this.engine) {
       try {
-        await this.engine.insert("system_file", full);
+        await this.engine.insert("sys_file", full);
       } catch {
       }
     }
@@ -505,7 +508,7 @@ var StorageMetadataStore = class {
   async getFile(id) {
     if (this.engine) {
       try {
-        const found = await this.engine.findOne("system_file", { where: { id } });
+        const found = await this.engine.findOne("sys_file", { where: { id } });
         if (found) return found;
       } catch {
       }
@@ -519,7 +522,7 @@ var StorageMetadataStore = class {
     this.files.set(id, merged);
     if (this.engine) {
       try {
-        await this.engine.update("system_file", merged, { where: { id } });
+        await this.engine.update("sys_file", merged, { where: { id } });
       } catch {
       }
     }
@@ -529,7 +532,7 @@ var StorageMetadataStore = class {
     this.files.delete(id);
     if (this.engine) {
       try {
-        await this.engine.delete("system_file", { where: { id } });
+        await this.engine.delete("sys_file", { where: { id } });
       } catch {
       }
     }
@@ -550,7 +553,7 @@ var StorageMetadataStore = class {
     this.sessions.set(full.id, full);
     if (this.engine) {
       try {
-        await this.engine.insert("system_upload_session", full);
+        await this.engine.insert("sys_upload_session", full);
       } catch {
       }
     }
@@ -559,7 +562,7 @@ var StorageMetadataStore = class {
   async getSession(id) {
     if (this.engine) {
       try {
-        const found = await this.engine.findOne("system_upload_session", { where: { id } });
+        const found = await this.engine.findOne("sys_upload_session", { where: { id } });
         if (found) return found;
       } catch {
       }
@@ -578,7 +581,7 @@ var StorageMetadataStore = class {
     this.sessions.set(id, merged);
     if (this.engine) {
       try {
-        await this.engine.update("system_upload_session", merged, { where: { id } });
+        await this.engine.update("sys_upload_session", merged, { where: { id } });
       } catch {
       }
     }
@@ -588,7 +591,7 @@ var StorageMetadataStore = class {
     this.sessions.delete(id);
     if (this.engine) {
       try {
-        await this.engine.delete("system_upload_session", { where: { id } });
+        await this.engine.delete("sys_upload_session", { where: { id } });
       } catch {
       }
     }
@@ -881,6 +884,28 @@ function registerStorageRoutes(httpServer, storage, store, opts = {}) {
       res.status(500).json({ error: err.message ?? "Internal error" });
     }
   });
+  httpServer.get(`${basePath}/files/:fileId`, async (req, res) => {
+    try {
+      const { fileId } = req.params;
+      const file = await store.getFile(fileId);
+      if (!file || file.status !== "committed") {
+        res.status(404).json({ error: "File not found or not committed" });
+        return;
+      }
+      let url;
+      if (storage.getPresignedDownload) {
+        const desc = await storage.getPresignedDownload(file.key, presignedTtl);
+        url = desc.downloadUrl;
+      } else if (storage.getSignedUrl) {
+        url = await storage.getSignedUrl(file.key, presignedTtl);
+      } else {
+        url = `${basePath}/_local/file/${encodeURIComponent(file.key)}`;
+      }
+      res.status(302).header("Location", url).send("");
+    } catch (err) {
+      res.status(500).json({ error: err.message ?? "Internal error" });
+    }
+  });
   httpServer.put(`${basePath}/_local/raw/:token`, async (req, res) => {
     try {
       const { token } = req.params;
@@ -933,7 +958,7 @@ function buildKey(scope, fileId, filename) {
 // src/objects/system-file.object.ts
 import { ObjectSchema, Field } from "@objectstack/spec/data";
 var SystemFile = ObjectSchema.create({
-  name: "system_file",
+  name: "sys_file",
   label: "System File",
   pluralLabel: "System Files",
   icon: "file",
@@ -979,7 +1004,7 @@ var SystemFile = ObjectSchema.create({
       label: "ACL",
       options: [
         { label: "Private", value: "private" },
-        { label: "Public Read", value: "public-read" }
+        { label: "Public Read", value: "public_read" }
       ]
     }),
     status: Field.select({
@@ -1012,7 +1037,7 @@ var SystemFile = ObjectSchema.create({
 // src/objects/system-upload-session.object.ts
 import { ObjectSchema as ObjectSchema2, Field as Field2 } from "@objectstack/spec/data";
 var SystemUploadSession = ObjectSchema2.create({
-  name: "system_upload_session",
+  name: "sys_upload_session",
   label: "System Upload Session",
   pluralLabel: "System Upload Sessions",
   icon: "upload-cloud",
@@ -1099,6 +1124,103 @@ var SystemUploadSession = ObjectSchema2.create({
   }
 });
 
+// src/swappable-storage-service.ts
+var SwappableStorageService = class {
+  constructor(initial, onSwap) {
+    this.inner = initial;
+    this.onSwap = onSwap;
+  }
+  /** Replace the inner adapter. */
+  swap(next) {
+    const previous = this.inner;
+    this.inner = next;
+    this.onSwap?.(previous, next);
+  }
+  /** Expose the active inner adapter — primarily for tests. */
+  getInner() {
+    return this.inner;
+  }
+  upload(key, data, options) {
+    return this.inner.upload(key, data, options);
+  }
+  download(key) {
+    return this.inner.download(key);
+  }
+  delete(key) {
+    return this.inner.delete(key);
+  }
+  exists(key) {
+    return this.inner.exists(key);
+  }
+  getInfo(key) {
+    return this.inner.getInfo(key);
+  }
+  list(prefix) {
+    if (typeof this.inner.list !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support list()"));
+    }
+    return this.inner.list(prefix);
+  }
+  getSignedUrl(key, expiresIn) {
+    if (typeof this.inner.getSignedUrl !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support getSignedUrl()"));
+    }
+    return this.inner.getSignedUrl(key, expiresIn);
+  }
+  getPresignedUpload(key, expiresIn, options) {
+    if (typeof this.inner.getPresignedUpload !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support getPresignedUpload()"));
+    }
+    return this.inner.getPresignedUpload(key, expiresIn, options);
+  }
+  getPresignedDownload(key, expiresIn) {
+    if (typeof this.inner.getPresignedDownload !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support getPresignedDownload()"));
+    }
+    return this.inner.getPresignedDownload(key, expiresIn);
+  }
+  initiateChunkedUpload(key, options) {
+    if (typeof this.inner.initiateChunkedUpload !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support initiateChunkedUpload()"));
+    }
+    return this.inner.initiateChunkedUpload(key, options);
+  }
+  uploadChunk(uploadId, partNumber, data) {
+    if (typeof this.inner.uploadChunk !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support uploadChunk()"));
+    }
+    return this.inner.uploadChunk(uploadId, partNumber, data);
+  }
+  completeChunkedUpload(uploadId, parts) {
+    if (typeof this.inner.completeChunkedUpload !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support completeChunkedUpload()"));
+    }
+    return this.inner.completeChunkedUpload(uploadId, parts);
+  }
+  abortChunkedUpload(uploadId) {
+    if (typeof this.inner.abortChunkedUpload !== "function") {
+      return Promise.reject(new Error("Active storage adapter does not support abortChunkedUpload()"));
+    }
+    return this.inner.abortChunkedUpload(uploadId);
+  }
+  /**
+   * Verify a presigned HMAC token (LocalStorageAdapter-specific).
+   *
+   * `IStorageService` does not declare this method, but `storage-routes`
+   * type-narrows the active storage to `LocalStorageAdapter` to handle the
+   * `/_local/raw/:token` PUT and GET endpoints. Without a passthrough on
+   * the swappable wrapper, the route sees `verifyToken === undefined` and
+   * returns 501 even though the underlying local adapter supports it.
+   */
+  verifyToken(token, expectedOp) {
+    const inner = this.inner;
+    if (typeof inner.verifyToken !== "function") {
+      throw new Error("Active storage adapter does not support verifyToken()");
+    }
+    return inner.verifyToken(token, expectedOp);
+  }
+};
+
 // src/storage-service-plugin.ts
 var StorageServicePlugin = class {
   constructor(options = {}) {
@@ -1109,22 +1231,57 @@ var StorageServicePlugin = class {
     this.store = null;
     this.options = { adapter: "local", ...options };
   }
+  /** Build a concrete adapter from a values map (settings-derived). */
+  async buildAdapterFromValues(values) {
+    const adapter = String(values.adapter ?? "local");
+    if (adapter === "s3") {
+      const bucket = values.s3_bucket;
+      const region = values.s3_region;
+      if (!bucket || !region) {
+        throw new Error("StorageServicePlugin: S3 adapter requires s3_bucket and s3_region");
+      }
+      const opts = {
+        bucket,
+        region,
+        endpoint: values.s3_endpoint || void 0,
+        accessKeyId: values.s3_access_key_id || void 0,
+        secretAccessKey: values.s3_secret_access_key || void 0,
+        forcePathStyle: !!values.s3_force_path_style
+      };
+      return new S3StorageAdapter(opts);
+    }
+    const rootDir = values.local_root || "./storage";
+    return new LocalStorageAdapter({
+      basePath: this.options.basePath ?? "/api/v1/storage",
+      ...this.options.local ?? {},
+      // settings value wins over any constructor-provided local.rootDir
+      rootDir
+    });
+  }
   async init(ctx) {
     const adapter = this.options.adapter;
+    let initial;
     if (adapter === "s3") {
-      const { S3StorageAdapter: S3StorageAdapter2 } = await Promise.resolve().then(() => (init_s3_storage_adapter(), s3_storage_adapter_exports));
+      const { S3StorageAdapter: S3Ctor } = await Promise.resolve().then(() => (init_s3_storage_adapter(), s3_storage_adapter_exports));
       const s3Opts = this.options.s3;
       if (!s3Opts) {
         throw new Error('StorageServicePlugin: s3 options are required when adapter is "s3"');
       }
-      this.storage = new S3StorageAdapter2(s3Opts);
+      initial = new S3Ctor(s3Opts);
     } else {
       const rootDir = this.options.local?.rootDir ?? "./storage";
       const basePath = this.options.basePath ?? "/api/v1/storage";
-      this.storage = new LocalStorageAdapter({ rootDir, basePath, ...this.options.local });
+      initial = new LocalStorageAdapter({ rootDir, basePath, ...this.options.local });
     }
+    this.storage = new SwappableStorageService(initial, (prev, next) => {
+      const prevName = prev?.constructor?.name ?? "unknown";
+      const nextName = next?.constructor?.name ?? "unknown";
+      ctx.logger.warn(
+        `StorageServicePlugin: storage adapter swapped (${prevName} \u2192 ${nextName}). Existing files were NOT migrated and may be unreachable through the new adapter.`
+      );
+    });
     ctx.registerService("file-storage", this.storage);
-    ctx.logger.info(`StorageServicePlugin: registered ${adapter} storage adapter`);
+    ctx.logger.info(`StorageServicePlugin: registered ${adapter} storage adapter (swappable)`);
     try {
       ctx.getService("manifest").register({
         id: "com.objectstack.service.storage",
@@ -1138,31 +1295,101 @@ var StorageServicePlugin = class {
     }
   }
   async start(ctx) {
-    if (this.options.registerRoutes === false) return;
     ctx.hook("kernel:ready", async () => {
-      let httpServer = null;
-      try {
-        httpServer = ctx.getService("http-server");
-      } catch {
-      }
-      if (!httpServer || !this.storage) {
-        ctx.logger.warn(
-          'StorageServicePlugin: no HTTP server available \u2014 REST routes not registered. File storage is still accessible programmatically via kernel.getService("file-storage").'
-        );
-        return;
+      if (this.options.registerRoutes !== false) {
+        let httpServer = null;
+        try {
+          httpServer = ctx.getService("http-server");
+        } catch {
+        }
+        if (httpServer && this.storage) {
+          let engine = null;
+          try {
+            engine = ctx.getService("objectql");
+          } catch {
+          }
+          this.store = new StorageMetadataStore(engine);
+          registerStorageRoutes(httpServer, this.storage, this.store, {
+            basePath: this.options.basePath ?? "/api/v1/storage",
+            presignedTtl: this.options.presignedTtl,
+            sessionTtl: this.options.sessionTtl
+          });
+          ctx.logger.info(
+            "StorageServicePlugin: REST routes registered at " + (this.options.basePath ?? "/api/v1/storage")
+          );
+        } else if (!httpServer) {
+          ctx.logger.warn(
+            'StorageServicePlugin: no HTTP server available \u2014 REST routes not registered. File storage is still accessible programmatically via kernel.getService("file-storage").'
+          );
+        }
       }
-      let engine = null;
+      if (this.options.bindToSettings === false) return;
       try {
-        engine = ctx.getService("objectql");
+        const settings = ctx.getService("settings");
+        if (!settings || typeof settings.createClient !== "function") return;
+        const applySettings = async () => {
+          if (!this.storage) return;
+          try {
+            const payload = await settings.getNamespace("storage");
+            const values = {};
+            for (const [k, v] of Object.entries(payload.values)) {
+              values[k] = v?.value;
+            }
+            const hasAny = Object.values(values).some((v) => v !== void 0 && v !== null && v !== "");
+            if (!hasAny) return;
+            const next = await this.buildAdapterFromValues(values);
+            this.storage.swap(next);
+          } catch (err) {
+            ctx.logger.warn(
+              "StorageServicePlugin: failed to apply storage settings: " + (err?.message ?? err)
+            );
+          }
+        };
+        await applySettings();
+        if (typeof settings.subscribe === "function") {
+          settings.subscribe("storage", () => {
+            void applySettings();
+          });
+          ctx.logger.info("StorageServicePlugin: bound to settings:changed for namespace=storage");
+        }
+        if (typeof settings.registerAction === "function" && this.storage) {
+          const proxy = this.storage;
+          settings.registerAction("storage", "test", async ({ values }) => {
+            const probeKey = `__objectstack_probe__/${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+            const probeBytes = Buffer.from(`probe@${(/* @__PURE__ */ new Date()).toISOString()}`, "utf-8");
+            try {
+              let target = proxy;
+              if (values && Object.keys(values).length > 0) {
+                try {
+                  target = await this.buildAdapterFromValues(values);
+                } catch (err) {
+                  return { ok: false, severity: "error", message: err?.message ?? String(err) };
+                }
+              }
+              await target.upload(probeKey, probeBytes, { contentType: "text/plain" });
+              const got = await target.download(probeKey);
+              if (!got || !Buffer.isBuffer(got) || got.toString("utf-8") !== probeBytes.toString("utf-8")) {
+                return { ok: false, severity: "error", message: "Probe download did not match upload." };
+              }
+              await target.delete(probeKey);
+              const adapter = String(values?.adapter ?? this.options.adapter ?? "local");
+              return {
+                ok: true,
+                severity: "info",
+                message: `Storage round-trip succeeded (adapter=${adapter}).`
+              };
+            } catch (err) {
+              try {
+                await proxy.delete(probeKey);
+              } catch {
+              }
+              return { ok: false, severity: "error", message: err?.message ?? String(err) };
+            }
+          });
+          ctx.logger.info("StorageServicePlugin: registered settings action storage/test");
+        }
       } catch {
       }
-      this.store = new StorageMetadataStore(engine);
-      registerStorageRoutes(httpServer, this.storage, this.store, {
-        basePath: this.options.basePath ?? "/api/v1/storage",
-        presignedTtl: this.options.presignedTtl,
-        sessionTtl: this.options.sessionTtl
-      });
-      ctx.logger.info("StorageServicePlugin: REST routes registered at " + (this.options.basePath ?? "/api/v1/storage"));
     });
   }
 };
@@ -1174,6 +1401,7 @@ export {
   S3StorageAdapter,
   StorageMetadataStore,
   StorageServicePlugin,
+  SwappableStorageService,
   SystemFile,
   SystemUploadSession,
   registerStorageRoutes