@cyberismo/backend 0.0.15 → 0.0.17

package/src/domain/project/service.ts

@@ -0,0 +1,88 @@
+/**
+  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 { type CommandManager } from '@cyberismo/data-handler';
+
+export interface ProjectModule {
+  name: string;
+  cardKeyPrefix: string;
+}
+
+export interface ProjectInfo {
+  name: string;
+  cardKeyPrefix: string;
+  modules: ProjectModule[];
+}
+
+export interface ProjectUpdatePayload {
+  name?: string;
+  cardKeyPrefix?: string;
+}
+
+async function toModuleInfo(
+  commands: CommandManager,
+  moduleName: string,
+): Promise<ProjectModule> {
+  try {
+    const data = await commands.showCmd.showModule(moduleName);
+    return {
+      name: data.name || moduleName,
+      cardKeyPrefix: data.cardKeyPrefix || moduleName,
+    };
+  } catch {
+    return {
+      name: moduleName,
+      cardKeyPrefix: moduleName,
+    };
+  }
+}
+
+export async function getProject(
+  commands: CommandManager,
+): Promise<ProjectInfo> {
+  const project = await commands.showCmd.showProject();
+  const modules = await commands.showCmd.showModules();
+  const moduleDetails = await Promise.all(
+    modules.map((mod) => toModuleInfo(commands, mod)),
+  );
+
+  return {
+    name: project.name,
+    cardKeyPrefix: project.prefix,
+    modules: moduleDetails,
+  };
+}
+
+export async function updateProject(
+  commands: CommandManager,
+  updates: ProjectUpdatePayload,
+): Promise<ProjectInfo> {
+  const { name, cardKeyPrefix } = updates;
+
+  if (cardKeyPrefix) {
+    await commands.renameCmd.rename(cardKeyPrefix);
+  }
+  if (name) {
+    await commands.project.configuration.setProjectName(name);
+  }
+
+  return getProject(commands);
+}
+
+export async function updateModule(commands: CommandManager, module: string) {
+  await commands.importCmd.updateModule(module);
+}
+
+export async function deleteModule(commands: CommandManager, module: string) {
+  await commands.removeCmd.remove('module', module);
+}

package/src/domain/resources/service.ts

@@ -11,7 +11,7 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
-import type { ResourceContent } from '@cyberismo/data-handler/interfaces/resource-interfaces';
+import type { AnyResourceContent } from '@cyberismo/data-handler/interfaces/resource-interfaces';
 import type {
   Card,
   CardWithChildrenCards,
@@ -40,12 +40,51 @@ const resourceTypes: ResourceFolderType[] = [
   'workflows',
 ];
 
+async function getModules(commands: CommandManager) {
+  try {
+    const moduleNames = commands.showCmd.showModules();
+    return Promise.all(
+      moduleNames.map(async (moduleName) => {
+        try {
+          const module = await commands.showCmd.showModule(moduleName);
+          return { name: module.name, cardKeyPrefix: module.cardKeyPrefix };
+        } catch (error) {
+          return { name: moduleName, cardKeyPrefix: moduleName };
+        }
+      }),
+    );
+  } catch {
+    return [];
+  }
+}
+
 export async function buildResourceTree(commands: CommandManager) {
   const project = await commands.showCmd.showProject();
   const tree: unknown[] = [];
-  const allModuleResources: {
-    [prefix: string]: { [type: string]: unknown[] };
-  } = {};
+
+  const sortByDisplayName = (
+    nodes: { data: { displayName: string; name: string } }[],
+  ) =>
+    nodes.sort((a, b) =>
+      (a.data.displayName || a.data.name.split('/')[2] || '').localeCompare(
+        b.data.displayName || b.data.name.split('/')[2] || '',
+      ),
+    );
+
+  const modules = await getModules(commands);
+
+  // General section first (single node with project + modules metadata)
+  tree.push({
+    id: 'general-project',
+    type: 'general',
+    name: 'project',
+    data: {
+      name: project.name,
+      cardKeyPrefix: project.prefix,
+      modules,
+    },
+    readOnly: false,
+  });
 
   // Process each resource type
   for (const resourceType of resourceTypes) {
@@ -65,47 +104,54 @@ export async function buildResourceTree(commands: CommandManager) {
       ));
     }
 
-    // Add root level resources
-    if (rootResources.length > 0) {
+    // Sort resources by display name if present
+    sortByDisplayName(
+      rootResources as { data: { displayName: string; name: string } }[],
+    );
+
+    Object.values(moduleResources).forEach((resources) =>
+      sortByDisplayName(
+        resources as { data: { displayName: string; name: string } }[],
+      ),
+    );
+
+    const projectNode =
+      rootResources.length > 0
+        ? [
+            {
+              id: `${resourceType}-project`,
+              type: 'module',
+              name: 'project',
+              children: rootResources,
+              readOnly: false,
+            },
+          ]
+        : [];
+
+    const moduleNodes = Object.entries(moduleResources)
+      .map(([prefix, resources]) => ({
+        id: `${resourceType}-module-${prefix}`,
+        type: 'module',
+        name:
+          modules.find((module) => module.cardKeyPrefix === prefix)?.name ||
+          prefix,
+        prefix,
+        children: resources,
+        readOnly: true,
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    const allResources = [...projectNode, ...moduleNodes];
+
+    // Add combined resources (project + modules nested under module nodes) under the same group
+    if (allResources.length > 0) {
       tree.push({
         id: resourceType,
         type: 'resourceGroup',
         name: resourceType,
-        children: rootResources,
+        children: allResources,
       });
     }
-
-    // Collect module resources
-    Object.entries(moduleResources).forEach(([prefix, resources]) => {
-      if (!allModuleResources[prefix]) {
-        allModuleResources[prefix] = {};
-      }
-      allModuleResources[prefix][resourceType] = resources;
-    });
-  }
-
-  // Build modules section
-  if (Object.keys(allModuleResources).length > 0) {
-    const modules = Object.entries(allModuleResources).map(
-      ([prefix, resourcesByType]) => ({
-        id: `modules-${prefix}`,
-        type: 'module',
-        name: prefix,
-        children: Object.entries(resourcesByType).map(([type, resources]) => ({
-          id: `modules-${prefix}-${type}`,
-          type: 'resourceGroup',
-          name: type,
-          children: resources,
-        })),
-      }),
-    );
-
-    tree.push({
-      id: 'modules',
-      type: 'modulesGroup',
-      name: 'modules',
-      children: modules,
-    });
   }
 
   return tree;
@@ -138,7 +184,7 @@ async function createResourceNode(
   id: string;
   type: ResourceFolderType;
   name: string;
-  data: ResourceContent | undefined;
+  data: AnyResourceContent | undefined;
   children?: unknown[];
   readOnly?: boolean;
 }> {
@@ -147,7 +193,7 @@ async function createResourceNode(
     id: string;
     type: ResourceFolderType;
     name: string;
-    data: ResourceContent | undefined;
+    data: AnyResourceContent | undefined;
     children?: unknown[];
     readOnly?: boolean;
   } = {

package/src/domain/templates/index.ts

@@ -12,10 +12,10 @@
 */
 
 import { Hono } from 'hono';
