@spottoai/types-package 1.0.2-beta.43 → 1.0.2-beta.430

package/dist/esm/scheduler/resourceStrategyFinancialValidation.js

@@ -0,0 +1,145 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS, } from './resourceStrategyContracts.js';
+import { isResourceStrategyWeeklyScheduleSuggestion, isResourceStrategyWeeklyScheduleWriteRequest } from './resourceStrategyScheduleValidation.js';
+import { hasOnlyKeys, isBoundedString, isBoundedStringArray, isCapabilityRef, isCurrency, isDate, isIsoTimestamp, isNonNegativeDecimal, isOptionalBoundedString, isPositiveInteger, isRecord, isWithinJsonByteLimit, } from './resourceStrategyValidationShared.js';
+function isMoneyProjection(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'measure',
+            'amount',
+            'basis',
+            'provenance',
+            'period',
+            'currency',
+            'additivity',
+            'evidenceObservedAtUtc',
+            'coverage',
+            'components',
+        ]) ||
+        value.measure !== 'savings' ||
+        !isNonNegativeDecimal(value.amount) ||
+        !Array.isArray(value.components) ||
+        value.components.length === 0 ||
+        value.components.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems) {
+        return false;
+    }
+    const componentIds = new Set();
+    const validComponents = value.components.every(component => {
+        if (!isRecord(component) ||
+            !hasOnlyKeys(component, ['componentId', 'amount', 'unit', 'tier']) ||
+            !isBoundedString(component.componentId, 200) ||
+            !isNonNegativeDecimal(component.amount) ||
+            !isBoundedString(component.unit, 200) ||
+            !isOptionalBoundedString(component.tier, 200) ||
+            componentIds.has(component.componentId)) {
+            return false;
+        }
+        componentIds.add(component.componentId);
+        return true;
+    });
+    if (!validComponents)
+        return false;
+    const decimalScale = 100000000n;
+    const toScaledInteger = (amount) => {
+        const [whole, fraction = ''] = amount.split('.');
+        return BigInt(whole) * decimalScale + BigInt(fraction.padEnd(8, '0'));
+    };
+    const componentTotal = value.components.reduce((total, component) => total + toScaledInteger(component.amount), 0n);
+    if (componentTotal !== toScaledInteger(value.amount))
+        return false;
+    return ((value.basis === 'billed' || value.basis === 'amortized') &&
+        ['billing-backed', 'estimated', 'blended'].includes(String(value.provenance)) &&
+        isRecord(value.period) &&
+        hasOnlyKeys(value.period, ['startDate', 'endDate']) &&
+        isDate(value.period.startDate) &&
+        isDate(value.period.endDate) &&
+        value.period.startDate <= value.period.endDate &&
+        isCurrency(value.currency) &&
+        (value.additivity === 'scenario' || value.additivity === 'portfolio') &&
+        isIsoTimestamp(value.evidenceObservedAtUtc) &&
+        (value.coverage === 'complete' || value.coverage === 'partial'));
+}
+function isScenarioMoneyProjection(value) {
+    return isMoneyProjection(value) && value.additivity === 'scenario';
+}
+export function isResourceSchedulePreviewRequest(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['draft', 'draftHash', 'evidenceReferences', 'concurrency', 'draftPeriodKeys']) &&
+        isResourceStrategyWeeklyScheduleWriteRequest(value.draft) &&
+        isBoundedString(value.draftHash, 200) &&
+        isBoundedStringArray(value.evidenceReferences, RESOURCE_STRATEGY_CONTRACT_LIMITS.evidenceReferences) &&
+        isRecord(value.concurrency) &&
+        hasOnlyKeys(value.concurrency, ['requestVersion', 'evidenceVersion']) &&
+        isPositiveInteger(value.concurrency.requestVersion) &&
+        isOptionalBoundedString(value.concurrency.evidenceVersion, 200) &&
+        (value.draftPeriodKeys === undefined || isBoundedStringArray(value.draftPeriodKeys, RESOURCE_STRATEGY_CONTRACT_LIMITS.draftPeriodKeys)));
+}
+export function isResourceSchedulePreviewResponse(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, ['draftHash', 'requestVersion', 'availability', 'aggregate', 'windows', 'unavailableReason']) ||
+        !isBoundedString(value.draftHash, 200) ||
+        !isPositiveInteger(value.requestVersion) ||
+        !['available', 'unavailable'].includes(String(value.availability)) ||
+        !Array.isArray(value.windows) ||
+        value.windows.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.draftPeriodKeys) {
+        return false;
+    }
+    const validWindows = value.windows.every(window => isRecord(window) &&
+        isBoundedString(window.draftPeriodKey, 200) &&
+        (window.availability === 'available'
+            ? hasOnlyKeys(window, ['draftPeriodKey', 'availability', 'projection']) && isScenarioMoneyProjection(window.projection)
+            : window.availability === 'unavailable' &&
+                hasOnlyKeys(window, ['draftPeriodKey', 'availability', 'unavailableReason']) &&
+                isPreviewUnavailableReason(window.unavailableReason)));
+    if (!validWindows)
+        return false;
+    if (value.availability === 'available') {
+        return hasOnlyKeys(value, ['draftHash', 'requestVersion', 'availability', 'aggregate', 'windows']) && isScenarioMoneyProjection(value.aggregate);
+    }
+    return (hasOnlyKeys(value, ['draftHash', 'requestVersion', 'availability', 'windows', 'unavailableReason']) &&
+        value.aggregate === undefined &&
+        isPreviewUnavailableReason(value.unavailableReason));
+}
+function isPreviewUnavailableReason(value) {
+    return ['missing-evidence', 'stale-evidence', 'mixed-currency', 'unsupported', 'calculation-failed'].includes(String(value));
+}
+export function isResourceSchedulingOpportunity(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) || !isRecord(value))
+        return false;
+    const commonKeys = [
+        'opportunityId',
+        'provider',
+        'providerScopeId',
+        'cloudAccountId',
+        'resourceId',
+        'capability',
+        'suggestedDefinition',
+        'projectionAvailability',
+        'projection',
+        'projectionUnavailableReason',
+        'observedAtUtc',
+    ];
+    if (!hasOnlyKeys(value, commonKeys) ||
+        !isBoundedString(value.opportunityId, 200) ||
+        !isBoundedString(value.provider, 100) ||
+        !isBoundedString(value.providerScopeId, 300) ||
+        !isOptionalBoundedString(value.cloudAccountId, 200) ||
+        !isBoundedString(value.resourceId, 2000) ||
+        !isCapabilityRef(value.capability) ||
+        (value.suggestedDefinition !== undefined && !isResourceStrategyWeeklyScheduleSuggestion(value.suggestedDefinition)) ||
+        !isIsoTimestamp(value.observedAtUtc)) {
+        return false;
+    }
+    if (value.suggestedDefinition !== undefined) {
+        const suggestion = value.suggestedDefinition;
+        if (suggestion.capability.capabilityId !== value.capability.capabilityId ||
+            suggestion.capability.capabilityVersion !== value.capability.capabilityVersion) {
+            return false;
+        }
+    }
+    if (value.projectionAvailability === 'available') {
+        return isScenarioMoneyProjection(value.projection) && value.projectionUnavailableReason === undefined;
+    }
+    return (value.projectionAvailability === 'unavailable' && value.projection === undefined && isPreviewUnavailableReason(value.projectionUnavailableReason));
+}

