@isardsat/editorial-server 6.0.2 → 6.0.4

package/dist/app.js

@@ -7,6 +7,7 @@ import { createHooks } from "./lib/hooks.js";
 import { createStorage } from "./lib/storage.js";
 import { createActionRoutes } from "./routes/actions.js";
 import { createAdminRoutes } from "./routes/admin.js";
+import { createConfigRoutes } from "./routes/config.js";
 import { createDataRoutes } from "./routes/data.js";
 import { createFilesRoutes } from "./routes/files.js";
 export const BASE_EDITORIAL_PATH = "./editorial";
@@ -16,6 +17,7 @@ export async function createEditorialServer({ configDirectory = BASE_EDITORIAL_P
     const storage = createStorage(editorialDirectory);
     const hooks = await createHooks(configDirectory);
     app.use(logger());
+    app.route("/api/v1", createConfigRoutes(config));
     app.route("/api/v1", createDataRoutes(storage));
     app.route("/api/v1", createFilesRoutes());
     app.route("/api/v1", createActionRoutes(storage, hooks));

package/dist/lib/hooks.d.ts

@@ -2,7 +2,7 @@ export declare function createHooks(configDirectory: string): Promise<{
     onPublish: (content: any, schema: any) => Promise<any>;
     onLocalize: (content: any, schema: any) => Promise<any>;
     onLocalizeEnd: (content: any, schema: any) => Promise<any>;
-    onPull: () => Promise<any>;
-    onPush: () => Promise<any>;
+    onPull: (author: string) => Promise<any>;
+    onPush: (author: string) => Promise<any>;
 }>;
 export type Hooks = Awaited<ReturnType<typeof createHooks>>;

package/dist/lib/hooks.js

@@ -1,10 +1,10 @@
-import { join } from 'node:path';
+import { join } from "node:path";
 export async function createHooks(configDirectory) {
-    const hooksDirPath = join(configDirectory, 'hooks');
+    const hooksDirPath = join(configDirectory, "hooks");
     async function loadHook(name) {
         const hookScript = join(process.cwd(), hooksDirPath, name);
         const module = await import(`${hookScript}.mjs`);
-        const hookFunction = typeof module.default === 'function' ? module.default : null;
+        const hookFunction = typeof module.default === "function" ? module.default : null;
         return hookFunction;
     }
     async function executeHook(hookName, ...args) {
@@ -14,19 +14,27 @@ export async function createHooks(configDirectory) {
         return hook(...args);
     }
     async function onPublish(content, schema) {
-        return executeHook('onPublish', content, schema);
+        return executeHook("onPublish", content, schema);
     }
     async function onLocalize(content, schema) {
-        return executeHook('onLocalize', content, schema);
+        return executeHook("onLocalize", content, schema);
     }
     async function onLocalizeEnd(content, schema) {
-        return executeHook('onLocalizeEnd', content, schema);
+        return executeHook("onLocalizeEnd", content, schema);
     }
-    async function onPull() {
-        return executeHook('onPull');
+    async function onPull(author) {
+        if (process.env.NODE_ENV !== "production") {
+            console.info("Dropping onPull hook event in development environment");
+            return;
+        }
+        return executeHook("onPull", author);
     }
-    async function onPush() {
-        return executeHook('onPush');
+    async function onPush(author) {
+        if (process.env.NODE_ENV !== "production") {
+            console.info("Dropping onPush hook event in development environment");
+            return;
+        }
+        return executeHook("onPush", author);
     }
     return { onPublish, onLocalize, onLocalizeEnd, onPull, onPush };
 }

package/dist/lib/i18n.d.ts

@@ -0,0 +1,35 @@
+import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
+export declare function createI18n(dataDirectory: string): {
+    getSchema: () => Promise<Record<string, {
+        displayName: string;
+        fields: Record<string, import("zod").objectOutputType<{
+            type: import("zod").ZodEnum<["string", "url", "boolean", "date", "datetime", "markdown", "number", "color", "select", "color"]>;
+            displayName: import("zod").ZodString;
+            displayExtra: import("zod").ZodOptional<import("zod").ZodString>;
+            placeholder: import("zod").ZodOptional<import("zod").ZodString>;
+            isRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            showInSummary: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        singleton?: boolean | undefined;
+    }>>;
+    getContent: () => Promise<EditorialData>;
+    saveLocalisationMessages: (messages: any) => Promise<boolean>;
+    createItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodString;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    updateItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    deleteItem: (item: EditorialDataObjectWithType) => Promise<Record<string, Record<string, import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>>;
+    saveContent: ({ production }: {
+        production?: boolean;
+    }) => Promise<boolean>;
+};
+export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/i18n.js

@@ -0,0 +1,67 @@
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { parse } from "yaml";
+import { writeFileSafe } from "./utils/fs.js";
+export function createI18n(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() {
+        return await readFile(dataPath, "utf-8").then((value) => JSON.parse(value));
+    }
+    async function saveContent({ production }) {
+        const content = await getContent();
+        await writeFileSafe(production ? dataProdPath : 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();
+        content[item.type][item.id] = EditorialDataItemSchema.parse(item);
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return item;
+    }
+    async function updateItem(item) {
+        const content = await getContent();
+        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();
+        delete content[item.type][item.id];
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return content;
+    }
+    return {
+        getSchema,
+        getContent,
+        saveLocalisationMessages,
+        createItem,
+        updateItem,
+        deleteItem,
+        saveContent,
+    };
+}

package/dist/lib/lang.d.ts

@@ -0,0 +1,35 @@
+import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
+export declare function createStorage(dataDirectory: string): {
+    getSchema: () => Promise<Record<string, {
+        displayName: string;
+        fields: Record<string, import("zod").objectOutputType<{
+            type: import("zod").ZodEnum<["string", "url", "boolean", "date", "datetime", "markdown", "number", "color", "select", "color"]>;
+            displayName: import("zod").ZodString;
+            displayExtra: import("zod").ZodOptional<import("zod").ZodString>;
+            placeholder: import("zod").ZodOptional<import("zod").ZodString>;
+            isRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            showInSummary: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        singleton?: boolean | undefined;
+    }>>;
+    getContent: () => Promise<EditorialData>;
+    saveLocalisationMessages: (messages: any) => Promise<boolean>;
+    createItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodString;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    updateItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    deleteItem: (item: EditorialDataObjectWithType) => Promise<Record<string, Record<string, import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>>;
+    saveContent: ({ production }: {
+        production?: boolean;
+    }) => Promise<boolean>;
+};
+export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/lang.js

@@ -0,0 +1,67 @@
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { readFile } 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() {
+        return await readFile(dataPath, "utf-8").then((value) => JSON.parse(value));
+    }
+    async function saveContent({ production }) {
+        const content = await getContent();
+        await writeFileSafe(production ? dataProdPath : 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();
+        content[item.type][item.id] = EditorialDataItemSchema.parse(item);
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return item;
+    }
+    async function updateItem(item) {
+        const content = await getContent();
+        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();
+        delete content[item.type][item.id];
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return content;
+    }
+    return {
+        getSchema,
+        getContent,
+        saveLocalisationMessages,
+        createItem,
+        updateItem,
+        deleteItem,
+        saveContent,
+    };
+}

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

@@ -0,0 +1,35 @@
+import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
+export declare function createStorage(dataDirectory: string): {
+    getSchema: () => Promise<Record<string, {
+        displayName: string;
+        fields: Record<string, import("zod").objectOutputType<{
+            type: import("zod").ZodEnum<["string", "url", "boolean", "date", "datetime", "markdown", "number", "color", "select", "color"]>;
+            displayName: import("zod").ZodString;
+            displayExtra: import("zod").ZodOptional<import("zod").ZodString>;
+            placeholder: import("zod").ZodOptional<import("zod").ZodString>;
+            isRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            showInSummary: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        singleton?: boolean | undefined;
+    }>>;
+    getContent: () => Promise<EditorialData>;
+    saveLocalisationMessages: (messages: any) => Promise<boolean>;
+    createItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodString;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    updateItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    deleteItem: (item: EditorialDataObjectWithType) => Promise<Record<string, Record<string, import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>>;
+    saveContent: ({ production }: {
+        production?: boolean;
+    }) => Promise<boolean>;
+};
+export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/storage copy.js

@@ -0,0 +1,67 @@
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { readFile } 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() {
+        return await readFile(dataPath, "utf-8").then((value) => JSON.parse(value));
+    }
+    async function saveContent({ production }) {
+        const content = await getContent();
+        await writeFileSafe(production ? dataProdPath : 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();
+        content[item.type][item.id] = EditorialDataItemSchema.parse(item);
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return item;
+    }
+    async function updateItem(item) {
+        const content = await getContent();
+        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();
+        delete content[item.type][item.id];
+        // TODO: Use superjson to safely encode different types.
+        await writeFileSafe(dataPath, JSON.stringify(content, null, 2));
+        return content;
+    }
+    return {
+        getSchema,
+        getContent,
+        saveLocalisationMessages,
+        createItem,
+        updateItem,
+        deleteItem,
+        saveContent,
+    };
+}

package/dist/lib/storage.d.ts

@@ -1,9 +1,9 @@
-import type { EditorialData, EditorialDataObjectWithType } from '@isardsat/editorial-common';
+import type { EditorialData, EditorialDataObjectWithType } from "@isardsat/editorial-common";
 export declare function createStorage(dataDirectory: string): {
     getSchema: () => Promise<Record<string, {
         displayName: string;
         fields: Record<string, import("zod").objectOutputType<{
-            type: import("zod").ZodEnum<["string", "boolean", "date", "datetime", "markdown", "number", "color", "select", "color"]>;
+            type: import("zod").ZodEnum<["string", "url", "boolean", "date", "datetime", "markdown", "number", "color", "select", "color"]>;
             displayName: import("zod").ZodString;
             displayExtra: import("zod").ZodOptional<import("zod").ZodString>;
             placeholder: import("zod").ZodOptional<import("zod").ZodString>;
@@ -13,6 +13,7 @@ export declare function createStorage(dataDirectory: string): {
         singleton?: boolean | undefined;
     }>>;
     getContent: () => Promise<EditorialData>;
+    getLocalisationMessages: (langCode: string) => Promise<any>;
     saveLocalisationMessages: (messages: any) => Promise<boolean>;
     createItem: (item: EditorialDataObjectWithType) => Promise<import("zod").objectOutputType<{
         id: import("zod").ZodString;
@@ -28,6 +29,8 @@ export declare function createStorage(dataDirectory: string): {
         createdAt: import("zod").ZodDefault<import("zod").ZodString>;
         updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
     }, import("zod").ZodTypeAny, "passthrough">>>>;
-    saveProdContent: () => Promise<boolean>;
+    saveContent: ({ production }: {
+        production?: boolean;
+    }) => Promise<boolean>;
 };
 export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/storage.js

@@ -1,15 +1,15 @@
-import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from '@isardsat/editorial-common';
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-import { parse } from 'yaml';
-import { writeFileSafe } from './utils/fs.js';
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+import { readFile } 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');
+    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 schemaFile = await readFile(schemaPath, "utf-8").then((value) => parse(value));
         const schema = EditorialSchemaSchema.parse(schemaFile);
         return schema;
     }
@@ -17,11 +17,14 @@ export function createStorage(dataDirectory) {
      * TODO: This should ideally cache the result of reading the file until an update occurs.
      */
     async function getContent() {
-        return await readFile(dataPath, 'utf-8').then((value) => JSON.parse(value));
+        return await readFile(dataPath, "utf-8").then((value) => JSON.parse(value));
     }
-    async function saveProdContent() {
+    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();
-        await writeFileSafe(dataProdPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
+        await writeFileSafe(production ? dataProdPath : dataPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
         return true;
     }
     async function saveLocalisationMessages(messages) {
@@ -58,10 +61,11 @@ export function createStorage(dataDirectory) {
     return {
         getSchema,
         getContent,
+        getLocalisationMessages,
         saveLocalisationMessages,
         createItem,
         updateItem,
         deleteItem,
-        saveProdContent,
+        saveContent,
     };
 }

package/dist/routes/actions.d.ts

@@ -1,4 +1,4 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-import type { Hooks } from '../lib/hooks.js';
-import type { Storage } from '../lib/storage.js';
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Hooks } from "../lib/hooks.js";
+import type { Storage } from "../lib/storage.js";
 export declare function createActionRoutes(storage: Storage, hooks: Hooks): OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/routes/actions.js

@@ -1,23 +1,35 @@
-import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+const ActionRequestSchema = z.object({
+    author: z.string(),
+});
 export function createActionRoutes(storage, hooks) {
     const app = new OpenAPIHono();
     app.openapi(createRoute({
-        method: 'post',
-        path: '/publish',
+        method: "post",
+        path: "/publish",
+        request: {
+            body: {
+                content: {
+                    "application/json": {
+                        schema: ActionRequestSchema,
+                    },
+                },
+            },
+        },
         responses: {
             202: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.boolean(),
                     },
                 },
-                description: 'Trigger the publishing process',
+                description: "Trigger the publishing process",
             },
         },
     }), 
     // TODO: Don't async, let the promises run in the background.
     async (c) => {
-        await storage.saveProdContent();
+        await storage.saveContent({ production: false });
         const content = await storage.getContent();
         const schema = await storage.getSchema();
         try {
@@ -25,33 +37,53 @@ export function createActionRoutes(storage, hooks) {
             await storage.saveLocalisationMessages(scriptResult);
         }
         catch (error) {
-            console.error('Error executing script:', error);
+            console.error("Error executing script:", error);
             return c.json(false);
         }
         return c.json(true);
     });
     app.openapi(createRoute({
-        method: 'post',
-        path: '/pull',
+        method: "post",
+        path: "/pull",
+        request: {
+            body: {
+                content: {
+                    "application/json": {
+                        schema: ActionRequestSchema,
+                    },
+                },
+            },
+        },
         responses: {
             200: {
-                description: 'Trigger the pull process',
+                description: "Trigger the pull process",
             },
         },
     }), async (c) => {
-        await hooks.onPull();
+        const { author } = c.req.valid("json");
+        await hooks.onPull(author);
         return c.json(true);
     });
     app.openapi(createRoute({
-        method: 'post',
-        path: '/push',
+        method: "post",
+        path: "/push",
+        request: {
+            body: {
+                content: {
+                    "application/json": {
+                        schema: ActionRequestSchema,
+                    },
+                },
+            },
+        },
         responses: {
             200: {
-                description: 'Trigger the push process',
+                description: "Trigger the push process",
             },
         },
     }), async (c) => {
-        await hooks.onPush();
+        const { author } = c.req.valid("json");
+        await hooks.onPush(author);
         return c.json(true);
     });
     return app;

package/dist/routes/config.d.ts

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

package/dist/routes/config.js

@@ -0,0 +1,23 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { EditorialConfigSchema } from "@isardsat/editorial-common";
+export function createConfigRoutes(config) {
+    const app = new OpenAPIHono();
+    app.openapi({
+        method: "get",
+        path: "/config",
+        summary: "Get Editorial configuration",
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialConfigSchema,
+                    },
+                },
+                description: "Editorial configuration",
+            },
+        },
+    }, (c) => {
+        return c.json(config);
+    });
+    return app;
+}

package/dist/routes/data.js

@@ -45,12 +45,14 @@ export function createDataRoutes(storage) {
                     param: { name: "itemType", in: "path" },
                     example: "newsItem",
                 }),
-                locale: z
+            }),
+            query: z.object({
+                lang: z
                     .string()
                     .optional()
                     .openapi({
-                    param: { name: "locale", in: "query" },
-                    example: "es_ES",
+                    param: { name: "lang", in: "query" },
+                    example: "es",
                 }),
             }),
         },
@@ -66,8 +68,20 @@ export function createDataRoutes(storage) {
         },
     }), async (c) => {
         const { itemType } = c.req.valid("param");
+        const { lang } = c.req.valid("query");
         const content = await storage.getContent();
-        return c.json(content[itemType]);
+        const collection = content[itemType];
+        // 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(".");
+                if (contentKey === itemType) {
+                    collection[typeKey][fieldKey] = message.defaultMessage;
+                }
+            }
+        }
+        return c.json(collection);
     });
     app.openapi(createRoute({
         method: "get",
@@ -108,12 +122,14 @@ export function createDataRoutes(storage) {
                     param: { name: "id", in: "path" },
                     example: "about-us",
                 }),
-                locale: z
+            }),
+            query: z.object({
+                lang: z
                     .string()
                     .optional()
                     .openapi({
-                    param: { name: "locale", in: "query" },
-                    example: "es_ES",
+                    param: { name: "lang", in: "query" },
+                    example: "es",
                 }),
             }),
         },
