@isardsat/editorial-server 6.13.0 → 6.14.0

package/dist/lib/schema.d.ts

@@ -2,12 +2,15 @@ export declare function createSchema(configDirectory: string): Promise<Record<st
     displayName: string;
     fields: Record<string, {
         [x: string]: unknown;
-        type: "string" | "number" | "boolean" | "url" | "date" | "datetime" | "markdown" | "color" | "select";
+        type: "string" | "number" | "boolean" | "url" | "date" | "datetime" | "markdown" | "color" | "select" | "multiselect";
         displayName: string;
         optional: boolean;
         displayExtra?: string | undefined;
         placeholder?: string | undefined;
         showInSummary?: boolean | undefined;
+        options?: string[] | undefined;
+        maxSelectedOptions?: number | undefined;
+        minSelectedOptions?: number | undefined;
     }>;
     filterBy?: string | undefined;
     singleton?: boolean | undefined;

package/dist/lib/storage.d.ts

@@ -4,12 +4,15 @@ export declare function createStorage(dataDirectory: string): {
         displayName: string;
         fields: Record<string, {
             [x: string]: unknown;
-            type: "string" | "number" | "boolean" | "url" | "date" | "datetime" | "markdown" | "color" | "select";
+            type: "string" | "number" | "boolean" | "url" | "date" | "datetime" | "markdown" | "color" | "select" | "multiselect";
             displayName: string;
             optional: boolean;
             displayExtra?: string | undefined;
             placeholder?: string | undefined;
             showInSummary?: boolean | undefined;
+            options?: string[] | undefined;
+            maxSelectedOptions?: number | undefined;
+            minSelectedOptions?: number | undefined;
         }>;
         filterBy?: string | undefined;
         singleton?: boolean | undefined;

package/dist/routes/data.js

@@ -1,5 +1,5 @@
 import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
-import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, getOptionsReference, } from "@isardsat/editorial-common";
 function createCache() {
     let schemaCache = null;
     const contentCache = new Map();
@@ -36,6 +36,86 @@ function createCache() {
         },
     };
 }
+/**
+ * Resolves uploaded file paths to full URLs for an item.
+ */
+function resolveFileUrls(item, schema, itemType, origin) {
+    const resolvedItem = { ...item };
+    const itemSchema = schema[itemType];
+    if (!itemSchema)
+        return resolvedItem;
+    for (const [key, value] of Object.entries(resolvedItem)) {
+        if (!itemSchema.fields[key]?.isUploadedFile)
+            continue;
+        if (typeof value !== "string")
+            continue;
+        if (value.startsWith("http"))
+            continue;
+        resolvedItem[key] = `${origin}/${value}`;
+    }
+    return resolvedItem;
+}
+/**
+ * Resolves referenced fields in an item, replacing IDs with full objects.
+ * Recursively resolves nested references.
+ */
+function resolveReferences(item, schema, itemType, content, origin, resolvedIds = new Set()) {
+    const itemIdentifier = `${itemType}:${item.id}`;
+    // Prevent circular references
+    if (resolvedIds.has(itemIdentifier)) {
+        return resolveFileUrls(item, schema, itemType, origin);
+    }
+    resolvedIds.add(itemIdentifier);
+    // First resolve file URLs for the current item
+    let resolvedItem = resolveFileUrls(item, schema, itemType, origin);
+    const itemSchema = schema[itemType];
+    if (!itemSchema)
+        return resolvedItem;
+    for (const [fieldKey, fieldConfig] of Object.entries(itemSchema.fields)) {
+        if (fieldConfig.type !== "select" && fieldConfig.type !== "multiselect") {
+            continue;
+        }
+        const referencedType = getOptionsReference(fieldConfig.options);
+        if (!referencedType)
+            continue;
+        const referencedCollection = content[referencedType];
+        if (!referencedCollection)
+            continue;
+        const fieldValue = item[fieldKey];
+        if (fieldConfig.type === "select" && typeof fieldValue === "string") {
+            // Single reference - replace ID with full object
+            const referencedItem = referencedCollection[fieldValue];
+            if (referencedItem) {
+                // Recursively resolve nested references
+                resolvedItem[fieldKey] = resolveReferences(referencedItem, schema, referencedType, content, origin, new Set(resolvedIds));
+            }
+        }
+        else if (fieldConfig.type === "multiselect" &&
+            Array.isArray(fieldValue)) {
+            // Multiple references - replace IDs with full objects
+            resolvedItem[fieldKey] = fieldValue
+                .map((id) => {
+                const referencedItem = referencedCollection[id];
+                if (!referencedItem)
+                    return null;
+                // Recursively resolve nested references
+                return resolveReferences(referencedItem, schema, referencedType, content, origin, new Set(resolvedIds));
+            })
+                .filter(Boolean);
+        }
+    }
+    return resolvedItem;
+}
+/**
+ * Resolves all references in a collection.
+ */
+function resolveCollectionReferences(collection, schema, itemType, content, origin) {
+    const resolvedCollection = {};
+    for (const [itemKey, item] of Object.entries(collection)) {
+        resolvedCollection[itemKey] = resolveReferences(item, schema, itemType, content, origin);
+    }
+    return resolvedCollection;
+}
 export function createDataRoutes(config, storage) {
     const app = new OpenAPIHono();
     const cache = createCache();
@@ -70,6 +150,13 @@ export function createDataRoutes(config, storage) {
                     example: "es_ES",
                 }),
                 preview: z.string().optional(),