-import { isSSGContext } from '../../export.js';
 import * as templateService from './service.js';
 import { createTemplateSchema, addTemplateCardSchema } from './schema.js';
 import { zValidator } from '../../middleware/zvalidator.js';
+import { isSSGContext } from 'hono/ssg';
 
 const router = new Hono();
 

package/src/domain/tree/index.ts

@@ -13,7 +13,8 @@
 
 import { Hono } from 'hono';
 import * as treeService from './service.js';
-import { isSSGContext } from '../../export.js';
+import { isSSGContext } from 'hono/ssg';
+import type { AppContext } from '../../types.js';
 
 const router = new Hono();
 
@@ -31,11 +32,17 @@ const router = new Hono();
  *       500:
  *         description: project_path not set or other internal error
  */
-router.get('/', async (c) => {
+router.get('/', async (c: AppContext) => {
   const commands = c.get('commands');
+  const tree = c.get('tree');
 
   try {
-    const response = await treeService.getCardTree(commands, isSSGContext(c));
+    const response = await treeService.getCardTree(
+      commands,
+      isSSGContext(c),
+      tree?.cardKey,
+      tree?.recursive,
+    );
     return c.json(response);
   } catch (error) {
     return c.json(

package/src/domain/tree/service.ts

@@ -13,10 +13,24 @@
 
 import type { CommandManager } from '@cyberismo/data-handler';
 
-export async function getCardTree(commands: CommandManager, isSsg: boolean) {
+/**
+ * Returns the card tree of the project
+ * @param commands command manager used for the query
+ * @param isSsg whether the context is static site generation
+ * @param cardKey optional card key to start the tree from
+ * @param recursive if false, includes only the given card. Otherwise, includes all child cards recursively.
+ * @returns
+ */
+export async function getCardTree(
+  commands: CommandManager,
+  isSsg: boolean,
+  cardKey?: string,
+  recursive?: boolean,
+): ReturnType<typeof commands.calculateCmd.runQuery> {
   await commands.calculateCmd.generate();
   return commands.calculateCmd.runQuery(
     'tree',
     isSsg ? 'exportedSite' : 'localApp',
+    { cardKey, recursive },
   );
 }

package/src/export.ts

@@ -13,21 +13,22 @@
 
 import path from 'node:path';
 
-import { mkdir, readFile } from 'node:fs/promises';
+import fs, { readFile } from 'node:fs/promises';
 
 import { CommandManager } from '@cyberismo/data-handler';
 import { createApp } from './app.js';
 import { cp, writeFile } from 'node:fs/promises';
-import {
-  runCbSafely,
-  runInParallel,
-  staticFrontendDirRelative,
-} from './utils.js';
+import { staticFrontendDirRelative } from './utils.js';
 import type { QueryResult } from '@cyberismo/data-handler/types/queries';
-import type { Context, Hono, MiddlewareHandler } from 'hono';
-import mime from 'mime-types';
+import { toSSG } from 'hono/ssg';
+import type { TreeOptions } from './types.js';
+import {
+  findAllCards,
+  findRelevantAttachments,
+} from './domain/cards/service.js';
 
 let _cardQueryPromise: Promise<QueryResult<'card'>[]> | null = null;
+const OVERHEAD_CALLS = 6; // estimated number of overhead calls during export in addition to card exports
 
 /**
  *  DO NO USE DIRECTLY. This resets the callOnce map, allowing you to redo the export.
@@ -73,19 +74,29 @@ export async function getCardQueryResult(
  * Export the site to a given directory.
  * Note: Do not call this function in parallel.
  * @param projectPath - Path to the project.
+ * @param options - Export options.
+ * @param options.recursive - Whether to export cards recursively.
+ * @param options.cardKey - Key of the card to export. If not provided, all cards will be exported.
  * @param exportDir - Directory to export to.
  * @param level - Log level for the operation.
  * @param onProgress - Optional progress callback function.
+ * @returns An object containing any errors that occurred during export.
  */
 export async function exportSite(
   projectPath: string,
   exportDir?: string,
+  options?: TreeOptions,
   level?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal',
-  onProgress?: (current?: number, total?: number) => void,
-) {
+  onProgress?: (current: number, total: number) => void,
+): Promise<{ errors: string[] }> {
   exportDir = exportDir || 'static';
+  const opts = {
+    recursive: false,
+    cardKey: undefined,
+    ...options,
+  };
 
-  const app = createApp(projectPath);
+  const app = createApp(projectPath, opts);
 
   // copy whole frontend to the same directory
   await cp(staticFrontendDirRelative, exportDir, { recursive: true });
@@ -101,192 +112,48 @@ export async function exportSite(
   const commands = await CommandManager.getInstance(projectPath, {
     logLevel: level,
   });
-  await toSsg(app, commands, exportDir, onProgress);
-}
-
-async function getRoutes(app: Hono) {
-  const routes = new Set<string>();
-  for (const route of app.routes) {
-    if (route.method === 'GET') routes.add(route.path);
-  }
-
-  // handles both routes with and without dynamic parameters
-  const filteredRoutes = [];
-  for (const route of routes) {
-    if (!route.includes(':')) {
-      filteredRoutes.push(route);
-      continue;
-    }
-    const response = await createSsgRequest(app, route, true);
-    if (response.ok) {
-      const params = await response.json();
-      if (Array.isArray(params) && params.length > 0) {
-        for (const param of params) {
-          let newRoute = route;
-          for (const [key, value] of Object.entries(param)) {
-            newRoute = newRoute.replace(`:${key}`, `${value}`);
-          }
-          filteredRoutes.push(newRoute);
-        }
-      }
-    }
-  }
-
-  return filteredRoutes;
-}
 
-/**
- * This is similar to hono's ssg function, but it only calls middlewares once
- * @param app
- * @param onProgress
- */
-async function toSsg(
-  app: Hono,
-  commands: CommandManager,
-  dir: string,
-  onProgress?: (current?: number, total?: number) => void,
-) {
   reset();
   await commands.project.calculationEngine.generate();
 
-  const promises = [];
-
-  const routes = await getRoutes(app);
-  await runCbSafely(() => onProgress?.(0, routes.length));
-
-  let processedFiles = 0;
-  let failed = false;
-  const errors: Error[] = [];
-  const done = async (error?: Error) => {
-    if (error) {
-      failed = true;
-      errors.push(error);
-    }
-    processedFiles++;
-    await runCbSafely(() => onProgress?.(processedFiles, routes.length));
-  };
-  for (const route of routes) {
-    promises.push(async () => {
-      try {
-        const response = await createSsgRequest(app, route, false);
-        if (!response.ok) {
-          const error = await response.json();
-          if (typeof error === 'object' && error !== null && 'error' in error) {
-            await done(
-              new Error(`Failed to export route ${route}: ${error.error}`),
-            );
-          } else {
-            await done(new Error(`Failed to export route ${route}`));
+  // estimate total based on the number of cards to export
+  const cards = await findAllCards(commands, opts);
+  const attachments = await findRelevantAttachments(commands, opts);
+  let total = cards.length + attachments.length + OVERHEAD_CALLS;
+
+  // Actual export with progress reporting
+  let done = 0;
+  onProgress?.(done, total);
+  const errors: string[] = [];
+  await toSSG(app, fs, {
+    dir: exportDir,
+    concurrency: 5,
+    plugins: [
+      {
+        afterResponseHook: async (response) => {
+          if (![200, 201, 204].includes(response.status)) {
+            const error = await response.json();
+            if (
+              typeof error === 'object' &&
+              error != null &&
+              'error' in error &&
+              typeof error.error === 'string'
+            ) {
+              errors.push(error.error);
+            }
+            return false; // ignore route
           }
-          return;
-        }
-        await writeFileToDir(dir, response, route);
-        await done();
-      } catch (error) {
-        await done(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-
-  await runInParallel(promises, 5);
-  if (failed) {
-    const message = `Errors:\n${errors.map((e) => e.message).join('\n')}`;
-    throw new Error(message);
-  }
-}
-
-/**
- * Get the file content and file ending for a given response and route.
- * @param response - The response to get the file content and file ending for.
- * @param route - The route to get the file content and file ending for.
- * @returns The file content and file ending for the given response and route.
- * If the route already has a file ending, it will be returned as an empty string.
- */
-async function getFileContent(
-  response: Response,
-  route: string,
-): Promise<{
-  content: ArrayBuffer;
-  fileEnding: string;
-}> {
-  // Check if route already has an extension
-  const routeExtension = path.extname(route);
-  if (routeExtension) {
-    // Trust the existing extension in the route
-    const content = await response.arrayBuffer();
-    return {
-      content,
-      fileEnding: '',
-    };
-  }
-
-  // No extension in route, fall back to content type detection
-  const contentType = response.headers.get('content-type');
-  if (!contentType) {
-    throw new Error('No content type');
-  }
-  const extension = mime.extension(contentType);
-  if (!extension) {
-    throw new Error('Unsupported content type');
-  }
-
-  // Use ArrayBuffer for all content types
-  const content = await response.arrayBuffer();
-  return {
-    content,
-    fileEnding: `.${extension}`,
-  };
-}
-
-async function writeFileToDir(dir: string, response: Response, route: string) {
-  const { content, fileEnding } = await getFileContent(response, route);
-
-  let filePath = path.join(dir, route);
-
-  // if route does not have a file ending, add it based on the content type
-  if (!route.endsWith(fileEnding)) {
-    filePath += fileEnding;
-  }
-
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, Buffer.from(content));
-}
-
-// findroutes = if this request is used to find the routes in the app
-function createSsgRequest(
-  app: Hono,
-  route: string,
-  findRoutes: boolean = true,
-) {
-  return app.request(route, {
-    headers: new Headers({
-      'x-ssg': 'true',
-      'x-ssg-find': findRoutes ? 'true' : 'false',
-    }),
+          done++;
+          if (done > total) {
+            total = done; // adjust total if underestimated
+          }
+          onProgress?.(done, total);
+          return response;
+        },
+      },
+    ],
   });
-}
-
-/**
- * Check if the request is a static site generation request.
- * @param c - The context of the request.
- * @returns True if the request is a static site generation request.
- */
-export function isSSGContext(c: Context) {
-  return c.req.header('x-ssg') === 'true';
-}
-
-/**
- * This middleware is used to find the routes in the app.
- * @param fn - The function to call to get the parameters for the route.
- * @returns The middleware handler.
- */
-export function ssgParams(
-  fn?: (c: Context) => Promise<unknown[]>,
-): MiddlewareHandler {
-  return async (c, next) => {
-    if (c.req.header('x-ssg-find') === 'true') {
-      return fn ? c.json(await fn(c)) : c.json([]);
-    }
-    return next();
+  return {
+    errors,
   };
 }

package/src/index.ts

@@ -11,6 +11,7 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 import { serve } from '@hono/node-server';
+import type { Env, Schema } from 'hono';
 import { Hono } from 'hono';
 import { serveStatic } from '@hono/node-server/serve-static';
 import path from 'node:path';
@@ -62,7 +63,10 @@ export async function startServer(
   startApp(app, port);
 }
 
-function startApp(app: Hono, port: number) {
+function startApp<E extends Env, S extends Schema, P extends string>(
+  app: Hono<E, S, P>,
+  port: number,
+) {
   serve(
     {
       fetch: app.fetch,

package/src/middleware/tree.ts

@@ -0,0 +1,17 @@
+import type { Next } from 'hono';
+import type { AppContext, TreeOptions } from '../types.js';
+
+/**
+ * Injects tree options into the context for each request
+ * @param opts Options to inject
+ * @returns Middleware function
+ */
+const treeMiddleware =
+  (opts?: TreeOptions) => async (c: AppContext, next: Next) => {
+    if (opts) {
+      c.set('tree', { recursive: opts.recursive, cardKey: opts.cardKey });
+    }
+    await next();
+  };
+
+export default treeMiddleware;

package/src/types.ts

@@ -11,6 +11,8 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
+import type { Context } from 'hono';
+
 export interface ResourceFileContentResponse {
   content: string;
 }
@@ -18,3 +20,14 @@ export interface ResourceFileContentResponse {
 export interface ResourceValidationResponse {
   errors: string[];
 }
+
+export interface TreeOptions {
+  recursive?: boolean;
+  cardKey?: string;
+}
+
+export interface AppVars {
+  tree?: TreeOptions;
+}
+
+export type AppContext = Context<{ Variables: AppVars }>;