@unrdf/kgn 5.0.1 → 26.4.2

package/src/injection/injection-engine.js

@@ -6,7 +6,7 @@
  */
 
 import { promises as fs } from 'fs';
-import { join, dirname, resolve, relative } from 'path';
+import { join as _join, dirname, resolve as _resolve, relative as _relative } from 'path';
 import { createHash } from 'crypto';
 
 import { TargetResolver } from './target-resolver.js';
@@ -23,7 +23,13 @@ import {
   OPERATION_METADATA
 } from './constants.js';
 
+/**
+ *
+ */
 export class InjectionEngine {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
 
@@ -127,6 +133,9 @@ export class InjectionEngine {
    * Private Methods
    */
 
+  /**
+   *
+   */
   _generateOperationId(templateConfig, content) {
     const hash = createHash('sha256');
     hash.update(JSON.stringify(templateConfig, null, 0));
@@ -135,6 +144,9 @@ export class InjectionEngine {
     return `injection-${hash.digest('hex').substring(0, 16)}`;
   }
 
+  /**
+   *
+   */
   async _beginOperation(operationId, templateConfig) {
     this.activeOperations.set(operationId, {
       id: operationId,
@@ -146,6 +158,9 @@ export class InjectionEngine {
     });
   }
 
+  /**
+   *
+   */
   async _validateAllTargets(targets, throwOnError = true) {
     const results = [];
 
@@ -166,6 +181,9 @@ export class InjectionEngine {
     return results;
   }
 
+  /**
+   *
+   */
   async _filterIdempotentTargets(targets, content, variables) {
     const filtered = [];
 
@@ -184,6 +202,9 @@ export class InjectionEngine {
     return filtered;
   }
 
+  /**
+   *
+   */
   async _checkIdempotency(targets, content, variables) {
     const results = [];
 
@@ -197,6 +218,9 @@ export class InjectionEngine {
     return results;
   }
 
+  /**
+   *
+   */
   async _executeAtomicInjection(targets, content, variables, operationId) {
     const operation = this.activeOperations.get(operationId);
     operation.phase = 'executing';
@@ -211,6 +235,9 @@ export class InjectionEngine {
     return await this._executeTransaction(targets, content, variables, operationId);
   }
 
+  /**
+   *
+   */
   async _injectSingleTarget(target, content, variables, operationId) {
     // Read current file content
     const currentContent = await this._readTargetFile(target);
@@ -247,6 +274,9 @@ export class InjectionEngine {
     };
   }
 
+  /**
+   *
+   */
   async _executeTransaction(targets, content, variables, operationId) {
     const transaction = await this.atomicWriter.beginTransaction(operationId);
 
@@ -290,6 +320,9 @@ export class InjectionEngine {
     }
   }
 
+  /**
+   *
+   */
   async _readTargetFile(target) {
     if (target.mode === INJECTION_MODES.CREATE && target.createIfMissing) {
       try {
@@ -309,6 +342,9 @@ export class InjectionEngine {
     return await fs.readFile(target.resolvedPath, 'utf8');
   }
 
+  /**
+   *
+   */
   async _commitOperation(operationId, results) {
     const operation = this.activeOperations.get(operationId);
     operation.phase = 'committed';
@@ -329,6 +365,9 @@ export class InjectionEngine {
     this.activeOperations.delete(operationId);
   }
 
+  /**
+   *
+   */
   async _rollbackOperation(operationId, error) {
     const operation = this.activeOperations.get(operationId);
 
@@ -353,6 +392,9 @@ export class InjectionEngine {
     }
   }
 
+  /**
+   *
+   */
   _wrapError(error, operationId) {
     return new InjectionError(
       error.message,
@@ -367,6 +409,9 @@ export class InjectionEngine {
  * Custom error class for injection operations
  */
 export class InjectionError extends Error {
+  /**
+   *
+   */
   constructor(message, code, operationId, originalError = null) {
     super(message);
     this.name = 'InjectionError';

package/src/injection/integration.js

@@ -5,7 +5,7 @@
  * Provides seamless injection support for template processing.
  */
 
-import { inject, dryRun, processTemplate, initializeInjection } from './api.js';
+import { inject, dryRun, processTemplate as _processTemplate, initializeInjection } from './api.js';
 import { DEFAULT_CONFIG, INJECTION_MODES } from './constants.js';
 
 /**
@@ -147,7 +147,7 @@ async function processInjectionTemplate(template, data, options, injectionEngine
 /**
  * Render template content (without injection)
  */
-async function renderTemplateContent(content, data, options) {
+async function renderTemplateContent(content, data, _options) {
   // Simple variable interpolation - in production use proper template engine
   return content.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
     return data[variable] || match;
@@ -219,7 +219,7 @@ function parseFrontmatter(text) {
 /**
  * Create injection-aware template loader
  */
-export function createInjectionTemplateLoader(baseLoader, injectionConfig = {}) {
+export function createInjectionTemplateLoader(baseLoader, _injectionConfig = {}) {
   return {
     ...baseLoader,
 

package/src/injection/modes/index.js

@@ -7,7 +7,13 @@
 
 import { INJECTION_MODES, LINE_ENDINGS } from '../constants.js';
 
+/**
+ *
+ */
 export class InjectionModes {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = config;
   }
@@ -241,6 +247,9 @@ export class InjectionModes {
    * Helper Methods
    */
 
+  /**
+   *
+   */
   _normalizeContent(content) {
     if (!content) return '';
 
@@ -253,6 +262,9 @@ export class InjectionModes {
     return content;
   }
 
+  /**
+   *
+   */
   _normalizeInjectionContent(content, variables) {
     // Variable interpolation
     let result = content.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
@@ -267,12 +279,18 @@ export class InjectionModes {
     return result;
   }
 
+  /**
+   *
+   */
   _detectLineEnding(content) {
     if (content.includes('\r\n')) return LINE_ENDINGS.CRLF;
     if (content.includes('\r')) return LINE_ENDINGS.CR;
     return LINE_ENDINGS.LF;
   }
 
+  /**
+   *
+   */
   _findTargetLine(lines, pattern, target) {
     if (target.regex) {
       const flags = target.regexFlags || 'gm';
@@ -284,15 +302,24 @@ export class InjectionModes {
     return lines.findIndex(line => line.includes(pattern));
   }
 
+  /**
+   *
+   */
   _getLineIndentation(line) {
     const match = line.match(/^(\s*)/);
     return match ? match[1] : '';
   }
 
+  /**
+   *
+   */
   _looksLikeImports(content) {
     return /^import\s+.*from\s+['"][^'"]+['"];?\s*$/m.test(content);
   }
 
+  /**
+   *
+   */
   _sortImports(content) {
     const lineEnding = this._detectLineEnding(content);
     const lines = content.split(lineEnding);
@@ -334,6 +361,9 @@ export class InjectionModes {
     return content;
   }
 
+  /**
+   *
+   */
   _extractImportSource(importLine) {
     const match = importLine.match(/from\s+['"]([^'"]+)['"]/);
     return match ? match[1] : '';

package/src/injection/rollback-manager.js

@@ -6,12 +6,18 @@
  */
 
 import { promises as fs } from 'fs';
-import { join, dirname, basename } from 'path';
+import { join as _join, dirname, basename as _basename } from 'path';
 import { createHash } from 'crypto';
 
-import { ERROR_CODES, CHECKSUM_ALGORITHMS } from './constants.js';
+import { ERROR_CODES as _ERROR_CODES, CHECKSUM_ALGORITHMS } from './constants.js';
 
+/**
+ *
+ */
 export class RollbackManager {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = config;
     this.rollbackHistory = new Map();
@@ -215,6 +221,9 @@ export class RollbackManager {
    * Private Methods
    */
 
+  /**
+   *
+   */
   async _restoreFromBackup(targetPath, backupPath) {
     // Verify backup exists
     try {
@@ -254,6 +263,9 @@ export class RollbackManager {
     }
   }
 
+  /**
+   *
+   */
   async _cleanupTemporaryFiles(operationData) {
     // Clean up any temporary files created during operation
     if (operationData.tempFiles) {
@@ -267,6 +279,9 @@ export class RollbackManager {
     }
   }
 
+  /**
+   *
+   */
   async _releaseLocks(operationData) {
     // Release any locks held by the operation
     if (operationData.locks) {
@@ -280,6 +295,9 @@ export class RollbackManager {
     }
   }
 
+  /**
+   *
+   */
   _getOperationHistory(operationId) {
     // This would normally come from the injection engine's history
     // For now, return a mock structure
@@ -291,10 +309,16 @@ export class RollbackManager {
     };
   }
 
+  /**
+   *
+   */
   _findOperationBackups(operationId) {
     return this.operationBackups.get(operationId) || [];
   }
 
+  /**
+   *
+   */
   async _calculateFileChecksum(filePath, algorithm = CHECKSUM_ALGORITHMS.SHA256) {
     const content = await fs.readFile(filePath);
     const hash = createHash(algorithm);

package/src/injection/target-resolver.js

@@ -6,10 +6,10 @@
  */
 
 import { promises as fs } from 'fs';
-import { resolve, join, relative, dirname, basename } from 'path';
+import { resolve, join as _join, relative, dirname as _dirname, basename } from 'path';
 // Simple glob implementation for basic pattern matching
 // In production, use a proper glob library like 'glob' or 'fast-glob'
-function simpleGlob(pattern, options = {}) {
+function simpleGlob(pattern, _options = {}) {
   // Very basic glob implementation for demo purposes
   return Promise.resolve([]);
 }
@@ -17,7 +17,13 @@ const glob = simpleGlob;
 
 import { ERROR_CODES, DEFAULT_CONFIG } from './constants.js';
 
+/**
+ *
+ */
 export class TargetResolver {
+  /**
+   *
+   */
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.projectRoot = config.projectRoot || process.cwd();
@@ -57,6 +63,9 @@ export class TargetResolver {
    * Private Methods
    */
 
+  /**
+   *
+   */
   async _resolveSingleTarget(targetConfig, variables) {
     let targetPath = targetConfig.to;
 
@@ -97,7 +106,10 @@ export class TargetResolver {
     return target;
   }
 
-  async _resolveGlobTargets(globPattern, targetConfig, variables) {
+  /**
+   *
+   */
+  async _resolveGlobTargets(globPattern, targetConfig, _variables) {
     // Use glob to find matching files
     const matches = await glob(globPattern, {
       cwd: this.projectRoot,
@@ -143,6 +155,9 @@ export class TargetResolver {
     return targets;
   }
 
+  /**
+   *
+   */
   _interpolateVariables(template, variables) {
     return template.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
       const value = variables[variable];
@@ -153,10 +168,16 @@ export class TargetResolver {
     });
   }
 
+  /**
+   *
+   */
   _isGlobPattern(path) {
     return /[*?{}\[\]]/.test(path);
   }
 
+  /**
+   *
+   */
   _resolvePath(targetPath) {
     // Convert to absolute path
     if (!targetPath.startsWith('/')) {
@@ -165,6 +186,9 @@ export class TargetResolver {
     return resolve(targetPath);
   }
 
+  /**
+   *
+   */
   _validatePath(resolvedPath) {
     // Security: Prevent path traversal
     if (this.config.preventPathTraversal) {
@@ -183,6 +207,9 @@ export class TargetResolver {
     }
   }
 
+  /**
+   *
+   */
   _applyExclusions(matches, exclusions) {
     const exclusionPatterns = Array.isArray(exclusions) ? exclusions : [exclusions];
 
@@ -201,6 +228,9 @@ export class TargetResolver {
     });
   }
 
+  /**
+   *
+   */
   _matchesGlob(path, pattern) {
     // Simple glob matching - in production, use minimatch or similar
     const regex = pattern
@@ -211,6 +241,9 @@ export class TargetResolver {
     return new RegExp(`^${regex}$`).test(path);
   }
 
+  /**
+   *
+   */
   async _evaluateTargetCondition(target, condition) {
     try {
       // Check if file exists first
@@ -254,6 +287,9 @@ export class TargetResolver {
     }
   }
 
+  /**
+   *
+   */
   async _evaluateComplexCondition(target, content, condition) {
     const { pattern, size, lines, encoding } = condition;
 
@@ -287,6 +323,9 @@ export class TargetResolver {
     return true;
   }
 
+  /**
+   *
+   */
   async _fileExists(filePath) {
     try {
       await fs.access(filePath);
@@ -296,12 +335,18 @@ export class TargetResolver {
     }
   }
 
+  /**
+   *
+   */
   _getFileExtension(filePath) {
     const name = basename(filePath);
     const dotIndex = name.lastIndexOf('.');
     return dotIndex === -1 ? '' : name.slice(dotIndex);
   }
 
+  /**
+   *
+   */
   _detectEncoding(content) {
     // Simple encoding detection - in production use a proper library
     try {

package/src/injection/tests/injection-engine.test.js

@@ -5,13 +5,13 @@
  * atomic operations, idempotency, and error handling.
  */
 
-import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+import { describe, test, expect, beforeEach, afterEach, vi as _vi } from 'vitest';
 import { promises as fs } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname as _dirname } from 'path';
 import { tmpdir } from 'os';
 
 import { InjectionEngine } from '../injection-engine.js';
-import { INJECTION_MODES, ERROR_CODES } from '../constants.js';
+import { INJECTION_MODES, ERROR_CODES as _ERROR_CODES } from '../constants.js';
 
 describe('InjectionEngine', () => {
   let tempDir;

package/src/injection/tests/integration.test.js

@@ -232,8 +232,9 @@ export default router;`;
       };
 
       const content = 'test content';
+      const variables = {};
 
-      await expect(inject(templateConfig, content, variables = {}))
+      await expect(inject(templateConfig, content, variables))
         .rejects.toThrow(/Unknown injection mode/);
     });
 

package/src/injection/tests/run-tests.js

@@ -16,6 +16,9 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const rootDir = join(__dirname, '../../..');
 
+/**
+ *
+ */
 async function runTests() {
   console.log('🚀 Starting KGEN Injection System Tests');
   console.log('=' .repeat(50));