@unrdf/kgn 5.0.1 → 26.4.2

package/src/filters/array.js

@@ -71,13 +71,21 @@ export const sort = (arr, key = null) => {
 };
 
 /**
- * Reverse array
- * @param {any} arr - Input array
- * @returns {Array} Reversed array
+ * Reverse array or string
+ * @param {any} value - Input array or string
+ * @returns {Array|string} Reversed array or string
  */
-export const reverse = (arr) => {
-  if (!Array.isArray(arr)) return arr;
-  return [...arr].reverse();
+export const reverse = (value) => {
+  // Handle strings
+  if (typeof value === 'string') {
+    return value.split('').reverse().join('');
+  }
+  // Handle arrays
+  if (Array.isArray(value)) {
+    return [...value].reverse();
+  }
+  // Return other types unchanged
+  return value;
 };
 
 /**

package/src/filters/index.js

@@ -29,6 +29,16 @@ export function createCustomFilters(options = {}) {
     ...dataFilters,
     ...rdfFilters,
 
+    // Smart reverse filter that works with both strings and arrays
+    reverse: input => {
+      if (Array.isArray(input)) {
+        return [...input].reverse();
+      }
+      // Treat as string
+      if (input === null || input === undefined) return '';
+      return String(input).split('').reverse().join('');
+    },
+
     // Enhanced deterministic filters that override or augment the base filters
 
     // Deterministic date/time formatting
@@ -61,9 +71,10 @@ export function createCustomFilters(options = {}) {
       const d = new Date(date);
       if (isNaN(d.getTime())) return '';
 
-      const hours = d.getHours().toString().padStart(2, '0');
-      const minutes = d.getMinutes().toString().padStart(2, '0');
-      const seconds = d.getSeconds().toString().padStart(2, '0');
+      // Use UTC time to match test expectations
+      const hours = d.getUTCHours().toString().padStart(2, '0');
+      const minutes = d.getUTCMinutes().toString().padStart(2, '0');
+      const seconds = d.getUTCSeconds().toString().padStart(2, '0');
 
       switch (format) {
         case 'HH:mm:ss':
@@ -75,6 +86,48 @@ export function createCustomFilters(options = {}) {
       }
     },
 
+    // Date arithmetic - add days to a date
+    dateAdd: (date, amount, unit = 'day') => {
+      const d = new Date(date);
+      if (isNaN(d.getTime())) return '';
+
+      switch (unit.toLowerCase()) {
+        case 'day':
+        case 'days':
+          d.setUTCDate(d.getUTCDate() + amount);
+          break;
+        case 'month':
+        case 'months':
+          d.setUTCMonth(d.getUTCMonth() + amount);
+          break;
+        case 'year':
+        case 'years':
+          d.setUTCFullYear(d.getUTCFullYear() + amount);
+          break;
+        case 'hour':
+        case 'hours':
+          d.setUTCHours(d.getUTCHours() + amount);
+          break;
+        case 'minute':
+        case 'minutes':
+          d.setUTCMinutes(d.getUTCMinutes() + amount);
+          break;
+        case 'second':
+        case 'seconds':
+          d.setUTCSeconds(d.getUTCSeconds() + amount);
+          break;
+        default:
+          return '';
+      }
+
+      return d.toISOString();
+    },
+
+    // Date arithmetic - subtract days from a date
+    dateSub: (date, amount, unit = 'day') => {
+      return allFilters.dateAdd(date, -amount, unit);
+    },
+
     // Deterministic timestamp
     timestamp: () => {
       if (deterministicMode) {
@@ -93,7 +146,7 @@ export function createCustomFilters(options = {}) {
     },
 
     // File and path utilities
-    filename: (filePath) => {
+    filename: filePath => {
       if (!filePath) return '';
       return filePath.split('/').pop().split('\\').pop();
     },
@@ -107,7 +160,7 @@ export function createCustomFilters(options = {}) {
       return dotIndex > 0 ? name.slice(0, dotIndex) : name;
     },
 
-    dirname: (filePath) => {
+    dirname: filePath => {
       if (!filePath) return '';
       const parts = filePath.split('/');
       if (parts.length === 1) {
@@ -118,20 +171,104 @@ export function createCustomFilters(options = {}) {
       return parts.slice(0, -1).join('/');
     },
 
+    // Date arithmetic filters
+    dateAdd: (dateStr, amount, unit = 'day') => {
+      const date = new Date(dateStr);
+      switch (unit) {
+        case 'day':
+          date.setDate(date.getDate() + amount);
+          break;
+        case 'month':
+          date.setMonth(date.getMonth() + amount);
+          break;
+        case 'year':
+          date.setFullYear(date.getFullYear() + amount);
+          break;
+        default:
+          throw new Error(`Unknown unit: ${unit}`);
+      }
+      return date.toISOString();
+    },
+
+    dateSub: (dateStr, amount, unit = 'day') => {
+      const date = new Date(dateStr);
+      switch (unit) {
+        case 'day':
+          date.setDate(date.getDate() - amount);
+          break;
+        case 'month':
+          date.setMonth(date.getMonth() - amount);
+          break;
+        case 'year':
+          date.setFullYear(date.getFullYear() - amount);
+          break;
+        default:
+          throw new Error(`Unknown unit: ${unit}`);
+      }
+      return date.toISOString();
+    },
+
+    // Path utility filters
+    resolve: (base, relative) => {
+      // Simple path resolution (normalize and join)
+      const baseParts = base.split('/').filter(p => p);
+      const relativeParts = relative.split('/').filter(p => p);
+
+      for (const part of relativeParts) {
+        if (part === '..') {
+          baseParts.pop();
+        } else if (part !== '.') {
+          baseParts.push(part);
+        }
+      }
+
+      return '/' + baseParts.join('/');
+    },
+
+    relative: (from, to) => {
+      // Simple relative path calculation
+      const fromParts = from.split('/').filter(p => p);
+      const toParts = to.split('/').filter(p => p);
+
+      // Find common base
+      let i = 0;
+      while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+        i++;
+      }
+
+      // Go up from 'from' directory
+      const upCount = fromParts.length - i;
+      const upParts = Array(upCount).fill('..');
+
+      // Then append remaining 'to' parts
+      const remainingParts = toParts.slice(i);
+
+      return [...upParts, ...remainingParts].join('/');
+    },
+
     // Code generation helpers
     comment: (text, style = '//') => {
       if (!text) return '';
       switch (style) {
         case '//':
-          return text.split('\n').map(line => `// ${line}`).join('\n');
+          return text
+            .split('\n')
+            .map(line => `// ${line}`)
+            .join('\n');
         case '#':
-          return text.split('\n').map(line => `# ${line}`).join('\n');
+          return text
+            .split('\n')
+            .map(line => `# ${line}`)
+            .join('\n');
         case '/*':
           return `/* ${text} */`;
         case '<!--':
           return `<!-- ${text} -->`;
         default:
-          return text.split('\n').map(line => `${style} ${line}`).join('\n');
+          return text
+            .split('\n')
+            .map(line => `${style} ${line}`)
+            .join('\n');
       }
     },
 
@@ -146,21 +283,27 @@ export function createCustomFilters(options = {}) {
     // Determinism blockers - these will throw in deterministic mode
     now: () => {
       if (deterministicMode) {
-        throw new Error('Filter "now" is not allowed in deterministic mode. Use "timestamp" instead.');
+        throw new Error(
+          'Filter "now" is not allowed in deterministic mode. Use "timestamp" instead.'
+        );
       }
       return new Date().toISOString();
     },
 
     random: () => {
       if (deterministicMode) {
-        throw new Error('Filter "random" is not allowed in deterministic mode. Use "hash" for consistent randomness.');
+        throw new Error(
+          'Filter "random" is not allowed in deterministic mode. Use "hash" for consistent randomness.'
+        );
       }
       return Math.random();
     },
 
     uuid: () => {
       if (deterministicMode) {
-        throw new Error('Filter "uuid" is not allowed in deterministic mode. Use "hash" for consistent IDs.');
+        throw new Error(
+          'Filter "uuid" is not allowed in deterministic mode. Use "hash" for consistent IDs.'
+        );
       }
       return crypto.randomUUID();
     },
@@ -175,7 +318,9 @@ export function createCustomFilters(options = {}) {
 
       // Get headers from first object
       if (headers && data.length > 0 && typeof data[0] === 'object') {
-        const headerRow = Object.keys(data[0]).map(h => `${quote}${h}${quote}`).join(delimiter);
+        const headerRow = Object.keys(data[0])
+          .map(h => `${quote}${h}${quote}`)
+          .join(delimiter);
         lines.push(headerRow);
       }
 
@@ -214,9 +359,12 @@ export function createCustomFilters(options = {}) {
         // Separator row
         const separators = headers.map(() => {
           switch (align) {
-            case 'center': return ':---:';
-            case 'right': return '---:';
-            default: return '---';
+            case 'center':
+              return ':---:';
+            case 'right':
+              return '---:';
+            default:
+              return '---';
           }
         });
         lines.push('| ' + separators.join(' | ') + ' |');
@@ -229,7 +377,7 @@ export function createCustomFilters(options = {}) {
       }
 
       return lines.join('\n');
-    }
+    },
   };
 
   return allFilters;
@@ -267,4 +415,4 @@ export { textFilters, arrayFilters, dataFilters, rdfFilters };
 /**
  * Export default function
  */
-export default createCustomFilters;
+export default createCustomFilters;

package/src/filters/rdf.js

@@ -79,7 +79,7 @@ export const contract = (uri, prefixes = {}) => {
  * @param {any} dataset - Mock dataset (ignored in stub)
  * @returns {Array} Mock query results
  */
-export const sparql = async (query, dataset = null) => {
+export const sparql = async (query, _dataset = null) => {
   if (!query || typeof query !== 'string') return [];
 
   // Return mock results for known queries
@@ -227,7 +227,7 @@ export const rdfDatatype = (value, datatype = 'string') => {
  * @param {any} shape - SHACL shape
  * @returns {Object} Mock validation result
  */
-export const shaclValidate = (data, shape) => {
+export const shaclValidate = (_data, _shape) => {
   return {
     conforms: true,
     results: [],
@@ -241,7 +241,7 @@ export const shaclValidate = (data, shape) => {
  * @param {string} reasoner - Reasoner type
  * @returns {any} Original graph (no inference applied)
  */
-export const infer = (graph, reasoner = 'rdfs') => {
+export const infer = (graph, _reasoner = 'rdfs') => {
   return graph; // No-op for stub
 };
 

package/src/{index.js → index.mjs}

@@ -11,6 +11,13 @@
  * - Marker-based targeting and rollback capabilities (NEW)
  */
 
+// Import classes/functions for local use
+import { TemplateEngine, EnhancedTemplateEngine } from './engine/template-engine.js';
+import { TemplateInheritanceEngine } from './inheritance/index.js';
+import { enhanceKgenWithInjection } from './injection/integration.js';
+import { initializeInjection } from './injection/api.js';
+
+// Re-export for external use
 export { TemplateEngine, EnhancedTemplateEngine } from './engine/template-engine.js';
 export { TemplateInheritanceEngine } from './inheritance/index.js';
 export { createCustomFilters } from './filters/index.js';
@@ -75,6 +82,9 @@ export {
 } from './injection/constants.js';
 
 // Enhanced engine factory with inheritance and injection support
+/**
+ *
+ */
 export function createEngine(options = {}) {
   // Use EnhancedTemplateEngine by default for inheritance support
   const engineClass = options.useBasicEngine ? TemplateEngine : EnhancedTemplateEngine;
@@ -89,11 +99,17 @@ export function createEngine(options = {}) {
 }
 
 // Inheritance-specific engine factory
+/**
+ *
+ */
 export function createInheritanceEngine(options = {}) {
   return new TemplateInheritanceEngine(options);
 }
 
 // Enhanced template engine factory (inheritance + all features)
+/**
+ *
+ */
 export function createEnhancedEngine(options = {}) {
   return new EnhancedTemplateEngine({
     enableInheritance: true,
@@ -104,6 +120,36 @@ export function createEnhancedEngine(options = {}) {
 }
 
 // Injection-specific engine factory
+/**
+ *
+ */
 export function createInjectionEngine(injectionConfig = {}) {
   return initializeInjection(injectionConfig);
+}
+
+// RDF TEMPLATE SYSTEM EXPORTS (NEW)
+// RDF-aware template engine with @unrdf/core integration
+export {
+  RdfTemplateEngine,
+  createRdfTemplateEngine,
+  renderRdfTemplate,
+  RdfTemplateEngineConfigSchema,
+  RdfRenderContextSchema,
+  SparqlTemplateSchema,
+} from './rdf/index.js';
+
+// RDF template filters
+export {
+  rdfTemplateFilters,
+  toTurtle,
+  toSparql,
+  rdfPrefix,
+  blankNode,
+  literal,
+} from './rdf/filters.js';
+
+// RDF engine factory
+export async function createRdfEngine(config = {}) {
+  const { RdfTemplateEngine } = await import('./rdf/index.js');
+  return new RdfTemplateEngine(config);
 }

package/src/index.test.mjs

@@ -0,0 +1,40 @@
+/**
+ * @file KGN package basic tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createEngine,
+  createInheritanceEngine,
+  createEnhancedEngine,
+  TemplateEngine,
+  EnhancedTemplateEngine,
+} from './index.mjs';
+
+describe('@unrdf/kgn', () => {
+  it('should export main engine classes', () => {
+    expect(TemplateEngine).toBeDefined();
+    expect(EnhancedTemplateEngine).toBeDefined();
+  });
+
+  it('should create basic engine', () => {
+    const engine = createEngine({ useBasicEngine: true });
+    expect(engine).toBeDefined();
+    expect(engine).toBeInstanceOf(TemplateEngine);
+  });
+
+  it('should create enhanced engine by default', () => {
+    const engine = createEngine();
+    expect(engine).toBeDefined();
+  });
+
+  it('should create inheritance engine', () => {
+    const engine = createInheritanceEngine();
+    expect(engine).toBeDefined();
+  });
+
+  it('should create enhanced engine with options', () => {
+    const engine = createEnhancedEngine({ enableCache: false });
+    expect(engine).toBeDefined();
+  });
+});

package/src/inheritance/index.js

@@ -2,12 +2,21 @@
  * Template Inheritance System - Placeholder for future implementation
  */
 
+/**
+ *
+ */
 export class TemplateInheritanceEngine {
+  /**
+   *
+   */
   constructor(options = {}) {
     this.options = options;
   }
 
-  async processTemplate(templatePath, context = {}) {
+  /**
+   *
+   */
+  async processTemplate(templatePath, _context = {}) {
     // Basic implementation for build compatibility
     return {
       templatePath,
@@ -18,6 +27,9 @@ export class TemplateInheritanceEngine {
     };
   }
 
+  /**
+   *
+   */
   getStats() {
     return {
       templatesProcessed: 0,
@@ -28,10 +40,16 @@ export class TemplateInheritanceEngine {
     };
   }
 
+  /**
+   *
+   */
   async clearCache() {
     // No-op for now
   }
 
+  /**
+   *
+   */
   getConfig() {
     return this.options;
   }

package/src/injection/atomic-writer.js

@@ -10,9 +10,15 @@ import { join, dirname, basename, extname } from 'path';
 import { createHash } from 'crypto';
 import { pipeline } from 'stream/promises';
 
-import { ERROR_CODES, CHECKSUM_ALGORITHMS, LOCK_CONFIG } from './constants.js';
+import { ERROR_CODES as _ERROR_CODES, CHECKSUM_ALGORITHMS, LOCK_CONFIG } from './constants.js';
 
+/**
+ *
+ */
 export class AtomicWriter {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = config;
     this.activeLocks = new Map();
@@ -118,6 +124,9 @@ export class AtomicWriter {
    * Private Methods
    */
 
+  /**
+   *
+   */
   async _acquireLock(filePath) {
     const lockId = `${filePath}-${Date.now()}-${Math.random()}`;
     const startTime = Date.now();
@@ -154,6 +163,9 @@ export class AtomicWriter {
     throw new Error(`Failed to acquire lock for ${filePath} within timeout`);
   }
 
+  /**
+   *
+   */
   async _releaseLock(lockId) {
     const lockFile = this.activeLocks.get(lockId);
     if (lockFile) {
@@ -166,6 +178,9 @@ export class AtomicWriter {
     }
   }
 
+  /**
+   *
+   */
   async _createBackup(filePath, operationId) {
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const ext = extname(filePath);
@@ -182,6 +197,9 @@ export class AtomicWriter {
     return backupPath;
   }
 
+  /**
+   *
+   */
   async _createTempFile(filePath) {
     const dir = dirname(filePath);
     const base = basename(filePath);
@@ -189,6 +207,9 @@ export class AtomicWriter {
     return join(dir, tempName);
   }
 
+  /**
+   *
+   */
   async _calculateChecksum(filePath, algorithm = CHECKSUM_ALGORITHMS.SHA256) {
     const hash = createHash(algorithm);
     const stream = createReadStream(filePath);

package/src/injection/idempotency-manager.js

@@ -10,7 +10,13 @@ import { createHash } from 'crypto';
 
 import { SKIP_IF_LOGIC, CHECKSUM_ALGORITHMS } from './constants.js';
 
+/**
+ *
+ */
 export class IdempotencyManager {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = config;
     this.contentCache = new Map();
@@ -103,6 +109,9 @@ export class IdempotencyManager {
    * Private Methods
    */
 
+  /**
+   *
+   */
   async _evaluateSingleCondition(condition, target, content, variables) {
     // Built-in conditions
     if (condition === 'file_exists') {
@@ -155,6 +164,9 @@ export class IdempotencyManager {
     };
   }
 
+  /**
+   *
+   */
   async _evaluateMultipleConditions(conditions, target, content, variables) {
     const logic = target.skipIfLogic || SKIP_IF_LOGIC.OR;
     const results = [];
@@ -181,6 +193,9 @@ export class IdempotencyManager {
     }
   }
 
+  /**
+   *
+   */
   async _evaluateObjectCondition(conditionObj, target, content, variables) {
     // Complex object-based conditions
     const { pattern, exists, custom, hash } = conditionObj;
@@ -218,12 +233,18 @@ export class IdempotencyManager {
     return { skip: false, reason: 'Invalid object condition' };
   }
 
+  /**
+   *
+   */
   _interpolateVariables(template, variables) {
     return template.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
       return variables[variable] || match;
     });
   }
 
+  /**
+   *
+   */
   async _getFileContent(filePath) {
     const cacheKey = filePath;
 
@@ -244,6 +265,9 @@ export class IdempotencyManager {
     }
   }
 
+  /**
+   *
+   */
   async _fileExists(filePath) {
     try {
       await fs.access(filePath);
@@ -253,6 +277,9 @@ export class IdempotencyManager {
     }
   }
 
+  /**
+   *
+   */
   async _getFileSize(filePath) {
     try {
       const stats = await fs.stat(filePath);
@@ -265,6 +292,9 @@ export class IdempotencyManager {
     }
   }
 
+  /**
+   *
+   */
   async _getLineCount(filePath) {
     try {
       const content = await this._getFileContent(filePath);
@@ -274,6 +304,9 @@ export class IdempotencyManager {
     }
   }
 
+  /**
+   *
+   */
   async _getExistingContentHash(target) {
     try {
       const content = await this._getFileContent(target.resolvedPath);