@twin.org/blob-storage-service 0.0.1-next.8 → 0.0.1

package/dist/esm/index.mjs

@@ -1,11 +1,16 @@
-import { Guards, ComponentFactory, Is, Converter, GeneralError, Validation, Urn, NotFoundError } from '@twin.org/core';
+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 { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
-import { JsonLdHelper } from '@twin.org/data-json-ld';
+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';
-import { property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
  * The source used when communicating about these routes.
  */
@@ -23,13 +28,19 @@ const tagsBlobStorage = [
  * 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) {
+function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
+    const typeName = options?.typeName ?? "Blob Storage";
+    const lowerName = typeName.toLowerCase();
+    const camelTypeName = StringHelper.camelCase(typeName);
     const blobStorageCreateRoute = {
-        operationId: "blobStorageCreate",
-        summary: "Create a blob in to storage",
-        tag: tagsBlobStorage[0].name,
+        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),
@@ -37,12 +48,12 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageCreateRequest",
             examples: [
                 {
-                    id: "blobStorageCreateExample",
+                    id: `${camelTypeName}CreateRequestExample`,
                     request: {
                         body: {
                             blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==",
                             metadata: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "DigitalDocument",
                                 name: "myfile.pdf"
                             }
@@ -56,7 +67,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 type: "ICreatedResponse",
                 examples: [
                     {
-                        id: "blobStorageCreateResponseExample",
+                        id: `${camelTypeName}CreateResponseExample`,
                         response: {
                             statusCode: HttpStatusCode.created,
                             headers: {
@@ -69,9 +80,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageGetRoute = {
-        operationId: "blobStorageGet",
-        summary: "Get the blob metadata from storage",
-        tag: tagsBlobStorage[0].name,
+        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),
@@ -79,13 +90,13 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageGetRequest",
             examples: [
                 {
-                    id: "blobStorageGetRequestExample",
+                    id: `${camelTypeName}GetRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            includeContent: true
+                            includeContent: "true"
                         }
                     }
                 }
@@ -96,11 +107,54 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 type: "IBlobStorageGetResponse",
                 examples: [
                     {
-                        id: "blobStorageGetResponseExample",
+                        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": "http://schema.org/",
+                                    "@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"
                                 },
@@ -116,9 +170,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageGetContentRoute = {
-        operationId: "blobStorageGetContent",
-        summary: "Get the blob from storage",
-        tag: tagsBlobStorage[0].name,
+        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),
@@ -126,13 +180,13 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageGetRequest",
             examples: [
                 {
-                    id: "blobStorageGetContentRequestExample",
+                    id: `${camelTypeName}GetContentRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            download: true,
+                            download: "true",
                             filename: "my-file.pdf"
                         }
                     }
@@ -145,8 +199,8 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 mimeType: MimeTypes.OctetStream,
                 examples: [
                     {
-                        id: "blobStorageGetContentResponseExample",
-                        description: `The content of the blob, which will be a specific mime type if one can be detected from the content (or set as mimeType in the metadata), or defaults to ${MimeTypes.OctetStream}.`,
+                        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()
                         }
@@ -159,9 +213,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageUpdateRoute = {
-        operationId: "blobStorageUpdate",
-        summary: "Update a blob metadata in storage",
-        tag: tagsBlobStorage[0].name,
+        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),
@@ -169,14 +223,14 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageUpdateRequest",
             examples: [
                 {
-                    id: "blobStorageUpdateExample",
+                    id: `${camelTypeName}UpdateRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         body: {
                             metadata: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "DigitalDocument",
                                 name: "myfile.pdf"
                             }
@@ -192,9 +246,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageRemoveRoute = {
-        operationId: "blobStorageRemove",
-        summary: "Remove the blob from storage",
-        tag: tagsBlobStorage[0].name,
+        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),
@@ -202,7 +256,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageRemoveRequest",
             examples: [
                 {
-                    id: "blobStorageRemoveRequestExample",
+                    id: `${camelTypeName}RemoveRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
@@ -220,12 +274,116 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             }
         ]
     };
+    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
+        blobStorageRemoveRoute,
+        blobStorageListRoute
     ];
 }
 /**
@@ -240,7 +398,11 @@ async function blobStorageCreate(httpRequestContext, componentName, 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.mimeType, request.body.extension, request.body.metadata, request.body.namespace, httpRequestContext.nodeIdentity);
+    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: {
@@ -259,9 +421,17 @@ 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, request.query?.includeContent ?? false, httpRequestContext.nodeIdentity);
+    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
     };
 }
@@ -277,18 +447,34 @@ async function blobStorageGetContent(httpRequestContext, componentName, 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 result = await component.get(request.pathParams.id, true, httpRequestContext.nodeIdentity);
-    const mimeType = result?.mimeType ?? MimeTypes.OctetStream;
+    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.extension ?? MimeTypeHelper.defaultExtension(mimeType)}`;
+        filename = `file.${result.fileExtension ?? MimeTypeHelper.defaultExtension(encodingFormat)}${compressedExtension}`;
     }
     return {
         body: Is.stringBase64(result.blob) ? Converter.base64ToBytes(result.blob) : new Uint8Array(),
         attachment: {
-            mimeType,
+            mimeType: compressedEncodingFormat ?? encodingFormat,
             filename,
-            inline: !(request.query?.download ?? false)
+            inline: !download
         }
     };
 }
@@ -304,7 +490,7 @@ async function blobStorageUpdate(httpRequestContext, componentName, 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.mimeType, request.body.extension, request.body.metadata);
+    await component.update(request.pathParams.id, request.body.encodingFormat, request.body.fileExtension, request.body.metadata, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.noContent
     };
@@ -321,11 +507,30 @@ async function blobStorageRemove(httpRequestContext, componentName, 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);
+    await component.remove(request.pathParams.id, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     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?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -351,7 +556,7 @@ class BlobStorageService {
      * The storage connector for the metadata.
      * @internal
      */
-    _metadataEntityStorage;
+    _entryEntityStorage;
     /**
      * The vault connector for the encryption, can be undefined if no encryption required.
      * @internal
@@ -362,71 +567,116 @@ class BlobStorageService {
      * @internal
      */
     _vaultKeyId;
+    /**
+     * Include the node identity when performing storage operations, defaults to true.
+     * @internal
+     */
+    _includeNodeIdentity;
+    /**
+     * Include the user identity when performing storage operations, defaults to true.
+     * @internal
+     */
+    _includeUserIdentity;
     /**
      * Create a new instance of BlobStorageService.
-     * @param options The dependencies for the service.
-     * @param options.metadataEntityStorageType The type of the storage connector for the metadata, defaults to "blob-metadata".
-     * @param options.vaultConnectorType The type of the vault connector for encryption, if undefined no encryption will be performed.
-     * @param options.config The configuration for the service.
+     * @param options The options for the service.
      */
     constructor(options) {
         const names = BlobStorageConnectorFactory.names();
         if (names.length === 0) {
             throw new GeneralError(this.CLASS_NAME, "noConnectors");
         }
-        this._metadataEntityStorage = EntityStorageConnectorFactory.get(options?.metadataEntityStorageType ?? "blob-metadata");
+        this._entryEntityStorage = EntityStorageConnectorFactory.get(options?.entryEntityStorageType ?? "blob-storage-entry");
         if (Is.stringValue(options?.vaultConnectorType)) {
-            this._vaultConnector = VaultConnectorFactory.getIfExists(options.vaultConnectorType);
+            this._vaultConnector = VaultConnectorFactory.get(options.vaultConnectorType);
         }
         this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
-        this._vaultKeyId = options?.config?.vaultKeyId ?? "blob-storage";
+        this._vaultKeyId = options?.config?.vaultKeyId;
+        this._includeNodeIdentity = options?.config?.includeNodeIdentity ?? true;
+        this._includeUserIdentity = options?.config?.includeUserIdentity ?? true;
+        SchemaOrgDataTypes.registerRedirects();
     }
     /**
      * Create the blob with some metadata.
      * @param blob The data for the blob in base64 format.
-     * @param mimeType Mime type for the blob, will be detected if left undefined.
-     * @param extension Extension for the blob, will be detected if left undefined.
+     * @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 namespace The namespace to use for storing, defaults to component configured namespace.
-     * @param nodeIdentity The node identity which controls the vault key.
+     * @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, mimeType, extension, metadata, namespace, nodeIdentity) {
+    async create(blob, encodingFormat, fileExtension, metadata, options, userIdentity, nodeIdentity) {
         Guards.stringBase64(this.CLASS_NAME, "blob", blob);
-        if (this._vaultConnector) {
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        const disableEncryption = options?.disableEncryption ?? false;
+        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
+        const encryptionEnabled = !disableEncryption && Is.stringValue(vaultKeyId);
+        if (this._includeNodeIdentity || encryptionEnabled) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         }
         try {
-            const connectorNamespace = namespace ?? this._defaultNamespace;
+            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(mimeType)) {
-                mimeType = await MimeTypeHelper.detect(storeBlob);
+            if (!Is.stringValue(encodingFormat)) {
+                encodingFormat = await MimeTypeHelper.detect(storeBlob);
             }
-            if (!Is.stringValue(extension) && Is.stringValue(mimeType)) {
-                extension = await MimeTypeHelper.defaultExtension(mimeType);
+            if (!Is.stringValue(fileExtension) && Is.stringValue(encodingFormat)) {
+                fileExtension = await MimeTypeHelper.defaultExtension(encodingFormat);
             }
             if (Is.object(metadata)) {
                 const validationFailures = [];
                 JsonLdHelper.validate(metadata, validationFailures);
                 Validation.asValidationError(this.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 (this._vaultConnector) {
-                storeBlob = await this._vaultConnector.encrypt(`${nodeIdentity}/${this._vaultKeyId}`, VaultEncryptionType.ChaCha20Poly1305, storeBlob);
+            if (encryptionEnabled) {
+                if (Is.empty(this._vaultConnector)) {
+                    throw new GeneralError(this.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);
-            await this._metadataEntityStorage.set({
+            // Now store the entry in entity storage
+            const blobEntry = {
                 id: blobId,
-                mimeType,
-                extension,
-                metadata
-            });
+                dateCreated: new Date(Date.now()).toISOString(),
+                blobSize,
+                blobHash,
+                encodingFormat,
+                fileExtension,
+                metadata,
+                isEncrypted: encryptionEnabled,
+                compression: options?.compress
+            };
+            const conditions = [];
+            if (this._includeUserIdentity) {
+                ObjectHelper.propertySet(blobEntry, "userIdentity", userIdentity);
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                ObjectHelper.propertySet(blobEntry, "nodeIdentity", nodeIdentity);
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._entryEntityStorage.set(blobEntry, conditions);
             return blobId;
         }
         catch (error) {
@@ -434,21 +684,40 @@ class BlobStorageService {
         }
     }
     /**
-     * Get the blob and metadata.
+     * Get the blob entry.
      * @param id The id of the blob to get in urn format.
-     * @param includeContent Include the content, or just get the metadata.
-     * @param nodeIdentity The node identity which controls the vault key.
-     * @returns The metadata and data for the blob if it can be found.
+     * @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, includeContent, nodeIdentity) {
+    async get(id, options, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
-        if (this._vaultConnector && includeContent) {
+        const includeContent = options?.includeContent ?? false;
+        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
+        const conditions = [];
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            conditions.push({
+                property: "userIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: userIdentity
+            });
+        }
+        if (this._includeNodeIdentity || (Is.notEmpty(this._vaultConnector) && includeContent)) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            conditions.push({
+                property: "nodeIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
         }
         try {
-            // Get the metadata
-            const blobMetadata = await this._metadataEntityStorage.get(id);
+            const blobEntry = await this.internalGet(id, userIdentity, nodeIdentity);
             let returnBlob;
             if (includeContent) {
                 const blobStorageConnector = this.getConnector(id);
@@ -456,17 +725,20 @@ class BlobStorageService {
                 if (Is.undefined(returnBlob)) {
                     throw new NotFoundError(this.CLASS_NAME, "blobNotFound", id);
                 }
-                // If we have a vault connector then decrypt the data.
-                if (this._vaultConnector) {
-                    returnBlob = await this._vaultConnector.decrypt(`${nodeIdentity}/${this._vaultKeyId}`, VaultEncryptionType.ChaCha20Poly1305, returnBlob);
+                // If the data is encrypted then decrypt it.
+                const decryptionEnabled = blobEntry.isEncrypted && Is.stringValue(vaultKeyId);
+                if (decryptionEnabled) {
+                    if (Is.empty(this._vaultConnector)) {
+                        throw new GeneralError(this.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);
                 }
             }
-            return {
-                blob: Is.uint8Array(returnBlob) ? Converter.bytesToBase64(returnBlob) : undefined,
-                mimeType: blobMetadata?.mimeType,
-                extension: blobMetadata?.extension,
-                metadata: blobMetadata?.metadata
-            };
+            const jsonLd = this.entryToJsonLd(blobEntry, returnBlob);
+            return JsonLdProcessor.compact(jsonLd, jsonLd["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
@@ -474,18 +746,26 @@ class BlobStorageService {
     }
     /**
      * Update the blob with metadata.
-     * @param id The id of the blob metadata to update.
-     * @param mimeType Mime type for the blob, will be detected if left undefined.
-     * @param extension Extension for the blob, will be detected if left undefined.
+     * @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.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns Nothing.
      * @throws Not found error if the blob cannot be found.
      */
-    async update(id, mimeType, extension, metadata) {
+    async update(id, encodingFormat, fileExtension, metadata, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        }
         try {
-            const blobMetadata = await this._metadataEntityStorage.get(id);
-            if (Is.undefined(blobMetadata)) {
+            const blobEntry = await this._entryEntityStorage.get(id);
+            if (Is.undefined(blobEntry)) {
                 throw new NotFoundError(this.CLASS_NAME, "blobNotFound", id);
             }
             if (Is.object(metadata)) {
@@ -493,12 +773,29 @@ class BlobStorageService {
                 await JsonLdHelper.validate(metadata, validationFailures);
                 Validation.asValidationError(this.CLASS_NAME, "metadata", validationFailures);
             }
-            await this._metadataEntityStorage.set({
-                id: blobMetadata.id,
-                mimeType: mimeType ?? blobMetadata.mimeType,
-                extension: extension ?? blobMetadata.extension,
-                metadata: metadata ?? blobMetadata.metadata
-            });
+            // 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._includeUserIdentity) {
+                ObjectHelper.propertySet(updatedBlobEntry, "userIdentity", userIdentity);
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                ObjectHelper.propertySet(updatedBlobEntry, "nodeIdentity", nodeIdentity);
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._entryEntityStorage.set(updatedBlobEntry, conditions);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
@@ -507,22 +804,100 @@ class BlobStorageService {
     /**
      * 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.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns Nothing.
      */
-    async remove(id) {
+    async remove(id, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        }
         try {
             const blobStorageConnector = this.getConnector(id);
+            const conditions = [];
+            if (this._includeUserIdentity) {
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._entryEntityStorage.remove(id, conditions);
             const removed = await blobStorageConnector.remove(id);
             if (!removed) {
                 throw new NotFoundError(this.CLASS_NAME, "blobNotFound", id);
             }
-            await this._metadataEntityStorage.remove(id);
         }
         catch (error) {
             throw new GeneralError(this.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 pageSize 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.
+     * @param nodeIdentity The node 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, pageSize, userIdentity, nodeIdentity) {
+        const finalConditions = {
+            conditions: [],
+            logicalOperator: LogicalOperator.And
+        };
+        if (this._includeNodeIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            finalConditions.conditions.push({
+                property: "nodeIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
+        }
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.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, pageSize);
+        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.
@@ -539,53 +914,206 @@ class BlobStorageService {
         }
         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.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns The object if it can be found or throws.
+     * @internal
+     */
+    async internalGet(id, userIdentity, nodeIdentity) {
+        const conditions = [];
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            conditions.push({
+                property: "userIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: userIdentity
+            });
+        }
+        if (this._includeNodeIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            conditions.push({
+                property: "nodeIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
+        }
+        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(this.CLASS_NAME, "entityNotFound", id);
+        }
+        return ObjectHelper.omit(entity, ["nodeIdentity", "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 metadata for the blob storage.
+ * Class representing entry for the blob storage.
  */
-let BlobMetadata = class BlobMetadata {
+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.
      */
-    mimeType;
+    encodingFormat;
     /**
      * The extension.
      */
-    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;
+    /**
+     * The node identity that created the blob.
+     */
+    nodeIdentity;
 };
 __decorate([
     property({ type: "string", isPrimary: true }),
     __metadata("design:type", String)
-], BlobMetadata.prototype, "id", void 0);
+], BlobStorageEntry.prototype, "id", void 0);
 __decorate([
-    property({ type: "string" }),
+    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)
-], BlobMetadata.prototype, "mimeType", void 0);
+], 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)
-], BlobMetadata.prototype, "extension", void 0);
+], 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" }),
+    property({ type: "object", itemTypeRef: "IJsonLdNodeObject", optional: true }),
     __metadata("design:type", Object)
-], BlobMetadata.prototype, "metadata", void 0);
-BlobMetadata = __decorate([
+], 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);
+__decorate([
+    property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], BlobStorageEntry.prototype, "nodeIdentity", void 0);
+BlobStorageEntry = __decorate([
     entity()
-], BlobMetadata);
+], 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: "blobStorage",
-        defaultBaseRoute: "blob",
+        name: "blob-storage",
+        defaultBaseRoute: "blob-storage",
         tags: tagsBlobStorage,
         generateRoutes: generateRestRoutesBlobStorage
     }
@@ -597,7 +1125,7 @@ const restEntryPoints = [
  * Initialize the schema for the blob storage entities.
  */
 function initSchema() {
-    EntitySchemaFactory.register("BlobMetadata", () => EntitySchemaHelper.getSchema(BlobMetadata));
+    EntitySchemaFactory.register("BlobStorageEntry", () => EntitySchemaHelper.getSchema(BlobStorageEntry));
 }
 
-export { BlobMetadata, BlobStorageService, blobStorageCreate, blobStorageGet, blobStorageGetContent, blobStorageRemove, blobStorageUpdate, generateRestRoutesBlobStorage, initSchema, restEntryPoints, tagsBlobStorage };
+export { BlobStorageEntry, BlobStorageService, blobStorageCreate, blobStorageGet, blobStorageGetContent, blobStorageList, blobStorageRemove, blobStorageUpdate, generateRestRoutesBlobStorage, initSchema, restEntryPoints, tagsBlobStorage };