@spottoai/types-package 1.0.2-dev1138.13 → 1.0.2-dev1138.14

package/dist/esm/azure/recommendationLifecycleOverlayValidation.js

@@ -0,0 +1,75 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { RECOMMENDATION_LIFECYCLE_OVERLAY_CONTRACT_VERSION_V2, RECOMMENDATION_LIFECYCLE_OVERLAY_SCHEMA_VERSION_V2, } from './recommendations.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsRecord, } from './financialSavingsAuthorityValidationPrimitives.js';
+const STATUSES = new Set(['Active', 'Prioritized', 'Dismissed', 'Archived', 'Implementing', 'Implemented', 'Failed']);
+const MAX_STATES = 50000;
+const MAX_REASONS = 64;
+const isReasonCodes = (value) => Array.isArray(value) &&
+    value.length > 0 &&
+    value.length <= MAX_REASONS &&
+    value.every(isFinancialSavingsIdentity) &&
+    new Set(value).size === value.length;
+const isLifecycleState = (value) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, ['recommendationId', 'scope', 'status', 'updatedAt', 'revision'], ['resourceId', 'statusStartAt', 'statusEndAt']) ||
+        !isFinancialSavingsIdentity(value.recommendationId) ||
+        (value.scope !== 'resource' && value.scope !== 'providerScope') ||
+        (value.scope === 'resource') !== (value.resourceId !== undefined) ||
+        (value.resourceId !== undefined && !isFinancialSavingsIdentity(value.resourceId)) ||
+        typeof value.status !== 'string' ||
+        !STATUSES.has(value.status) ||
+        (value.statusStartAt !== undefined && !isFinancialSavingsIsoInstant(value.statusStartAt)) ||
+        (value.statusEndAt !== undefined && !isFinancialSavingsIsoInstant(value.statusEndAt)) ||
+        !isFinancialSavingsIsoInstant(value.updatedAt) ||
+        !isFinancialSavingsIdentity(value.revision))
+        return false;
+    if (value.statusStartAt !== undefined && value.statusEndAt !== undefined && value.statusStartAt >= value.statusEndAt)
+        return false;
+    return value.statusStartAt === undefined || value.updatedAt >= value.statusStartAt;
+};
+const canonicalizeState = (state) => ({ ...state });
+export const canonicalizeRecommendationLifecycleOverlayIdentityV2 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    ...value,
+    ...(value.status === 'complete' ? {} : { reasonCodes: [...value.reasonCodes].sort() }),
+    states: [...value.states]
+        .sort((left, right) => left.recommendationId.localeCompare(right.recommendationId) ||
+        (left.resourceId ?? '').localeCompare(right.resourceId ?? ''))
+        .map(canonicalizeState),
+}));
+export const createRecommendationLifecycleOverlayIdV2 = (value) => `sha256:${sha256Utf8(canonicalizeRecommendationLifecycleOverlayIdentityV2(value))}`;
+export const isRecommendationLifecycleOverlayV2 = (value) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, [
+            'schemaVersion',
+            'contractVersion',
+            'overlayId',
+            'companyId',
+            'provider',
+            'providerScopeId',
+            'revision',
+            'generatedAt',
+            'status',
+            'states',
+        ], value.status === 'complete' ? [] : ['reasonCodes']) ||
+        value.schemaVersion !== RECOMMENDATION_LIFECYCLE_OVERLAY_SCHEMA_VERSION_V2 ||
+        value.contractVersion !== RECOMMENDATION_LIFECYCLE_OVERLAY_CONTRACT_VERSION_V2 ||
+        !isFinancialSavingsHash(value.overlayId) ||
+        !isFinancialSavingsIdentity(value.companyId) ||
+        value.provider !== 'azure' ||
+        !isFinancialSavingsIdentity(value.providerScopeId) ||
+        !isFinancialSavingsIdentity(value.revision) ||
+        !isFinancialSavingsIsoInstant(value.generatedAt) ||
+        (value.status !== 'complete' && value.status !== 'partial' && value.status !== 'unavailable') ||
+        !Array.isArray(value.states) ||
+        value.states.length > MAX_STATES ||
+        !value.states.every(isLifecycleState) ||
+        (value.status === 'unavailable' && value.states.length !== 0) ||
+        (value.status !== 'complete' && !isReasonCodes(value.reasonCodes)))
+        return false;
+    const stateKeys = value.states.map(state => `${state.scope}\u0000${state.resourceId?.toLowerCase() ?? ''}\u0000${state.recommendationId}`);
+    if (new Set(stateKeys).size !== stateKeys.length)
+        return false;
+    const overlay = value;
+    const { overlayId: _overlayId, ...identity } = overlay;
+    return overlay.overlayId === createRecommendationLifecycleOverlayIdV2(identity);
+};

