@twin.org/auditable-item-graph-service 0.0.1-next.10

package/dist/cjs/index.cjs

@@ -0,0 +1,1606 @@
+'use strict';
+
+var auditableItemGraphModels = require('@twin.org/auditable-item-graph-models');
+var core = require('@twin.org/core');
+var dataSchemaOrg = require('@twin.org/data-schema-org');
+var web = require('@twin.org/web');
+var dataJsonLd = require('@twin.org/data-json-ld');
+var entity = require('@twin.org/entity');
+var entityStorageModels = require('@twin.org/entity-storage-models');
+var immutableProofModels = require('@twin.org/immutable-proof-models');
+
+/**
+ * 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: {
+                            vertexObject: {
+                                "@context": "http://schema.org/",
+                                "@type": "Note",
+                                content: "This is a simple note"
+                            },
+                            aliases: [
+                                {
+                                    id: "bar456",
+                                    aliasObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "foo321",
+                                    aliasObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                }
+                            ],
+                            resources: [
+                                {
+                                    id: "resource1",
+                                    resourceObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "resource2",
+                                    resourceObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                }
+                            ],
+                            edges: [
+                                {
+                                    id: "edge1",
+                                    edgeRelationship: "frenemy",
+                                    edgeObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "edge2",
+                                    edgeRelationship: "end",
+                                    edgeObject: {
+                                        "@context": "http://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: web.HttpStatusCode.created,
+                            headers: {
+                                [web.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: {
+                            [web.HeaderTypes.Accept]: web.MimeTypes.Json
+                        },
+                        pathParams: {
+                            id: "aig:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemGraphGetResponse",
+                examples: [
+                    {
+                        id: "auditableItemGraphGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
+                                id: "aig:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                dateModified: "2024-08-22T11:55:16.271Z",
+                                vertexObject: {
+                                    "@context": "http://schema.org/",
+                                    "@type": "Note",
+                                    content: "This is a simple note"
+                                },
+                                aliases: [
+                                    {
+                                        "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                        type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemGraphGetResponse",
+                mimeType: web.MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemGraphJsonLdGetResponseExample",
+                        response: {
+                            headers: {
+                                [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
+                                id: "aig:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                dateModified: "2024-08-22T11:55:16.271Z",
+                                vertexObject: {
+                                    "@context": "http://schema.org/",
+                                    "@type": "Note",
+                                    content: "This is a simple note"
+                                },
+                                aliases: [
+                                    {
+                                        "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                        type: auditableItemGraphModels.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: {
+                            vertexObject: {
+                                "@context": "http://schema.org/",
+                                "@type": "Note",
+                                content: "This is a simple note"
+                            },
+                            aliases: [
+                                {
+                                    id: "bar456",
+                                    aliasObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "foo321",
+                                    aliasObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                }
+                            ],
+                            resources: [
+                                {
+                                    id: "resource1",
+                                    resourceObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "resource2",
+                                    resourceObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                }
+                            ],
+                            edges: [
+                                {
+                                    id: "edge1",
+                                    edgeRelationship: "frenemy",
+                                    edgeObject: {
+                                        "@context": "http://schema.org/",
+                                        "@type": "Note",
+                                        content: "This is a simple note"
+                                    }
+                                },
+                                {
+                                    id: "edge2",
+                                    edgeRelationship: "end",
+                                    edgeObject: {
+                                        "@context": "http://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": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                type: auditableItemGraphModels.AuditableItemGraphTypes.VertexList,
+                                vertices: [
+                                    {
+                                        "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                        type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
+                                        id: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        aliases: [
+                                            {
+                                                "@context": [
+                                                    auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot,
+                                                    dataSchemaOrg.SchemaOrgTypes.ContextRoot
+                                                ],
+                                                type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
+                                                id: "foo4",
+                                                dateCreated: "2024-08-22T11:55:16.271Z"
+                                            }
+                                        ]
+                                    }
+                                ],
+                                cursor: "1"
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemGraphListResponse",
+                mimeType: web.MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemGraphJsonLdListResponseExample",
+                        response: {
+                            headers: {
+                                [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                type: auditableItemGraphModels.AuditableItemGraphTypes.VertexList,
+                                vertices: [
+                                    {
+                                        "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                                        type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
+                                        id: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        aliases: [
+                                            {
+                                                "@context": [
+                                                    auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot,
+                                                    dataSchemaOrg.SchemaOrgTypes.ContextRoot
+                                                ],
+                                                type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
+                                                id: "foo4",
+                                                dateCreated: "2024-08-22T11:55:16.271Z"
+                                            }
+                                        ]
+                                    }
+                                ],
+                                cursor: "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) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    const component = core.ComponentFactory.get(componentName);
+    const id = await component.create(request.body?.vertexObject, request.body?.aliases, request.body?.resources, request.body?.edges, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: web.HttpStatusCode.created,
+        headers: {
+            [web.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) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.get(request.pathParams.id, {
+        includeDeleted: request.query?.includeDeleted,
+        includeChangesets: request.query?.includeChangesets,
+        verifySignatureDepth: request.query?.verifySignatureDepth
+    });
+    return {
+        headers: {
+            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.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) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    const component = core.ComponentFactory.get(componentName);
+    await component.update(request.pathParams.id, request.body?.vertexObject, request.body?.aliases, request.body?.resources, request.body?.edges, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: web.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) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.query({
+        id: request.query?.id,
+        idMode: request.query?.idMode
+    }, request.query?.orderBy, request.query?.orderByDirection, request.query?.properties?.split(","), request.query?.cursor, request.query?.pageSize);
+    return {
+        headers: {
+            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class for performing auditable item graph operations.
+ */
+class AuditableItemGraphService {
+    /**
+     * The namespace for the service.
+     */
+    static NAMESPACE = "aig";
+    /**
+     * The namespace for the service changeset.
+     */
+    static NAMESPACE_CHANGESET = "changeset";
+    /**
+     * The keys to pick when creating the proof for the stream.
+     */
+    static _PROOF_KEYS_CHANGESET = [
+        "id",
+        "vertexId",
+        "userIdentity",
+        "dateCreated",
+        "patches"
+    ];
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "AuditableItemGraphService";
+    /**
+     * The immutable proof component.
+     * @internal
+     */
+    _immutableProofComponent;
+    /**
+     * The entity storage for vertices.
+     * @internal
+     */
+    _vertexStorage;
+    /**
+     * The entity storage for changesets.
+     * @internal
+     */
+    _changesetStorage;
+    /**
+     * Create a new instance of AuditableItemGraphService.
+     * @param options The dependencies for the auditable item graph connector.
+     * @param options.config The configuration for the connector.
+     * @param options.immutableProofComponentType The immutable proof component type, defaults to "immutable-proof".
+     * @param options.vertexEntityStorageType The entity storage for vertices, defaults to "auditable-item-graph-vertex".
+     * @param options.changesetEntityStorageType The entity storage for changesets, defaults to "auditable-item-graph-changeset".
+     */
+    constructor(options) {
+        this._immutableProofComponent = core.ComponentFactory.get(options?.immutableProofComponentType ?? "immutable-proof");
+        this._vertexStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.vertexEntityStorageType ?? core.StringHelper.kebabCase("AuditableItemGraphVertex"));
+        this._changesetStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.changesetEntityStorageType ??
+            core.StringHelper.kebabCase("AuditableItemGraphChangeset"));
+        dataSchemaOrg.SchemaOrgDataTypes.registerRedirects();
+    }
+    /**
+     * Create a new graph vertex.
+     * @param vertexObject The object for the vertex as JSON-LD.
+     * @param aliases Alternative aliases that can be used to identify the vertex.
+     * @param resources The resources attached to the vertex.
+     * @param 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(vertexObject, aliases, resources, edges, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            if (core.Is.object(vertexObject)) {
+                const validationFailures = [];
+                await dataJsonLd.JsonLdHelper.validate(vertexObject, validationFailures);
+                core.Validation.asValidationError(this.CLASS_NAME, "vertexObject", validationFailures);
+            }
+            const id = core.Converter.bytesToHex(core.RandomHelper.generate(32), false);
+            const context = {
+                now: new Date(Date.now()).toISOString(),
+                userIdentity,
+                nodeIdentity
+            };
+            const vertex = {
+                id,
+                nodeIdentity,
+                dateCreated: context.now,
+                dateModified: context.now
+            };
+            const originalEntity = core.ObjectHelper.clone(vertex);
+            vertex.vertexObject = vertexObject;
+            await this.updateAliasList(context, vertex, aliases);
+            await this.updateResourceList(context, vertex, resources);
+            await this.updateEdgeList(context, vertex, edges);
+            delete originalEntity.aliasIndex;
+            await this.addChangeset(context, originalEntity, vertex, true);
+            await this._vertexStorage.set({
+                ...vertex,
+                aliasIndex: vertex.aliases
+                    ?.map(a => a.id)
+                    .join("||")
+                    .toLowerCase()
+            });
+            return new core.Urn(AuditableItemGraphService.NAMESPACE, id).toString();
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
+        }
+    }
+    /**
+     * Get a graph vertex.
+     * @param id The id of the vertex to get.
+     * @returns The vertex if found.
+     * @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".
+     * @throws NotFoundError if the vertex is not found.
+     */
+    async get(id, options) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (core.Is.empty(vertexEntity)) {
+                throw new core.NotFoundError(this.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 === auditableItemGraphModels.VerifyDepth.Current ||
+                verifySignatureDepth === auditableItemGraphModels.VerifyDepth.All ||
+                includeChangesets) {
+                const verifyResult = await this.verifyChangesets(vertexModel, verifySignatureDepth);
+                verified = verifyResult.verified;
+                changesets = verifyResult.changesets;
+            }
+            if (!(options?.includeDeleted ?? false)) {
+                if (core.Is.arrayValue(vertexModel.aliases)) {
+                    vertexModel.aliases = vertexModel.aliases.filter(a => core.Is.undefined(a.dateDeleted));
+                    if (vertexModel.aliases.length === 0) {
+                        delete vertexModel.aliases;
+                    }
+                }
+                if (core.Is.arrayValue(vertexModel.resources)) {
+                    vertexModel.resources = vertexModel.resources.filter(r => core.Is.undefined(r.dateDeleted));
+                    if (vertexModel.resources.length === 0) {
+                        delete vertexModel.resources;
+                    }
+                }
+                if (core.Is.arrayValue(vertexModel.edges)) {
+                    vertexModel.edges = vertexModel.edges.filter(r => core.Is.undefined(r.dateDeleted));
+                    if (vertexModel.edges.length === 0) {
+                        delete vertexModel.edges;
+                    }
+                }
+            }
+            if (includeChangesets) {
+                vertexModel.changesets = changesets;
+            }
+            if (verifySignatureDepth !== auditableItemGraphModels.VerifyDepth.None) {
+                vertexModel.verified = verified;
+            }
+            const compacted = await dataJsonLd.JsonLdProcessor.compact(vertexModel, vertexModel["@context"]);
+            return compacted;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
+        }
+    }
+    /**
+     * Update a graph vertex.
+     * @param id The id of the vertex to update.
+     * @param vertexObject The object for the vertex.
+     * @param aliases Alternative aliases that can be used to identify the vertex.
+     * @param resources The resources attached to the vertex.
+     * @param 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(id, vertexObject, aliases, resources, edges, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (core.Is.empty(vertexEntity)) {
+                throw new core.NotFoundError(this.CLASS_NAME, "vertexNotFound", id);
+            }
+            if (core.Is.object(vertexObject)) {
+                const validationFailures = [];
+                await dataJsonLd.JsonLdHelper.validate(vertexObject, validationFailures);
+                core.Validation.asValidationError(this.CLASS_NAME, "vertexObject", validationFailures);
+            }
+            const context = {
+                now: new Date(Date.now()).toISOString(),
+                userIdentity,
+                nodeIdentity
+            };
+            delete vertexEntity.aliasIndex;
+            const originalEntity = core.ObjectHelper.clone(vertexEntity);
+            const newEntity = core.ObjectHelper.clone(vertexEntity);
+            newEntity.vertexObject = vertexObject;
+            await this.updateAliasList(context, newEntity, aliases);
+            await this.updateResourceList(context, newEntity, resources);
+            await this.updateEdgeList(context, newEntity, edges);
+            const changes = await this.addChangeset(context, originalEntity, newEntity, false);
+            if (changes) {
+                newEntity.dateModified = context.now;
+                await this._vertexStorage.set({
+                    ...newEntity,
+                    aliasIndex: newEntity.aliases
+                        ?.map(a => a.id)
+                        .join("||")
+                        .toLowerCase()
+                });
+            }
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove the immutable 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 removeImmutable(id, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemGraphService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemGraphService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const vertexId = urnParsed.namespaceSpecific(0);
+            const vertexEntity = await this._vertexStorage.get(vertexId);
+            if (core.Is.empty(vertexEntity)) {
+                throw new core.NotFoundError(this.CLASS_NAME, "vertexNotFound", id);
+            }
+            let changesetsResult;
+            do {
+                changesetsResult = await this._changesetStorage.query({
+                    property: "vertexId",
+                    value: vertexId,
+                    comparison: entity.ComparisonOperator.Equals
+                }, [
+                    {
+                        property: "dateCreated",
+                        sortDirection: entity.SortDirection.Ascending
+                    }
+                ], undefined, changesetsResult?.cursor);
+                for (const changeset of changesetsResult.entities) {
+                    if (core.Is.stringValue(changeset.proofId)) {
+                        await this._immutableProofComponent.removeImmutable(changeset.proofId, nodeIdentity);
+                        delete changeset.proofId;
+                        await this._changesetStorage.set(changeset);
+                    }
+                }
+            } while (core.Is.stringValue(changesetsResult.cursor));
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "removeImmutableFailed", 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 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 page of entities.
+     * @param pageSize The maximum number of entities in a page.
+     * @returns The entities, which can be partial if a limited keys list was provided.
+     */
+    async query(options, orderBy, orderByDirection, properties, cursor, pageSize) {
+        try {
+            const propertiesToReturn = properties ?? [
+                "id",
+                "dateCreated",
+                "dateModified",
+                "aliases",
+                "vertexObject"
+            ];
+            const conditions = [];
+            const orderProperty = orderBy ?? "dateCreated";
+            const orderDirection = orderByDirection ?? entity.SortDirection.Descending;
+            const idOrAlias = options?.id;
+            if (core.Is.stringValue(idOrAlias)) {
+                const idMode = options?.idMode ?? "both";
+                if (idMode === "id" || idMode === "both") {
+                    conditions.push({
+                        property: "id",
+                        comparison: entity.ComparisonOperator.Includes,
+                        value: idOrAlias
+                    });
+                }
+                if (idMode === "alias" || idMode === "both") {
+                    conditions.push({
+                        property: "aliasIndex",
+                        comparison: entity.ComparisonOperator.Includes,
+                        value: idOrAlias.toLowerCase()
+                    });
+                }
+            }
+            if (!propertiesToReturn.includes("id")) {
+                propertiesToReturn.unshift("id");
+            }
+            const results = await this._vertexStorage.query(conditions.length > 0
+                ? {
+                    conditions,
+                    logicalOperator: entity.LogicalOperator.Or
+                }
+                : undefined, [
+                {
+                    property: orderProperty,
+                    sortDirection: orderDirection
+                }
+            ], propertiesToReturn, cursor, pageSize);
+            const models = results.entities.map(e => this.vertexEntityToJsonLd(e));
+            const vertexList = {
+                "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                type: auditableItemGraphModels.AuditableItemGraphTypes.VertexList,
+                vertices: models,
+                cursor: results.cursor
+            };
+            const compacted = await dataJsonLd.JsonLdProcessor.compact(vertexList, vertexList["@context"]);
+            return compacted;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.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": [
+                auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot,
+                immutableProofModels.ImmutableProofTypes.ContextRoot,
+                dataSchemaOrg.SchemaOrgTypes.ContextRoot
+            ],
+            type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
+            id: vertexEntity.id,
+            dateCreated: vertexEntity.dateCreated,
+            dateModified: vertexEntity.dateModified,
+            nodeIdentity: vertexEntity.nodeIdentity,
+            vertexObject: vertexEntity.vertexObject
+        };
+        if (core.Is.arrayValue(vertexEntity.aliases)) {
+            model.aliases ??= [];
+            for (const aliasEntity of vertexEntity.aliases) {
+                const aliasModel = {
+                    "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                    type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
+                    id: aliasEntity.id,
+                    aliasFormat: aliasEntity.aliasFormat,
+                    dateCreated: aliasEntity.dateCreated,
+                    dateModified: aliasEntity.dateModified,
+                    dateDeleted: aliasEntity.dateDeleted,
+                    aliasObject: aliasEntity.aliasObject
+                };
+                model.aliases.push(aliasModel);
+            }
+        }
+        if (core.Is.arrayValue(vertexEntity.resources)) {
+            model.resources ??= [];
+            for (const resourceEntity of vertexEntity.resources) {
+                const resourceModel = {
+                    "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                    type: auditableItemGraphModels.AuditableItemGraphTypes.Resource,
+                    id: resourceEntity.id,
+                    dateCreated: resourceEntity.dateCreated,
+                    dateModified: resourceEntity.dateModified,
+                    dateDeleted: resourceEntity.dateDeleted,
+                    resourceObject: resourceEntity.resourceObject
+                };
+                model.resources.push(resourceModel);
+            }
+        }
+        if (core.Is.arrayValue(vertexEntity.edges)) {
+            model.edges ??= [];
+            for (const edgeEntity of vertexEntity.edges) {
+                const edgeModel = {
+                    "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                    type: auditableItemGraphModels.AuditableItemGraphTypes.Edge,
+                    id: edgeEntity.id,
+                    dateCreated: edgeEntity.dateCreated,
+                    dateModified: edgeEntity.dateModified,
+                    dateDeleted: edgeEntity.dateDeleted,
+                    edgeRelationship: edgeEntity.edgeRelationship,
+                    edgeObject: edgeEntity.edgeObject
+                };
+                model.edges.push(edgeModel);
+            }
+        }
+        return model;
+    }
+    /**
+     * Map the changeset entity to a JSON-LD.
+     * @param changesetEntity The changeset entity.
+     * @returns The model.
+     * @internal
+     */
+    changesetEntityToJsonLd(changesetEntity) {
+        const model = {
+            "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+            type: auditableItemGraphModels.AuditableItemGraphTypes.Changeset,
+            id: changesetEntity.id,
+            dateCreated: changesetEntity.dateCreated,
+            userIdentity: changesetEntity.userIdentity,
+            patches: changesetEntity.patches.map(p => ({
+                "@context": [auditableItemGraphModels.AuditableItemGraphTypes.ContextRoot, dataSchemaOrg.SchemaOrgTypes.ContextRoot],
+                type: auditableItemGraphModels.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 => core.Is.empty(a.dateDeleted)) ?? [];
+        // The active aliases that are not in the update list should be marked as deleted.
+        if (core.Is.arrayValue(active)) {
+            for (const alias of active) {
+                if (!aliases?.find(a => a.id === alias.id)) {
+                    alias.dateDeleted = context.now;
+                }
+            }
+        }
+        if (core.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) {
+        core.Guards.object(this.CLASS_NAME, "alias", alias);
+        core.Guards.stringValue(this.CLASS_NAME, "alias.id", alias.id);
+        if (core.Is.object(alias.aliasObject)) {
+            const validationFailures = [];
+            await dataJsonLd.JsonLdHelper.validate(alias.aliasObject, validationFailures);
+            core.Validation.asValidationError(this.CLASS_NAME, "alias.aliasObject", validationFailures);
+        }
+        // Try to find an existing alias with the same id.
+        const existing = vertex.aliases?.find(a => a.id === alias.id);
+        if (core.Is.empty(existing) || !core.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,
+                aliasObject: alias.aliasObject
+            };
+            vertex.aliases.push(model);
+        }
+        else if (existing.aliasFormat !== alias.aliasFormat ||
+            !core.ObjectHelper.equal(existing.aliasObject, alias.aliasObject, false)) {
+            // Existing alias found, update the aliasObject.
+            existing.dateModified = context.now;
+            existing.aliasFormat = alias.aliasFormat;
+            existing.aliasObject = alias.aliasObject;
+        }
+    }
+    /**
+     * 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) {
+        const active = vertex.resources?.filter(r => core.Is.empty(r.dateDeleted)) ?? [];
+        // The active resources that are not in the update list should be marked as deleted.
+        if (core.Is.arrayValue(active)) {
+            for (const resource of active) {
+                if (!resources?.find(a => a.id === resource.id)) {
+                    resource.dateDeleted = context.now;
+                }
+            }
+        }
+        if (core.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) {
+        core.Guards.object(this.CLASS_NAME, "resource", resource);
+        core.Guards.stringValue(this.CLASS_NAME, "resource.id", resource.id);
+        if (core.Is.object(resource.resourceObject)) {
+            const validationFailures = [];
+            await dataJsonLd.JsonLdHelper.validate(resource.resourceObject, validationFailures);
+            core.Validation.asValidationError(this.CLASS_NAME, "resource.resourceObject", validationFailures);
+        }
+        // Try to find an existing resource with the same id.
+        const existing = vertex.resources?.find(r => r.id === resource.id);
+        if (core.Is.empty(existing) || !core.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 (!core.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 => core.Is.empty(e.dateDeleted)) ?? [];
+        // The active edges that are not in the update list should be marked as deleted.
+        if (core.Is.arrayValue(active)) {
+            for (const edge of active) {
+                if (!edges?.find(a => a.id === edge.id)) {
+                    edge.dateDeleted = context.now;
+                }
+            }
+        }
+        if (core.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) {
+        core.Guards.object(this.CLASS_NAME, "edge", edge);
+        core.Guards.stringValue(this.CLASS_NAME, "edge.id", edge.id);
+        core.Guards.stringValue(this.CLASS_NAME, "edge.edgeRelationship", edge.edgeRelationship);
+        if (core.Is.object(edge.edgeObject)) {
+            const validationFailures = [];
+            await dataJsonLd.JsonLdHelper.validate(edge.edgeObject, validationFailures);
+            core.Validation.asValidationError(this.CLASS_NAME, "edge.edgeObject", validationFailures);
+        }
+        // Try to find an existing edge with the same id.
+        const existing = vertex.edges?.find(r => r.id === edge.id);
+        if (core.Is.empty(existing) || !core.Is.empty(existing?.dateDeleted)) {
+            // Did not find a matching item, or found one which is deleted.
+            vertex.edges ??= [];
+            const model = {
+                id: edge.id,
+                dateCreated: context.now,
+                edgeObject: edge.edgeObject,
+                edgeRelationship: edge.edgeRelationship
+            };
+            vertex.edges.push(model);
+        }
+        else if (existing.edgeRelationship !== edge.edgeRelationship ||
+            !core.ObjectHelper.equal(existing.edgeObject, edge.edgeObject, false)) {
+            // Existing resource found, update the edgeObject.
+            existing.dateModified = context.now;
+            existing.edgeRelationship = edge.edgeRelationship;
+            existing.edgeObject = edge.edgeObject;
+        }
+    }
+    /**
+     * 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 = core.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: core.Converter.bytesToHex(core.RandomHelper.generate(32), false),
+                vertexId: updated.id,
+                dateCreated: context.now,
+                userIdentity: context.userIdentity,
+                patches,
+                proofId: ""
+            };
+            // 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({
+                ...core.ObjectHelper.pick(changesetEntity, AuditableItemGraphService._PROOF_KEYS_CHANGESET),
+                id: `${AuditableItemGraphService.NAMESPACE}:${updated.id}:${AuditableItemGraphService.NAMESPACE_CHANGESET}:${changesetEntity.id}`
+            });
+            // Create the proof for the changeset object
+            changesetEntity.proofId = await this._immutableProofComponent.create(reducedChangesetJsonLd, context.userIdentity, context.nodeIdentity);
+            // Link the immutable storage id to the changeset
+            await this._changesetStorage.set(changesetEntity);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 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;
+        do {
+            changesetsResult = await this._changesetStorage.query({
+                property: "vertexId",
+                value: vertex.id,
+                comparison: entity.ComparisonOperator.Equals
+            }, [
+                {
+                    property: "dateCreated",
+                    sortDirection: entity.SortDirection.Ascending
+                }
+            ], undefined, changesetsResult?.cursor);
+            const storedChangesets = changesetsResult.entities;
+            if (core.Is.arrayValue(storedChangesets)) {
+                for (let i = 0; i < storedChangesets.length; i++) {
+                    const storedChangeset = storedChangesets[i];
+                    const storedChangesetJsonLd = this.changesetEntityToJsonLd(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 === auditableItemGraphModels.VerifyDepth.All ||
+                        (verifySignatureDepth === auditableItemGraphModels.VerifyDepth.Current &&
+                            !core.Is.stringValue(changesetsResult.cursor) &&
+                            i === storedChangesets.length - 1)) {
+                        if (!core.Is.stringValue(storedChangeset.proofId)) {
+                            verified = false;
+                            storedChangesetJsonLd.verification = {
+                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
+                                verified: false,
+                                failure: immutableProofModels.ImmutableProofFailure.ProofMissing
+                            };
+                        }
+                        else {
+                            // 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(core.ObjectHelper.pick(storedChangeset, AuditableItemGraphService._PROOF_KEYS_CHANGESET));
+                            // Verify the proof for the changeset object
+                            storedChangesetJsonLd.verification = await this._immutableProofComponent.verify(storedChangeset.proofId, reducedChangesetJsonLd);
+                            if (!storedChangesetJsonLd.verification.verified) {
+                                verified = false;
+                            }
+                        }
+                    }
+                }
+            }
+        } while (core.Is.stringValue(changesetsResult.cursor));
+        return {
+            verified,
+            changesets
+        };
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the auditable item graph alias.
+ */
+exports.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.
+     */
+    aliasObject;
+};
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphAlias.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphAlias.prototype, "aliasFormat", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphAlias.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphAlias.prototype, "dateModified", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphAlias.prototype, "dateDeleted", void 0);
+__decorate([
+    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.NodeObject }),
+    __metadata("design:type", Object)
+], exports.AuditableItemGraphAlias.prototype, "aliasObject", void 0);
+exports.AuditableItemGraphAlias = __decorate([
+    entity.entity()
+], exports.AuditableItemGraphAlias);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing a set of updates to the vertex.
+ */
+exports.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([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphChangeset.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphChangeset.prototype, "vertexId", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphChangeset.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphChangeset.prototype, "userIdentity", void 0);
+__decorate([
+    entity.property({ type: "array", itemTypeRef: "AuditableItemGraphPatch" }),
+    __metadata("design:type", Array)
+], exports.AuditableItemGraphChangeset.prototype, "patches", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphChangeset.prototype, "proofId", void 0);
+exports.AuditableItemGraphChangeset = __decorate([
+    entity.entity()
+], exports.AuditableItemGraphChangeset);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the auditable item graph edge.
+ */
+exports.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 relationship between the two vertices.
+     */
+    edgeRelationship;
+    /**
+     * Object to associate with the edge as JSON-LD.
+     */
+    edgeObject;
+};
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphEdge.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphEdge.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphEdge.prototype, "dateModified", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphEdge.prototype, "dateDeleted", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphEdge.prototype, "edgeRelationship", void 0);
+__decorate([
+    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.NodeObject }),
+    __metadata("design:type", Object)
+], exports.AuditableItemGraphEdge.prototype, "edgeObject", void 0);
+exports.AuditableItemGraphEdge = __decorate([
+    entity.entity()
+], exports.AuditableItemGraphEdge);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the auditable item graph patches.
+ */
+exports.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([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphPatch.prototype, "op", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphPatch.prototype, "path", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphPatch.prototype, "from", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.AuditableItemGraphPatch.prototype, "value", void 0);
+exports.AuditableItemGraphPatch = __decorate([
+    entity.entity()
+], exports.AuditableItemGraphPatch);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the auditable item graph vertex resource.
+ */
+exports.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([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphResource.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphResource.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphResource.prototype, "dateModified", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphResource.prototype, "dateDeleted", void 0);
+__decorate([
+    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.NodeObject }),
+    __metadata("design:type", Object)
+], exports.AuditableItemGraphResource.prototype, "resourceObject", void 0);
+exports.AuditableItemGraphResource = __decorate([
+    entity.entity()
+], exports.AuditableItemGraphResource);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the auditable item graph vertex.
+ */
+exports.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;
+    /**
+     * Object to associate with the vertex as JSON-LD.
+     */
+    vertexObject;
+    /**
+     * 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([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphVertex.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphVertex.prototype, "nodeIdentity", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphVertex.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphVertex.prototype, "dateModified", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemGraphVertex.prototype, "aliasIndex", void 0);
+__decorate([
+    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.NodeObject }),
+    __metadata("design:type", Object)
+], exports.AuditableItemGraphVertex.prototype, "vertexObject", void 0);
+__decorate([
+    entity.property({ type: "array", itemType: "string" }),
+    __metadata("design:type", Array)
+], exports.AuditableItemGraphVertex.prototype, "aliases", void 0);
+__decorate([
+    entity.property({ type: "array", itemTypeRef: "AuditableItemGraphResource" }),
+    __metadata("design:type", Array)
+], exports.AuditableItemGraphVertex.prototype, "resources", void 0);
+__decorate([
+    entity.property({ type: "array", itemTypeRef: "AuditableItemGraphEdge" }),
+    __metadata("design:type", Array)
+], exports.AuditableItemGraphVertex.prototype, "edges", void 0);
+exports.AuditableItemGraphVertex = __decorate([
+    entity.entity()
+], exports.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() {
+    entity.EntitySchemaFactory.register("AuditableItemGraphVertex", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphVertex));
+    entity.EntitySchemaFactory.register("AuditableItemGraphAlias", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphAlias));
+    entity.EntitySchemaFactory.register("AuditableItemGraphResource", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphResource));
+    entity.EntitySchemaFactory.register("AuditableItemGraphEdge", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphEdge));
+    entity.EntitySchemaFactory.register("AuditableItemGraphChangeset", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphChangeset));
+    entity.EntitySchemaFactory.register("AuditableItemGraphPatch", () => entity.EntitySchemaHelper.getSchema(exports.AuditableItemGraphPatch));
+}
+
+exports.AuditableItemGraphService = AuditableItemGraphService;
+exports.auditableItemGraphCreate = auditableItemGraphCreate;
+exports.auditableItemGraphGet = auditableItemGraphGet;
+exports.auditableItemGraphList = auditableItemGraphList;
+exports.auditableItemGraphUpdate = auditableItemGraphUpdate;
+exports.generateRestRoutesAuditableItemGraph = generateRestRoutesAuditableItemGraph;
+exports.initSchema = initSchema;
+exports.restEntryPoints = restEntryPoints;
+exports.tagsAuditableItemGraph = tagsAuditableItemGraph;