@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,8 @@
+export * from './Rule.js';
+export * from './RuleConfig.js';
+export * from './RulePlan.js';
+export * from './RuleSet.js';
+export * from './NamedRuleRegistry.js';
+export * from './NamedRuleSetRegistry.js';
+export * from './Node/index.js';
+export * from './Edge/index.js';

package/dist/cjs/Graph/Rules/index.js

@@ -0,0 +1,24 @@
+"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("./Rule.js"), exports);
+__exportStar(require("./RuleConfig.js"), exports);
+__exportStar(require("./RulePlan.js"), exports);
+__exportStar(require("./RuleSet.js"), exports);
+__exportStar(require("./NamedRuleRegistry.js"), exports);
+__exportStar(require("./NamedRuleSetRegistry.js"), exports);
+__exportStar(require("./Node/index.js"), exports);
+__exportStar(require("./Edge/index.js"), exports);

package/dist/cjs/Graph/Rules/registerAll.d.ts

@@ -0,0 +1,14 @@
+import './Node/ConvertNodeToEdge.js';
+import './Node/NodeDotProperties.js';
+import './Node/NodeProperties.js';
+import './Node/RemoveLeafChain.js';
+import './Node/RemoveNode.js';
+import './Node/RemoveNodeAndReconnectEdges.js';
+import './Edge/AlignNodes.js';
+import './Edge/EdgeDirectionSemantic.js';
+import './Edge/EdgeDotProperties.js';
+import './Edge/EdgeLegend.js';
+import './Edge/EdgeReverse.js';
+import './Edge/EdgeSemanticLegend.js';
+import './Edge/ExplicitEdge.js';
+import './Edge/RemoveEdge.js';

package/dist/cjs/Graph/Rules/registerAll.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./Node/ConvertNodeToEdge.js");
+require("./Node/NodeDotProperties.js");
+require("./Node/NodeProperties.js");
+require("./Node/RemoveLeafChain.js");
+require("./Node/RemoveNode.js");
+require("./Node/RemoveNodeAndReconnectEdges.js");
+require("./Edge/AlignNodes.js");
+require("./Edge/EdgeDirectionSemantic.js");
+require("./Edge/EdgeDotProperties.js");
+require("./Edge/EdgeLegend.js");
+require("./Edge/EdgeReverse.js");
+require("./Edge/EdgeSemanticLegend.js");
+require("./Edge/ExplicitEdge.js");
+require("./Edge/RemoveEdge.js");

package/dist/cjs/Graph/Serialization/Registry.d.ts

@@ -0,0 +1,5 @@
+import { AdapterOperationsConstructor } from '../Operations/Operations.js';
+import { BaseRule } from '../Rules/Rule.js';
+import { SerializedRule } from '../Rules/RuleConfig.js';
+export type RuleRegistry = Record<string, (config: SerializedRule['config']) => BaseRule>;
+export type SupportedAdapterOperationsRegistry = Record<string, AdapterOperationsConstructor>;

package/dist/cjs/Graph/Serialization/Registry.js

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

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

@@ -0,0 +1 @@
+export * from './Registry.js';

package/dist/cjs/Graph/Serialization/index.js

@@ -0,0 +1,17 @@
+"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("./Registry.js"), exports);

package/dist/cjs/Graph/TgGraph.d.ts

