@twin.org/auditable-item-graph-service 0.0.2-next.8 → 0.0.3-next.1

package/dist/esm/index.mjs

@@ -1,1844 +0,0 @@
-import { HttpParameterHelper } from '@twin.org/api-models';
-import { AuditableItemGraphTypes, AuditableItemGraphContexts, AuditableItemGraphTopics, VerifyDepth } from '@twin.org/auditable-item-graph-models';
-import { Guards, ComponentFactory, Coerce, Is, Validation, Converter, RandomHelper, ObjectHelper, Urn, GeneralError, NotFoundError, StringHelper, ArrayHelper, JsonHelper } from '@twin.org/core';
-import { SchemaOrgContexts, SchemaOrgTypes, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
-import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
-import { JsonLdHelper, JsonLdProcessor, JsonLdTypes } from '@twin.org/data-json-ld';
-import { ComparisonOperator, SortDirection, LogicalOperator, property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { ImmutableProofContexts, ImmutableProofFailure, ImmutableProofTypes } from '@twin.org/immutable-proof-models';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE = "auditableItemGraphRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsAuditableItemGraph = [
-    {
-        name: "Auditable Item Graph",
-        description: "Endpoints which are modelled to access an auditable item graph contract."
-    }
-];
-/**
- * The REST routes for auditable item graph.
- * @param baseRouteName Prefix to prepend to the paths.
- * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
- * @returns The generated routes.
- */
-function generateRestRoutesAuditableItemGraph(baseRouteName, componentName) {
-    const createRoute = {
-        operationId: "auditableItemGraphCreate",
-        summary: "Create a new graph vertex",
-        tag: tagsAuditableItemGraph[0].name,
-        method: "POST",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => auditableItemGraphCreate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IAuditableItemGraphCreateRequest",
-            examples: [
-                {
-                    id: "auditableItemGraphCreateRequestExample",
-                    request: {
-                        body: {
-                            annotationObject: {
-                                "@context": "https://schema.org",
-                                "@type": "Note",
-                                content: "This is a simple note"
-                            },
-                            aliases: [
-                                {
-                                    id: "bar456",
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    id: "foo321",
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ],
-                            resources: [
-                                {
-                                    id: "resource1",
-                                    resourceObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    id: "resource2",
-                                    resourceObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ],
-                            edges: [
-                                {
-                                    targetId: "aig:1234567890",
-                                    edgeRelationships: ["frenemy"],
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    targetId: "aig:45678901234",
-                                    edgeRelationships: ["end"],
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ]
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "ICreatedResponse",
-                examples: [
-                    {
-                        id: "auditableItemGraphCreateResponseExample",
-                        description: "The response when a new graph vertex is created.",
-                        response: {
-                            statusCode: HttpStatusCode.created,
-                            headers: {
-                                [HeaderTypes.Location]: "aig:1234567890"
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    const getRoute = {
-        operationId: "auditableItemGraphGet",
-        summary: "Get a graph vertex",
-        tag: tagsAuditableItemGraph[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => auditableItemGraphGet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IAuditableItemGraphGetRequest",
-            examples: [
-                {
-                    id: "auditableItemGraphGetRequestExample",
-                    request: {
-                        headers: {
-                            [HeaderTypes.Accept]: MimeTypes.Json
-                        },
-                        pathParams: {
-                            id: "aig:1234567890"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IAuditableItemGraphGetResponse",
-                examples: [
-                    {
-                        id: "auditableItemGraphGetResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    AuditableItemGraphContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRootCommon,
-                                    SchemaOrgContexts.ContextRoot
-                                ],
-                                type: AuditableItemGraphTypes.Vertex,
-                                id: "aig:1234567890",
-                                dateCreated: "2024-08-22T11:55:16.271Z",
-                                dateModified: "2024-08-22T11:55:16.271Z",
-                                annotationObject: {
-                                    "@context": "https://schema.org",
-                                    "@type": "Note",
-                                    content: "This is a simple note"
-                                },
-                                aliases: [
-                                    {
-                                        "@context": [
-                                            AuditableItemGraphContexts.ContextRoot,
-                                            AuditableItemGraphContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: AuditableItemGraphTypes.Alias,
-                                        id: "tst:1234567890",
-                                        dateCreated: "2024-08-22T11:55:16.271Z"
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IAuditableItemGraphGetResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "auditableItemGraphJsonLdGetResponseExample",
-                        response: {
-                            headers: {
-                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
-                            },
-                            body: {
-                                "@context": [
-                                    AuditableItemGraphContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRootCommon,
-                                    SchemaOrgContexts.ContextRoot
-                                ],
-                                type: AuditableItemGraphTypes.Vertex,
-                                id: "aig:1234567890",
-                                dateCreated: "2024-08-22T11:55:16.271Z",
-                                dateModified: "2024-08-22T11:55:16.271Z",
-                                annotationObject: {
-                                    "@context": "https://schema.org",
-                                    "@type": "Note",
-                                    content: "This is a simple note"
-                                },
-                                aliases: [
-                                    {
-                                        "@context": [
-                                            AuditableItemGraphContexts.ContextRoot,
-                                            AuditableItemGraphContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: AuditableItemGraphTypes.Alias,
-                                        dateCreated: "2024-08-22T11:55:16.271Z",
-                                        id: "tst:1234567890"
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    const updateRoute = {
-        operationId: "auditableItemGraphUpdate",
-        summary: "Update a graph vertex",
-        tag: tagsAuditableItemGraph[0].name,
-        method: "PUT",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => auditableItemGraphUpdate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IAuditableItemGraphUpdateRequest",
-            examples: [
-                {
-                    id: "auditableItemGraphUpdateRequestExample",
-                    request: {
-                        pathParams: {
-                            id: "aig:1234567890"
-                        },
-                        body: {
-                            annotationObject: {
-                                "@context": "https://schema.org",
-                                "@type": "Note",
-                                content: "This is a simple note"
-                            },
-                            aliases: [
-                                {
-                                    id: "bar456",
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    id: "foo321",
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ],
-                            resources: [
-                                {
-                                    id: "resource1",
-                                    resourceObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    id: "resource2",
-                                    resourceObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ],
-                            edges: [
-                                {
-                                    id: "edge1",
-                                    targetId: "aig:1234567890",
-                                    edgeRelationships: ["frenemy"],
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                },
-                                {
-                                    id: "edge2",
-                                    targetId: "aig:45678901234",
-                                    edgeRelationships: ["end"],
-                                    annotationObject: {
-                                        "@context": "https://schema.org",
-                                        "@type": "Note",
-                                        content: "This is a simple note"
-                                    }
-                                }
-                            ]
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            }
-        ]
-    };
-    const listRoute = {
-        operationId: "auditableItemGraphList",
-        summary: "Query graph vertices by id or alias",
-        tag: tagsAuditableItemGraph[0].name,
-        method: "GET",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => auditableItemGraphList(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IAuditableItemGraphListRequest",
-            examples: [
-                {
-                    id: "IAuditableItemGraphListAllRequest",
-                    request: {}
-                },
-                {
-                    id: "IAuditableItemGraphListIdRequest",
-                    request: {
-                        query: {
-                            id: "1234567890"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IAuditableItemGraphListResponse",
-                examples: [
-                    {
-                        id: "auditableItemGraphListResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    SchemaOrgContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRootCommon
-                                ],
-                                type: [SchemaOrgTypes.ItemList, AuditableItemGraphTypes.VertexList],
-                                [SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            AuditableItemGraphContexts.ContextRoot,
-                                            AuditableItemGraphContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: AuditableItemGraphTypes.Vertex,
-                                        id: "0101010101010101010101010101010101010101010101010101010101010101",
-                                        dateCreated: "2024-08-22T11:55:16.271Z",
-                                        aliases: [
-                                            {
-                                                "@context": [
-                                                    AuditableItemGraphContexts.ContextRoot,
-                                                    AuditableItemGraphContexts.ContextRootCommon,
-                                                    SchemaOrgContexts.ContextRoot
-                                                ],
-                                                type: AuditableItemGraphTypes.Alias,
-                                                id: "foo4",
-                                                dateCreated: "2024-08-22T11:55:16.271Z"
-                                            }
-                                        ]
-                                    }
-                                ],
-                                [SchemaOrgTypes.NextItem]: "1"
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IAuditableItemGraphListResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "auditableItemGraphJsonLdListResponseExample",
-                        response: {
-                            headers: {
-                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
-                            },
-                            body: {
-                                "@context": [
-                                    SchemaOrgContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRoot,
-                                    AuditableItemGraphContexts.ContextRootCommon
-                                ],
-                                type: [SchemaOrgTypes.ItemList, AuditableItemGraphTypes.VertexList],
-                                [SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            AuditableItemGraphContexts.ContextRoot,
-                                            AuditableItemGraphContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: AuditableItemGraphTypes.Vertex,
-                                        id: "0101010101010101010101010101010101010101010101010101010101010101",
-                                        dateCreated: "2024-08-22T11:55:16.271Z",
-                                        aliases: [
-                                            {
-                                                "@context": [
-                                                    AuditableItemGraphContexts.ContextRoot,
-                                                    AuditableItemGraphContexts.ContextRootCommon,
-                                                    SchemaOrgContexts.ContextRoot
-                                                ],
-                                                type: AuditableItemGraphTypes.Alias,
-                                                id: "foo4",
-                                                dateCreated: "2024-08-22T11:55:16.271Z"
-                                            }
-                                        ]
-                                    }
-                                ],
-                                [SchemaOrgTypes.NextItem]: "1"
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    return [createRoute, getRoute, updateRoute, listRoute];
-}
-/**
- * Create the graph vertex.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function auditableItemGraphCreate(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    const component = ComponentFactory.get(componentName);
-    const id = await component.create(request.body, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: HttpStatusCode.created,
-        headers: {
-            [HeaderTypes.Location]: id
-        }
-    };
-}
-/**
- * Get the graph vertex.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function auditableItemGraphGet(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.id, {
-        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
-        includeChangesets: Coerce.boolean(request.query?.includeChangesets),
-        verifySignatureDepth: request.query?.verifySignatureDepth
-    });
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-/**
- * Update the graph vertex.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function auditableItemGraphUpdate(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    const component = ComponentFactory.get(componentName);
-    await component.update({ ...request.body, id: request.pathParams.id }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * Query the graph vertices.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function auditableItemGraphList(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.query", request.query);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.query({
-        id: request.query?.id,
-        idMode: request.query?.idMode,
-        idExact: Coerce.boolean(request.query?.idExact),
-        resourceTypes: HttpParameterHelper.arrayFromString(request.query?.resourceTypes)
-    }, HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, HttpParameterHelper.arrayFromString(request.query?.properties), request.query?.cursor, Coerce.integer(request.query?.limit));
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing auditable item graph operations.
- */
-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();
-    }
-    /**
-     * 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.
-     * @param userIdentity The identity to create the auditable item graph operation with.
-     * @param nodeIdentity The node identity to include in the auditable item graph.
-     * @returns The id of the new graph item.
-     */
-    async create(vertex, userIdentity, nodeIdentity) {
-        Guards.object(AuditableItemGraphService.CLASS_NAME, "vertex", vertex);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "userIdentity", userIdentity);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        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(),
-                userIdentity,
-                nodeIdentity
-            };
-            const vertexModel = {
-                id,
-                nodeIdentity,
-                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;
-            }
-            return JsonLdProcessor.compact(vertexModel, vertexModel["@context"]);
-        }
-        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.
-     * @param userIdentity The identity to create the auditable item graph operation with.
-     * @param nodeIdentity The node identity to include in the auditable item graph.
-     * @returns Nothing.
-     */
-    async update(vertex, userIdentity, nodeIdentity) {
-        Guards.object(AuditableItemGraphService.CLASS_NAME, "vertex", vertex);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "vertex.id", vertex.id);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "userIdentity", userIdentity);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        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(),
-                userIdentity,
-                nodeIdentity
-            };
-            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.
-     * @param nodeIdentity The node identity to use for vault operations.
-     * @returns Nothing.
-     * @throws NotFoundError if the vertex is not found.
-     */
-    async removeVerifiable(id, nodeIdentity) {
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "id", id);
-        Guards.stringValue(AuditableItemGraphService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        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, nodeIdentity);
-                        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
-            };
-            return JsonLdProcessor.compact(vertexList, vertexList["@context"]);
-        }
-        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,
-            nodeIdentity: vertexEntity.nodeIdentity,
-            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(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.userIdentity,
-                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 = await 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, context.userIdentity, context.nodeIdentity);
-            // Link the verifiable storage id to the changeset
-            await this._changesetStorage.set(changesetEntity);
-            return patches;
-        }
-        return [];
-    }
-    /**
-     * Verify the changesets of a vertex.
-     * @param nodeIdentity The node identity to verify the changesets with.
-     * @param vertex The vertex to verify.
-     * @param verifySignatureDepth How many signatures to verify.
-     * @internal
-     */
-    async verifyChangesets(vertex, verifySignatureDepth) {
-        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 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(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();
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the auditable item graph alias.
- */
-let AuditableItemGraphAlias = class AuditableItemGraphAlias {
-    /**
-     * The alternative alias for the vertex.
-     */
-    id;
-    /**
-     * The format of the alias for the vertex.
-     */
-    aliasFormat;
-    /**
-     * The date/time of when the alias was created.
-     */
-    dateCreated;
-    /**
-     * The date/time of when the alias was last modified.
-     */
-    dateModified;
-    /**
-     * The timestamp of when the alias was deleted, as we never actually remove items.
-     */
-    dateDeleted;
-    /**
-     * Object to associate with the alias as JSON-LD.
-     */
-    annotationObject;
-};
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphAlias.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphAlias.prototype, "aliasFormat", void 0);
-__decorate([
-    property({ type: "string", format: "date-time" }),
-    __metadata("design:type", String)
-], AuditableItemGraphAlias.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphAlias.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphAlias.prototype, "dateDeleted", void 0);
-__decorate([
-    property({ type: "object", itemTypeRef: JsonLdTypes.NodeObject, optional: true }),
-    __metadata("design:type", Object)
-], AuditableItemGraphAlias.prototype, "annotationObject", void 0);
-AuditableItemGraphAlias = __decorate([
-    entity()
-], AuditableItemGraphAlias);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing a set of updates to the vertex.
- */
-let AuditableItemGraphChangeset = class AuditableItemGraphChangeset {
-    /**
-     * The id of the changeset.
-     */
-    id;
-    /**
-     * The vertex the changeset belongs to.
-     */
-    vertexId;
-    /**
-     * The date/time of when the changeset was created.
-     */
-    dateCreated;
-    /**
-     * The identity of the user who made the changeset.
-     */
-    userIdentity;
-    /**
-     * The patches in the changeset.
-     */
-    patches;
-    /**
-     * The immutable proof id which contains the signature for this changeset.
-     */
-    proofId;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphChangeset.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", isSecondary: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphChangeset.prototype, "vertexId", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
-    __metadata("design:type", String)
-], AuditableItemGraphChangeset.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphChangeset.prototype, "userIdentity", void 0);
-__decorate([
-    property({ type: "array", itemTypeRef: "AuditableItemGraphPatch" }),
-    __metadata("design:type", Array)
-], AuditableItemGraphChangeset.prototype, "patches", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphChangeset.prototype, "proofId", void 0);
-AuditableItemGraphChangeset = __decorate([
-    entity()
-], AuditableItemGraphChangeset);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the auditable item graph edge.
- */
-let AuditableItemGraphEdge = class AuditableItemGraphEdge {
-    /**
-     * The id of the edge.
-     */
-    id;
-    /**
-     * The date/time of when the edge was created.
-     */
-    dateCreated;
-    /**
-     * The date/time of when the edge was last modified.
-     */
-    dateModified;
-    /**
-     * The timestamp of when the edge was deleted, as we never actually remove items.
-     */
-    dateDeleted;
-    /**
-     * The target id of the edge.
-     */
-    targetId;
-    /**
-     * The relationships between the two vertices.
-     */
-    edgeRelationships;
-    /**
-     * Object to associate with the edge as JSON-LD.
-     */
-    annotationObject;
-};
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphEdge.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", format: "date-time" }),
-    __metadata("design:type", String)
-], AuditableItemGraphEdge.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphEdge.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphEdge.prototype, "dateDeleted", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphEdge.prototype, "targetId", void 0);
-__decorate([
-    property({ type: "array" }),
-    __metadata("design:type", Array)
-], AuditableItemGraphEdge.prototype, "edgeRelationships", void 0);
-__decorate([
-    property({ type: "object", itemTypeRef: JsonLdTypes.NodeObject, optional: true }),
-    __metadata("design:type", Object)
-], AuditableItemGraphEdge.prototype, "annotationObject", void 0);
-AuditableItemGraphEdge = __decorate([
-    entity()
-], AuditableItemGraphEdge);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the auditable item graph patches.
- */
-let AuditableItemGraphPatch = class AuditableItemGraphPatch {
-    /**
-     * The operation for the patch.
-     */
-    op;
-    /**
-     * The path for the patch.
-     */
-    path;
-    /**
-     * The from for the patch.
-     */
-    from;
-    /**
-     * The value for the patch.
-     */
-    value;
-};
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphPatch.prototype, "op", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemGraphPatch.prototype, "path", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphPatch.prototype, "from", void 0);
-__decorate([
-    property({ type: "object", optional: true }),
-    __metadata("design:type", Object)
-], AuditableItemGraphPatch.prototype, "value", void 0);
-AuditableItemGraphPatch = __decorate([
-    entity()
-], AuditableItemGraphPatch);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the auditable item graph vertex resource.
- */
-let AuditableItemGraphResource = class AuditableItemGraphResource {
-    /**
-     * The id of the resource.
-     */
-    id;
-    /**
-     * The date/time of when the resource was created.
-     */
-    dateCreated;
-    /**
-     * The date/time of when the resource was last modified.
-     */
-    dateModified;
-    /**
-     * The timestamp of when the resource was deleted, as we never actually remove items.
-     */
-    dateDeleted;
-    /**
-     * Object to associate with the resource as JSON-LD.
-     */
-    resourceObject;
-};
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphResource.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", format: "date-time" }),
-    __metadata("design:type", String)
-], AuditableItemGraphResource.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphResource.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphResource.prototype, "dateDeleted", void 0);
-__decorate([
-    property({ type: "object", itemTypeRef: JsonLdTypes.NodeObject, optional: true }),
-    __metadata("design:type", Object)
-], AuditableItemGraphResource.prototype, "resourceObject", void 0);
-AuditableItemGraphResource = __decorate([
-    entity()
-], AuditableItemGraphResource);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the auditable item graph vertex.
- */
-let AuditableItemGraphVertex = class AuditableItemGraphVertex {
-    /**
-     * The id of the vertex.
-     */
-    id;
-    /**
-     * The identity of the node which controls the vertex.
-     */
-    nodeIdentity;
-    /**
-     * The date/time of when the vertex was created.
-     */
-    dateCreated;
-    /**
-     * The date/time of when the vertex was last modified.
-     */
-    dateModified;
-    /**
-     * Combined alias index for the vertex used for querying.
-     */
-    aliasIndex;
-    /**
-     * Combined resource type index for the vertex used for querying.
-     */
-    resourceTypeIndex;
-    /**
-     * Object to associate with the vertex as JSON-LD.
-     */
-    annotationObject;
-    /**
-     * Alternative aliases that can be used to identify the vertex.
-     */
-    aliases;
-    /**
-     * The resources attached to the vertex.
-     */
-    resources;
-    /**
-     * Edges connected to the vertex.
-     */
-    edges;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "nodeIdentity", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "dateCreated", void 0);
-__decorate([
-    property({
-        type: "string",
-        format: "date-time",
-        sortDirection: SortDirection.Descending,
-        optional: true
-    }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "string", isSecondary: true, optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "aliasIndex", void 0);
-__decorate([
-    property({ type: "string", isSecondary: true, optional: true }),
-    __metadata("design:type", String)
-], AuditableItemGraphVertex.prototype, "resourceTypeIndex", void 0);
-__decorate([
-    property({ type: "object", itemTypeRef: JsonLdTypes.NodeObject, optional: true }),
-    __metadata("design:type", Object)
-], AuditableItemGraphVertex.prototype, "annotationObject", void 0);
-__decorate([
-    property({ type: "array", itemType: "string", optional: true }),
-    __metadata("design:type", Array)
-], AuditableItemGraphVertex.prototype, "aliases", void 0);
-__decorate([
-    property({ type: "array", itemTypeRef: "AuditableItemGraphResource", optional: true }),
-    __metadata("design:type", Array)
-], AuditableItemGraphVertex.prototype, "resources", void 0);
-__decorate([
-    property({ type: "array", itemTypeRef: "AuditableItemGraphEdge", optional: true }),
-    __metadata("design:type", Array)
-], AuditableItemGraphVertex.prototype, "edges", void 0);
-AuditableItemGraphVertex = __decorate([
-    entity()
-], AuditableItemGraphVertex);
-
-const restEntryPoints = [
-    {
-        name: "auditable-item-graph",
-        defaultBaseRoute: "auditable-item-graph",
-        tags: tagsAuditableItemGraph,
-        generateRoutes: generateRestRoutesAuditableItemGraph
-    }
-];
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialize the schema for the auditable item graph entity storage connector.
- */
-function initSchema() {
-    EntitySchemaFactory.register("AuditableItemGraphVertex", () => EntitySchemaHelper.getSchema(AuditableItemGraphVertex));
-    EntitySchemaFactory.register("AuditableItemGraphAlias", () => EntitySchemaHelper.getSchema(AuditableItemGraphAlias));
-    EntitySchemaFactory.register("AuditableItemGraphResource", () => EntitySchemaHelper.getSchema(AuditableItemGraphResource));
-    EntitySchemaFactory.register("AuditableItemGraphEdge", () => EntitySchemaHelper.getSchema(AuditableItemGraphEdge));
-    EntitySchemaFactory.register("AuditableItemGraphChangeset", () => EntitySchemaHelper.getSchema(AuditableItemGraphChangeset));
-    EntitySchemaFactory.register("AuditableItemGraphPatch", () => EntitySchemaHelper.getSchema(AuditableItemGraphPatch));
-}
-
-export { AuditableItemGraphAlias, AuditableItemGraphChangeset, AuditableItemGraphEdge, AuditableItemGraphPatch, AuditableItemGraphResource, AuditableItemGraphService, AuditableItemGraphVertex, auditableItemGraphCreate, auditableItemGraphGet, auditableItemGraphList, auditableItemGraphUpdate, generateRestRoutesAuditableItemGraph, initSchema, restEntryPoints, tagsAuditableItemGraph };