@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Operations/Matchers/NodeQuery/NodeQuery.test.js

@@ -0,0 +1,306 @@
+import { mock } from 'jest-mock-extended';
+import { asEdgeId, asNodeId } from '../../../TgGraph.js';
+import { NodeQuery } from './NodeQuery.js';
+describe('NodeQuery.match', () => {
+    it('shoud return true for any node when using any', () => {
+        const query = NodeQuery.from({ any: true });
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const node = { label: 'resource.name' };
+        expect(query.match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud support children.exists with false', () => {
+        const parentId = asNodeId('cluster_module.a');
+        const query = NodeQuery.from({
+            and: [
+                { nodeId: { startsWith: 'cluster_module' } },
+                { children: { exists: false } },
+            ],
+        });
+        const graph = mock();
+        graph.successors.mockReturnValue([asNodeId('module.a.resource.one')]);
+        const resultWithChild = query.match(parentId, { label: 'module.a' }, graph);
+        expect(resultWithChild).toBe(false);
+        graph.successors.mockReturnValue([]);
+        const resultWithoutChild = query.match(parentId, { label: 'module.a' }, graph);
+        expect(resultWithoutChild).toBe(true);
+    });
+    it('shoud support children.count', () => {
+        const parentId = asNodeId('cluster_module.a');
+        const query = NodeQuery.from({
+            and: [
+                { nodeId: { startsWith: 'cluster_module' } },
+                { children: { count: 2 } },
+            ],
+        });
+        const graph = mock();
+        graph.successors.mockReturnValue([
+            asNodeId('module.a.resource.one'),
+            asNodeId('module.a.resource.two'),
+        ]);
+        expect(query.match(parentId, { label: 'module.a' }, graph)).toBe(true);
+    });
+    it('shoud evaluate children independently of module naming conventions', () => {
+        const sourceId = asNodeId('alpha');
+        const query = NodeQuery.from({ children: { exists: true } });
+        const graph = mock();
+        graph.successors.mockReturnValue([asNodeId('beta')]);
+        expect(query.match(sourceId, { label: 'random.node' }, graph)).toBe(true);
+    });
+    it('shoud support OR and NOT predicates together', () => {
+        const sourceId = asNodeId('node-a');
+        const graph = mock();
+        const query = NodeQuery.from({
+            and: [
+                {
+                    or: [{ nodeId: { eq: 'node-a' } }, { nodeId: { eq: 'node-z' } }],
+                },
+                { not: { nodeId: { eq: 'node-b' } } },
+            ],
+        });
+        expect(query.match(sourceId, { label: 'node-a' }, graph)).toBe(true);
+        expect(query.match(asNodeId('node-b'), { label: 'node-b' }, graph)).toBe(false);
+    });
+    it('shoud support inbound edge predicates', () => {
+        const sourceId = asNodeId('node-a');
+        const targetId = asNodeId('node-b');
+        const sourceEdge = asEdgeId('edge-a-b');
+        const graph = mock();
+        graph.inEdges.mockReturnValue([sourceEdge]);
+        graph.edgeSource.mockReturnValue(sourceId);
+        graph.getNodeAttributes.mockImplementation((nodeId) => {
+            if (nodeId === sourceId) {
+                return { label: 'node-a' };
+            }
+            return undefined;
+        });
+        const query = NodeQuery.from({
+            edge: {
+                in: {
+                    nodeId: { eq: 'node-a' },
+                },
+            },
+        });
+        expect(query.match(targetId, { label: 'node-b' }, graph)).toBe(true);
+    });
+    it('shoud return false when edge predicates cannot resolve node attributes', () => {
+        const sourceId = asNodeId('node-a');
+        const targetId = asNodeId('node-b');
+        const sourceEdge = asEdgeId('edge-a-b');
+        const graph = mock();
+        graph.inEdges.mockReturnValue([sourceEdge]);
+        graph.edgeSource.mockReturnValue(sourceId);
+        graph.getNodeAttributes.mockReturnValue(undefined);
+        const query = NodeQuery.from({
+            edge: {
+                in: {
+                    nodeId: { eq: 'node-a' },
+                },
+            },
+        });
+        expect(query.match(targetId, { label: 'node-b' }, graph)).toBe(false);
+    });
+    it('shoud return false when outbound targets are missing', () => {
+        const sourceId = asNodeId('node-a');
+        const targetId = asNodeId('node-b');
+        const sourceEdge = asEdgeId('edge-a-b');
+        const graph = mock();
+        graph.outEdges.mockReturnValue([sourceEdge]);
+        graph.edgeTarget.mockReturnValue(targetId);
+        graph.getNodeAttributes.mockReturnValue(undefined);
+        const query = NodeQuery.from({
+            edge: {
+                out: {
+                    nodeId: { eq: 'node-b' },
+                },
+            },
+        });
+        expect(query.match(sourceId, { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud evaluate inbound and outbound edge predicates together', () => {
+        const sourceId = asNodeId('node-a');
+        const targetId = asNodeId('node-b');
+        const sourceEdge = asEdgeId('edge-a-b');
+        const graph = mock();
+        graph.inEdges.mockReturnValue([sourceEdge]);
+        graph.outEdges.mockReturnValue([sourceEdge]);
+        graph.edgeSource.mockReturnValue(sourceId);
+        graph.edgeTarget.mockReturnValue(targetId);
+        graph.getNodeAttributes.mockImplementation((nodeId) => {
+            if (nodeId === sourceId) {
+                return { label: 'node-a' };
+            }
+            if (nodeId === targetId) {
+                return { label: 'node-b' };
+            }
+            return undefined;
+        });
+        const query = NodeQuery.from({
+            edge: {
+                in: {
+                    nodeId: { startsWith: 'node' },
+                },
+                out: {
+                    nodeId: { endsWith: 'b' },
+                },
+            },
+        });
+        expect(query.match(sourceId, { label: 'node-a' }, graph)).toBe(true);
+    });
+    it('shoud support outbound edge predicates', () => {
+        const sourceId = asNodeId('node-a');
+        const targetId = asNodeId('node-b');
+        const sourceEdge = asEdgeId('edge-a-b');
+        const graph = mock();
+        graph.outEdges.mockReturnValue([sourceEdge]);
+        graph.edgeTarget.mockReturnValue(targetId);
+        graph.getNodeAttributes.mockImplementation((nodeId) => {
+            if (nodeId === targetId) {
+                return { label: 'node-b' };
+            }
+            return undefined;
+        });
+        const query = NodeQuery.from({
+            edge: {
+                out: {
+                    nodeId: { eq: 'node-b' },
+                },
+            },
+        });
+        expect(query.match(sourceId, { label: 'node-a' }, graph)).toBe(true);
+    });
+    it('shoud match attr predicates beyond equality', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const node = {
+            meta: {
+                kind: 'resource',
+                name: 'alpha.beta',
+                status: 'ready',
+            },
+        };
+        expect(NodeQuery.from({
+            attr: { key: 'meta.kind', in: ['resource', 'other'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name', contains: 'beta' },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name', startsWith: ['nope', 'alpha'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name', endsWith: ['beta', 'zzz'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.missing', exists: false },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.kind', exists: true },
+        }).match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud support string startsWith and endsWith predicates', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const node = {
+            meta: {
+                name: 'alpha.beta',
+            },
+        };
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name', startsWith: 'alpha' },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name', endsWith: 'beta' },
+        }).match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud handle string predicates when values are missing', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const node = {
+            meta: {},
+        };
+        expect(NodeQuery.from({
+            attr: { key: 'meta.missing', contains: 'beta' },
+        }).match(nodeId, node, graph)).toBe(false);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.missing', startsWith: 'alpha' },
+        }).match(nodeId, node, graph)).toBe(false);
+        expect(NodeQuery.from({
+            attr: { key: 'meta.missing', endsWith: 'beta' },
+        }).match(nodeId, node, graph)).toBe(false);
+    });
+    it('shoud return false for invalid children predicates', () => {
+        const graph = mock();
+        graph.successors.mockReturnValue([]);
+        const query = new NodeQuery({ children: {} });
+        expect(query.match(asNodeId('node-a'), { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud treat non-object path segments as missing', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const node = {
+            meta: {
+                name: 'alpha',
+            },
+        };
+        expect(NodeQuery.from({
+            attr: { key: 'meta.name.value', exists: false },
+        }).match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud match nodeId predicates beyond equality', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        expect(NodeQuery.from({
+            nodeId: { in: ['node-a', 'node-b'] },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+        expect(NodeQuery.from({
+            nodeId: { contains: 'ode-' },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+        expect(NodeQuery.from({
+            nodeId: { endsWith: 'a' },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+    });
+    it('shoud return false for unsupported dsl entries', () => {
+        const graph = mock();
+        const query = new NodeQuery({});
+        expect(query.match(asNodeId('node-a'), { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud treat empty attribute paths as undefined', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const query = new NodeQuery({
+            attr: { key: '', eq: 'value' },
+        });
+        expect(query.match(nodeId, { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud return false when predicates have no operators', () => {
+        const graph = mock();
+        const nodeId = asNodeId('node-a');
+        const query = new NodeQuery({
+            attr: { key: 'meta.kind' },
+        });
+        expect(query.match(nodeId, { meta: { kind: 'resource' } }, graph)).toBe(false);
+    });
+    it('shoud provide fromJson as a parsing shortcut', () => {
+        const query = NodeQuery.fromJson({ any: true });
+        const graph = mock();
+        expect(query.match(asNodeId('node-any'), { label: 'anything' }, graph)).toBe(true);
+    });
+});
+describe('NodeQuery.getDsl', () => {
+    it('shoud return the parsed dsl', () => {
+        const input = { any: true };
+        const query = NodeQuery.from(input);
+        expect(query.getDsl()).toEqual(input);
+    });
+});
+describe('NodeQuery.toMatcher', () => {
+    it('shoud expose a matcher function', () => {
+        const query = NodeQuery.from({
+            attr: { key: 'meta.kind', eq: 'resource' },
+        });
+        const matcher = query.toMatcher();
+        const graph = mock();
+        expect(matcher(asNodeId('node-a'), { meta: { kind: 'resource' } }, graph)).toBe(true);
+    });
+});

package/dist/esm/Graph/Operations/Matchers/NodeQuery/QuerySchema.d.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+declare const PredicateObject: z.ZodObject<{
+    eq: z.ZodOptional<z.ZodUnknown>;
+    in: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contains: z.ZodOptional<z.ZodString>;
+    startsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    endsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    exists: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>;
+declare const AttrPredicateObject: z.ZodObject<{
+    eq: z.ZodOptional<z.ZodUnknown>;
+    in: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contains: z.ZodOptional<z.ZodString>;
+    startsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    endsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    exists: z.ZodOptional<z.ZodBoolean>;
+} & {
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>;
+export declare const AttrPredicateSchema: z.ZodEffects<z.ZodObject<{
+    eq: z.ZodOptional<z.ZodUnknown>;
+    in: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contains: z.ZodOptional<z.ZodString>;
+    startsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    endsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    exists: z.ZodOptional<z.ZodBoolean>;
+} & {
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    key: string;
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>;
+export declare const NodeIdPredicateSchema: z.ZodEffects<z.ZodObject<{
+    eq: z.ZodOptional<z.ZodUnknown>;
+    in: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contains: z.ZodOptional<z.ZodString>;
+    startsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    endsWith: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    exists: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}, {
+    endsWith?: string | string[] | undefined;
+    startsWith?: string | string[] | undefined;
+    contains?: string | undefined;
+    in?: unknown[] | undefined;
+    eq?: unknown;
+    exists?: boolean | undefined;
+}>;
+export type AttrPredicate = z.infer<typeof AttrPredicateObject>;
+export type NodeIdPredicate = z.infer<typeof PredicateObject>;
+export type ChildrenPredicate = {
+    exists?: boolean;
+    count?: number;
+};
+export type QueryDsl = {
+    any: true;
+} | {
+    and: QueryDsl[];
+} | {
+    or: QueryDsl[];
+} | {
+    not: QueryDsl;
+} | {
+    attr: AttrPredicate;
+} | {
+    nodeId: NodeIdPredicate;
+} | {
+    children: ChildrenPredicate;
+} | {
+    edge: {
+        in?: QueryDsl;
+        out?: QueryDsl;
+    };
+};
+export declare const QuerySchema: z.ZodType<QueryDsl>;
+export {};

package/dist/esm/Graph/Operations/Matchers/NodeQuery/QuerySchema.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+const PredicateObject = z.object({
+    eq: z.unknown().optional(),
+    in: z.array(z.unknown()).optional(),
+    contains: z.string().optional(),
+    startsWith: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
+    endsWith: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
+    exists: z.boolean().optional(),
+});
+const refinePredicate = (value) => {
+    const ops = [
+        value.eq !== undefined,
+        value.in !== undefined,
+        value.contains !== undefined,
+        value.startsWith !== undefined,
+        value.endsWith !== undefined,
+        value.exists !== undefined,
+    ].filter(Boolean);
+    return ops.length === 1;
+};
+const PredicateSchema = PredicateObject.refine(refinePredicate, {
+    message: 'predicate must specify exactly one of: eq | in | contains | startsWith | endsWith | exists',
+});
+const AttrPredicateObject = PredicateObject.extend({
+    key: z.string().min(1),
+});
+export const AttrPredicateSchema = AttrPredicateObject.refine(refinePredicate, {
+    message: 'attr must specify exactly one of: eq | in | contains | startsWith | endsWith | exists',
+});
+export const NodeIdPredicateSchema = PredicateSchema;
+export const QuerySchema = z.lazy(() => z.union([
+    z.object({ any: z.literal(true) }),
+    z.object({ and: z.array(QuerySchema).min(1) }),
+    z.object({ or: z.array(QuerySchema).min(1) }),
+    z.object({ not: QuerySchema }),
+    z.object({ attr: AttrPredicateSchema }),
+    z.object({ nodeId: NodeIdPredicateSchema }),
+    z
+        .object({
+        children: z.object({
+            exists: z.boolean().optional(),
+            count: z.number().int().min(0).optional(),
+        }),
+    })
+        .refine((value) => {
+        const ops = [
+            value.children.exists !== undefined,
+            value.children.count !== undefined,
+        ].filter(Boolean);
+        return ops.length === 1;
+    }, {
+        message: 'children must define exactly one of: exists | count',
+    }),
+    z
+        .object({
+        edge: z.object({
+            in: QuerySchema.optional(),
+            out: QuerySchema.optional(),
+        }),
+    })
+        .refine((value) => value.edge.in || value.edge.out, {
+        message: 'edge must define at least one of: in | out',
+    }),
+]));

package/dist/esm/Graph/Operations/Matchers/NodeQuery/QuerySchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/Graph/Operations/Matchers/NodeQuery/QuerySchema.test.js

@@ -0,0 +1,49 @@
+import { QuerySchema } from './QuerySchema.js';
+describe('QuerySchema', () => {
+    it('shoud parse valid query definitions', () => {
+        const valid = QuerySchema.parse({
+            and: [
+                { any: true },
+                {
+                    or: [
+                        { nodeId: { startsWith: 'resource.' } },
+                        { children: { count: 1 } },
+                    ],
+                },
+            ],
+        });
+        expect(valid).toEqual({
+            and: [
+                { any: true },
+                {
+                    or: [
+                        { nodeId: { startsWith: 'resource.' } },
+                        { children: { count: 1 } },
+                    ],
+                },
+            ],
+        });
+    });
+    it('shoud reject predicates that define multiple operations', () => {
+        expect(() => QuerySchema.parse({
+            attr: {
+                key: 'label',
+                eq: 'a',
+                in: ['a', 'b'],
+            },
+        })).toThrow('attr must specify exactly one of: eq | in | contains | startsWith | endsWith | exists');
+    });
+    it('shoud reject child predicate definitions that define no operation', () => {
+        expect(() => QuerySchema.parse({
+            children: {
+                exists: true,
+                count: 1,
+            },
+        })).toThrow('children must define exactly one of: exists | count');
+    });
+    it('shoud reject edge predicates with no in/out matcher', () => {
+        expect(() => QuerySchema.parse({
+            edge: {},
+        })).toThrow('edge must define at least one of: in | out');
+    });
+});

package/dist/esm/Graph/Operations/Matchers/NodeQuery/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NodeQuery.js';
+export * from './QuerySchema.js';

package/dist/esm/Graph/Operations/Matchers/NodeQuery/index.js

@@ -0,0 +1,2 @@
+export * from './NodeQuery.js';
+export * from './QuerySchema.js';

package/dist/esm/Graph/Operations/Matchers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NodeMatchFn.js';
+export * from './NodeQuery/index.js';

package/dist/esm/Graph/Operations/Matchers/index.js

@@ -0,0 +1,2 @@
+export * from './NodeMatchFn.js';
+export * from './NodeQuery/index.js';

package/dist/esm/Graph/Operations/Operations.d.ts

@@ -0,0 +1,21 @@
+import type { Adapter } from '../Adapter.js';
+import type { EdgeId, NodeId, TgEdgeAttributes, TgNodeAttributes } from '../TgGraph.js';
+export interface Operations {
+    getNodeAttributes(nodeId: NodeId): TgNodeAttributes | undefined;
+    getEdgeAttributes(edgeId: EdgeId): TgEdgeAttributes;
+    edgeSource(edgeId: EdgeId): NodeId;
+    edgeTarget(edgeId: EdgeId): NodeId;
+    nodeIds(): NodeId[];
+    neighbors(nodeId: NodeId): NodeId[];
+    predecessors(nodeId: NodeId): NodeId[];
+    successors(nodeId: NodeId): NodeId[];
+    inEdges(nodeId: NodeId): EdgeId[];
+    outEdges(nodeId: NodeId): EdgeId[];
+    edgesBetween(source: NodeId, target: NodeId): EdgeId[];
+    setNodeAttributes(nodeId: NodeId, attributes: TgNodeAttributes): this;
+    setEdge(edgeId: EdgeId, source: NodeId, target: NodeId, attributes: TgEdgeAttributes): this;
+    removeNode(nodeId: NodeId): this;
+    removeEdge(edgeId: EdgeId): this;
+}
+export type AdapterOperations = Adapter & Operations;
+export type AdapterOperationsConstructor = new (...args: any[]) => AdapterOperations;

package/dist/esm/Graph/Operations/Operations.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/Graph/Operations/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Operations.js';
+export * from './Matchers/index.js';

package/dist/esm/Graph/Operations/index.js

@@ -0,0 +1,2 @@
+export * from './Operations.js';
+export * from './Matchers/index.js';

package/dist/esm/Graph/Profile.d.ts

@@ -0,0 +1,55 @@
+import { GraphPluginRef, GraphPluginRegistry, SerializedGraphPluginRef } from './GraphPlugin.js';
+import { AdapterOperationsConstructor } from './Operations/Operations.js';
+import { NamedRuleRegistry } from './Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from './Rules/NamedRuleSetRegistry.js';
+import { BaseRule } from './Rules/Rule.js';
+import { PhasePlan, SerializedPhasePlan } from './Rules/RulePlan.js';
+import { SupportedAdapterOperationsRegistry } from './Serialization/Registry.js';
+export type ProfileRenderConfig<TOptions = Record<string, unknown>> = {
+    renderer?: string;
+    options?: TOptions;
+};
+export type SerializedProfile<TOptions = Record<string, unknown>> = {
+    name: string;
+    supports?: string;
+    render?: ProfileRenderConfig<TOptions>;
+    phases?: SerializedPhasePlan;
+    plugins?: SerializedGraphPluginRef[];
+    usesProfiles?: SerializedProfile<TOptions>[];
+};
+export type ProfileOptions<TOptions = Record<string, unknown>> = {
+    supports?: AdapterOperationsConstructor;
+    render?: ProfileRenderConfig<TOptions>;
+    phases?: PhasePlan;
+    plugins?: GraphPluginRef[];
+    usesProfiles?: Profile<TOptions>[];
+};
+export declare class Profile<TOptions = Record<string, unknown>> {
+    readonly name: string;
+    readonly supports?: AdapterOperationsConstructor;
+    private readonly render?;
+    private readonly phases;
+    private readonly plugins;
+    private readonly usesProfiles;
+    constructor(name: string, options: ProfileOptions<TOptions>);
+    use(profile: Profile<TOptions>): Profile<TOptions>;
+    addPhases(phases: PhasePlan): Profile<TOptions>;
+    usePlugin(plugin: string, options?: unknown): Profile<TOptions>;
+    resolvePhases(namedRules?: NamedRuleRegistry, namedRuleSets?: NamedRuleSetRegistry, pluginRegistry?: GraphPluginRegistry): BaseRule[][];
+    serialize(): SerializedProfile<TOptions>;
+    static deseriaize<TOptions = Record<string, unknown>>(json: SerializedProfile<TOptions>, supportedAdpaterOperationsRegistry?: SupportedAdapterOperationsRegistry): Profile<TOptions>;
+    resolveRendererOptions(): TOptions | undefined;
+    resolveRenderer(): string | undefined;
+    private assertCompatibleSupportedAdapterOperations;
+    private collectProfiles;
+    private resolvePhaseEntries;
+    private resolveOwnPhaseEntries;
+    private resolvePhasePlan;
+    private orderPhaseEntries;
+    private resolveOwnPlugins;
+    private resolveRule;
+    private static isRuleInstance;
+    private serializePhases;
+    private static deserializePhases;
+    private static deserializeRule;
+}