@isardsat/editorial-server 6.0.0-canary-001

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lobelia Earth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,8 @@
+```
+npm install
+npm run dev
+```
+
+```
+open http://localhost:3000
+```

package/dist/app.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { EditorialConfig } from "@isardsat/editorial-common";
+import { type Storage } from "./lib/storage.js";
+export declare const BASE_EDITORIAL_PATH = "./editorial";
+export interface EditorialServerConfig {
+    configDirectory?: string;
+    editorialDirectory?: string;
+}
+export interface EditorialServer {
+    app: OpenAPIHono;
+    config: EditorialConfig;
+    storage: Storage;
+}
+export declare function createEditorialServer({ configDirectory, editorialDirectory, }: EditorialServerConfig): Promise<EditorialServer>;

package/dist/app.js

@@ -0,0 +1,39 @@
+import { serveStatic } from "@hono/node-server/serve-static";
+import { swaggerUI } from "@hono/swagger-ui";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { logger } from "hono/logger";
+import { createConfig } from "./lib/config.js";
+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 { createDataRoutes } from "./routes/data.js";
+import { createFilesRoutes } from "./routes/files.js";
+export const BASE_EDITORIAL_PATH = "./editorial";
+export async function createEditorialServer({ configDirectory = BASE_EDITORIAL_PATH, editorialDirectory = BASE_EDITORIAL_PATH, }) {
+    const app = new OpenAPIHono();
+    const config = await createConfig(configDirectory);
+    const storage = createStorage(editorialDirectory);
+    const hooks = await createHooks(configDirectory);
+    app.use(logger());
+    app.route("/api/v1", createDataRoutes(storage));
+    app.route("/api/v1", createFilesRoutes());
+    app.route("/api/v1", createActionRoutes(storage, hooks));
+    app.route("/", createAdminRoutes());
+    app.doc("/doc", {
+        openapi: "3.0.0",
+        info: {
+            version: "1.0.0",
+            title: `Editorial API: ${config.name}`,
+        },
+    });
+    app.get("/doc/ui", swaggerUI({ url: "/doc" }));
+    app.use("/public/*", serveStatic({
+        root: "./",
+    }));
+    return {
+        app,
+        config,
+        storage,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createEditorialServer } from './app.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { createEditorialServer } from './app.js';

package/dist/lib/config.d.ts

@@ -0,0 +1,6 @@
+export declare function createConfig(configDirectory: string): Promise<{
+    name: string;
+    publicUrl: string;
+    previewUrl?: string | undefined;
+    silent?: boolean | undefined;
+}>;

package/dist/lib/config.js

@@ -0,0 +1,8 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { EditorialConfigSchema } from '@isardsat/editorial-common';
+export async function createConfig(configDirectory) {
+    const configFile = await readFile(join(configDirectory, 'config.json'), 'utf-8').then((value) => JSON.parse(value));
+    const config = EditorialConfigSchema.parse(configFile);
+    return config;
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,8 @@
+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>;
+}>;
+export type Hooks = Awaited<ReturnType<typeof createHooks>>;

package/dist/lib/hooks.js

@@ -0,0 +1,32 @@
+import { join } from 'node:path';
+export async function createHooks(configDirectory) {
+    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;
+        return hookFunction;
+    }
+    async function executeHook(hookName, ...args) {
+        const hook = await loadHook(hookName);
+        if (!hook)
+            return;
+        return hook(...args);
+    }
+    async function onPublish(content, schema) {
+        return executeHook('onPublish', content, schema);
+    }
+    async function onLocalize(content, schema) {
+        return executeHook('onLocalize', content, schema);
+    }
+    async function onLocalizeEnd(content, schema) {
+        return executeHook('onLocalizeEnd', content, schema);
+    }
+    async function onPull() {
+        return executeHook('onPull');
+    }
+    async function onPush() {
+        return executeHook('onPush');
+    }
+    return { onPublish, onLocalize, onLocalizeEnd, onPull, onPush };
+}