@@ -129,8 +145,20 @@ export function createDataRoutes(storage) {
         },
     }), async (c) => {
         const { itemType, id } = c.req.valid("param");
+        const { lang } = c.req.valid("query");
         const content = await storage.getContent();
-        return c.json(content[itemType][id]);
+        const item = content[itemType][id];
+        // 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(".");
+                if (typeKey === id) {
+                    item[fieldKey] = message.defaultMessage;
+                }
+            }
+        }
+        return c.json(item);
     });
     app.openapi(createRoute({
         method: "put",

package/dist/routes/files.d.ts

@@ -1,2 +1,2 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
+import { OpenAPIHono } from "@hono/zod-openapi";
 export declare function createFilesRoutes(): OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/routes/files.js

@@ -1,30 +1,41 @@
-import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
-import { EditorialFilesSchema, } 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';
+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() {
     const app = new OpenAPIHono();
-    const publicDirPath = 'public';
-    const deletedDirPath = 'public/.deleted';
+    const publicDirPath = "public";
+    const deletedDirPath = "public/.deleted";
     app.openapi(createRoute({
-        method: 'get',
-        path: '/files',
+        method: "get",
+        path: "/files",
         responses: {
             200: {
                 content: {
-                    'application/json': {
-                        schema: EditorialFilesSchema,
+                    "application/json": {
+                        schema: EditorialFilesResponseSchema,
                     },
                 },
-                description: 'Get tree of public files',
+                description: "Get tree of public files with total size",
             },
         },
     }), async (c) => {
+        function calculateTotalSize(files) {
+            return files.reduce((total, file) => {
+                if (file.type === "file") {
+                    return total + file.size;
+                }
+                else if (file.children) {
+                    return total + calculateTotalSize(file.children);
+                }
+                return total;
+            }, 0);
+        }
         function readDirectoryChildren(path) {
             const directory = readdirSync(path);
             return directory
-                .filter((fileName) => !fileName.startsWith('.'))
+                .filter((fileName) => !fileName.startsWith("."))
                 .map((fileName) => {
                 const file = statSync(join(path, fileName));
                 const isDirectory = file.isDirectory();
@@ -32,24 +43,25 @@ export function createFilesRoutes() {
                     name: basename(fileName),
                     path: join(path, fileName),
                     size: file.size,
-                    type: isDirectory ? 'directory' : 'file',
+                    type: isDirectory ? "directory" : "file",
                     children: isDirectory
                         ? readDirectoryChildren(join(path, fileName))
                         : undefined,
                 };
             })
-                .sort((a, b) => (a.type === 'directory' ? -1 : 0));
+                .sort((a, b) => (a.type === "directory" ? -1 : 0));
         }
         const files = readDirectoryChildren(publicDirPath);
-        return c.json(files);
+        const totalSize = calculateTotalSize(files);
+        return c.json({ files, totalSize });
     });
     app.openapi(createRoute({
-        method: 'delete',
-        path: '/files',
+        method: "delete",
+        path: "/files",
         request: {
             body: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             path: z.string(),
                         }),
@@ -61,55 +73,55 @@ export function createFilesRoutes() {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.boolean(),
                     },
                 },
-                description: '',
+                description: "",
             },
             400: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             error: z.string(),
                         }),
                     },
                 },
-                description: 'Invalid file path',
+                description: "Invalid file path",
             },
             404: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             error: z.string(),
                         }),
                     },
                 },
-                description: 'File not found',
+                description: "File not found",
             },
             500: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             error: z.string(),
                         }),
                     },
                 },
-                description: 'Server error',
+                description: "Server error",
             },
         },
     }), async (c) => {
-        const { path: filePath } = c.req.valid('json');
+        const { path: filePath } = c.req.valid("json");
         try {
             const normalizedPath = normalize(filePath);
             if (!normalizedPath.startsWith(publicDirPath)) {
-                return c.json({ error: 'Invalid file path' }, 400);
+                return c.json({ error: "Invalid file path" }, 400);
             }
             const exists = await access(filePath, constants.W_OK)
                 .then(() => true)
                 .catch(() => false);
             if (!exists) {
-                return c.json({ error: 'File not found' }, 404);
+                return c.json({ error: "File not found" }, 404);
             }
             // Move to deleted directory
             await mkdir(deletedDirPath, { recursive: true });
@@ -117,8 +129,8 @@ export function createFilesRoutes() {
             return c.json(true, 200);
         }
         catch (err) {
-            console.error('Delete failed:', err);
-            return c.json({ error: 'Server error' }, 500);
+            console.error("Delete failed:", err);
+            return c.json({ error: "Server error" }, 500);
         }
     });
     return app;

package/package.json

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