@yesprasad/fluent-graph 0.1.0 → 0.2.0

package/dist/sdk/registry.d.ts

@@ -0,0 +1,30 @@
+interface TableInfo {
+    table: string;
+    pluginName: string;
+    isChild: boolean;
+    parentTable?: string;
+    parentVia?: string;
+    children: string[];
+}
+export declare class ArtifactTypeRegistry {
+    private tables;
+    load(sdkPath: string): void;
+    private register;
+    /**
+     * Parse the top-level relationships map:
+     * { parentTable: { childTable: { via, descendant, relationships: { grandchild: ... } } } }
+     */
+    private parseRelationships;
+    private processChildren;
+    get(table: string): TableInfo | undefined;
+    getPluginName(table: string): string;
+    getDisplayGroupName(table: string): string;
+    isChild(table: string): boolean;
+    getParentTable(table: string): string | undefined;
+    getChildren(table: string): string[];
+    getTablesByPlugin(pluginName: string): string[];
+    getAllPluginNames(): string[];
+    getAllTables(): string[];
+    isKnown(table: string): boolean;
+}
+export {};

package/dist/sdk/registry.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactTypeRegistry = void 0;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
+class ArtifactTypeRegistry {
+    constructor() {
+        this.tables = new Map();
+    }
+    load(sdkPath) {
+        try {
+            const requireFromWorkspace = (0, module_1.createRequire)(path_1.default.join(sdkPath, 'package.json'));
+            const buildPlugins = requireFromWorkspace('@servicenow/sdk-build-plugins');
+            for (const [, value] of Object.entries(buildPlugins)) {
+                const plugin = value;
+                if (!plugin?.config?.name)
+                    continue;
+                const pluginName = plugin.config.name;
+                const tables = Object.keys(plugin.config.records || {}).filter(k => k !== '*');
+                if (tables.length === 0)
+                    continue;
+                for (const table of tables) {
+                    this.register(table, pluginName);
+                }
+                try {
+                    const rels = plugin.getRelationships();
+                    if (rels && typeof rels === 'object') {
+                        this.parseRelationships(rels, pluginName);
+                    }
+                }
+                catch {
+                    // safe to skip — needs compiler context
+                }
+            }
+        }
+        catch {
+            // sdk-build-plugins unavailable; registry stays empty, fallback behavior applies
+        }
+    }
+    register(table, pluginName) {
+        if (!this.tables.has(table)) {
+            this.tables.set(table, { table, pluginName, isChild: false, children: [] });
+        }
+    }
+    /**
+     * Parse the top-level relationships map:
+     * { parentTable: { childTable: { via, descendant, relationships: { grandchild: ... } } } }
+     */
+    parseRelationships(rels, pluginName) {
+        for (const [parentTable, childDefs] of Object.entries(rels)) {
+            this.register(parentTable, pluginName);
+            if (childDefs && typeof childDefs === 'object') {
+                this.processChildren(childDefs, pluginName, parentTable);
+            }
+        }
+    }
+    processChildren(childDefs, pluginName, parentTable) {
+        for (const [key, def] of Object.entries(childDefs)) {
+            // Skip meta-keys and self-referential entries
+            if (key === 'via' || key === 'descendant' || key === 'relationships')
+                continue;
+            if (key === parentTable)
+                continue;
+            const childTable = key;
+            this.register(childTable, pluginName);
+            const entry = this.tables.get(childTable);
+            if (!entry.isChild) {
+                entry.isChild = true;
+                entry.parentTable = parentTable;
+                if (def && typeof def === 'object' && typeof def.via === 'string') {
+                    entry.parentVia = def.via;
+                }
+            }
+            // Add to parent's children list
+            const parentEntry = this.tables.get(parentTable);
+            if (parentEntry && !parentEntry.children.includes(childTable)) {
+                parentEntry.children.push(childTable);
+            }
+            // Recurse into nested relationships
+            if (def && typeof def === 'object' && def.relationships && typeof def.relationships === 'object') {
+                this.processChildren(def.relationships, pluginName, childTable);
+            }
+        }
+    }
+    get(table) {
+        return this.tables.get(table);
+    }
+    getPluginName(table) {
+        return this.tables.get(table)?.pluginName ?? 'Record';
+    }
+    getDisplayGroupName(table) {
+        const entry = this.tables.get(table);
+        if (!entry)
+            return 'Other';
+        return entry.pluginName
+            .replace(/Plugin$/, '')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/^./, c => c.toUpperCase())
+            .trim();
+    }
+    isChild(table) {
+        return this.tables.get(table)?.isChild ?? false;
+    }
+    getParentTable(table) {
+        return this.tables.get(table)?.parentTable;
+    }
+    getChildren(table) {
+        return this.tables.get(table)?.children ?? [];
+    }
+    getTablesByPlugin(pluginName) {
+        return [...this.tables.values()]
+            .filter(t => t.pluginName === pluginName)
+            .map(t => t.table);
+    }
+    getAllPluginNames() {
+        return [...new Set([...this.tables.values()].map(t => t.pluginName))].sort();
+    }
+    getAllTables() {
+        return [...this.tables.keys()];
+    }
+    isKnown(table) {
+        return this.tables.has(table);
+    }
+}
+exports.ArtifactTypeRegistry = ArtifactTypeRegistry;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@yesprasad/fluent-graph",
-  "version": "0.1.0",
-  "description": "Dependency/ Lineage graph extraction & Blast-radius/ impact analysis for ServiceNow Fluent Artifacts",
+  "version": "0.2.0",
+  "description": "Dependency visibility and impact analysis for ServiceNow Fluent SDK projects",
   "bin": {
     "fluent-graph": "./bin/fluent-graph.js"
   },
   "main": "dist/index.js",
-"types": "dist/index.d.ts",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "bin"
@@ -27,13 +27,13 @@
   ],
   "author": "Eshwar Sowbhagya Prasad Yaddanapudi",
   "repository": {
-  "type": "git",
-  "url": "https://github.com/yesprasad/fluent-graph.git"
-},
-"bugs": {
-  "url": "https://github.com/yesprasad/fluent-graph/issues"
-},
-"homepage": "https://github.com/yesprasad/fluent-graph#readme",
+    "type": "git",
+    "url": "https://github.com/yesprasad/fluent-graph.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yesprasad/fluent-graph/issues"
+  },
+  "homepage": "https://github.com/yesprasad/fluent-graph#readme",
   "license": "MIT",
   "type": "commonjs",
   "dependencies": {
@@ -43,11 +43,14 @@
     "ora": "^5.4.1"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/node": "^20.19.39",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "peerDependencies": {
-    "@servicenow/sdk": "4.1.0"
+    "@servicenow/sdk": "4.5.0"
   }
-}
+}