@cyberismo/backend 0.0.6 → 0.0.8

package/src/routes/cards.ts

@@ -10,7 +10,7 @@
     License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { Hono } from 'hono';
+import { Context, Hono } from 'hono';
 import Processor from '@asciidoctor/core';
 import {
   Card,
@@ -20,6 +20,7 @@ import {
 } from '@cyberismo/data-handler/interfaces/project-interfaces';
 import { CommandManager, evaluateMacros } from '@cyberismo/data-handler';
 import { ContentfulStatusCode } from 'hono/utils/http-status';
+import { getCardQueryResult, isSSGContext, ssgParams } from '../export.js';
 
 const router = new Hono();
 
@@ -70,6 +71,7 @@ router.get('/', async (c) => {
 async function getCardDetails(
   commands: CommandManager,
   key: string,
+  staticMode?: boolean,
 ): Promise<any> {
   const fetchCardDetails: ProjectFetchCardDetails = {
     attachments: true,
@@ -97,11 +99,15 @@ async function getCardDetails(
 
   let asciidocContent = '';
   try {
-    asciidocContent = await evaluateMacros(cardDetailsResponse.content || '', {
-      mode: 'inject',
-      projectPath: commands.project.basePath || '',
-      cardKey: key,
-    });
+    asciidocContent = await evaluateMacros(
+      cardDetailsResponse.content || '',
+      {
+        mode: staticMode ? 'static' : 'inject',
+        project: commands.project,
+        cardKey: key,
+      },
+      commands.calculateCmd,
+    );
   } catch (error) {
     asciidocContent = `Macro error: ${error instanceof Error ? error.message : 'Unknown error'}\n\n${asciidocContent}`;
   }
@@ -116,13 +122,16 @@ async function getCardDetails(
     })
     .toString();
 
-  // always parse for now
-  await commands.calculateCmd.generate();
-
-  const card = await commands.calculateCmd.runQuery('card', {
-    cardKey: key,
-  });
+  // always parse for now if not in export mode
+  if (!staticMode) {
+    await commands.calculateCmd.generate();
+  }
 
+  const card = staticMode
+    ? await getCardQueryResult(commands.project.basePath, key)
+    : await commands.calculateCmd.runQuery('card', {
+        cardKey: key,
+      });
   if (card.length !== 1) {
     throw new Error('Query failed. Check card-query syntax');
   }
@@ -157,22 +166,44 @@ async function getCardDetails(
  *       500:
  *         description: project_path not set.
  */
-router.get('/:key', async (c) => {
-  const key = c.req.param('key');
-  if (!key) {
-    return c.text('No search key', 400);
-  }
+router.get(
+  '/:key',
+  ssgParams(async (c: Context) => {
+    const commands = c.get('commands');
+    const fetchedCards = await commands.showCmd.showCards(
+      CardLocation.projectOnly,
+    );
+    const projectCards = fetchedCards.find(
+      (cardContainer) => cardContainer.type === 'project',
+    );
+    if (!projectCards) {
+      throw new Error('Data handler did not return project cards');
+    }
+    return projectCards.cards.map((key) => ({ key }));
+  }),
+  async (c) => {
+    const key = c.req.param('key');
+    if (!key) {
+      return c.text('No search key', 400);
+    }
 
-  const result = await getCardDetails(c.get('commands'), key);
-  if (result.status === 200) {
-    return c.json(result.data);
-  } else {
-    return c.text(
-      result.message || 'Unknown error',
-      result.status as ContentfulStatusCode,
+    const result = await getCardDetails(
+      c.get('commands'),
+      key,
+      isSSGContext(c),
     );
-  }
-});
+    if (result.status === 200) {
+      return c.json(result.data);
+    } else {
+      return c.json(
+        {
+          error: result.message || 'Unknown error',
+        },
+        result.status as ContentfulStatusCode,
+      );
+    }
+  },
+);
 
 /**
  * @swagger
@@ -271,8 +302,10 @@ router.patch('/:key', async (c) => {
   if (result.status === 200) {
     return c.json(result.data);
   } else {
-    return c.text(
-      result.message || 'Unknown error',
+    return c.json(
+      {
+        error: result.message || 'Unknown error',
+      },
       result.status as ContentfulStatusCode,
     );
   }
@@ -309,8 +342,10 @@ router.delete('/:key', async (c) => {
     await commands.removeCmd.remove('card', key);
     return new Response(null, { status: 204 });
   } catch (error) {
-    return c.text(
-      error instanceof Error ? error.message : 'Unknown error',
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : 'Unknown error',
+      },
       400,
     );
   }
@@ -361,9 +396,9 @@ router.post('/:key', async (c) => {
     return c.json(result);
   } catch (error) {
     if (error instanceof Error) {
-      return c.text(error.message, 400);
+      return c.json({ error: error.message }, 400);
     }
-    return c.text('Unknown error occurred', 500);
+    return c.json({ error: 'Unknown error occurred' }, 500);
   }
 });
 
@@ -563,11 +598,15 @@ router.post('/:key/parse', async (c) => {
   try {
     let asciidocContent = '';
     try {
-      asciidocContent = await evaluateMacros(content, {
-        mode: 'inject',
-        projectPath: commands.project.basePath || '',
-        cardKey: key,
-      });
+      asciidocContent = await evaluateMacros(
+        content,
+        {
+          mode: 'inject',
+          project: commands.project,
+          cardKey: key,
+        },
+        commands.calculateCmd,
+      );
     } catch (error) {
       asciidocContent = `Macro error: ${error instanceof Error ? error.message : 'Unknown error'}\n\n${content}`;
     }
@@ -725,43 +764,56 @@ router.delete('/:key/links', async (c) => {
  *       500:
  *         description: project_path not set.
  */
-router.get('/:key/a/:attachment', async (c) => {
-  const commands = c.get('commands');
-  const { key, attachment } = c.req.param();
-  const filename = decodeURI(attachment);
+router.get(
+  '/:key/a/:attachment',
+  ssgParams(async (c: Context) => {
+    const commands = c.get('commands');
+    const attachments = await commands.showCmd.showAttachments();
+    return attachments.map((attachment) => ({
+      key: attachment.card,
+      attachment: attachment.fileName,
+    }));
+  }),
+  async (c) => {
+    const commands = c.get('commands');
+    const { key, attachment } = c.req.param();
+    const filename = decodeURI(attachment);
+
+    if (!filename || !key) {
+      return c.text('Missing cardKey or filename', 400);
+    }
 
-  if (!filename || !key) {
-    return c.text('Missing cardKey or filename', 400);
-  }
+    try {
+      const attachmentResponse = await commands.showCmd.showAttachment(
+        key,
+        filename,
+      );
 
-  try {
-    const attachmentResponse = await commands.showCmd.showAttachment(
-      key,
-      filename,
-    );
+      if (!attachmentResponse) {
+        return c.text(
+          `No attachment found from card ${key} and filename ${filename}`,
+          404,
+        );
+      }
 
-    if (!attachmentResponse) {
-      return c.text(
-        `No attachment found from card ${key} and filename ${filename}`,
+      const payload = attachmentResponse as any;
+
+      return new Response(payload.fileBuffer, {
+        headers: {
+          'Content-Type': payload.mimeType,
+          'Content-Disposition': `attachment; filename="${filename}"`,
+          'Cache-Control': 'no-store',
+        },
+      });
+    } catch {
+      return c.json(
+        {
+          error: `No attachment found from card ${key} and filename ${filename}`,
+        },
         404,
       );
     }
-
-    const payload = attachmentResponse as any;
-
-    return new Response(payload.fileBuffer, {
-      headers: {
-        'Content-Type': payload.mimeType,
-        'Content-Disposition': `attachment; filename="${filename}"`,
-        'Cache-Control': 'no-store',
-      },
-    });
-  } catch {
-    return c.text(
-      `No attachment found from card ${key} and filename ${filename}`,
-      404,
-    );
-  }
-});
+  },
+);
 
 export default router;

package/src/routes/fieldTypes.ts

@@ -41,8 +41,10 @@ router.get('/', async (c) => {
 
     return c.json(fieldTypes);
   } else {
-    return c.text(
-      `No field types found from path ${c.get('projectPath')}`,
+    return c.json(
+      {
+        error: `No field types found from path ${c.get('projectPath')}`,
+      },
       500,
     );
   }

package/src/routes/linkTypes.ts

@@ -41,7 +41,12 @@ router.get('/', async (c) => {
 
     return c.json(linkTypes);
   } else {
-    return c.text(`No link types found from path ${c.get('projectPath')}`, 500);
+    return c.json(
+      {
+        error: `No link types found from path ${c.get('projectPath')}`,
+      },
+      500,
+    );
   }
 });
 

package/src/routes/templates.ts

@@ -11,6 +11,7 @@
 */
 
 import { Hono } from 'hono';
+import { isSSGContext } from 'hono/ssg';
 
 const router = new Hono();
 
@@ -29,13 +30,22 @@ const router = new Hono();
  *         description: project_path not set or other internal error
  */
 router.get('/', async (c) => {
+  // We do not need templates in ssg context
+  if (isSSGContext(c)) {
+    return c.json([]);
+  }
   const commands = c.get('commands');
 
   const response = await commands.showCmd.showTemplatesWithDetails();
   if (response) {
     return c.json(response);
   } else {
-    return c.text(`No templates found from path ${c.get('projectPath')}`, 500);
+    return c.json(
+      {
+        error: `No templates found from path ${c.get('projectPath')}`,
+      },
+      500,
+    );
   }
 });
 

package/src/routes/tree.ts

@@ -33,7 +33,12 @@ router.get('/', async (c) => {
     const tree = await commands.calculateCmd.runQuery('tree');
     return c.json(tree);
   } catch (e) {
-    return c.text((e instanceof Error && e.message) || '', 500);
+    return c.json(
+      {
+        error: (e instanceof Error && e.message) || '',
+      },
+      500,
+    );
   }
 });
 

package/src/utils.ts

@@ -0,0 +1,100 @@
+/**
+  Cyberismo
+  Copyright © Cyberismo Ltd and contributors 2025
+  This program is free software: you can redistribute it and/or modify it under
+  the terms of the GNU Affero General Public License version 3 as published by
+  the Free Software Foundation.
+  This program is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+  details. You should have received a copy of the GNU Affero General Public
+  License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+import path from 'node:path';
+import { createServer } from 'node:net';
+
+/**
+ * Runs promises in parallel, but only maxConcurrent at a time.
+ * @param promises - Array of promises to run in parallel
+ * @param maxConcurrent - Maximum number of promises to run at a time
+ * @returns - Promise that resolves when all promises have resolved
+ */
+export async function runInParallel<T>(
+  promises: (() => Promise<unknown>)[],
+  maxConcurrent: number = 2,
+) {
+  const waitingPromises: (() => Promise<unknown>)[] = [];
+  const wrappedPromises = promises.map((fn) => async () => {
+    await fn();
+    const next = waitingPromises.shift();
+    if (next) {
+      await next();
+    }
+  });
+
+  const runningPromises = wrappedPromises.slice(0, maxConcurrent);
+  waitingPromises.push(...wrappedPromises.slice(maxConcurrent));
+
+  return Promise.all(runningPromises.map((p) => p()));
+}
+/**
+ * Runs a callback and returns the result or undefined if it throws.
+ * @param cb - The callback to run.
+ * @returns The result of the callback or undefined if it throws.
+ */
+export async function runCbSafely<T>(
+  cb: () => Promise<T> | T,
+): Promise<T | undefined> {
+  try {
+    return await cb();
+  } catch {}
+}
+
+/**
+ * The relative path to the static frontend directory.
+ */
+export const staticFrontendDirRelative = path.relative(
+  process.cwd(),
+  path.resolve(import.meta.dirname, 'public'),
+);
+
+/**
+ * Finds a free port.
+ * @param port - The port to start looking for.
+ * @param maxAttempts - The maximum number of attempts to find a free port.
+ * @returns The free port.
+ */
+export async function findFreePort(
+  minPort: number,
+  maxPort: number,
+): Promise<number> {
+  for (let i = minPort; i < maxPort; i++) {
+    try {
+      await testPort(i);
+      return i;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes('EADDRINUSE')) {
+        console.log(`Port ${i} is already in use, trying next port...`);
+      } else {
+        throw err;
+      }
+    }
+  }
+  throw new Error('Failed to find free port');
+}
+
+function testPort(port: number) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(port, () => {
+      server.close();
+      resolve(true);
+    });
+    server.on('error', (err) => {
+      reject(err);
+    });
+    setTimeout(() => {
+      reject(new Error('Timed out waiting for port to be free'));
+    }, 2000);
+  });
+}