package/dist/lib/schema.d.ts

@@ -0,0 +1,6 @@
+export declare function createSchema(configDirectory: string): Promise<{
+    name: string;
+    publicUrl: string;
+    previewUrl?: string | undefined;
+    silent?: boolean | undefined;
+}>;

package/dist/lib/schema.js

@@ -0,0 +1,9 @@
+import { EditorialConfigSchema } from '@isardsat/editorial-common';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { parse } from 'yaml';
+export async function createSchema(configDirectory) {
+    const configFile = await readFile(join(configDirectory, 'schema.yaml'), 'utf-8').then((value) => parse(value));
+    const config = EditorialConfigSchema.parse(configFile);
+    return config;
+}

package/dist/lib/storage.d.ts

@@ -0,0 +1,33 @@
+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"]>;
+            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">>>>;
+    saveProdContent: () => Promise<boolean>;
+};
+export type Storage = ReturnType<typeof createStorage>;

package/dist/lib/storage.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 saveProdContent() {
+        const content = await getContent();
+        await writeFileSafe(dataProdPath, 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,
+        saveProdContent,
+    };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * This function writes a file in as atomic a way as possible. It first creates
+ * a backup of the file to be written to, writes new content to a temporary
+ * file, and finally renames the temporary file to the final name.
+ */
+export declare function writeFileSafe(file: string, contents: string): Promise<void>;

package/dist/lib/utils/fs.js

@@ -0,0 +1,20 @@
+import { copyFile, rename, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, dirname, join } from 'path';
+/**
+ * This function writes a file in as atomic a way as possible. It first creates
+ * a backup of the file to be written to, writes new content to a temporary
+ * file, and finally renames the temporary file to the final name.
+ */
+export async function writeFileSafe(file, contents) {
+    const fileName = basename(file);
+    const destination = join(dirname(file), `${fileName}.${Date.now()}.tmp`);
+    try {
+        await copyFile(file, join(tmpdir(), fileName));
+        await writeFile(destination, contents);
+        await rename(destination, file);
+    }
+    catch (error) {
+        throw error;
+    }
+}

package/dist/routes/actions.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,58 @@
+import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
+export function createActionRoutes(storage, hooks) {
+    const app = new OpenAPIHono();
+    app.openapi(createRoute({
+        method: 'post',
+        path: '/publish',
+        responses: {
+            202: {
+                content: {
+                    'application/json': {
+                        schema: z.boolean(),
+                    },
+                },
+                description: 'Trigger the publishing process',
+            },
+        },
+    }), 
+    // TODO: Don't async, let the promises run in the background.
+    async (c) => {
+        await storage.saveProdContent();
+        const content = await storage.getContent();
+        const schema = await storage.getSchema();
+        try {
+            const scriptResult = await hooks.onLocalize(content, schema);
+            await storage.saveLocalisationMessages(scriptResult);
+        }
+        catch (error) {
+            console.error('Error executing script:', error);
+            return c.json(false);
+        }
+        return c.json(true);
+    });
+    app.openapi(createRoute({
+        method: 'post',
+        path: '/pull',
+        responses: {
+            200: {
+                description: 'Trigger the pull process',
+            },
+        },
+    }), async (c) => {
+        await hooks.onPull();
+        return c.json(true);
+    });
+    app.openapi(createRoute({
+        method: 'post',
+        path: '/push',
+        responses: {
+            200: {
+                description: 'Trigger the push process',
+            },
+        },
+    }), async (c) => {
+        await hooks.onPush();
+        return c.json(true);
+    });
+    return app;
+}

package/dist/routes/admin.d.ts

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

package/dist/routes/admin.js

@@ -0,0 +1,22 @@
+import { serveStatic } from "@hono/node-server/serve-static";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import path from "path";
+export function createAdminRoutes() {
+    const app = new OpenAPIHono();
+    // TODO: This is package manager dependent
+    const adminPath = path.join(import.meta.dirname, "..", "..", "node_modules", "@isardsat", "editorial-admin", "build", "client");
+    const relativeAdminPath = path.relative(process.cwd(), adminPath);
+    app.use("/admin/*", serveStatic({
+        root: relativeAdminPath,
+        rewriteRequestPath(path) {
+            return path.split("/admin/")[0];
+        },
+        onNotFound(path, c) {
+            console.log("onNotFound", path, c);
+        },
+    }));
+    app.use("/assets/*", serveStatic({
+        root: relativeAdminPath,
+    }));
+    return app;
+}

package/dist/routes/data.d.ts

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

package/dist/routes/data.js

@@ -0,0 +1,242 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { EditorialDataItemSchema, EditorialDataSchema, EditorialSchemaSchema, } from "@isardsat/editorial-common";
+export function createDataRoutes(storage) {
+    const app = new OpenAPIHono();
+    app.openapi(createRoute({
+        method: "get",
+        path: "/schema",
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialSchemaSchema,
+                    },
+                },
+                description: "Get Editorial schema",
+            },
+        },
+    }), async (c) => {
+        const schema = await storage.getSchema();
+        return c.json(schema);
+    });
+    app.openapi(createRoute({
+        method: "get",
+        path: "/data",
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataSchema,
+                    },
+                },
+                description: "Get all Editorial data",
+            },
+        },
+    }), async (c) => {
+        const content = await storage.getContent();
+        return c.json(content);
+    });
+    app.openapi(createRoute({
+        method: "get",
+        path: "/data/{itemType}",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+                locale: z
+                    .string()
+                    .optional()
+                    .openapi({
+                    param: { name: "locale", in: "query" },
+                    example: "es_ES",
+                }),
+            }),
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataSchema,
+                    },
+                },
+                description: "Get objects by type",
+            },
+        },
+    }), async (c) => {
+        const { itemType } = c.req.valid("param");
+        const content = await storage.getContent();
+        return c.json(content[itemType]);
+    });
+    app.openapi(createRoute({
+        method: "get",
+        path: "/data/{itemType}/ids",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+            }),
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.array(z.string()),
+                    },
+                },
+                description: "Get object ids by type",
+            },
+        },
+    }), async (c) => {
+        const { itemType } = c.req.valid("param");
+        const content = await storage.getContent();
+        return c.json(Object.keys(content[itemType]));
+    });
+    app.openapi(createRoute({
+        method: "get",
+        path: "/data/{itemType}/{id}",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+                id: z.string().openapi({
+                    param: { name: "id", in: "path" },
+                    example: "about-us",
+                }),
+                locale: z
+                    .string()
+                    .optional()
+                    .openapi({
+                    param: { name: "locale", in: "query" },
+                    example: "es_ES",
+                }),
+            }),
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataSchema,
+                    },
+                },
+                description: "Get object data",
+            },
+        },
+    }), async (c) => {
+        const { itemType, id } = c.req.valid("param");
+        const content = await storage.getContent();
+        return c.json(content[itemType][id]);
+    });
+    app.openapi(createRoute({
+        method: "put",
+        path: "/data/{itemType}/{id}",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+                id: z.string().openapi({
+                    param: { name: "id", in: "path" },
+                    example: "learn-about-us",
+                }),
+            }),
+            body: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataItemSchema,
+                    },
+                },
+                required: true,
+            },
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataItemSchema,
+                    },
+                },
+                description: "Create a new object",
+            },
+        },
+    }), async (c) => {
+        const itemAtts = await c.req.json();
+        const newItem = await storage.createItem(itemAtts);
+        return c.json(newItem);
+    });
+    app.openapi(createRoute({
+        method: "patch",
+        path: "/data/{itemType}/{id}",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+                id: z.string().openapi({
+                    param: { name: "id", in: "path" },
+                    example: "about-us",
+                }),
+            }),
+            body: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataItemSchema,
+                    },
+                },
+                required: true,
+            },
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: EditorialDataSchema,
+                    },
+                },
+                description: "Update object",
+            },
+        },
+    }), async (c) => {
+        const itemAtts = await c.req.json();
+        const newItem = await storage.updateItem(itemAtts);
+        return c.json(newItem);
+    });
+    app.openapi(createRoute({
+        method: "delete",
+        path: "/data/{itemType}/{id}",
+        request: {
+            params: z.object({
+                itemType: z.string().openapi({
+                    param: { name: "itemType", in: "path" },
+                    example: "newsItem",
+                }),
+                id: z.string().openapi({
+                    param: { name: "id", in: "path" },
+                    example: "about-us",
+                }),
+            }),
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.boolean(),
+                    },
+                },
+                description: "Delete object",
+            },
+        },
+    }), async (c) => {
+        const { itemType, id } = c.req.valid("param");
+        await storage.deleteItem({ type: itemType, id });
+        return c.json(true, 200);
+    });
+    return app;
+}