package/dist/esm/azure/recommendations.js

@@ -8,3 +8,5 @@ export var RecommendationCategory;
     RecommendationCategory["OperationalExcellence"] = "OperationalExcellence";
     RecommendationCategory["OperationalExcellenceAlternative"] = "Operational Excellence";
 })(RecommendationCategory || (RecommendationCategory = {}));
+export const RECOMMENDATION_LIFECYCLE_OVERLAY_SCHEMA_VERSION_V2 = 2;
+export const RECOMMENDATION_LIFECYCLE_OVERLAY_CONTRACT_VERSION_V2 = 'recommendation-lifecycle-overlay/v2';

package/dist/esm/azure/reportDailySpend.js

@@ -0,0 +1,2 @@
+/** Maximum span of the current month and two preceding complete calendar months. */
+export const REPORT_DAILY_SPEND_MAX_DAYS = 92;

package/dist/esm/azure/reportDailySpendValidation.js

@@ -0,0 +1,67 @@
+import { REPORT_DAILY_SPEND_MAX_DAYS } from './reportDailySpend.js';
+import { isCount, isFiniteNumber, isRecord } from './reportEvidenceValidationHelpers.js';
+import { hasReportSpendValue, isReportSpendAmounts } from './reportSpendValidation.js';
+import { isReportCalendarDate as isCalendarDate, isReportUtcTimestamp as isUtcTimestamp } from './reportSpendValidationHelpers.js';
+const DAY_MS = 86400000;
+const isCoverage = (value, covered, expected) => {
+    const status = covered === expected ? 'complete' : covered === 0 ? 'unavailable' : 'partial';
+    return isRecord(value) && isCount(value.coveredDayCount) && value.coveredDayCount === covered && value.status === status;
+};
+export const isReportDailySpend = (value) => {
+    if (!isRecord(value) ||
+        !isCalendarDate(value.startDate) ||
+        !isCalendarDate(value.endDate) ||
+        value.dateBasis !== 'billing-calendar' ||
+        typeof value.currency !== 'string' ||
+        !/^[A-Z]{3}$/.test(value.currency) ||
+        !isUtcTimestamp(value.generatedAt) ||
+        !['current', 'stale', 'unavailable'].includes(value.freshness) ||
+        !isRecord(value.coverage) ||
+        !Array.isArray(value.entries) ||
+        value.entries.length > REPORT_DAILY_SPEND_MAX_DAYS)
+        return false;
+    const expected = (Date.parse(value.endDate) - Date.parse(value.startDate)) / DAY_MS + 1;
+    if (expected < 1 || expected > REPORT_DAILY_SPEND_MAX_DAYS)
+        return false;
+    if ((value.sourceObservedAt !== undefined &&
+        (!isUtcTimestamp(value.sourceObservedAt) || Date.parse(value.sourceObservedAt) > Date.parse(value.generatedAt))) ||
+        (value.entries.length > 0 && (value.sourceObservedAt === undefined || value.freshness === 'unavailable')))
+        return false;
+    let previousDate = '';
+    let billedDays = 0;
+    let amortizedDays = 0;
+    for (const entry of value.entries) {
+        if (!isRecord(entry) ||
+            !isCalendarDate(entry.date) ||
+            entry.date <= previousDate ||
+            entry.date < value.startDate ||
+            entry.date > value.endDate ||
+            (entry.cost === undefined && entry.costAmortized === undefined && entry.financials === undefined) ||
+            (entry.cost !== undefined && !isFiniteNumber(entry.cost)) ||
+            (entry.costAmortized !== undefined && !isFiniteNumber(entry.costAmortized)))
+            return false;
+        if (entry.financials !== undefined) {
+            if (!isReportSpendAmounts(entry.financials, value.currency, value.generatedAt) || !hasReportSpendValue(entry.financials))
+                return false;
+            for (const [basis, field] of [
+                ['billed', 'cost'],
+                ['amortized', 'costAmortized'],
+            ]) {
+                const actual = entry.financials.composition[basis].actual.availability;
+                const complete = entry.financials.coverage[basis].actual === 'complete';
+                if (actual.status === 'available' && complete) {
+                    if (entry[field] !== Number(actual.component.amount))
+                        return false;
+                }
+                else if (entry[field] !== undefined)
+                    return false;
+            }
+        }
+        previousDate = entry.date;
+        if (entry.cost !== undefined)
+            billedDays++;
+        if (entry.costAmortized !== undefined)
+            amortizedDays++;
+    }
+    return isCoverage(value.coverage.billed, billedDays, expected) && isCoverage(value.coverage.amortized, amortizedDays, expected);
+};