@@ -0,0 +1,82 @@
+export type NodeId = string & {
+    readonly __brand: 'NodeId';
+};
+export type EdgeId = string & {
+    readonly __brand: 'EdgeId';
+};
+export declare const TG_ID_NAMESPACE = "tg";
+export declare const TG_SCHEMA_VERSION = "1.0.0";
+export type TgNodeKind = 'resource' | 'data' | 'local' | 'var' | 'output' | 'module' | 'provider' | 'root' | 'meta' | 'terraform';
+export type ParsedTgNodeId = {
+    namespace: string;
+    version: string;
+    kind: string;
+    address: string;
+};
+export type TgEdgeLegendAttribute = {
+    title: string;
+    colour: string;
+};
+export type TgEdgeRenderHints = {
+    resource: string;
+    name: string;
+};
+export declare const TgEdgeDirectionSemantics: {
+    readonly Invokes: "invokes";
+    readonly Accesses: "accesses";
+    readonly Publishes: "publishes";
+    readonly Triggers: "triggers";
+    readonly Routes: "routes";
+    readonly Authorizes: "authorizes";
+    readonly ObservedBy: "observedBy";
+};
+export type TgEdgeDirectionSemantic = (typeof TgEdgeDirectionSemantics)[keyof typeof TgEdgeDirectionSemantics];
+export declare const TG_EDGE_DIRECTION_SEMANTICS: readonly TgEdgeDirectionSemantic[];
+export declare const isTgEdgeDirectionSemantic: (value: unknown) => value is TgEdgeDirectionSemantic;
+export interface TgEdgeAttributes extends Record<string, unknown> {
+    directionSemantic?: TgEdgeDirectionSemantic;
+    legend?: TgEdgeLegendAttribute;
+    renderHints?: TgEdgeRenderHints;
+    adapter?: Record<string, Record<string, unknown>>;
+}
+export type TgEdge = {
+    id: EdgeId;
+    from: NodeId;
+    to: NodeId;
+    attributes?: TgEdgeAttributes;
+};
+export type TgNodeTerraform = {
+    kind?: TgNodeKind;
+    address?: string;
+    resource?: string;
+    name?: string;
+    moduleAddress?: string;
+    parentModuleName?: string;
+    parentModuleNodeId?: NodeId;
+};
+export type TgNodeLabelHints = {
+    end?: string;
+};
+export type TgNodeHints = {
+    label?: TgNodeLabelHints;
+};
+export type TgNodeAttributes = {
+    terraform?: TgNodeTerraform;
+    hints?: TgNodeHints;
+    adapter?: Record<string, Record<string, unknown>>;
+    [key: string]: unknown;
+};
+export type TgNode = {
+    id: NodeId;
+} & TgNodeAttributes;
+export type TgGraph = {
+    schemaVersion: string;
+    nodes: Record<string, TgNode>;
+    edges: TgEdge[];
+    description: Record<string, string>;
+};
+export declare const edgeIdFrom: (from: NodeId, to: NodeId, suffix?: string, version?: string) => EdgeId;
+export declare const tgNodeIdFrom: (kind: TgNodeKind, address: string, version?: string) => NodeId;
+export declare const parseTgNodeId: (value: NodeId | string) => ParsedTgNodeId | undefined;
+export declare const asNodeId: (value: string) => NodeId;
+export declare const asEdgeId: (value: string) => EdgeId;

package/dist/cjs/Graph/TgGraph.js

@@ -0,0 +1,55 @@
+"use strict";
+// this is DOT / graphviz specific?
+// export type TgGraphMeta = {
+//   directed: boolean;
+//   multigraph: boolean;
+//   compound: boolean;
+// };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asEdgeId = exports.asNodeId = exports.parseTgNodeId = exports.tgNodeIdFrom = exports.edgeIdFrom = exports.isTgEdgeDirectionSemantic = exports.TG_EDGE_DIRECTION_SEMANTICS = exports.TgEdgeDirectionSemantics = exports.TG_SCHEMA_VERSION = exports.TG_ID_NAMESPACE = void 0;
+exports.TG_ID_NAMESPACE = 'tg';
+exports.TG_SCHEMA_VERSION = '1.0.0';
+exports.TgEdgeDirectionSemantics = {
+    Invokes: 'invokes',
+    Accesses: 'accesses',
+    Publishes: 'publishes',
+    Triggers: 'triggers',
+    Routes: 'routes',
+    Authorizes: 'authorizes',
+    ObservedBy: 'observedBy',
+};
+exports.TG_EDGE_DIRECTION_SEMANTICS = Object.freeze(Object.values(exports.TgEdgeDirectionSemantics));
+const isTgEdgeDirectionSemantic = (value) => {
+    return (typeof value === 'string' &&
+        exports.TG_EDGE_DIRECTION_SEMANTICS.includes(value));
+};
+exports.isTgEdgeDirectionSemantic = isTgEdgeDirectionSemantic;
+const edgeIdFrom = (from, to, suffix, version = exports.TG_SCHEMA_VERSION) => {
+    const base = `${exports.TG_ID_NAMESPACE}:${version}:edge:${from}->${to}`;
+    return (suffix ? `${base}:${suffix}` : base);
+};
+exports.edgeIdFrom = edgeIdFrom;
+const tgNodeIdFrom = (kind, address, version = exports.TG_SCHEMA_VERSION) => `${exports.TG_ID_NAMESPACE}:${version}:${kind}:${address}`;
+exports.tgNodeIdFrom = tgNodeIdFrom;
+const parseTgNodeId = (value) => {
+    const nodeId = String(value);
+    const parts = nodeId.split(':');
+    if (parts.length < 4) {
+        return undefined;
+    }
+    const [namespace, version, kind, ...addressParts] = parts;
+    if (namespace !== exports.TG_ID_NAMESPACE || addressParts.length === 0) {
+        return undefined;
+    }
+    return {
+        namespace,
+        version,
+        kind,
+        address: addressParts.join(':'),
+    };
+};
+exports.parseTgNodeId = parseTgNodeId;
+const asNodeId = (value) => value;
+exports.asNodeId = asNodeId;
+const asEdgeId = (value) => value;
+exports.asEdgeId = asEdgeId;

