jinaga-server 3.1.0 → 3.1.1

package/src/http/serializer.ts

@@ -1,81 +0,0 @@
-import { FactEnvelope, FactReference, PredecessorCollection } from "jinaga";
-
-type IndexPredecessorCollection = {
-    [role: string]: number | number[];
-};
-
-export class GraphSerializer
-{
-    private index = 0;
-    private indexByFactReference: { [key: string]: number } = {};
-    private publicKeys: string[] = [];
-
-    constructor(
-        private readonly write: (chunk: string) => void
-    ) {}
-
-    serialize(result: FactEnvelope[]) {
-        // Write the facts
-        for (const fact of result) {
-            // Skip facts that have already been written
-            const key = fact.fact.type + ":" + fact.fact.hash;
-            if (this.indexByFactReference.hasOwnProperty(key)) {
-                continue;
-            }
-
-            // Write any new public keys
-            for (const signature of fact.signatures) {
-                if (!this.publicKeys.includes(signature.publicKey)) {
-                    const pkIndex = this.publicKeys.length;
-                    const publicKey = JSON.stringify(signature.publicKey);
-                    this.write(`PK${pkIndex.toString()}\n${publicKey}\n\n`);
-                    this.publicKeys.push(signature.publicKey);
-                }
-            }
-
-            // Write the fact
-            const factType = JSON.stringify(fact.fact.type);
-            const predecessorIndexes = JSON.stringify(this.getPredecessorIndexes(fact.fact.predecessors));
-            const factFields = JSON.stringify(fact.fact.fields);
-
-            let output = `${factType}\n${predecessorIndexes}\n${factFields}`;
-
-            // Write the signatures
-            for (const signature of fact.signatures) {
-                const publicKeyIndex = this.publicKeys.indexOf(signature.publicKey);
-                const publicKey = `PK${publicKeyIndex.toString()}`;
-                const signatureString = JSON.stringify(signature.signature);
-
-                output += `\n${publicKey}\n${signatureString}`;
-            }
-
-            output += "\n\n";
-
-            this.write(output);
-
-            this.indexByFactReference[key] = this.index;
-            this.index++;
-        }
-    }
-
-    private getPredecessorIndexes(predecessors: PredecessorCollection): IndexPredecessorCollection {
-        const result: IndexPredecessorCollection = {};
-        for (const role in predecessors) {
-            const reference = predecessors[role];
-            if (Array.isArray(reference)) {
-                result[role] = reference.map(r => this.getFactIndex(r));
-            } else {
-                result[role] = this.getFactIndex(reference);
-            }
-        }
-        return result;
-    }
-
-    private getFactIndex(reference: FactReference): number {
-        const key = reference.type + ":" + reference.hash;
-        if (!this.indexByFactReference.hasOwnProperty(key)) {
-            throw new Error(`Fact reference not found in graph: ${key}`);
-        }
-        return this.indexByFactReference[key];
-    }
-}

package/test/http/serializerSpec.ts

@@ -1,140 +0,0 @@
-import { GraphSerializer } from "../../src/http/serializer";
-
-describe("GraphSerializer", () => {
-    it("should write an empty graph", () => {
-        let output = "";
-        const serializer = new GraphSerializer(chunk => {
-            output += chunk;
-        });
-
-        serializer.serialize([]);
-
-        expect(output).toBe("");
-    });
-
-    it("should write a graph with one fact without signatures", () => {
-        let output = "";
-        const serializer = new GraphSerializer(chunk => {
-            output += chunk;
-        });
-
-        serializer.serialize([{
-            fact: {
-                type: "MyApp.Root",
-                hash: "roothash",
-                fields: {
-                    identifier: "root"
-                },
-                predecessors: {}
-            },
-            signatures: []
-        }]);
-
-        expect(output).toBe("\"MyApp.Root\"\n{}\n{\"identifier\":\"root\"}\n\n");
-    });
-
-    it("should write a graph with two facts without signatures", () => {
-        let output = "";
-        const serializer = new GraphSerializer(chunk => {
-            output += chunk;
-        });
-
-        serializer.serialize([{
-            fact: {
-                type: "MyApp.Root",
-                hash: "roothash",
-                fields: {},
-                predecessors: {}
-            },
-            signatures: []
-        }, {
-            fact: {
-                type: "MyApp.Child",
-                hash: "childhash",
-                fields: {},
-                predecessors: {
-                    root: {
-                        type: "MyApp.Root",
-                        hash: "roothash"
-                    }
-                }
-            },
-            signatures: []
-        }]);
-
-        expect(output).toBe("\"MyApp.Root\"\n{}\n{}\n\n\"MyApp.Child\"\n{\"root\":0}\n{}\n\n");
-    });
-
-    it("should not repeat a fact", () => {
-        let output = "";
-        const serializer = new GraphSerializer(chunk => {
-            output += chunk;
-        });
-
-        serializer.serialize([{
-            fact: {
-                type: "MyApp.Root",
-                hash: "roothash",
-                fields: {},
-                predecessors: {}
-            },
-            signatures: []
-        }, {
-            fact: {
-                type: "MyApp.Root",
-                hash: "roothash",
-                fields: {},
-                predecessors: {}
-            },
-            signatures: []
-        }]);
-
-        expect(output).toBe("\"MyApp.Root\"\n{}\n{}\n\n");
-    });
-
-    it("should write a graph with two facts with signatures", () => {
-        let output = "";
-        const serializer = new GraphSerializer(chunk => {
-            output += chunk;
-        });
-
-        serializer.serialize([{
-            fact: {
-                type: "MyApp.Root",
-                hash: "roothash",
-                fields: {},
-                predecessors: {}
-            },
-            signatures: [{
-                publicKey: "public",
-                signature: "signature"
-            }]
-        }, {
-            fact: {
-                type: "MyApp.Child",
-                hash: "childhash",
-                fields: {},
-                predecessors: {
-                    root: {
-                        type: "MyApp.Root",
-                        hash: "roothash"
-                    }
-                }
-            },
-            signatures: [{
-                publicKey: "public",
-                signature: "signature1"
-            }, {
-                publicKey: "public2",
-                signature: "signature2"
-            }]
-        }]);
-
-        expect(output).toBe(
-            "PK0\n\"public\"\n\n" +
-            "\"MyApp.Root\"\n{}\n{}\nPK0\n\"signature\"\n\n" +
-            "PK1\n\"public2\"\n\n" +
-            "\"MyApp.Child\"\n{\"root\":0}\n{}\nPK0\n\"signature1\"\nPK1\n\"signature2\"\n\n"
-        );
-    });
-});