@twin.org/document-management-service 0.0.2-next.4 → 0.0.3-next.2

package/dist/cjs/index.cjs

@@ -1,1233 +0,0 @@
-'use strict';
-
-var auditableItemGraphModels = require('@twin.org/auditable-item-graph-models');
-var core = require('@twin.org/core');
-var documentManagementModels = require('@twin.org/document-management-models');
-var standardsSchemaOrg = require('@twin.org/standards-schema-org');
-var standardsUnece = require('@twin.org/standards-unece');
-var web = require('@twin.org/web');
-var attestationModels = require('@twin.org/attestation-models');
-var blobStorageModels = require('@twin.org/blob-storage-models');
-var crypto = require('@twin.org/crypto');
-var dataJsonLd = require('@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: standardsUnece.UneceDocumentCodes.BillOfLading,
-                            blob: "SGVsbG8gV29ybGQ=",
-                            annotationObject: {
-                                "@context": "https://schema.org",
-                                "@type": "DigitalDocument",
-                                name: "myfile.pdf"
-                            },
-                            createAttestation: true
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "ICreatedResponse",
-                examples: [
-                    {
-                        id: "DocumentManagementCreateResponseExample",
-                        response: {
-                            statusCode: web.HttpStatusCode.created,
-                            headers: {
-                                [web.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: web.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": [
-                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRootCommon
-                                ],
-                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
-                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            documentManagementModels.DocumentContexts.ContextRoot,
-                                            documentManagementModels.DocumentContexts.ContextRootCommon,
-                                            standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: documentManagementModels.DocumentTypes.Document,
-                                        id: "2721000:0",
-                                        documentId: "2721000",
-                                        documentIdFormat: "bol",
-                                        documentCode: standardsUnece.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: web.MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "DocumentManagementGetResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRootCommon
-                                ],
-                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
-                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            documentManagementModels.DocumentContexts.ContextRoot,
-                                            documentManagementModels.DocumentContexts.ContextRootCommon,
-                                            standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: documentManagementModels.DocumentTypes.Document,
-                                        id: "2721000:0",
-                                        documentId: "2721000",
-                                        documentIdFormat: "bol",
-                                        documentCode: standardsUnece.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 documentManagementGetRevisionRoute = {
-        operationId: "DocumentManagementGetRevision",
-        summary: "Get the data for a document revision from document management",
-        tag: tagsDocumentManagement[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:auditableItemGraphDocumentId/:revision`,
-        handler: async (httpRequestContext, request) => documentManagementGetRevision(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IDocumentManagementGetRequest",
-            examples: [
-                {
-                    id: "DocumentManagementGetRevisionRequestExample",
-                    request: {
-                        pathParams: {
-                            auditableItemGraphDocumentId: "aig:123456",
-                            revision: "1"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IDocumentManagementGetRevisionResponse",
-                examples: [
-                    {
-                        id: "DocumentManagementGetRevisionResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    documentManagementModels.DocumentContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRootCommon,
-                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-                                ],
-                                type: documentManagementModels.DocumentTypes.Document,
-                                id: "2721000:0",
-                                documentId: "2721000",
-                                documentIdFormat: "bol",
-                                documentCode: standardsUnece.UneceDocumentCodes.BillOfLading,
-                                documentRevision: 1,
-                                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: "IDocumentManagementGetRevisionResponse",
-                mimeType: web.MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "DocumentManagementGetRevisionResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    documentManagementModels.DocumentContexts.ContextRoot,
-                                    documentManagementModels.DocumentContexts.ContextRootCommon,
-                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-                                ],
-                                type: documentManagementModels.DocumentTypes.Document,
-                                id: "2721000:0",
-                                documentId: "2721000",
-                                documentIdFormat: "bol",
-                                documentCode: standardsUnece.UneceDocumentCodes.BillOfLading,
-                                documentRevision: 1,
-                                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 documentManagementRemoveRevisionRoute = {
-        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": [standardsSchemaOrg.SchemaOrgContexts.ContextRoot, auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot],
-                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemGraphModels.AuditableItemGraphTypes.VertexList],
-                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                                            auditableItemGraphModels.AuditableItemGraphContexts.ContextRootCommon
-                                        ],
-                                        id: "aig:c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7",
-                                        type: auditableItemGraphModels.AuditableItemGraphTypes.Vertex,
-                                        dateCreated: "2024-08-22T04:13:20.000Z",
-                                        aliases: [
-                                            {
-                                                "@context": [auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot],
-                                                id: "test-id-0",
-                                                type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
-                                                dateCreated: "2024-08-22T04:13:20.000Z"
-                                            }
-                                        ],
-                                        resources: [
-                                            {
-                                                "@context": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                                                type: auditableItemGraphModels.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,
-        documentManagementGetRevisionRoute,
-        documentManagementRemoveRevisionRoute,
-        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) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    core.Guards.stringBase64(ROUTES_SOURCE, "request.body.blob", request.body.blob);
-    const component = core.ComponentFactory.get(componentName);
-    const id = await component.create(request.body.documentId, request.body.documentIdFormat, request.body.documentCode, core.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: web.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) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
-    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = core.ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.auditableItemGraphDocumentId, {
-        includeBlobStorageMetadata: core.Coerce.boolean(request.query?.includeBlobStorageMetadata),
-        includeBlobStorageData: core.Coerce.boolean(request.query?.includeBlobStorageData),
-        includeAttestation: core.Coerce.boolean(request.query?.includeAttestation),
-        includeRemoved: core.Coerce.boolean(request.query?.includeRemoved),
-        extractRuleGroupId: request.query?.extractRuleGroupId,
-        extractMimeType: request.query?.extractMimeType
-    }, request.query?.cursor, core.Coerce.integer(request.query?.limit), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        headers: {
-            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-/**
- * Get the document revision 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 documentManagementGetRevision(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
-    const revision = core.Coerce.integer(request.pathParams.revision);
-    core.Guards.integer(ROUTES_SOURCE, "revision", revision);
-    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = core.ComponentFactory.get(componentName);
-    const result = await component.getRevision(request.pathParams.auditableItemGraphDocumentId, revision, {
-        includeBlobStorageMetadata: core.Coerce.boolean(request.query?.includeBlobStorageMetadata),
-        includeBlobStorageData: core.Coerce.boolean(request.query?.includeBlobStorageData),
-        includeAttestation: core.Coerce.boolean(request.query?.includeAttestation),
-        extractRuleGroupId: request.query?.extractRuleGroupId,
-        extractMimeType: request.query?.extractMimeType
-    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        headers: {
-            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.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) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
-    const component = core.ComponentFactory.get(componentName);
-    await component.update(request.pathParams.auditableItemGraphDocumentId, core.Is.stringValue(request.body.blob) ? core.Converter.base64ToBytes(request.body.blob) : undefined, request.body.annotationObject, request.body.auditableItemGraphEdges, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: web.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) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
-    const revision = core.Coerce.number(request.pathParams.revision);
-    core.Guards.integer(ROUTES_SOURCE, "request.pathParams.revision", revision);
-    const component = core.ComponentFactory.get(componentName);
-    await component.removeRevision(request.pathParams.auditableItemGraphDocumentId, revision, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: web.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) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.query.documentId", request.query.documentId);
-    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = core.ComponentFactory.get(componentName);
-    const result = await component.query(request.query.documentId, request.query?.cursor, core.Coerce.integer(request.query?.limit), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        headers: {
-            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-
-/**
- * Service for performing document management operations.
- */
-class DocumentManagementService {
-    /**
-     * Runtime name for the class.
-     */
-    static 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;
-    /**
-     * The connector for the data processing.
-     * @internal
-     */
-    _dataProcessingComponent;
-    /**
-     * Create a new instance of DocumentManagementService.
-     * @param options The options for the service.
-     */
-    constructor(options) {
-        this._auditableItemGraphComponent = core.ComponentFactory.get(options?.auditableItemGraphComponentType ?? "auditable-item-graph");
-        this._blobStorageComponent = core.ComponentFactory.get(options?.blobStorageComponentType ?? "blob-storage");
-        this._attestationComponent = core.ComponentFactory.get(options?.attestationComponentType ?? "attestation");
-        this._dataProcessingComponent = core.ComponentFactory.get(options?.dataProcessingComponentType ?? "data-processing");
-        standardsSchemaOrg.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) {
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "documentId", documentId);
-        core.Guards.arrayOneOf(DocumentManagementService.CLASS_NAME, "documentCode", documentCode, Object.values(standardsUnece.UneceDocumentCodes));
-        core.Guards.uint8Array(DocumentManagementService.CLASS_NAME, "blob", blob);
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "userIdentity", userIdentity);
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        try {
-            // Get the connected vertices first, if one fails we abort the create
-            const connectedVertices = {};
-            if (core.Is.arrayValue(auditableItemGraphEdges)) {
-                for (const edge of auditableItemGraphEdges) {
-                    connectedVertices[edge.targetId] = await this._auditableItemGraphComponent.get(edge.targetId);
-                }
-            }
-            const documentVertex = {};
-            if (options?.addAlias ?? true) {
-                documentVertex.aliases ??= [];
-                documentVertex.aliases.push({
-                    "@context": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                    type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
-                    id: documentId,
-                    aliasFormat: documentIdFormat,
-                    annotationObject: options?.aliasAnnotationObject
-                });
-            }
-            // Add the blob to blob storage
-            const blobStorageId = await this._blobStorageComponent.create(core.Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
-            const currentRevision = {
-                "@context": [
-                    documentManagementModels.DocumentContexts.ContextRoot,
-                    documentManagementModels.DocumentContexts.ContextRootCommon,
-                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-                ],
-                type: documentManagementModels.DocumentTypes.Document,
-                id: this.createDocumentId(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": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                type: auditableItemGraphModels.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 (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.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) {
-        core.Urn.guard(DocumentManagementService.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "userIdentity", userIdentity);
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        try {
-            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: true });
-            if (core.Is.empty(documentVertex.resources)) {
-                throw new core.NotFoundError(DocumentManagementService.CLASS_NAME, "documentRevisionNone");
-            }
-            const documents = await this.getDocumentsFromVertex(documentVertex);
-            const latestRevision = documents.itemListElement[0];
-            documentVertex.resources = documentVertex.resources.filter(r => core.Is.empty(r.dateDeleted));
-            if (core.Is.empty(latestRevision)) {
-                throw new core.NotFoundError(DocumentManagementService.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 (core.Is.array(auditableItemGraphEdges)) {
-                // Get the updated connected vertices first, if one fails we abort the update
-                for (const edge of auditableItemGraphEdges) {
-                    connectedVertices[edge.targetId] = await this._auditableItemGraphComponent.get(edge.targetId);
-                }
-                // Also get the current edges in case some need disconnecting
-                if (core.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 (core.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 (core.Is.uint8Array(blob)) {
-                const newBlobHash = this.generateBlobHash(blob);
-                if (latestRevision.blobHash !== newBlobHash) {
-                    // Add the blob to blob storage
-                    const blobStorageId = await this._blobStorageComponent.create(core.Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
-                    const newRevision = core.ObjectHelper.clone(latestRevision);
-                    newRevision.documentRevision++;
-                    newRevision.id = this.createDocumentId(newRevision.documentId, newRevision.documentRevision);
-                    newRevision.blobHash = newBlobHash;
-                    newRevision.blobStorageId = blobStorageId;
-                    newRevision.annotationObject = annotationObject;
-                    if (core.Is.stringValue(latestRevision.attestationId)) {
-                        newRevision.attestationId = await this.createAttestation(newRevision, userIdentity, nodeIdentity);
-                    }
-                    documentVertex.resources.push({
-                        "@context": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                        type: auditableItemGraphModels.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 &&
-                !core.ObjectHelper.equal(latestRevision.annotationObject, annotationObject)) {
-                updatedVertex = true;
-                latestRevision.annotationObject = annotationObject;
-                latestRevision.dateModified = new Date(Date.now()).toISOString();
-            }
-            const existingEdgeIds = documentVertex.edges?.map(e => e.targetId) ?? [];
-            // 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 (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.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 options.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
-     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
-     * @param cursor The cursor to get the next chunk of revisions.
-     * @param limit Limit the number 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, limit, userIdentity, nodeIdentity) {
-        core.Urn.guard(DocumentManagementService.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, limit, userIdentity, nodeIdentity);
-            return dataJsonLd.JsonLdProcessor.compact(documents, documents["@context"]);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.CLASS_NAME, "getFailed", undefined, error);
-        }
-    }
-    /**
-     * Get a document revision using it's auditable item graph vertex id.
-     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
-     * @param revision The revision id for 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.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
-     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
-     * @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 getRevision(auditableItemGraphDocumentId, revision, options, userIdentity, nodeIdentity) {
-        core.Urn.guard(DocumentManagementService.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
-        core.Guards.integer(DocumentManagementService.CLASS_NAME, "revision", revision);
-        try {
-            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: true });
-            if (core.Is.empty(documentVertex.resources)) {
-                throw new core.NotFoundError(DocumentManagementService.CLASS_NAME, "documentRevisionNone");
-            }
-            documentVertex.resources = documentVertex.resources.filter(d => d.resourceObject?.documentRevision === revision);
-            if (documentVertex.resources.length === 0) {
-                throw new core.NotFoundError(DocumentManagementService.CLASS_NAME, "documentRevisionNotFound", revision.toString());
-            }
-            // Populate the document and revisions with the options set
-            const docList = await this.getDocumentsFromVertex(documentVertex, options, undefined, undefined, userIdentity, nodeIdentity);
-            return dataJsonLd.JsonLdProcessor.compact(docList.itemListElement[0], docList.itemListElement[0]["@context"]);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.CLASS_NAME, "getRevisionFailed", 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) {
-        core.Urn.guard(DocumentManagementService.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
-        core.Guards.number(DocumentManagementService.CLASS_NAME, "revision", revision);
-        try {
-            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId);
-            if (core.Is.empty(documentVertex.resources)) {
-                throw new core.NotFoundError(DocumentManagementService.CLASS_NAME, "documentRevisionNone");
-            }
-            const docRevisionIndex = documentVertex.resources.findIndex(d => d.resourceObject?.documentRevision === revision);
-            if (docRevisionIndex === -1) {
-                throw new core.NotFoundError(DocumentManagementService.CLASS_NAME, "documentRevisionNotFound", revision.toString());
-            }
-            documentVertex.resources.splice(docRevisionIndex, 1);
-            await this._auditableItemGraphComponent.update(documentVertex, userIdentity, nodeIdentity);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.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 limit The limit 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, limit, userIdentity, nodeIdentity) {
-        core.Guards.stringValue(DocumentManagementService.CLASS_NAME, "documentId", documentId);
-        try {
-            return this._auditableItemGraphComponent.query({
-                id: documentId,
-                idMode: "both",
-                resourceTypes: [documentManagementModels.DocumentTypes.Document]
-            }, undefined, undefined, undefined, ["id", "dateCreated", "dateModified", "aliases", "annotationObject", "resources", "edges"], cursor, limit);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorName(error, "NotFoundError")) {
-                throw error;
-            }
-            throw new core.GeneralError(DocumentManagementService.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.targetId) ?? [];
-        if (core.Is.array(auditableItemGraphEdges)) {
-            for (const aigEdge of auditableItemGraphEdges) {
-                const existingIndex = existingEdgeIds.indexOf(aigEdge.targetId);
-                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": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                        type: auditableItemGraphModels.AuditableItemGraphTypes.Edge,
-                        targetId: aigEdge.targetId,
-                        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 && core.Is.array(documentVertex.edges)) {
-                for (const existingEdgeId of existingEdgeIds) {
-                    const existingIndex = documentVertex.edges.findIndex(e => e.targetId === 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 (core.Is.array(auditableItemGraphEdges)) {
-            for (const aigEdge of auditableItemGraphEdges) {
-                const connected = connectedVertices[aigEdge.targetId];
-                if (!core.Is.empty(connected)) {
-                    let updatedConnected = false;
-                    const existingIndex = existingEdgeIds.indexOf(aigEdge.targetId);
-                    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.targetId === auditableItemGraphDocumentId);
-                    if (!hasEdge) {
-                        const vertexEdge = {
-                            "@context": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                            type: auditableItemGraphModels.AuditableItemGraphTypes.Edge,
-                            targetId: 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 (core.Is.empty(alias)) {
-                            // No existing alias, so create one
-                            const vertexAlias = {
-                                "@context": auditableItemGraphModels.AuditableItemGraphContexts.ContextRoot,
-                                type: auditableItemGraphModels.AuditableItemGraphTypes.Alias,
-                                id: documentId,
-                                aliasFormat: documentIdFormat,
-                                annotationObject: aigEdge.aliasAnnotationObject
-                            };
-                            connected.aliases ??= [];
-                            connected.aliases?.push(vertexAlias);
-                            updatedConnected = true;
-                        }
-                        else if (!core.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 (!core.Is.empty(connected)) {
-                    let updatedConnected = false;
-                    // Remove the edge from the connected vertex
-                    if (core.Is.arrayValue(connected.edges)) {
-                        const existingIndex = connected.edges.findIndex(e => e.targetId === auditableItemGraphDocumentId);
-                        if (existingIndex !== -1) {
-                            connected.edges.splice(existingIndex, 1);
-                            updatedConnected = true;
-                        }
-                    }
-                    // Remove the alias from the connected vertex
-                    if (core.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:${core.Converter.bytesToBase64(crypto.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.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
-     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
-     * @param cursor The cursor to get the next chunk of revisions.
-     * @param limit Limit the number 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, limit, userIdentity, nodeIdentity) {
-        const docList = {
-            "@context": [
-                standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
-                documentManagementModels.DocumentContexts.ContextRoot,
-                documentManagementModels.DocumentContexts.ContextRootCommon
-            ],
-            type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
-            [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: []
-        };
-        if (core.Is.arrayValue(documentVertex.resources)) {
-            // Sort by newest revision first
-            documentVertex.resources.sort((a, b) => (core.Coerce.number(b.resourceObject?.documentRevision) ?? 0) -
-                (core.Coerce.number(a.resourceObject?.documentRevision) ?? 0));
-            const startIndex = core.Coerce.integer(cursor) ?? 0;
-            const endIndex = Math.min(startIndex + (limit ?? 1), documentVertex.resources.length);
-            const slicedResources = documentVertex.resources.slice(startIndex, endIndex);
-            docList[standardsSchemaOrg.SchemaOrgTypes.NextItem] =
-                documentVertex.resources.length > endIndex ? (endIndex + 1).toString() : undefined;
-            const includeBlobStorageMetadata = options?.includeBlobStorageMetadata ?? false;
-            const includeBlobStorageData = options?.includeBlobStorageData ?? false;
-            const includeAttestation = options?.includeAttestation ?? false;
-            const extractData = core.Is.stringValue(options?.extractRuleGroupId);
-            for (let i = 0; i < slicedResources.length; i++) {
-                const document = slicedResources[i].resourceObject;
-                if (core.Is.object(document)) {
-                    document.dateDeleted = slicedResources[i].dateDeleted;
-                    docList[standardsSchemaOrg.SchemaOrgTypes.ItemListElement].push(document);
-                    const blobRequired = includeBlobStorageMetadata || includeBlobStorageData;
-                    if (blobRequired || extractData) {
-                        const blobEntry = await this._blobStorageComponent.get(document.blobStorageId, {
-                            includeContent: includeBlobStorageData || extractData
-                        }, userIdentity, nodeIdentity);
-                        if (blobRequired) {
-                            document.blobStorageEntry = blobEntry;
-                            if (!docList["@context"].includes(blobStorageModels.BlobStorageContexts.ContextRoot)) {
-                                docList["@context"].push(blobStorageModels.BlobStorageContexts.ContextRoot);
-                            }
-                        }
-                        if (core.Is.stringValue(options?.extractRuleGroupId) && core.Is.stringValue(blobEntry.blob)) {
-                            const binaryBlob = core.Converter.base64ToBytes(blobEntry.blob);
-                            document.extractedData = await this._dataProcessingComponent.extract(options.extractRuleGroupId, binaryBlob, undefined, options?.extractMimeType);
-                        }
-                        // If we have the blob data due to extraction but we weren't asked for it
-                        // then we remove it from the document
-                        if (!blobRequired) {
-                            delete document.blobStorageEntry;
-                        }
-                        else if (!includeBlobStorageData) {
-                            delete document.blobStorageEntry?.blob;
-                        }
-                    }
-                    if (includeAttestation && core.Is.stringValue(document.attestationId)) {
-                        const attestationInformation = await this._attestationComponent.get(document.attestationId);
-                        document.attestationInformation = attestationInformation;
-                        if (!docList["@context"].includes(attestationModels.AttestationContexts.ContextRoot)) {
-                            docList["@context"].push(attestationModels.AttestationContexts.ContextRoot);
-                        }
-                    }
-                }
-            }
-        }
-        if (core.Is.arrayValue(documentVertex.edges)) {
-            docList.edges ??= [];
-            for (const edge of documentVertex.edges) {
-                if (core.Is.object(edge)) {
-                    docList.edges.push(edge.targetId);
-                }
-            }
-        }
-        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": [
-                documentManagementModels.DocumentContexts.ContextRoot,
-                documentManagementModels.DocumentContexts.ContextRootCommon,
-                standardsSchemaOrg.SchemaOrgContexts.ContextRoot
-            ],
-            type: documentManagementModels.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);
-    }
-    /**
-     * Create a document id from the document id and revision.
-     * @param documentId The document id to create.
-     * @param revision The revision of the document.
-     * @returns The document id.
-     * @internal
-     */
-    createDocumentId(documentId, revision) {
-        const documentIdHash = core.Converter.bytesToBase64Url(crypto.Sha256.sum256(core.Converter.utf8ToBytes(documentId)));
-        return `document:${documentIdHash}:${revision}`;
-    }
-}
-
-const restEntryPoints = [
-    {
-        name: "document-management",
-        defaultBaseRoute: "document-management",
-        tags: tagsDocumentManagement,
-        generateRoutes: generateRestRoutesDocumentManagement
-    }
-];
-
-exports.DocumentManagementService = DocumentManagementService;
-exports.documentManagementCreate = documentManagementCreate;
-exports.documentManagementGet = documentManagementGet;
-exports.documentManagementGetRevision = documentManagementGetRevision;
-exports.documentManagementQuery = documentManagementQuery;
-exports.documentManagementRemove = documentManagementRemove;
-exports.documentManagementUpdate = documentManagementUpdate;
-exports.generateRestRoutesDocumentManagement = generateRestRoutesDocumentManagement;
-exports.restEntryPoints = restEntryPoints;
-exports.tagsDocumentManagement = tagsDocumentManagement;