package/dist/esm/scheduler/resourceStrategyPermissionValidation.js

@@ -0,0 +1,190 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS, } from './resourceStrategyContracts.js';
+import { hasOnlyKeys, isBoundedString, isBoundedStringArray, isCapabilityRef, isIsoTimestamp, isRecord, isWithinJsonByteLimit, } from './resourceStrategyValidationShared.js';
+export function isResourceSchedulePermissionManifestProjection(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'schemaVersion',
+            'provider',
+            'version',
+            'contentHash',
+            'capabilityVersions',
+            'orderedGrantGroupHashes',
+            'grantGroups',
+            'generatedAtUtc',
+            'evidenceObservedAtUtc',
+            'expiresAtUtc',
+            'reviewStatus',
+            'change',
+        ]) ||
+        value.schemaVersion !== 1 ||
+        !isBoundedString(value.provider, 100) ||
+        !isBoundedString(value.version, 200) ||
+        !isBoundedString(value.contentHash, 200) ||
+        !Array.isArray(value.capabilityVersions) ||
+        value.capabilityVersions.length === 0 ||
+        value.capabilityVersions.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems ||
+        !value.capabilityVersions.every(isCapabilityRef) ||
+        !Array.isArray(value.grantGroups) ||
+        value.grantGroups.length === 0 ||
+        value.grantGroups.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.grantGroups ||
+        !Array.isArray(value.orderedGrantGroupHashes) ||
+        value.orderedGrantGroupHashes.length !== value.grantGroups.length ||
+        !isIsoTimestamp(value.generatedAtUtc) ||
+        !isIsoTimestamp(value.evidenceObservedAtUtc) ||
+        !(value.expiresAtUtc === null || isIsoTimestamp(value.expiresAtUtc)) ||
+        !['current', 'review-required', 'expired'].includes(String(value.reviewStatus)) ||
+        !isRecord(value.change) ||
+        !hasOnlyKeys(value.change, ['status', 'addedOperations', 'removedOperations']) ||
+        !['new', 'unchanged', 'expanding', 'narrowing', 'missing'].includes(String(value.change.status)) ||
+        !isPermissionChangeOperations(value.change.addedOperations) ||
+        !isPermissionChangeOperations(value.change.removedOperations) ||
+        Date.parse(value.evidenceObservedAtUtc) > Date.parse(value.generatedAtUtc) ||
+        (typeof value.expiresAtUtc === 'string' && Date.parse(value.expiresAtUtc) < Date.parse(value.generatedAtUtc)) ||
+        new Set(value.capabilityVersions.map(item => `${item.capabilityId}:${item.capabilityVersion}`)).size !== value.capabilityVersions.length) {
+        return false;
+    }
+    const change = value.change;
+    const addedKeys = new Set(change.addedOperations.map(permissionChangeOperationKey));
+    const removedKeys = new Set(change.removedOperations.map(permissionChangeOperationKey));
+    if (addedKeys.size !== change.addedOperations.length ||
+        removedKeys.size !== change.removedOperations.length ||
+        [...addedKeys].some(key => removedKeys.has(key))) {
+        return false;
+    }
+    if ((value.change.status === 'unchanged' && (change.addedOperations.length > 0 || change.removedOperations.length > 0)) ||
+        ((value.change.status === 'new' || value.change.status === 'missing') &&
+            (change.addedOperations.length === 0 || change.removedOperations.length > 0)) ||
+        (value.change.status === 'expanding' && change.addedOperations.length === 0) ||
+        (value.change.status === 'narrowing' && (change.addedOperations.length > 0 || change.removedOperations.length === 0))) {
+        return false;
+    }
+    const grantGroups = value.grantGroups;
+    const seenGroupHashes = new Set();
+    const validGrantGroups = grantGroups.every(group => {
+        if (!isRecord(group) ||
+            !hasOnlyKeys(group, [
+                'groupHash',
+                'provider',
+                'providerScopeId',
+                'exactAssignmentScope',
+                'operationSetHash',
+                'principalRef',
+                'roleDefinitionRef',
+                'roleName',
+                'roleDefinitionScope',
+                'roleAssignmentRef',
+                'actions',
+                'dataActions',
+                'disclosureKeys',
+            ]) ||
+            !isBoundedString(group.groupHash, 200) ||
+            group.provider !== value.provider ||
+            !isBoundedString(group.providerScopeId, 300) ||
+            !isBoundedString(group.exactAssignmentScope, 2000) ||
+            !isBoundedString(group.operationSetHash, 200) ||
+            !isBoundedString(group.principalRef, 200) ||
+            !isBoundedString(group.roleDefinitionRef, 200) ||
+            !isBoundedString(group.roleName, 500) ||
+            !isBoundedString(group.roleDefinitionScope, 2000) ||
+            !isBoundedString(group.roleAssignmentRef, 200) ||
+            !isPermissionOperations(group.actions) ||
+            !isPermissionOperations(group.dataActions) ||
+            group.actions.length + group.dataActions.length === 0 ||
+            (group.disclosureKeys !== undefined && !isBoundedStringArray(group.disclosureKeys)) ||
+            seenGroupHashes.has(group.groupHash)) {
+            return false;
+        }
+        const actions = group.actions;
+        const dataActions = group.dataActions;
+        if (actions.some(action => dataActions.some(dataAction => dataAction.operation.toLowerCase() === action.operation.toLowerCase()))) {
+            return false;
+        }
+        seenGroupHashes.add(group.groupHash);
+        return true;
+    });
+    if (!validGrantGroups ||
+        !value.orderedGrantGroupHashes.every((hash, index) => isBoundedString(hash, 200) && isRecord(grantGroups[index]) && hash === grantGroups[index].groupHash)) {
+        return false;
+    }
+    const currentOperationKeys = new Set();
+    for (const group of grantGroups) {
+        if (!isRecord(group))
+            return false;
+        for (const operation of group.actions) {
+            currentOperationKeys.add(permissionChangeOperationKey({
+                groupHash: String(group.groupHash),
+                providerScopeId: String(group.providerScopeId),
+                exactAssignmentScope: String(group.exactAssignmentScope),
+                operationKind: 'action',
+                operation: operation.operation,
+            }));
+        }
+        for (const operation of group.dataActions) {
+            currentOperationKeys.add(permissionChangeOperationKey({
+                groupHash: String(group.groupHash),
+                providerScopeId: String(group.providerScopeId),
+                exactAssignmentScope: String(group.exactAssignmentScope),
+                operationKind: 'data-action',
+                operation: operation.operation,
+            }));
+        }
+    }
+    if ((value.change.status === 'new' || value.change.status === 'missing') &&
+        (addedKeys.size !== currentOperationKeys.size || [...currentOperationKeys].some(key => !addedKeys.has(key)))) {
+        return false;
+    }
+    return (change.addedOperations.every(operation => currentOperationKeys.has(permissionChangeOperationKey(operation))) &&
+        change.removedOperations.every(operation => !currentOperationKeys.has(permissionChangeOperationKey(operation))));
+}
+function permissionChangeOperationKey(value) {
+    return [value.groupHash, value.providerScopeId, value.exactAssignmentScope, value.operationKind, value.operation]
+        .map(item => item.toLowerCase())
+        .join('\u0000');
+}
+function isPermissionChangeOperations(value) {
+    return (Array.isArray(value) &&
+        value.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.permissionOperations &&
+        value.every(item => isRecord(item) &&
+            hasOnlyKeys(item, ['groupHash', 'providerScopeId', 'exactAssignmentScope', 'operationKind', 'operation']) &&
+            isBoundedString(item.groupHash, 200) &&
+            isBoundedString(item.providerScopeId, 300) &&
+            isBoundedString(item.exactAssignmentScope, 2000) &&
+            ['action', 'data-action'].includes(String(item.operationKind)) &&
+            isBoundedString(item.operation, 500) &&
+            !item.operation.includes('*')));
+}
+function isPermissionOperations(value) {
+    if (!Array.isArray(value) || value.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems)
+        return false;
+    const operations = new Set();
+    return value.every(item => {
+        if (!isRecord(item) ||
+            !hasOnlyKeys(item, ['operation', 'permissionSetRefs', 'reason', 'evidenceUrl']) ||
+            !isBoundedString(item.operation, 500) ||
+            item.operation.includes('*') ||
+            !Array.isArray(item.permissionSetRefs) ||
+            item.permissionSetRefs.length === 0 ||
+            !isBoundedStringArray(item.permissionSetRefs) ||
+            new Set(item.permissionSetRefs).size !== item.permissionSetRefs.length ||
+            !isBoundedString(item.reason, 2000) ||
+            !isBoundedString(item.evidenceUrl, 2000) ||
+            operations.has(item.operation.toLowerCase())) {
+            return false;
+        }
+        operations.add(item.operation.toLowerCase());
+        return true;
+    });
+}
+export function isResourceSchedulePermissionManifestConsent(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['version', 'contentHash', 'orderedGrantGroupHashes']) &&
+        isBoundedString(value.version, 200) &&
+        isBoundedString(value.contentHash, 200) &&
+        Array.isArray(value.orderedGrantGroupHashes) &&
+        value.orderedGrantGroupHashes.length > 0 &&
+        value.orderedGrantGroupHashes.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.grantGroups &&
+        value.orderedGrantGroupHashes.every(item => isBoundedString(item, 200)) &&
+        new Set(value.orderedGrantGroupHashes).size === value.orderedGrantGroupHashes.length);
+}