@adaptabletools/adaptable 23.1.0-canary.2 → 24.0.0-canary.0

package/src/migration/VersionUpgrade24.js

@@ -0,0 +1,679 @@
+import { isAST_Function, migrateExpression, parse, printExpression, LEGACY_OBSERVABLE_SOURCE_NAMES, } from "../../vendor/aql/index.js";
+import { VersionUpgrade } from './VersionUpgrade';
+import { expressionContainsObservableCall, inferCalculatedColumnTypeFromExpression, refineAggregatedCalculatedColumnType, } from '../AdaptableState/CalculatedColumnState';
+import { AlertType } from '../AdaptableState/AlertState';
+import { inferExpressionKindFromText } from '../AdaptableState/Common/AdaptableQuery';
+import { getLegacyObservableRuleSource, inferAlertTypeFromRule, } from '../Utilities/Helpers/AlertTypeHelper';
+import { getLegacyQueryKind, getLegacyQueryText, isLegacyAdaptableQuery, } from './legacyAdaptableQuery';
+import { badgePredicateToBooleanExpression, columnFilterPredicatesToExpression, columnFilterPredicatesToPreferredFilter, rulePredicatesToBooleanExpression, } from './predicateExpressionMigration';
+import { migrateGreenfieldExpressionTexts } from './migrateGreenfieldExpressionTexts';
+import { isAdaptableSharedEntity } from '../AdaptableState/TeamSharingState';
+import { migrateLayoutTagsToRegistry } from './migrateLayoutTagsToRegistry';
+const NEEDS_MIGRATION_SUFFIX = ' (needs migration)';
+const LEGACY_SOURCE_PATTERN = new RegExp(`\\b(${[...LEGACY_OBSERVABLE_SOURCE_NAMES].join('|')})\\s*[({]`);
+export class VersionUpgrade24 extends VersionUpgrade {
+    options;
+    constructor(logger, options = {}) {
+        super(logger);
+        this.options = options;
+    }
+    migrateState(state) {
+        this.migrateNoteTimestamps(state);
+        this.migrateColumnFilters(state);
+        this.migrateAlertRules(state);
+        this.migrateFlashingCellRules(state);
+        this.migrateFormatColumnRules(state);
+        this.migrateBadgeStyleRules(state);
+        this.migrateExpressionQueryKeys(state);
+        this.migrateNamedQueries(state);
+        this.migrateCalculatedColumnTypes(state);
+        this.migrateAlertTypes(state);
+        this.migrateGreenfieldExpressionTexts(state);
+        this.migrateQueryWrappersToStrings(state);
+        this.migrateAlertDefinitions(state);
+        this.retypeObservableCalculatedColumns(state);
+        this.stampFlashingCellTypes(state);
+        migrateLayoutTagsToRegistry(state, this.logger, this.options.layoutTagOptions);
+        return state;
+    }
+    migrateNoteTimestamps(state) {
+        const notes = state.Note?.Notes;
+        if (!notes?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        for (const note of notes) {
+            if (note.Timestamp == null) {
+                continue;
+            }
+            if (note.CreatedAt == null) {
+                note.CreatedAt = note.Timestamp;
+            }
+            if (note.UpdatedAt == null) {
+                note.UpdatedAt = note.Timestamp;
+            }
+            delete note.Timestamp;
+            migratedCount++;
+        }
+        if (migratedCount > 0) {
+            this.logger.info(`Migrated ${migratedCount} Note(s): legacy "Timestamp" seeded into "CreatedAt" / "UpdatedAt" and removed (v24).`);
+        }
+    }
+    migrateColumnFilters(state) {
+        const layouts = state.Layout?.Layouts;
+        if (!layouts?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        let preservedCount = 0;
+        for (const layout of layouts) {
+            const filters = layout.ColumnFilters;
+            if (!filters?.length) {
+                continue;
+            }
+            for (const filter of filters) {
+                if (filter.Expression) {
+                    delete filter.Predicates;
+                    delete filter.PredicatesOperator;
+                    delete filter.PreferredFilter;
+                    continue;
+                }
+                if (!filter.Predicates?.length) {
+                    continue;
+                }
+                const expression = columnFilterPredicatesToExpression(filter);
+                if (expression != null) {
+                    filter.Expression = expression;
+                    delete filter.PreferredFilter;
+                    delete filter.Predicates;
+                    delete filter.PredicatesOperator;
+                    migratedCount++;
+                    continue;
+                }
+                const preferredFilter = columnFilterPredicatesToPreferredFilter(filter);
+                if (preferredFilter != null) {
+                    filter.PreferredFilter = preferredFilter;
+                    delete filter.Expression;
+                    delete filter.Predicates;
+                    delete filter.PredicatesOperator;
+                    migratedCount++;
+                    continue;
+                }
+                preservedCount++;
+            }
+        }
+        this.logPredicateMigrationSummary('Column Filter', migratedCount, preservedCount);
+    }
+    migrateAlertRules(state) {
+        this.migratePredicateRulesInDefinitions(state.Alert?.AlertDefinitions, 'Alert', (definition) => definition.Rule);
+    }
+    migrateFlashingCellRules(state) {
+        this.migratePredicateRulesInDefinitions(state.FlashingCell?.FlashingCellDefinitions, 'Flashing Cell', (definition) => definition.Rule);
+    }
+    migrateFormatColumnRules(state) {
+        this.migratePredicateRulesInDefinitions(state.FormatColumn?.FormatColumns, 'Format Column', (definition) => definition.Rule);
+    }
+    migrateBadgeStyleRules(state) {
+        const columns = state.StyledColumn?.StyledColumns;
+        if (!columns?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        let preservedCount = 0;
+        for (const styledColumn of columns) {
+            const badges = styledColumn.BadgeStyle?.Badges;
+            if (!badges?.length) {
+                continue;
+            }
+            for (const badge of badges) {
+                const legacyExpression = badge.Expression;
+                if (badge.Rule?.Expression || legacyExpression?.Expression || legacyExpression?.BooleanExpression) {
+                    delete badge.Predicate;
+                    continue;
+                }
+                if (!badge.Predicate?.PredicateId) {
+                    continue;
+                }
+                const expression = badgePredicateToBooleanExpression(badge.Predicate, styledColumn.ColumnId);
+                if (expression == null) {
+                    preservedCount++;
+                    continue;
+                }
+                badge.Rule = { Expression: expression };
+                delete badge.Predicate;
+                migratedCount++;
+            }
+        }
+        this.logPredicateMigrationSummary('Badge Style', migratedCount, preservedCount);
+    }
+    migratePredicateRulesInDefinitions(definitions, moduleLabel, getRule) {
+        if (!definitions?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        let preservedCount = 0;
+        for (const definition of definitions) {
+            const result = this.migratePredicateRule(getRule(definition));
+            if (result === 'migrated') {
+                migratedCount++;
+            }
+            if (result === 'preserved') {
+                preservedCount++;
+            }
+        }
+        this.logPredicateMigrationSummary(moduleLabel, migratedCount, preservedCount);
+    }
+    migratePredicateRule(rule) {
+        if (!isLegacyAdaptableQuery(rule)) {
+            return 'skip';
+        }
+        if (rule.Expression ||
+            rule.BooleanExpression ||
+            rule.ScalarExpression ||
+            rule.AggregatedExpression ||
+            rule.AggregatedBooleanExpression ||
+            rule.AggregatedScalarExpression ||
+            rule.ObservableExpression) {
+            if (rule.Predicates) {
+                delete rule.Predicates;
+            }
+            return 'skip';
+        }
+        if (!rule.Predicates?.length) {
+            return 'skip';
+        }
+        const expression = rulePredicatesToBooleanExpression(rule.Predicates);
+        if (expression == null) {
+            return 'preserved';
+        }
+        delete rule.Predicates;
+        rule.Expression = expression;
+        return 'migrated';
+    }
+    migrateExpressionQueryKeys(state) {
+        let migratedCount = 0;
+        const migrateQuery = (query) => {
+            if (!isLegacyAdaptableQuery(query)) {
+                return false;
+            }
+            let changed = false;
+            if (query.BooleanExpression != null && query.Expression == null) {
+                query.Expression = query.BooleanExpression;
+                changed = true;
+            }
+            if (query.ScalarExpression != null && query.Expression == null) {
+                query.Expression = query.ScalarExpression;
+                changed = true;
+            }
+            if (query.AggregatedBooleanExpression != null && query.AggregatedExpression == null) {
+                query.AggregatedExpression = query.AggregatedBooleanExpression;
+                changed = true;
+            }
+            if (query.AggregatedScalarExpression != null && query.AggregatedExpression == null) {
+                query.AggregatedExpression = query.AggregatedScalarExpression;
+                changed = true;
+            }
+            delete query.BooleanExpression;
+            delete query.ScalarExpression;
+            delete query.AggregatedBooleanExpression;
+            delete query.AggregatedScalarExpression;
+            return changed;
+        };
+        state.NamedQuery?.NamedQueries?.forEach((namedQuery) => {
+            if (migrateQuery(namedQuery)) {
+                migratedCount++;
+            }
+        });
+        state.CalculatedColumn?.CalculatedColumns?.forEach((column) => {
+            if (migrateQuery(column.Query)) {
+                migratedCount++;
+            }
+        });
+        const migrateDefinitionRule = (rule) => {
+            if (migrateQuery(rule)) {
+                migratedCount++;
+            }
+        };
+        state.Alert?.AlertDefinitions?.forEach((definition) => migrateDefinitionRule(definition.Rule));
+        state.FlashingCell?.FlashingCellDefinitions?.forEach((definition) => migrateDefinitionRule(definition.Rule));
+        state.FormatColumn?.FormatColumns?.forEach((column) => migrateDefinitionRule(column.Rule));
+        state.PlusMinus?.PlusMinusNudges?.forEach((definition) => migrateDefinitionRule(definition.Rule));
+        state.Export?.Reports?.forEach((report) => migrateDefinitionRule(report.Query));
+        state.StyledColumn?.StyledColumns?.forEach((styledColumn) => {
+            styledColumn.BadgeStyle?.Badges?.forEach((badge) => {
+                const legacyBadge = badge;
+                if (legacyBadge.Expression && !legacyBadge.Rule) {
+                    const legacyQuery = legacyBadge.Expression;
+                    const expression = legacyQuery.Expression ??
+                        legacyQuery.BooleanExpression ??
+                        undefined;
+                    if (expression != null) {
+                        legacyBadge.Rule = { Expression: expression };
+                    }
+                    delete legacyBadge.Expression;
+                    migratedCount++;
+                }
+                else if (legacyBadge.Rule) {
+                    if (migrateQuery(legacyBadge.Rule)) {
+                        migratedCount++;
+                    }
+                }
+            });
+        });
+        for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+            if (!isAdaptableSharedEntity(shared)) {
+                continue;
+            }
+            const entity = shared.Entity;
+            if (!entity || typeof entity !== 'object') {
+                continue;
+            }
+            if (migrateQuery(entity.Query)) {
+                migratedCount++;
+            }
+            if (migrateQuery(entity.Rule)) {
+                migratedCount++;
+            }
+            if (migrateQuery(entity)) {
+                migratedCount++;
+            }
+            const badgeStyle = entity.BadgeStyle;
+            for (const badge of badgeStyle?.Badges ?? []) {
+                if (badge.Expression && !badge.Rule) {
+                    const legacyQuery = badge.Expression;
+                    const expression = legacyQuery.Expression ?? legacyQuery.BooleanExpression ?? undefined;
+                    if (expression != null) {
+                        badge.Rule = { Expression: expression };
+                    }
+                    delete badge.Expression;
+                    migratedCount++;
+                }
+                else if (badge.Rule && migrateQuery(badge.Rule)) {
+                    migratedCount++;
+                }
+            }
+        }
+        if (migratedCount > 0) {
+            this.logger.info(`Migrated ${migratedCount} expression query wrapper(s) to unified Expression / AggregatedExpression keys (v24).`);
+        }
+    }
+    migrateNamedQueries(state) {
+        const namedQueries = state.NamedQuery?.NamedQueries;
+        if (!namedQueries?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        namedQueries.forEach((namedQuery) => {
+            if (namedQuery.ReturnType == null) {
+                namedQuery.ReturnType = 'boolean';
+                migratedCount++;
+            }
+        });
+        if (migratedCount > 0) {
+            this.logger.info(`Stamped ReturnType: 'boolean' on ${migratedCount} Named Query(ies) (v24).`);
+        }
+    }
+    migrateCalculatedColumnTypes(state) {
+        const calculatedColumns = state.CalculatedColumn?.CalculatedColumns;
+        if (!calculatedColumns?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        calculatedColumns.forEach((calculatedColumn) => {
+            if (calculatedColumn.Type != null) {
+                return;
+            }
+            const query = calculatedColumn.Query ?? calculatedColumn.Expression;
+            const text = getLegacyQueryText(query);
+            const kind = getLegacyQueryKind(query) ?? inferExpressionKindFromText(text);
+            calculatedColumn.Type =
+                kind === 'aggregated' ? refineAggregatedCalculatedColumnType(text) : 'Standard';
+            migratedCount++;
+        });
+        if (migratedCount > 0) {
+            this.logger.info(`Stamped Type on ${migratedCount} Calculated Column(s) (v24).`);
+        }
+    }
+    migrateAlertTypes(state) {
+        const alertDefinitions = state.Alert?.AlertDefinitions;
+        if (!alertDefinitions?.length) {
+            return;
+        }
+        let migratedCount = 0;
+        alertDefinitions.forEach((alertDefinition) => {
+            if (alertDefinition.Type != null) {
+                return;
+            }
+            let inferred;
+            if ('Schedule' in alertDefinition) {
+                inferred = AlertType.Scheduled;
+            }
+            else {
+                const rule = alertDefinition.Rule;
+                inferred = inferAlertTypeFromRule(getLegacyQueryText(rule), getLegacyQueryKind(rule), {
+                    preventEdit: alertDefinition.AlertProperties?.PreventEdit,
+                });
+            }
+            if (inferred) {
+                alertDefinition.Type = inferred;
+                migratedCount++;
+            }
+        });
+        if (migratedCount > 0) {
+            this.logger.info(`Stamped Type on ${migratedCount} Alert Definition(s) (v24).`);
+        }
+    }
+    migrateGreenfieldExpressionTexts(state) {
+        migrateGreenfieldExpressionTexts(state, this.logger);
+    }
+    logPredicateMigrationSummary(module, migrated, preserved) {
+        if (migrated > 0) {
+            this.logger.info(`Migrated ${migrated} ${module} predicate rule(s) to AdaptableQL Expression (v24).`);
+        }
+        if (preserved > 0) {
+            this.logger.warn(`Left ${preserved} ${module} predicate rule(s) unchanged (no lossless AdaptableQL ` +
+                `equivalent — e.g. a custom predicate or PercentChange); they continue to ` +
+                `evaluate via the legacy predicate path.`);
+        }
+    }
+    migrateQueryWrappersToStrings(state) {
+        let migratedCount = 0;
+        const textOf = (value) => {
+            if (typeof value === 'string') {
+                return value;
+            }
+            return isLegacyAdaptableQuery(value) ? (getLegacyQueryText(value) ?? undefined) : undefined;
+        };
+        const unwrap = (holder, key, options) => {
+            if (!holder) {
+                return;
+            }
+            const value = holder[key];
+            if (!isLegacyAdaptableQuery(value)) {
+                return;
+            }
+            const text = getLegacyQueryText(value);
+            if (text != null) {
+                holder[key] = text;
+            }
+            else if (options.required) {
+                holder[key] = '';
+            }
+            else {
+                delete holder[key];
+            }
+            migratedCount++;
+        };
+        const renameQueryToExpression = (holder, options) => {
+            if (!holder || !('Query' in holder)) {
+                return;
+            }
+            const legacyValue = holder.Query;
+            delete holder.Query;
+            migratedCount++;
+            if (typeof holder.Expression === 'string') {
+                return;
+            }
+            const text = textOf(legacyValue);
+            if (text != null) {
+                holder.Expression = text;
+            }
+            else if (options.required) {
+                holder.Expression = '';
+            }
+            else {
+                delete holder.Expression;
+            }
+        };
+        const unwrapBadges = (badgeStyle) => {
+            const badges = asRecord(badgeStyle)?.Badges;
+            if (!Array.isArray(badges)) {
+                return;
+            }
+            for (const badge of badges) {
+                unwrap(asRecord(badge), 'Rule', { required: false });
+            }
+        };
+        state.CalculatedColumn?.CalculatedColumns?.forEach((column) => renameQueryToExpression(asRecord(column), { required: true }));
+        state.Alert?.AlertDefinitions?.forEach((definition) => {
+            if ('Rule' in definition) {
+                unwrap(asRecord(definition), 'Rule', { required: true });
+            }
+        });
+        state.FlashingCell?.FlashingCellDefinitions?.forEach((definition) => unwrap(asRecord(definition), 'Rule', { required: true }));
+        state.FormatColumn?.FormatColumns?.forEach((column) => unwrap(asRecord(column), 'Rule', { required: false }));
+        state.PlusMinus?.PlusMinusNudges?.forEach((nudge) => unwrap(asRecord(nudge), 'Rule', { required: false }));
+        state.Export?.Reports?.forEach((report) => renameQueryToExpression(asRecord(report), { required: false }));
+        state.StyledColumn?.StyledColumns?.forEach((styledColumn) => unwrapBadges(styledColumn.BadgeStyle));
+        for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+            if (!isAdaptableSharedEntity(shared)) {
+                continue;
+            }
+            const entity = asRecord(shared.Entity);
+            if (!entity) {
+                continue;
+            }
+            if (shared.Module === 'CalculatedColumn' || shared.Module === 'Export') {
+                renameQueryToExpression(entity, { required: shared.Module === 'CalculatedColumn' });
+            }
+            unwrap(entity, 'Rule', {
+                required: shared.Module === 'Alert' || shared.Module === 'FlashingCell',
+            });
+            unwrapBadges(entity.BadgeStyle);
+        }
+        if (migratedCount > 0) {
+            this.logger.info(`Migrated ${migratedCount} expression property(ies) to plain strings (v24).`);
+        }
+    }
+    stampFlashingCellTypes(state) {
+        let stamped = 0;
+        for (const definition of state.FlashingCell?.FlashingCellDefinitions ?? []) {
+            if (this.stampFlashingCellType(asRecord(definition))) {
+                stamped++;
+            }
+        }
+        for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+            if (!isAdaptableSharedEntity(shared) || shared.Module !== 'FlashingCell') {
+                continue;
+            }
+            if (this.stampFlashingCellType(asRecord(shared.Entity))) {
+                stamped++;
+            }
+        }
+        if (stamped > 0) {
+            this.logger.info(`Stamped Type 'Change' on ${stamped} Flashing Cell Definition(s) missing a Type (v24).`);
+        }
+    }
+    stampFlashingCellType(definition) {
+        if (!definition || definition.Type != null) {
+            return false;
+        }
+        definition.Type = 'Change';
+        return true;
+    }
+    retypeObservableCalculatedColumns(state) {
+        let retyped = 0;
+        for (const calculatedColumn of state.CalculatedColumn?.CalculatedColumns ?? []) {
+            if (this.retypeObservableCalculatedColumn(asRecord(calculatedColumn))) {
+                retyped++;
+            }
+        }
+        for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+            if (!isAdaptableSharedEntity(shared) || shared.Module !== 'CalculatedColumn') {
+                continue;
+            }
+            if (this.retypeObservableCalculatedColumn(asRecord(shared.Entity))) {
+                retyped++;
+            }
+        }
+        if (retyped > 0) {
+            this.logger.info(`Re-typed ${retyped} Calculated Column(s) with observable expressions to Type 'Observable' (v24).`);
+        }
+    }
+    retypeObservableCalculatedColumn(calculatedColumn) {
+        if (!calculatedColumn || typeof calculatedColumn.Expression !== 'string') {
+            return false;
+        }
+        const expression = calculatedColumn.Expression;
+        if (calculatedColumn.Type == null) {
+            const inferred = inferCalculatedColumnTypeFromExpression(expression);
+            calculatedColumn.Type = inferred;
+            return inferred === 'Observable';
+        }
+        if (calculatedColumn.Type === 'Standard' && expressionContainsObservableCall(expression)) {
+            calculatedColumn.Type = 'Observable';
+            return true;
+        }
+        return false;
+    }
+    migrateAlertDefinitions(state) {
+        const counters = { rowChange: 0, observable: 0, inferred: 0, suspended: 0 };
+        for (const definition of state.Alert?.AlertDefinitions ?? []) {
+            this.migrateAlertDefinition(asRecord(definition), counters);
+        }
+        for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+            if (!isAdaptableSharedEntity(shared) || shared.Module !== 'Alert') {
+                continue;
+            }
+            this.migrateAlertDefinition(asRecord(shared.Entity), counters);
+        }
+        const total = counters.rowChange + counters.observable + counters.inferred + counters.suspended;
+        if (total > 0) {
+            this.logger.info(`Migrated ${total} Alert Definition(s) off legacy observable rules (v24): ` +
+                `${counters.rowChange} to Row Change Alerts, ${counters.observable} to observable rules, ` +
+                `${counters.inferred} typed from their rule, ${counters.suspended} suspended (need manual migration).`);
+        }
+    }
+    migrateAlertDefinition(definition, counters) {
+        if (!definition) {
+            return;
+        }
+        if (this.migrateRowChangeAlert(definition)) {
+            counters.rowChange++;
+            return;
+        }
+        const outcome = this.migrateLegacyObservableAlertRule(definition);
+        if (outcome === 'migrated') {
+            counters.observable++;
+        }
+        else if (outcome === 'suspended') {
+            counters.suspended++;
+            return;
+        }
+        if (this.inferMissingAlertType(definition)) {
+            counters.inferred++;
+        }
+    }
+    migrateRowChangeAlert(definition) {
+        if (definition.Type === 'RowChange' && 'RowChangeTrigger' in definition) {
+            return false;
+        }
+        const rule = typeof definition.Rule === 'string' ? definition.Rule : undefined;
+        const legacySource = getLegacyObservableRuleSource(rule);
+        if (legacySource !== 'ROW_ADDED' && legacySource !== 'ROW_REMOVED') {
+            return false;
+        }
+        const rowEvent = parseLegacyRowEventRule(rule);
+        if (!rowEvent) {
+            return false;
+        }
+        if (rowEvent.where !== undefined) {
+            const migratedWhere = migrateExpression(rowEvent.where);
+            if (migratedWhere.error) {
+                return false;
+            }
+            definition.Rule = migratedWhere.expression;
+        }
+        else {
+            delete definition.Rule;
+        }
+        definition.Type = 'RowChange';
+        definition.RowChangeTrigger = rowEvent.trigger;
+        if (definition.Scope == null) {
+            definition.Scope = { All: true };
+        }
+        return true;
+    }
+    migrateLegacyObservableAlertRule(definition) {
+        const rule = typeof definition.Rule === 'string' ? definition.Rule : undefined;
+        if (!getLegacyObservableRuleSource(rule)) {
+            return 'untouched';
+        }
+        const name = typeof definition.Name === 'string' ? definition.Name : '<unnamed>';
+        const result = migrateExpression(rule, { rewriteLegacyObservables: true });
+        if (result.error || LEGACY_SOURCE_PATTERN.test(result.expression)) {
+            this.suspendDefinition(definition);
+            this.logger.warn(`Alert '${name}': the legacy observable rule "${rule}" could not be migrated automatically` +
+                (result.error ? ` (${result.error})` : '') +
+                `; the Alert has been suspended — rewrite it with an observable expression (v24).`);
+            return 'suspended';
+        }
+        definition.Rule = result.expression;
+        definition.Type = 'Observable';
+        this.logger.info(`Alert '${name}': rule "${rule}" migrated to "${result.expression}" (v24).`);
+        for (const note of result.notes ?? []) {
+            this.logNote(name, note);
+        }
+        return 'migrated';
+    }
+    inferMissingAlertType(definition) {
+        if (definition.Type == null && typeof definition.Rule === 'string' && !('Schedule' in definition)) {
+            const inferred = inferAlertTypeFromRule(definition.Rule, undefined);
+            if (inferred) {
+                definition.Type = inferred;
+                return true;
+            }
+        }
+        return false;
+    }
+    suspendDefinition(definition) {
+        definition.IsSuspended = true;
+        const name = typeof definition.Name === 'string' ? definition.Name : '';
+        if (!name.endsWith(NEEDS_MIGRATION_SUFFIX)) {
+            definition.Name = `${name}${NEEDS_MIGRATION_SUFFIX}`;
+        }
+    }
+    logNote(alertName, note) {
+        this.logger.warn(`Alert '${alertName}' (${note.code}): ${note.message}`);
+    }
+}
+const asRecord = (value) => (value != null && typeof value === 'object' ? value : undefined);
+const isNamedCall = (node, type) => isAST_Function(node) && node.type === type;
+const parseLegacyRowEventRule = (rule) => {
+    let ast;
+    try {
+        ast = parse(rule).ast;
+    }
+    catch {
+        return undefined;
+    }
+    if (ast.length !== 1) {
+        return undefined;
+    }
+    let root = ast[0];
+    let where;
+    if (isNamedCall(root, 'WHERE') && root.args.length === 2) {
+        where = root.args[1];
+        root = root.args[0];
+    }
+    if (!isAST_Function(root) || (root.type !== 'ROW_ADDED' && root.type !== 'ROW_REMOVED')) {
+        return undefined;
+    }
+    for (const arg of root.args) {
+        if (!isAST_Function(arg)) {
+            return undefined;
+        }
+        if (arg.type === 'WHERE' && arg.args.length === 1) {
+            if (where !== undefined) {
+                return undefined;
+            }
+            where = arg.args[0];
+            continue;
+        }
+        return undefined;
+    }
+    return {
+        trigger: root.type === 'ROW_ADDED' ? 'Added' : 'Removed',
+        where: where === undefined ? undefined : printExpression(where),
+    };
+};