@isardsat/editorial-server 6.10.0 → 6.11.1

package/dist/lib/schema.d.ts

@@ -9,5 +9,6 @@ export declare function createSchema(configDirectory: string): Promise<Record<st
         placeholder?: string | undefined;
         showInSummary?: boolean | undefined;
     }>;
+    filterBy?: string | undefined;
     singleton?: boolean | undefined;
 }>>;

package/dist/lib/storage copy.d.ts

@@ -0,0 +1,46 @@
+import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
+export declare function createStorage(dataDirectory: string): {
+    getSchema: () => Promise<Record<string, {
+        displayName: string;
+        fields: Record<string, {
+            [x: string]: unknown;
+            type: "string" | "number" | "boolean" | "url" | "date" | "datetime" | "markdown" | "color" | "select";
+            displayName: string;
+            optional: boolean;
+            displayExtra?: string | undefined;
+            placeholder?: string | undefined;
+            showInSummary?: boolean | undefined;
+        }>;
+        singleton?: boolean | undefined;
+    }>>;
+    getContent: ({ production, }: {
+        production?: boolean;
+    }) => Promise<EditorialData>;
+    getLocalisationMessages: (langCode: string) => Promise<any>;
+    saveLocalisationMessages: (messages: any) => Promise<boolean>;
+    createItem: (item: EditorialDataObjectWithType) => Promise<{
+        [x: string]: unknown;
+        id: string;
+        isDraft: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    updateItem: (item: EditorialDataObjectWithType) => Promise<{
+        [x: string]: unknown;
+        id: string;
+        isDraft: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    deleteItem: (item: EditorialDataObjectWithType) => Promise<Record<string, Record<string, {
+        [x: string]: unknown;
+        id: string;
+        isDraft: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>>>;
+    saveContent: ({ production }: {
+        production?: boolean;
+    }) => Promise<boolean>;
+};
+export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/storage copy.js

@@ -0,0 +1,137 @@
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { parse } from "yaml";
+import { writeFileSafe } from "./utils/fs.js";
+export function createStorage(dataDirectory) {
+    const schemaPath = join(dataDirectory, "schema.yaml");
+    const dataPath = join(dataDirectory, "data.json");
+    const dataProdPath = join(dataDirectory, "data.prod.json");
+    const dataExtractedPath = join(dataDirectory, "data.messages.json");
+    async function getSchema() {
+        const schemaFile = await readFile(schemaPath, "utf-8").then((value) => parse(value));
+        const schema = EditorialSchemaSchema.parse(schemaFile);
+        return schema;
+    }
+    /**
+     * TODO: This should ideally cache the result of reading the file until an update occurs.
+     */
+    async function getContent({ production, }) {
+        const content = await readFile(production ? dataProdPath : dataPath, "utf-8").then((value) => EditorialDataSchema.parse(JSON.parse(value)));
+        return content;
+    }
+    async function getLocalisationMessages(langCode) {
+        return await readFile(join(dataDirectory, "locales", "messages", `${langCode}.json`), "utf-8").then((value) => JSON.parse(value));
+    }
+    async function saveContent({ production }) {
+        const content = await getContent({ production: false });
+        /** Do not save any items that have `isDraft` */
+        if (production) {
+            const filteredContent = {};
+            for (const [itemType, items] of Object.entries(content)) {
+                filteredContent[itemType] = {};
+                const typedItems = items;
+                for (const [itemId, item] of Object.entries(typedItems)) {
+                    if (!item.isDraft) {
+                        filteredContent[itemType][itemId] = item;
+                    }
+                }
+            }
+            await writeFileSafe(dataProdPath, JSON.stringify(EditorialDataSchema.parse(filteredContent), null, 2));
+            const usedKeys = collectUsedMessageKeys(filteredContent);
+            console.log("🚀 ~ saveContent ~ usedKeys:", usedKeys);
+            const localesDir = join(dataDirectory, "locales", "messages");
+            const locales = await getAllLocalesMessages(localesDir);
+            for (const locale of locales) {
+                const pruned = pruneMessages(locale.messages, usedKeys);
+                await writeFileSafe(locale.path, JSON.stringify(pruned, null, 2));
+            }
+            return true;
+        }
+        await writeFileSafe(dataPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
+        return true;
+    }
+    async function saveLocalisationMessages(messages) {
+        await writeFileSafe(dataExtractedPath, JSON.stringify(messages, null, 2));
+        return true;
+    }
+    async function createItem(item) {
+        const content = await getContent({ production: false });
+        content[item.type] = content[item.type] ?? {};
+        const parsedItem = EditorialDataItemSchema.parse(item);
+        content[item.type][item.id] = parsedItem;
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return parsedItem;
+    }
+    async function updateItem(item) {
+        const content = await getContent({ production: false });
+        content[item.type] = content[item.type] ?? {};
+        const oldItem = content[item.type][item.id];
+        const newItem = EditorialDataItemSchema.parse({
+            ...oldItem,
+            ...item,
+            updatedAt: new Date().toISOString(),
+        });
+        content[item.type][item.id] = newItem;
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return newItem;
+    }
+    async function deleteItem(item) {
+        const content = await getContent({ production: false });
+        delete content[item.type][item.id];
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return content;
+    }
+    function collectFromItem(value, keys) {
+        console.log("🚀 ~ collectFromItem ~ typeof value:", typeof value);
+        if (!value)
+            return;
+        if (typeof value === "object") {
+            if (typeof value.i18nKey === "string") {
+                keys.add(value.i18nKey);
+            }
+            for (const v of Object.values(value)) {
+                collectFromItem(v, keys);
+            }
+        }
+    }
+    function collectUsedMessageKeys(content) {
+        const keys = new Set();
+        for (const items of Object.values(content)) {
+            for (const item of Object.values(items)) {
+                collectFromItem(item, keys);
+            }
+        }
+        return keys;
+    }
+    async function getAllLocalesMessages(dir) {
+        const files = await readdir(dir);
+        return Promise.all(files.map(async (file) => ({
+            file,
+            path: join(dir, file),
+            messages: JSON.parse(await readFile(join(dir, file), "utf-8")),
+        })));
+    }
+    function pruneMessages(messages, usedKeys) {
+        const pruned = {};
+        for (const key of usedKeys) {
+            if (messages[key]) {
+                pruned[key] = messages[key];
+            }
+        }
+        return pruned;
+    }
+    return {
+        getSchema,
+        getContent,
+        getLocalisationMessages,
+        saveLocalisationMessages,
+        createItem,
+        updateItem,
+        deleteItem,
+        saveContent,
+    };
+}

package/dist/lib/storage.d.ts

@@ -11,13 +11,14 @@ export declare function createStorage(dataDirectory: string): {
             placeholder?: string | undefined;
             showInSummary?: boolean | undefined;
         }>;
+        filterBy?: string | undefined;
         singleton?: boolean | undefined;
     }>>;
     getContent: ({ production, }: {
         production?: boolean;
     }) => Promise<EditorialData>;
     getLocalisationMessages: (langCode: string) => Promise<any>;
-    saveLocalisationMessages: (messages: any) => Promise<boolean>;
+    saveLocalisationMessages: (newMessages: any) => Promise<boolean>;
     createItem: (item: EditorialDataObjectWithType) => Promise<{
         [x: string]: unknown;
         id: string;

package/dist/lib/storage.js

@@ -1,5 +1,5 @@
 import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
-import { readFile } from "fs/promises";
+import { readFile, readdir } from "fs/promises";
 import { join } from "path";
 import { parse } from "yaml";
 import { writeFileSafe } from "./utils/fs.js";
@@ -8,6 +8,7 @@ export function createStorage(dataDirectory) {
     const dataPath = join(dataDirectory, "data.json");
     const dataProdPath = join(dataDirectory, "data.prod.json");
     const dataExtractedPath = join(dataDirectory, "data.messages.json");
+    const localesPath = join(dataDirectory, "locales", "messages");
     async function getSchema() {
         const schemaFile = await readFile(schemaPath, "utf-8").then((value) => parse(value));
         const schema = EditorialSchemaSchema.parse(schemaFile);
@@ -43,8 +44,50 @@ export function createStorage(dataDirectory) {
         await writeFileSafe(dataPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
         return true;
     }
-    async function saveLocalisationMessages(messages) {
-        await writeFileSafe(dataExtractedPath, JSON.stringify(messages, null, 2));
+    async function getAllLocalesMessages(dir) {
+        const files = await readdir(dir);
+        return Promise.all(files.map(async (file) => ({
+            file,
+            path: join(dir, file),
+            messages: JSON.parse(await readFile(join(dir, file), "utf-8")),
+        })));
+    }
+    function pruneMessages(messages, deletedItemKeys) {
+        const pruned = { ...messages };
+        deletedItemKeys.forEach((key) => {
+            if (pruned.hasOwnProperty(key)) {
+                delete pruned[key];
+            }
+        });
+        return pruned;
+    }
+    async function saveLocalisationMessages(newMessages) {
+        const productionMessages = await readFile(dataExtractedPath, "utf-8").then((value) => JSON.parse(value));
+        await writeFileSafe(dataExtractedPath, JSON.stringify(newMessages, null, 2));
+        /**
+         * Get deleted items by checking
+         * keys that are in productionMessages but not in newMessages
+         */
+        const deletedItemKeys = [];
+        for (const itemType of Object.keys(productionMessages)) {
+            if (!newMessages[itemType]) {
+                /**
+                 * We need to store both the full itemType with hash and the shortItemType without hash
+                 * The itemType is used for locale files starting with underscore _
+                 * The shortItemType is used for normal locale files
+                 */
+                deletedItemKeys.push(itemType);
+                const shortItemType = itemType.split(".").slice(0, -1).join(".");
+                deletedItemKeys.push(shortItemType);
+            }
+        }
+        if (deletedItemKeys.length === 0)
+            return true;
+        const locales = await getAllLocalesMessages(localesPath);
+        for (const locale of locales) {
+            const pruned = pruneMessages(locale.messages, deletedItemKeys);
+            await writeFileSafe(locale.path, JSON.stringify(pruned, null, 2));
+        }
         return true;
     }
     async function createItem(item) {

package/dist/routes/data.js

@@ -143,6 +143,8 @@ export function createDataRoutes(config, storage) {
             for (const [key, message] of Object.entries(messages)) {
                 const [contentKey, typeKey, fieldKey] = key.split(".");
                 if (contentKey === itemType) {
+                    if (!collection[typeKey])
+                        continue;
                     collection[typeKey][fieldKey] = message.defaultMessage;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isardsat/editorial-server",
-  "version": "6.10.0",
+  "version": "6.11.1",
   "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.10.0",
-    "@isardsat/editorial-common": "^6.10.0"
+    "@isardsat/editorial-admin": "^6.11.1",
+    "@isardsat/editorial-common": "^6.11.1"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.0",

package/dist/lib/logger.d.ts

@@ -1,7 +0,0 @@
-import { type Logger } from "pino";
-export interface LoggerConfig {
-    level?: "trace" | "debug" | "info" | "warn" | "error" | "fatal";
-    pretty?: boolean;
-    name?: string;
-}
-export declare function createLogger(config?: LoggerConfig): Logger;

package/dist/lib/logger.js

@@ -1,26 +0,0 @@
-import pino, {} from "pino";
-export function createLogger(config = {}) {
-    const isDevelopment = process.env.NODE_ENV !== "production";
-    const level = config.level ?? (isDevelopment ? "debug" : "info");
-    const pretty = config.pretty ?? isDevelopment;
-    const transport = pretty
-        ? {
-            target: "pino-pretty",
-            options: {
-                colorize: true,
-                translateTime: "HH:MM:ss Z",
-                ignore: "pid,hostname",
-            },
-        }
-        : undefined;
-    return pino({
-        name: config.name ?? "editorial-server",
-        level,
-        transport,
-        serializers: {
-            err: pino.stdSerializers.err,
-            req: pino.stdSerializers.req,
-            res: pino.stdSerializers.res,
-        },
-    });
-}