@stryker-mutator/dashboard-data-access 0.14.4-pr-888.4 → 0.14.4-pr-889.0

package/dist/src/mappers/DashboardQuery.d.ts

@@ -1,5 +1,5 @@
 import { ModelClass } from './ModelClass.js';
-import { TableEntityQueryOptions } from '@azure/data-tables';
+import { TableQuery } from 'azure-storage';
 export declare class DashboardQuery<TModel, TPartitionKeyFields extends keyof TModel, TRowKeyFields extends keyof TModel> {
     protected ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>;
     private readonly whereConditions;
@@ -7,6 +7,6 @@ export declare class DashboardQuery<TModel, TPartitionKeyFields extends keyof TM
     whereRowKeyNotEquals(rowKey: Pick<TModel, TRowKeyFields>): DashboardQuery<TModel, TPartitionKeyFields, TRowKeyFields>;
     wherePartitionKeyEquals(partitionKey: Pick<TModel, TPartitionKeyFields>): DashboardQuery<TModel, TPartitionKeyFields, TRowKeyFields>;
     static create<TModel, TPartitionKeyFields extends keyof TModel, TRowKeyFields extends keyof TModel>(ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>): DashboardQuery<TModel, TPartitionKeyFields, TRowKeyFields>;
-    build(): TableEntityQueryOptions;
+    build(): TableQuery;
 }
 //# sourceMappingURL=DashboardQuery.d.ts.map

package/dist/src/mappers/DashboardQuery.js

@@ -1,5 +1,5 @@
+import { TableQuery } from 'azure-storage';
 import { encodeKey } from '../utils.js';
-import { odata } from '@azure/data-tables';
 export class DashboardQuery {
     constructor(ModelClass, whereConditions) {
         this.ModelClass = ModelClass;
@@ -7,13 +7,15 @@ export class DashboardQuery {
     }
     whereRowKeyNotEquals(rowKey) {
         const whereCondition = {
-            condition: odata `not(RowKey eq ${encodeKey(this.ModelClass.createRowKey(rowKey) || '')})`,
+            condition: 'not(RowKey eq ?)',
+            params: [encodeKey(this.ModelClass.createRowKey(rowKey) || '')],
         };
         return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
     }
     wherePartitionKeyEquals(partitionKey) {
         const whereCondition = {
-            condition: odata `PartitionKey eq ${encodeKey(this.ModelClass.createPartitionKey(partitionKey))}`,
+            condition: 'PartitionKey eq ?',
+            params: [encodeKey(this.ModelClass.createPartitionKey(partitionKey))],
         };
         return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
     }
@@ -23,12 +25,12 @@ export class DashboardQuery {
     build() {
         return this.whereConditions.reduce((tableQuery, whereCondition, index) => {
             if (index === 0) {
-                return { filter: whereCondition.condition };
+                return tableQuery.where(whereCondition.condition, ...whereCondition.params);
             }
             else {
-                return { filter: `${tableQuery.filter} and ${whereCondition.condition}` };
+                return tableQuery.and(whereCondition.condition, whereCondition.params);
             }
-        }, {});
+        }, new TableQuery());
     }
 }
 //# sourceMappingURL=DashboardQuery.js.map

package/dist/src/mappers/MutationTestingResultMapper.d.ts

@@ -1,14 +1,15 @@
+import { BlobServiceAsPromised } from '../services/BlobServiceAsPromised.js';
+import { BlobService } from 'azure-storage';
 import * as schema from 'mutation-testing-report-schema';
 import { ReportIdentifier } from '@stryker-mutator/dashboard-common';
