@twin.org/document-management-service 0.0.1-next.10

package/dist/esm/index.mjs

@@ -0,0 +1,1015 @@
+import { AuditableItemGraphTypes, AuditableItemGraphContexts } from '@twin.org/auditable-item-graph-models';
+import { Guards, ComponentFactory, Converter, Coerce, Is, BaseError, GeneralError, Urn, NotFoundError, ObjectHelper } from '@twin.org/core';
+import { DocumentTypes, DocumentContexts } from '@twin.org/document-management-models';
+import { SchemaOrgContexts, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
+import { UneceDocumentCodes } from '@twin.org/standards-unece';
+import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
+import { AttestationContexts } from '@twin.org/attestation-models';
+import { BlobStorageContexts } from '@twin.org/blob-storage-models';
+import { Sha256 } from '@twin.org/crypto';
+import { JsonLdProcessor } from '@twin.org/data-json-ld';
+
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "documentManagementStorageRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const tagsDocumentManagement = [
+    {
+        name: "Document Management",
+        description: "Endpoints which are modelled to access a document management contract."
+    }
+];
+/**
+ * The REST routes for document management.
+ * @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 generateRestRoutesDocumentManagement(baseRouteName, componentName) {
+    const documentManagementCreateRoute = {
+        operationId: "DocumentManagementSet",
+        summary: "Store a document in an auditable item graph vertex and add its content to blob storage.",
+        tag: tagsDocumentManagement[0].name,
+        method: "POST",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => documentManagementCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementCreateRequest",
+            examples: [
+                {
+                    id: "DocumentManagementCreateRequestExample",
+                    request: {
+                        body: {
+                            documentId: "2721000",
+                            documentIdFormat: "bol",
+                            documentCode: UneceDocumentCodes.BillOfLading,
+                            blob: "SGVsbG8gV29ybGQ=",
+                            annotationObject: {
+                                "@context": "https://schema.org",
+                                "@type": "DigitalDocument",
+                                name: "myfile.pdf"
+                            },
+                            createAttestation: true
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementCreateResponseExample",
+                        response: {
+                            statusCode: HttpStatusCode.created,
+                            headers: {
+                                [HeaderTypes.Location]: "aig:123456"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const documentManagementUpdateRoute = {
+        operationId: "DocumentManagementUpdate",
+        summary: "Update a document in an auditable item graph vertex and add its content to blob storage.",
+        tag: tagsDocumentManagement[0].name,
+        method: "PUT",
+        path: `${baseRouteName}/:auditableItemGraphDocumentId`,
+        handler: async (httpRequestContext, request) => documentManagementUpdate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementUpdateRequest",
+            examples: [
+                {
+                    id: "DocumentManagementUpdateRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphDocumentId: "aig:123456"
+                        },
+                        body: {
+                            blob: "SGVsbG8gV29ybGQ=",
+                            annotationObject: {
+                                "@context": "https://schema.org",
+                                "@type": "DigitalDocument",
+                                name: "myfile.pdf"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementCreateResponseExample",
+                        response: {
+                            statusCode: HttpStatusCode.noContent
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const documentManagementGetRoute = {
+        operationId: "DocumentManagementGet",
+        summary: "Get the data for a document from document management",
+        tag: tagsDocumentManagement[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:auditableItemGraphDocumentId`,
+        handler: async (httpRequestContext, request) => documentManagementGet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementGetRequest",
+            examples: [
+                {
+                    id: "DocumentManagementGetRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphDocumentId: "aig:123456"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDocumentManagementGetResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [DocumentContexts.ContextRoot, DocumentContexts.ContextRootCommon],
+                                type: DocumentTypes.DocumentList,
+                                documents: [
+                                    {
+                                        "@context": [
+                                            DocumentContexts.ContextRoot,
+                                            DocumentContexts.ContextRootCommon,
+                                            SchemaOrgContexts.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "2721000:0",
+                                        documentId: "2721000",
+                                        documentIdFormat: "bol",
+                                        documentCode: UneceDocumentCodes.BillOfLading,
+                                        documentRevision: 0,
+                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
+                                        blobHash: "sha256:123456",
+                                        dateCreated: "2024-01-01T00:00:00Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "DigitalDocument",
+                                            name: "myfile.pdf"
+                                        },
+                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
+                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IDocumentManagementGetResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [DocumentContexts.ContextRoot, DocumentContexts.ContextRootCommon],
+                                type: DocumentTypes.DocumentList,
+                                documents: [
+                                    {
+                                        "@context": [
+                                            DocumentContexts.ContextRoot,
+                                            DocumentContexts.ContextRootCommon,
+                                            SchemaOrgContexts.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "2721000:0",
+                                        documentId: "2721000",
+                                        documentIdFormat: "bol",
+                                        documentCode: UneceDocumentCodes.BillOfLading,
+                                        documentRevision: 0,
+                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
+                                        blobHash: "sha256:123456",
+                                        dateCreated: "2024-01-01T00:00:00Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "DigitalDocument",
+                                            name: "myfile.pdf"
+                                        },
+                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
+                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const documentManagementRemoveRoute = {
+        operationId: "DocumentManagementRemove",
+        summary: "Remove an document from an auditable item graph vertex",
+        tag: tagsDocumentManagement[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:auditableItemGraphDocumentId/:revision`,
+        handler: async (httpRequestContext, request) => documentManagementRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementRemoveRequest",
+            examples: [
+                {
+                    id: "DocumentManagementRemoveRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphDocumentId: "aig:1234",
+                            revision: "1"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const documentManagementQueryRoute = {
+        operationId: "DocumentManagementQuery",
+        summary: "Query the items from an auditable item graph vertex",
+        tag: tagsDocumentManagement[0].name,
+        method: "GET",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => documentManagementQuery(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementQueryRequest",
+            examples: [
+                {
+                    id: "DocumentManagementQueryRequestExample",
+                    request: {
+                        query: {
+                            documentId: "2721000"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDocumentManagementQueryResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementQueryResponseExample",
+                        response: {
+                            body: {
+                                "@context": [AuditableItemGraphContexts.ContextRoot],
+                                type: AuditableItemGraphTypes.VertexList,
+                                vertices: [
+                                    {
+                                        "@context": [
+                                            AuditableItemGraphContexts.ContextRoot,
+                                            AuditableItemGraphContexts.ContextRootCommon
+                                        ],
+                                        id: "aig:c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7",
+                                        type: AuditableItemGraphTypes.Vertex,
+                                        dateCreated: "2024-08-22T04:13:20.000Z",
+                                        aliases: [
+                                            {
+                                                "@context": [AuditableItemGraphContexts.ContextRoot],
+                                                id: "test-id-0",
+                                                type: AuditableItemGraphTypes.Alias,
+                                                dateCreated: "2024-08-22T04:13:20.000Z"
+                                            }
+                                        ],
+                                        resources: [
+                                            {
+                                                "@context": AuditableItemGraphContexts.ContextRoot,
+                                                type: AuditableItemGraphTypes.Resource,
+                                                dateCreated: "2024-08-22T04:13:20.000Z",
+                                                resourceObject: {
+                                                    "@context": [
+                                                        "https://schema.twindev.org/documents/",
+                                                        "https://schema.twindev.org/common/",
+                                                        "https://schema.org"
+                                                    ],
+                                                    type: "Document",
+                                                    id: "test-id-0:0",
+                                                    documentId: "test-id-0",
+                                                    documentCode: "unece:DocumentCodeList#705",
+                                                    documentRevision: 0,
+                                                    annotationObject: {
+                                                        "@context": "https://schema.org",
+                                                        type: "DigitalDocument",
+                                                        name: "bill-of-lading"
+                                                    },
+                                                    blobHash: "sha256:E3Duqrp6bHojSx+CzDttAToAiP1eFkCDAPBbKLABVGM=",
+                                                    blobStorageId: "blob:memory:1370eeaaba7a6c7a234b1f82cc3b6d013a0088fd5e16408300f05b28b0015463",
+                                                    dateCreated: "2024-08-22T04:13:20.000Z",
+                                                    nodeIdentity: "did:entity-storage:0x0101010101010101010101010101010101010101010101010101010101010101",
+                                                    userIdentity: "did:entity-storage:0x0404040404040404040404040404040404040404040404040404040404040404"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    return [
+        documentManagementCreateRoute,
+        documentManagementUpdateRoute,
+        documentManagementGetRoute,
+        documentManagementRemoveRoute,
+        documentManagementQueryRoute
+    ];
+}
+/**
+ * Create a document as an auditable item 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 documentManagementCreate(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    Guards.stringBase64(ROUTES_SOURCE, "request.body.blob", request.body.blob);
+    const component = ComponentFactory.get(componentName);
+    const id = await component.create(request.body.documentId, request.body.documentIdFormat, request.body.documentCode, Converter.base64ToBytes(request.body.blob), request.body.annotationObject, request.body.auditableItemGraphEdges, {
+        createAttestation: request.body.createAttestation,
+        addAlias: request.body.addAlias,
+        aliasAnnotationObject: request.body.aliasAnnotationObject
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: HttpStatusCode.created,
+        headers: {
+            location: id
+        }
+    };
+}
+/**
+ * Get the document from the auditable item 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 documentManagementGet(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.get(request.pathParams.auditableItemGraphDocumentId, {
+        includeBlobStorageMetadata: Coerce.boolean(request.query?.includeBlobStorageMetadata),
+        includeBlobStorageData: Coerce.boolean(request.query?.includeBlobStorageData),
+        includeAttestation: Coerce.boolean(request.query?.includeAttestation),
+        includeRemoved: Coerce.boolean(request.query?.includeRemoved)
+    }, request.query?.cursor, Coerce.integer(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+/**
+ * UPdate the document from the auditable item 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 documentManagementUpdate(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const component = ComponentFactory.get(componentName);
+    await component.update(request.pathParams.auditableItemGraphDocumentId, Is.stringValue(request.body.blob) ? Converter.base64ToBytes(request.body.blob) : undefined, request.body.annotationObject, request.body.auditableItemGraphEdges, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Remove the document from the auditable item 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 documentManagementRemove(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const revision = Coerce.number(request.pathParams.revision);
+    Guards.integer(ROUTES_SOURCE, "request.pathParams.revision", revision);
+    const component = ComponentFactory.get(componentName);
+    await component.removeRevision(request.pathParams.auditableItemGraphDocumentId, revision, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Query the documents from an auditable item 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 documentManagementQuery(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    Guards.stringValue(ROUTES_SOURCE, "request.query.documentId", request.query.documentId);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.query(request.query.documentId, request.query?.cursor, Coerce.integer(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+
+/**
+ * Service for performing document management operations.
+ */
+class DocumentManagementService {
+    /**
+     * The namespace supported by the document management service.
+     */
+    static NAMESPACE = "documents";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "DocumentManagementService";
+    /**
+     * The component for the auditable item graph.
+     * @internal
+     */
+    _auditableItemGraphComponent;
+    /**
+     * The connector for the blob component.
+     * @internal
+     */
+    _blobStorageComponent;
+    /**
+     * The connector for the attestation.
+     * @internal
+     */
+    _attestationComponent;
+    /**
+     * Create a new instance of DocumentManagementService.
+     * @param options The options for the service.
+     */
+    constructor(options) {
+        this._auditableItemGraphComponent = ComponentFactory.get(options?.auditableItemGraphComponentType ?? "auditable-item-graph");
+        this._blobStorageComponent = ComponentFactory.get(options?.blobStorageComponentType ?? "blob-storage");
+        this._attestationComponent = ComponentFactory.get(options?.attestationComponentType ?? "attestation");
+        SchemaOrgDataTypes.registerRedirects();
+    }
+    /**
+     * Store a document as an auditable item graph vertex and add its content to blob storage.
+     * If the document id already exists and the blob data is different a new revision will be created.
+     * For any other changes the current revision will be updated.
+     * @param documentId The document id to create.
+     * @param documentIdFormat The format of the document identifier.
+     * @param documentCode The code for the document type.
+     * @param blob The data to create the document with.
+     * @param annotationObject Additional information to associate with the document.
+     * @param auditableItemGraphEdges The auditable item graph vertices to connect the document to.
+     * @param options Additional options for the set operation.
+     * @param options.createAttestation Flag to create an attestation for the document, defaults to false.
+     * @param options.addAlias Flag to add the document id as an alias to the aig vertex, defaults to true.
+     * @param options.aliasAnnotationObject Annotation object for the alias.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The auditable item graph vertex created for the document including its revision.
+     */
+    async create(documentId, documentIdFormat, documentCode, blob, annotationObject, auditableItemGraphEdges, options, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
+        Guards.arrayOneOf(this.CLASS_NAME, "documentCode", documentCode, Object.values(UneceDocumentCodes));
+        Guards.uint8Array(this.CLASS_NAME, "blob", blob);
+        Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            // Get the connected vertices first, if one fails we abort the create
+            const connectedVertices = {};
+            if (Is.arrayValue(auditableItemGraphEdges)) {
+                for (const edge of auditableItemGraphEdges) {
+                    connectedVertices[edge.id] = await this._auditableItemGraphComponent.get(edge.id);
+                }
+            }
+            const documentVertex = {};
+            if (options?.addAlias ?? true) {
+                documentVertex.aliases ??= [];
+                documentVertex.aliases.push({
+                    "@context": AuditableItemGraphContexts.ContextRoot,
+                    type: AuditableItemGraphTypes.Alias,
+                    id: documentId,
+                    aliasFormat: documentIdFormat,
+                    annotationObject: options?.aliasAnnotationObject
+                });
+            }
+            // Add the blob to blob storage
+            const blobStorageId = await this._blobStorageComponent.create(Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
+            const currentRevision = {
+                "@context": [
+                    DocumentContexts.ContextRoot,
+                    DocumentContexts.ContextRootCommon,
+                    SchemaOrgContexts.ContextRoot
+                ],
+                type: DocumentTypes.Document,
+                id: `${documentId}:0`,
+                documentId,
+                documentIdFormat,
+                documentCode,
+                documentRevision: 0,
+                annotationObject,
+                blobHash: this.generateBlobHash(blob),
+                blobStorageId,
+                dateCreated: new Date(Date.now()).toISOString(),
+                nodeIdentity,
+                userIdentity
+            };
+            if (options?.createAttestation ?? false) {
+                currentRevision.attestationId = await this.createAttestation(currentRevision, userIdentity, nodeIdentity);
+            }
+            // Add the new revision in to the vertex
+            documentVertex.resources ??= [];
+            documentVertex.resources.push({
+                "@context": AuditableItemGraphContexts.ContextRoot,
+                type: AuditableItemGraphTypes.Resource,
+                resourceObject: currentRevision
+            });
+            // Add the edges from the document to the items
+            this.updateEdges(documentVertex, auditableItemGraphEdges);
+            // And create the vertex
+            const vertexId = await this._auditableItemGraphComponent.create(documentVertex, userIdentity, nodeIdentity);
+            // Now add the edges to the connected vertices
+            await this.updateConnectedEdges(connectedVertices, vertexId, [], auditableItemGraphEdges, documentId, documentIdFormat, userIdentity, nodeIdentity);
+            return vertexId;
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
+        }
+    }
+    /**
+     * Update a document as an auditable item graph vertex and add its content to blob storage.
+     * If the blob data is different a new revision will be created.
+     * For any other changes the current revision will be updated.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param blob The data to update the document with.
+     * @param annotationObject Additional information to associate with the document.
+     * @param auditableItemGraphEdges The auditable item graph vertices to connect the document to, if undefined retains current connections.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     */
+    async update(auditableItemGraphDocumentId, blob, annotationObject, auditableItemGraphEdges, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId);
+            if (Is.empty(documentVertex.resources)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            const documents = await this.getDocumentsFromVertex(documentVertex);
+            const latestRevision = documents.documents[0];
+            if (Is.empty(latestRevision)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            // If auditableItemGraphEdges is undefined we are not updating the edges
+            // an empty array can be passed to remove all edges
+            const connectedVertices = {};
+            if (Is.array(auditableItemGraphEdges)) {
+                // Get the updated connected vertices first, if one fails we abort the update
+                for (const edge of auditableItemGraphEdges) {
+                    connectedVertices[edge.id] = await this._auditableItemGraphComponent.get(edge.id);
+                }
+                // Also get the current edges in case some need disconnecting
+                if (Is.arrayValue(documents.edges)) {
+                    for (const edgeId of documents.edges) {
+                        // If we haven't retrieved the edge then it must be one that needs removing
+                        if (Is.empty(connectedVertices[edgeId])) {
+                            connectedVertices[edgeId] = await this._auditableItemGraphComponent.get(edgeId);
+                        }
+                    }
+                }
+            }
+            let updatedVertex = false;
+            // If the blob is set and its hash has changed then we create a new revision
+            if (Is.uint8Array(blob)) {
+                const newBlobHash = this.generateBlobHash(blob);
+                if (latestRevision.blobHash !== newBlobHash) {
+                    // Add the blob to blob storage
+                    const blobStorageId = await this._blobStorageComponent.create(Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
+                    const newRevision = ObjectHelper.clone(latestRevision);
+                    newRevision.documentRevision++;
+                    newRevision.id = `${newRevision.documentId}:${newRevision.documentRevision}`;
+                    newRevision.blobHash = newBlobHash;
+                    newRevision.blobStorageId = blobStorageId;
+                    newRevision.annotationObject = annotationObject;
+                    if (Is.stringValue(latestRevision.attestationId)) {
+                        newRevision.attestationId = await this.createAttestation(newRevision, userIdentity, nodeIdentity);
+                    }
+                    documentVertex.resources.push({
+                        "@context": AuditableItemGraphContexts.ContextRoot,
+                        type: AuditableItemGraphTypes.Resource,
+                        resourceObject: newRevision
+                    });
+                    updatedVertex = true;
+                }
+            }
+            // If the blob wasn't updated but the annotation object has then update the current revision
+            // instead of creating a new one
+            if (!updatedVertex &&
+                !ObjectHelper.equal(latestRevision.annotationObject, annotationObject)) {
+                updatedVertex = true;
+                latestRevision.annotationObject = annotationObject;
+                latestRevision.dateModified = new Date(Date.now()).toISOString();
+            }
+            const existingEdgeIds = documentVertex.edges?.map(e => e.id) ?? [];
+            // Update the edges from the document to the items
+            const edgesUpdated = this.updateEdges(documentVertex, auditableItemGraphEdges);
+            if (edgesUpdated) {
+                updatedVertex = true;
+            }
+            if (updatedVertex) {
+                await this._auditableItemGraphComponent.update(documentVertex, userIdentity, nodeIdentity);
+            }
+            if (edgesUpdated) {
+                await this.updateConnectedEdges(connectedVertices, auditableItemGraphDocumentId, existingEdgeIds, auditableItemGraphEdges, latestRevision.documentId, latestRevision.documentIdFormat, userIdentity, nodeIdentity);
+            }
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
+        }
+    }
+    /**
+     * Get a document using it's auditable item graph vertex id and optional revision.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param options Additional options for the get operation.
+     * @param options.includeBlobStorageMetadata Flag to include the blob storage metadata for the document, defaults to false.
+     * @param options.includeBlobStorageData Flag to include the blob storage data for the document, defaults to false.
+     * @param options.includeAttestation Flag to include the attestation information for the document, defaults to false.
+     * @param options.includeRemoved Flag to include deleted documents, defaults to false.
+     * @param cursor The cursor to get the next chunk of revisions.
+     * @param pageSize Page size of items to return, defaults to 1 so only most recent is returned.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The documents and revisions if requested, ordered by revision descending, cursor is set if there are more document revisions.
+     */
+    async get(auditableItemGraphDocumentId, options, cursor, pageSize, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        try {
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: options?.includeRemoved });
+            // Populate the document and revisions with the options set
+            const documents = await this.getDocumentsFromVertex(documentVertex, options, cursor, pageSize, userIdentity, nodeIdentity);
+            return JsonLdProcessor.compact(documents, documents["@context"]);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove an auditable item graph vertex using it's id.
+     * The document dateDeleted will be set, but can still be queried with the includeRemoved flag.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param revision The revision of the document to remove.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     */
+    async removeRevision(auditableItemGraphDocumentId, revision, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        Guards.number(this.CLASS_NAME, "revision", revision);
+        try {
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId);
+            if (Is.empty(documentVertex.resources)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            const docRevisionIndex = documentVertex.resources.findIndex(d => d.resourceObject?.documentRevision === revision);
+            if (docRevisionIndex === -1) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", revision.toString());
+            }
+            documentVertex.resources.splice(docRevisionIndex, 1);
+            await this._auditableItemGraphComponent.update(documentVertex, userIdentity, nodeIdentity);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "removeRevisionFailed", undefined, error);
+        }
+    }
+    /**
+     * Find all the document with a specific id.
+     * @param documentId The document id to find in the graph.
+     * @param cursor The cursor to get the next chunk of documents.
+     * @param pageSize The page size to get the next chunk of documents.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The graph vertices that contain documents referencing the specified document id.
+     */
+    async query(documentId, cursor, pageSize, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
+        try {
+            return this._auditableItemGraphComponent.query({
+                id: documentId,
+                idMode: "both",
+                resourceTypes: [DocumentTypes.Document]
+            }, undefined, undefined, undefined, ["id", "dateCreated", "dateModified", "aliases", "annotationObject", "resources", "edges"], cursor, pageSize);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "queryFailed", undefined, error);
+        }
+    }
+    /**
+     * Update the edges of the document vertex.
+     * @param documentVertex The document vertex to update.
+     * @param auditableItemGraphEdges The list of edges to use.
+     * @returns True if the edges were updated.
+     * @internal
+     */
+    updateEdges(documentVertex, auditableItemGraphEdges) {
+        let changed = false;
+        const existingEdgeIds = documentVertex.edges?.map(e => e.id) ?? [];
+        if (Is.array(auditableItemGraphEdges)) {
+            for (const aigEdge of auditableItemGraphEdges) {
+                const existingIndex = existingEdgeIds.indexOf(aigEdge.id);
+                if (existingIndex !== -1) {
+                    // If the edge already exists then we don't need to add it again
+                    // We just need to remove it from the list of existing ids
+                    // any remaining after this loop will be need to be removed
+                    existingEdgeIds.splice(existingIndex, 1);
+                }
+                else {
+                    const vertexEdge = {
+                        "@context": AuditableItemGraphContexts.ContextRoot,
+                        type: AuditableItemGraphTypes.Edge,
+                        id: aigEdge.id,
+                        edgeRelationships: ["document"]
+                    };
+                    documentVertex.edges ??= [];
+                    documentVertex.edges?.push(vertexEdge);
+                    changed = true;
+                }
+            }
+            // Anything left in the existingEdgeIds array means they need to be removed
+            if (existingEdgeIds.length > 0 && Is.array(documentVertex.edges)) {
+                for (const existingEdgeId of existingEdgeIds) {
+                    const existingIndex = documentVertex.edges.findIndex(e => e.id === existingEdgeId);
+                    if (existingIndex !== -1) {
+                        documentVertex.edges.splice(existingIndex, 1);
+                        changed = true;
+                    }
+                }
+            }
+        }
+        return changed;
+    }
+    /**
+     * Update the edges.
+     * @param connectedVertices The connected vertices for the edges.
+     * @param auditableItemGraphDocumentId The document id to use.
+     * @param documentVertex The document vertex to update.
+     * @param auditableItemGraphEdges The list of edges to use.
+     * @param documentId The document identifier.
+     * @param documentIdFormat The format of the document identifier.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @internal
+     */
+    async updateConnectedEdges(connectedVertices, auditableItemGraphDocumentId, existingEdgeIds, auditableItemGraphEdges, documentId, documentIdFormat, userIdentity, nodeIdentity) {
+        if (Is.array(auditableItemGraphEdges)) {
+            for (const aigEdge of auditableItemGraphEdges) {
+                const connected = connectedVertices[aigEdge.id];
+                if (!Is.empty(connected)) {
+                    let updatedConnected = false;
+                    const existingIndex = existingEdgeIds.indexOf(aigEdge.id);
+                    if (existingIndex !== -1) {
+                        // If the edge already exists we remove it from the list of existing ids
+                        // any remaining after this loop will be need to be disconnected
+                        existingEdgeIds.splice(existingIndex, 1);
+                    }
+                    // Add the edge with the document vertex id if it doesn't already exist
+                    const hasEdge = connected.edges?.some(e => e.id === auditableItemGraphDocumentId);
+                    if (!hasEdge) {
+                        const vertexEdge = {
+                            "@context": AuditableItemGraphContexts.ContextRoot,
+                            type: AuditableItemGraphTypes.Edge,
+                            id: auditableItemGraphDocumentId,
+                            edgeRelationships: ["document"]
+                        };
+                        connected.edges ??= [];
+                        connected.edges?.push(vertexEdge);
+                        updatedConnected = true;
+                    }
+                    // Add alias with the document id if option flag is set and it doesn't already exist
+                    if (aigEdge.addAlias) {
+                        const alias = connected.aliases?.find(a => a.id === documentId);
+                        if (Is.empty(alias)) {
+                            // No existing alias, so create one
+                            const vertexAlias = {
+                                "@context": AuditableItemGraphContexts.ContextRoot,
+                                type: AuditableItemGraphTypes.Alias,
+                                id: documentId,
+                                aliasFormat: documentIdFormat,
+                                annotationObject: aigEdge.aliasAnnotationObject
+                            };
+                            connected.aliases ??= [];
+                            connected.aliases?.push(vertexAlias);
+                            updatedConnected = true;
+                        }
+                        else if (!ObjectHelper.equal(alias.annotationObject, aigEdge.aliasAnnotationObject) ||
+                            documentIdFormat !== alias.aliasFormat) {
+                            // The alias already exists, but the format or annotation object has changed
+                            alias.annotationObject = aigEdge.aliasAnnotationObject;
+                            alias.aliasFormat = documentIdFormat;
+                            updatedConnected = true;
+                        }
+                    }
+                    if (updatedConnected) {
+                        await this._auditableItemGraphComponent.update(connected, userIdentity, nodeIdentity);
+                    }
+                }
+            }
+        }
+        // Anything left in the existingEdgeIds array means they need to be removed
+        if (existingEdgeIds.length > 0) {
+            for (const existingEdgeId of existingEdgeIds) {
+                const connected = connectedVertices[existingEdgeId];
+                if (!Is.empty(connected)) {
+                    let updatedConnected = false;
+                    // Remove the edge from the connected vertex
+                    if (Is.arrayValue(connected.edges)) {
+                        const existingIndex = connected.edges.findIndex(e => e.id === auditableItemGraphDocumentId);
+                        if (existingIndex !== -1) {
+                            connected.edges.splice(existingIndex, 1);
+                            updatedConnected = true;
+                        }
+                    }
+                    // Remove the alias from the connected vertex
+                    if (Is.arrayValue(connected.aliases)) {
+                        const existingIndex = connected.aliases.findIndex(e => e.id === documentId);
+                        if (existingIndex !== -1) {
+                            connected.aliases.splice(existingIndex, 1);
+                            updatedConnected = true;
+                        }
+                    }
+                    if (updatedConnected) {
+                        await this._auditableItemGraphComponent.update(connected, userIdentity, nodeIdentity);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Generate a hash for the blob data.
+     * @param blob The blob data to hash.
+     * @returns The hash.
+     * @internal
+     */
+    generateBlobHash(blob) {
+        return `sha256:${Converter.bytesToBase64(Sha256.sum256(blob))}`;
+    }
+    /**
+     * Get the documents from the auditable item graph vertex.
+     * @param documentVertex The vertex containing the documents.
+     * @param options Additional options for the get operation.
+     * @param options.includeBlobStorageMetadata Flag to include the blob storage metadata for the document, defaults to false.
+     * @param options.includeBlobStorageData Flag to include the blob storage data for the document, defaults to false.
+     * @param options.includeAttestation Flag to include the attestation information for the document, defaults to false.
+     * @param options.includeRemoved Flag to include deleted documents, defaults to false.
+     * @param cursor The cursor to get the next chunk of revisions.
+     * @param pageSize Page size of items to return, defaults to 1 so only most recent is returned.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The finalised list of documents.
+     * @internal
+     */
+    async getDocumentsFromVertex(documentVertex, options, cursor, pageSize, userIdentity, nodeIdentity) {
+        const docList = {
+            "@context": [
+                DocumentContexts.ContextRoot,
+                DocumentContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
+            ],
+            type: DocumentTypes.DocumentList,
+            documents: []
+        };
+        if (Is.arrayValue(documentVertex.resources)) {
+            // Sort by newest revision first
+            documentVertex.resources.sort((a, b) => (Coerce.number(b.resourceObject?.documentRevision) ?? 0) -
+                (Coerce.number(a.resourceObject?.documentRevision) ?? 0));
+            const startIndex = Coerce.integer(cursor) ?? 0;
+            const endIndex = Math.min(startIndex + (pageSize ?? 1), documentVertex.resources.length);
+            const slicedResources = documentVertex.resources.slice(startIndex, endIndex);
+            docList.cursor =
+                documentVertex.resources.length > endIndex ? (endIndex + 1).toString() : undefined;
+            const includeBlobStorageMetadata = options?.includeBlobStorageMetadata ?? false;
+            const includeBlobStorageData = options?.includeBlobStorageData ?? false;
+            const includeAttestation = options?.includeAttestation ?? false;
+            for (let i = 0; i < slicedResources.length; i++) {
+                const document = slicedResources[i].resourceObject;
+                if (Is.object(document)) {
+                    docList.documents.push(document);
+                    if (includeBlobStorageMetadata || includeBlobStorageData) {
+                        const blobEntry = await this._blobStorageComponent.get(document.blobStorageId, includeBlobStorageData, userIdentity, nodeIdentity);
+                        document.blobStorageEntry = blobEntry;
+                        if (!docList["@context"].includes(BlobStorageContexts.ContextRoot)) {
+                            docList["@context"].push(BlobStorageContexts.ContextRoot);
+                        }
+                    }
+                    if (includeAttestation && Is.stringValue(document.attestationId)) {
+                        const attestationInformation = await this._attestationComponent.get(document.attestationId);
+                        document.attestationInformation = attestationInformation;
+                        if (!docList["@context"].includes(AttestationContexts.ContextRoot)) {
+                            docList["@context"].push(AttestationContexts.ContextRoot);
+                        }
+                    }
+                }
+            }
+        }
+        if (Is.arrayValue(documentVertex.edges)) {
+            docList.edges ??= [];
+            for (const edge of documentVertex.edges) {
+                if (Is.object(edge)) {
+                    docList.edges.push(edge.id);
+                }
+            }
+        }
+        return docList;
+    }
+    /**
+     * Create an attestation for the document.
+     * @param document The document to create the attestation for.
+     * @param userIdentity The identity to perform the attestation operation with.
+     * @param nodeIdentity The node identity to perform attestation operation with.
+     * @returns The attestation identifier.
+     */
+    async createAttestation(document, userIdentity, nodeIdentity) {
+        const documentAttestation = {
+            "@context": [
+                DocumentContexts.ContextRoot,
+                DocumentContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
+            ],
+            type: DocumentTypes.DocumentAttestation,
+            id: document.id,
+            documentId: document.documentId,
+            documentCode: document.documentCode,
+            documentRevision: document.documentRevision,
+            dateCreated: document.dateCreated,
+            blobHash: document.blobHash
+        };
+        return this._attestationComponent.create(documentAttestation, undefined, userIdentity, nodeIdentity);
+    }
+}
+
+const restEntryPoints = [
+    {
+        name: "document-management",
+        defaultBaseRoute: "document-management",
+        tags: tagsDocumentManagement,
+        generateRoutes: generateRestRoutesDocumentManagement
+    }
+];
+
+export { DocumentManagementService, documentManagementCreate, documentManagementGet, documentManagementQuery, documentManagementRemove, documentManagementUpdate, generateRestRoutesDocumentManagement, restEntryPoints, tagsDocumentManagement };