@memberjunction/version-history 6.2.0-edge.0 → 6.2.0-edge.2

package/README.md

@@ -6,6 +6,9 @@ Version labeling, snapshot capture, diff, and restore for MemberJunction records
 
 The `@memberjunction/version-history` package enables developers to create named version labels that capture record state at specific points in time, compare changes between labels, and restore records to previous states while respecting entity dependency ordering.
 
+> [!NOTE]
+> The core record dependency traversal, topological sorting, and link resolution engine (`DependencyGraphWalker`, `SortByEntityDependencyOrder`, `SortNodesTopologically`) has been extracted into [`@memberjunction/record-graph`](../RecordGraph/README.md) so it can be shared across Version History, Record Cloning, and Metadata Sync. Version History re-exports these symbols for backward compatibility.
+
 ```mermaid
 graph TD
     A["VersionHistoryEngine<br/>(Facade)"] --> B["LabelManager"]

package/dist/DependencyGraphWalker.d.ts

@@ -1,169 +1,6 @@
-import { CompositeKey, IMetadataProvider, UserInfo } from '@memberjunction/core';
-import { DependencyNode, WalkOptions } from './types.js';
 /**
- * Walks entity relationship graphs to discover records for version labeling.
- *
- * ## Two-direction traversal
- *
- * **Reverse**: Uses the entity's `RelatedEntities` (EntityRelationship metadata)
- * to find child records. This is curated by CodeGen and admins — only explicitly
- * registered One-To-Many relationships are walked.
- *
- * **Forward**: Scans the current entity's own FK fields to find records it
- * references (e.g., AI Agent Prompt → AI Prompt via PromptID). Skips
- * system/infrastructure fields (UserID, CreatedBy, etc.).
- *
- * ## Discovery mode — prevents explosion from forward references
- *
- * Records found via **reverse walk** are "owned children" and get full treatment
- * (both reverse + forward walks). Records found via **forward walk** are
- * "referenced records" and only get forward-only treatment (their own FK refs
- * are followed, but their EntityRelationship children are NOT discovered).
- *
- * This prevents the classic explosion pattern:
- * ```
- * Agent → AgentPrompt → Prompt → [reverse to ALL PromptModels] → Model
- *   → [reverse to ALL AgentModels across ALL agents] → explosion!
- * ```
- *
- * With discovery mode:
- * ```
- * Agent → AgentPrompt(reverse,full) → Prompt(forward,forward-only)
- *   → Model(forward,forward-only) → STOP (no reverse walk on Model)
- * ```
- *
- * ## Ancestor stack — prevents backtracking
- *
- * A set of entity names on the current path from root to the current node is
- * maintained. When evaluating any relationship, if the target entity type is
- * already on the ancestor stack, it is skipped. This is a secondary safety net
- * that prevents cycles even within full-mode walks.
- *
- * ## Filters
- *
- * - Only walks entities with `TrackRecordChanges === true`
- * - Skips system FK fields via regex patterns (UserID, CreatedBy, etc.)
- * - Respects `ExcludeEntities` and `EntityFilter` options
- * - Uses a global `visited` set for record-level cycle detection
+ * NOTE: DependencyGraphWalker has moved to @memberjunction/record-graph.
+ * Re-exported here for backward compatibility.
  */
-export declare class DependencyGraphWalker {
-    /** Cache: entityID → reverse relationships from EntityRelationship metadata */
-    private reverseRelCache;
-    /** Cache: entityID → forward FK references from field metadata */
-    private forwardRefCache;
-    /** Optional provider override; falls back to Metadata.Provider when not set. */
-    private _provider?;
-    /** Returns the active provider — explicit override if set, otherwise the global default. */
-    protected get ProviderToUse(): IMetadataProvider;
-    /**
-     * Walk from a root record through its relationships, building a tree of
-     * all records that should be included in a version label.
-     *
-     * @param entityName - The starting entity name
-     * @param recordKey  - The starting record's primary key
-     * @param options    - Controls depth, filtering, etc.
-     * @param contextUser - Server-side user context
-     * @returns The root DependencyNode with all descendants populated
-     */
-    WalkDependents(entityName: string, recordKey: CompositeKey, options: WalkOptions, contextUser: UserInfo): Promise<DependencyNode>;
-    /**
-     * Flatten a dependency tree into a topologically sorted list.
-     * Parents appear before their children, ensuring safe restore ordering.
-     */
-    FlattenTopological(root: DependencyNode): DependencyNode[];
-    /**
-     * Recursively discover and attach child nodes for a given parent node.
-     *
-     * The `discoveryMode` controls which directions are walked:
-     * - `'full'`: both reverse (EntityRelationship) and forward (FK refs)
-     * - `'forward-only'`: only forward FK refs — no reverse children discovered
-     *
-     * Records found via reverse walk are recursed with `'full'` mode.
-     * Records found via forward walk are recursed with `'forward-only'` mode.
-     */
-    private walkChildren;
-    /**
-     * Walk reverse relationships: for each EntityRelationship on the parent
-     * entity, load matching child records and recurse into them.
-     *
-     * Skips any child entity type that is already on the ancestor stack,
-     * preventing backtracking (e.g., from AI Prompt back to AI Agent Prompts).
-     *
-     * Children found via reverse walk are recursed with 'full' discovery mode,
-     * since they are "owned children" that may have their own children.
-     */
-    private walkReverseRelationships;
-    /**
-     * Walk forward FK references: for each FK field on the parent entity that
-     * points to another tracked entity, load the referenced record and recurse.
-     *
-     * Skips system/infrastructure FKs (UserID, CreatedBy, etc.) and any target
-     * entity type already on the ancestor stack.
-     *
-     * Targets found via forward walk are recursed with 'forward-only' discovery
-     * mode — they won't discover their own reverse children, preventing graph
-     * explosion from "hub" entities like AI Models.
-     */
-    private walkForwardReferences;
-    /**
-     * Discover reverse relationships for an entity using EntityRelationship
-     * metadata. Only includes One-To-Many relationships to entities that have
-     * TrackRecordChanges enabled.
-     *
-     * Uses EntityRelationship (already loaded in memory on EntityInfo) rather
-     * than scanning all entities' FK fields. This means only relationships
-     * that CodeGen or admins have explicitly registered are walked.
-     */
-    private discoverReverseRelationships;
-    /**
-     * Discover forward FK references on an entity — fields that point TO other
-     * entities. Only includes references to entities with TrackRecordChanges
-     * enabled, and skips system/infrastructure FK fields.
-     */
-    private discoverForwardReferences;
-    /**
-     * Load child records for a reverse relationship.
-     * Queries the child entity where the join field matches the parent's key value.
-     */
-    private loadChildRecords;
-    /**
-     * Load a single record's data by primary key.
-     */
-    private loadRecordData;
-    /**
-     * Build a DependencyNode from record data, register it in the visited set,
-     * and attach it as a child of the parent. Returns null if already visited.
-     */
-    private registerNode;
-    /** Create an empty stats accumulator. */
-    private createEmptyStats;
-    /** Increment the per-entity record counter. */
-    private incrementEntityCount;
-    /**
-     * Log a detailed summary of the walk: total records, per-entity counts,
-     * skips, and suppression stats.
-     */
-    private logWalkSummary;
-    /** Build a unique key for the visited set: "EntityName::recordID" */
-    private visitKey;
-    /**
-     * Determine the parent key field from an EntityRelationship record.
-     * Uses EntityKeyField if specified, otherwise falls back to the first PK.
-     */
-    private resolveParentKeyFieldFromRelationship;
-    /**
-     * Determine the target key field from a FK field definition.
-     * Uses RelatedEntityFieldName if specified, otherwise falls back to the
-     * target entity's first PK.
-     */
-    private resolveParentKeyFieldFromFK;
-    /** Check if a field name matches a system/infrastructure FK pattern. */
-    private isSystemFKField;
-    /** Check if an entity should be skipped based on filter options. */
-    private shouldSkipEntity;
-    /** Check if an entity has a soft delete field. */
-    private entityHasSoftDelete;
-    /** Apply defaults to walk options. */
-    private resolveDefaults;
-}
+export { DependencyGraphWalker } from '@memberjunction/record-graph';
 //# sourceMappingURL=DependencyGraphWalker.d.ts.map

package/dist/DependencyGraphWalker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DependencyGraphWalker.d.ts","sourceRoot":"","sources":["../src/DependencyGraphWalker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuD,iBAAiB,EAAqB,QAAQ,EAAuB,MAAM,sBAAsB,CAAC;AAE9K,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA6FtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBAAa,qBAAqB;IAC9B,+EAA+E;IAC/E,OAAO,CAAC,eAAe,CAA4C;IACnE,kEAAkE;IAClE,OAAO,CAAC,eAAe,CAAyC;IAEhE,gFAAgF;IAChF,OAAO,CAAC,SAAS,CAAC,CAAoB;IAEtC,4FAA4F;IAC5F,SAAS,KAAK,aAAa,IAAI,iBAAiB,CAE/C;IAMD;;;;;;;;;OASG;IACU,cAAc,CACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,WAAW,EACpB,WAAW,EAAE,QAAQ,GACtB,OAAO,CAAC,cAAc,CAAC;IA2C1B;;;OAGG;IACI,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,EAAE;IAiBjE;;;;;;;;;OASG;YACW,YAAY;IA4B1B;;;;;;;;;OASG;YACW,wBAAwB;IAyCtC;;;;;;;;;;OAUG;YACW,qBAAqB;IAwDnC;;;;;;;;OAQG;IACH,OAAO,CAAC,4BAA4B;IA6BpC;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IA+BjC;;;OAGG;YACW,gBAAgB;IAsC9B;;OAEG;YACW,cAAc;IA0B5B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAqCpB,yCAAyC;IACzC,OAAO,CAAC,gBAAgB;IAUxB,+CAA+C;IAC/C,OAAO,CAAC,oBAAoB;IAK5B;;;OAGG;IACH,OAAO,CAAC,cAAc;IA0BtB,qEAAqE;IACrE,OAAO,CAAC,QAAQ;IAIhB;;;OAGG;IACH,OAAO,CAAC,qCAAqC;IAU7C;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAUnC,wEAAwE;IACxE,OAAO,CAAC,eAAe;IAIvB,oEAAoE;IACpE,OAAO,CAAC,gBAAgB;IAUxB,kDAAkD;IAClD,OAAO,CAAC,mBAAmB;IAI3B,sCAAsC;IACtC,OAAO,CAAC,eAAe;CAQ1B"}
+{"version":3,"file":"DependencyGraphWalker.d.ts","sourceRoot":"","sources":["../src/DependencyGraphWalker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}