@stryker-mutator/dashboard-data-access 0.20.2 → 0.20.4

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

@@ -1,8 +1,8 @@
 import type { TableEntityQueryOptions } from '@azure/data-tables';
 import type { ModelClass } from './ModelClass.js';
 export declare class DashboardQuery<TModel, TPartitionKeyFields extends keyof TModel, TRowKeyFields extends keyof TModel> {
+    #private;
     protected ModelClass: ModelClass<TModel, TPartitionKeyFields, TRowKeyFields>;
-    private readonly whereConditions;
     private constructor();
     whereRowKeyNotEquals(rowKey: Pick<TModel, TRowKeyFields>): DashboardQuery<TModel, TPartitionKeyFields, TRowKeyFields>;
     wherePartitionKeyEquals(partitionKey: Pick<TModel, TPartitionKeyFields>): DashboardQuery<TModel, TPartitionKeyFields, TRowKeyFields>;

package/dist/src/mappers/DashboardQuery.js

@@ -2,24 +2,24 @@ import { odata } from '@azure/data-tables';
 import { encodeKey } from '../utils.js';
 export class DashboardQuery {
     ModelClass;
-    whereConditions;
+    #whereConditions;
     constructor(ModelClass, whereConditions) {
         this.ModelClass = ModelClass;
-        this.whereConditions = whereConditions;
+        this.#whereConditions = whereConditions;
     }
     whereRowKeyNotEquals(rowKey) {
         const whereCondition = odata `RowKey ne ${encodeKey(this.ModelClass.createRowKey(rowKey) || '')}`;
-        return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
+        return new DashboardQuery(this.ModelClass, [...this.#whereConditions, whereCondition]);
     }
     wherePartitionKeyEquals(partitionKey) {
         const whereCondition = odata `PartitionKey eq ${encodeKey(this.ModelClass.createPartitionKey(partitionKey))}`;
-        return new DashboardQuery(this.ModelClass, [...this.whereConditions, whereCondition]);
+        return new DashboardQuery(this.ModelClass, [...this.#whereConditions, whereCondition]);
     }
     static create(ModelClass) {
         return new DashboardQuery(ModelClass, []);
     }
     build() {
-        return this.whereConditions.reduce((tableQuery, whereCondition, index) => {
+        return this.#whereConditions.reduce((tableQuery, whereCondition, index) => {
             if (index === 0) {
                 return { filter: whereCondition };
             }

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

@@ -6,7 +6,6 @@ import type * as schema from 'mutation-testing-report-schema';
  */
 export declare class MutationTestingResultMapper {
     #private;
-    private static readonly CONTAINER_NAME;
     constructor(blobService?: BlobServiceClient);
     createStorageIfNotExists(): Promise<ContainerCreateIfNotExistsResponse>;
     insertOrReplace(id: ReportIdentifier, result: schema.MutationTestResult | null): Promise<void>;

package/dist/src/mappers/MutationTestingResultMapper.js

@@ -9,10 +9,10 @@ const errCodes = Object.freeze({
  * The report json part of a mutation testing report is stored in blob storage
  */
 export class MutationTestingResultMapper {
-    static CONTAINER_NAME = 'mutation-testing-report';
+    static #CONTAINER_NAME = 'mutation-testing-report';
     #containerClient;
     constructor(blobService = createBlobServiceClient()) {
-        this.#containerClient = blobService.getContainerClient(MutationTestingResultMapper.CONTAINER_NAME);
+        this.#containerClient = blobService.getContainerClient(MutationTestingResultMapper.#CONTAINER_NAME);
     }
     createStorageIfNotExists() {
         return this.#containerClient.createIfNotExists({});

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

@@ -4,7 +4,6 @@ import type { Mapper, Result } from './Mapper.js';
 import type { ModelClass } from './ModelClass.js';
 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);
     createStorageIfNotExists(): Promise<void>;
     insertOrMerge(model: TModel): Promise<void>;
@@ -19,7 +18,5 @@ export default class TableStorageMapper<TModel extends object, TPartitionKeyFiel
     replace(model: TModel, etag: string): Promise<Result<TModel>>;
     insert(model: TModel): Promise<Result<TModel>>;
     delete(identity: Pick<TModel, TPartitionKeyFields | TRowKeyFields>): Promise<void>;
-    private toModel;
-    private toEntity;
 }
 //# sourceMappingURL=TableStorageMapper.d.ts.map

package/dist/src/mappers/TableStorageMapper.js

@@ -8,23 +8,23 @@ const errCodes = Object.freeze({
     RESOURCE_NOT_FOUND: 'ResourceNotFound',
 });
 export default class TableStorageMapper {
-    ModelClass;
+    #ModelClass;
     #tableClient;
     constructor(ModelClass, tableClient = createTableClient(ModelClass.name)) {
-        this.ModelClass = ModelClass;
+        this.#ModelClass = ModelClass;
         this.#tableClient = tableClient;
     }
     async createStorageIfNotExists() {
         await this.#tableClient.createTable();
     }
     async insertOrMerge(model) {
-        const entity = this.toEntity(model);
+        const entity = this.#toEntity(model);
         await this.#tableClient.upsertEntity(entity, 'Merge');
     }
     async findOne(identity) {
         try {
-            const result = await this.#tableClient.getEntity(encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
-            return this.toModel(result);
+            const result = await this.#tableClient.getEntity(encodeKey(this.#ModelClass.createPartitionKey(identity)), encodeKey(this.#ModelClass.createRowKey(identity) || ''));
+            return this.#toModel(result);
         }
         catch (err) {
             if (hasErrorCode(err, errCodes.RESOURCE_NOT_FOUND)) {
@@ -36,12 +36,12 @@ export default class TableStorageMapper {
             }
         }
     }
-    async findAll(query = DashboardQuery.create(this.ModelClass)) {
+    async findAll(query = DashboardQuery.create(this.#ModelClass)) {
         const tableQuery = query.build();
         const entities = this.#tableClient.listEntities({ queryOptions: tableQuery });
         const results = [];
         for await (const entity of entities) {
-            results.push(this.toModel(entity));
+            results.push(this.#toModel(entity));
         }
         return results;
     }
@@ -52,7 +52,7 @@ export default class TableStorageMapper {
      * @throws {OptimisticConcurrencyError}
      */
     async replace(model, etag) {
-        const entity = this.toEntity(model);
+        const entity = this.#toEntity(model);
         try {
             const result = await this.#tableClient.updateEntity(entity, 'Replace', { etag });
             return { model, etag: result.etag };
@@ -67,7 +67,7 @@ export default class TableStorageMapper {
         }
     }
     async insert(model) {
-        const entity = this.toEntity(model);
+        const entity = this.#toEntity(model);
         try {
             const result = await this.#tableClient.createEntity(entity);
             return { model, etag: result.etag };
@@ -83,7 +83,7 @@ export default class TableStorageMapper {
     }
     async delete(identity) {
         try {
-            await this.#tableClient.deleteEntity(encodeKey(this.ModelClass.createPartitionKey(identity)), encodeKey(this.ModelClass.createRowKey(identity) || ''));
+            await this.#tableClient.deleteEntity(encodeKey(this.#ModelClass.createPartitionKey(identity)), encodeKey(this.#ModelClass.createRowKey(identity) || ''));
         }
         catch (err) {
             if (hasErrorCode(err, errCodes.RESOURCE_NOT_FOUND)) {
@@ -94,23 +94,23 @@ 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]));
+    #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]));
         return {
             etag: entity.etag,
             model: value,
         };
     }
-    toEntity(entity) {
+    #toEntity(entity) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         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) || ''),
         };
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        this.ModelClass.persistedFields.forEach((field) => (data[field] = entity[field]));
+        this.#ModelClass.persistedFields.forEach((field) => (data[field] = entity[field]));
         return data;
     }
 }

package/dist/src/models/MutationTestingReport.js

@@ -27,8 +27,8 @@ export class MutationTestingReport {
     }
     static identify(entity, partitionKeyValue, rowKeyValue) {
         const versionSplit = partitionKeyValue.lastIndexOf('/');
-        entity.projectName = partitionKeyValue.substr(0, versionSplit);
-        entity.version = partitionKeyValue.substr(versionSplit + 1);
+        entity.projectName = partitionKeyValue.substring(0, versionSplit);
+        entity.version = partitionKeyValue.substring(versionSplit + 1);
         entity.moduleName = rowKeyValue;
     }
     static persistedFields = ['mutationScore'];

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

@@ -3,17 +3,11 @@ import type { MutationTestResult } from 'mutation-testing-report-schema';
 import type { MutationTestingReportMapper } from '../mappers/index.js';
 import { MutationTestingResultMapper } from '../mappers/MutationTestingResultMapper.js';
 export declare class MutationTestingReportService {
-    private readonly resultMapper;
-    private readonly mutationScoreMapper;
+    #private;
     constructor(resultMapper?: MutationTestingResultMapper, mutationScoreMapper?: MutationTestingReportMapper);
     createStorageIfNotExists(): Promise<void>;
     saveReport(id: ReportIdentifier, result: MutationScoreOnlyResult | MutationTestResult, logger: Logger): Promise<void>;
-    private aggregateProjectReport;
-    private deleteModules;
-    private tryAggregateProjectReport;
     findOne(id: ReportIdentifier): Promise<Report | null>;
     delete(id: ReportIdentifier, logger: Logger): Promise<void>;
-    private insertOrMergeReport;
-    private calculateMutationScore;
 }
 //# sourceMappingURL=MutationTestingReportService.d.ts.map

package/dist/src/services/MutationTestingReportService.js

@@ -8,45 +8,45 @@ function moduleHasResult(tuple) {
     return !!tuple[1];
 }
 export class MutationTestingReportService {
-    resultMapper;
-    mutationScoreMapper;
-    constructor(resultMapper = new MutationTestingResultMapper(), mutationScoreMapper = createMutationTestingReportMapper()) {
-        this.resultMapper = resultMapper;
-        this.mutationScoreMapper = mutationScoreMapper;
+    #resultMapper;
+    #mutationScoreMapper;
+    constructor(resultMapper, mutationScoreMapper) {
+        this.#resultMapper = resultMapper ?? new MutationTestingResultMapper();
+        this.#mutationScoreMapper = mutationScoreMapper ?? createMutationTestingReportMapper();
     }
     async createStorageIfNotExists() {
-        await this.resultMapper.createStorageIfNotExists();
-        await this.mutationScoreMapper.createStorageIfNotExists();
+        await this.#resultMapper.createStorageIfNotExists();
+        await this.#mutationScoreMapper.createStorageIfNotExists();
     }
     async saveReport(id, result, logger) {
-        const mutationScore = this.calculateMutationScore(result);
-        await this.insertOrMergeReport(id, {
+        const mutationScore = this.#calculateMutationScore(result);
+        await this.#insertOrMergeReport(id, {
             ...id,
             mutationScore,
         }, isMutationTestResult(result) ? result : null);
         if (isMutationTestResult(result) && id.moduleName) {
-            await this.aggregateProjectReport(id.projectName, id.version, logger);
+            await this.#aggregateProjectReport(id.projectName, id.version, logger);
         }
     }
-    async aggregateProjectReport(projectName, version, logger) {
+    async #aggregateProjectReport(projectName, version, logger) {
         const id = {
             projectName,
             version,
             moduleName: undefined,
         };
-        while (!(await this.tryAggregateProjectReport(id))) {
+        while (!(await this.#tryAggregateProjectReport(id))) {
             logger.log({
                 message: `Optimistic concurrency exception occurred while trying to aggregate the report ${JSON.stringify(id)}, retrying...`,
             });
         }
     }
-    async deleteModules(projectName, version) {
+    async #deleteModules(projectName, version) {
         const id = {
             projectName,
             version,
             moduleName: undefined,
         };
-        const modules = await this.mutationScoreMapper.findAll(DashboardQuery.create(MutationTestingReport)
+        const modules = await this.#mutationScoreMapper.findAll(DashboardQuery.create(MutationTestingReport)
             .wherePartitionKeyEquals(id)
             .whereRowKeyNotEquals({ moduleName: undefined }));
         await Promise.all(modules.map(async (module) => {
@@ -55,28 +55,31 @@ export class MutationTestingReportService {
                 version,
                 moduleName: module.model.moduleName,
             };
-            return Promise.all([this.resultMapper.delete(id), this.mutationScoreMapper.delete(id)]);
+            return Promise.all([this.#resultMapper.delete(id), this.#mutationScoreMapper.delete(id)]);
         }));
     }
-    async tryAggregateProjectReport(id) {
-        const projectMutationScoreModel = await this.mutationScoreMapper.findOne(id);
-        const moduleScoreResults = await this.mutationScoreMapper.findAll(DashboardQuery.create(MutationTestingReport)
-            .wherePartitionKeyEquals(id)
-            .whereRowKeyNotEquals({ moduleName: undefined }));
-        const resultsByModule = Object.fromEntries((await Promise.all(moduleScoreResults.map(async (score) => [score.model.moduleName, await this.resultMapper.findOne(score.model)]))).filter(moduleHasResult));
+    async #tryAggregateProjectReport(id) {
+        const [projectMutationScoreModel, resultsByModule] = await Promise.all([
+            this.#mutationScoreMapper.findOne(id),
+            this.#mutationScoreMapper
+                .findAll(DashboardQuery.create(MutationTestingReport)
+                .wherePartitionKeyEquals(id)
+                .whereRowKeyNotEquals({ moduleName: undefined }))
+                .then(async (moduleScoreResults) => Object.fromEntries((await Promise.all(moduleScoreResults.map(async (score) => [score.model.moduleName, await this.#resultMapper.findOne(score.model)]))).filter(moduleHasResult))),
+        ]);
         if (Object.keys(resultsByModule).length) {
             const projectResult = aggregateResultsByModule(resultsByModule);
             const projectReport = {
                 ...id,
-                mutationScore: this.calculateMutationScore(projectResult),
+                mutationScore: this.#calculateMutationScore(projectResult),
             };
             try {
-                await this.resultMapper.insertOrReplace(id, projectResult);
+                await this.#resultMapper.insertOrReplace(id, projectResult);
                 if (projectMutationScoreModel) {
-                    await this.mutationScoreMapper.replace(projectReport, projectMutationScoreModel.etag);
+                    await this.#mutationScoreMapper.replace(projectReport, projectMutationScoreModel.etag);
                 }
                 else {
-                    await this.mutationScoreMapper.insert(projectReport);
+                    await this.#mutationScoreMapper.insert(projectReport);
                 }
             }
             catch (err) {
@@ -92,8 +95,8 @@ export class MutationTestingReportService {
     }
     async findOne(id) {
         const [reportEntity, result] = await Promise.all([
-            this.mutationScoreMapper.findOne(id),
-            this.resultMapper.findOne(id),
+            this.#mutationScoreMapper.findOne(id),
+            this.#resultMapper.findOne(id),
         ]);
         if (reportEntity) {
             if (result) {
@@ -112,18 +115,21 @@ export class MutationTestingReportService {
         }
     }
     async delete(id, logger) {
-        await Promise.all([this.resultMapper.delete(id), this.mutationScoreMapper.delete(id)]);
+        await Promise.all([this.#resultMapper.delete(id), this.#mutationScoreMapper.delete(id)]);
         if (id.moduleName) {
-            await this.aggregateProjectReport(id.projectName, id.version, logger);
+            await this.#aggregateProjectReport(id.projectName, id.version, logger);
         }
         else {
-            await this.deleteModules(id.projectName, id.version);
+            await this.#deleteModules(id.projectName, id.version);
         }
     }
-    async insertOrMergeReport(id, report, result) {
-        await Promise.all([this.resultMapper.insertOrReplace(id, result), this.mutationScoreMapper.insertOrMerge(report)]);
+    async #insertOrMergeReport(id, report, result) {
+        await Promise.all([
+            this.#resultMapper.insertOrReplace(id, result),
+            this.#mutationScoreMapper.insertOrMerge(report),
+        ]);
     }
-    calculateMutationScore(result) {
+    #calculateMutationScore(result) {
         if (isMutationTestResult(result)) {
             return calculateMetrics(result.files).metrics.mutationScore;
         }

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

@@ -3,7 +3,6 @@ import type { ReportIdentifier } from '@stryker-mutator/dashboard-common';
 import type { MutantResult } from 'mutation-testing-report-schema';
 export declare class RealTimeMutantsBlobService {
     #private;
-    private static readonly CONTAINER_NAME;
     constructor(blobService?: BlobServiceClient);
     createStorageIfNotExists(): Promise<void>;
     createReport(id: ReportIdentifier): Promise<void>;

package/dist/src/services/RealTimeMutantsBlobService.js

@@ -3,10 +3,10 @@ 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 {
-    static CONTAINER_NAME = 'real-time-mutant-results';
+    static #CONTAINER_NAME = 'real-time-mutant-results';
     #containerClient;
     constructor(blobService = createBlobServiceClient()) {
-        this.#containerClient = blobService.getContainerClient(RealTimeMutantsBlobService.CONTAINER_NAME);
+        this.#containerClient = blobService.getContainerClient(RealTimeMutantsBlobService.#CONTAINER_NAME);
     }
     async createStorageIfNotExists() {
         await this.#containerClient.createIfNotExists({});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryker-mutator/dashboard-data-access",
-  "version": "0.20.2",
+  "version": "0.20.4",
   "type": "module",
   "description": "This package contains the data access layer of the stryker dashboard application.",
   "scripts": {
@@ -25,12 +25,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@azure/core-rest-pipeline": "1.22.2",
+    "@azure/core-rest-pipeline": "1.23.0",
     "@azure/data-tables": "13.3.2",
-    "@azure/storage-blob": "12.29.1",
-    "@stryker-mutator/dashboard-common": "0.20.2",
-    "mutation-testing-metrics": "3.7.0",
-    "mutation-testing-report-schema": "3.7.0"
+    "@azure/storage-blob": "12.31.0",
+    "@stryker-mutator/dashboard-common": "0.20.4",
+    "mutation-testing-metrics": "3.7.3",
+    "mutation-testing-report-schema": "3.7.3"
   },
-  "gitHead": "76d369d14d473c784634168a2d3547c68b2e571e"
+  "gitHead": "48e1e0ee49fb77ce3130d3a98eb14a9dfd1e75c8"
 }