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

package/dist/esm/index.mjs

@@ -0,0 +1,857 @@
+import { HttpParameterHelper } from '@twin.org/api-models';
+import { Guards, ComponentFactory, Converter, Coerce, Is, ObjectHelper, BaseError, GeneralError, Urn, NotFoundError } from '@twin.org/core';
+import { DocumentTypes } from '@twin.org/document-management-models';
+import { SchemaOrgTypes, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
+import { UneceDocumentCodes } from '@twin.org/standards-unece';
+import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
+import { AttestationTypes } from '@twin.org/attestation-models';
+import { AuditableItemGraphTypes } from '@twin.org/auditable-item-graph-models';
+import { BlobStorageTypes } from '@twin.org/blob-storage-models';
+import { Sha256 } from '@twin.org/crypto';
+import { JsonLdProcessor } from '@twin.org/data-json-ld';
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * 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 documentManagementSetRoute = {
+        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}/:auditableItemGraphId`,
+        handler: async (httpRequestContext, request) => documentManagementSet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementSetRequest",
+            examples: [
+                {
+                    id: "DocumentManagementSetRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphId: "aig:123456"
+                        },
+                        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: "DocumentManagementSetResponseExample",
+                        response: {
+                            statusCode: HttpStatusCode.created,
+                            headers: {
+                                [HeaderTypes.Location]: "documents:123456:705:2721000"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const documentManagementGetRoute = {
+        operationId: "DocumentManagementGet",
+        summary: "Get the data for a document from document management",
+        tag: tagsDocumentManagement[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:auditableItemGraphId/:documentId`,
+        handler: async (httpRequestContext, request) => documentManagementGet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementGetRequest",
+            examples: [
+                {
+                    id: "DocumentManagementGetRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphId: "aig:1234",
+                            documentId: "documents:123456:705:2721000"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDocumentManagementGetResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    DocumentTypes.ContextRoot,
+                                    DocumentTypes.ContextRootCommon,
+                                    SchemaOrgTypes.ContextRoot
+                                ],
+                                type: DocumentTypes.Document,
+                                id: "documents:705:2721000:rev-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"
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IDocumentManagementGetResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    DocumentTypes.ContextRoot,
+                                    DocumentTypes.ContextRootCommon,
+                                    SchemaOrgTypes.ContextRoot
+                                ],
+                                type: DocumentTypes.Document,
+                                id: "documents:705:2721000:rev-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"
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const documentManagementRemoveRoute = {
+        operationId: "DocumentManagementRemove",
+        summary: "Remove an document from an auditable item graph vertex",
+        tag: tagsDocumentManagement[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:auditableItemGraphId/:documentId`,
+        handler: async (httpRequestContext, request) => documentManagementRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementRemoveRequest",
+            examples: [
+                {
+                    id: "DocumentManagementRemoveRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphId: "aig:1234",
+                            documentId: "documents:123456:705:2721000"
+                        }
+                    }
+                }
+            ]
+        },
+        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}/:auditableItemGraphId`,
+        handler: async (httpRequestContext, request) => documentManagementQuery(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementQueryRequest",
+            examples: [
+                {
+                    id: "DocumentManagementQueryRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphId: "aig:123456"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDocumentManagementQueryResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementQueryResponseExample",
+                        response: {
+                            body: {
+                                "@context": [DocumentTypes.ContextRoot, DocumentTypes.ContextRootCommon],
+                                type: DocumentTypes.DocumentList,
+                                documents: [
+                                    {
+                                        "@context": [
+                                            DocumentTypes.ContextRoot,
+                                            DocumentTypes.ContextRootCommon,
+                                            SchemaOrgTypes.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "documents:705:2721000:rev-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"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IDocumentManagementQueryResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "DocumentManagementListResponseJsonLdExample",
+                        response: {
+                            body: {
+                                "@context": [DocumentTypes.ContextRoot, DocumentTypes.ContextRootCommon],
+                                type: DocumentTypes.DocumentList,
+                                documents: [
+                                    {
+                                        "@context": [
+                                            DocumentTypes.ContextRoot,
+                                            DocumentTypes.ContextRootCommon,
+                                            SchemaOrgTypes.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "documents:705:2721000:rev-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"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    return [
+        documentManagementSetRoute,
+        documentManagementGetRoute,
+        documentManagementRemoveRoute,
+        documentManagementQueryRoute
+    ];
+}
+/**
+ * Set a document in to 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 documentManagementSet(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
+    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.set(request.pathParams.auditableItemGraphId, request.body.documentId, request.body.documentIdFormat, request.body.documentCode, Converter.base64ToBytes(request.body.blob), request.body.annotationObject, request.body.createAttestation, 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.auditableItemGraphId", request.pathParams.auditableItemGraphId);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.documentId", request.pathParams.documentId);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.get(request.pathParams.auditableItemGraphId, request.pathParams.documentId, {
+        includeBlobStorageMetadata: Coerce.boolean(request.query?.includeBlobStorageMetadata),
+        includeBlobStorageData: Coerce.boolean(request.query?.includeBlobStorageData),
+        includeAttestation: Coerce.boolean(request.query?.includeAttestation),
+        includeRemoved: Coerce.boolean(request.query?.includeRemoved),
+        maxRevisionCount: Coerce.integer(request.query?.maxRevisionCount)
+    }, request.query?.revisionCursor, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+/**
+ * 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.auditableItemGraphId", request.pathParams.auditableItemGraphId);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.documentId", request.pathParams.documentId);
+    const component = ComponentFactory.get(componentName);
+    await component.remove(request.pathParams.auditableItemGraphId, request.pathParams.documentId, {
+        removeAllRevisions: request.query?.removeAllRevisions
+    }, 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.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.query(request.pathParams.auditableItemGraphId, HttpParameterHelper.arrayFromString(request.query?.documentCodes), {
+        includeRemoved: Coerce.boolean(request.query?.includeRemoved),
+        includeMostRecentRevisions: Coerce.boolean(request.query?.includeMostRecentRevisions)
+    }, request.query?.cursor, 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";
+    /**
+     * Default Page Size for cursor.
+     * @internal
+     */
+    static _DEFAULT_PAGE_SIZE = 20;
+    /**
+     * 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 in 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 auditableItemGraphId The auditable item graph vertex id to create the document on.
+     * @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.
+     * @param annotationObject Additional information to associate with the document.
+     * @param createAttestation Flag to create an attestation for the document, defaults to false.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The identifier for the document which includes the auditable item graph identifier.
+     */
+    async set(auditableItemGraphId, documentId, documentIdFormat, documentCode, blob, annotationObject, createAttestation, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+        Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
+        Guards.arrayOneOf(this.CLASS_NAME, "documentCode", documentCode, Object.values(UneceDocumentCodes));
+        Guards.uint8Array(this.CLASS_NAME, "blob", blob);
+        try {
+            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
+            vertex.resources = vertex.resources ?? [];
+            // Get all the docs from the AIG vertex
+            const vertexDocs = this.filterDocumentsFromVertex(vertex);
+            // Reduce the list to those with a matching id and code
+            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentId, documentCode, true);
+            // Calculate the hash for the blob.
+            const blobHash = this.generateBlobHash(blob);
+            let documentRevision;
+            if (Is.arrayValue(matchingDocIds) && matchingDocIds[0].blobHash === blobHash) {
+                documentRevision = matchingDocIds[0].documentRevision;
+                // If there is already a doc with the matching blob hash no need to create a new revision
+                // instead we just update the annotation object if it has changed.
+                if (!ObjectHelper.equal(matchingDocIds[0].annotationObject, annotationObject, false)) {
+                    matchingDocIds[0].dateModified = new Date().toISOString();
+                    matchingDocIds[0].annotationObject = annotationObject;
+                    await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
+                }
+                return matchingDocIds[0].id;
+            }
+            // Nothing matches the current blob hash so upload it to blob storage
+            const blobStorageId = await this._blobStorageComponent.create(Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
+            documentRevision = matchingDocIds.length;
+            // We are creating a new document, if there is already docs with the same id and code we use the list length
+            // to determine the next revision number.
+            const document = {
+                "@context": [
+                    DocumentTypes.ContextRoot,
+                    DocumentTypes.ContextRootCommon,
+                    SchemaOrgTypes.ContextRoot
+                ],
+                type: DocumentTypes.Document,
+                id: this.createIdentifier(documentCode, documentId, documentRevision),
+                documentId,
+                documentIdFormat,
+                documentCode,
+                documentRevision,
+                blobStorageId,
+                blobHash,
+                dateCreated: new Date(Date.now()).toISOString()
+            };
+            // If the attestation flag is set then create it
+            if (createAttestation ?? false) {
+                document.attestationId = await this._attestationComponent.create(document, undefined, userIdentity, nodeIdentity);
+            }
+            // We assign the annotation object after the attestation was created
+            // as we don't want to include it in the attestation
+            document.annotationObject = annotationObject;
+            // Add the new revision in to the AIG
+            vertex.resources.push({
+                "@context": AuditableItemGraphTypes.ContextRoot,
+                type: AuditableItemGraphTypes.Resource,
+                resourceObject: document
+            });
+            await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
+            return document.id;
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "setFailed", undefined, error);
+        }
+    }
+    /**
+     * Get a specific document from an auditable item graph vertex.
+     * @param auditableItemGraphId The auditable item graph vertex id to get the document from.
+     * @param identifier The identifier of the document to get.
+     * @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 options.maxRevisionCount Max number of revisions to return, defaults to 0.
+     * @param revisionCursor The cursor to get the next chunk of revisions.
+     * @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(auditableItemGraphId, identifier, options, revisionCursor, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+        Urn.guard(this.CLASS_NAME, "identifier", identifier);
+        try {
+            const includeBlobStorageMetadata = options?.includeBlobStorageMetadata ?? false;
+            const includeBlobStorageData = options?.includeBlobStorageData ?? false;
+            const includeAttestation = options?.includeAttestation ?? false;
+            const includeRemoved = options?.includeRemoved ?? false;
+            const revCursor = Math.max(Coerce.integer(revisionCursor) ?? 0, 0);
+            const maxRevisionCount = Math.max(Coerce.integer(options?.maxRevisionCount) ?? 0);
+            const documentIdParts = this.parseDocumentId(identifier);
+            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
+            // Get all the docs from the AIG vertex
+            const vertexDocs = this.filterDocumentsFromVertex(vertex);
+            // Reduce the list to those with a matching id and code
+            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentIdParts.documentId, documentIdParts.documentCode, includeRemoved);
+            // Populate the document and revisions with the options set
+            const document = await this.getDocumentAndRevisions(matchingDocIds, identifier, {
+                includeBlobStorageMetadata,
+                includeBlobStorageData,
+                includeAttestation,
+                includeRemoved,
+                maxRevisionCount
+            }, revCursor, userIdentity, nodeIdentity);
+            return JsonLdProcessor.compact(document, document["@context"]);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove a specific document from an auditable item graph vertex.
+     * The documents dateDeleted will be set, but can still be queried with the includeRemoved flag.
+     * @param auditableItemGraphId The auditable item graph vertex id to remove the document from.
+     * @param identifier The identifier of the document to remove.
+     * @param options Additional options for the remove operation.
+     * @param options.removeAllRevisions Flag to remove all revisions of the document, defaults to false.
+     * @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 remove(auditableItemGraphId, identifier, options, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+        Urn.guard(this.CLASS_NAME, "identifier", identifier);
+        try {
+            const documentIdParts = this.parseDocumentId(identifier);
+            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
+            // Get all the docs from the AIG vertex
+            const vertexDocs = this.filterDocumentsFromVertex(vertex);
+            // Reduce the list to those with a matching id and code
+            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentIdParts.documentId, documentIdParts.documentCode, false);
+            const removeAllRevisions = options?.removeAllRevisions ?? false;
+            const now = Date.now();
+            if (removeAllRevisions) {
+                for (const doc of matchingDocIds) {
+                    doc.dateDeleted = new Date(now).toISOString();
+                }
+            }
+            else {
+                const matchingRevision = matchingDocIds.find(d => d.documentRevision === documentIdParts.documentRevision);
+                if (matchingRevision) {
+                    matchingRevision.dateDeleted = new Date(now).toISOString();
+                }
+                else {
+                    throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", identifier);
+                }
+            }
+            await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "removeFailed", undefined, error);
+        }
+    }
+    /**
+     * Query an auditable item graph vertex for documents.
+     * @param auditableItemGraphId The auditable item graph vertex to get the documents from.
+     * @param documentCodes The document codes to query for, if undefined gets all document codes.
+     * @param options Additional options for the query operation.
+     * @param options.includeMostRecentRevisions Include the most recent 5 revisions, use the individual get to retrieve more.
+     * @param options.includeRemoved Flag to include deleted documents, defaults to false.
+     * @param cursor The cursor 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 most recent revisions of each document, cursor is set if there are more documents.
+     */
+    async query(auditableItemGraphId, documentCodes, options, cursor, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+        try {
+            const includeRemoved = options?.includeRemoved ?? false;
+            const includeMostRecentRevisions = options?.includeMostRecentRevisions ?? false;
+            const docCursor = Math.max(Coerce.integer(cursor) ?? 0, 0);
+            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
+            // Get all the docs from the AIG vertex
+            const vertexDocs = this.filterDocumentsFromVertex(vertex);
+            let matchingDocIds = vertexDocs;
+            if (Is.arrayValue(documentCodes)) {
+                matchingDocIds = vertexDocs.filter(d => documentCodes.includes(d.documentCode));
+            }
+            const documentIdGroups = {};
+            let docGroupIds = [];
+            for (const doc of matchingDocIds) {
+                const docId = `${doc.documentId}:${doc.documentCode}`;
+                if (!docGroupIds.includes(docId)) {
+                    docGroupIds.push(docId);
+                }
+                documentIdGroups[docId] ??= [];
+                documentIdGroups[docId].push(doc);
+            }
+            let nextDocCursor;
+            if (docGroupIds.length > docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE) {
+                nextDocCursor = (docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE).toString();
+            }
+            docGroupIds = docGroupIds.slice(docCursor, docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE);
+            const finalDocs = [];
+            for (const docId of docGroupIds) {
+                finalDocs.push(await this.getDocumentAndRevisions(documentIdGroups[docId], docId, {
+                    includeAttestation: false,
+                    includeBlobStorageData: false,
+                    includeBlobStorageMetadata: false,
+                    includeRemoved,
+                    maxRevisionCount: includeMostRecentRevisions ? 5 : 0
+                }, 0, userIdentity, nodeIdentity));
+            }
+            const docList = {
+                "@context": [
+                    DocumentTypes.ContextRoot,
+                    DocumentTypes.ContextRootCommon,
+                    SchemaOrgTypes.ContextRoot
+                ],
+                type: DocumentTypes.DocumentList,
+                documents: finalDocs,
+                cursor: nextDocCursor
+            };
+            return JsonLdProcessor.compact(docList, docList["@context"]);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "queryFailed", undefined, error);
+        }
+    }
+    /**
+     * Encode the document id.
+     * @param documentId The document identifier.
+     * @returns The encoded identifier.
+     * @internal
+     */
+    encodeDocumentIdentifier(documentId, documentRevision) {
+        return `${documentId}:rev-${documentRevision}`;
+    }
+    /**
+     * Decode the document id.
+     * @param documentId The document identifier.
+     * @returns The decoded identifier.
+     * @internal
+     */
+    decodeDocumentIdentifier(documentId) {
+        const parts = documentId.split(":");
+        const lastPart = parts[parts.length - 1];
+        let revision;
+        if (lastPart.startsWith("rev-")) {
+            revision = Number.parseInt(lastPart.slice(4), 10);
+            parts.pop();
+        }
+        return { documentId: parts.join(":"), documentRevision: revision };
+    }
+    /**
+     * Create a full identifier for a document.
+     * @param documentCode The document code.
+     * @param documentId The document identifier.
+     * @param documentRevision The document revision.
+     * @returns The full identifier.
+     * @internal
+     */
+    createIdentifier(documentCode, documentId, documentRevision) {
+        const docCode = this.parseDocumentCode(documentCode);
+        return `documents:${docCode}:${this.encodeDocumentIdentifier(documentId, documentRevision)}`;
+    }
+    /**
+     * Parse the document identifier from the full identifier.
+     * @param identifier The full identifier to parse.
+     * @returns The document identifier.
+     * @internal
+     */
+    parseDocumentId(identifier) {
+        const urn = Urn.fromValidString(identifier);
+        const remainingParts = urn.namespaceSpecificParts();
+        if (remainingParts.length < 2) {
+            throw new GeneralError(this.CLASS_NAME, "invalidDocumentId", { identifier });
+        }
+        const documentCode = `unece:DocumentCodeList#${remainingParts[0]}`;
+        const { documentId, documentRevision } = this.decodeDocumentIdentifier(urn.namespaceSpecific(1));
+        return { documentCode, documentId, documentRevision };
+    }
+    /**
+     * Parse the document code from the full identifier.
+     * @param documentCode The document code to parse.
+     * @returns The document code.
+     * @internal
+     */
+    parseDocumentCode(documentCode) {
+        // Document codes are in the format unece:DocumentCodeList#1, so we need to split the string to get the code.
+        const documentCodeParts = documentCode.split("#");
+        if (documentCodeParts.length !== 2) {
+            throw new GeneralError(this.CLASS_NAME, "invalidDocumentCode", { documentCode });
+        }
+        const docCode = Number.parseInt(documentCodeParts[1], 10);
+        if (!Is.number(docCode)) {
+            throw new GeneralError(this.CLASS_NAME, "invalidDocumentCode", { documentCode });
+        }
+        return docCode;
+    }
+    /**
+     * Get the documents from a vertex.
+     * @param vertex The vertex to get the documents from.
+     * @returns The documents.
+     * @internal
+     */
+    filterDocumentsFromVertex(vertex) {
+        return (vertex.resources
+            ?.filter(resource => ObjectHelper.extractProperty(resource.resourceObject, ["@type", "type"], false) ===
+            DocumentTypes.Document)
+            .map(resource => resource.resourceObject) ?? []);
+    }
+    /**
+     * Find matching documents in the list of existing documents.
+     * @param documents The documents to search.
+     * @param documentId The document id.
+     * @param documentCode The document code.
+     * @param includeRemoved Include deleted documents.
+     * @returns The matching documents.
+     * @internal
+     */
+    findMatchingDocs(documents, documentId, documentCode, includeRemoved) {
+        return documents
+            .filter(d => d.documentId === documentId &&
+            d.documentCode === documentCode &&
+            (includeRemoved || Is.empty(d.dateDeleted)))
+            .sort((a, b) => b.documentRevision - a.documentRevision);
+    }
+    /**
+     * 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 matchingDocIds The documents which match document type and id.
+     * @param identifier The full document identifier.
+     * @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 options.maxRevisionCount Max number of revisions to return, defaults to 0.
+     * @param revisionCursor The cursor to get the next chunk of revisions.
+     * @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 getDocumentAndRevisions(matchingDocIds, identifier, options, revisionCursor, userIdentity, nodeIdentity) {
+        const document = matchingDocIds.shift();
+        if (Is.empty(document)) {
+            throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", identifier);
+        }
+        let revisions;
+        let nextRevisionCursor;
+        if (options.maxRevisionCount > 0) {
+            revisions = matchingDocIds.slice(revisionCursor, revisionCursor + options.maxRevisionCount);
+            nextRevisionCursor =
+                matchingDocIds.length > revisionCursor + options.maxRevisionCount
+                    ? (revisionCursor + options.maxRevisionCount).toString()
+                    : undefined;
+        }
+        if (options.includeBlobStorageMetadata || options.includeBlobStorageData) {
+            const blobEntry = await this._blobStorageComponent.get(document.blobStorageId, options.includeBlobStorageData, userIdentity, nodeIdentity);
+            document.blobStorageEntry = blobEntry;
+            document["@context"].push(BlobStorageTypes.ContextRoot);
+        }
+        if (options.includeAttestation && Is.stringValue(document.attestationId)) {
+            const attestationInformation = await this._attestationComponent.get(document.attestationId);
+            document.attestationInformation = attestationInformation;
+            document["@context"].push(AttestationTypes.ContextRoot);
+        }
+        document.revisions = Is.arrayValue(revisions) ? revisions : undefined;
+        document.revisionCursor = nextRevisionCursor;
+        return document;
+    }
+}
+
+const restEntryPoints = [
+    {
+        name: "documents",
+        defaultBaseRoute: "documents",
+        tags: tagsDocumentManagement,
+        generateRoutes: generateRestRoutesDocumentManagement
+    }
+];
+
+export { DocumentManagementService, documentManagementGet, documentManagementQuery, documentManagementRemove, documentManagementSet, generateRestRoutesDocumentManagement, restEntryPoints, tagsDocumentManagement };