@isardsat/editorial-server 6.3.2 → 6.4.0

package/dist/app.js

@@ -23,8 +23,8 @@ export async function createEditorialServer({ configDirectory = BASE_EDITORIAL_P
         origin: "*",
     }));
     app.route("/api/v1", createConfigRoutes(config));
-    app.route("/api/v1", createDataRoutes(storage));
-    app.route("/api/v1", createFilesRoutes());
+    app.route("/api/v1", createDataRoutes(config, storage));
+    app.route("/api/v1", await createFilesRoutes(config));
     app.route("/api/v1", createActionRoutes(storage, hooks));
     app.route("/", createAdminRoutes(config));
     app.doc("/doc", {
@@ -35,8 +35,9 @@ export async function createEditorialServer({ configDirectory = BASE_EDITORIAL_P
         },
     });
     app.get("/doc/ui", swaggerUI({ url: "/doc" }));
-    app.use("/public/*", serveStatic({
-        root: "./",
+    app.use("/*", serveStatic({
+        root: config.publicDir,
+        rewriteRequestPath: (path) => path.replace(/^\/public/, ""),
     }));
     return {
         app,

package/dist/lib/config.d.ts

@@ -1,6 +1,10 @@
 export declare function createConfig(configDirectory: string): Promise<{
     name: string;
     publicUrl: string;
+    publicDir: string;
+    publicDeletedDir: string;
+    filesUrl: string;
+    largeFilesUrl: string;
     previewUrl?: string | undefined;
     silent?: boolean | undefined;
     firebase?: {

package/dist/lib/schema.d.ts

@@ -1,6 +1,10 @@
 export declare function createSchema(configDirectory: string): Promise<{
     name: string;
     publicUrl: string;
+    publicDir: string;
+    publicDeletedDir: string;
+    filesUrl: string;
+    largeFilesUrl: string;
     previewUrl?: string | undefined;
     silent?: boolean | undefined;
     firebase?: {

package/dist/lib/storage.js

@@ -33,6 +33,7 @@ export function createStorage(dataDirectory) {
     }
     async function createItem(item) {
         const content = await getContent();
+        content[item.type] = content[item.type] ?? {};
         content[item.type][item.id] = EditorialDataItemSchema.parse(item);
         // TODO: Use superjson to safely encode different types.
         await writeFileSafe(dataPath, JSON.stringify(content, null, 2));

package/dist/routes/data.d.ts

@@ -1,3 +1,4 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
+import { type EditorialConfig } from "@isardsat/editorial-common";
 import type { Storage } from "../lib/storage.js";
-export declare function createDataRoutes(storage: Storage): OpenAPIHono<import("hono").Env, {}, "/">;
+export declare function createDataRoutes(config: EditorialConfig, storage: Storage): OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/routes/data.js

@@ -1,7 +1,8 @@
 import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
 import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
-export function createDataRoutes(storage) {
+export function createDataRoutes(config, storage) {
     const app = new OpenAPIHono();
+    const publicFilesUrl = config.filesUrl;
     app.openapi(createRoute({
         method: "get",
         path: "/schema",
@@ -54,6 +55,7 @@ export function createDataRoutes(storage) {
                     param: { name: "lang", in: "query" },
                     example: "es_ES",
                 }),
+                preview: z.string().optional(),
             }),
         },
         responses: {
@@ -65,12 +67,20 @@ export function createDataRoutes(storage) {
                 },
                 description: "Get objects by type",
             },
+            404: {
+                description: "Collection not found",
+            },
         },
     }), async (c) => {
         const { itemType } = c.req.valid("param");
-        const { lang } = c.req.valid("query");
+        const { lang, preview } = c.req.valid("query");
+        const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
         const content = await storage.getContent();
+        const schema = await storage.getSchema();
         const collection = content[itemType];
+        if (!collection) {
+            return c.notFound();
+        }
         // TODO: Formalize this process.
         if (lang) {
             const messages = await storage.getLocalisationMessages(lang);
@@ -81,6 +91,13 @@ export function createDataRoutes(storage) {
                 }
             }
         }
+        for (const [itemKey, itemValue] of Object.entries(collection)) {
+            for (const [key, value] of Object.entries(itemValue)) {
+                if (!schema[itemType].fields[key]?.isUploadedFile)
+                    continue;
+                collection[itemKey][key] = `${origin}/${value}`;
+            }
+        }
         return c.json(collection);
     });
     app.openapi(createRoute({
@@ -131,6 +148,7 @@ export function createDataRoutes(storage) {
                     param: { name: "lang", in: "query" },
                     example: "es_ES",
                 }),
+                preview: z.string().optional(),
             }),
         },
         responses: {
@@ -142,22 +160,39 @@ export function createDataRoutes(storage) {
                 },
                 description: "Get object data",
             },
+            404: {
+                description: "Collection or item not found",
+            },
         },
     }), async (c) => {
         const { itemType, id } = c.req.valid("param");
-        const { lang } = c.req.valid("query");
+        const { lang, preview } = c.req.valid("query");
+        const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
         const content = await storage.getContent();
-        const item = content[itemType][id];
+        const schema = await storage.getSchema();
+        const collection = content[itemType];
+        if (!collection) {
+            return c.notFound();
+        }
+        const item = collection[id];
+        if (!item) {
+            return c.notFound();
+        }
         // TODO: Formalize this process.
         if (lang) {
             const messages = await storage.getLocalisationMessages(lang);
             for (const [key, message] of Object.entries(messages)) {
-                const [contentKey, typeKey, fieldKey, hash] = key.split(".");
+                const [, typeKey, fieldKey] = key.split(".");
                 if (typeKey === id) {
                     item[fieldKey] = message.defaultMessage;
                 }
             }
         }
+        for (const [key, value] of Object.entries(item)) {
+            if (!schema[itemType].fields[key]?.isUploadedFile)
+                continue;
+            item[key] = `${origin}/${value}`;
+        }
         return c.json(item);
     });
     app.openapi(createRoute({

package/dist/routes/files.d.ts

@@ -1,2 +1,3 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-export declare function createFilesRoutes(): OpenAPIHono<import("hono").Env, {}, "/">;
+import { type EditorialConfig } from "@isardsat/editorial-common";
+export declare function createFilesRoutes(config: EditorialConfig): Promise<OpenAPIHono<import("hono").Env, {}, "/">>;

package/dist/routes/files.js

@@ -1,15 +1,24 @@
 import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
 import { EditorialFilesResponseSchema, } from "@isardsat/editorial-common";
 import { readdirSync, statSync } from "node:fs";
-import { access, constants, mkdir, rename } from "node:fs/promises";
-import { basename, join, normalize } from "node:path";
-export function createFilesRoutes() {
+import { access, constants, mkdir, rename, writeFile } from "node:fs/promises";
+import { basename, join, normalize, relative } from "node:path";
+export async function createFilesRoutes(config) {
     const app = new OpenAPIHono();
-    const publicDirPath = "public";
-    const deletedDirPath = "public/.deleted";
+    // Dynamically import the ES module and call its init function
+    const hookScript = join(process.cwd(), "editorial", "largeFileHandler");
+    const largeFilesHandler = await import(`${hookScript}.mjs`).then((mod) => mod.init());
+    const publicFilesUrl = config.filesUrl;
+    const publicDirPath = config.publicDir;
+    const deletedDirPath = config.publicDeletedDir;
     app.openapi(createRoute({
         method: "get",
         path: "/files",
+        request: {
+            query: z.object({
+                preview: z.string().optional(),
+            }),
+        },
         responses: {
             200: {
                 content: {
@@ -20,7 +29,11 @@ export function createFilesRoutes() {
                 description: "Get tree of public files with total size",
             },
         },
-    }), async (c) => {
+    }), 
+    // TODO: Index large files from bucket.
+    async (c) => {
+        const { preview } = c.req.valid("query");
+        const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
         function calculateTotalSize(files) {
             return files.reduce((total, file) => {
                 if (file.type === "file") {
@@ -33,15 +46,19 @@ export function createFilesRoutes() {
             }, 0);
         }
         function readDirectoryChildren(path) {
+            // TODO: Gracefully handle missing directory?
             const directory = readdirSync(path);
             return directory
                 .filter((fileName) => !fileName.startsWith("."))
                 .map((fileName) => {
                 const file = statSync(join(path, fileName));
+                const filePath = join(path, fileName);
                 const isDirectory = file.isDirectory();
+                const relativePath = relative(publicDirPath, filePath);
                 return {
                     name: basename(fileName),
-                    path: join(path, fileName),
+                    path: isDirectory ? relativePath : `${origin}/${relativePath}`,
+                    relativePath: relativePath,
                     size: file.size,
                     type: isDirectory ? "directory" : "file",
                     children: isDirectory
@@ -49,11 +66,45 @@ export function createFilesRoutes() {
                         : undefined,
                 };
             })
-                .sort((a, b) => (a.type === "directory" ? -1 : 0));
+                .toSorted((a, b) => {
+                if (a.type === "directory" && b.type !== "directory")
+                    return -1;
+                if (a.type !== "directory" && b.type === "directory")
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+        }
+        function mergeDirectoryTrees(localFiles, largeFiles) {
+            const merged = [...localFiles];
+            for (const largeFile of largeFiles) {
+                const existingIndex = merged.findIndex((file) => file.name === largeFile.name && file.type === "directory");
+                if (existingIndex !== -1 &&
+                    merged[existingIndex].type === "directory") {
+                    // Merge directories with same name
+                    const existingDir = merged[existingIndex];
+                    merged[existingIndex] = {
+                        ...existingDir,
+                        children: mergeDirectoryTrees(existingDir.children || [], largeFile.children || []),
+                    };
+                }
+                else {
+                    // Add new file/directory
+                    merged.push(largeFile);
+                }
+            }
+            return merged.toSorted((a, b) => {
+                if (a.type === "directory" && b.type !== "directory")
+                    return -1;
+                if (a.type !== "directory" && b.type === "directory")
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
         }
         const files = readDirectoryChildren(publicDirPath);
-        const totalSize = calculateTotalSize(files);
-        return c.json({ files, totalSize });
+        const largeFiles = await largeFilesHandler.list();
+        const mergedFiles = mergeDirectoryTrees(files, largeFiles);
+        const totalSize = calculateTotalSize(mergedFiles);
+        return c.json({ files: mergedFiles, totalSize });
     });
     app.openapi(createRoute({
         method: "delete",
@@ -133,5 +184,86 @@ export function createFilesRoutes() {
             return c.json({ error: "Server error" }, 500);
         }
     });
+    app.openapi(createRoute({
+        method: "put",
+        path: "/files",
+        request: {
+            body: {
+                content: {
+                    "multipart/form-data": {
+                        schema: z.object({
+                            path: z.string().optional(),
+                            files: z.any(),
+                        }),
+                    },
+                },
+                required: true,
+            },
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.string().array(),
+                    },
+                },
+                description: "Files uploaded successfully",
+            },
+            400: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: "Invalid request",
+            },
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: "Server error",
+            },
+        },
+    }), async (c) => {
+        try {
+            const body = await c.req.parseBody();
+            const targetPath = body.path || "";
+            const files = body.files;
+            if (!files) {
+                return c.json({ error: "No files provided" }, 400);
+            }
+            const fileArray = Array.isArray(files) ? files : [files];
+            const uploadedFiles = [];
+            const targetDir = join(publicDirPath, targetPath);
+            const normalizedTargetDir = normalize(targetDir);
+            if (!normalizedTargetDir.startsWith(publicDirPath)) {
+                return c.json({ error: "Invalid target path" }, 400);
+            }
+            await mkdir(normalizedTargetDir, { recursive: true });
+            for (const file of fileArray) {
+                if (file instanceof File) {
+                    if (file.size >= 1e6) {
+                        return c.json({ error: "File too large" }, 400);
+                    }
+                    const fileName = file.name;
+                    const filePath = join(normalizedTargetDir, fileName);
+                    const buffer = await file.arrayBuffer();
+                    await writeFile(filePath, new Uint8Array(buffer));
+                    uploadedFiles.push(fileName);
+                }
+            }
+            return c.json(uploadedFiles, 200);
+        }
+        catch (err) {
+            console.error("Upload failed:", err);
+            return c.json({ error: "Server error" }, 500);
+        }
+    });
     return app;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isardsat/editorial-server",
-  "version": "6.3.2",
+  "version": "6.4.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,8 +14,8 @@
     "hono": "^4.6.20",
     "yaml": "^2.7.0",
     "zod": "^3.24.1",
-    "@isardsat/editorial-admin": "^6.3.2",
-    "@isardsat/editorial-common": "^6.3.2"
+    "@isardsat/editorial-admin": "^6.4.0",
+    "@isardsat/editorial-common": "^6.4.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.0",