+                resolve: z
+                    .string()
+                    .optional()
+                    .openapi({
+                    param: { name: "resolve", in: "query" },
+                    description: "Resolve referenced fields to full objects",
+                }),
             }),
         },
         responses: {
@@ -83,9 +170,19 @@ export function createDataRoutes(config, storage) {
             },
         },
     }), async (c) => {
-        const { preview } = c.req.valid("query");
+        const { preview, resolve } = c.req.valid("query");
         const content = await cache.getContent(storage, { production: !preview });
-        return c.json(content);
+        if (!resolve) {
+            return c.json(content);
+        }
+        const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
+        // Resolve references for all collections
+        const schema = await cache.getSchema(storage);
+        const resolvedContent = {};
+        for (const [itemType, collection] of Object.entries(content)) {
+            resolvedContent[itemType] = resolveCollectionReferences(collection, schema, itemType, content, origin);
+        }
+        return c.json(resolvedContent);
     });
     app.openapi(createRoute({
         method: "get",
@@ -106,6 +203,13 @@ export function createDataRoutes(config, storage) {
                     example: "es_ES",
                 }),
                 preview: z.string().optional(),
+                resolve: z
+                    .string()
+                    .optional()
+                    .openapi({
+                    param: { name: "resolve", in: "query" },
+                    description: "Resolve referenced fields to full objects",
+                }),
             }),
         },
         responses: {
@@ -123,7 +227,7 @@ export function createDataRoutes(config, storage) {
         },
     }), async (c) => {
         const { itemType } = c.req.valid("param");
-        const { lang, preview } = c.req.valid("query");
+        const { lang, preview, resolve } = c.req.valid("query");
         const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
         const content = await cache.getContent(storage, {
             production: !preview,
@@ -149,6 +253,11 @@ export function createDataRoutes(config, storage) {
                 }
             }
         }
+        // Resolve references if requested (includes file URL resolution)
+        if (resolve) {
+            return c.json(resolveCollectionReferences(collection, schema, itemType, content, origin));
+        }
+        // Apply file URL resolution for non-resolved requests
         for (const [itemKey, itemValue] of Object.entries(collection)) {
             for (const [key, value] of Object.entries(itemValue)) {
                 if (!schema[itemType].fields[key]?.isUploadedFile)
@@ -219,6 +328,13 @@ export function createDataRoutes(config, storage) {
                     example: "es_ES",
                 }),
                 preview: z.string().optional(),
+                resolve: z
+                    .string()
+                    .optional()
+                    .openapi({
+                    param: { name: "resolve", in: "query" },
+                    description: "Resolve referenced fields to full objects",
+                }),
             }),
         },
         responses: {
@@ -236,7 +352,7 @@ export function createDataRoutes(config, storage) {
         },
     }), async (c) => {
         const { itemType, id } = c.req.valid("param");
-        const { lang, preview } = c.req.valid("query");
+        const { lang, preview, resolve } = c.req.valid("query");
         const origin = preview ? new URL(c.req.url).origin : publicFilesUrl;
         const content = await cache.getContent(storage, {
             production: !preview,
@@ -247,7 +363,7 @@ export function createDataRoutes(config, storage) {
         if (!collection) {
             return c.notFound();
         }
-        const item = collection[id];
+        let item = collection[id];
         if (!item) {
             return c.notFound();
         }
@@ -261,6 +377,12 @@ export function createDataRoutes(config, storage) {
                 }
             }
         }
+        // Resolve references if requested (includes file URL resolution)
+        if (resolve) {
+            item = resolveReferences(item, schema, itemType, content, origin);
+            return c.json(item);
+        }
+        // Apply file URL resolution for non-resolved requests
         for (const [key, value] of Object.entries(item)) {
             if (!schema[itemType].fields[key]?.isUploadedFile)
                 continue;

package/dist/routes/files.js

@@ -2,7 +2,7 @@ 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, writeFile } from "node:fs/promises";
-import { basename, join, normalize, relative } from "node:path";
+import { basename, dirname, join, normalize, relative } from "node:path";
 export async function createFilesRoutes(config) {
     const app = new OpenAPIHono();
     // Dynamically import the ES module and call its init function
@@ -114,6 +114,7 @@ export async function createFilesRoutes(config) {
                 content: {
                     "application/json": {
                         schema: z.object({
+                            // relative to publicDirPath, e.g. "images/2026/a.png" or "images/2026"
                             path: z.string(),
                         }),
                     },
@@ -123,60 +124,46 @@ export async function createFilesRoutes(config) {
         },
         responses: {
             200: {
-                content: {
-                    "application/json": {
-                        schema: z.boolean(),
-                    },
-                },
-                description: "",
+                content: { "application/json": { schema: z.boolean() } },
+                description: "Deleted (moved to deleted folder)",
             },
             400: {
                 content: {
-                    "application/json": {
-                        schema: z.object({
-                            error: z.string(),
-                        }),
-                    },
+                    "application/json": { schema: z.object({ error: z.string() }) },
                 },
                 description: "Invalid file path",
             },
             404: {
                 content: {
-                    "application/json": {
-                        schema: z.object({
-                            error: z.string(),
-                        }),
-                    },
+                    "application/json": { schema: z.object({ error: z.string() }) },
                 },
                 description: "File not found",
             },
             500: {
                 content: {
-                    "application/json": {
-                        schema: z.object({
-                            error: z.string(),
-                        }),
-                    },
+                    "application/json": { schema: z.object({ error: z.string() }) },
                 },
                 description: "Server error",
             },
         },
     }), async (c) => {
-        const { path: filePath } = c.req.valid("json");
+        const { path: relativePathInput } = c.req.valid("json");
         try {
-            const normalizedPath = normalize(filePath);
-            if (!normalizedPath.startsWith(publicDirPath)) {
+            const rel = normalize(relativePathInput).replace(/^([/\\])+/, "");
+            const absoluteSource = normalize(join(publicDirPath, rel));
+            const publicRoot = normalize(publicDirPath + (publicDirPath.endsWith("/") ? "" : "/"));
+            if (!absoluteSource.startsWith(publicRoot)) {
                 return c.json({ error: "Invalid file path" }, 400);
             }
-            const exists = await access(filePath, constants.W_OK)
+            const exists = await access(absoluteSource, constants.F_OK)
                 .then(() => true)
                 .catch(() => false);
             if (!exists) {
                 return c.json({ error: "File not found" }, 404);
             }
-            // Move to deleted directory
-            await mkdir(deletedDirPath, { recursive: true });
-            await rename(filePath, join(deletedDirPath, basename(filePath)));
+            const absoluteTarget = normalize(join(deletedDirPath, rel));
+            await mkdir(dirname(absoluteTarget), { recursive: true });
+            await rename(absoluteSource, absoluteTarget);
             return c.json(true, 200);
         }
         catch (err) {
@@ -249,7 +236,9 @@ export async function createFilesRoutes(config) {
             for (const file of fileArray) {
                 if (file instanceof File) {
                     if (file.size >= 1e6) {
-                        return c.json({ error: "File too large" }, 400);
+                        await largeFilesHandler.upload(file, { path: targetPath });
+                        uploadedFiles.push(file.name);
+                        continue;
                     }
                     const fileName = file.name;
                     const filePath = join(normalizedTargetDir, fileName);
@@ -265,5 +254,95 @@ export async function createFilesRoutes(config) {
             return c.json({ error: "Server error" }, 500);
         }
     });
+    app.openapi(createRoute({
+        method: "post",
+        path: "/files/directory",
+        request: {
+            body: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            // path relative to publicDirPath, e.g. "images/2026"
+                            path: z.string().optional().default(""),
+                            // directory name to create, e.g. "new-folder"
+                            name: z.string().min(1),
+                        }),
+                    },
+                },
+                required: true,
+            },
+        },
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            relativePath: z.string(),
+                        }),
+                    },
+                },
+                description: "Directory created",
+            },
+            400: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: "Invalid directory path/name",
+            },
+            409: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: "Directory already exists",
+            },
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: "Server error",
+            },
+        },
+    }), async (c) => {
+        try {
+            const { path, name } = c.req.valid("json");
+            // Avoid path traversal and invalid names
+            if (name.includes("/") ||
+                name.includes("\\") ||
+                name === "." ||
+                name === "..") {
+                return c.json({ error: "Invalid directory name" }, 400);
+            }
+            const targetDir = join(publicDirPath, path ?? "", name);
+            const normalizedTargetDir = normalize(targetDir);
+            if (!normalizedTargetDir.startsWith(publicDirPath)) {
+                return c.json({ error: "Invalid directory path" }, 400);
+            }
+            const exists = await access(normalizedTargetDir, constants.F_OK)
+                .then(() => true)
+                .catch(() => false);
+            if (exists) {
+                return c.json({ error: "Directory already exists" }, 409);
+            }
+            await mkdir(normalizedTargetDir, { recursive: true });
+            const relativePath = relative(publicDirPath, normalizedTargetDir);
+            return c.json({ relativePath }, 201);
+        }
+        catch (err) {
+            console.error("Create directory failed:", err);
+            return c.json({ error: "Server error" }, 500);
+        }
+    });
     return app;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isardsat/editorial-server",
-  "version": "6.13.0",
+  "version": "6.14.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,8 +14,8 @@
     "hono": "^4.9.8",
     "yaml": "^2.8.1",
     "zod": "^4.1.11",
-    "@isardsat/editorial-admin": "^6.13.0",
-    "@isardsat/editorial-common": "^6.13.0"
+    "@isardsat/editorial-common": "^6.14.0",
+    "@isardsat/editorial-admin": "^6.14.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.0",