package/dist/cjs/Graph/TgGraph.test.d.ts

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

package/dist/cjs/Graph/TgGraph.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TgGraph_js_1 = require("./TgGraph.js");
+describe('TgGraph.edgeIdFrom', () => {
+    it('should create expected id without suffix', () => {
+        expect((0, TgGraph_js_1.edgeIdFrom)((0, TgGraph_js_1.asNodeId)('from'), (0, TgGraph_js_1.asNodeId)('to'))).toStrictEqual(`tg:${TgGraph_js_1.TG_SCHEMA_VERSION}:edge:from->to`);
+    });
+    it('should create expected id with suffix', () => {
+        expect((0, TgGraph_js_1.edgeIdFrom)((0, TgGraph_js_1.asNodeId)('from'), (0, TgGraph_js_1.asNodeId)('to'), 'suffix')).toStrictEqual(`tg:${TgGraph_js_1.TG_SCHEMA_VERSION}:edge:from->to:suffix`);
+    });
+});
+describe('TgGraph.tgNodeIdFrom', () => {
+    it('should create expected namespaced id', () => {
+        expect((0, TgGraph_js_1.tgNodeIdFrom)('resource', 'aws_s3_bucket.example')).toStrictEqual(`tg:${TgGraph_js_1.TG_SCHEMA_VERSION}:resource:aws_s3_bucket.example`);
+    });
+});
+describe('TgGraph.parseTgNodeId', () => {
+    it('should parse namespaced ids', () => {
+        expect((0, TgGraph_js_1.parseTgNodeId)(`tg:${TgGraph_js_1.TG_SCHEMA_VERSION}:resource:aws_s3_bucket.example`)).toStrictEqual({
+            namespace: 'tg',
+            version: TgGraph_js_1.TG_SCHEMA_VERSION,
+            kind: 'resource',
+            address: 'aws_s3_bucket.example',
+        });
+    });
+    it('should return undefined for invalid namespaces or missing addresses', () => {
+        expect((0, TgGraph_js_1.parseTgNodeId)('not-tg:1.0.0:resource:one')).toBeUndefined();
+        expect((0, TgGraph_js_1.parseTgNodeId)(`tg:${TgGraph_js_1.TG_SCHEMA_VERSION}:resource`)).toBeUndefined();
+    });
+});
+describe('TgGraph.asNodeId', () => {
+    it('should return the same string value, branded as a NodeId', () => {
+        const id = (0, TgGraph_js_1.asNodeId)('node-1');
+        expect(id).toBe('node-1');
+        const _assert = id;
+    });
+});
+describe('TgGraph.asEdgeId', () => {
+    it('should return the same string value, branded as an EdgeId', () => {
+        const id = (0, TgGraph_js_1.asEdgeId)('edge-1');
+        expect(id).toBe('edge-1');
+        const _assert = id;
+    });
+});
+describe('TgGraph.TgEdgeDirectionSemantic', () => {
+    it('should include expected direction semantic values', () => {
+        expect(TgGraph_js_1.TG_EDGE_DIRECTION_SEMANTICS).toStrictEqual([
+            'invokes',
+            'accesses',
+            'publishes',
+            'triggers',
+            'routes',
+            'authorizes',
+            'observedBy',
+        ]);
+    });
+    it('should validate direction semantic values', () => {
+        expect((0, TgGraph_js_1.isTgEdgeDirectionSemantic)('invokes')).toBe(true);
+        expect((0, TgGraph_js_1.isTgEdgeDirectionSemantic)('unknown')).toBe(false);
+    });
+});

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

@@ -0,0 +1,15 @@
+export * from './Adapter.js';
+export * from './Importer.js';
+export * from './Renderer.js';
+export * from './TgGraph.js';
+export * from './RuleError.js';
+export * from './GraphResolver.js';
+export * from './GraphPlugin.js';
+export * from './Profile.js';
+export * from './ProfileRegistry.js';
+export * from './Adapters/index.js';
+export * from './Importers/index.js';
+export * from './Operations/index.js';
+export * from './Renderers/index.js';
+export * from './Rules/index.js';
+export * from './Serialization/index.js';

