@bernierllc/nevar-loop-detector 0.0.1 → 0.1.0

package/README.md

@@ -1,45 +1,71 @@
 # @bernierllc/nevar-loop-detector
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Static and runtime loop detection for the Nevar rules engine. Analyzes rule sets for potential evaluation cycles at registration time and tracks runtime emit chains.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+## Installation
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+```bash
+npm install @bernierllc/nevar-loop-detector
+```
 
-## Purpose
+## Usage
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@bernierllc/nevar-loop-detector`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```typescript
+import { LoopDetector, ChainTracker } from '@bernierllc/nevar-loop-detector';
+import type { Rule } from '@bernierllc/nevar-types';
 
-## What is OIDC Trusted Publishing?
+// Static analysis: detect cycles in rule definitions
+const detector = new LoopDetector();
+const analysis = detector.analyze(rules);
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+if (analysis.hasLoops) {
+  for (const loop of analysis.loops) {
+    console.log('Cycle:', loop.chain.join(' -> '));
+    console.log('All rules opted in:', loop.allOptedIn);
+    console.log('Rule IDs:', loop.ruleIds);
+  }
+}
 
-## Setup Instructions
+// Runtime tracking: detect cycles during emit chain execution
+const tracker = new ChainTracker();
 
-To properly configure OIDC trusted publishing for this package:
+const isCycle = tracker.enter('order.created', 'ctx-123');
+if (isCycle) {
+  // This trigger+context pair was already seen in this chain
+}
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+console.log(tracker.getDepth()); // current chain depth
+tracker.reset(); // clear for next chain
+```
 
-## DO NOT USE THIS PACKAGE
+## API
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+### `LoopDetector`
 
-## More Information
+Static loop analysis for rule sets. Builds a graph of trigger-to-deferred-trigger relationships and detects cycles using depth-first search.
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+- `analyze(rules: Rule[])` - Returns a `LoopAnalysis` with `hasLoops: boolean` and `loops: DetectedLoop[]`. Each `DetectedLoop` contains the `chain` of trigger keys forming the cycle, `ruleIds` involved, and whether `allOptedIn` to looping.
 
----
+### `ChainTracker`
 
-**Maintained for OIDC setup purposes only**
+Runtime cycle detection for emit chains. Tracks `(triggerKey, contextId)` pairs within a single emit chain.
+
+- `enter(triggerKey, contextId)` - Records entry into a trigger evaluation. Returns `true` if a cycle is detected (pair already seen), `false` on first occurrence
+- `getDepth()` - Returns the current chain depth
+- `reset()` - Clears all recorded entries and resets depth
+
+### `LoopDetectorError`
+
+Error class for loop detection failures. Extends `Error` with `code` and `context` properties.
+
+## Integration Documentation
+
+### Logger Integration
+This package does not integrate with `@bernierllc/logger`. As a core package, logger integration is optional and not included by default. Consumers should handle logging at the service layer.
+
+### NeverHub Integration
+This package does not integrate with `@bernierllc/neverhub-adapter`. As a core package, NeverHub integration is not applicable. NeverHub registration should be handled by service-layer packages that compose this package.
+
+## License
+
+Copyright (c) 2025 Bernier LLC. All rights reserved.

package/dist/chain-tracker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Runtime cycle detection for emit chains.
+ *
+ * Tracks (triggerKey, contextId) pairs within a single emit chain
+ * to detect runtime loops.
+ */
+export declare class ChainTracker {
+    private seen;
+    private depth;
+    /**
+     * Record entry into a trigger evaluation.
+     *
+     * @param triggerKey - The trigger key being evaluated
+     * @param contextId - A unique context identifier for the emit chain
+     * @returns true if this (triggerKey, contextId) pair was already seen (cycle detected),
+     *          false if this is the first occurrence
+     */
+    enter(triggerKey: string, contextId: string): boolean;
+    /**
+     * Get the current chain depth.
+     */
+    getDepth(): number;
+    /**
+     * Reset the tracker, clearing all recorded entries and depth.
+     */
+    reset(): void;
+}

package/dist/chain-tracker.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainTracker = void 0;
+/**
+ * Runtime cycle detection for emit chains.
+ *
+ * Tracks (triggerKey, contextId) pairs within a single emit chain
+ * to detect runtime loops.
+ */
+class ChainTracker {
+    seen = new Set();
+    depth = 0;
+    /**
+     * Record entry into a trigger evaluation.
+     *
+     * @param triggerKey - The trigger key being evaluated
+     * @param contextId - A unique context identifier for the emit chain
+     * @returns true if this (triggerKey, contextId) pair was already seen (cycle detected),
+     *          false if this is the first occurrence
+     */
+    enter(triggerKey, contextId) {
+        const key = `${triggerKey}::${contextId}`;
+        if (this.seen.has(key)) {
+            return true;
+        }
+        this.seen.add(key);
+        this.depth++;
+        return false;
+    }
+    /**
+     * Get the current chain depth.
+     */
+    getDepth() {
+        return this.depth;
+    }
+    /**
+     * Reset the tracker, clearing all recorded entries and depth.
+     */
+    reset() {
+        this.seen.clear();
+        this.depth = 0;
+    }
+}
+exports.ChainTracker = ChainTracker;

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error class for loop detection failures.
+ */
+export declare class LoopDetectorError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectorError = void 0;
+/**
+ * Error class for loop detection failures.
+ */
+class LoopDetectorError extends Error {
+    code;
+    context;
+    constructor(message, options) {
+        super(message, { cause: options?.cause });
+        this.name = 'LoopDetectorError';
+        this.code = options?.code ?? 'LOOP_DETECTOR_ERROR';
+        this.context = options?.context;
+    }
+}
+exports.LoopDetectorError = LoopDetectorError;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { LoopDetector } from './loop-detector';
+export { ChainTracker } from './chain-tracker';
+export { LoopDetectorError } from './errors';

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectorError = exports.ChainTracker = exports.LoopDetector = void 0;
+var loop_detector_1 = require("./loop-detector");
+Object.defineProperty(exports, "LoopDetector", { enumerable: true, get: function () { return loop_detector_1.LoopDetector; } });
+var chain_tracker_1 = require("./chain-tracker");
+Object.defineProperty(exports, "ChainTracker", { enumerable: true, get: function () { return chain_tracker_1.ChainTracker; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "LoopDetectorError", { enumerable: true, get: function () { return errors_1.LoopDetectorError; } });

package/dist/loop-detector.d.ts

@@ -0,0 +1,21 @@
+import type { Rule, LoopAnalysis } from '@bernierllc/nevar-types';
+/**
+ * Static loop analysis for rule sets.
+ *
+ * Walks trigger -> action -> deferredTrigger chains across rules
+ * to detect cycles at registration time.
+ */
+export declare class LoopDetector {
+    /**
+     * Analyze a set of rules for potential evaluation loops.
+     *
+     * Builds a graph of triggerType -> deferredTrigger relationships
+     * and detects cycles using DFS.
+     */
+    analyze(rules: Rule[]): LoopAnalysis;
+    private buildEdges;
+    private extractDeferredTriggers;
+    private findCycles;
+    private dfs;
+    private deduplicateLoops;
+}

package/dist/loop-detector.js

@@ -0,0 +1,136 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetector = void 0;
+/**
+ * Static loop analysis for rule sets.
+ *
+ * Walks trigger -> action -> deferredTrigger chains across rules
+ * to detect cycles at registration time.
+ */
+class LoopDetector {
+    /**
+     * Analyze a set of rules for potential evaluation loops.
+     *
+     * Builds a graph of triggerType -> deferredTrigger relationships
+     * and detects cycles using DFS.
+     */
+    analyze(rules) {
+        const edges = this.buildEdges(rules);
+        const ruleMap = new Map(rules.map((r) => [r.id, r]));
+        const loops = this.findCycles(edges, ruleMap);
+        return {
+            hasLoops: loops.length > 0,
+            loops,
+        };
+    }
+    buildEdges(rules) {
+        const edges = new Map();
+        for (const rule of rules) {
+            if (!rule.isActive) {
+                continue;
+            }
+            for (const action of rule.actions) {
+                const config = action.config;
+                const deferredTriggers = this.extractDeferredTriggers(config);
+                for (const triggerKey of deferredTriggers) {
+                    if (!edges.has(rule.triggerType)) {
+                        edges.set(rule.triggerType, []);
+                    }
+                    edges.get(rule.triggerType).push({
+                        triggerKey,
+                        ruleId: rule.id,
+                        allowLoop: rule.allowLoop,
+                    });
+                }
+            }
+        }
+        return edges;
+    }
+    extractDeferredTriggers(config) {
+        const triggers = [];
+        if (config['deferredTrigger'] && typeof config['deferredTrigger'] === 'object') {
+            const dt = config['deferredTrigger'];
+            if (typeof dt['triggerKey'] === 'string') {
+                triggers.push(dt['triggerKey']);
+            }
+        }
+        if (Array.isArray(config['deferredTriggers'])) {
+            for (const dt of config['deferredTriggers']) {
+                if (dt && typeof dt === 'object' && typeof dt['triggerKey'] === 'string') {
+                    triggers.push(dt['triggerKey']);
+                }
+            }
+        }
+        return triggers;
+    }
+    findCycles(edges, ruleMap) {
+        const loops = [];
+        const allTriggerTypes = new Set();
+        for (const [source, targets] of edges) {
+            allTriggerTypes.add(source);
+            for (const t of targets) {
+                allTriggerTypes.add(t.triggerKey);
+            }
+        }
+        for (const startNode of allTriggerTypes) {
+            this.dfs(startNode, edges, ruleMap, [], [], new Set(), loops);
+        }
+        return this.deduplicateLoops(loops);
+    }
+    dfs(current, edges, ruleMap, path, pathRuleIds, visited, loops) {
+        const cycleStart = path.indexOf(current);
+        if (cycleStart !== -1) {
+            const cyclePath = [...path.slice(cycleStart), current];
+            const cycleRuleIds = pathRuleIds.slice(cycleStart);
+            const allOptedIn = cycleRuleIds.every((ruleId) => {
+                const rule = ruleMap.get(ruleId);
+                return rule?.allowLoop === true;
+            });
+            loops.push({
+                chain: cyclePath,
+                allOptedIn,
+                ruleIds: cycleRuleIds,
+            });
+            return;
+        }
+        if (visited.has(current)) {
+            return;
+        }
+        const targets = edges.get(current);
+        if (!targets) {
+            return;
+        }
+        visited.add(current);
+        for (const target of targets) {
+            this.dfs(target.triggerKey, edges, ruleMap, [...path, current], [...pathRuleIds, target.ruleId], new Set(visited), loops);
+        }
+    }
+    deduplicateLoops(loops) {
+        const seen = new Set();
+        const unique = [];
+        for (const loop of loops) {
+            // Rotate chain to start with the lexicographically smallest element for stable dedup
+            const chain = loop.chain.slice(0, -1);
+            const minIdx = chain.indexOf(chain.reduce((min, val) => (val < min ? val : min), chain[0]));
+            const normalized = [
+                ...chain.slice(minIdx),
+                ...chain.slice(0, minIdx),
+                chain[minIdx],
+            ];
+            const key = normalized.join('->');
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(loop);
+            }
+        }
+        return unique;
+    }
+}
+exports.LoopDetector = LoopDetector;

package/package.json

@@ -1,10 +1,56 @@
 {
   "name": "@bernierllc/nevar-loop-detector",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @bernierllc/nevar-loop-detector",
+  "version": "0.1.0",
+  "description": "Static loop analysis and runtime cycle detection for the Nevar rules engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "nevar",
+    "rules-engine",
+    "loop-detection",
+    "cycle-detection",
+    "static-analysis"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bernierllc/tools.git",
+    "directory": "packages/core/nevar-loop-detector"
+  },
+  "dependencies": {
+    "@bernierllc/nevar-types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.5.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prebuild": "npm run clean",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src __tests__ --ext .ts"
+  }
+}