@isardsat/editorial-server 6.19.5 → 6.21.0

package/dist/lib/storage.d.ts

@@ -1,4 +1,4 @@
-import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
+import type { EditorialData, EditorialDataObjectWithType, EditorialUpdateDataItem } from "@isardsat/editorial-common";
 export declare function createStorage(dataDirectory: string): {
     getSchema: () => Promise<Record<string, {
         displayName: string;
@@ -31,7 +31,11 @@ export declare function createStorage(dataDirectory: string): {
         createdAt: string;
         updatedAt: string;
     }>;
-    updateItem: (item: EditorialDataObjectWithType) => Promise<{
+    checkItemExists: ({ type, id }: {
+        type: string;
+        id: string;
+    }) => Promise<boolean>;
+    updateItem: (item: EditorialUpdateDataItem) => Promise<{
         [x: string]: unknown;
         id: string;
         isDraft: boolean;

package/dist/lib/storage.js

@@ -90,6 +90,10 @@ export function createStorage(dataDirectory) {
         }
         return true;
     }
+    async function checkItemExists({ type, id }) {
+        const content = await getContent({ production: false });
+        return !!content[type]?.[id];
+    }
     async function createItem(item) {
         const content = await getContent({ production: false });
         content[item.type] = content[item.type] ?? {};
@@ -100,6 +104,9 @@ export function createStorage(dataDirectory) {
         return parsedItem;
     }
     async function updateItem(item) {
+        if (!item.id) {
+            throw new Error("Item ID is required for update.");
+        }
         const content = await getContent({ production: false });
         content[item.type] = content[item.type] ?? {};
         const oldItem = content[item.type][item.id];
@@ -108,7 +115,17 @@ export function createStorage(dataDirectory) {
             ...item,
             updatedAt: new Date().toISOString(),
         });
-        content[item.type][item.id] = newItem;
+        // Handle ID change: if the ID has changed, we need to delete the old item and create a new one with the new ID
+        if (newItem.hasOwnProperty("newId")) {
+            delete content[item.type][item.id];
+            const newId = item.newId || item.id;
+            delete newItem.newId;
+            newItem.id = newId;
+            content[item.type][newId] = newItem;
+        }
+        else {
+            content[item.type][item.id] = newItem;
+        }
         // TODO: Use superjson to safely encode different types.
         await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
         return newItem;
@@ -126,6 +143,7 @@ export function createStorage(dataDirectory) {
         getLocalisationMessages,
         saveLocalisationMessages,
         createItem,
+        checkItemExists,
         updateItem,
         deleteItem,
         saveContent,

package/dist/lib/utils/references.d.ts

@@ -0,0 +1,19 @@
+import { type EditorialData, type EditorialDataItem, type EditorialSchema } from "@isardsat/editorial-common";
+import { type Storage } from "../storage.js";
+/**
+ * Resolves referenced fields in an item, replacing IDs with full objects.
+ * Recursively resolves nested references.
+ */
+export declare function resolveReferences(item: EditorialDataItem, schema: EditorialSchema, itemType: string, content: EditorialData, origin: string, resolvedIds?: Set<string>): EditorialDataItem;
+/**
+ * Resolves all references in a collection.
+ */
+export declare function resolveCollectionReferences(collection: Record<string, EditorialDataItem>, schema: EditorialSchema, itemType: string, content: EditorialData, origin: string): Record<string, EditorialDataItem>;
+export declare function updateOrRemoveReferences(params: {
+    schema: any;
+    content: Record<string, Record<string, any>>;
+    storage: Storage;
+    targetType: string;
+    oldId: string;
+    newId?: string | null;
+}): Promise<void>;

package/dist/lib/utils/references.js

@@ -0,0 +1,135 @@
+import { getChoicesReference, } from "@isardsat/editorial-common";
+import {} from "../storage.js";
+/**
+ * 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.
+ */
+export 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 = getChoicesReference(fieldConfig.choicesFixed);
+        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.
+ */
+export 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 async function updateOrRemoveReferences(params) {
+    const { schema, content, storage, targetType, oldId, newId } = params;
+    for (const [containerType, containerSchema] of Object.entries(schema)) {
+        const fields = containerSchema.fields || {};
+        const collection = content[containerType] || {};
+        // Find fields in this type that reference the target type
+        const referenceFields = Object.entries(fields).filter(([, fieldConfig]) => {
+            if (fieldConfig.type !== "select" &&
+                fieldConfig.type !== "multiselect") {
+                return false;
+            }
+            return getChoicesReference(fieldConfig.choicesFixed) === targetType;
+        });
+        if (referenceFields.length === 0)
+            continue;
+        for (const [itemId, item] of Object.entries(collection)) {
+            let changed = false;
+            const patchedItem = { ...item };
+            for (const [fieldKey, fieldConfig] of referenceFields) {
+                if (fieldConfig.type === "select") {
+                    if (patchedItem[fieldKey] === oldId) {
+                        patchedItem[fieldKey] = newId ?? null; // rename or remove
+                        changed = true;
+                    }
+                }
+                else if (fieldConfig.type === "multiselect") {
+                    const value = patchedItem[fieldKey];
+                    if (Array.isArray(value)) {
+                        let next;
+                        if (newId != null) {
+                            next = value.map((v) => (v === oldId ? newId : v));
+                        }
+                        else {
+                            next = value.filter((v) => v !== oldId); // remove
+                        }
+                        if (next.length !== value.length ||
+                            next.some((v, i) => v !== value[i])) {
+                            patchedItem[fieldKey] = next;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            if (changed) {
+                await storage.updateItem({
+                    ...patchedItem,
+                    type: containerType,
+                    id: itemId,
+                });
+            }
+        }
+    }
+}

package/dist/lib/utils/version.d.ts

@@ -0,0 +1,2 @@
+import { type EditorialVersionResponse } from "@isardsat/editorial-common";
+export declare function getCurrentAndLatestVersion(): Promise<EditorialVersionResponse>;

package/dist/lib/utils/version.js

@@ -0,0 +1,22 @@
+import {} from "@isardsat/editorial-common";
+import pkg from "../../../package.json" with { type: "json" };
+const CURRENT_VERSION = pkg.version;
+let latestVersionCache = null;
+let lastChecked = 0;
+export async function getCurrentAndLatestVersion() {
+    const now = Date.now();
+    if (latestVersionCache && now - lastChecked < 60_000 * 10) {
+        // cache 10 min
+        return { current: CURRENT_VERSION, latest: latestVersionCache };
+    }
+    try {
+        const res = await fetch("https://registry.npmjs.org/@isardsat/editorial-admin", { headers: { Accept: "application/vnd.npm.install-v1+json" } });
+        const data = (await res.json());
+        latestVersionCache = data["dist-tags"].latest;
+        lastChecked = now;
+        return { current: CURRENT_VERSION, latest: latestVersionCache };
+    }
+    catch {
+        throw new Error("Failed to fetch latest version from npm registry");
+    }
+}

package/dist/routes/app.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routes/app.js

@@ -0,0 +1 @@
+export {};

package/dist/routes/data.js

@@ -1,9 +1,9 @@
 import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
-import { EditorialDataItemSchema, EditorialDataSchema, EditorialDiffResponseSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialDiffResponseSchema, EditorialSchemaSchema, EditorialUpdateDataItemSchema, } from "@isardsat/editorial-common";
 import { createCache } from "../lib/cache.js";
 import { firebaseAuth } from "../lib/middleware/auth.js";
 import { getChangedFields } from "../lib/utils/diff.js";
-import { resolveCollectionReferences, resolveReferences, } from "../lib/utils/resolve.js";
+import { resolveCollectionReferences, resolveReferences, updateOrRemoveReferences, } from "../lib/utils/references.js";
 import { generateMetaSchema } from "../lib/utils/schema.js";
 export function createDataRoutes(config, storage) {
     const app = new OpenAPIHono();
@@ -294,7 +294,7 @@ export function createDataRoutes(config, storage) {
     app.openapi(createRoute({
         method: "put",
         path: "/data/{itemType}/{id}",
-        summary: "Create or update object data by type and id",
+        summary: "Create object data by type and id",
         request: {
             params: z.object({
                 itemType: z.string().openapi({
@@ -324,12 +324,22 @@ export function createDataRoutes(config, storage) {
                 },
                 description: "Create a new object",
             },
+            409: {
+                description: "Item with this type and id already exists",
+            },
         },
         tags: ["Data"],
         middleware: [firebaseAuth(config.firebase?.projectId || "")],
         security: [{ bearerAuth: [] }],
     }), async (c) => {
         const itemAtts = await c.req.json();
+        const itemExists = await storage.checkItemExists({
+            type: itemAtts.type,
+            id: itemAtts.id,
+        });
+        if (itemExists) {
+            return c.json({ error: "Item with this type and id already exists" }, 409);
+        }
         const newItem = await storage.createItem(itemAtts);
         cache.invalidateContent();
         return c.json(newItem);
@@ -352,7 +362,7 @@ export function createDataRoutes(config, storage) {
             body: {
                 content: {
                     "application/json": {
-                        schema: EditorialDataItemSchema,
+                        schema: EditorialUpdateDataItemSchema,
                     },
                 },
                 required: true,
@@ -367,15 +377,51 @@ export function createDataRoutes(config, storage) {
                 },
                 description: "Update object",
             },
+            409: {
+                description: "Item with this type and id already exists",
+            },
         },
         tags: ["Data"],
         middleware: [firebaseAuth(config.firebase?.projectId || "")],
         security: [{ bearerAuth: [] }],
     }), async (c) => {
+        const { itemType, id } = c.req.valid("param");
         const itemAtts = await c.req.json();
-        const newItem = await storage.updateItem(itemAtts);
+        if (itemAtts.newId) {
+            const itemWithNewIdExists = await storage.checkItemExists({
+                type: itemAtts.type,
+                id: itemAtts.newId,
+            });
+            if (itemWithNewIdExists) {
+                return c.json({ error: "Item with this type and this new id already exists" }, 409);
+            }
+        }
+        const oldId = id;
+        const newId = itemAtts.newId || itemAtts.id || id;
+        const renamed = oldId !== newId;
+        // Update renamed item first
+        const updatedItem = await storage.updateItem({
+            ...itemAtts,
+            type: itemType,
+            id: oldId,
+        });
+        // Repair references if needed
+        if (renamed) {
+            const [schema, content] = await Promise.all([
+                storage.getSchema(),
+                storage.getContent({ production: false }), // preview/content being edited
+            ]);
+            await updateOrRemoveReferences({
+                schema,
+                content,
+                storage,
+                targetType: itemType,
+                oldId,
+                newId,
+            });
+        }
         cache.invalidateContent();
-        return c.json(newItem);
+        return c.json(updatedItem);
     });
     app.openapi(createRoute({
         method: "delete",
@@ -409,6 +455,19 @@ export function createDataRoutes(config, storage) {
     }), async (c) => {
         const { itemType, id } = c.req.valid("param");
         await storage.deleteItem({ type: itemType, id });
+        // Remove references to the deleted item
+        const [schema, content] = await Promise.all([
+            storage.getSchema(),
+            storage.getContent({ production: false }),
+        ]);
+        await updateOrRemoveReferences({
+            schema,
+            content,
+            storage,
+            targetType: itemType,
+            oldId: id,
+            newId: null,
+        });
         cache.invalidateContent();
         return c.json(true, 200);
     });
@@ -492,7 +551,7 @@ export function createDataRoutes(config, storage) {
                 if (singletonKey) {
                     const previewItem = previewCollection[singletonKey];
                     const productionItem = productionCollection[singletonKey];
-                    if (previewItem && !productionItem) {
+                    if (previewItem && !previewItem.isDraft && !productionItem) {
                         // Singleton exists in preview but not in production = added
                         result.singles[itemType] = {
                             status: "added",
@@ -508,7 +567,8 @@ export function createDataRoutes(config, storage) {
                             production: productionItem,
                         };
                     }
-                    else if (previewItem?.updatedAt !== productionItem?.updatedAt) {
+                    else if (productionItem &&
+                        previewItem?.updatedAt !== productionItem?.updatedAt) {
                         // Singleton has different updatedAt = modified
                         const changedFields = getChangedFields(previewItem, productionItem);
                         if (changedFields.length === 0) {
@@ -533,7 +593,7 @@ export function createDataRoutes(config, storage) {
                 // Find added and modified items
                 for (const [id, previewItem] of Object.entries(previewCollection)) {
                     const productionItem = productionCollection[id];
-                    if (!productionItem) {
+                    if (!previewItem.isDraft && !productionItem) {
                         // Item exists in preview but not in production = added
                         added.push({
                             id,
@@ -541,7 +601,8 @@ export function createDataRoutes(config, storage) {
                             updatedAt: previewItem.updatedAt,
                         });
                     }
-                    else if (previewItem.updatedAt !== productionItem.updatedAt) {
+                    else if (productionItem &&
+                        previewItem.updatedAt !== productionItem.updatedAt) {
                         // Item has different updatedAt = modified (not yet published)
                         const changedFields = getChangedFields(previewItem, productionItem);
                         if (changedFields.length === 0) {

package/dist/routes/version.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Hooks } from "../lib/hooks.js";
+export declare function createVersionRoutes(hooks: Hooks): OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/routes/version.js

@@ -0,0 +1,69 @@
+import { OpenAPIHono, z } from "@hono/zod-openapi";
+import { EditorialVersionResponseSchema } from "@isardsat/editorial-common";
+import { getCurrentAndLatestVersion } from "../lib/utils/version.js";
+export function createVersionRoutes(hooks) {
+    const app = new OpenAPIHono();
+    app.openapi({
+        method: "get",
+        path: "/version",
+        summary: "Get Editorial version",
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialVersionResponseSchema,
+                    },
+                },
+                description: "Editorial version",
+            },
+            500: {
+                content: {
+                    "application/json": { schema: z.object({ error: z.string() }) },
+                },
+                description: "Server error",
+            },
+        },
+        tags: ["Version"],
+    }, async (c) => {
+        try {
+            const { current, latest } = await getCurrentAndLatestVersion();
+            return c.json({ current, latest }, 200);
+        }
+        catch (error) {
+            return c.json({ error: "Failed to fetch latest version from npm registry" }, 500);
+        }
+    });
+    app.openapi({
+        method: "post",
+        path: "/version/upgrade",
+        summary: "Trigger Editorial upgrade hook",
+        description: "Triggers a placeholder hook to start upgrade flow. Replace hook implementation with real deployment/migration logic.",
+        responses: {
+            202: {
+                content: {
+                    "application/json": {
+                        schema: z.boolean(),
+                    },
+                },
+                description: "Upgrade request accepted",
+            },
+            500: {
+                content: {
+                    "application/json": { schema: z.object({ error: z.string() }) },
+                },
+                description: "Server error",
+            },
+        },
+        tags: ["Version"],
+    }, async (c) => {
+        try {
+            await hooks.onUpgrade();
+        }
+        catch (error) {
+            console.error("Error executing onUpgrade script:", error);
+            return c.json({ error: "Failed upgrade Editorial version" }, 500);
+        }
+        return c.json(true, 202);
+    });
+    return app;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isardsat/editorial-server",
-  "version": "6.19.5",
+  "version": "6.21.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "jose": "^6.1.3",
     "yaml": "^2.8.1",
     "zod": "^4.1.11",
-    "@isardsat/editorial-admin": "^6.19.5",
-    "@isardsat/editorial-common": "^6.19.5"
+    "@isardsat/editorial-admin": "^6.21.0",
+    "@isardsat/editorial-common": "^6.21.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.0",