@cyberismo/data-handler 0.0.8 → 0.0.10

package/src/utils/clingo-parser.ts

@@ -11,11 +11,7 @@
 */
 
 import type { DataType } from '../interfaces/resource-interfaces.js';
-import type {
-  BaseResult,
-  LinkDirection,
-  ParseResult,
-} from '../types/queries.js';
+import type { BaseResult, ParseResult } from '../types/queries.js';
 
 /**
  * This function reverses the encoding made by the "encodeClingoValue" function
@@ -28,25 +24,17 @@ export function decodeClingoValue(value: string) {
     return char;
   });
 }
+// Enums and lists are handled by the query language
+type FieldDataType = Omit<DataType, 'list' | 'enum'> | 'stringList';
 
 class ClingoParser {
   private keywords = [
     'queryError',
     'result',
     'childResult',
+    'childObject',
     'field',
-    'enumField',
-    'listField',
-    'label',
-    'link',
-    'transitionDenied',
-    'movingCardDenied',
-    'deletingCardDenied',
-    'editingFieldDenied',
-    'editingContentDenied',
-    'notification',
-    'policyCheckFailure',
-    'policyCheckSuccess',
+    'childResultCollection',
     'order',
   ];
 
@@ -62,6 +50,11 @@ class ClingoParser {
     childKey: string;
     collection: string;
   }[] = [];
+  private childObjectQueue: {
+    parentKey: string;
+    name: string;
+    collection: string;
+  }[] = [];
   private tempResults: { [key: string]: BaseResult } = {};
   private orderQueue: {
     level: number;
@@ -78,6 +71,7 @@ class ClingoParser {
     };
     this.resultQueue = [];
     this.childResultQueue = [];
+    this.childObjectQueue = [];
     this.tempResults = {};
     this.orderQueue = [];
     this.collections = new Set();
@@ -100,47 +94,20 @@ class ClingoParser {
       this.childResultQueue.push({ parentKey, childKey, collection });
       this.collections.add(collection);
     },
-    enumField: async (
-      key: string,
-      fieldName: string,
-      fieldValue: string,
-      index: string,
-      displayValue: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      const decoded = decodeClingoValue(fieldValue);
-      const parsedIndex = parseInt(index, 10);
-      res[fieldName] = {
-        value: decoded,
-        index: parsedIndex,
-        displayValue,
-      };
-    },
-    // NOTE: Must be tested in INTDEV-623
-    listField: async (
-      key: string,
-      fieldName: string,
-      fieldValue: string,
-      index: string,
-      displayValue: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      const decoded = decodeClingoValue(fieldValue);
-      if (!res[fieldName] || !Array.isArray(res[fieldName])) {
-        res[fieldName] = [];
+    childResultCollection: (parentKey: string, collection: string) => {
+      const parent = this.getOrInitResult(parentKey);
+      if (!parent[collection] || !Array.isArray(parent[collection])) {
+        parent[collection] = [];
       }
-      const parsedIndex = parseInt(index, 10);
-      (res[fieldName] as unknown[]).push({
-        value: decoded,
-        index: parsedIndex,
-        displayValue,
-      });
+    },
+    childObject: (parentKey: string, name: string, collection: string) => {
+      this.childObjectQueue.push({ parentKey, name, collection });
     },
     field: async (
       key: string,
       fieldName: string,
       fieldValue: string,
-      dataType: DataType,
+      dataType: FieldDataType,
     ) => {
       const res = this.getOrInitResult(key);
       const decoded = decodeClingoValue(fieldValue);
@@ -161,89 +128,14 @@ class ClingoParser {
         case 'boolean':
           res[fieldName] = fieldValue === 'true';
           break;
+        case 'stringList':
+          if (!res[fieldName] || !Array.isArray(res[fieldName])) {
+            res[fieldName] = [];
+          }
+          (res[fieldName] as unknown[]).push(decoded);
+          break;
       }
     },
-    label: (key: string, label: string) => {
-      const res = this.getOrInitResult(key);
-      res.labels.push(label);
-    },
-    link: (
-      key: string, // key is the card itself
-      cardKey: string, // cardKey is otherCard this is being linked to
-      title: string,
-      linkType: string,
-      displayName: string,
-      direction: LinkDirection,
-      linkSource: 'user' | 'calculated',
-      linkDescription?: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      res.links.push({
-        key: cardKey,
-        linkType,
-        displayName,
-        linkDescription,
-        direction,
-        linkSource,
-        title,
-      });
-    },
-    transitionDenied: (
-      key: string,
-      transitionName: string,
-      errorMessage: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      res.deniedOperations.transition.push({ transitionName, errorMessage });
-    },
-    movingCardDenied: (key: string, errorMessage: string) => {
-      const res = this.getOrInitResult(key);
-      res.deniedOperations.move.push({ errorMessage });
-    },
-    deletingCardDenied: (key: string, errorMessage: string) => {
-      const res = this.getOrInitResult(key);
-      res.deniedOperations.delete.push({ errorMessage });
-    },
-    editingFieldDenied: (
-      key: string,
-      fieldName: string,
-      errorMessage: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      res.deniedOperations.editField.push({ fieldName, errorMessage });
-    },
-    editingContentDenied: (key: string, errorMessage: string) => {
-      const res = this.getOrInitResult(key);
-      res.deniedOperations.editContent.push({ errorMessage });
-    },
-    notification: (
-      key: string,
-      category: string,
-      title: string,
-      message: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      res.notifications.push({ key, category, title, message });
-    },
-    policyCheckFailure: (
-      key: string,
-      category: string,
-      title: string,
-      errorMessage: string,
-      fieldName?: string,
-    ) => {
-      const res = this.getOrInitResult(key);
-      res.policyChecks.failures.push({
-        category,
-        title,
-        errorMessage,
-        fieldName,
-      });
-    },
-    policyCheckSuccess: (key: string, category: string, title: string) => {
-      const res = this.getOrInitResult(key);
-      res.policyChecks.successes.push({ category, title });
-    },
     order: (
       level: string,
       collection: string,
@@ -267,17 +159,6 @@ class ClingoParser {
     if (!this.tempResults[key]) {
       this.tempResults[key] = {
         key,
-        labels: [],
-        links: [],
-        notifications: [],
-        policyChecks: { successes: [], failures: [] },
-        deniedOperations: {
-          transition: [],
-          move: [],
-          delete: [],
-          editField: [],
-          editContent: [],
-        },
       };
     }
     return this.tempResults[key];
@@ -379,6 +260,12 @@ class ClingoParser {
       (parent[collection] as unknown[]).push(child);
     });
 
+    this.childObjectQueue.forEach(({ parentKey, name, collection }) => {
+      const parent = this.getOrInitResult(parentKey);
+      const child = this.getOrInitResult(name);
+      parent[collection] = child;
+    });
+
     this.sortByLevel(this.result.results);
   }
 

package/src/utils/constants.ts

@@ -15,6 +15,22 @@ import type { PredefinedCardMetadata } from '../interfaces/project-interfaces.js
 
 export const INT32_MAX = 2147483647; // 2^31-1
 
+// Maximum level offset for includeMacro
+export const MAX_LEVEL_OFFSET = 5;
+
+/**
+ * These are file names that are valid for folder resources.
+ * Note that the folders might still contain other files, such as .schema files,
+ * but this is used for whitelisting the files that are allowed to be edited.
+ */
+export const VALID_FOLDER_RESOURCE_FILES = [
+  'index.adoc.hbs',
+  'query.lp.hbs',
+  'parameterSchema.json',
+  'view.lp.hbs',
+  'model.lp',
+];
+
 /**
  * These are field names that are non-custom fields that present in metadata
  */