package/dist/esm/azure/reportEvidence.js

@@ -0,0 +1,29 @@
+export const REPORT_EVIDENCE_LIMITS = {
+    detailRows: 50,
+    currentRecommendations: 90,
+    recommendationCatalogue: 2000,
+    complianceAssessments: 2000,
+    activityDays: 400,
+    activityMonths: 13,
+    commitmentsFreshnessEntries: 50,
+    commitmentsFreshnessWarnings: 10,
+    recommendationResources: 2,
+    resourceCatalogue: 2000,
+    totalRecommendationResourceRows: 10000,
+    inventoryCatalogue: 2000,
+    healthCatalogue: 2000,
+    summaryDimensions: 25,
+    summaryRows: 20,
+    topRecommendationIds: 20,
+    topRecommendationIdsPerPillar: 5,
+    upcomingEvents: 20,
+    historyPeriods: 13,
+    historyRecommendations: 2000,
+    historyComparisonIdentities: 2000,
+    costChangePeriods: 13,
+    costChangeDrivers: 50,
+    costChangeReasons: 10,
+    tenantGlobalAdministrators: 50,
+};
+/** Lowercase Azure RBAC principal types. Producers omit `principalType` when the source type is absent or outside this list. */
+export const REPORT_PRINCIPAL_TYPES = ['user', 'group', 'serviceprincipal', 'foreigngroup', 'device'];

package/dist/esm/azure/reportEvidenceCatalogueValidation.js

