@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_mock_extended_1 = require("jest-mock-extended");
+const TgGraph_js_1 = require("../../../TgGraph.js");
+const NodeQuery_js_1 = require("./NodeQuery.js");
+describe('NodeQuery.match', () => {
+    it('shoud return true for any node when using any', () => {
+        const query = NodeQuery_js_1.NodeQuery.from({ any: true });
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.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 = (0, TgGraph_js_1.asNodeId)('cluster_module.a');
+        const query = NodeQuery_js_1.NodeQuery.from({
+            and: [
+                { nodeId: { startsWith: 'cluster_module' } },
+                { children: { exists: false } },
+            ],
+        });
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.successors.mockReturnValue([(0, TgGraph_js_1.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 = (0, TgGraph_js_1.asNodeId)('cluster_module.a');
+        const query = NodeQuery_js_1.NodeQuery.from({
+            and: [
+                { nodeId: { startsWith: 'cluster_module' } },
+                { children: { count: 2 } },
+            ],
+        });
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.successors.mockReturnValue([
+            (0, TgGraph_js_1.asNodeId)('module.a.resource.one'),
+            (0, TgGraph_js_1.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 = (0, TgGraph_js_1.asNodeId)('alpha');
+        const query = NodeQuery_js_1.NodeQuery.from({ children: { exists: true } });
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.successors.mockReturnValue([(0, TgGraph_js_1.asNodeId)('beta')]);
+        expect(query.match(sourceId, { label: 'random.node' }, graph)).toBe(true);
+    });
+    it('shoud support OR and NOT predicates together', () => {
+        const sourceId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const graph = (0, jest_mock_extended_1.mock)();
+        const query = NodeQuery_js_1.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((0, TgGraph_js_1.asNodeId)('node-b'), { label: 'node-b' }, graph)).toBe(false);
+    });
+    it('shoud support inbound edge predicates', () => {
+        const sourceId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const targetId = (0, TgGraph_js_1.asNodeId)('node-b');
+        const sourceEdge = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const graph = (0, jest_mock_extended_1.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_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const targetId = (0, TgGraph_js_1.asNodeId)('node-b');
+        const sourceEdge = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.inEdges.mockReturnValue([sourceEdge]);
+        graph.edgeSource.mockReturnValue(sourceId);
+        graph.getNodeAttributes.mockReturnValue(undefined);
+        const query = NodeQuery_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const targetId = (0, TgGraph_js_1.asNodeId)('node-b');
+        const sourceEdge = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.outEdges.mockReturnValue([sourceEdge]);
+        graph.edgeTarget.mockReturnValue(targetId);
+        graph.getNodeAttributes.mockReturnValue(undefined);
+        const query = NodeQuery_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const targetId = (0, TgGraph_js_1.asNodeId)('node-b');
+        const sourceEdge = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const graph = (0, jest_mock_extended_1.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_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const targetId = (0, TgGraph_js_1.asNodeId)('node-b');
+        const sourceEdge = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const graph = (0, jest_mock_extended_1.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_js_1.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 = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const node = {
+            meta: {
+                kind: 'resource',
+                name: 'alpha.beta',
+                status: 'ready',
+            },
+        };
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.kind', in: ['resource', 'other'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.name', contains: 'beta' },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.name', startsWith: ['nope', 'alpha'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.name', endsWith: ['beta', 'zzz'] },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.missing', exists: false },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.kind', exists: true },
+        }).match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud support string startsWith and endsWith predicates', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const node = {
+            meta: {
+                name: 'alpha.beta',
+            },
+        };
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.name', startsWith: 'alpha' },
+        }).match(nodeId, node, graph)).toBe(true);
+        expect(NodeQuery_js_1.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 = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const node = {
+            meta: {},
+        };
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.missing', contains: 'beta' },
+        }).match(nodeId, node, graph)).toBe(false);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.missing', startsWith: 'alpha' },
+        }).match(nodeId, node, graph)).toBe(false);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.missing', endsWith: 'beta' },
+        }).match(nodeId, node, graph)).toBe(false);
+    });
+    it('shoud return false for invalid children predicates', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        graph.successors.mockReturnValue([]);
+        const query = new NodeQuery_js_1.NodeQuery({ children: {} });
+        expect(query.match((0, TgGraph_js_1.asNodeId)('node-a'), { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud treat non-object path segments as missing', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const node = {
+            meta: {
+                name: 'alpha',
+            },
+        };
+        expect(NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.name.value', exists: false },
+        }).match(nodeId, node, graph)).toBe(true);
+    });
+    it('shoud match nodeId predicates beyond equality', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        expect(NodeQuery_js_1.NodeQuery.from({
+            nodeId: { in: ['node-a', 'node-b'] },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            nodeId: { contains: 'ode-' },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+        expect(NodeQuery_js_1.NodeQuery.from({
+            nodeId: { endsWith: 'a' },
+        }).match(nodeId, { label: 'node-a' }, graph)).toBe(true);
+    });
+    it('shoud return false for unsupported dsl entries', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        const query = new NodeQuery_js_1.NodeQuery({});
+        expect(query.match((0, TgGraph_js_1.asNodeId)('node-a'), { label: 'node-a' }, graph)).toBe(false);
+    });
+    it('shoud treat empty attribute paths as undefined', () => {
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const query = new NodeQuery_js_1.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 = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const query = new NodeQuery_js_1.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_js_1.NodeQuery.fromJson({ any: true });
+        const graph = (0, jest_mock_extended_1.mock)();
+        expect(query.match((0, TgGraph_js_1.asNodeId)('node-any'), { label: 'anything' }, graph)).toBe(true);
+    });
+});
+describe('NodeQuery.getDsl', () => {
+    it('shoud return the parsed dsl', () => {
+        const input = { any: true };
+        const query = NodeQuery_js_1.NodeQuery.from(input);
+        expect(query.getDsl()).toEqual(input);
+    });
+});
+describe('NodeQuery.toMatcher', () => {
+    it('shoud expose a matcher function', () => {
+        const query = NodeQuery_js_1.NodeQuery.from({
+            attr: { key: 'meta.kind', eq: 'resource' },
+        });
+        const matcher = query.toMatcher();
+        const graph = (0, jest_mock_extended_1.mock)();
+        expect(matcher((0, TgGraph_js_1.asNodeId)('node-a'), { meta: { kind: 'resource' } }, graph)).toBe(true);
+    });
+});

