@dyrected/core 2.10.1 → 2.12.0

package/dist/server.js

@@ -30,7 +30,7 @@ import {
   touchAuthSession,
   transitionWorkflow,
   verifyCollectionToken
-} from "./chunk-H7DVVW2P.js";
+} from "./chunk-VOE2LOLF.js";
 import {
   attachRequestMetrics,
   bindObservabilityRuntime,
@@ -870,7 +870,7 @@ function mergeWhereConstraint(where, constraint) {
 
 // src/utils/action-mutation.ts
 function resolveActionMutation(mutation, ctx) {
-  if (!mutation) return {};
+  if (!mutation) return { ...ctx.input ?? {} };
   return resolveValue(mutation, ctx);
 }
 function resolveValue(value, ctx) {
@@ -1032,7 +1032,7 @@ var CollectionController = class {
       if (this.collection.admin?.filterable === false) {
         where = void 0;
       } else {
-        const { sanitizeWhereClause } = await import("./where-sanitizer-47QPJQ6O.js");
+        const { sanitizeWhereClause } = await import("./where-sanitizer-CAAIYSSK.js");
         where = sanitizeWhereClause(where, this.collection.fields);
         if (Object.keys(where).length === 0) {
           where = void 0;
@@ -2088,9 +2088,31 @@ var CollectionController = class {
       const body = await c.req.json().catch(() => null);
       if (body?.ids && Array.isArray(body.ids)) {
         ids = body.ids;
+      } else if (Array.isArray(body)) {
+        ids = body;
       }
     } catch {
     }
+    if (!ids.length) {
+      try {
+        const parsed = await c.req.parseBody().catch(() => null);
+        if (parsed) {
+          if (Array.isArray(parsed.ids)) {
+            ids = parsed.ids.filter((x) => typeof x === "string");
+          } else if (Array.isArray(parsed["ids[]"])) {
+            ids = parsed["ids[]"].filter((x) => typeof x === "string");
+          } else if (typeof parsed.ids === "string") {
+            try {
+              const json = JSON.parse(parsed.ids);
+              if (Array.isArray(json)) ids = json;
+            } catch {
+              ids = [parsed.ids];
+            }
+          }
+        }
+      } catch {
+      }
+    }
     if (!ids.length) {
       const raw = c.req.queries("ids") ?? c.req.queries("ids[]") ?? [];
       ids = raw.filter(Boolean);
@@ -2227,7 +2249,7 @@ var CollectionController = class {
         groupBy = queryGroupBy.trim();
       }
     }
-    const { sanitizeWhereClause } = await import("./where-sanitizer-47QPJQ6O.js");
+    const { sanitizeWhereClause } = await import("./where-sanitizer-CAAIYSSK.js");
     const sanitizedAggregates = {};
     for (const [key, op] of Object.entries(rawAggregates)) {
       if (!op || typeof op !== "object" || Array.isArray(op)) {
@@ -2508,6 +2530,7 @@ var MediaController = class {
     }
     const body = await c.req.parseBody();
     const file = body["file"];
+    const folderId = body["folderId"] || null;
     const focalPointStr = body["focalPoint"];
     const focalPoint = focalPointStr ? JSON.parse(focalPointStr) : void 0;
     if (!file) {
@@ -2548,8 +2571,8 @@ var MediaController = class {
           config: colConfig?.upload,
           focalPoint
         });
-        imageMetadata = processed.metadata;
-        imageSizes = processed.sizes;
+        imageMetadata = processed.metadata || {};
+        imageSizes = processed.sizes || {};
       } catch (err) {
         getRequestLogger(c, this.loggerComponent).error({
           err,
@@ -2565,9 +2588,28 @@ var MediaController = class {
       mimeType: file.type,
       prefix
     });
+    const width = fileData.width || imageMetadata.width;
+    const height = fileData.height || imageMetadata.height;
+    const aspectRatio = width && height ? width / height : void 0;
+    const customFields = {};
+    for (const [key, val] of Object.entries(body)) {
+      if (!["file", "focalPoint", "folderId"].includes(key) && typeof val === "string") {
+        try {
+          customFields[key] = JSON.parse(val);
+        } catch {
+          customFields[key] = val;
+        }
+      }
+    }
     const finalFileData = {
+      ...customFields,
       ...fileData,
       ...imageMetadata,
+      originalFilename: file.name,
+      folderId,
+      width,
+      height,
+      aspectRatio,
       focalPoint,
       sizes: {}
     };
@@ -2608,15 +2650,143 @@ var MediaController = class {
     });
     return c.json(doc, 201);
   }
+  async replace(c) {
+    const id = c.req.param("id");
+    const config = c.get("config");
+    const storage = config.storage;
+    const imageService = config.image;
+    const db = config.db;
+    if (!storage) {
+      return c.json({ message: "Storage not configured" }, 500);
+    }
+    if (!db) {
+      return c.json({ message: "Database not configured" }, 500);
+    }
+    if (!id) {
+      return c.json({ message: "Missing ID" }, 400);
+    }
+    const existingDoc = await db.findOne({ collection: this.collection, id });
+    if (!existingDoc) {
+      return c.json({ message: "Asset not found" }, 404);
+    }
+    const body = await c.req.parseBody();
+    const file = body["file"];
+    if (!file) {
+      return c.json({ message: "No file uploaded" }, 400);
+    }
+    const siteId = c.get("siteId");
+    let colConfig = config.collections.find((col) => col.slug === this.collection);
+    if (!colConfig && config.onSchemaFetch && siteId) {
+      const requestConfig = mergeDynamicConfig(config, await config.onSchemaFetch(siteId));
+      colConfig = requestConfig.collections.find((col) => col.slug === this.collection);
+    }
+    const uploadConfig = typeof colConfig?.upload === "object" ? colConfig.upload : void 0;
+    const validationError = validateUpload(file, uploadConfig);
+    if (validationError) {
+      return c.json({ message: validationError.message }, validationError.status);
+    }
+    const buffer = new Uint8Array(await file.arrayBuffer());
+    const workspaceId = c.get("workspaceId");
+    const prefix = workspaceId ? `${workspaceId}/${siteId}` : siteId || "default";
+    const uniqueFilename = generateUniqueUploadFilename(file.name);
+    let imageMetadata = {};
+    let imageSizes = {};
+    if (imageService && file.type.startsWith("image/")) {
+      try {
+        const processed = await imageService.process({
+          buffer,
+          mimeType: file.type,
+          config: colConfig?.upload,
+          focalPoint: existingDoc.focalPoint
+        });
+        imageMetadata = processed.metadata || {};
+        imageSizes = processed.sizes || {};
+      } catch (err) {
+        getRequestLogger(c, this.loggerComponent).error({
+          err,
+          msg: "Image processing failed during replace",
+          collection: this.collection,
+          filename: file.name
+        });
+      }
+    }
+    const fileData = await storage.upload({
+      filename: uniqueFilename,
+      buffer,
+      mimeType: file.type,
+      prefix
+    });
+    const width = fileData.width || imageMetadata.width;
+    const height = fileData.height || imageMetadata.height;
+    const aspectRatio = width && height ? width / height : void 0;
+    const finalFileData = {
+      ...fileData,
+      ...imageMetadata,
+      originalFilename: file.name,
+      width,
+      height,
+      aspectRatio,
+      sizes: {}
+    };
+    if (imageSizes) {
+      for (const [sizeName, sizeData] of Object.entries(imageSizes)) {
+        const lastDot = uniqueFilename.lastIndexOf(".");
+        const ext = lastDot !== -1 ? uniqueFilename.substring(lastDot) : "";
+        const baseName = lastDot !== -1 ? uniqueFilename.substring(0, lastDot) : uniqueFilename;
+        const sizeFilename = `${baseName}-${sizeName}${ext}`;
+        try {
+          const sizeFileData = await storage.upload({
+            filename: sizeFilename,
+            buffer: sizeData.buffer,
+            mimeType: file.type,
+            prefix
+          });
+          finalFileData.sizes[sizeName] = {
+            ...sizeFileData,
+            width: sizeData.width,
+            height: sizeData.height
+          };
+        } catch (err) {
+          getRequestLogger(c, this.loggerComponent).error({
+            err,
+            msg: "Failed to upload image size during replace",
+            collection: this.collection,
+            filename: file.name,
+            sizeName
+          });
+        }
+      }
+    }
+    if (existingDoc.filename && existingDoc.filename !== fileData.filename) {
+      try {
+        await storage.delete({ filename: existingDoc.filename });
+      } catch {
+      }
+    }
+    const updatedDoc = await db.update({
+      collection: this.collection,
+      id,
+      data: finalFileData
+    });
+    return c.json(updatedDoc, 200);
+  }
   async find(c) {
     const db = c.get("config").db;
     if (!db) return c.json({ message: "Database not configured" }, 500);
     const limit = Number(c.req.query("limit")) || 10;
     const page = Number(c.req.query("page")) || 1;
+    const sort = c.req.query("sort") || void 0;
+    const folderId = c.req.query("folderId");
+    const where = {};
+    if (folderId !== void 0) {
+      where.folderId = folderId === "root" || folderId === "null" ? null : folderId;
+    }
     const result = await db.find({
       collection: this.collection,
       limit,
-      page
+      page,
+      sort,
+      where: Object.keys(where).length > 0 ? where : void 0
     });
     return c.json(result);
   }
@@ -2645,21 +2815,195 @@ var MediaController = class {
   async serve(c) {
     const config = c.get("config");
     const storage = config.storage;
-    if (!storage || !storage.resolve) {
+    if (!storage) {
       return c.json({ message: "Storage not configured for serving" }, 404);
     }
     const filename = c.req.param("filename");
     if (!filename) return c.json({ message: "Missing filename" }, 400);
+    const key = c.req.query("key");
+    const width = c.req.query("width") ? Number(c.req.query("width")) : void 0;
+    const height = c.req.query("height") ? Number(c.req.query("height")) : void 0;
+    const aspectRatio = c.req.query("aspectRatio") || c.req.query("aspect_ratio");
+    const crop = c.req.query("crop") || c.req.query("fit");
+    const gravity = c.req.query("gravity");
+    const format = c.req.query("format");
+    const qualityParam = c.req.query("quality");
+    const quality = qualityParam ? isNaN(Number(qualityParam)) ? qualityParam : Number(qualityParam) : void 0;
+    const download = c.req.query("download") === "true" || c.req.query("download") === "1";
+    let transform;
+    if (key && config.media?.presets?.[key]) {
+      transform = { ...config.media.presets[key] };
+    } else if (width || height || aspectRatio || crop || gravity || format || quality) {
+      transform = { width, height, aspectRatio, crop, gravity, format, quality };
+    }
+    if (transform && typeof storage.getURL === "function") {
+      const targetUrl = storage.getURL({ filename, transform });
+      if (targetUrl && targetUrl.startsWith("http")) {
+        return c.redirect(targetUrl, 302);
+      }
+    }
+    if (!storage.resolve) {
+      const publicUrl = storage.getURL({ filename, transform });
+      return c.redirect(publicUrl, 302);
+    }
     let res = await storage.resolve({ filename });
     if (!res && !filename.includes("/")) {
       res = await storage.resolve({ filename: `default/${filename}` });
     }
     if (!res) return c.json({ message: "Not Found" }, 404);
     c.header("Content-Type", res.mimeType);
+    c.header("Cache-Control", "public, max-age=31536000, immutable");
+    if (download) {
+      const downloadName = filename.split("/").pop() || "download";
+      c.header("Content-Disposition", `attachment; filename="${downloadName}"`);
+    }
     return c.body(res.buffer);
   }
 };
 
+// src/controllers/media-folders.controller.ts
+var MediaFolderController = class {
+  collection;
+  constructor(collection = "media") {
+    this.collection = collection;
+  }
+  async list(c) {
+    const config = c.get("config");
+    const db = config.db;
+    if (!db) {
+      return c.json({ message: "Database not configured" }, 500);
+    }
+    try {
+      const result = await db.find({
+        collection: "_media_folders",
+        where: {
+          collection: { equals: this.collection }
+        },
+        limit: 1e3,
+        sort: "name"
+      });
+      return c.json(result);
+    } catch {
+      return c.json({
+        docs: [],
+        total: 0,
+        limit: 1e3,
+        page: 1,
+        totalPages: 1,
+        hasNextPage: false,
+        hasPrevPage: false
+      });
+    }
+  }
+  async create(c) {
+    const config = c.get("config");
+    const db = config.db;
+    if (!db) {
+      return c.json({ message: "Database not configured" }, 500);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const name = String(body.name || "").trim();
+    const parentId = body.parentId ? String(body.parentId) : null;
+    const color = body.color ? String(body.color) : null;
+    if (!name) {
+      return c.json({ message: "Folder name is required" }, 400);
+    }
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    let path = `/${slug}`;
+    if (parentId) {
+      try {
+        const parent = await db.findOne({
+          collection: "_media_folders",
+          id: parentId
+        });
+        if (parent && parent.path) {
+          path = `${parent.path}/${slug}`;
+        }
+      } catch {
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const folderData = {
+      name,
+      slug,
+      collection: this.collection,
+      parentId,
+      path,
+      color,
+      createdAt: now,
+      updatedAt: now
+    };
+    const doc = await db.create({
+      collection: "_media_folders",
+      data: folderData
+    });
+    return c.json(doc, 201);
+  }
+  async update(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const id = c.req.param("id");
+    if (!db) {
+      return c.json({ message: "Database not configured" }, 500);
+    }
+    if (!id) {
+      return c.json({ message: "Folder ID is required" }, 400);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const existing = await db.findOne({
+      collection: "_media_folders",
+      id
+    });
+    if (!existing) {
+      return c.json({ message: "Folder not found" }, 404);
+    }
+    const updateData = {
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (body.name !== void 0) {
+      const name = String(body.name).trim();
+      if (!name) return c.json({ message: "Folder name cannot be empty" }, 400);
+      updateData.name = name;
+      updateData.slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    }
+    if (body.color !== void 0) {
+      updateData.color = body.color || null;
+    }
+    if (body.parentId !== void 0) {
+      updateData.parentId = body.parentId || null;
+    }
+    const updated = await db.update({
+      collection: "_media_folders",
+      id,
+      data: updateData
+    });
+    return c.json(updated);
+  }
+  async delete(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const id = c.req.param("id");
+    if (!db) {
+      return c.json({ message: "Database not configured" }, 500);
+    }
+    if (!id) {
+      return c.json({ message: "Folder ID is required" }, 400);
+    }
+    const existing = await db.findOne({
+      collection: "_media_folders",
+      id
+    });
+    if (!existing) {
+      return c.json({ message: "Folder not found" }, 404);
+    }
+    await db.delete({
+      collection: "_media_folders",
+      id
+    });
+    return c.json({ success: true, id });
+  }
+};
+
 // src/controllers/auth.controller.ts
 import { randomBytes as randomBytes2 } from "crypto";
 
@@ -4465,6 +4809,9 @@ function accessGate(config, target, action) {
 function serializeFieldForApi(f) {
   if (!f) return f;
   const serialized = { ...f };
+  if (typeof serialized.defaultValue === "function") {
+    serialized.defaultValue = `${SERIALIZED_ADMIN_HOOK_PREFIX}${serialized.defaultValue.toString()}`;
+  }
   if (serialized.admin?.hooks) {
     const hooks = { ...serialized.admin.hooks };
     if (typeof hooks.onChange === "function") {
@@ -4990,6 +5337,22 @@ function registerRoutes(app, config) {
     });
     return c.json({ success: true });
   });
+  app.get("/api/media/folders", async (c) => {
+    const folderController = new MediaFolderController("media");
+    return folderController.list(c);
+  });
+  app.post("/api/media/folders", async (c) => {
+    const folderController = new MediaFolderController("media");
+    return folderController.create(c);
+  });
+  app.patch("/api/media/folders/:id", async (c) => {
+    const folderController = new MediaFolderController("media");
+    return folderController.update(c);
+  });
+  app.delete("/api/media/folders/:id", async (c) => {
+    const folderController = new MediaFolderController("media");
+    return folderController.delete(c);
+  });
   app.get("/api/media/:filename{.+$}", async (c) => {
     const mediaController = new MediaController("media");
     return mediaController.serve(c);
@@ -5002,10 +5365,17 @@ function registerRoutes(app, config) {
     const uploadCollections = config.collections.filter((c) => c.upload);
     for (const col of uploadCollections) {
       const mediaController = new MediaController(col.slug);
+      const folderController = new MediaFolderController(col.slug);
       const prefix = `/api/collections/${col.slug}`;
+      app.get(`${prefix}/folders`, accessGate(config, col, "read"), (c) => folderController.list(c));
+      app.post(`${prefix}/folders`, accessGate(config, col, "create"), (c) => folderController.create(c));
+      app.patch(`${prefix}/folders/:id`, accessGate(config, col, "update"), (c) => folderController.update(c));
+      app.delete(`${prefix}/folders/:id`, accessGate(config, col, "delete"), (c) => folderController.delete(c));
       app.get(`${prefix}/media`, accessGate(config, col, "read"), (c) => mediaController.find(c));
       app.get(`${prefix}/media/:filename{.+$}`, (c) => mediaController.serve(c));
       app.post(`${prefix}/media`, accessGate(config, col, "create"), (c) => mediaController.upload(c));
+      app.post(`${prefix}/media/:id/file`, accessGate(config, col, "update"), (c) => mediaController.replace(c));
+      app.put(`${prefix}/media/:id/file`, accessGate(config, col, "update"), (c) => mediaController.replace(c));
       app.delete(`${prefix}/media/:id`, accessGate(config, col, "delete"), (c) => mediaController.delete(c));
     }
   }

package/dist/{where-sanitizer-47QPJQ6O.js → where-sanitizer-CAAIYSSK.js}

@@ -10,6 +10,25 @@ var NEVER_FILTERABLE_TYPES = [
   "join",
   "collapsible"
 ];
+var SYSTEM_FILTERABLE_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "createdAt",
+  "updatedAt",
+  "createdBy",
+  "updatedBy",
+  "folderId",
+  "filename",
+  "originalFilename",
+  "mimeType",
+  "filesize",
+  "url",
+  "width",
+  "height",
+  "aspectRatio",
+  "blurhash",
+  "alt",
+  "caption"
+]);
 function sanitizeWhereClause(where, fields) {
   const fieldMap = /* @__PURE__ */ new Map();
   function addFieldsToMap(fList, prefix = "") {
@@ -38,7 +57,7 @@ function sanitizeWhereClause(where, fields) {
         }
         continue;
       }
-      if (key === "id") {
+      if (SYSTEM_FILTERABLE_FIELDS.has(key)) {
         result[key] = value;
         continue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dyrected/core",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",