@cyberismo/data-handler 0.0.6 → 0.0.8

package/src/macros/index.ts

@@ -18,7 +18,7 @@ import report from './report/index.js';
 import scoreCard from './scoreCard/index.js';
 
 import { validateJson } from '../utils/validate.js';
-import { DHValidationError } from '../exceptions/index.js';
+import { DHValidationError, MacroError } from '../exceptions/index.js';
 import type { AdmonitionType } from '../interfaces/adoc.js';
 import type { Validator } from 'jsonschema';
 import type {
@@ -28,21 +28,46 @@ import type {
 } from '../interfaces/macros.js';
 import type BaseMacro from './base-macro.js';
 import TaskQueue from './task-queue.js';
-
+import type { Calculate } from '../commands/index.js';
+import { ClingoError } from '@cyberismo/node-clingo';
 const CURLY_LEFT = '{';
 const CURLY_RIGHT = '}';
 
-export interface MacroConstructor {
-  new (tasks: TaskQueue): BaseMacro; // Constructor signature
+/**
+ * Constructor for all macros except report macros
+ */
+export interface SimpleMacroConstructor {
+  new (tasks: TaskQueue): BaseMacro;
+}
+
+/**
+ * Constructor for report macros
+ */
+export interface ReportMacroConstructor {
+  new (tasks: TaskQueue, calculate: Calculate): BaseMacro;
 }
 
-export const macros: { [K in MacroName]: MacroConstructor } = {
+/**
+ * Constructor for all macros
+ */
+export type MacroConstructor = SimpleMacroConstructor | ReportMacroConstructor;
+
+export const macros: {
+  [K in MacroName]: MacroConstructor;
+} = {
   createCards,
   graph,
   report,
   scoreCard,
 };
 
+/**
+ * Validates the content inside a macro
+ * @param macro - The macro to validate the content of
+ * @param data - The data to validate
+ * @param validator - The validator to use
+ * @returns The validated data
+ */
 export function validateMacroContent<T>(
   macro: MacroMetadata,
   data: unknown,
@@ -74,11 +99,12 @@ export function registerMacros(
   instance: typeof Handlebars,
   context: MacroGenerationContext,
   tasks: TaskQueue,
+  calculate: Calculate,
 ) {
   const macroInstances: BaseMacro[] = [];
   for (const macro of Object.keys(macros) as MacroName[]) {
     const MacroClass = macros[macro];
-    const macroInstance = new MacroClass(tasks);
+    const macroInstance = new MacroClass(tasks, calculate);
     instance.registerHelper(macro, function (this: unknown, options) {
       if (
         this != null &&
@@ -134,11 +160,12 @@ export function registerEmptyMacros(instance: typeof Handlebars) {
 export async function evaluateMacros(
   content: string,
   context: MacroGenerationContext,
+  calculate: Calculate,
   maxTries: number = 10,
 ) {
   const handlebars = Handlebars.create();
   const tasks = new TaskQueue();
-  registerMacros(handlebars, context, tasks);
+  registerMacros(handlebars, context, tasks, calculate);
   let result = content;
   while (maxTries-- > 0) {
     tasks.reset();
@@ -185,7 +212,14 @@ export function applyMacroResults(
   context: MacroGenerationContext,
 ) {
   for (const item of tasks) {
-    if (item.promiseResult === null) {
+    if (item.error) {
+      input = input.replace(
+        item.placeholder,
+        handleMacroError(item.error, item.macro, context),
+      );
+    } // It should not be possible that promiseResult is null if there never was an error
+    // Unless the function itself returns null / undefined
+    else if (item.promiseResult == null) {
       input = handleMacroError(
         new Error(
           `Tried to access result before it was resolved for ${item.placeholder}`,
@@ -214,7 +248,17 @@ export function handleMacroError(
   let message = `Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
   if (error instanceof DHValidationError) {
     message = `Check json syntax of macro ${macro}: ${error.errors?.map((e) => e.message).join(', ')}`;
+  } else if (error instanceof MacroError) {
+    const { cardKey, macroName, dependency } = error.context;
+    message = `Macro error in card '${cardKey}' in macro '${macroName}':\n\n${error.message}.`;
+
+    if (dependency) {
+      message += `\n\nParameters:\n\n${context.mode === 'validate' ? dependency.parameters : createCodeBlock(dependency.parameters)}.\n\n${dependency.output ? `Output:\n\n${context.mode === 'validate' ? dependency.output : createCodeBlock(dependency.output)}` : ''}`;
+    }
+  } else if (error instanceof ClingoError) {
+    message = `Error running logic program in macro '${macro}':${error.details.errors.join('\n')}`;
   }
+
   if (
     typeof error === 'object' &&
     error != null &&
@@ -302,6 +346,15 @@ export function createAdmonition(
   return `[${type}]\n.${label}\n====\n${content}\n====\n\n`;
 }
 
+/**
+ * Creates a code block
+ * @param content - The content of the code block
+ * @returns The code block as a string
+ */
+export function createCodeBlock(content: string) {
+  return `\n\n----\n${content}\n----\n\n`;
+}
+
 /**
  * Helper function for including base64 encoded images for now
  * @param image base64 encoded image

package/src/macros/report/index.ts

@@ -1,35 +1,40 @@
 /**
-    Cyberismo
-    Copyright © Cyberismo Ltd and contributors 2024
-
-    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/>.
+  Cyberismo
+  Copyright © Cyberismo Ltd and contributors 2024
+  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 { registerEmptyMacros, validateMacroContent } from '../index.js';
+import { validateMacroContent } from '../index.js';
 import type { MacroOptions } from '../index.js';
+
 import type { MacroGenerationContext } from '../../interfaces/macros.js';
 import macroMetadata from './metadata.js';
-import { Project } from '../../containers/project.js';
-import { Calculate } from '../../commands/index.js';
-import Handlebars from 'handlebars';
+import type { Calculate } from '../../commands/index.js';
 import BaseMacro from '../base-macro.js';
 import { validateJson } from '../../utils/validate.js';
 import type TaskQueue from '../task-queue.js';
 import { ReportResource } from '../../resources/report-resource.js';
 import { resourceName } from '../../utils/resource-utils.js';
+import { generateReportContent } from '../../utils/report.js';
+import { ClingoError } from '@cyberismo/node-clingo';
 
 export interface ReportOptions extends MacroOptions {
   name: string;
 }
 
 class ReportMacro extends BaseMacro {
-  constructor(tasksQueue: TaskQueue) {
-    super(macroMetadata, tasksQueue);
+  constructor(
+    tasks: TaskQueue,
+    private readonly calculate: Calculate,
+  ) {
+    super(macroMetadata, tasks);
   }
   handleValidate = (input: unknown) => {
     this.validate(input);
@@ -41,43 +46,37 @@ class ReportMacro extends BaseMacro {
 
   handleInject = async (context: MacroGenerationContext, data: unknown) => {
     const options = this.validate(data);
-    const project = new Project(context.projectPath);
-    const resource = new ReportResource(project, resourceName(options.name));
+    const resource = new ReportResource(
+      context.project,
+      resourceName(options.name),
+    );
     const report = await resource.show();
 
-    if (!report) throw new Error(`Report ${options} does not exist`);
+    if (!report) throw new Error(`Report ${options.name} does not exist`);
 
     if (report.schema) {
       validateJson(options, {
         schema: report.schema,
       });
     }
-
-    const handlebarsContext = {
-      cardKey: context.cardKey,
-      ...options,
-    };
-
-    const handlebars = Handlebars.create();
-
-    const template = handlebars.compile(report.queryTemplate, {
-      strict: true,
-    });
-
-    const calculate = new Calculate(project);
-    const result = await calculate.runLogicProgram({
-      query: template(handlebarsContext),
-    });
-    if (result.error) {
-      throw new Error(result.error);
+    try {
+      return await generateReportContent({
+        calculate: this.calculate,
+        contentTemplate: report.contentTemplate,
+        queryTemplate: report.queryTemplate,
+        options: {
+          cardKey: context.cardKey,
+          ...options,
+        },
+      });
+    } catch (error) {
+      if (error instanceof ClingoError) {
+        throw new Error(
+          `Error running logic program in report '${options.name}':${error.details.errors.join('\n')}`,
+        );
+      }
+      throw error;
     }
-    // register empty macros so that other macros aren't touched yet
-    registerEmptyMacros(handlebars);
-
-    return handlebars.compile(report.contentTemplate)({
-      ...handlebarsContext,
-      ...result,
-    });
   };
 
   private validate(data: unknown): ReportOptions {