-import { BlobServiceClient, ContainerCreateIfNotExistsResponse } from '@azure/storage-blob';
 /**
  * The report json part of a mutation testing report is stored in blob storage
  */
 export declare class MutationTestingResultMapper {
-    #private;
+    private readonly blobService;
     private static readonly CONTAINER_NAME;
-    constructor(blobService?: BlobServiceClient);
-    createStorageIfNotExists(): Promise<ContainerCreateIfNotExistsResponse>;
+    constructor(blobService?: BlobServiceAsPromised);
+    createStorageIfNotExists(): Promise<BlobService.ContainerResult>;
     insertOrReplace(id: ReportIdentifier, result: schema.MutationTestResult | null): Promise<void>;
     findOne(identifier: ReportIdentifier): Promise<schema.MutationTestResult | null>;
     delete(id: ReportIdentifier): Promise<void>;

package/dist/src/mappers/MutationTestingResultMapper.js

@@ -1,46 +1,31 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MutationTestingResultMapper_containerClient;
-import { hasDetailsCode, isStorageError, toBlobName } from '../utils.js';
+import { BlobServiceAsPromised } from '../services/BlobServiceAsPromised.js';
+import { Constants } from 'azure-storage';
+import { isStorageError, toBlobName } from '../utils.js';
 import { OptimisticConcurrencyError } from '../errors/index.js';
-import { createBlobServiceClient } from '../services/BlobServiceClient.js';
-const errCodes = Object.freeze({
+const additionalErrorCodes = Object.freeze({
     BLOB_HAS_BEEN_MODIFIED: 'BlobHasBeenModified',
-    BLOB_NOT_FOUND: 'BlobNotFound',
 });
 /**
  * The report json part of a mutation testing report is stored in blob storage
  */
 export class MutationTestingResultMapper {
-    constructor(blobService = createBlobServiceClient()) {
-        _MutationTestingResultMapper_containerClient.set(this, void 0);
-        __classPrivateFieldSet(this, _MutationTestingResultMapper_containerClient, blobService.getContainerClient(MutationTestingResultMapper.CONTAINER_NAME), "f");
+    constructor(blobService = new BlobServiceAsPromised()) {
+        this.blobService = blobService;
     }
     createStorageIfNotExists() {
-        return __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").createIfNotExists({});
+        return this.blobService.createContainerIfNotExists(MutationTestingResultMapper.CONTAINER_NAME, {});
     }
     async insertOrReplace(id, result) {
         try {
-            await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f")
-                .getBlockBlobClient(toBlobName(id))
-                .uploadData(Buffer.from(JSON.stringify(result), 'utf-8'), {
-                blobHTTPHeaders: {
-                    blobContentType: 'application/json',
-                    blobContentEncoding: 'utf8',
+            await this.blobService.createBlockBlobFromText(MutationTestingResultMapper.CONTAINER_NAME, toBlobName(id), JSON.stringify(result), {
+                contentSettings: {
+                    contentType: 'application/json',
+                    contentEncoding: 'utf8',
                 },
             });
         }
         catch (err) {
-            if (isStorageError(err) && hasDetailsCode(err.details, errCodes.BLOB_HAS_BEEN_MODIFIED)) {
+            if (isStorageError(err) && err.code === additionalErrorCodes.BLOB_HAS_BEEN_MODIFIED) {
                 throw new OptimisticConcurrencyError(`Blob "${JSON.stringify(id)}" was modified by another process`);
             }
             else {
@@ -51,11 +36,11 @@ export class MutationTestingResultMapper {
     async findOne(identifier) {
         const blobName = toBlobName(identifier);
         try {
-            const result = JSON.parse((await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").getBlockBlobClient(blobName).downloadToBuffer()).toString('utf-8'));
+            const result = JSON.parse(await this.blobService.blobToText(MutationTestingResultMapper.CONTAINER_NAME, blobName));
             return result;
         }
         catch (error) {
-            if (isStorageError(error) && hasDetailsCode(error.details, errCodes.BLOB_NOT_FOUND)) {
+            if (isStorageError(error) && error.code === Constants.BlobErrorCodeStrings.BLOB_NOT_FOUND) {
                 return null;
             }
             else {
@@ -66,9 +51,8 @@ export class MutationTestingResultMapper {
     }
     async delete(id) {
         const blobName = toBlobName(id);
-        await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").getBlockBlobClient(blobName).deleteIfExists();
+        await this.blobService.deleteBlobIfExists(MutationTestingResultMapper.CONTAINER_NAME, blobName);
     }
 }
-_MutationTestingResultMapper_containerClient = new WeakMap();
 MutationTestingResultMapper.CONTAINER_NAME = 'mutation-testing-report';
 //# sourceMappingURL=MutationTestingResultMapper.js.map

package/dist/src/mappers/TableStorageMapper.d.ts

@@ -1,11 +1,11 @@
+import TableServiceAsPromised from '../services/TableServiceAsPromised.js';
 import { Mapper, Result } from './Mapper.js';
 import { ModelClass } from './ModelClass.js';
 import { DashboardQuery } from './DashboardQuery.js';
-import { TableClient } from '@azure/data-tables';
 export default class TableStorageMapper<TModel extends object, TPartitionKeyFields extends keyof TModel, TRowKeyFields extends keyof TModel> implements Mapper<TModel, TPartitionKeyFields, TRowKeyFields> {
-    #private;
     private readonly ModelClass;
-    constructor(ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>, tableClient?: TableClient);
+    private readonly tableService;
+    constructor(ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>, tableService?: TableServiceAsPromised);
     createStorageIfNotExists(): Promise<void>;
     insertOrMerge(model: TModel): Promise<void>;
     findOne(identity: Pick<TModel, TPartitionKeyFields | TRowKeyFields>): Promise<Result<TModel> | null>;

package/dist/src/mappers/TableStorageMapper.js

@@ -1,51 +1,28 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var _TableStorageMapper_tableClient;
-import { encodeKey, decodeKey, isStorageError, hasDetailsCode } from '../utils.js';
+import { Constants } from 'azure-storage';
+import TableServiceAsPromised from '../services/TableServiceAsPromised.js';
+import { encodeKey, decodeKey, isStorageError } from '../utils.js';
 import { OptimisticConcurrencyError } from '../errors/index.js';
 import { DashboardQuery } from './DashboardQuery.js';
-import { createTableClient } from '../services/TableClient.js';
-const errCodes = Object.freeze({
-    UPDATE_CONDITION_NOT_SATISFIED: 'UpdateConditionNotSatisfied',
-    ENTITY_ALREADY_EXISTS: 'EntityAlreadyExists',
-    RESOURCE_NOT_FOUND: 'ResourceNotFound',
-});
-class TableStorageMapper {
-    constructor(ModelClass, tableClient = createTableClient(ModelClass.name)) {
+export default class TableStorageMapper {
+    constructor(ModelClass, tableService = new TableServiceAsPromised()) {
         this.ModelClass = ModelClass;
-        _TableStorageMapper_tableClient.set(this, void 0);
-        __classPrivateFieldSet(this, _TableStorageMapper_tableClient, tableClient, "f");
+        this.tableService = tableService;
     }
     async createStorageIfNotExists() {
-        await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").createTable();
+        await this.tableService.createTableIfNotExists(this.ModelClass.tableName);
     }
     async insertOrMerge(model) {
         const entity = this.toEntity(model);
-        await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").upsertEntity(entity, 'Merge');
+        await this.tableService.insertOrMergeEntity(this.ModelClass.tableName, entity);
     }
     async findOne(identity) {
         try {
-            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").getEntity(encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
+            const result = await this.tableService.retrieveEntity(this.ModelClass.tableName, encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
             return this.toModel(result);
         }
         catch (err) {
-            if (isStorageError(err) && hasDetailsCode(err.details, errCodes.RESOURCE_NOT_FOUND)) {
+            if (isStorageError(err) &&
+                err.code === Constants.StorageErrorCodeStrings.RESOURCE_NOT_FOUND) {
                 return null;
             }
             else {
@@ -55,26 +32,9 @@ class TableStorageMapper {
         }
     }
     async findAll(query = DashboardQuery.create(this.ModelClass)) {
-        var _a, e_1, _b, _c;
         const tableQuery = query.build();
-        const entities = __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").listEntities({ queryOptions: tableQuery });
-        const results = [];
-        try {
-            for (var _d = true, entities_1 = __asyncValues(entities), entities_1_1; entities_1_1 = await entities_1.next(), _a = entities_1_1.done, !_a; _d = true) {
-                _c = entities_1_1.value;
-                _d = false;
-                const entity = _c;
-                results.push(this.toModel(entity));
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = entities_1.return)) await _b.call(entities_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return results;
+        const results = await this.tableService.queryEntities(this.ModelClass.tableName, tableQuery, undefined);
+        return results.entries.map((entity) => this.toModel(entity));
     }
     /**
      * Replace an entity of a specific version (throws error otherwise)
@@ -84,14 +44,15 @@ class TableStorageMapper {
      */
     async replace(model, etag) {
         const entity = this.toEntity(model);
+        entity['.metadata'].etag = etag;
         try {
-            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").updateEntity(entity, 'Replace', { etag });
-            return { model, etag: result.etag };
+            const result = await this.tableService.replaceEntity(this.ModelClass.tableName, entity, {});
+            return { model, etag: result['.metadata'].etag };
         }
         catch (err) {
             if (isStorageError(err) &&
-                hasDetailsCode(err.details, errCodes.UPDATE_CONDITION_NOT_SATISFIED)) {
-                throw new OptimisticConcurrencyError(`Replace entity with etag ${etag} resulted in ${err.details.errorCode}`);
+                err.code === Constants.StorageErrorCodeStrings.UPDATE_CONDITION_NOT_SATISFIED) {
+                throw new OptimisticConcurrencyError(`Replace entity with etag ${etag} resulted in ${Constants.StorageErrorCodeStrings.UPDATE_CONDITION_NOT_SATISFIED}`);
             }
             else {
                 throw err;
@@ -101,12 +62,13 @@ class TableStorageMapper {
     async insert(model) {
         const entity = this.toEntity(model);
         try {
-            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").createEntity(entity);
-            return { model, etag: result.etag };
+            const result = await this.tableService.insertEntity(this.ModelClass.tableName, entity, {});
+            return { model, etag: result['.metadata'].etag };
         }
         catch (err) {
-            if (isStorageError(err) && hasDetailsCode(err.details, errCodes.ENTITY_ALREADY_EXISTS)) {
-                throw new OptimisticConcurrencyError(`Trying to insert "${entity.partitionKey}" "${entity.rowKey}" which already exists (${err.details.errorCode})`);
+            if (isStorageError(err) &&
+                err.code === Constants.TableErrorCodeStrings.ENTITY_ALREADY_EXISTS) {
+                throw new OptimisticConcurrencyError(`Trying to insert "${entity.PartitionKey}" "${entity.RowKey}" which already exists (${Constants.TableErrorCodeStrings.ENTITY_ALREADY_EXISTS})`);
             }
             else {
                 throw err;
@@ -115,22 +77,21 @@ class TableStorageMapper {
     }
     toModel(entity) {
         const value = new this.ModelClass();
-        this.ModelClass.identify(value, decodeKey(entity.partitionKey), decodeKey(entity.rowKey));
-        this.ModelClass.persistedFields.forEach((field) => (value[field] = entity[field]));
+        this.ModelClass.identify(value, decodeKey(entity.PartitionKey._), decodeKey(entity.RowKey._));
+        this.ModelClass.persistedFields.forEach((field) => (value[field] = entity[field]._));
         return {
-            etag: entity.etag,
+            etag: entity['.metadata'].etag,
             model: value,
         };
     }
     toEntity(entity) {
         const data = {
-            partitionKey: encodeKey(this.ModelClass.createPartitionKey(entity)),
-            rowKey: encodeKey(this.ModelClass.createRowKey(entity) || ''),
+            PartitionKey: encodeKey(this.ModelClass.createPartitionKey(entity)),
+            RowKey: encodeKey(this.ModelClass.createRowKey(entity) || ''),
         };
         this.ModelClass.persistedFields.forEach((field) => (data[field] = entity[field]));
+        data['.metadata'] = {};
         return data;
     }
 }
-_TableStorageMapper_tableClient = new WeakMap();
-export default TableStorageMapper;
 //# sourceMappingURL=TableStorageMapper.js.map

package/dist/src/services/BlobServiceAsPromised.d.ts

@@ -0,0 +1,11 @@
+import { BlobService } from 'azure-storage';
+export declare class BlobServiceAsPromised {
+    createContainerIfNotExists: (container: string, options: BlobService.CreateContainerOptions) => Promise<BlobService.ContainerResult>;
+    createBlockBlobFromText: (container: string, blob: string, text: string | Buffer, options: BlobService.CreateBlobRequestOptions) => Promise<BlobService.BlobResult>;
+    blobToText: (container: string, blob: string) => Promise<string>;
+    createAppendBlobFromText: (container: string, blob: string, text: string | Buffer) => Promise<BlobService.BlobResult>;
+    appendBlockFromText: (container: string, blob: string, text: string | Buffer) => Promise<BlobService.BlobResult>;
+    deleteBlobIfExists: (container: string, blob: string) => Promise<unknown>;
+    constructor(blobService?: BlobService);
+}
+//# sourceMappingURL=BlobServiceAsPromised.d.ts.map

package/dist/src/services/BlobServiceAsPromised.js

@@ -0,0 +1,13 @@
+import { createBlobService } from 'azure-storage';
+import { promisify } from 'util';
+export class BlobServiceAsPromised {
+    constructor(blobService = createBlobService()) {
+        this.createContainerIfNotExists = promisify(blobService.createContainerIfNotExists).bind(blobService);
+        this.createBlockBlobFromText = promisify(blobService.createBlockBlobFromText).bind(blobService);
+        this.blobToText = promisify(blobService.getBlobToText).bind(blobService);
+        this.createAppendBlobFromText = promisify(blobService.createAppendBlobFromText).bind(blobService);
+        this.appendBlockFromText = promisify(blobService.appendBlockFromText).bind(blobService);
+        this.deleteBlobIfExists = promisify(blobService.deleteBlobIfExists).bind(blobService);
+    }
+}
+//# sourceMappingURL=BlobServiceAsPromised.js.map

package/dist/src/services/RealTimeMutantsBlobService.d.ts

@@ -1,10 +1,10 @@
 import { ReportIdentifier } from '@stryker-mutator/dashboard-common';
+import { BlobServiceAsPromised } from './BlobServiceAsPromised.js';
 import { MutantResult } from 'mutation-testing-report-schema';
-import { BlobServiceClient } from '@azure/storage-blob';
 export declare class RealTimeMutantsBlobService {
     #private;
     private static readonly CONTAINER_NAME;
-    constructor(blobService?: BlobServiceClient);
+    constructor(blobService?: BlobServiceAsPromised);
     createStorageIfNotExists(): Promise<void>;
     createReport(id: ReportIdentifier): Promise<void>;
     appendToReport(id: ReportIdentifier, mutants: Array<Partial<MutantResult>>): Promise<void>;

package/dist/src/services/RealTimeMutantsBlobService.js

@@ -9,31 +9,33 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _RealTimeMutantsBlobService_containerClient;
+var _RealTimeMutantsBlobService_blobService;
+import { BlobServiceAsPromised } from './BlobServiceAsPromised.js';
 import { toBlobName } from '../utils.js';
-import { createBlobServiceClient } from './BlobServiceClient.js';
 // To make resource delete themselves automatically, this should be managed from within Azure:
 // https://learn.microsoft.com/en-us/azure/storage/blobs/lifecycle-management-overview?tabs=azure-portal
 export class RealTimeMutantsBlobService {
-    constructor(blobService = createBlobServiceClient()) {
-        _RealTimeMutantsBlobService_containerClient.set(this, void 0);
-        __classPrivateFieldSet(this, _RealTimeMutantsBlobService_containerClient, blobService.getContainerClient(RealTimeMutantsBlobService.CONTAINER_NAME), "f");
+    constructor(blobService = new BlobServiceAsPromised()) {
+        _RealTimeMutantsBlobService_blobService.set(this, void 0);
+        __classPrivateFieldSet(this, _RealTimeMutantsBlobService_blobService, blobService, "f");
     }
     async createStorageIfNotExists() {
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").createIfNotExists({});
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").createContainerIfNotExists(RealTimeMutantsBlobService.CONTAINER_NAME, {});
     }
     async createReport(id) {
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(toBlobName(id)).create();
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").createAppendBlobFromText(RealTimeMutantsBlobService.CONTAINER_NAME, toBlobName(id), '');
     }
     async appendToReport(id, mutants) {
         const blobName = toBlobName(id);
         const data = mutants.map((mutant) => `${JSON.stringify(mutant)}\n`).join('');
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(blobName).appendBlock(data, data.length);
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").appendBlockFromText(RealTimeMutantsBlobService.CONTAINER_NAME, blobName, data);
     }
     async getReport(id) {
-        const data = await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(toBlobName(id)).downloadToBuffer();
+        const data = await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").blobToText(RealTimeMutantsBlobService.CONTAINER_NAME, toBlobName(id));
+        if (data === '') {
+            return [];
+        }
         return (data
-            .toString('utf-8')
             .split('\n')
             // Since every line has a newline it will produce an empty string in the list.
             // Remove it, so nothing breaks.
@@ -42,9 +44,9 @@ export class RealTimeMutantsBlobService {
     }
     async delete(id) {
         const blobName = toBlobName(id);
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(blobName).deleteIfExists();
+        __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").deleteBlobIfExists(RealTimeMutantsBlobService.CONTAINER_NAME, blobName);
     }
 }
-_RealTimeMutantsBlobService_containerClient = new WeakMap();
+_RealTimeMutantsBlobService_blobService = new WeakMap();
 RealTimeMutantsBlobService.CONTAINER_NAME = 'real-time-mutant-results';
 //# sourceMappingURL=RealTimeMutantsBlobService.js.map

package/dist/src/services/TableServiceAsPromised.d.ts

@@ -0,0 +1,32 @@
+import { TableService, TableQuery, common } from 'azure-storage';
+export type Entity<T, TKeyFields extends keyof T> = {
+    [K in Exclude<keyof T, TKeyFields>]: {
+        $: string;
+        _: T[K];
+    };
+} & EntityKey & EntityMetadata;
+export interface EntityKey {
+    PartitionKey: {
+        $: 'Edm.String';
+        _: string;
+    };
+    RowKey: {
+        $: 'Edm.String';
+        _: string;
+    };
+}
+export interface EntityMetadata {
+    ['.metadata']: {
+        etag: string;
+    };
+}
+export default class TableServiceAsPromised {
+    constructor(tableService?: TableService);
+    insertEntity: (table: string, entityDescriptor: unknown, options: common.RequestOptions) => Promise<TableService.EntityMetadata>;
+    replaceEntity: (table: string, entityDescriptor: unknown, options: common.RequestOptions) => Promise<TableService.EntityMetadata>;
+    createTableIfNotExists: (name: string) => Promise<TableService.TableResult>;
+    queryEntities: <T, Keys extends keyof T>(table: string, tableQuery: TableQuery, cancellationToken: TableService.TableContinuationToken | undefined) => Promise<TableService.QueryEntitiesResult<Entity<T, Keys> & EntityKey>>;
+    insertOrMergeEntity: (table: string, entity: any) => Promise<TableService.EntityMetadata>;
+    retrieveEntity: <TResult>(table: string, partitionKey: string, rowKey: string, options?: TableService.TableEntityRequestOptions) => Promise<TResult>;
+}
+//# sourceMappingURL=TableServiceAsPromised.d.ts.map

package/dist/src/services/TableServiceAsPromised.js

@@ -0,0 +1,13 @@
+import { promisify } from 'util';
+import { createTableService } from 'azure-storage';
+export default class TableServiceAsPromised {
+    constructor(tableService = createTableService()) {
+        this.createTableIfNotExists = promisify(tableService.createTableIfNotExists).bind(tableService);
+        this.queryEntities = promisify(tableService.queryEntities).bind(tableService);
+        this.insertOrMergeEntity = promisify(tableService.insertOrMergeEntity).bind(tableService);
+        this.retrieveEntity = promisify(tableService.retrieveEntity).bind(tableService);
+        this.replaceEntity = promisify(tableService.replaceEntity).bind(tableService);
+        this.insertEntity = promisify(tableService.insertEntity).bind(tableService);
+    }
+}
+//# sourceMappingURL=TableServiceAsPromised.js.map

package/dist/src/utils.d.ts

@@ -1,10 +1,7 @@
 import { ReportIdentifier } from '@stryker-mutator/dashboard-common';
-import { RestError } from '@azure/storage-blob';
+import { StorageError } from 'azure-storage';
 export declare function encodeKey(inputWithSlashes: string): string;
 export declare function decodeKey(inputWithSemiColons: string): string;
-export declare function isStorageError(maybeStorageError: unknown): maybeStorageError is RestError;
-export declare function hasDetailsCode(maybeDetails: unknown, code: string): maybeDetails is {
-    errorCode: string;
-};
+export declare function isStorageError(maybeStorageError: unknown): maybeStorageError is StorageError;
 export declare function toBlobName({ projectName, version, moduleName, realTime }: ReportIdentifier): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.js

@@ -1,4 +1,3 @@
-import { RestError } from '@azure/storage-blob';
 export function encodeKey(inputWithSlashes) {
     return inputWithSlashes.replace(/\//g, ';');
 }
@@ -6,13 +5,8 @@ export function decodeKey(inputWithSemiColons) {
     return inputWithSemiColons.replace(/;/g, '/');
 }
 export function isStorageError(maybeStorageError) {
-    return maybeStorageError instanceof RestError;
-}
-export function hasDetailsCode(maybeDetails, code) {
-    return (typeof maybeDetails === 'object' &&
-        maybeDetails !== null &&
-        'errorCode' in maybeDetails &&
-        maybeDetails.errorCode === code);
+    return (maybeStorageError instanceof Error &&
+        maybeStorageError.name === 'StorageError');
 }
 export function toBlobName({ projectName, version, moduleName, realTime }) {
     const slug = [projectName, version, moduleName, realTime ? 'real-time' : realTime]

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@stryker-mutator/dashboard-data-access",
-  "version": "0.14.4-pr-888.4",
+  "version": "0.14.4-pr-889.0",
   "type": "module",
   "description": "This package contains the data access layer of the stryker dashboard application.",
   "scripts": {
     "test": "c8 --check-coverage --reporter=html --report-dir=reports/coverage --lines 80 --functions 75 --branches 65 mocha --node-option enable-source-maps \"dist/test/helpers/**/*.js\" \"dist/test/unit/**/*.js\"",
-    "test:integration": "mocha --node-option enable-source-maps \"dist/test/helpers/**/*.js\" \"dist/test/integration/**/*.js\"",
     "stryker": "stryker run"
   },
   "publishConfig": {
@@ -22,11 +21,10 @@
   "typings": "src/index.ts",
   "license": "ISC",
   "dependencies": {
-    "@azure/data-tables": "13.2.2",
-    "@azure/storage-blob": "12.24.0",
-    "@stryker-mutator/dashboard-common": "0.14.4-pr-888.4",
+    "@stryker-mutator/dashboard-common": "0.14.4-pr-889.0",
+    "azure-storage": "2.10.7",
     "mutation-testing-metrics": "3.2.0",
     "mutation-testing-report-schema": "3.1.1"
   },
-  "gitHead": "f3df70d4eba0783518d84ef76e10df1de1da07bb"
+  "gitHead": "3fdcbcfc2c3da666c22ba37b605fbc29064ef89d"
 }

package/dist/src/services/BlobServiceClient.d.ts

@@ -1,3 +0,0 @@
-import { BlobServiceClient } from '@azure/storage-blob';
-export declare const createBlobServiceClient: () => BlobServiceClient;
-//# sourceMappingURL=BlobServiceClient.d.ts.map

package/dist/src/services/BlobServiceClient.js

@@ -1,11 +0,0 @@
-import { BlobServiceClient } from '@azure/storage-blob';
-export const createBlobServiceClient = () => {
-    const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
-    if (connectionString) {
-        return BlobServiceClient.fromConnectionString(connectionString);
-    }
-    else {
-        throw new Error('AZURE_STORAGE_CONNECTION_STRING is not set');
-    }
-};
-//# sourceMappingURL=BlobServiceClient.js.map

package/dist/src/services/TableClient.d.ts

@@ -1,3 +0,0 @@
-import { TableClient } from '@azure/data-tables';
-export declare const createTableClient: (tableName: string) => TableClient;
-//# sourceMappingURL=TableClient.d.ts.map

package/dist/src/services/TableClient.js

@@ -1,13 +0,0 @@
-import { TableClient } from '@azure/data-tables';
-export const createTableClient = (tableName) => {
-    const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
-    if (connectionString) {
-        return TableClient.fromConnectionString(connectionString, tableName, {
-            allowInsecureConnection: process.env.NODE_ENV !== 'production',
-        });
-    }
-    else {
-        throw new Error('AZURE_STORAGE_CONNECTION_STRING is not set');
-    }
-};
-//# sourceMappingURL=TableClient.js.map