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

package/dist/cjs/index.cjs

@@ -98,7 +98,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            includeContent: true
+                            includeContent: "true"
                         }
                     }
                 }
@@ -188,7 +188,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            download: true,
+                            download: "true",
                             filename: "my-file.pdf"
                         }
                     }
@@ -277,7 +277,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
         ]
     };
     const blobStorageListRoute = {
-        operationId: `${camelTypeName}Get`,
+        operationId: `${camelTypeName}Query`,
         summary: `Query the items from ${lowerName}`,
         tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "GET",
@@ -400,7 +400,11 @@ async function blobStorageCreate(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
     core.Guards.stringBase64(ROUTES_SOURCE, "request.body.blob", request.body.blob);
     const component = core.ComponentFactory.get(componentName);
-    const id = await component.create(request.body.blob, request.body.encodingFormat, request.body.fileExtension, request.body.metadata, request.body.namespace, httpRequestContext.userIdentity, 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: web.HttpStatusCode.created,
         headers: {
@@ -421,7 +425,11 @@ async function blobStorageGet(httpRequestContext, componentName, request) {
     core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.id, request.query?.includeContent ?? false, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    const result = await component.get(request.pathParams.id, {
+        includeContent: core.Coerce.boolean(request.query?.includeContent),
+        decompress: core.Coerce.boolean(request.query?.decompress),
+        overrideVaultKeyId: request.query?.overrideVaultKeyId
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         headers: {
             [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
@@ -441,16 +449,31 @@ async function blobStorageGetContent(httpRequestContext, componentName, request)
     core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
     core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.id, true, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    const decompress = core.Coerce.boolean(request.query?.decompress);
+    const result = await component.get(request.pathParams.id, {
+        includeContent: true,
+        decompress,
+        overrideVaultKeyId: request.query?.overrideVaultKeyId
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     const encodingFormat = result?.encodingFormat ?? web.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 === blobStorageModels.BlobStorageCompressionType.Gzip ? web.MimeTypes.Gzip : web.MimeTypes.Zlib;
+        compressedExtension = `.${web.MimeTypeHelper.defaultExtension(compressedEncodingFormat)}`;
+    }
     let filename = request.query?.filename;
     if (!core.Is.stringValue(filename)) {
-        filename = `file.${result.fileExtension ?? web.MimeTypeHelper.defaultExtension(encodingFormat)}`;
+        filename = `file.${result.fileExtension ?? web.MimeTypeHelper.defaultExtension(encodingFormat)}${compressedExtension}`;
     }
     return {
         body: core.Is.stringBase64(result.blob) ? core.Converter.base64ToBytes(result.blob) : new Uint8Array(),
         attachment: {
-            mimeType: encodingFormat,
+            mimeType: compressedEncodingFormat ?? encodingFormat,
             filename,
             inline: !(request.query?.download ?? false)
         }
@@ -566,10 +589,10 @@ class BlobStorageService {
         }
         this._entryEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.entryEntityStorageType ?? "blob-storage-entry");
         if (core.Is.stringValue(options?.vaultConnectorType)) {
-            this._vaultConnector = vaultModels.VaultConnectorFactory.getIfExists(options.vaultConnectorType);
+            this._vaultConnector = vaultModels.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;
         standardsSchemaOrg.SchemaOrgDataTypes.registerRedirects();
@@ -580,21 +603,28 @@ class BlobStorageService {
      * @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 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, namespace, userIdentity, nodeIdentity) {
+    async create(blob, encodingFormat, fileExtension, metadata, options, userIdentity, nodeIdentity) {
         core.Guards.stringBase64(this.CLASS_NAME, "blob", blob);
         if (this._includeUserIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         }
-        if (this._includeNodeIdentity || core.Is.notEmpty(this._vaultConnector)) {
+        const disableEncryption = options?.disableEncryption ?? false;
+        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
+        const encryptionEnabled = !disableEncryption && core.Is.stringValue(vaultKeyId);
+        if (this._includeNodeIdentity || encryptionEnabled) {
             core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         }
         try {
-            const connectorNamespace = namespace ?? this._defaultNamespace;
+            const connectorNamespace = options?.namespace ?? this._defaultNamespace;
             const blobStorageConnector = blobStorageModels.BlobStorageConnectorFactory.get(connectorNamespace);
             // Convert the base64 data into bytes
             let storeBlob = core.Converter.base64ToBytes(blob);
@@ -614,9 +644,15 @@ class BlobStorageService {
                 core.Validation.asValidationError(this.CLASS_NAME, "metadata", validationFailures);
             }
             const blobHash = `sha256:${core.Converter.bytesToBase64(crypto.Sha256.sum256(storeBlob))}`;
+            if (!core.Is.empty(options?.compress)) {
+                storeBlob = await core.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}`, vaultModels.VaultEncryptionType.ChaCha20Poly1305, storeBlob);
+            if (encryptionEnabled) {
+                if (core.Is.empty(this._vaultConnector)) {
+                    throw new core.GeneralError(this.CLASS_NAME, "vaultConnectorNotConfigured");
+                }
+                storeBlob = await this._vaultConnector.encrypt(`${nodeIdentity}/${vaultKeyId}`, vaultModels.VaultEncryptionType.ChaCha20Poly1305, storeBlob);
             }
             // Set the blob in the storage connector, which may now be encrypted
             const blobId = await blobStorageConnector.set(storeBlob);
@@ -628,7 +664,9 @@ class BlobStorageService {
                 blobHash,
                 encodingFormat,
                 fileExtension,
-                metadata
+                metadata,
+                isEncrypted: encryptionEnabled,
+                compression: options?.compress
             };
             const conditions = [];
             if (this._includeUserIdentity) {
@@ -649,14 +687,19 @@ class BlobStorageService {
     /**
      * 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 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, userIdentity, nodeIdentity) {
+    async get(id, options, userIdentity, nodeIdentity) {
         core.Urn.guard(this.CLASS_NAME, "id", id);
+        const includeContent = options?.includeContent ?? false;
+        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
         const conditions = [];
         if (this._includeUserIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
@@ -683,9 +726,16 @@ class BlobStorageService {
                 if (core.Is.undefined(returnBlob)) {
                     throw new core.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}`, vaultModels.VaultEncryptionType.ChaCha20Poly1305, returnBlob);
+                // If the data is encrypted then decrypt it.
+                const decryptionEnabled = blobEntry.isEncrypted && core.Is.stringValue(vaultKeyId);
+                if (decryptionEnabled) {
+                    if (core.Is.empty(this._vaultConnector)) {
+                        throw new core.GeneralError(this.CLASS_NAME, "vaultConnectorNotConfigured");
+                    }
+                    returnBlob = await this._vaultConnector.decrypt(`${nodeIdentity}/${vaultKeyId}`, vaultModels.VaultEncryptionType.ChaCha20Poly1305, returnBlob);
+                }
+                if (!core.Is.empty(blobEntry.compression) && (options?.decompress ?? true)) {
+                    returnBlob = await core.Compression.decompress(returnBlob, blobEntry.compression);
                 }
             }
             const jsonLd = this.entryToJsonLd(blobEntry, returnBlob);
@@ -733,7 +783,9 @@ class BlobStorageService {
                 blobHash: blobEntry.blobHash,
                 encodingFormat: encodingFormat ?? blobEntry.encodingFormat,
                 fileExtension: fileExtension ?? blobEntry.fileExtension,
-                metadata: metadata ?? blobEntry.metadata
+                metadata: metadata ?? blobEntry.metadata,
+                isEncrypted: blobEntry.isEncrypted,
+                compression: blobEntry.compression
             };
             const conditions = [];
             if (this._includeUserIdentity) {
@@ -828,10 +880,6 @@ class BlobStorageService {
                 sortDirection: orderDirection
             }
         ], undefined, cursor, pageSize);
-        for (const entity of result.entities) {
-            core.ObjectHelper.propertyDelete(entity, "nodeIdentity");
-            core.ObjectHelper.propertyDelete(entity, "userIdentity");
-        }
         let context = [
             standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
             blobStorageModels.BlobStorageContexts.ContextRoot,
@@ -915,9 +963,7 @@ class BlobStorageService {
         if (core.Is.empty(entity$1)) {
             throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
         }
-        core.ObjectHelper.propertyDelete(entity$1, "nodeIdentity");
-        core.ObjectHelper.propertyDelete(entity$1, "userIdentity");
-        return entity$1;
+        return core.ObjectHelper.omit(entity$1, ["nodeIdentity", "userIdentity"]);
     }
     /**
      * Convert the entry to JSON-LD.
@@ -942,7 +988,9 @@ class BlobStorageService {
             encodingFormat: entry?.encodingFormat,
             fileExtension: entry?.fileExtension,
             metadata: entry?.metadata,
-            blob: core.Is.uint8Array(blob) ? core.Converter.bytesToBase64(blob) : undefined
+            blob: core.Is.uint8Array(blob) ? core.Converter.bytesToBase64(blob) : undefined,
+            isEncrypted: entry.isEncrypted,
+            compression: entry.compression
         };
         return jsonLd;
     }
@@ -984,6 +1032,14 @@ exports.BlobStorageEntry = class BlobStorageEntry {
      * 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.
      */
@@ -1030,6 +1086,14 @@ __decorate([
     entity.property({ type: "object", itemTypeRef: "IJsonLdNodeObject", optional: true }),
     __metadata("design:type", Object)
 ], exports.BlobStorageEntry.prototype, "metadata", void 0);
+__decorate([
+    entity.property({ type: "boolean" }),
+    __metadata("design:type", Boolean)
+], exports.BlobStorageEntry.prototype, "isEncrypted", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.BlobStorageEntry.prototype, "compression", void 0);
 __decorate([
     entity.property({ type: "string", optional: true }),
     __metadata("design:type", String)

package/dist/esm/index.mjs

@@ -1,6 +1,6 @@
 import { HttpParameterHelper } from '@twin.org/api-models';
-import { BlobStorageTypes, BlobStorageContexts, BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
-import { StringHelper, Guards, ComponentFactory, Is, Converter, Coerce, GeneralError, Validation, ObjectHelper, Urn, NotFoundError } from '@twin.org/core';
+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';
@@ -96,7 +96,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            includeContent: true
+                            includeContent: "true"
                         }
                     }
                 }
@@ -186,7 +186,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
                         },
                         query: {
-                            download: true,
+                            download: "true",
                             filename: "my-file.pdf"
                         }
                     }
@@ -275,7 +275,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
         ]
     };
     const blobStorageListRoute = {
-        operationId: `${camelTypeName}Get`,
+        operationId: `${camelTypeName}Query`,
         summary: `Query the items from ${lowerName}`,
         tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "GET",
@@ -398,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.encodingFormat, request.body.fileExtension, request.body.metadata, request.body.namespace, httpRequestContext.userIdentity, 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: {
@@ -419,7 +423,11 @@ async function blobStorageGet(httpRequestContext, componentName, request) {
     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.userIdentity, 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
@@ -439,16 +447,31 @@ 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.userIdentity, httpRequestContext.nodeIdentity);
+    const decompress = Coerce.boolean(request.query?.decompress);
+    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)}`;
+        filename = `file.${result.fileExtension ?? MimeTypeHelper.defaultExtension(encodingFormat)}${compressedExtension}`;
     }
     return {
         body: Is.stringBase64(result.blob) ? Converter.base64ToBytes(result.blob) : new Uint8Array(),
         attachment: {
-            mimeType: encodingFormat,
+            mimeType: compressedEncodingFormat ?? encodingFormat,
             filename,
             inline: !(request.query?.download ?? false)
         }
@@ -564,10 +587,10 @@ class BlobStorageService {
         }
         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();
@@ -578,21 +601,28 @@ class BlobStorageService {
      * @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 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, namespace, userIdentity, nodeIdentity) {
+    async create(blob, encodingFormat, fileExtension, metadata, options, userIdentity, nodeIdentity) {
         Guards.stringBase64(this.CLASS_NAME, "blob", blob);
         if (this._includeUserIdentity) {
             Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         }
-        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
+        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);
@@ -612,9 +642,15 @@ class BlobStorageService {
                 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);
@@ -626,7 +662,9 @@ class BlobStorageService {
                 blobHash,
                 encodingFormat,
                 fileExtension,
-                metadata
+                metadata,
+                isEncrypted: encryptionEnabled,
+                compression: options?.compress
             };
             const conditions = [];
             if (this._includeUserIdentity) {
@@ -647,14 +685,19 @@ class BlobStorageService {
     /**
      * 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 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, userIdentity, nodeIdentity) {
+    async get(id, options, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
+        const includeContent = options?.includeContent ?? false;
+        const vaultKeyId = options?.overrideVaultKeyId ?? this._vaultKeyId;
         const conditions = [];
         if (this._includeUserIdentity) {
             Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
@@ -681,9 +724,16 @@ 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);
                 }
             }
             const jsonLd = this.entryToJsonLd(blobEntry, returnBlob);
@@ -731,7 +781,9 @@ class BlobStorageService {
                 blobHash: blobEntry.blobHash,
                 encodingFormat: encodingFormat ?? blobEntry.encodingFormat,
                 fileExtension: fileExtension ?? blobEntry.fileExtension,
-                metadata: metadata ?? blobEntry.metadata
+                metadata: metadata ?? blobEntry.metadata,
+                isEncrypted: blobEntry.isEncrypted,
+                compression: blobEntry.compression
             };
             const conditions = [];
             if (this._includeUserIdentity) {
@@ -826,10 +878,6 @@ class BlobStorageService {
                 sortDirection: orderDirection
             }
         ], undefined, cursor, pageSize);
-        for (const entity of result.entities) {
-            ObjectHelper.propertyDelete(entity, "nodeIdentity");
-            ObjectHelper.propertyDelete(entity, "userIdentity");
-        }
         let context = [
             SchemaOrgContexts.ContextRoot,
             BlobStorageContexts.ContextRoot,
@@ -913,9 +961,7 @@ class BlobStorageService {
         if (Is.empty(entity)) {
             throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
         }
-        ObjectHelper.propertyDelete(entity, "nodeIdentity");
-        ObjectHelper.propertyDelete(entity, "userIdentity");
-        return entity;
+        return ObjectHelper.omit(entity, ["nodeIdentity", "userIdentity"]);
     }
     /**
      * Convert the entry to JSON-LD.
@@ -940,7 +986,9 @@ class BlobStorageService {
             encodingFormat: entry?.encodingFormat,
             fileExtension: entry?.fileExtension,
             metadata: entry?.metadata,
-            blob: Is.uint8Array(blob) ? Converter.bytesToBase64(blob) : undefined
+            blob: Is.uint8Array(blob) ? Converter.bytesToBase64(blob) : undefined,
+            isEncrypted: entry.isEncrypted,
+            compression: entry.compression
         };
         return jsonLd;
     }
@@ -982,6 +1030,14 @@ let BlobStorageEntry = class BlobStorageEntry {
      * 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.
      */
@@ -1028,6 +1084,14 @@ __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)

package/dist/types/blobStorageService.d.ts

@@ -1,4 +1,4 @@
-import { type IBlobStorageComponent, type IBlobStorageEntry, type IBlobStorageEntryList } from "@twin.org/blob-storage-models";
+import { type BlobStorageCompressionType, type IBlobStorageComponent, type IBlobStorageEntry, type IBlobStorageEntryList } from "@twin.org/blob-storage-models";
 import { type IJsonLdNodeObject } from "@twin.org/data-json-ld";
 import { SortDirection, type EntityCondition } from "@twin.org/entity";
 import type { IBlobStorageServiceConstructorOptions } from "./models/IBlobStorageServiceConstructorOptions";
@@ -25,22 +25,38 @@ export declare class BlobStorageService implements IBlobStorageComponent {
      * @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 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.
      */
-    create(blob: string, encodingFormat?: string, fileExtension?: string, metadata?: IJsonLdNodeObject, namespace?: string, userIdentity?: string, nodeIdentity?: string): Promise<string>;
+    create(blob: string, encodingFormat?: string, fileExtension?: string, metadata?: IJsonLdNodeObject, options?: {
+        disableEncryption?: boolean;
+        overrideVaultKeyId?: string;
+        compress?: BlobStorageCompressionType;
+        namespace?: string;
+    }, userIdentity?: string, nodeIdentity?: string): Promise<string>;
     /**
      * 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 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.
      */
-    get(id: string, includeContent: boolean, userIdentity?: string, nodeIdentity?: string): Promise<IBlobStorageEntry>;
+    get(id: string, options?: {
+        includeContent?: boolean;
+        decompress?: boolean;
+        overrideVaultKeyId?: string;
+    }, userIdentity?: string, nodeIdentity?: string): Promise<IBlobStorageEntry>;
     /**
      * Update the blob with metadata.
      * @param id The id of the blob entry to update.

package/dist/types/entities/blobStorageEntry.d.ts

@@ -1,3 +1,4 @@
+import type { BlobStorageCompressionType } from "@twin.org/blob-storage-models";
 import type { IJsonLdNodeObject } from "@twin.org/data-json-ld";
 /**
  * Class representing entry for the blob storage.
@@ -35,6 +36,14 @@ export declare class BlobStorageEntry {
      * The metadata for the blob as JSON-LD.
      */
     metadata?: IJsonLdNodeObject;
+    /**
+     * Is the entry encrypted.
+     */
+    isEncrypted: boolean;
+    /**
+     * Is the entry compressed.
+     */
+    compression?: BlobStorageCompressionType;
     /**
      * The user identity that created the blob.
      */

package/dist/types/models/IBlobStorageServiceConfig.d.ts

@@ -3,8 +3,7 @@
  */
 export interface IBlobStorageServiceConfig {
     /**
-     * The name of the vault key to use for encryption if the service has a vault connector configured.
-     * @default blob-storage.
+     * The name of the vault key to use for encryption, if not configured no encryption will happen.
      */
     vaultKeyId?: string;
     /**

package/dist/types/models/IBlobStorageServiceConstructorOptions.d.ts

@@ -9,7 +9,7 @@ export interface IBlobStorageServiceConstructorOptions {
      */
     entryEntityStorageType?: string;
     /**
-     * The type of the vault connector for encryption, if undefined no encryption will be performed.
+     * The type of the vault connector for encryption.
      */
     vaultConnectorType?: string;
     /**