package/dist/routes/files.d.ts

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

package/dist/routes/files.js

@@ -0,0 +1,125 @@
+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';
+    app.openapi(createRoute({
+        method: 'get',
+        path: '/files',
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: EditorialFilesSchema,
+                    },
+                },
+                description: 'Get tree of public files',
+            },
+        },
+    }), async (c) => {
+        function readDirectoryChildren(path) {
+            const directory = readdirSync(path);
+            return directory
+                .filter((fileName) => !fileName.startsWith('.'))
+                .map((fileName) => {
+                const file = statSync(join(path, fileName));
+                const isDirectory = file.isDirectory();
+                return {
+                    name: basename(fileName),
+                    path: join(path, fileName),
+                    size: file.size,
+                    type: isDirectory ? 'directory' : 'file',
+                    children: isDirectory
+                        ? readDirectoryChildren(join(path, fileName))
+                        : undefined,
+                };
+            })
+                .sort((a, b) => (a.type === 'directory' ? -1 : 0));
+        }
+        const files = readDirectoryChildren(publicDirPath);
+        return c.json(files);
+    });
+    app.openapi(createRoute({
+        method: 'delete',
+        path: '/files',
+        request: {
+            body: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            path: z.string(),
+                        }),
+                    },
+                },
+                required: true,
+            },
+        },
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.boolean(),
+                    },
+                },
+                description: '',
+            },
+            400: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: 'Invalid file path',
+            },
+            404: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: 'File not found',
+            },
+            500: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            error: z.string(),
+                        }),
+                    },
+                },
+                description: 'Server error',
+            },
+        },
+    }), async (c) => {
+        const { path: filePath } = c.req.valid('json');
+        try {
+            const normalizedPath = normalize(filePath);
+            if (!normalizedPath.startsWith(publicDirPath)) {
+                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);
+            }
+            // Move to deleted directory
+            await mkdir(deletedDirPath, { recursive: true });
+            await rename(filePath, join(deletedDirPath, basename(filePath)));
+            return c.json(true, 200);
+        }
+        catch (err) {
+            console.error('Delete failed:', err);
+            return c.json({ error: 'Server error' }, 500);
+        }
+    });
+    return app;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@isardsat/editorial-server",
+  "version": "6.0.0-canary-001",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.13.8",
+    "@hono/swagger-ui": "^0.5.0",
+    "@hono/zod-openapi": "^0.18.4",
+    "hono": "^4.6.20",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.1",
+    "@isardsat/editorial-admin": "^6.0.0-canary-001",
+    "@isardsat/editorial-common": "^6.0.0-canary-001"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.0",
+    "@types/node": "22.13.1",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "esbuild": "^0.24.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsx": "^4.7.1",
+    "typescript": "^5.7.3"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "compile:watch": "tsc --watch"
+  }
+}