@isardsat/editorial-server 6.9.0 → 6.11.0

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,6 +11,7 @@ export declare function createStorage(dataDirectory: string): {
             placeholder?: string | undefined;
             showInSummary?: boolean | undefined;
         }>;
+        filterBy?: string | undefined;
         singleton?: boolean | undefined;
     }>>;
     getContent: ({ production, }: {

package/dist/routes/data.js

@@ -253,8 +253,8 @@ export function createDataRoutes(config, storage) {
         if (lang) {
             const messages = await storage.getLocalisationMessages(lang);
             for (const [key, message] of Object.entries(messages)) {
-                const [, typeKey, fieldKey] = key.split(".");
-                if (typeKey === id) {
+                const [contentKey, typeKey, fieldKey] = key.split(".");
+                if (contentKey === itemType && typeKey === id) {
                     item[fieldKey] = message.defaultMessage;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isardsat/editorial-server",
-  "version": "6.9.0",
+  "version": "6.11.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.9.0",
-    "@isardsat/editorial-common": "^6.9.0"
+    "@isardsat/editorial-common": "^6.11.0",
+    "@isardsat/editorial-admin": "^6.11.0"
   },
   "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,
-        },
-    });
-}