@stryker-mutator/dashboard-data-access 0.14.4-pr-822.16 → 0.15.0

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

@@ -1,5 +1,5 @@
 import { ModelClass } from './ModelClass.js';
-import { TableQuery } from 'azure-storage';
+import { TableEntityQueryOptions } from '@azure/data-tables';
 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(): TableQuery;
+    build(): TableEntityQueryOptions;
 }
 //# sourceMappingURL=DashboardQuery.d.ts.map

package/dist/src/mappers/DashboardQuery.js

@@ -1,22 +1,16 @@
-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;
         this.whereConditions = whereConditions;
     }
     whereRowKeyNotEquals(rowKey) {
-        const whereCondition = {
-            condition: 'not(RowKey eq ?)',
-            params: [encodeKey(this.ModelClass.createRowKey(rowKey) || '')],
-        };
+        const whereCondition = odata `RowKey ne ${encodeKey(this.ModelClass.createRowKey(rowKey) || '')}`;
         return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
     }
     wherePartitionKeyEquals(partitionKey) {
-        const whereCondition = {
-            condition: 'PartitionKey eq ?',
-            params: [encodeKey(this.ModelClass.createPartitionKey(partitionKey))],
-        };
+        const whereCondition = odata `PartitionKey eq ${encodeKey(this.ModelClass.createPartitionKey(partitionKey))}`;
         return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
     }
     static create(ModelClass) {
@@ -25,12 +19,12 @@ export class DashboardQuery {
     build() {
         return this.whereConditions.reduce((tableQuery, whereCondition, index) => {
             if (index === 0) {
-                return tableQuery.where(whereCondition.condition, ...whereCondition.params);
+                return { filter: whereCondition };
             }
             else {
-                return tableQuery.and(whereCondition.condition, whereCondition.params);
+                return { filter: `${tableQuery.filter} and ${whereCondition}` };
             }
-        }, new TableQuery());
+        }, {});
     }
 }
 //# sourceMappingURL=DashboardQuery.js.map

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

@@ -1,15 +1,14 @@
-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 readonly blobService;
+    #private;
     private static readonly CONTAINER_NAME;
-    constructor(blobService?: BlobServiceAsPromised);
-    createStorageIfNotExists(): Promise<BlobService.ContainerResult>;
+    constructor(blobService?: BlobServiceClient);
+    createStorageIfNotExists(): Promise<ContainerCreateIfNotExistsResponse>;
     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,31 +1,46 @@
-import { BlobServiceAsPromised } from '../services/BlobServiceAsPromised.js';
-import { Constants } from 'azure-storage';
-import { isStorageError, toBlobName } from '../utils.js';
+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 { hasErrorCode, toBlobName } from '../utils.js';
 import { OptimisticConcurrencyError } from '../errors/index.js';