package/dist/cjs/Graph/index.js

@@ -0,0 +1,31 @@
+"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("./Adapter.js"), exports);
+__exportStar(require("./Importer.js"), exports);
+__exportStar(require("./Renderer.js"), exports);
+__exportStar(require("./TgGraph.js"), exports);
+__exportStar(require("./RuleError.js"), exports);
+__exportStar(require("./GraphResolver.js"), exports);
+__exportStar(require("./GraphPlugin.js"), exports);
+__exportStar(require("./Profile.js"), exports);
+__exportStar(require("./ProfileRegistry.js"), exports);
+__exportStar(require("./Adapters/index.js"), exports);
+__exportStar(require("./Importers/index.js"), exports);
+__exportStar(require("./Operations/index.js"), exports);
+__exportStar(require("./Renderers/index.js"), exports);
+__exportStar(require("./Rules/index.js"), exports);
+__exportStar(require("./Serialization/index.js"), exports);

package/dist/cjs/Output/ArtifactTransformer/DotCliArtifactTransformer.d.ts

@@ -0,0 +1,25 @@
+import { RenderArtifact } from '../../Graph/Renderer.js';
+import { ArtifactTransformInput, ArtifactTransformer } from '../ArtifactTransformer.js';
+export type DotCliRunProcessInput = {
+    executable: string;
+    args: string[];
+    stdin: string;
+};
+export type DotCliRunProcess = (input: DotCliRunProcessInput) => Promise<Uint8Array>;
+export type DotCliArtifactTransformerOptions = {
+    format: string;
+    executable?: string;
+    dotArgs?: string[];
+    runProcess?: DotCliRunProcess;
+};
+export declare class DotCliArtifactTransformer implements ArtifactTransformer {
+    private readonly options;
+    private readonly executable;
+    private readonly runProcess;
+    constructor(options: DotCliArtifactTransformerOptions);
+    transform(input: ArtifactTransformInput): Promise<RenderArtifact>;
+    private isDotArtifact;
+    private toUtf8;
+    private static resolveMediaType;
+    private readonly defaultRunProcess;
+}

package/dist/cjs/Output/ArtifactTransformer/DotCliArtifactTransformer.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DotCliArtifactTransformer = void 0;
+const node_child_process_1 = require("node:child_process");
+const dotMediaTypeByFormat = {
+    dot: 'text/vnd.graphviz',
+    json: 'application/json',
+    pdf: 'application/pdf',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+};
+class DotCliArtifactTransformer {
+    options;
+    executable;
+    runProcess;
+    constructor(options) {
+        this.options = options;
+        this.executable = options.executable ?? 'dot';
+        this.runProcess = options.runProcess ?? this.defaultRunProcess;
+    }
+    async transform(input) {
+        if (!this.isDotArtifact(input.artifact)) {
+            throw new Error("DotCliArtifactTransformer can only transform DOT artifacts ('text/vnd.graphviz' or extension 'dot')");
+        }
+        const args = [`-T${this.options.format}`, ...(this.options.dotArgs ?? [])];
+        const stdin = this.toUtf8(input.artifact.content);
+        let content;
+        try {
+            content = await this.runProcess({
+                executable: this.executable,
+                args,
+                stdin,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`DotCliArtifactTransformer failed for format '${this.options.format}': ${message}`);
+        }
+        return {
+            content,
+            mediaType: DotCliArtifactTransformer.resolveMediaType(this.options.format),
+            extension: this.options.format,
+        };
+    }
+    isDotArtifact(artifact) {
+        return (artifact.mediaType === 'text/vnd.graphviz' || artifact.extension === 'dot');
+    }
+    toUtf8(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return Buffer.from(content).toString('utf8');
+    }
+    static resolveMediaType(format) {
+        return dotMediaTypeByFormat[format] ?? 'application/octet-stream';
+    }
+    defaultRunProcess = async (input) => {
+        return await new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.spawn)(input.executable, input.args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            child.stdout.on('data', (chunk) => {
+                stdoutChunks.push(chunk);
+            });
+            child.stderr.on('data', (chunk) => {
+                stderrChunks.push(chunk);
+            });
+            child.on('error', (error) => {
+                reject(error);
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(Buffer.concat(stdoutChunks));
+                    return;
+                }
+                const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+                const output = stderr ? `: ${stderr}` : '';
+                reject(new Error(`dot exited with code ${String(code)}${output}`));
+            });
+            child.stdin.end(input.stdin);
+        });
+    };
+}
+exports.DotCliArtifactTransformer = DotCliArtifactTransformer;

