@twin.org/blob-storage-service 0.0.2-next.5 → 0.0.3-next.2

package/dist/esm/index.mjs

@@ -1,1072 +0,0 @@
-import { HttpParameterHelper } from '@twin.org/api-models';
-import { BlobStorageTypes, BlobStorageContexts, BlobStorageCompressionType, BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
-import { StringHelper, Guards, ComponentFactory, Coerce, Is, Converter, GeneralError, Validation, Compression, ObjectHelper, Urn, NotFoundError } from '@twin.org/core';
-import { SchemaOrgContexts, SchemaOrgTypes, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
-import { HttpStatusCode, HeaderTypes, MimeTypes, MimeTypeHelper } from '@twin.org/web';
-import { Sha256 } from '@twin.org/crypto';
-import { JsonLdHelper, JsonLdProcessor } from '@twin.org/data-json-ld';
-import { ComparisonOperator, LogicalOperator, SortDirection, EntitySchemaHelper, property, entity, EntitySchemaFactory } from '@twin.org/entity';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { VaultConnectorFactory, VaultEncryptionType } from '@twin.org/vault-models';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE = "blobStorageRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsBlobStorage = [
-    {
-        name: "Blob Storage",
-        description: "Endpoints which are modelled to access a blob storage contract."
-    }
-];
-/**
- * The REST routes for blob storage.
- * @param baseRouteName Prefix to prepend to the paths.
- * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
- * @param options Additional options for the routes.
- * @param options.typeName Optional type name to use in the routes, defaults to Blob Storage.
- * @param options.tagName Optional name to use in OpenAPI spec for tag.
- * @returns The generated routes.
- */
-function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
-    const typeName = options?.typeName ?? "Blob Storage";
-    const lowerName = typeName.toLowerCase();
-    const camelTypeName = StringHelper.camelCase(typeName);
-    const blobStorageCreateRoute = {
-        operationId: `${camelTypeName}Create`,
-        summary: `Create an entry in ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "POST",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => blobStorageCreate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageCreateRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}CreateRequestExample`,
-                    request: {
-                        body: {
-                            blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==",
-                            metadata: {
-                                "@context": "https://schema.org",
-                                "@type": "DigitalDocument",
-                                name: "myfile.pdf"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "ICreatedResponse",
-                examples: [
-                    {
-                        id: `${camelTypeName}CreateResponseExample`,
-                        response: {
-                            statusCode: HttpStatusCode.created,
-                            headers: {
-                                [HeaderTypes.Location]: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    const blobStorageGetRoute = {
-        operationId: `${camelTypeName}Get`,
-        summary: `Get the metadata for an item from ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => blobStorageGet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageGetRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}GetRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                        },
-                        query: {
-                            includeContent: "true"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IBlobStorageGetResponse",
-                examples: [
-                    {
-                        id: `${camelTypeName}GetResponseExample`,
-                        response: {
-                            body: {
-                                "@context": [
-                                    BlobStorageContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRootCommon,
-                                    SchemaOrgContexts.ContextRoot
-                                ],
-                                type: BlobStorageTypes.Entry,
-                                id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                dateCreated: "2024-01-01T00:00:00Z",
-                                encodingFormat: MimeTypes.Pdf,
-                                blobSize: 42,
-                                blobHash: "sha256:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                fileExtension: "pdf",
-                                metadata: {
-                                    "@context": "https://schema.org",
-                                    "@type": "DigitalDocument",
-                                    name: "myfile.pdf"
-                                },
-                                blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=="
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IBlobStorageGetResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: `${camelTypeName}GetResponseJsonLdExample`,
-                        response: {
-                            body: {
-                                "@context": [
-                                    BlobStorageContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRootCommon,
-                                    SchemaOrgContexts.ContextRoot
-                                ],
-                                type: BlobStorageTypes.Entry,
-                                id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                dateCreated: "2024-01-01T00:00:00Z",
-                                encodingFormat: MimeTypes.Pdf,
-                                blobSize: 42,
-                                blobHash: "sha256:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                fileExtension: "pdf",
-                                metadata: {
-                                    "@context": "https://schema.org",
-                                    "@type": "DigitalDocument",
-                                    name: "myfile.pdf"
-                                },
-                                blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=="
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const blobStorageGetContentRoute = {
-        operationId: `${camelTypeName}GetContent`,
-        summary: `Get the content for an item in ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id/content`,
-        handler: async (httpRequestContext, request) => blobStorageGetContent(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageGetRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}GetContentRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                        },
-                        query: {
-                            download: "true",
-                            filename: "my-file.pdf"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "Uint8Array",
-                mimeType: MimeTypes.OctetStream,
-                examples: [
-                    {
-                        id: `${camelTypeName}GetContentResponseExample`,
-                        description: `The content of the blob, which will be a specific mime type if one can be detected from the content (or set as encodingFormat in the entry), or defaults to ${MimeTypes.OctetStream}.`,
-                        response: {
-                            body: new Uint8Array()
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const blobStorageUpdateRoute = {
-        operationId: `${camelTypeName}Update`,
-        summary: `Update the metadata for an item in ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "PUT",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => blobStorageUpdate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageUpdateRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}UpdateRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                        },
-                        body: {
-                            metadata: {
-                                "@context": "https://schema.org",
-                                "@type": "DigitalDocument",
-                                name: "myfile.pdf"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            }
-        ]
-    };
-    const blobStorageRemoveRoute = {
-        operationId: `${camelTypeName}Remove`,
-        summary: `Remove an item from ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "DELETE",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => blobStorageRemove(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageRemoveRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}RemoveRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const blobStorageListRoute = {
-        operationId: `${camelTypeName}Query`,
-        summary: `Query the items from ${lowerName}`,
-        tag: options?.tagName ?? tagsBlobStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => blobStorageList(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IBlobStorageListRequest",
-            examples: [
-                {
-                    id: `${camelTypeName}ListRequestExample`,
-                    request: {}
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IBlobStorageListResponse",
-                examples: [
-                    {
-                        id: `${camelTypeName}ListResponseExample`,
-                        response: {
-                            body: {
-                                "@context": [
-                                    SchemaOrgContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRootCommon
-                                ],
-                                type: SchemaOrgTypes.ItemList,
-                                [SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            BlobStorageContexts.ContextRoot,
-                                            BlobStorageContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: BlobStorageTypes.Entry,
-                                        id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        dateCreated: "2024-01-01T00:00:00Z",
-                                        encodingFormat: MimeTypes.Pdf,
-                                        blobSize: 42,
-                                        blobHash: "sha256:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        fileExtension: "pdf",
-                                        metadata: {
-                                            "@context": "https://schema.org",
-                                            "@type": "DigitalDocument",
-                                            name: "myfile.pdf"
-                                        },
-                                        blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=="
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IBlobStorageListResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: `${camelTypeName}ListResponseJsonLdExample`,
-                        response: {
-                            body: {
-                                "@context": [
-                                    SchemaOrgContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRoot,
-                                    BlobStorageContexts.ContextRootCommon
-                                ],
-                                type: SchemaOrgTypes.ItemList,
-                                [SchemaOrgTypes.ItemListElement]: [
-                                    {
-                                        "@context": [
-                                            BlobStorageContexts.ContextRoot,
-                                            BlobStorageContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
-                                        ],
-                                        type: BlobStorageTypes.Entry,
-                                        id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        dateCreated: "2024-01-01T00:00:00Z",
-                                        encodingFormat: MimeTypes.Pdf,
-                                        blobSize: 42,
-                                        blobHash: "sha256:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        fileExtension: "pdf",
-                                        metadata: {
-                                            "@context": "https://schema.org",
-                                            "@type": "DigitalDocument",
-                                            name: "myfile.pdf"
-                                        },
-                                        blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=="
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    return [
-        blobStorageCreateRoute,
-        blobStorageGetRoute,
-        blobStorageGetContentRoute,
-        blobStorageUpdateRoute,
-        blobStorageRemoveRoute,
-        blobStorageListRoute
-    ];
-}
-/**
- * Create a blob in storage.
- * @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 blobStorageCreate(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    Guards.stringBase64(ROUTES_SOURCE, "request.body.blob", request.body.blob);
-    const component = ComponentFactory.get(componentName);
-    const id = await component.create(request.body.blob, request.body.encodingFormat, request.body.fileExtension, request.body.metadata, {
-        disableEncryption: request.body.disableEncryption,
-        overrideVaultKeyId: request.body.overrideVaultKeyId,
-        namespace: request.body.namespace
-    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: HttpStatusCode.created,
-        headers: {
-            location: id
-        }
-    };
-}
-/**
- * Get the blob from storage.
- * @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 blobStorageGet(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.id, {
-        includeContent: Coerce.boolean(request.query?.includeContent),
-        decompress: Coerce.boolean(request.query?.decompress),
-        overrideVaultKeyId: request.query?.overrideVaultKeyId
-    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-/**
- * Get the blob from storage.
- * @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 blobStorageGetContent(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const component = ComponentFactory.get(componentName);
-    const decompress = Coerce.boolean(request.query?.decompress);
-    const download = Coerce.boolean(request.query?.download) ?? false;
-    const result = await component.get(request.pathParams.id, {
-        includeContent: true,
-        decompress,
-        overrideVaultKeyId: request.query?.overrideVaultKeyId
-    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    const encodingFormat = result?.encodingFormat ?? MimeTypes.OctetStream;
-    let compressedEncodingFormat;
-    let compressedExtension = "";
-    // If the entry is compressed and we are not decompressing
-    // we need to override the encoding format to the compressed type
-    // and append an additional extension to the filename.
-    if (result.compression && !decompress) {
-        compressedEncodingFormat =
-            result.compression === BlobStorageCompressionType.Gzip ? MimeTypes.Gzip : MimeTypes.Zlib;
-        compressedExtension = `.${MimeTypeHelper.defaultExtension(compressedEncodingFormat)}`;
-    }
-    let filename = request.query?.filename;
-    if (!Is.stringValue(filename)) {
-        filename = `file.${result.fileExtension ?? MimeTypeHelper.defaultExtension(encodingFormat)}${compressedExtension}`;
-    }
-    return {
-        body: Is.stringBase64(result.blob) ? Converter.base64ToBytes(result.blob) : new Uint8Array(),
-        attachment: {
-            mimeType: compressedEncodingFormat ?? encodingFormat,
-            filename,
-            inline: !download
-        }
-    };
-}
-/**
- * Update the blob storage metadata.
- * @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 blobStorageUpdate(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const component = ComponentFactory.get(componentName);
-    await component.update(request.pathParams.id, request.body.encodingFormat, request.body.fileExtension, request.body.metadata, httpRequestContext.userIdentity);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * Remove the blob from storage.
- * @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 blobStorageRemove(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const component = ComponentFactory.get(componentName);
-    await component.remove(request.pathParams.id, httpRequestContext.userIdentity);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * List the entries from blob storage.
- * @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 blobStorageList(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.query(HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, request.query?.cursor, Coerce.number(request.query?.limit), httpRequestContext.userIdentity);
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Service for performing blob storage operations to a connector.
- */
-class BlobStorageService {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "BlobStorageService";
-    /**
-     * The namespace supported by the blob storage service.
-     * @internal
-     */
-    static _NAMESPACE = "blob";
-    /**
-     * The namespace of the default storage connector to use.
-     * Defaults to the first entry in the factory if not provided.
-     * @internal
-     */
-    _defaultNamespace;
-    /**
-     * The storage connector for the metadata.
-     * @internal
-     */
-    _entryEntityStorage;
-    /**
-     * The vault connector for the encryption, can be undefined if no encryption required.
-     * @internal
-     */
-    _vaultConnector;
-    /**
-     * The id of the vault key to use for encryption if the service has a vault connector configured.
-     * @internal
-     */
-    _vaultKeyId;
-    /**
-     * Include the user identity when performing storage operations, can be used to partition for users, defaults to false.
-     * @internal
-     */
-    _partitionPerUser;
-    /**
-     * Create a new instance of BlobStorageService.
-     * @param options The options for the service.
-     */
-    constructor(options) {
-        const names = BlobStorageConnectorFactory.names();
-        if (names.length === 0) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "noConnectors");
-        }
-        this._entryEntityStorage = EntityStorageConnectorFactory.get(options?.entryEntityStorageType ?? "blob-storage-entry");
-        if (Is.stringValue(options?.vaultConnectorType)) {
-            this._vaultConnector = VaultConnectorFactory.get(options.vaultConnectorType);
-        }
-        this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
-        this._vaultKeyId = options?.config?.vaultKeyId;
-        this._partitionPerUser = options?.config?.partitionPerUser ?? false;
-        SchemaOrgDataTypes.registerRedirects();
-    }
-    /**
-     * Create the blob with some metadata.
-     * @param blob The data for the blob in base64 format.
-     * @param encodingFormat Mime type for the blob, will be detected if left undefined.
-     * @param fileExtension Extension for the blob, will be detected if left undefined.
-     * @param metadata Data for the custom metadata as JSON-LD.
-     * @param options Optional options for the creation of the blob.
-     * @param options.disableEncryption Disables encryption if enabled by default.
-     * @param options.overrideVaultKeyId Use a different vault key id for encryption, if not provided the default vault key id will be used.
-     * @param options.compress Optional compression type to use for the blob, defaults to no compression.*
-     * @param options.namespace The namespace to use for storing, defaults to component configured namespace.
-     * @param userIdentity The user identity to use with storage operations.
-     * @param nodeIdentity The node identity to use with storage operations.
-     * @returns The id of the stored blob in urn format.
-     */
-    async create(blob, encodingFormat, fileExtension, metadata, options, userIdentity, nodeIdentity) {
-        Guards.stringBase64(BlobStorageService.CLASS_NAME, "blob", blob);
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-        }
-        const disableEncryption = options?.disableEncryption ?? false;
-        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
-        const encryptionEnabled = !disableEncryption && Is.stringValue(vaultKeyId);
-        try {
-            const connectorNamespace = options?.namespace ?? this._defaultNamespace;
-            const blobStorageConnector = BlobStorageConnectorFactory.get(connectorNamespace);
-            // Convert the base64 data into bytes
-            let storeBlob = Converter.base64ToBytes(blob);
-            const blobSize = storeBlob.length;
-            // See if we can detect the mime type and default extension for the data.
-            // If not already supplied by the caller. We have to perform this operation
-            // on the unencrypted data.
-            if (!Is.stringValue(encodingFormat)) {
-                encodingFormat = await MimeTypeHelper.detect(storeBlob);
-            }
-            if (!Is.stringValue(fileExtension) && Is.stringValue(encodingFormat)) {
-                fileExtension = await MimeTypeHelper.defaultExtension(encodingFormat);
-            }
-            if (Is.object(metadata)) {
-                const validationFailures = [];
-                JsonLdHelper.validate(metadata, validationFailures);
-                Validation.asValidationError(BlobStorageService.CLASS_NAME, "metadata", validationFailures);
-            }
-            const blobHash = `sha256:${Converter.bytesToBase64(Sha256.sum256(storeBlob))}`;
-            if (!Is.empty(options?.compress)) {
-                storeBlob = await Compression.compress(storeBlob, options.compress);
-            }
-            // If we have a vault connector then encrypt the data.
-            if (encryptionEnabled) {
-                Guards.stringValue(BlobStorageService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-                if (Is.empty(this._vaultConnector)) {
-                    throw new GeneralError(BlobStorageService.CLASS_NAME, "vaultConnectorNotConfigured");
-                }
-                storeBlob = await this._vaultConnector.encrypt(`${nodeIdentity}/${vaultKeyId}`, VaultEncryptionType.ChaCha20Poly1305, storeBlob);
-            }
-            // Set the blob in the storage connector, which may now be encrypted
-            const blobId = await blobStorageConnector.set(storeBlob);
-            // Now store the entry in entity storage
-            const blobEntry = {
-                id: blobId,
-                dateCreated: new Date(Date.now()).toISOString(),
-                blobSize,
-                blobHash,
-                encodingFormat,
-                fileExtension,
-                metadata,
-                isEncrypted: encryptionEnabled,
-                compression: options?.compress
-            };
-            const conditions = [];
-            if (this._partitionPerUser) {
-                ObjectHelper.propertySet(blobEntry, "userIdentity", userIdentity);
-                conditions.push({ property: "userIdentity", value: userIdentity });
-            }
-            await this._entryEntityStorage.set(blobEntry, conditions);
-            return blobId;
-        }
-        catch (error) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "createFailed", undefined, error);
-        }
-    }
-    /**
-     * Get the blob entry.
-     * @param id The id of the blob to get in urn format.
-     * @param options Optional options for the retrieval of the blob.
-     * @param options.includeContent Include the content, or just get the metadata.
-     * @param options.overrideVaultKeyId Use a different vault key id for decryption, if not provided the default vault key id will be used.
-     * @param options.decompress If the content should be decompressed, if it was compressed when stored, defaults to true.
-     * @param userIdentity The user identity to use with storage operations.
-     * @param nodeIdentity The node identity to use with storage operations.
-     * @returns The entry and data for the blob if it can be found.
-     * @throws Not found error if the blob cannot be found.
-     */
-    async get(id, options, userIdentity, nodeIdentity) {
-        Urn.guard(BlobStorageService.CLASS_NAME, "id", id);
-        const includeContent = options?.includeContent ?? false;
-        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
-        const conditions = [];
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-            conditions.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        try {
-            const blobEntry = await this.internalGet(id, userIdentity);
-            let returnBlob;
-            if (includeContent) {
-                const blobStorageConnector = this.getConnector(id);
-                returnBlob = await blobStorageConnector.get(id);
-                if (Is.undefined(returnBlob)) {
-                    throw new NotFoundError(BlobStorageService.CLASS_NAME, "blobNotFound", id);
-                }
-                // If the data is encrypted then decrypt it.
-                const decryptionEnabled = blobEntry.isEncrypted && Is.stringValue(vaultKeyId);
-                if (decryptionEnabled) {
-                    Guards.stringValue(BlobStorageService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-                    if (Is.empty(this._vaultConnector)) {
-                        throw new GeneralError(BlobStorageService.CLASS_NAME, "vaultConnectorNotConfigured");
-                    }
-                    returnBlob = await this._vaultConnector.decrypt(`${nodeIdentity}/${vaultKeyId}`, VaultEncryptionType.ChaCha20Poly1305, returnBlob);
-                }
-                if (!Is.empty(blobEntry.compression) && (options?.decompress ?? true)) {
-                    returnBlob = await Compression.decompress(returnBlob, blobEntry.compression);
-                }
-            }
-            const jsonLd = this.entryToJsonLd(blobEntry, returnBlob);
-            return JsonLdProcessor.compact(jsonLd, jsonLd["@context"]);
-        }
-        catch (error) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "getFailed", undefined, error);
-        }
-    }
-    /**
-     * Update the blob with metadata.
-     * @param id The id of the blob entry to update.
-     * @param encodingFormat Mime type for the blob, will be detected if left undefined.
-     * @param fileExtension Extension for the blob, will be detected if left undefined.
-     * @param metadata Data for the custom metadata as JSON-LD.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns Nothing.
-     * @throws Not found error if the blob cannot be found.
-     */
-    async update(id, encodingFormat, fileExtension, metadata, userIdentity) {
-        Urn.guard(BlobStorageService.CLASS_NAME, "id", id);
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-        }
-        try {
-            const blobEntry = await this._entryEntityStorage.get(id);
-            if (Is.undefined(blobEntry)) {
-                throw new NotFoundError(BlobStorageService.CLASS_NAME, "blobNotFound", id);
-            }
-            if (Is.object(metadata)) {
-                const validationFailures = [];
-                await JsonLdHelper.validate(metadata, validationFailures);
-                Validation.asValidationError(BlobStorageService.CLASS_NAME, "metadata", validationFailures);
-            }
-            // Now store the entry in entity storage
-            const updatedBlobEntry = {
-                id: blobEntry.id,
-                dateCreated: blobEntry.dateCreated,
-                dateModified: new Date(Date.now()).toISOString(),
-                blobSize: blobEntry.blobSize,
-                blobHash: blobEntry.blobHash,
-                encodingFormat: encodingFormat ?? blobEntry.encodingFormat,
-                fileExtension: fileExtension ?? blobEntry.fileExtension,
-                metadata: metadata ?? blobEntry.metadata,
-                isEncrypted: blobEntry.isEncrypted,
-                compression: blobEntry.compression
-            };
-            const conditions = [];
-            if (this._partitionPerUser) {
-                ObjectHelper.propertySet(updatedBlobEntry, "userIdentity", userIdentity);
-                conditions.push({ property: "userIdentity", value: userIdentity });
-            }
-            await this._entryEntityStorage.set(updatedBlobEntry, conditions);
-        }
-        catch (error) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "updateFailed", undefined, error);
-        }
-    }
-    /**
-     * Remove the blob.
-     * @param id The id of the blob to remove in urn format.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns Nothing.
-     */
-    async remove(id, userIdentity) {
-        Urn.guard(BlobStorageService.CLASS_NAME, "id", id);
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-        }
-        try {
-            const blobStorageConnector = this.getConnector(id);
-            const conditions = [];
-            if (this._partitionPerUser) {
-                conditions.push({ property: "userIdentity", value: userIdentity });
-            }
-            await this._entryEntityStorage.remove(id, conditions);
-            const removed = await blobStorageConnector.remove(id);
-            if (!removed) {
-                throw new NotFoundError(BlobStorageService.CLASS_NAME, "blobNotFound", id);
-            }
-        }
-        catch (error) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "removeFailed", undefined, error);
-        }
-    }
-    /**
-     * Query all the blob storage entries which match the conditions.
-     * @param conditions The conditions to match for the entries.
-     * @param orderBy The order for the results, defaults to created.
-     * @param orderByDirection The direction for the order, defaults to descending.
-     * @param cursor The cursor to request the next page of entries.
-     * @param limit The suggested number of entries to return in each chunk, in some scenarios can return a different amount.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns All the entries for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     */
-    async query(conditions, orderBy, orderByDirection, cursor, limit, userIdentity) {
-        const finalConditions = {
-            conditions: [],
-            logicalOperator: LogicalOperator.And
-        };
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-            finalConditions.conditions.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        if (!Is.empty(conditions)) {
-            finalConditions.conditions.push(conditions);
-        }
-        const orderProperty = orderBy ?? "dateCreated";
-        const orderDirection = orderByDirection ?? SortDirection.Descending;
-        const result = await this._entryEntityStorage.query(finalConditions.conditions.length > 0 ? finalConditions : undefined, [
-            {
-                property: orderProperty,
-                sortDirection: orderDirection
-            }
-        ], undefined, cursor, limit);
-        let context = [
-            SchemaOrgContexts.ContextRoot,
-            BlobStorageContexts.ContextRoot,
-            BlobStorageContexts.ContextRootCommon
-        ];
-        const entriesJsonLd = [];
-        for (const entry of result.entities) {
-            // The entries are never Partial as we don't allow custom property requests.
-            entriesJsonLd.push(this.entryToJsonLd(entry));
-            context = JsonLdProcessor.combineContexts(context, entry.metadata?.["@context"]);
-        }
-        const jsonLd = {
-            "@context": context,
-            type: SchemaOrgTypes.ItemList,
-            [SchemaOrgTypes.ItemListElement]: entriesJsonLd,
-            [SchemaOrgTypes.NextItem]: result.cursor
-        };
-        return JsonLdProcessor.compact(jsonLd, jsonLd["@context"]);
-    }
-    /**
-     * Get the connector from the uri.
-     * @param id The id of the blob storage item in urn format.
-     * @returns The connector.
-     * @internal
-     */
-    getConnector(id) {
-        const idUri = Urn.fromValidString(id);
-        if (idUri.namespaceIdentifier() !== BlobStorageService._NAMESPACE) {
-            throw new GeneralError(BlobStorageService.CLASS_NAME, "namespaceMismatch", {
-                namespace: BlobStorageService._NAMESPACE,
-                id
-            });
-        }
-        return BlobStorageConnectorFactory.get(idUri.namespaceMethod());
-    }
-    /**
-     * Get an entity.
-     * @param id The id of the entity to get, or the index value if secondaryIndex is set.
-     * @param secondaryIndex Get the item using a secondary index.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns The object if it can be found or throws.
-     * @internal
-     */
-    async internalGet(id, userIdentity) {
-        const conditions = [];
-        if (this._partitionPerUser) {
-            Guards.stringValue(BlobStorageService.CLASS_NAME, "userIdentity", userIdentity);
-            conditions.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        let entity;
-        if (conditions.length === 0) {
-            entity = await this._entryEntityStorage.get(id);
-        }
-        else {
-            const schema = this._entryEntityStorage.getSchema();
-            const primaryKey = EntitySchemaHelper.getPrimaryKey(schema);
-            conditions.unshift({
-                property: primaryKey.property,
-                comparison: ComparisonOperator.Equals,
-                value: id
-            });
-            const results = await this._entryEntityStorage.query({
-                conditions,
-                logicalOperator: LogicalOperator.And
-            }, undefined, undefined, undefined, 1);
-            entity = results.entities[0];
-        }
-        if (Is.empty(entity)) {
-            throw new NotFoundError(BlobStorageService.CLASS_NAME, "entityNotFound", id);
-        }
-        return ObjectHelper.omit(entity, ["userIdentity"]);
-    }
-    /**
-     * Convert the entry to JSON-LD.
-     * @param entry The entry to convert.
-     * @param blob The optional blob to return.
-     * @returns The JSON-LD representation of the entry.
-     * @internal
-     */
-    entryToJsonLd(entry, blob) {
-        const jsonLd = {
-            "@context": JsonLdProcessor.combineContexts([
-                BlobStorageContexts.ContextRoot,
-                BlobStorageContexts.ContextRootCommon,
-                SchemaOrgContexts.ContextRoot
-            ], entry?.metadata?.["@context"]),
-            id: entry.id,
-            type: BlobStorageTypes.Entry,
-            dateCreated: entry.dateCreated,
-            dateModified: entry.dateModified,
-            blobSize: entry.blobSize,
-            blobHash: entry.blobHash,
-            encodingFormat: entry?.encodingFormat,
-            fileExtension: entry?.fileExtension,
-            metadata: entry?.metadata,
-            blob: Is.uint8Array(blob) ? Converter.bytesToBase64(blob) : undefined,
-            isEncrypted: entry.isEncrypted,
-            compression: entry.compression
-        };
-        return jsonLd;
-    }
-}
-
-/**
- * Class representing entry for the blob storage.
- */
-let BlobStorageEntry = class BlobStorageEntry {
-    /**
-     * The id for the blob.
-     */
-    id;
-    /**
-     * The date/time when the entry was created.
-     */
-    dateCreated;
-    /**
-     * The date/time when the entry was modified.
-     */
-    dateModified;
-    /**
-     * The length of the data in the blob.
-     */
-    blobSize;
-    /**
-     * The hash of the data in the blob.
-     */
-    blobHash;
-    /**
-     * The mime type for the blob.
-     */
-    encodingFormat;
-    /**
-     * The extension.
-     */
-    fileExtension;
-    /**
-     * The metadata for the blob as JSON-LD.
-     */
-    metadata;
-    /**
-     * Is the entry encrypted.
-     */
-    isEncrypted;
-    /**
-     * Is the entry compressed.
-     */
-    compression;
-    /**
-     * The user identity that created the blob.
-     */
-    userIdentity;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "id", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "dateCreated", void 0);
-__decorate([
-    property({
-        type: "string",
-        format: "date-time",
-        sortDirection: SortDirection.Descending,
-        optional: true
-    }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "number" }),
-    __metadata("design:type", Number)
-], BlobStorageEntry.prototype, "blobSize", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "blobHash", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "encodingFormat", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "fileExtension", void 0);
-__decorate([
-    property({ type: "object", itemTypeRef: "IJsonLdNodeObject", optional: true }),
-    __metadata("design:type", Object)
-], BlobStorageEntry.prototype, "metadata", void 0);
-__decorate([
-    property({ type: "boolean" }),
-    __metadata("design:type", Boolean)
-], BlobStorageEntry.prototype, "isEncrypted", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "compression", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], BlobStorageEntry.prototype, "userIdentity", void 0);
-BlobStorageEntry = __decorate([
-    entity()
-], BlobStorageEntry);
-
-/**
- * These are dummy entry points for the blob storage service.
- * In reality your application would create its own entry points based on the
- * blob types it wants to store, using a custom defaultBaseRoute.
- */
-const restEntryPoints = [
-    {
-        name: "blob-storage",
-        defaultBaseRoute: "blob-storage",
-        tags: tagsBlobStorage,
-        generateRoutes: generateRestRoutesBlobStorage
-    }
-];
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialize the schema for the blob storage entities.
- */
-function initSchema() {
-    EntitySchemaFactory.register("BlobStorageEntry", () => EntitySchemaHelper.getSchema(BlobStorageEntry));
-}
-
-export { BlobStorageEntry, BlobStorageService, blobStorageCreate, blobStorageGet, blobStorageGetContent, blobStorageList, blobStorageRemove, blobStorageUpdate, generateRestRoutesBlobStorage, initSchema, restEntryPoints, tagsBlobStorage };