-const additionalErrorCodes = Object.freeze({
+import { createBlobServiceClient } from '../services/BlobServiceClient.js';
+const errCodes = 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 = new BlobServiceAsPromised()) {
-        this.blobService = blobService;
+    constructor(blobService = createBlobServiceClient()) {
+        _MutationTestingResultMapper_containerClient.set(this, void 0);
+        __classPrivateFieldSet(this, _MutationTestingResultMapper_containerClient, blobService.getContainerClient(MutationTestingResultMapper.CONTAINER_NAME), "f");
     }
     createStorageIfNotExists() {
-        return this.blobService.createContainerIfNotExists(MutationTestingResultMapper.CONTAINER_NAME, {});
+        return __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").createIfNotExists({});
     }
     async insertOrReplace(id, result) {
         try {
-            await this.blobService.createBlockBlobFromText(MutationTestingResultMapper.CONTAINER_NAME, toBlobName(id), JSON.stringify(result), {
-                contentSettings: {
-                    contentType: 'application/json',
-                    contentEncoding: 'utf8',
+            await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f")
+                .getBlockBlobClient(toBlobName(id))
+                .uploadData(Buffer.from(JSON.stringify(result), 'utf-8'), {
+                blobHTTPHeaders: {
+                    blobContentType: 'application/json',
+                    blobContentEncoding: 'utf8',
                 },
             });
         }
         catch (err) {
-            if (isStorageError(err) && err.code === additionalErrorCodes.BLOB_HAS_BEEN_MODIFIED) {
+            if (hasErrorCode(err, errCodes.BLOB_HAS_BEEN_MODIFIED)) {
                 throw new OptimisticConcurrencyError(`Blob "${JSON.stringify(id)}" was modified by another process`);
             }
             else {
@@ -36,11 +51,11 @@ export class MutationTestingResultMapper {
     async findOne(identifier) {
         const blobName = toBlobName(identifier);
         try {
-            const result = JSON.parse(await this.blobService.blobToText(MutationTestingResultMapper.CONTAINER_NAME, blobName));
+            const result = JSON.parse((await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").getBlockBlobClient(blobName).downloadToBuffer()).toString('utf-8'));
             return result;
         }
         catch (error) {
-            if (isStorageError(error) && error.code === Constants.BlobErrorCodeStrings.BLOB_NOT_FOUND) {
+            if (hasErrorCode(error, errCodes.BLOB_NOT_FOUND)) {
                 return null;
             }
             else {
@@ -51,8 +66,9 @@ export class MutationTestingResultMapper {
     }
     async delete(id) {
         const blobName = toBlobName(id);
-        await this.blobService.deleteBlobIfExists(MutationTestingResultMapper.CONTAINER_NAME, blobName);
+        await __classPrivateFieldGet(this, _MutationTestingResultMapper_containerClient, "f").getBlockBlobClient(blobName).deleteIfExists();
     }
 }
+_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;
-    private readonly tableService;
-    constructor(ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>, tableService?: TableServiceAsPromised);
+    constructor(ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>, tableClient?: TableClient);
     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,28 +1,51 @@
-import { Constants } from 'azure-storage';
-import TableServiceAsPromised from '../services/TableServiceAsPromised.js';
-import { encodeKey, decodeKey, isStorageError } from '../utils.js';
+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, hasErrorCode } from '../utils.js';
 import { OptimisticConcurrencyError } from '../errors/index.js';
 import { DashboardQuery } from './DashboardQuery.js';
-export default class TableStorageMapper {
-    constructor(ModelClass, tableService = new TableServiceAsPromised()) {
+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)) {
         this.ModelClass = ModelClass;
-        this.tableService = tableService;
+        _TableStorageMapper_tableClient.set(this, void 0);
+        __classPrivateFieldSet(this, _TableStorageMapper_tableClient, tableClient, "f");
     }
     async createStorageIfNotExists() {
-        await this.tableService.createTableIfNotExists(this.ModelClass.tableName);
+        await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").createTable();
     }
     async insertOrMerge(model) {
         const entity = this.toEntity(model);
-        await this.tableService.insertOrMergeEntity(this.ModelClass.tableName, entity);
+        await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").upsertEntity(entity, 'Merge');
     }
     async findOne(identity) {
         try {
-            const result = await this.tableService.retrieveEntity(this.ModelClass.tableName, encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
+            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").getEntity(encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
             return this.toModel(result);
         }
         catch (err) {
-            if (isStorageError(err) &&
-                err.code === Constants.StorageErrorCodeStrings.RESOURCE_NOT_FOUND) {
+            if (hasErrorCode(err, errCodes.RESOURCE_NOT_FOUND)) {
                 return null;
             }
             else {
@@ -32,9 +55,26 @@ export default class TableStorageMapper {
         }
     }
     async findAll(query = DashboardQuery.create(this.ModelClass)) {
+        var _a, e_1, _b, _c;
         const tableQuery = query.build();
-        const results = await this.tableService.queryEntities(this.ModelClass.tableName, tableQuery, undefined);
-        return results.entries.map((entity) => this.toModel(entity));
+        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;
     }
     /**
      * Replace an entity of a specific version (throws error otherwise)
@@ -44,15 +84,13 @@ export default class TableStorageMapper {
      */
     async replace(model, etag) {
         const entity = this.toEntity(model);
-        entity['.metadata'].etag = etag;
         try {
-            const result = await this.tableService.replaceEntity(this.ModelClass.tableName, entity, {});
-            return { model, etag: result['.metadata'].etag };
+            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").updateEntity(entity, 'Replace', { etag });
+            return { model, etag: result.etag };
         }
         catch (err) {
-            if (isStorageError(err) &&
-                err.code === Constants.StorageErrorCodeStrings.UPDATE_CONDITION_NOT_SATISFIED) {
-                throw new OptimisticConcurrencyError(`Replace entity with etag ${etag} resulted in ${Constants.StorageErrorCodeStrings.UPDATE_CONDITION_NOT_SATISFIED}`);
+            if (hasErrorCode(err, errCodes.UPDATE_CONDITION_NOT_SATISFIED)) {
+                throw new OptimisticConcurrencyError(`Replace entity with etag ${etag} resulted in ${errCodes.UPDATE_CONDITION_NOT_SATISFIED}`);
             }
             else {
                 throw err;
@@ -62,13 +100,12 @@ export default class TableStorageMapper {
     async insert(model) {
         const entity = this.toEntity(model);
         try {
-            const result = await this.tableService.insertEntity(this.ModelClass.tableName, entity, {});
-            return { model, etag: result['.metadata'].etag };
+            const result = await __classPrivateFieldGet(this, _TableStorageMapper_tableClient, "f").createEntity(entity);
+            return { model, etag: result.etag };
         }
         catch (err) {
-            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})`);
+            if (hasErrorCode(err, errCodes.ENTITY_ALREADY_EXISTS)) {
+                throw new OptimisticConcurrencyError(`Trying to insert "${entity.partitionKey}" "${entity.rowKey}" which already exists (${errCodes.ENTITY_ALREADY_EXISTS})`);
             }
             else {
                 throw err;
@@ -77,21 +114,22 @@ export default 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['.metadata'].etag,
+            etag: entity.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/BlobServiceClient.d.ts

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

package/dist/src/services/BlobServiceClient.js

@@ -0,0 +1,11 @@
+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/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?: BlobServiceAsPromised);
+    constructor(blobService?: BlobServiceClient);
     createStorageIfNotExists(): Promise<void>;
     createReport(id: ReportIdentifier): Promise<void>;
     appendToReport(id: ReportIdentifier, mutants: Array<Partial<MutantResult>>): Promise<void>;

package/dist/src/services/RealTimeMutantsBlobService.js

@@ -9,33 +9,31 @@ 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_blobService;
-import { BlobServiceAsPromised } from './BlobServiceAsPromised.js';
+var _RealTimeMutantsBlobService_containerClient;
 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 = new BlobServiceAsPromised()) {
-        _RealTimeMutantsBlobService_blobService.set(this, void 0);
-        __classPrivateFieldSet(this, _RealTimeMutantsBlobService_blobService, blobService, "f");
+    constructor(blobService = createBlobServiceClient()) {
+        _RealTimeMutantsBlobService_containerClient.set(this, void 0);
+        __classPrivateFieldSet(this, _RealTimeMutantsBlobService_containerClient, blobService.getContainerClient(RealTimeMutantsBlobService.CONTAINER_NAME), "f");
     }
     async createStorageIfNotExists() {
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").createContainerIfNotExists(RealTimeMutantsBlobService.CONTAINER_NAME, {});
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").createIfNotExists({});
     }
     async createReport(id) {
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").createAppendBlobFromText(RealTimeMutantsBlobService.CONTAINER_NAME, toBlobName(id), '');
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(toBlobName(id)).create();
     }
     async appendToReport(id, mutants) {
         const blobName = toBlobName(id);
         const data = mutants.map((mutant) => `${JSON.stringify(mutant)}\n`).join('');
-        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").appendBlockFromText(RealTimeMutantsBlobService.CONTAINER_NAME, blobName, data);
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(blobName).appendBlock(data, data.length);
     }
     async getReport(id) {
-        const data = await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").blobToText(RealTimeMutantsBlobService.CONTAINER_NAME, toBlobName(id));
-        if (data === '') {
-            return [];
-        }
+        const data = await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(toBlobName(id)).downloadToBuffer();
         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.
@@ -44,9 +42,9 @@ export class RealTimeMutantsBlobService {
     }
     async delete(id) {
         const blobName = toBlobName(id);
-        __classPrivateFieldGet(this, _RealTimeMutantsBlobService_blobService, "f").deleteBlobIfExists(RealTimeMutantsBlobService.CONTAINER_NAME, blobName);
+        await __classPrivateFieldGet(this, _RealTimeMutantsBlobService_containerClient, "f").getAppendBlobClient(blobName).deleteIfExists();
     }
 }
-_RealTimeMutantsBlobService_blobService = new WeakMap();
+_RealTimeMutantsBlobService_containerClient = new WeakMap();
 RealTimeMutantsBlobService.CONTAINER_NAME = 'real-time-mutant-results';
 //# sourceMappingURL=RealTimeMutantsBlobService.js.map

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

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

package/dist/src/services/TableClient.js

@@ -0,0 +1,13 @@
+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

package/dist/src/utils.d.ts

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

package/dist/src/utils.js

@@ -1,3 +1,4 @@
+import { RestError } from '@azure/storage-blob';
 export function encodeKey(inputWithSlashes) {
     return inputWithSlashes.replace(/\//g, ';');
 }
@@ -5,8 +6,16 @@ export function decodeKey(inputWithSemiColons) {
     return inputWithSemiColons.replace(/;/g, '/');
 }
 export function isStorageError(maybeStorageError) {
-    return (maybeStorageError instanceof Error &&
-        maybeStorageError.name === 'StorageError');
+    return maybeStorageError instanceof RestError;
+}
+export function hasErrorCode(err, code) {
+    var _a;
+    if (!isStorageError(err))
+        return false;
+    const details = err.details;
+    return (typeof details === 'object' &&
+        details !== null &&
+        (details.errorCode === code || ((_a = details.odataError) === null || _a === void 0 ? void 0 : _a.code) === code));
 }
 export function toBlobName({ projectName, version, moduleName, realTime }) {
     const slug = [projectName, version, moduleName, realTime ? 'real-time' : realTime]

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@stryker-mutator/dashboard-data-access",
-  "version": "0.14.4-pr-822.16",
+  "version": "0.15.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": {
@@ -21,10 +22,11 @@
   "typings": "src/index.ts",
   "license": "ISC",
   "dependencies": {
-    "@stryker-mutator/dashboard-common": "0.14.4-pr-822.16",
-    "azure-storage": "2.10.7",
+    "@azure/data-tables": "13.2.2",
+    "@azure/storage-blob": "12.24.0",
+    "@stryker-mutator/dashboard-common": "0.15.0",
     "mutation-testing-metrics": "3.2.0",
     "mutation-testing-report-schema": "3.1.1"
   },
-  "gitHead": "5ce06f30a58b922b79f7c5e2450de56ef94d0660"
+  "gitHead": "4fc5cd971e4e86fdb4b4e994651b8d40594c03aa"
 }

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

@@ -1,11 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/TableServiceAsPromised.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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