@isardsat/editorial-server 6.0.4 → 6.0.5

package/dist/app.js

@@ -7,7 +7,6 @@ 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";
@@ -17,7 +16,6 @@ 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: (author: string) => Promise<any>;
-    onPush: (author: string) => Promise<any>;
+    onPull: () => Promise<any>;
+    onPush: () => 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,27 +14,19 @@ 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(author) {
-        if (process.env.NODE_ENV !== "production") {
-            console.info("Dropping onPull hook event in development environment");
-            return;
-        }
-        return executeHook("onPull", author);
+    async function onPull() {
+        return executeHook('onPull');
     }
-    async function onPush(author) {
-        if (process.env.NODE_ENV !== "production") {
-            console.info("Dropping onPush hook event in development environment");
-            return;
-        }
-        return executeHook("onPush", author);
+    async function onPush() {
+        return executeHook('onPush');
     }
     return { onPublish, onLocalize, onLocalizeEnd, onPull, onPush };
 }

package/dist/lib/storage.d.ts

@@ -1,4 +1,4 @@
-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;
@@ -13,7 +13,6 @@ 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;
@@ -29,8 +28,6 @@ export declare function createStorage(dataDirectory: string): {
         createdAt: import("zod").ZodDefault<import("zod").ZodString>;
         updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
     }, import("zod").ZodTypeAny, "passthrough">>>>;
-    saveContent: ({ production }: {
-        production?: boolean;
-    }) => Promise<boolean>;
+    saveProdContent: () => 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,14 +17,11 @@ 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 getLocalisationMessages(langCode) {
-        return await readFile(join(dataDirectory, "locales", "messages", `${langCode}.json`), "utf-8").then((value) => JSON.parse(value));
-    }
-    async function saveContent({ production }) {
+    async function saveProdContent() {
         const content = await getContent();
-        await writeFileSafe(production ? dataProdPath : dataPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
+        await writeFileSafe(dataProdPath, JSON.stringify(EditorialDataSchema.parse(content), null, 2));
         return true;
     }
     async function saveLocalisationMessages(messages) {
@@ -61,11 +58,10 @@ export function createStorage(dataDirectory) {
     return {
         getSchema,
         getContent,
-        getLocalisationMessages,
         saveLocalisationMessages,
         createItem,
         updateItem,
         deleteItem,
-        saveContent,
+        saveProdContent,
     };
 }

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,35 +1,23 @@
-import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
-const ActionRequestSchema = z.object({
-    author: z.string(),
-});
+import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
 export function createActionRoutes(storage, hooks) {
     const app = new OpenAPIHono();
     app.openapi(createRoute({
-        method: "post",
-        path: "/publish",
-        request: {
-            body: {
-                content: {
-                    "application/json": {
-                        schema: ActionRequestSchema,
-                    },
-                },
-            },
-        },
+        method: 'post',
+        path: '/publish',
         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.saveContent({ production: false });
+        await storage.saveProdContent();
         const content = await storage.getContent();
         const schema = await storage.getSchema();
         try {
@@ -37,53 +25,33 @@ 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",
-        request: {
-            body: {
-                content: {
-                    "application/json": {
-                        schema: ActionRequestSchema,
-                    },
-                },
-            },
-        },
+        method: 'post',
+        path: '/pull',
         responses: {
             200: {
-                description: "Trigger the pull process",
+                description: 'Trigger the pull process',
             },
         },
     }), async (c) => {
-        const { author } = c.req.valid("json");
-        await hooks.onPull(author);
+        await hooks.onPull();
         return c.json(true);
     });
     app.openapi(createRoute({
-        method: "post",
-        path: "/push",
-        request: {
-            body: {
-                content: {
-                    "application/json": {
-                        schema: ActionRequestSchema,
-                    },
-                },
-            },
-        },
+        method: 'post',
+        path: '/push',
         responses: {
             200: {
-                description: "Trigger the push process",
+                description: 'Trigger the push process',
             },
         },
     }), async (c) => {
-        const { author } = c.req.valid("json");
-        await hooks.onPush(author);
+        await hooks.onPush();
         return c.json(true);
     });
     return app;

package/dist/routes/data.js

@@ -45,14 +45,12 @@ export function createDataRoutes(storage) {
                     param: { name: "itemType", in: "path" },
                     example: "newsItem",
                 }),
-            }),
-            query: z.object({
-                lang: z
+                locale: z
                     .string()
                     .optional()
                     .openapi({
-                    param: { name: "lang", in: "query" },
-                    example: "es",
+                    param: { name: "locale", in: "query" },
+                    example: "es_ES",
                 }),
             }),
         },
@@ -68,20 +66,8 @@ export function createDataRoutes(storage) {
         },
     }), async (c) => {
         const { itemType } = c.req.valid("param");
-        const { lang } = c.req.valid("query");
         const content = await storage.getContent();
-        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);
+        return c.json(content[itemType]);
     });
     app.openapi(createRoute({
         method: "get",
@@ -122,14 +108,12 @@ export function createDataRoutes(storage) {
                     param: { name: "id", in: "path" },
                     example: "about-us",
                 }),
-            }),
-            query: z.object({
-                lang: z
+                locale: z
                     .string()
                     .optional()
                     .openapi({
-                    param: { name: "lang", in: "query" },
-                    example: "es",
+                    param: { name: "locale", in: "query" },
+                    example: "es_ES",
                 }),
             }),
         },
@@ -145,20 +129,8 @@ export function createDataRoutes(storage) {
         },
     }), async (c) => {
         const { itemType, id } = c.req.valid("param");
-        const { lang } = c.req.valid("query");
         const content = await storage.getContent();
-        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);
+        return c.json(content[itemType][id]);
     });
     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,41 +1,30 @@
-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";
+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';
 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: EditorialFilesResponseSchema,
+                    'application/json': {
+                        schema: EditorialFilesSchema,
                     },
                 },
-                description: "Get tree of public files with total size",
+                description: 'Get tree of public files',
             },
         },
     }), 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();
@@ -43,25 +32,24 @@ 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);
-        const totalSize = calculateTotalSize(files);
-        return c.json({ files, totalSize });
+        return c.json(files);
     });
     app.openapi(createRoute({
-        method: "delete",
-        path: "/files",
+        method: 'delete',
+        path: '/files',
         request: {
             body: {
                 content: {
-                    "application/json": {
+                    'application/json': {
                         schema: z.object({
                             path: z.string(),
                         }),
@@ -73,55 +61,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 });
@@ -129,8 +117,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.4",
+  "version": "6.0.5",
   "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.4",
-    "@isardsat/editorial-common": "^6.0.4"
+    "@isardsat/editorial-common": "^6.0.5",
+    "@isardsat/editorial-admin": "^6.0.5"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.0",