@twin.org/auditable-item-graph-service 0.0.2-next.7 → 0.0.3-next.0

package/dist/es/auditableItemGraphService.js

@@ -0,0 +1,919 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+import { AuditableItemGraphContexts, AuditableItemGraphTopics, AuditableItemGraphTypes, VerifyDepth } from "@twin.org/auditable-item-graph-models";
+import { ContextIdKeys, ContextIdStore } from "@twin.org/context";
+import { ArrayHelper, ComponentFactory, Converter, GeneralError, Guards, Is, JsonHelper, NotFoundError, ObjectHelper, RandomHelper, StringHelper, Urn, Validation } from "@twin.org/core";
+import { JsonLdHelper, JsonLdProcessor } from "@twin.org/data-json-ld";
+import { ComparisonOperator, LogicalOperator, SortDirection } from "@twin.org/entity";
+import { EntityStorageConnectorFactory } from "@twin.org/entity-storage-models";
+import { ImmutableProofContexts, ImmutableProofFailure, ImmutableProofTypes } from "@twin.org/immutable-proof-models";
+import { SchemaOrgContexts, SchemaOrgDataTypes, SchemaOrgTypes } from "@twin.org/standards-schema-org";
+/**
+ * Class for performing auditable item graph operations.
+ */
+export class AuditableItemGraphService {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "AuditableItemGraphService";
+    /**
+     * The namespace for the service.
+     * @internal
+     */
+    static NAMESPACE = "aig";
+    /**
+     * The namespace for the service changeset.
+     */
+    static NAMESPACE_CHANGESET = "changeset";
+    /**
+     * The namespace for the service edge.
+     */
+    static NAMESPACE_EDGE = "edge";
+    /**
+     * The keys to pick when creating the proof for the stream.
+     * @internal
+     */
+    static _PROOF_KEYS_CHANGESET = [
+        "id",
+        "vertexId",
+        "userIdentity",
+        "dateCreated",
+        "patches"
+    ];
+    /**
+     * The immutable proof component.
+     * @internal
+     */
+    _immutableProofComponent;
+    /**
+     * The entity storage for vertices.
+     * @internal
+     */
+    _vertexStorage;
+    /**
+     * The entity storage for changesets.
+     * @internal
+     */
+    _changesetStorage;
+    /**
+     * The event bus component.
+     * @internal
+     */
+    _eventBusComponent;
+    /**
+     * Create a new instance of AuditableItemGraphService.
+     * @param options The dependencies for the auditable item graph connector.
+     */
+    constructor(options) {
+        this._immutableProofComponent = ComponentFactory.get(options?.immutableProofComponentType ?? "immutable-proof");
+        this._vertexStorage = EntityStorageConnectorFactory.get(options?.vertexEntityStorageType ?? "auditable-item-graph-vertex");
+        this._changesetStorage = EntityStorageConnectorFactory.get(options?.changesetEntityStorageType ?? "auditable-item-graph-changeset");
+        if (Is.stringValue(options?.eventBusComponentType)) {
+            this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType);
+        }
+        SchemaOrgDataTypes.registerRedirects();
+    }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return AuditableItemGraphService.CLASS_NAME;
+    }
+    /**
+     * Create a new graph vertex.
+     * @param vertex The vertex to create.
+     * @param vertex.annotationObject The annotation object for the vertex as JSON-LD.
+     * @param vertex.aliases Alternative aliases that can be used to identify the vertex.
+     * @param vertex.resources The resources attached to the vertex.
+     * @param vertex.edges The edges connected to the vertex.
+     * @returns The id of the new graph item.
+     */
+    async create(vertex) {
+        Guards.object(AuditableItemGraphService.CLASS_NAME, "vertex", vertex);
+        const contextIds = await ContextIdStore.getContextIds();
+        try {
+            if (Is.object(vertex.annotationObject)) {
+                const validationFailures = [];
+                await JsonLdHelper.validate(vertex.annotationObject, validationFailures);
+                Validation.asValidationError(AuditableItemGraphService.CLASS_NAME, "vertex.annotationObject", validationFailures);
+            }
+            const id = Converter.bytesToHex(RandomHelper.generate(32), false);
+            const context = {
+                now: new Date(Date.now()).toISOString(),
+                contextIds
+            };
+            const vertexModel = {
+                id,
+                organizationIdentity: contextIds?.[ContextIdKeys.Organization],
+                dateCreated: context.now
+            };
+            const originalEntity = ObjectHelper.clone(vertexModel);
+            vertexModel.annotationObject = vertex.annotationObject;
+            await this.updateAliasList(context, vertexModel, vertex.aliases);
+            await this.updateResourceList(context, vertexModel, vertex.resources);
+            await this.updateEdgeList(context, vertexModel, vertex.edges);
+            delete originalEntity.aliasIndex;
+            delete originalEntity.resourceTypeIndex;
+            await this.addChangeset(context, originalEntity, vertexModel, true);
+            await this._vertexStorage.set({
+                ...vertexModel,
+                ...this.buildIndexes(vertexModel)
+            });
+            const fullId = new Urn(AuditableItemGraphService.NAMESPACE, id).toString();
+            await this._eventBusComponent?.publish(AuditableItemGraphTopics.VertexCreated, { id: fullId });
+            return fullId;
+        }
+        catch (error) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "createFailed", undefined, error);
+        }
+    }
+    /**
+     * Get a graph vertex.
+     * @param id The id of the vertex to get.
+     * @param options Additional options for the get operation.
+     * @param options.includeDeleted Whether to include deleted/updated aliases, resource, edges, defaults to false.
+     * @param options.includeChangesets Whether to include the changesets of the vertex, defaults to false.
+     * @param options.verifySignatureDepth How many signatures to verify, defaults to "none".
+     * @returns The vertex if found.
+     * @throws NotFoundError if the vertex is not found.
+     */
+    async get(id, options) {
+        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "id", id);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (Is.empty(vertexEntity)) {
+                throw new NotFoundError(AuditableItemGraphService.CLASS_NAME, "vertexNotFound", id);
+            }
+            const vertexModel = this.vertexEntityToJsonLd(vertexEntity);
+            const includeChangesets = options?.includeChangesets ?? false;
+            const verifySignatureDepth = options?.verifySignatureDepth ?? "none";
+            let verified;
+            let changesets;
+            if (verifySignatureDepth === VerifyDepth.Current ||
+                verifySignatureDepth === VerifyDepth.All ||
+                includeChangesets) {
+                const verifyResult = await this.verifyChangesets(vertexModel, verifySignatureDepth);
+                verified = verifyResult.verified;
+                changesets = verifyResult.changesets;
+                vertexModel["@context"].push(ImmutableProofContexts.ContextRoot);
+            }
+            if (!(options?.includeDeleted ?? false)) {
+                if (Is.arrayValue(vertexModel.aliases)) {
+                    vertexModel.aliases = vertexModel.aliases.filter(a => Is.undefined(a.dateDeleted));
+                    if (vertexModel.aliases.length === 0) {
+                        delete vertexModel.aliases;
+                    }
+                }
+                if (Is.arrayValue(vertexModel.resources)) {
+                    vertexModel.resources = vertexModel.resources.filter(r => Is.undefined(r.dateDeleted));
+                    if (vertexModel.resources.length === 0) {
+                        delete vertexModel.resources;
+                    }
+                }
+                if (Is.arrayValue(vertexModel.edges)) {
+                    vertexModel.edges = vertexModel.edges.filter(r => Is.undefined(r.dateDeleted));
+                    if (vertexModel.edges.length === 0) {
+                        delete vertexModel.edges;
+                    }
+                }
+            }
+            if (includeChangesets) {
+                vertexModel.changesets = changesets;
+            }
+            if (verifySignatureDepth !== VerifyDepth.None) {
+                vertexModel.verified = verified;
+            }
+            const result = await JsonLdProcessor.compact(vertexModel, vertexModel["@context"]);
+            return result;
+        }
+        catch (error) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "getFailed", undefined, error);
+        }
+    }
+    /**
+     * Update a graph vertex.
+     * @param vertex The vertex to update.
+     * @param vertex.id The id of the vertex to update.
+     * @param vertex.annotationObject The annotation object for the vertex as JSON-LD.
+     * @param vertex.aliases Alternative aliases that can be used to identify the vertex.
+     * @param vertex.resources The resources attached to the vertex.
+     * @param vertex.edges The edges connected to the vertex.
+     * @returns Nothing.
+     */
+    async update(vertex) {
+        Guards.object(AuditableItemGraphService.CLASS_NAME, "vertex", vertex);
+        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "vertex.id", vertex.id);
+        const contextIds = await ContextIdStore.getContextIds();
+        const urnParsed = Urn.fromValidString(vertex.id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id: vertex.id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (Is.empty(vertexEntity)) {
+                throw new NotFoundError(AuditableItemGraphService.CLASS_NAME, "vertexNotFound", vertex.id);
+            }
+            if (Is.object(vertex.annotationObject)) {
+                const validationFailures = [];
+                await JsonLdHelper.validate(vertex.annotationObject, validationFailures);
+                Validation.asValidationError(AuditableItemGraphService.CLASS_NAME, "vertex.annotationObject", validationFailures);
+            }
+            const context = {
+                now: new Date(Date.now()).toISOString(),
+                contextIds
+            };
+            delete vertexEntity.aliasIndex;
+            const originalEntity = ObjectHelper.clone(vertexEntity);
+            const newEntity = ObjectHelper.clone(vertexEntity);
+            newEntity.annotationObject = vertex.annotationObject;
+            await this.updateAliasList(context, newEntity, vertex.aliases);
+            await this.updateResourceList(context, newEntity, vertex.resources);
+            await this.updateEdgeList(context, newEntity, vertex.edges);
+            const patches = await this.addChangeset(context, originalEntity, newEntity, false);
+            if (patches.length > 0) {
+                newEntity.dateModified = context.now;
+                const indexes = this.buildIndexes(newEntity);
+                await this._vertexStorage.set({
+                    ...newEntity,
+                    ...indexes
+                });
+                await this._eventBusComponent?.publish(AuditableItemGraphTopics.VertexUpdated, { id: vertex.id, patches });
+            }
+        }
+        catch (error) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "updatingFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove the verifiable storage for an item.
+     * @param id The id of the vertex to get.
+     * @returns Nothing.
+     * @throws NotFoundError if the vertex is not found.
+     */
+    async removeVerifiable(id) {
+        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "id", id);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (Is.empty(vertexEntity)) {
+                throw new NotFoundError(AuditableItemGraphService.CLASS_NAME, "vertexNotFound", id);
+            }
+            let changesetsResult;
+            do {
+                changesetsResult = await this._changesetStorage.query({
+                    property: "vertexId",
+                    value: vertexId,
+                    comparison: ComparisonOperator.Equals
+                }, [
+                    {
+                        property: "dateCreated",
+                        sortDirection: SortDirection.Ascending
+                    }
+                ], undefined, changesetsResult?.cursor);
+                for (const changeset of changesetsResult.entities) {
+                    if (Is.stringValue(changeset.proofId)) {
+                        await this._immutableProofComponent.removeVerifiable(changeset.proofId);
+                        delete changeset.proofId;
+                        await this._changesetStorage.set(changeset);
+                    }
+                }
+            } while (Is.stringValue(changesetsResult.cursor));
+        }
+        catch (error) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "removeVerifiableFailed", undefined, error);
+        }
+    }
+    /**
+     * Query the graph for vertices.
+     * @param options The query options.
+     * @param options.id The optional id to look for.
+     * @param options.idMode Look in id, alias or both, defaults to both.
+     * @param options.idExact Find only exact matches, default to false meaning partial matching.
+     * @param options.includesResourceTypes Include vertices with specific resource types.
+     * @param conditions Conditions to use in the query.
+     * @param orderBy The order for the results, defaults to created.
+     * @param orderByDirection The direction for the order, defaults to desc.
+     * @param properties The properties to return, if not provided defaults to id, created, aliases and object.
+     * @param cursor The cursor to request the next chunk of entities.
+     * @param limit Limit the number of entities to return.
+     * @returns The entities, which can be partial if a limited keys list was provided.
+     */
+    async query(options, conditions, orderBy, orderByDirection, properties, cursor, limit) {
+        try {
+            const propertiesToReturn = properties ?? [
+                "id",
+                "dateCreated",
+                "dateModified",
+                "aliases",
+                "annotationObject"
+            ];
+            const combinedConditions = conditions ?? [];
+            const orderProperty = orderBy ?? "dateCreated";
+            const orderDirection = orderByDirection ?? SortDirection.Descending;
+            const idExact = options?.idExact ?? false;
+            const idOrAlias = options?.id;
+            if (Is.stringValue(idOrAlias)) {
+                const idMode = options?.idMode ?? "both";
+                if (idMode === "id" || idMode === "both") {
+                    combinedConditions.push({
+                        property: "id",
+                        comparison: idExact ? ComparisonOperator.Equals : ComparisonOperator.Includes,
+                        value: idOrAlias
+                    });
+                }
+                if (idMode === "alias" || idMode === "both") {
+                    combinedConditions.push({
+                        property: "aliasIndex",
+                        comparison: ComparisonOperator.Includes,
+                        value: idExact ? `||${idOrAlias.toLowerCase()}||` : idOrAlias.toLowerCase()
+                    });
+                }
+            }
+            if (Is.arrayValue(options?.includesResourceTypes)) {
+                for (const resourceType of options.includesResourceTypes) {
+                    combinedConditions.push({
+                        property: "resourceTypeIndex",
+                        comparison: ComparisonOperator.Includes,
+                        value: `||${resourceType.toLowerCase()}||`
+                    });
+                }
+            }
+            if (!propertiesToReturn.includes("id")) {
+                propertiesToReturn.unshift("id");
+            }
+            const results = await this._vertexStorage.query(combinedConditions.length > 0
+                ? {
+                    conditions: combinedConditions,
+                    logicalOperator: LogicalOperator.Or
+                }
+                : undefined, [
+                {
+                    property: orderProperty,
+                    sortDirection: orderDirection
+                }
+            ], propertiesToReturn, cursor, limit);
+            const models = results.entities.map(e => this.vertexEntityToJsonLd(e));
+            const vertexList = {
+                "@context": [
+                    SchemaOrgContexts.ContextRoot,
+                    AuditableItemGraphContexts.ContextRoot,
+                    AuditableItemGraphContexts.ContextRootCommon
+                ],
+                type: [SchemaOrgTypes.ItemList, AuditableItemGraphTypes.VertexList],
+                [SchemaOrgTypes.ItemListElement]: models,
+                [SchemaOrgTypes.NextItem]: results.cursor
+            };
+            const result = await JsonLdProcessor.compact(vertexList, vertexList["@context"]);
+            return result;
+        }
+        catch (error) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "queryingFailed", undefined, error);
+        }
+    }
+    /**
+     * Map the vertex entity to JSON-LD.
+     * @param vertexEntity The vertex entity.
+     * @returns The model.
+     * @internal
+     */
+    vertexEntityToJsonLd(vertexEntity) {
+        const model = {
+            "@context": [
+                AuditableItemGraphContexts.ContextRoot,
+                AuditableItemGraphContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
+            ],
+            type: AuditableItemGraphTypes.Vertex,
+            id: new Urn(AuditableItemGraphService.NAMESPACE, vertexEntity.id).toString(),
+            dateCreated: vertexEntity.dateCreated,
+            dateModified: vertexEntity.dateModified,
+            organizationIdentity: vertexEntity.organizationIdentity,
+            annotationObject: vertexEntity.annotationObject
+        };
+        if (Is.arrayValue(vertexEntity.aliases)) {
+            model.aliases ??= [];
+            for (const aliasEntity of vertexEntity.aliases) {
+                const aliasModel = {
+                    "@context": [
+                        AuditableItemGraphContexts.ContextRoot,
+                        AuditableItemGraphContexts.ContextRootCommon,
+                        SchemaOrgContexts.ContextRoot
+                    ],
+                    type: AuditableItemGraphTypes.Alias,
+                    id: aliasEntity.id,
+                    aliasFormat: aliasEntity.aliasFormat,
+                    dateCreated: aliasEntity.dateCreated,
+                    dateModified: aliasEntity.dateModified,
+                    dateDeleted: aliasEntity.dateDeleted,
+                    annotationObject: aliasEntity.annotationObject
+                };
+                model.aliases.push(aliasModel);
+            }
+        }
+        if (Is.arrayValue(vertexEntity.resources)) {
+            model.resources ??= [];
+            for (const resourceEntity of vertexEntity.resources) {
+                const resourceModel = {
+                    "@context": [
+                        AuditableItemGraphContexts.ContextRoot,
+                        AuditableItemGraphContexts.ContextRootCommon,
+                        SchemaOrgContexts.ContextRoot
+                    ],
+                    type: AuditableItemGraphTypes.Resource,
+                    id: resourceEntity.id,
+                    dateCreated: resourceEntity.dateCreated,
+                    dateModified: resourceEntity.dateModified,
+                    dateDeleted: resourceEntity.dateDeleted,
+                    resourceObject: resourceEntity.resourceObject
+                };
+                model.resources.push(resourceModel);
+            }
+        }
+        if (Is.arrayValue(vertexEntity.edges)) {
+            model.edges ??= [];
+            for (const edgeEntity of vertexEntity.edges) {
+                const edgeModel = {
+                    "@context": [
+                        AuditableItemGraphContexts.ContextRoot,
+                        AuditableItemGraphContexts.ContextRootCommon,
+                        SchemaOrgContexts.ContextRoot
+                    ],
+                    type: AuditableItemGraphTypes.Edge,
+                    id: this.fullEdgeId(vertexEntity.id, edgeEntity.id),
+                    targetId: edgeEntity.targetId,
+                    dateCreated: edgeEntity.dateCreated,
+                    dateModified: edgeEntity.dateModified,
+                    dateDeleted: edgeEntity.dateDeleted,
+                    edgeRelationships: edgeEntity.edgeRelationships,
+                    annotationObject: edgeEntity.annotationObject
+                };
+                model.edges.push(edgeModel);
+            }
+        }
+        return model;
+    }
+    /**
+     * Map the changeset entity to a JSON-LD.
+     * @param vertexId The id of the vertex the changeset belongs to.
+     * @param changesetEntity The changeset entity.
+     * @returns The model.
+     * @internal
+     */
+    changesetEntityToJsonLd(vertexId, changesetEntity) {
+        const model = {
+            "@context": [
+                AuditableItemGraphContexts.ContextRoot,
+                AuditableItemGraphContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
+            ],
+            type: AuditableItemGraphTypes.Changeset,
+            id: new Urn(AuditableItemGraphService.NAMESPACE, [
+                vertexId,
+                AuditableItemGraphService.NAMESPACE_CHANGESET,
+                changesetEntity.id
+            ]).toString(),
+            dateCreated: changesetEntity.dateCreated,
+            userIdentity: changesetEntity.userIdentity,
+            patches: changesetEntity.patches.map(p => ({
+                "@context": [
+                    AuditableItemGraphContexts.ContextRoot,
+                    AuditableItemGraphContexts.ContextRootCommon,
+                    SchemaOrgContexts.ContextRoot
+                ],
+                type: AuditableItemGraphTypes.PatchOperation,
+                patchOperation: p.op,
+                patchPath: p.path,
+                patchFrom: p.from,
+                patchValue: p.value
+            })),
+            proofId: changesetEntity.proofId
+        };
+        return model;
+    }
+    /**
+     * Update the aliases of a vertex model.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param aliases The aliases to update.
+     * @internal
+     */
+    async updateAliasList(context, vertex, aliases) {
+        const active = vertex.aliases?.filter(a => Is.empty(a.dateDeleted)) ?? [];
+        // The active aliases that are not in the update list should be marked as deleted.
+        if (Is.arrayValue(active)) {
+            for (const alias of active) {
+                if (!aliases?.find(a => a.id === alias.id)) {
+                    alias.dateDeleted = context.now;
+                }
+            }
+        }
+        if (Is.arrayValue(aliases)) {
+            for (const alias of aliases) {
+                await this.updateAlias(context, vertex, alias);
+            }
+        }
+    }
+    /**
+     * Update an alias in the vertex.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param alias The alias.
+     * @internal
+     */
+    async updateAlias(context, vertex, alias) {
+        Guards.object(AuditableItemGraphService.CLASS_NAME, "alias", alias);
+        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "alias.id", alias.id);
+        if (alias.unique ?? false) {
+            const existingVertices = await this.findMatchingVertices(context, vertex.id, alias.id);
+            if (existingVertices) {
+                throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "aliasNotUnique", {
+                    aliasId: alias.id
+                });
+            }
+        }
+        if (Is.object(alias.annotationObject)) {
+            const validationFailures = [];
+            await JsonLdHelper.validate(alias.annotationObject, validationFailures);
+            Validation.asValidationError(AuditableItemGraphService.CLASS_NAME, "alias.annotationObject", validationFailures);
+        }
+        // Try to find an existing alias with the same id.
+        const existing = vertex.aliases?.find(a => a.id === alias.id);
+        if (Is.empty(existing) || !Is.empty(existing?.dateDeleted)) {
+            // Did not find a matching item, or found one which is deleted.
+            vertex.aliases ??= [];
+            const model = {
+                id: alias.id,
+                aliasFormat: alias.aliasFormat,
+                dateCreated: context.now,
+                annotationObject: alias.annotationObject
+            };
+            vertex.aliases.push(model);
+        }
+        else if (existing.aliasFormat !== alias.aliasFormat ||
+            !ObjectHelper.equal(existing.annotationObject, alias.annotationObject, false)) {
+            // Existing alias found, update the annotationObject.
+            existing.dateModified = context.now;
+            existing.aliasFormat = alias.aliasFormat;
+            existing.annotationObject = alias.annotationObject;
+        }
+    }
+    /**
+     * Update the resources of a vertex.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param resources The resources to update.
+     * @internal
+     */
+    async updateResourceList(context, vertex, resources) {
+        if (Is.arrayValue(resources)) {
+            for (let i = 0; i < resources.length; i++) {
+                const id = this.getResourceId(resources[i]);
+                if (Is.empty(id)) {
+                    throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "resourceIdMissing", {
+                        index: i
+                    });
+                }
+            }
+        }
+        const active = vertex.resources?.filter(r => Is.empty(r.dateDeleted)) ?? [];
+        // The active resources that are not in the update list should be marked as deleted.
+        if (Is.arrayValue(active)) {
+            for (const resource of active) {
+                if (!resources?.find(a => this.getResourceId(a) === this.getResourceId(resource))) {
+                    resource.dateDeleted = context.now;
+                }
+            }
+        }
+        if (Is.arrayValue(resources)) {
+            for (const resource of resources) {
+                await this.updateResource(context, vertex, resource);
+            }
+        }
+    }
+    /**
+     * Add a resource to the vertex.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param resource The resource.
+     * @internal
+     */
+    async updateResource(context, vertex, resource) {
+        Guards.object(AuditableItemGraphService.CLASS_NAME, "resource", resource);
+        if (Is.object(resource.resourceObject)) {
+            const validationFailures = [];
+            await JsonLdHelper.validate(resource.resourceObject, validationFailures);
+            Validation.asValidationError(AuditableItemGraphService.CLASS_NAME, "resource.resourceObject", validationFailures);
+        }
+        // Try to find an existing resource with the same id.
+        const existing = vertex.resources?.find(r => this.getResourceId(r) === this.getResourceId(resource));
+        if (Is.empty(existing) || !Is.empty(existing?.dateDeleted)) {
+            // Did not find a matching item, or found one which is deleted.
+            vertex.resources ??= [];
+            const model = {
+                id: resource.id,
+                dateCreated: context.now,
+                resourceObject: resource.resourceObject
+            };
+            vertex.resources.push(model);
+        }
+        else if (!ObjectHelper.equal(existing.resourceObject, resource.resourceObject, false)) {
+            // Existing resource found, update the resourceObject.
+            existing.dateModified = context.now;
+            existing.resourceObject = resource.resourceObject;
+        }
+    }
+    /**
+     * Update the edges of a vertex.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param edges The edges to update.
+     * @internal
+     */
+    async updateEdgeList(context, vertex, edges) {
+        const active = vertex.edges?.filter(e => Is.empty(e.dateDeleted)) ?? [];
+        // The active edges that are not in the update list should be marked as deleted.
+        if (Is.arrayValue(active)) {
+            for (const edge of active) {
+                if (!edges?.find(e => Is.stringValue(e.id) && this.reduceEdgeId(e.id) === edge.id)) {
+                    edge.dateDeleted = context.now;
+                }
+            }
+        }
+        if (Is.arrayValue(edges)) {
+            for (const edge of edges) {
+                await this.updateEdge(context, vertex, edge);
+            }
+        }
+    }
+    /**
+     * Add an edge to the vertex.
+     * @param context The context for the operation.
+     * @param vertex The vertex.
+     * @param edge The edge.
+     * @internal
+     */
+    async updateEdge(context, vertex, edge) {
+        Guards.object(AuditableItemGraphService.CLASS_NAME, "edge", edge);
+        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "edge.targetId", edge.targetId);
+        Guards.arrayValue(AuditableItemGraphService.CLASS_NAME, "edge.edgeRelationships", edge.edgeRelationships);
+        const validationFailures = [];
+        if (edge.targetId === vertex.id) {
+            validationFailures.push({
+                property: "id",
+                reason: `validation.${StringHelper.camelCase(AuditableItemGraphService.CLASS_NAME)}.edgeIdSameAsVertexId`,
+                properties: {
+                    targetId: edge.targetId
+                }
+            });
+        }
+        if (Is.object(edge.annotationObject)) {
+            await JsonLdHelper.validate(edge.annotationObject, validationFailures);
+        }
+        Validation.asValidationError(AuditableItemGraphService.CLASS_NAME, "edge.annotationObject", validationFailures);
+        let findId = Is.stringValue(edge.id) ? this.reduceEdgeId(edge.id) : undefined;
+        if (Is.empty(findId)) {
+            findId = Converter.bytesToHex(RandomHelper.generate(32), false);
+        }
+        // Try to find an existing edge with the same id.
+        const existing = vertex.edges?.find(r => r.id === findId);
+        if (Is.empty(existing) || !Is.empty(existing?.dateDeleted)) {
+            // Did not find a matching item, or found one which is deleted.
+            vertex.edges ??= [];
+            const model = {
+                id: findId,
+                targetId: edge.targetId,
+                dateCreated: context.now,
+                annotationObject: edge.annotationObject,
+                edgeRelationships: edge.edgeRelationships
+            };
+            vertex.edges.push(model);
+        }
+        else if (existing.targetId !== edge.targetId ||
+            !ArrayHelper.matches(existing.edgeRelationships, edge.edgeRelationships) ||
+            !ObjectHelper.equal(existing.annotationObject, edge.annotationObject, false)) {
+            // Existing edge found, update the properties.
+            existing.targetId = edge.targetId;
+            existing.dateModified = context.now;
+            existing.edgeRelationships = edge.edgeRelationships;
+            existing.annotationObject = edge.annotationObject;
+        }
+    }
+    /**
+     * Add a changeset to the vertex and generate the associated verifications.
+     * @param context The context for the operation.
+     * @param original The original vertex.
+     * @param updated The updated vertex.
+     * @param isNew Whether this is a new item.
+     * @returns True if there were changes.
+     * @internal
+     */
+    async addChangeset(context, original, updated, isNew) {
+        const patches = JsonHelper.diff(original, updated);
+        // If there is a diff set or this is the first time the item is created.
+        if (patches.length > 0 || isNew) {
+            const changesetEntity = {
+                id: Converter.bytesToHex(RandomHelper.generate(32), false),
+                vertexId: updated.id,
+                dateCreated: context.now,
+                userIdentity: context.contextIds?.[ContextIdKeys.User],
+                patches
+            };
+            // Create the JSON-LD object we want to use for the proof
+            // this is a subset of fixed properties from the changeset object.
+            const reducedChangesetJsonLd = this.changesetEntityToJsonLd(original.id, ObjectHelper.pick(changesetEntity, AuditableItemGraphService._PROOF_KEYS_CHANGESET));
+            // Create the proof for the changeset object
+            changesetEntity.proofId = await this._immutableProofComponent.create(reducedChangesetJsonLd);
+            // Link the verifiable storage id to the changeset
+            await this._changesetStorage.set(changesetEntity);
+            return patches;
+        }
+        return [];
+    }
+    /**
+     * Verify the changesets of a vertex.
+     * @param vertex The vertex to verify.
+     * @param verifySignatureDepth How many signatures to verify.
+     * @param contextIds The context ids to perform the operation with.
+     * @internal
+     */
+    async verifyChangesets(vertex, verifySignatureDepth, partitionKey) {
+        const changesets = [];
+        let changesetsResult;
+        let verified = true;
+        const vertexId = Urn.fromValidString(vertex.id);
+        do {
+            changesetsResult = await this._changesetStorage.query({
+                property: "vertexId",
+                value: vertexId.namespaceSpecific(),
+                comparison: ComparisonOperator.Equals
+            }, [
+                {
+                    property: "dateCreated",
+                    sortDirection: SortDirection.Ascending
+                }
+            ], undefined, changesetsResult?.cursor);
+            const storedChangesets = changesetsResult.entities;
+            if (Is.arrayValue(storedChangesets)) {
+                for (let i = 0; i < storedChangesets.length; i++) {
+                    const storedChangeset = storedChangesets[i];
+                    const storedChangesetJsonLd = this.changesetEntityToJsonLd(vertexId.namespaceSpecific(), storedChangeset);
+                    changesets.push(storedChangesetJsonLd);
+                    // If we are verifying all signatures
+                    // or this is the last changeset (cursor is empty)
+                    // and the changeset has a proofId, then verify the proof.
+                    if (verifySignatureDepth === VerifyDepth.All ||
+                        (verifySignatureDepth === VerifyDepth.Current &&
+                            !Is.stringValue(changesetsResult.cursor) &&
+                            i === storedChangesets.length - 1)) {
+                        if (!Is.stringValue(storedChangeset.proofId)) {
+                            verified = false;
+                            storedChangesetJsonLd.verification = {
+                                "@context": ImmutableProofContexts.ContextRoot,
+                                type: ImmutableProofTypes.ImmutableProofVerification,
+                                verified: false,
+                                failure: ImmutableProofFailure.ProofMissing
+                            };
+                        }
+                        else {
+                            // Verify the proof for the changeset object
+                            storedChangesetJsonLd.verification = await this._immutableProofComponent.verify(storedChangeset.proofId);
+                            if (!storedChangesetJsonLd.verification.verified) {
+                                verified = false;
+                            }
+                        }
+                    }
+                }
+            }
+        } while (Is.stringValue(changesetsResult.cursor));
+        return {
+            verified,
+            changesets
+        };
+    }
+    /**
+     * Get the resource id from a resource object.
+     * @param resource The resource.
+     * @param resource.id The id of the resource.
+     * @param resource.resourceObject The resource object.
+     * @returns The resource id if it can find one.
+     */
+    getResourceId(resource) {
+        return (resource.id ??
+            ObjectHelper.extractProperty(resource.resourceObject, ["id", "@id"], false));
+    }
+    /**
+     * Build the indexes for the vertex.
+     * @param vertex The vertex to build the indexes for.
+     * @returns The indexes.
+     * @internal
+     */
+    buildIndexes(vertex) {
+        const aliasIndex = vertex.aliases
+            ?.filter(a => Is.empty(a.dateDeleted))
+            .map(a => a.id)
+            .join("||")
+            .toLowerCase();
+        const resourceTypes = [];
+        if (Is.arrayValue(vertex.resources)) {
+            for (const resource of vertex.resources) {
+                const resourceType = ObjectHelper.extractProperty(resource.resourceObject, ["@type", "type"], false);
+                if (Is.stringValue(resourceType) && !resourceTypes.includes(resourceType)) {
+                    resourceTypes.push(resourceType);
+                }
+            }
+        }
+        const resourceTypeIndex = resourceTypes.join("||").toLowerCase();
+        return {
+            aliasIndex: Is.stringValue(aliasIndex) ? `||${aliasIndex}||` : undefined,
+            resourceTypeIndex: Is.stringValue(resourceTypeIndex) ? `||${resourceTypeIndex}||` : undefined
+        };
+    }
+    /**
+     * Find vertices with matching aliases.
+     * @param context The context for the operation.
+     * @param vertexId The id of the vertex to exclude from the search.
+     * @param aliasId The alias id to try and find.
+     * @returns True if any other vertices have matching aliases.
+     * @internal
+     */
+    async findMatchingVertices(context, vertexId, aliasId) {
+        const results = await this._vertexStorage.query({
+            conditions: [
+                {
+                    property: "aliasIndex",
+                    comparison: ComparisonOperator.Includes,
+                    value: `||${aliasId.toLowerCase()}||`
+                },
+                {
+                    property: "id",
+                    value: vertexId,
+                    comparison: ComparisonOperator.NotEquals
+                }
+            ],
+            logicalOperator: LogicalOperator.And
+        });
+        return results.entities.length > 0;
+    }
+    /**
+     * Reduce the edge ID from a URN.
+     * @param urn The URN to reduce.
+     * @returns The edge ID.
+     * @throws GeneralError if the URN is not valid or not an edge URN.
+     * @internal
+     */
+    reduceEdgeId(urn) {
+        const urnParsed = Urn.fromValidString(urn);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id: urn
+            });
+        }
+        if (urnParsed.namespaceSpecificParts().length !== 3) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "invalidEdgeId", {
+                edgeId: urn
+            });
+        }
+        if (urnParsed.namespaceSpecificParts()[1] !== AuditableItemGraphService.NAMESPACE_EDGE) {
+            throw new GeneralError(AuditableItemGraphService.CLASS_NAME, "invalidEdgeId", {
+                edgeId: urn
+            });
+        }
+        return urnParsed.namespaceSpecificParts()[2];
+    }
+    /**
+     * Create a full edge ID URN from a vertex ID and edge ID.
+     * @param vertexId The vertex id the edge belongs to.
+     * @param edgeId The edge id.
+     * @returns The full edge ID URN.
+     * @internal
+     */
+    fullEdgeId(vertexId, edgeId) {
+        return new Urn(AuditableItemGraphService.NAMESPACE, [
+            vertexId,
+            AuditableItemGraphService.NAMESPACE_EDGE,
+            edgeId
+        ]).toString();
+    }
+}
+//# sourceMappingURL=auditableItemGraphService.js.map