@@ -0,0 +1,103 @@
+import { REPORT_EVIDENCE_LIMITS } from './reportEvidence.js';
+import { isReportSavingsBasis } from './reportSpendValidation.js';
+import { hasValidReportSavingsMetadata } from './reportSavingsContributionValidation.js';
+import { isRecord, isString, isOptionalString, isOptionalFiniteNumber, isOptionalBoolean, isFiniteNumber, isCount, isBoundedRows, hasOptionalStrings, hasOptionalNumbers, } from './reportEvidenceValidationHelpers.js';
+const isCompactRecommendationResource = (value) => isRecord(value) &&
+    hasValidReportSavingsMetadata(value) &&
+    isString(value.id) &&
+    ['name', 'type', 'resourceGroup', 'location', 'currency', 'currencySymbol'].every(key => isOptionalString(value[key])) &&
+    ['spend', 'spendAmortized'].every(key => isOptionalFiniteNumber(value[key])) &&
+    (value.savingsBasis === undefined || isReportSavingsBasis(value.savingsBasis)) &&
+    (value.savings === undefined ||
+        (isRecord(value.savings) && isOptionalFiniteNumber(value.savings.minAmount) && isOptionalFiniteNumber(value.savings.maxAmount)));
+export const isCompactRecommendation = (value) => {
+    if (!isRecord(value) || !isRecord(value.recommendation) || !Array.isArray(value.resources))
+        return false;
+    if (!hasValidReportSavingsMetadata(value))
+        return false;
+    if (value.savingsBasis !== undefined && !isReportSavingsBasis(value.savingsBasis))
+        return false;
+    const recommendation = value.recommendation;
+    const assessment = recommendation.securityAssessmentSummary;
+    if (assessment !== undefined &&
+        (!isRecord(assessment) ||
+            !isCount(assessment.unhealthyCount) ||
+            !isCount(assessment.totalCount) ||
+            assessment.unhealthyCount > assessment.totalCount))
+        return false;
+    if (recommendation.securityImpactDetails !== undefined &&
+        (!isRecord(recommendation.securityImpactDetails) ||
+            !hasOptionalStrings(recommendation.securityImpactDetails, ['controlName', 'controlDisplayName'])))
+        return false;
+    if (!isString(recommendation.id) ||
+        !isString(recommendation.title) ||
+        recommendation.resolved === true ||
+        !isCount(value.resourcesCount) ||
+        !isCount(value.omittedResourceCount) ||
+        value.resources.length > REPORT_EVIDENCE_LIMITS.recommendationResources ||
+        !value.resources.every(isCompactRecommendationResource) ||
+        value.resourcesCount !== value.resources.length + value.omittedResourceCount) {
+        return false;
+    }
+    if (value.resourceCatalogue !== undefined &&
+        (!isBoundedRows(value.resourceCatalogue, REPORT_EVIDENCE_LIMITS.resourceCatalogue, isCompactRecommendationResource) ||
+            value.resourceCatalogue.totalCount !== value.resourcesCount))
+        return false;
+    if (!hasOptionalStrings(recommendation, [
+        'name',
+        'headline',
+        'plainSummary',
+        'bottomLine',
+        'description',
+        'remediation',
+        'impactReason',
+        'effortReason',
+        'potentialBenefits',
+        'considerations',
+        'technicalPlaybook',
+        'category',
+        'subCategory',
+        'impact',
+        'effort',
+        'severity',
+        'risk',
+        'priority',
+        'priorityLabel',
+        'priorityTier',
+        'manualPriority',
+        'costImpactUnit',
+    ]) ||
+        !hasOptionalNumbers(recommendation, [
+            'effortHours',
+            'costImpact',
+            'potentialMonthlySavings',
+            'confidencePercentage',
+            'adjustedScore',
+            'finalScore',
+            'normalizedScore',
+        ]) ||
+        !isOptionalBoolean(recommendation.resolved) ||
+        !isOptionalBoolean(recommendation.reportingTextTruncated) ||
+        !hasOptionalStrings(value, ['currency', 'currencySymbol'])) {
+        return false;
+    }
+    return (value.savings === undefined ||
+        (isRecord(value.savings) && isOptionalFiniteNumber(value.savings.minAmount) && isOptionalFiniteNumber(value.savings.maxAmount)));
+};
+export const isInventoryCatalogueResource = (value) => isRecord(value) &&
+    isCompactRecommendationResource(value) &&
+    isOptionalFiniteNumber(value.createdTime) &&
+    (value.tags === undefined ||
+        (isRecord(value.tags) &&
+            Object.keys(value.tags).length <= 100 &&
+            Object.entries(value.tags).every(([key, entry]) => key.length <= 512 && typeof entry === 'string' && entry.length <= 2048))) &&
+    (value.spottoTags === undefined ||
+        (isRecord(value.spottoTags) &&
+            Object.keys(value.spottoTags).length <= 100 &&
+            Object.entries(value.spottoTags).every(([key, entry]) => key.length <= 512 && isRecord(entry) && typeof entry.v === 'string' && entry.v.length <= 2048 && isFiniteNumber(entry.a)))) &&
+    (value.vmPricePerformance === undefined ||
+        (isRecord(value.vmPricePerformance) &&
+            isRecord(value.vmPricePerformance.current) &&
+            Array.isArray(value.vmPricePerformance.alternatives) &&
+            value.vmPricePerformance.alternatives.length <= 1 &&
+            value.vmPricePerformance.alternatives.every(isRecord)));