package/src/utils/csv.ts

@@ -45,7 +45,7 @@ export async function readCsvFile(file: string): Promise<CSVRowRaw[]> {
     if (!Array.isArray(row)) {
       throw new Error('Row is not an array');
     }
-    return headers.reduce((acc, header, index) => {
+    return headers.reduce((acc: Record<string, string>, header, index) => {
       acc[header] = row[index];
       return acc;
     }, {});

package/src/utils/report.ts

@@ -10,8 +10,10 @@
     License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import Handlebars from 'handlebars';
-import type { Calculate } from '../commands/index.js';
+import type { CalculationEngine } from '../containers/project/calculation-engine.js';
 import { registerEmptyMacros } from '../macros/index.js';
+import type { Context } from '../interfaces/project-interfaces.js';
+import { resourceName } from './resource-utils.js';
 
 /**
  * Formats a value from a logic program for use to graphviz
@@ -30,15 +32,51 @@ export function formatAttributeValue(value?: string) {
   return `"${value}"`;
 }
 
+/**
+ * Checks if a field is a custom field
+ * @param field - The field to check
+ * @returns True if the field is a custom field, false otherwise
+ */
+export function isCustomField(field: string) {
+  try {
+    const { type } = resourceName(field, true);
+    return type === 'fieldTypes';
+  } catch {
+    return false;
+  }
+}
+/**
+ * Formats a value for display in a report
+ * @param value - The value to format
+ * @returns The formatted value
+ */
+export function formatValue(value: unknown): string {
+  if (typeof value === 'object') {
+    if (Array.isArray(value)) {
+      return value.map((v) => formatValue(v)).join(', ');
+    }
+    if (
+      value != null &&
+      'displayValue' in value &&
+      typeof value.displayValue === 'string'
+    ) {
+      return value.displayValue;
+    }
+    return JSON.stringify(value, null, 2);
+  }
+  return value?.toString() ?? '';
+}
+
 /**
  * Parameters for the core generation function
  */
 interface GenerateReportContentParams {
-  calculate: Calculate;
+  calculate: CalculationEngine;
   contentTemplate: string;
   queryTemplate: string;
-  options: Record<string, string>;
+  options: Record<string, string | undefined | boolean>;
   graph?: boolean;
+  context: Context;
 }
 
 /**
@@ -58,6 +96,7 @@ export async function generateReportContent(
     queryTemplate,
     graph,
     options, // Destructure options
+    context,
   } = params;
 
   const handlebars = Handlebars.create();
@@ -67,7 +106,7 @@ export async function generateReportContent(
     strict: true,
   });
 
-  const result = await calculate.runLogicProgram(template(options));
+  const result = await calculate.runLogicProgram(template(options), context);
 
   if (result.error) {
     throw new Error(result.error);
@@ -78,6 +117,8 @@ export async function generateReportContent(
   if (graph) {
     handlebars.registerHelper('formatAttributeValue', formatAttributeValue);
   }
+  handlebars.registerHelper('isCustomField', isCustomField);
+  handlebars.registerHelper('formatValue', formatValue);
 
   return handlebars.compile(contentTemplate)({
     ...options,

package/src/utils/resource-utils.ts

@@ -29,7 +29,16 @@ const TYPE_INDEX = 1;
 const IDENTIFIER_INDEX = 2;
 // Valid resource name has three parts
 const RESOURCE_NAME_PARTS = 3;
+const RESOURCE_FOLDER_TYPES = [
+  'graphModels',
+  'graphViews',
+  'reports',
+  'templates',
+];
 
+export function isResourceFolderType(type: string): boolean {
+  return RESOURCE_FOLDER_TYPES.includes(type);
+}
 // Checks if name is valid (3 parts, separated by '/').
 export function isResourceName(name: string): boolean {
   const partsCount = name.split('/').length;
@@ -84,19 +93,20 @@ export function resourceName(
 export function resourceNameToPath(
   project: Project,
   resourceName: ResourceName,
+  extension: string = '.json',
 ): string {
   if (project.projectPrefix === resourceName.prefix) {
     return join(
       project.paths.resourcesFolder,
       resourceName.type,
-      resourceName.identifier + '.json',
+      resourceName.identifier + extension,
     );
   } else if (resourceName.prefix !== '') {
     return join(
       project.paths.modulesFolder,
       resourceName.prefix,
       resourceName.type,
-      resourceName.identifier + '.json',
+      resourceName.identifier + extension,
     );
   }
   throw new Error('resourceName does not contain prefix');

package/src/utils/user-preferences.ts

@@ -9,10 +9,11 @@
     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 { dirname } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { formatJson } from './json.js';
-import { dirname } from 'path';
+import { getChildLogger } from '../utils/log-utils.js';
 
 export interface UserPreferencesObject {
   editCommand: {
@@ -95,24 +96,41 @@ export class UserPreferences {
   };
 
   constructor(private prefsFilePath: string) {
-    if (!existsSync(this.prefsFilePath)) {
-      // Create the preferences directory based on prefsFilePath dirname
-      const prefsDir = dirname(this.prefsFilePath);
+    // Create the preferences directory based on prefsFilePath dirname
+    const prefsDir = dirname(this.prefsFilePath);
 
-      try {
-        if (!existsSync(prefsDir)) {
-          mkdirSync(prefsDir, { recursive: true });
+    try {
+      // Ensure directory exists first
+      if (!existsSync(prefsDir)) {
+        mkdirSync(prefsDir, { recursive: true });
+      }
+
+      // Try to create file exclusively using 'wx' flag
+      // This will fail atomically if file already exists
+      writeFileSync(this.prefsFilePath, formatJson(UserPreferences.defaults), {
+        flag: 'wx',
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        const err = error as NodeJS.ErrnoException;
+        // If file already exists (EEXIST), that's fine - we'll use the existing file
+        if (err?.code !== 'EEXIST') {
+          throw new Error(
+            `Error creating preferences file '${this.prefsFilePath}': ${error}`,
+          );
+        } else {
+          this.logger.warn('Preferences file already exists');
         }
-        // File does not exist, create it with default content
-        writeFileSync(this.prefsFilePath, formatJson(UserPreferences.defaults));
-      } catch (error) {
-        throw new Error(
-          `Error creating preferences file '${this.prefsFilePath}': ${error}`,
-        );
       }
     }
   }
 
+  private get logger() {
+    return getChildLogger({
+      module: 'userPreferences',
+    });
+  }
+
   public getPreferences(): UserPreferencesObject {
     // Read and parse the preferences file
     try {

package/src/utils/validate.ts

@@ -13,11 +13,13 @@ import { type Schema, Validator } from 'jsonschema';
 import { DHValidationError, SchemaNotFound } from '../exceptions/index.js';
 import { schemas } from '@cyberismo/assets';
 
+let validator: Validator | null = null;
+
 /**
  * Validates a JSON object against a schema
  * @param object The object to validate
  * @param schemaId The id of the schema to validate against
- * @param validator An optional validator to use. If validator is not provided or does not contain any schemas, project schemas will be used
+ * @param schema The schema to validate against. If schema is not provided, the schema with the given id will be used
  * @returns The object casted to the type T if it is valid
  * @throws DHValidationError if the object is not valid
  * @throws SchemaNotFound if the schema with the given id is not found
@@ -27,11 +29,9 @@ export function validateJson<T>(
   options: {
     schemaId?: string;
     schema?: Schema;
-    validator?: Validator;
   },
 ): T {
   const { schemaId, schema } = options;
-  let validator = options.validator;
 
   if (!schema && !schemaId) {
     throw new Error('Must either specify schema or schemaId');