package/dist/cjs/Output/ArtifactTransformer/DotCliArtifactTransformer.test.d.ts

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

package/dist/cjs/Output/ArtifactTransformer/DotCliArtifactTransformer.test.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const DotCliArtifactTransformer_js_1 = require("./DotCliArtifactTransformer.js");
+const spawnMock = jest.fn();
+jest.mock('node:child_process', () => ({
+    spawn: (...args) => spawnMock(...args),
+}));
+const buildChild = () => {
+    const child = new node_events_1.EventEmitter();
+    child.stdout = new node_events_1.EventEmitter();
+    child.stderr = new node_events_1.EventEmitter();
+    child.stdin = { end: jest.fn() };
+    return child;
+};
+describe('DotCliArtifactTransformer.transform', () => {
+    beforeEach(() => {
+        spawnMock.mockReset();
+    });
+    it('shoud transform dot text to the requested format', async () => {
+        const calls = [];
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'png',
+            dotArgs: ['-Gdpi=200'],
+            runProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([1, 2, 3]);
+            },
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(calls).toHaveLength(1);
+        expect(calls[0]).toEqual({
+            executable: 'dot',
+            args: ['-Tpng', '-Gdpi=200'],
+            stdin: 'digraph G {}',
+        });
+        expect(artifact.mediaType).toBe('image/png');
+        expect(artifact.extension).toBe('png');
+        expect(Buffer.from(artifact.content)).toEqual(Buffer.from([1, 2, 3]));
+    });
+    it('shoud reject artifacts that are not dot', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => Buffer.from([]),
+        });
+        const input = {
+            content: '{"ok":true}',
+            mediaType: 'application/json',
+            extension: 'json',
+        };
+        await expect(transformer.transform({
+            artifact: input,
+        })).rejects.toThrow("DotCliArtifactTransformer can only transform DOT artifacts ('text/vnd.graphviz' or extension 'dot')");
+    });
+    it('shoud add context when dot process execution fails', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => {
+                throw new Error('boom');
+            },
+        });
+        await expect(transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        })).rejects.toThrow("DotCliArtifactTransformer failed for format 'svg': boom");
+    });
+    it('shoud accept dot artifacts by extension and decode binary content', async () => {
+        const calls = [];
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([9, 8, 7]);
+            },
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: Buffer.from('digraph G {}'),
+                mediaType: 'text/plain',
+                extension: 'dot',
+            },
+        });
+        expect(calls[0]).toEqual({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        });
+        expect(artifact.mediaType).toBe('image/svg+xml');
+    });
+    it('shoud add context when dot process throws a non-error value', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => {
+                throw 'boom';
+            },
+        });
+        await expect(transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        })).rejects.toThrow("DotCliArtifactTransformer failed for format 'svg': boom");
+    });
+    it('shoud fall back to octet-stream when format is unknown', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format: 'eps',
+            runProcess: async () => Buffer.from([1, 2]),
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(artifact.mediaType).toBe('application/octet-stream');
+    });
+});
+describe('DotCliArtifactTransformer.defaultRunProcess', () => {
+    beforeEach(() => {
+        spawnMock.mockReset();
+    });
+    it('shoud resolve stdout when the process succeeds', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.stdout.emit('data', Buffer.from('ok'));
+                child.emit('close', 0);
+            });
+            return child;
+        });
+        const output = await runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        });
+        expect(Buffer.from(output).toString('utf8')).toBe('ok');
+    });
+    it('shoud reject with stderr when the process exits non-zero', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.stderr.emit('data', Buffer.from('failure'));
+                child.emit('close', 2);
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('dot exited with code 2: failure');
+    });
+    it('shoud include no stderr output when the process exits non-zero', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.emit('close', 3);
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('dot exited with code 3');
+    });
+    it('shoud reject when the process emits an error', async () => {
+        const transformer = new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.emit('error', new Error('spawn failed'));
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('spawn failed');
+    });
+});

package/dist/cjs/Output/ArtifactTransformer/index.d.ts

@@ -0,0 +1 @@
+export * from './DotCliArtifactTransformer.js';