package/dist/cjs/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/cjs/Graph/Operations/Matchers/NodeQuery/QuerySchema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySchema = exports.NodeIdPredicateSchema = exports.AttrPredicateSchema = void 0;
+const zod_1 = require("zod");
+const PredicateObject = zod_1.z.object({
+    eq: zod_1.z.unknown().optional(),
+    in: zod_1.z.array(zod_1.z.unknown()).optional(),
+    contains: zod_1.z.string().optional(),
+    startsWith: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()).min(1)]).optional(),
+    endsWith: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()).min(1)]).optional(),
+    exists: zod_1.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: zod_1.z.string().min(1),
+});
+exports.AttrPredicateSchema = AttrPredicateObject.refine(refinePredicate, {
+    message: 'attr must specify exactly one of: eq | in | contains | startsWith | endsWith | exists',
+});
+exports.NodeIdPredicateSchema = PredicateSchema;
+exports.QuerySchema = zod_1.z.lazy(() => zod_1.z.union([
+    zod_1.z.object({ any: zod_1.z.literal(true) }),
+    zod_1.z.object({ and: zod_1.z.array(exports.QuerySchema).min(1) }),
+    zod_1.z.object({ or: zod_1.z.array(exports.QuerySchema).min(1) }),
+    zod_1.z.object({ not: exports.QuerySchema }),
+    zod_1.z.object({ attr: exports.AttrPredicateSchema }),
+    zod_1.z.object({ nodeId: exports.NodeIdPredicateSchema }),
+    zod_1.z
+        .object({
+        children: zod_1.z.object({
+            exists: zod_1.z.boolean().optional(),
+            count: zod_1.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',
+    }),
+    zod_1.z
+        .object({
+        edge: zod_1.z.object({
+            in: exports.QuerySchema.optional(),
+            out: exports.QuerySchema.optional(),
+        }),
+    })
+        .refine((value) => value.edge.in || value.edge.out, {
+        message: 'edge must define at least one of: in | out',
+    }),
+]));

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const QuerySchema_js_1 = require("./QuerySchema.js");
+describe('QuerySchema', () => {
+    it('shoud parse valid query definitions', () => {
+        const valid = QuerySchema_js_1.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_js_1.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_js_1.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_js_1.QuerySchema.parse({
+            edge: {},
+        })).toThrow('edge must define at least one of: in | out');
+    });
+});

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./NodeQuery.js"), exports);
+__exportStar(require("./QuerySchema.js"), exports);

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./NodeMatchFn.js"), exports);
+__exportStar(require("./NodeQuery/index.js"), exports);

package/dist/cjs/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/cjs/Graph/Operations/Operations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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