@theguild/federation-composition 0.9.0 → 0.10.0

package/typings/supergraph/validation/rules/satisfiablity/supergraph.d.ts

@@ -0,0 +1,14 @@
+import { OperationTypeNode } from 'graphql';
+import type { SupergraphState } from '../../../state';
+import { Step } from './operation-path';
+export declare class Supergraph {
+    private supergraph;
+    private mergedGraph;
+    private fieldsResolver;
+    private moveRequirementChecker;
+    private logger;
+    constructor(supergraphState: SupergraphState);
+    validate(): import("./walker").WalkTracker[];
+    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker").WalkTracker;
+}
+//# sourceMappingURL=supergraph.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/walker.d.cts

@@ -0,0 +1,35 @@
+import { OperationTypeNode } from 'graphql';
+import type { Logger } from '../../../../utils/logger';
+import { type Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import type { Graph } from './graph';
+import type { MoveValidator } from './move-validator';
+import { OperationPath, type Step } from './operation-path';
+export declare class WalkTracker {
+    superPath: OperationPath;
+    paths: OperationPath[];
+    private errors;
+    constructor(superPath: OperationPath, paths: OperationPath[]);
+    move(edge: Edge): WalkTracker;
+    addPath(path: OperationPath): void;
+    addError(error: SatisfiabilityError): void;
+    isPossible(): boolean;
+    givesEmptyResult(): boolean;
+    isEdgeVisited(edge: Edge): boolean;
+    listErrors(): SatisfiabilityError[];
+}
+export declare class Walker {
+    private moveChecker;
+    private supergraph;
+    private mergedGraph;
+    private logger;
+    private pathFinder;
+    constructor(logger: Logger, moveChecker: MoveValidator, supergraph: Graph, mergedGraph: Graph);
+    walkTrail(operationType: OperationTypeNode, steps: Step[]): WalkTracker;
+    walk(method?: 'bfs' | 'dfs'): WalkTracker[];
+    private nextStep;
+    private dfs;
+    private _dfs;
+    private bfs;
+}
+//# sourceMappingURL=walker.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/walker.d.ts

@@ -0,0 +1,35 @@
+import { OperationTypeNode } from 'graphql';
+import type { Logger } from '../../../../utils/logger';
+import { type Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import type { Graph } from './graph';
+import type { MoveValidator } from './move-validator';
+import { OperationPath, type Step } from './operation-path';
+export declare class WalkTracker {
+    superPath: OperationPath;
+    paths: OperationPath[];
+    private errors;
+    constructor(superPath: OperationPath, paths: OperationPath[]);
+    move(edge: Edge): WalkTracker;
+    addPath(path: OperationPath): void;
+    addError(error: SatisfiabilityError): void;
+    isPossible(): boolean;
+    givesEmptyResult(): boolean;
+    isEdgeVisited(edge: Edge): boolean;
+    listErrors(): SatisfiabilityError[];
+}
+export declare class Walker {
+    private moveChecker;
+    private supergraph;
+    private mergedGraph;
+    private logger;
+    private pathFinder;
+    constructor(logger: Logger, moveChecker: MoveValidator, supergraph: Graph, mergedGraph: Graph);
+    walkTrail(operationType: OperationTypeNode, steps: Step[]): WalkTracker;
+    walk(method?: 'bfs' | 'dfs'): WalkTracker[];
+    private nextStep;
+    private dfs;
+    private _dfs;
+    private bfs;
+}
+//# sourceMappingURL=walker.d.ts.map

package/typings/utils/logger.d.cts

@@ -0,0 +1,33 @@
+import debug from 'debug';
+export declare class LoggerContext {
+    private indent;
+    private maxIdLength;
+    private idUpdateFns;
+    private logger;
+    private firstLoggerAt;
+    down(time: number): void;
+    up(time: number): number | undefined;
+    getTime(): number;
+    getIndent(): {
+        level: number;
+        str: string;
+        times: number[];
+    };
+    register(id: string, idUpdateFn: (len: number) => void): debug.Debugger;
+    private updateIndent;
+}
+export declare class Logger {
+    private id;
+    private context;
+    isEnabled: boolean;
+    private debug;
+    private idPrefix;
+    constructor(id: string, context: LoggerContext);
+    log(msg: string | (() => string), prefix?: string): void;
+    group(msg: string | (() => string)): void;
+    groupEnd(msg?: string | (() => string)): void;
+    create(id: string): Logger;
+    private _log;
+    private _updateIdPrefix;
+}
+//# sourceMappingURL=logger.d.ts.map

package/typings/utils/logger.d.ts

@@ -0,0 +1,33 @@
+import debug from 'debug';
+export declare class LoggerContext {
+    private indent;
+    private maxIdLength;
+    private idUpdateFns;
+    private logger;
+    private firstLoggerAt;
+    down(time: number): void;
+    up(time: number): number | undefined;
+    getTime(): number;
+    getIndent(): {
+        level: number;
+        str: string;
+        times: number[];
+    };
+    register(id: string, idUpdateFn: (len: number) => void): debug.Debugger;
+    private updateIndent;
+}
+export declare class Logger {
+    private id;
+    private context;
+    isEnabled: boolean;
+    private debug;
+    private idPrefix;
+    constructor(id: string, context: LoggerContext);
+    log(msg: string | (() => string), prefix?: string): void;
+    group(msg: string | (() => string)): void;
+    groupEnd(msg?: string | (() => string)): void;
+    create(id: string): Logger;
+    private _log;
+    private _updateIdPrefix;
+}
+//# sourceMappingURL=logger.d.ts.map

package/cjs/utils/dependency-graph.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepGraphCycleError = exports.DepGraph = void 0;
-function createDFS(edges, leavesOnly, result, circular) {
-    const visited = {};
-    return function (start) {
-        if (visited[start]) {
-            return;
-        }
-        const inCurrentPath = {};
-        const currentPath = [];
-        const todo = [];
-        todo.push({ node: start, processed: false });
-        while (todo.length > 0) {
-            const current = todo[todo.length - 1];
-            const processed = current.processed;
-            const node = current.node;
-            if (!processed) {
-                if (visited[node]) {
-                    todo.pop();
-                    continue;
-                }
-                else if (inCurrentPath[node]) {
-                    if (circular) {
-                        todo.pop();
-                        continue;
-                    }
-                    currentPath.push(node);
-                    throw new DepGraphCycleError(currentPath);
-                }
-                inCurrentPath[node] = true;
-                currentPath.push(node);
-                const nodeEdges = edges[node];
-                for (let i = nodeEdges.length - 1; i >= 0; i--) {
-                    todo.push({ node: nodeEdges[i], processed: false });
-                }
-                current.processed = true;
-            }
-            else {
-                todo.pop();
-                currentPath.pop();
-                inCurrentPath[node] = false;
-                visited[node] = true;
-                if (!leavesOnly || edges[node].length === 0) {
-                    result.push(node);
-                }
-            }
-        }
-    };
-}
-class DepGraph {
-    nodes = {};
-    outgoingEdges = {};
-    incomingEdges = {};
-    circular;
-    constructor(opts) {
-        this.circular = opts?.circular ?? false;
-    }
-    size() {
-        return Object.keys(this.nodes).length;
-    }
-    addNode(name, data) {
-        if (!this.hasNode(name)) {
-            if (arguments.length === 2) {
-                this.nodes[name] = data;
-            }
-            else {
-                this.nodes[name] = name;
-            }
-            this.outgoingEdges[name] = [];
-            this.incomingEdges[name] = [];
-        }
-    }
-    removeNode(name) {
-        if (this.hasNode(name)) {
-            delete this.nodes[name];
-            delete this.outgoingEdges[name];
-            delete this.incomingEdges[name];
-            [this.incomingEdges, this.outgoingEdges].forEach(edgeList => {
-                Object.keys(edgeList).forEach(key => {
-                    const idx = edgeList[key].indexOf(name);
-                    if (idx >= 0) {
-                        edgeList[key].splice(idx, 1);
-                    }
-                });
-            });
-        }
-    }
-    hasNode(name) {
-        return this.nodes.hasOwnProperty(name);
-    }
-    getNodeData(name) {
-        if (this.hasNode(name)) {
-            return this.nodes[name];
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    setNodeData(name, data) {
-        if (this.hasNode(name)) {
-            this.nodes[name] = data;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    addDependency(from, to) {
-        if (!this.hasNode(from)) {
-            throw new Error('Node does not exist: ' + from);
-        }
-        if (!this.hasNode(to)) {
-            throw new Error('Node does not exist: ' + to);
-        }
-        if (this.outgoingEdges[from].indexOf(to) === -1) {
-            this.outgoingEdges[from].push(to);
-        }
-        if (this.incomingEdges[to].indexOf(from) === -1) {
-            this.incomingEdges[to].push(from);
-        }
-        return true;
-    }
-    removeDependency(from, to) {
-        let idx;
-        if (this.hasNode(from)) {
-            idx = this.outgoingEdges[from].indexOf(to);
-            if (idx >= 0) {
-                this.outgoingEdges[from].splice(idx, 1);
-            }
-        }
-        if (this.hasNode(to)) {
-            idx = this.incomingEdges[to].indexOf(from);
-            if (idx >= 0) {
-                this.incomingEdges[to].splice(idx, 1);
-            }
-        }
-    }
-    directDependenciesOf(name) {
-        if (this.hasNode(name)) {
-            return this.outgoingEdges[name].slice(0);
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    directDependantsOf(name) {
-        if (this.hasNode(name)) {
-            return this.incomingEdges[name].slice(0);
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    dependenciesOf(name, leavesOnly) {
-        if (this.hasNode(name)) {
-            const result = [];
-            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
-            DFS(name);
-            const idx = result.indexOf(name);
-            if (idx >= 0) {
-                result.splice(idx, 1);
-            }
-            return result;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    dependantsOf(name, leavesOnly) {
-        if (this.hasNode(name)) {
-            const result = [];
-            const DFS = createDFS(this.incomingEdges, leavesOnly, result, this.circular);
-            DFS(name);
-            const idx = result.indexOf(name);
-            if (idx >= 0) {
-                result.splice(idx, 1);
-            }
-            return result;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    overallOrder(leavesOnly) {
-        const result = [];
-        const keys = Object.keys(this.nodes);
-        if (keys.length === 0) {
-            return result;
-        }
-        else {
-            if (!this.circular) {
-                const CycleDFS = createDFS(this.outgoingEdges, false, [], this.circular);
-                keys.forEach(function (n) {
-                    CycleDFS(n);
-                });
-            }
-            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
-            keys
-                .filter(node => this.incomingEdges[node].length === 0)
-                .forEach(n => {
-                DFS(n);
-            });
-            if (this.circular) {
-                keys
-                    .filter(node => result.indexOf(node) === -1)
-                    .forEach(function (n) {
-                    DFS(n);
-                });
-            }
-            return result;
-        }
-    }
-    entryNodes() {
-        return Object.keys(this.nodes).filter(node => this.incomingEdges[node].length === 0);
-    }
-    directDependentsOf = this.directDependantsOf;
-    dependentsOf = this.dependantsOf;
-}
-exports.DepGraph = DepGraph;
-class DepGraphCycleError extends Error {
-    cyclePath;
-    constructor(cyclePath) {
-        super('Dependency Cycle Found: ' + cyclePath.join(' -> '));
-        this.cyclePath = cyclePath;
-    }
-}
-exports.DepGraphCycleError = DepGraphCycleError;

package/esm/utils/dependency-graph.js

@@ -1,222 +0,0 @@
-function createDFS(edges, leavesOnly, result, circular) {
-    const visited = {};
-    return function (start) {
-        if (visited[start]) {
-            return;
-        }
-        const inCurrentPath = {};
-        const currentPath = [];
-        const todo = [];
-        todo.push({ node: start, processed: false });
-        while (todo.length > 0) {
-            const current = todo[todo.length - 1];
-            const processed = current.processed;
-            const node = current.node;
-            if (!processed) {
-                if (visited[node]) {
-                    todo.pop();
-                    continue;
-                }
-                else if (inCurrentPath[node]) {
-                    if (circular) {
-                        todo.pop();
-                        continue;
-                    }
-                    currentPath.push(node);
-                    throw new DepGraphCycleError(currentPath);
-                }
-                inCurrentPath[node] = true;
-                currentPath.push(node);
-                const nodeEdges = edges[node];
-                for (let i = nodeEdges.length - 1; i >= 0; i--) {
-                    todo.push({ node: nodeEdges[i], processed: false });
-                }
-                current.processed = true;
-            }
-            else {
-                todo.pop();
-                currentPath.pop();
-                inCurrentPath[node] = false;
-                visited[node] = true;
-                if (!leavesOnly || edges[node].length === 0) {
-                    result.push(node);
-                }
-            }
-        }
-    };
-}
-export class DepGraph {
-    nodes = {};
-    outgoingEdges = {};
-    incomingEdges = {};
-    circular;
-    constructor(opts) {
-        this.circular = opts?.circular ?? false;
-    }
-    size() {
-        return Object.keys(this.nodes).length;
-    }
-    addNode(name, data) {
-        if (!this.hasNode(name)) {
-            if (arguments.length === 2) {
-                this.nodes[name] = data;
-            }
-            else {
-                this.nodes[name] = name;
-            }
-            this.outgoingEdges[name] = [];
-            this.incomingEdges[name] = [];
-        }
-    }
-    removeNode(name) {
-        if (this.hasNode(name)) {
-            delete this.nodes[name];
-            delete this.outgoingEdges[name];
-            delete this.incomingEdges[name];
-            [this.incomingEdges, this.outgoingEdges].forEach(edgeList => {
-                Object.keys(edgeList).forEach(key => {
-                    const idx = edgeList[key].indexOf(name);
-                    if (idx >= 0) {
-                        edgeList[key].splice(idx, 1);
-                    }
-                });
-            });
-        }
-    }
-    hasNode(name) {
-        return this.nodes.hasOwnProperty(name);
-    }
-    getNodeData(name) {
-        if (this.hasNode(name)) {
-            return this.nodes[name];
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    setNodeData(name, data) {
-        if (this.hasNode(name)) {
-            this.nodes[name] = data;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    addDependency(from, to) {
-        if (!this.hasNode(from)) {
-            throw new Error('Node does not exist: ' + from);
-        }
-        if (!this.hasNode(to)) {
-            throw new Error('Node does not exist: ' + to);
-        }
-        if (this.outgoingEdges[from].indexOf(to) === -1) {
-            this.outgoingEdges[from].push(to);
-        }
-        if (this.incomingEdges[to].indexOf(from) === -1) {
-            this.incomingEdges[to].push(from);
-        }
-        return true;
-    }
-    removeDependency(from, to) {
-        let idx;
-        if (this.hasNode(from)) {
-            idx = this.outgoingEdges[from].indexOf(to);
-            if (idx >= 0) {
-                this.outgoingEdges[from].splice(idx, 1);
-            }
-        }
-        if (this.hasNode(to)) {
-            idx = this.incomingEdges[to].indexOf(from);
-            if (idx >= 0) {
-                this.incomingEdges[to].splice(idx, 1);
-            }
-        }
-    }
-    directDependenciesOf(name) {
-        if (this.hasNode(name)) {
-            return this.outgoingEdges[name].slice(0);
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    directDependantsOf(name) {
-        if (this.hasNode(name)) {
-            return this.incomingEdges[name].slice(0);
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    dependenciesOf(name, leavesOnly) {
-        if (this.hasNode(name)) {
-            const result = [];
-            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
-            DFS(name);
-            const idx = result.indexOf(name);
-            if (idx >= 0) {
-                result.splice(idx, 1);
-            }
-            return result;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    dependantsOf(name, leavesOnly) {
-        if (this.hasNode(name)) {
-            const result = [];
-            const DFS = createDFS(this.incomingEdges, leavesOnly, result, this.circular);
-            DFS(name);
-            const idx = result.indexOf(name);
-            if (idx >= 0) {
-                result.splice(idx, 1);
-            }
-            return result;
-        }
-        else {
-            throw new Error('Node does not exist: ' + name);
-        }
-    }
-    overallOrder(leavesOnly) {
-        const result = [];
-        const keys = Object.keys(this.nodes);
-        if (keys.length === 0) {
-            return result;
-        }
-        else {
-            if (!this.circular) {
-                const CycleDFS = createDFS(this.outgoingEdges, false, [], this.circular);
-                keys.forEach(function (n) {
-                    CycleDFS(n);
-                });
-            }
-            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
-            keys
-                .filter(node => this.incomingEdges[node].length === 0)
-                .forEach(n => {
-                DFS(n);
-            });
-            if (this.circular) {
-                keys
-                    .filter(node => result.indexOf(node) === -1)
-                    .forEach(function (n) {
-                    DFS(n);
-                });
-            }
-            return result;
-        }
-    }
-    entryNodes() {
-        return Object.keys(this.nodes).filter(node => this.incomingEdges[node].length === 0);
-    }
-    directDependentsOf = this.directDependantsOf;
-    dependentsOf = this.dependantsOf;
-}
-export class DepGraphCycleError extends Error {
-    cyclePath;
-    constructor(cyclePath) {
-        super('Dependency Cycle Found: ' + cyclePath.join(' -> '));
-        this.cyclePath = cyclePath;
-    }
-}

package/typings/utils/dependency-graph.d.cts

@@ -1,31 +0,0 @@
-export interface Options {
-    circular?: boolean;
-}
-export declare class DepGraph<T> {
-    private nodes;
-    private outgoingEdges;
-    private incomingEdges;
-    private circular;
-    constructor(opts?: Options);
-    size(): number;
-    addNode(name: string, data?: T): void;
-    removeNode(name: string): void;
-    hasNode(name: string): boolean;
-    getNodeData(name: string): string | T | undefined;
-    setNodeData(name: string, data?: T): void;
-    addDependency(from: string, to: string): boolean;
-    removeDependency(from: string, to: string): void;
-    directDependenciesOf(name: string): string[];
-    directDependantsOf(name: string): string[];
-    dependenciesOf(name: string, leavesOnly?: boolean): string[];
-    dependantsOf(name: string, leavesOnly?: boolean): string[];
-    overallOrder(leavesOnly?: boolean): string[];
-    entryNodes(): string[];
-    directDependentsOf: (name: string) => string[];
-    dependentsOf: (name: string, leavesOnly?: boolean) => string[];
-}
-export declare class DepGraphCycleError extends Error {
-    cyclePath: string[];
-    constructor(cyclePath: string[]);
-}
-//# sourceMappingURL=dependency-graph.d.ts.map

package/typings/utils/dependency-graph.d.ts

@@ -1,31 +0,0 @@
-export interface Options {
-    circular?: boolean;
-}
-export declare class DepGraph<T> {
-    private nodes;
-    private outgoingEdges;
-    private incomingEdges;
-    private circular;
-    constructor(opts?: Options);
-    size(): number;
-    addNode(name: string, data?: T): void;
-    removeNode(name: string): void;
-    hasNode(name: string): boolean;
-    getNodeData(name: string): string | T | undefined;
-    setNodeData(name: string, data?: T): void;
-    addDependency(from: string, to: string): boolean;
-    removeDependency(from: string, to: string): void;
-    directDependenciesOf(name: string): string[];
-    directDependantsOf(name: string): string[];
-    dependenciesOf(name: string, leavesOnly?: boolean): string[];
-    dependantsOf(name: string, leavesOnly?: boolean): string[];
-    overallOrder(leavesOnly?: boolean): string[];
-    entryNodes(): string[];
-    directDependentsOf: (name: string) => string[];
-    dependentsOf: (name: string, leavesOnly?: boolean) => string[];
-}
-export declare class DepGraphCycleError extends Error {
-    cyclePath: string[];
-    constructor(cyclePath: string[]);
-}
-//# sourceMappingURL=dependency-graph.d.ts.map