@cyberismo/data-handler 0.0.7 → 0.0.9

package/src/macros/graph/index.ts

@@ -12,12 +12,9 @@
 */
 
 import BaseMacro from '../base-macro.js';
-import { Calculate } from '../../commands/index.js';
-import type { MacroOptions } from '../index.js';
 import { createImage, validateMacroContent } from '../index.js';
 import Handlebars from 'handlebars';
 import { join } from 'node:path';
-import { getChildLogger } from '../../utils/log-utils.js';
 import type { MacroGenerationContext } from '../../interfaces/macros.js';
 import macroMetadata from './metadata.js';
 import { pathExists } from '../../utils/file-utils.js';
@@ -26,18 +23,14 @@ import { resourceName } from '../../utils/resource-utils.js';
 import type { Schema } from 'jsonschema';
 import { validateJson } from '../../utils/validate.js';
 import type TaskQueue from '../task-queue.js';
+import { ClingoError } from '@cyberismo/node-clingo';
 
-export interface GraphOptions extends MacroOptions {
+export interface GraphOptions {
   model: string;
   view: string;
 }
 
 class ReportMacro extends BaseMacro {
-  private get logger() {
-    return getChildLogger({
-      module: 'graphMacro',
-    });
-  }
   constructor(tasksQueue: TaskQueue) {
     super(macroMetadata, tasksQueue);
   }
@@ -51,8 +44,6 @@ class ReportMacro extends BaseMacro {
   };
 
   handleInject = async (context: MacroGenerationContext, input: unknown) => {
-    const calculate = new Calculate(context.project);
-
     const resourceNameToPath = (name: string, fileName: string) => {
       const { identifier, prefix, type } = resourceName(name);
       if (prefix === context.project.projectPrefix) {
@@ -117,7 +108,21 @@ class ReportMacro extends BaseMacro {
     const view = handlebars.compile(viewContent)(handlebarsContext);
 
     const modelContent = await readFile(modelLocation, { encoding: 'utf-8' });
-    const result = await calculate.runGraph(modelContent, view);
+    let result: string;
+    try {
+      result = await context.project.calculationEngine.runGraph(
+        modelContent,
+        view,
+        context.context,
+      );
+    } catch (error) {
+      if (error instanceof ClingoError) {
+        throw new Error(
+          `Error running graph in view '${options.view}' in model '${options.model}': ${error.details.errors.join('\n')}`,
+        );
+      }
+      throw error;
+    }
 
     if (typeof result !== 'string') {
       throw new Error(

package/src/macros/image/index.ts

@@ -0,0 +1,121 @@
+/**
+  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 { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import mime from 'mime-types';
+
+import { validateMacroContent } from '../index.js';
+
+import type { MacroGenerationContext } from '../../interfaces/macros.js';
+import macroMetadata from './metadata.js';
+import BaseMacro from '../base-macro.js';
+import type TaskQueue from '../task-queue.js';
+
+/**
+ * Options for the image macro.
+ * @param fileName - Name of the file to include.
+ * @param cardKey - Key of the card to include the file from.
+ * @param alt - Alternative text for the image.
+ * @param title - Title of the image.
+ */
+export interface ImageMacroOptions {
+  fileName: string;
+  cardKey?: string;
+  alt?: string;
+  title?: string;
+}
+
+/**
+ * Macro for including images in the content
+ */
+export default class ImageMacro extends BaseMacro {
+  constructor(tasksQueue: TaskQueue) {
+    super(macroMetadata, tasksQueue);
+  }
+
+  handleValidate = (input: unknown) => {
+    this.validate(input);
+  };
+
+  handleStatic = async (
+    context: MacroGenerationContext,
+    input: unknown,
+  ): Promise<string> => {
+    const options = this.validate(input);
+    const cardKey = options.cardKey || context.cardKey;
+
+    // Get the attachment folder path
+    const attachmentFolder =
+      await context.project.cardAttachmentFolder(cardKey);
+    if (!attachmentFolder) {
+      throw new Error(`Card '${cardKey}' not found`);
+    }
+
+    // Read the file and convert to base64
+    const attachmentPath = join(attachmentFolder, options.fileName);
+    if (!existsSync(attachmentPath)) {
+      throw new Error(
+        `Attachment file '${options.fileName}' not found in card '${cardKey}'`,
+      );
+    }
+
+    const fileBuffer = readFileSync(attachmentPath);
+    const base64Data = fileBuffer.toString('base64');
+
+    // Get mime type
+    const mimeType = mime.lookup(attachmentPath) || 'application/octet-stream';
+
+    // Build image attributes
+    const attributes = this.buildImageAttributes(options);
+
+    // Return as data URI for static mode (for export/PDF generation)
+    return `image::data:${mimeType};base64,${base64Data}[${attributes}]`;
+  };
+
+  handleInject = async (context: MacroGenerationContext, input: unknown) => {
+    const options = this.validate(input);
+    const cardKey = options.cardKey || context.cardKey;
+
+    // Verify that the card and attachment folder exist
+    const attachmentFolder =
+      await context.project.cardAttachmentFolder(cardKey);
+    if (!attachmentFolder) {
+      throw new Error(`Card '${cardKey}' not found`);
+    }
+
+    // Build image attributes
+    const attributes = this.buildImageAttributes(options);
+
+    // In inject mode, always use the API path for consistency
+    return `image::/api/cards/${cardKey}/a/${options.fileName}[${attributes}]`;
+  };
+
+  private buildImageAttributes(options: ImageMacroOptions): string {
+    const attributes: string[] = [];
+
+    if (options.alt !== undefined) {
+      attributes.push(`alt="${options.alt}"`);
+    }
+
+    if (options.title !== undefined) {
+      attributes.push(`title="${options.title}"`);
+    }
+
+    return attributes.join(',');
+  }
+
+  private validate(input: unknown): ImageMacroOptions {
+    return validateMacroContent<ImageMacroOptions>(this.metadata, input);
+  }
+}

package/src/macros/image/metadata.ts

@@ -0,0 +1,25 @@
+/**
+  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 { MacroMetadata } from '../../interfaces/macros.js';
+
+/**
+ * Metadata for the image macro.
+ */
+const macroMetadata: MacroMetadata = {
+  name: 'image',
+  tagName: 'image',
+  schema: 'imageMacroSchema',
+};
+
+export default macroMetadata;

package/src/macros/include/index.ts

@@ -0,0 +1,147 @@
+/**
+  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 { evaluateMacros, validateMacroContent } from '../index.js';
+
+import type { MacroGenerationContext } from '../../interfaces/macros.js';
+import macroMetadata from './metadata.js';
+import BaseMacro from '../base-macro.js';
+import type TaskQueue from '../task-queue.js';
+import { MAX_LEVEL_OFFSET } from '../../utils/constants.js';
+
+export interface IncludeMacroOptions {
+  cardKey: string;
+  levelOffset?: string;
+  title?: 'include' | 'exclude' | 'only';
+  pageTitles?: 'normal' | 'discrete';
+}
+
+export default class IncludeMacro extends BaseMacro {
+  constructor(tasksQueue: TaskQueue) {
+    super(macroMetadata, tasksQueue);
+  }
+
+  handleValidate = (input: unknown) => {
+    this.validate(input);
+  };
+
+  handleStatic = async (
+    context: MacroGenerationContext,
+    input: unknown,
+  ): Promise<string> => {
+    const options = this.validate(input);
+    if (!options.title) {
+      options.title = 'include';
+    }
+    if (!options.pageTitles) {
+      options.pageTitles = 'normal';
+    }
+    const card = await context.project.cardDetailsById(options.cardKey, {
+      content: true,
+      metadata: true,
+    });
+    if (!card) {
+      throw new Error(`Card key ${options.cardKey} not found`);
+    }
+    const newContext = {
+      ...context,
+      cardKey: options.cardKey,
+    };
+
+    const anchor = this.generateAnchor(options);
+    const title = this.generateTitle(options, card.metadata?.title);
+    const cardContent = await this.generateCardContent(
+      options,
+      card.content,
+      newContext,
+    );
+    const content = `\n\n${anchor}${title}${cardContent}`;
+
+    let levelOffset = 0;
+    if (options.levelOffset) {
+      levelOffset = parseInt(options.levelOffset, 10);
+      if (isNaN(levelOffset)) {
+        throw new Error(`Invalid level offset: ${options.levelOffset}`);
+      }
+      levelOffset = Math.min(
+        Math.max(levelOffset, -MAX_LEVEL_OFFSET),
+        MAX_LEVEL_OFFSET,
+      );
+    }
+
+    const adjustedContent = this.adjustTitles(
+      content,
+      levelOffset,
+      options.pageTitles === 'discrete',
+    );
+    return adjustedContent;
+  };
+
+  handleInject = async (context: MacroGenerationContext, input: unknown) => {
+    return this.handleStatic(context, input);
+  };
+
+  private validate(input: unknown): IncludeMacroOptions {
+    return validateMacroContent<IncludeMacroOptions>(this.metadata, input);
+  }
+
+  private generateAnchor(options: IncludeMacroOptions): string {
+    return options.title !== 'exclude' && options.pageTitles === 'normal'
+      ? `[[${options.cardKey}]]\n`
+      : '';
+  }
+
+  private generateTitle(
+    options: IncludeMacroOptions,
+    cardTitle?: string,
+  ): string {
+    if (options.title === 'only' || options.title === 'include') {
+      return `= ${cardTitle}\n\n`;
+    }
+    return '';
+  }
+
+  private async generateCardContent(
+    options: IncludeMacroOptions,
+    cardContent: string | undefined,
+    context: MacroGenerationContext,
+  ): Promise<string> {
+    if (options.title !== 'only') {
+      return await evaluateMacros(cardContent ?? '', context, true);
+    }
+    return '';
+  }
+
+  // Adjust asciidoc titles to match the level offset
+  private adjustTitles(
+    content: string,
+    levelOffset: number,
+    discrete: boolean,
+  ) {
+    const lines = content.split('\n');
+    const adjustedLines = lines.map((line) => {
+      const match = line.match(/^(\s*)([=#]+)(.*?)\s*$/);
+      if (match) {
+        const currentLevel = match[2].length;
+        const newLevel = Math.min(
+          Math.max(1, currentLevel + levelOffset),
+          MAX_LEVEL_OFFSET + 1,
+        );
+        const equals = '='.repeat(newLevel);
+        return `${discrete ? '[discrete]\n' : ''}${match[1]}${equals} ${match[3].trim()}`;
+      }
+      return line;
+    });
+    return adjustedLines.join('\n');
+  }
+}

package/src/macros/include/metadata.ts

@@ -0,0 +1,22 @@
+/**
+  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 { MacroMetadata } from '../../interfaces/macros.js';
+
+const macroMetadata: MacroMetadata = {
+  name: 'include',
+  tagName: 'include',
+  schema: 'includeMacroSchema',
+};
+
+export default macroMetadata;