@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/sla/sla-validators.ts

@@ -0,0 +1,331 @@
+/**
+ * SLA Plugin Validation Functions
+ *
+ * This module contains validation functions that enforce conditional field requirements
+ * for SLA definitions. Fields may be mandatory, optional, or restricted depending on
+ * the values of control fields.
+ *
+ * @see ./SLA-VALIDATION-BEHAVIORS.md for detailed documentation of all 11 validation behaviors
+ */
+
+import type { Diagnostics, ObjectShape } from '@servicenow/sdk-build-core'
+
+export const DEFAULT_WHEN_TO_RESUME = 'on_condition'
+export const DEFAULT_WHEN_TO_CANCEL = 'on_condition'
+export const DEFAULT_TIMEZONE_SOURCE = 'task.caller_id.time_zone'
+export const DEFAULT_RETROACTIVE_PAUSE = true
+export const DEFAULT_NO_SCHEDULE_ID = '38fa64edc0a8016400f4a5724b0434b8'
+
+export const ERROR_MESSAGES = {
+    MANDATORY_FIELD: (field: string, reason: string) => `Field '${field}' is required ${reason}`,
+
+    RESTRICTED_FIELD: (field: string, reason: string) =>
+        `Field '${field}' cannot be specified ${reason}. Remove this field from your SLA definition.`,
+
+    RESTRICTED_WITH_DEFAULT: (field: string, reason: string, defaultValue: unknown) =>
+        `Field '${field}' cannot be specified ${reason}. The default value '${defaultValue}' will be used automatically.`,
+
+    WARNING_FIELD_PERSISTENCE: (field: string, reason: string) =>
+        `Field '${field}' is restricted ${reason}. If this value came from an existing SLA definition, it will be preserved but cannot be modified. If you're creating a new SLA, remove this field.`,
+}
+
+/**
+ * Validates user-specified duration fields (Behavior 1)
+ */
+export function validateUserSpecifiedDuration(config: ObjectShape, diagnostics: Diagnostics) {
+    const duration = config.get('duration')
+
+    // Duration is mandatory when durationType is empty/"User specified"
+    if (!duration || duration.isUndefined()) {
+        diagnostics.error(
+            config,
+            ERROR_MESSAGES.MANDATORY_FIELD('duration', 'when durationType is empty (user specified duration)')
+        )
+    }
+    // Note: Schedule validation is handled in validateSlaDefinitionSchedule based on scheduleSource
+}
+
+/**
+ * Validates relative duration restrictions (Behavior 2)
+ */
+export function validateRelativeDuration(
+    config: ObjectShape,
+    conditions: ObjectShape | undefined,
+    diagnostics: Diagnostics
+) {
+    // When durationType is a relative duration, duration, conditions.pause, conditions.resume, and whenTo.resume
+    // are restricted fields. Existing values from XML are preserved (pass-through).
+    // We issue a warning to inform the user these fields are managed by the relative duration.
+    const duration = config.get('duration')
+    const pauseCondition = conditions?.get('pause')
+    const resumeCondition = conditions?.get('resume')
+    const whenTo = config.get('whenTo')?.ifDefined()?.asObject()
+    const whenToResume = whenTo?.get('resume')
+
+    // duration field is ignored when using relative duration
+    if (duration && !duration.isUndefined()) {
+        diagnostics.hint(
+            duration,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('duration', 'when durationType is a relative duration')
+        )
+    }
+
+    if (pauseCondition && !pauseCondition.isUndefined()) {
+        diagnostics.hint(
+            pauseCondition,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('conditions.pause', 'when durationType is a relative duration')
+        )
+    }
+
+    if (resumeCondition && !resumeCondition.isUndefined()) {
+        diagnostics.hint(
+            resumeCondition,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('conditions.resume', 'when durationType is a relative duration')
+        )
+    }
+
+    if (whenToResume && !whenToResume.isUndefined()) {
+        diagnostics.hint(
+            whenToResume,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('whenTo.resume', 'when durationType is a relative duration')
+        )
+    }
+}
+
+/**
+ * Validates retroactive start requirements (Behaviors 6 & 8)
+ */
+export function validateRetroactiveStart(
+    retroactive: ObjectShape,
+    isUserSpecifiedDuration: boolean,
+    diagnostics: Diagnostics
+) {
+    const setStartTo = retroactive.get('setStartTo')
+    const retroactivePause = retroactive.get('pause')
+
+    // setStartTo is mandatory when retroactive.start is true
+    const setStartToValue = setStartTo?.ifString()?.getValue()
+    if (!setStartToValue) {
+        diagnostics.error(
+            retroactive,
+            ERROR_MESSAGES.MANDATORY_FIELD('retroactive.setStartTo', 'when retroactive.start is true')
+        )
+    }
+
+    // Behavior 8: retroactive.start + relative duration restricts retroactive.pause
+    // Existing values from XML are preserved (pass-through) with a warning.
+    if (!isUserSpecifiedDuration && retroactivePause && !retroactivePause.isUndefined()) {
+        diagnostics.hint(
+            retroactivePause,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE(
+                'retroactive.pause',
+                'when retroactive.start is true and durationType is a relative duration'
+            )
+        )
+    }
+}
+
+/**
+ * Validates that retroactive.pause and retroactive.setStartTo are not set when retroactive.start is false (Behavior 7)
+ */
+export function validateRetroactiveFieldsWithoutStart(retroactive: ObjectShape | undefined, diagnostics: Diagnostics) {
+    if (!retroactive) {
+        return
+    }
+
+    const setStartTo = retroactive.get('setStartTo')
+    const retroactivePause = retroactive.get('pause')
+
+    // setStartTo requires retroactive.start to be true (warning for existing values)
+    if (setStartTo && !setStartTo.isUndefined()) {
+        const value = setStartTo.ifString()?.getValue()
+        if (value) {
+            diagnostics.hint(
+                setStartTo,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('retroactive.setStartTo', 'unless retroactive.start is true')
+            )
+        }
+    }
+
+    // retroactive.pause requires retroactive.start to be true (warning for existing values)
+    if (retroactivePause && !retroactivePause.isUndefined()) {
+        const value = retroactivePause.ifBoolean()?.getValue()
+        if (value !== undefined) {
+            diagnostics.hint(
+                retroactivePause,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('retroactive.pause', 'unless retroactive.start is true')
+            )
+        }
+    }
+}
+
+/**
+ * Validates no_schedule restrictions (Behavior 4)
+ */
+export function validateNoScheduleRestrictions(config: ObjectShape, diagnostics: Diagnostics) {
+    const schedule = config.get('schedule')
+    const timezoneSource = config.get('timezoneSource')
+    const timezone = config.get('timezone')
+    const scheduleSourceField = config.get('scheduleSourceField')
+
+    // Schedule field: warn if provided, since default is forced
+    if (schedule && !schedule.isUndefined()) {
+        const value = schedule.ifString()?.getValue()
+        if (value) {
+            diagnostics.hint(
+                schedule,
+                ERROR_MESSAGES.RESTRICTED_WITH_DEFAULT(
+                    'schedule',
+                    'when scheduleSource is "no_schedule"',
+                    DEFAULT_NO_SCHEDULE_ID
+                )
+            )
+        }
+    }
+
+    // timezoneSource: existing values are preserved with a warning
+    if (timezoneSource && !timezoneSource.isUndefined()) {
+        const value = timezoneSource.ifString()?.getValue()
+        if (value && value !== DEFAULT_TIMEZONE_SOURCE) {
+            diagnostics.hint(
+                timezoneSource,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('timezoneSource', 'when scheduleSource is "no_schedule"')
+            )
+        }
+    }
+
+    // timezone: existing values are preserved with a warning
+    if (timezone && !timezone.isUndefined()) {
+        const value = timezone.ifString()?.getValue()
+        if (value) {
+            diagnostics.hint(
+                timezone,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('timezone', 'when scheduleSource is "no_schedule"')
+            )
+        }
+    }
+
+    // scheduleSourceField: warn since it doesn't apply to no_schedule
+    if (scheduleSourceField && !scheduleSourceField.isUndefined()) {
+        const value = scheduleSourceField.ifString()?.getValue()
+        if (value) {
+            diagnostics.hint(
+                scheduleSourceField,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('scheduleSourceField', 'when scheduleSource is "no_schedule"')
+            )
+        }
+    }
+}
+
+/**
+ * Validates task_field schedule requirements (Behavior 5)
+ */
+export function validateTaskFieldSchedule(config: ObjectShape, diagnostics: Diagnostics) {
+    const schedule = config.get('schedule')
+    const scheduleSourceField = config.get('scheduleSourceField')
+    const duration = config.get('duration')
+
+    // schedule: warn since it doesn't apply when using task_field
+    if (schedule && !schedule.isUndefined()) {
+        const value = schedule.ifString()?.getValue()
+        if (value) {
+            diagnostics.hint(
+                schedule,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('schedule', 'when scheduleSource is "task_field"')
+            )
+        }
+    }
+
+    // duration: warn since it doesn't apply when using task_field
+    if (duration && !duration.isUndefined()) {
+        diagnostics.hint(
+            duration,
+            ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('duration', 'when scheduleSource is "task_field"')
+        )
+    }
+
+    if (!scheduleSourceField || scheduleSourceField.isUndefined()) {
+        diagnostics.error(
+            config,
+            ERROR_MESSAGES.MANDATORY_FIELD('scheduleSourceField', 'when scheduleSource is "task_field"')
+        )
+    }
+}
+
+/**
+ * Validates sla_definition schedule requirements (Behavior 3)
+ */
+export function validateSlaDefinitionSchedule(config: ObjectShape, diagnostics: Diagnostics) {
+    const schedule = config.get('schedule')
+    const scheduleValue = schedule?.ifString()?.getValue()
+
+    // Check for undefined, null, or empty string
+    if (!schedule || schedule.isUndefined() || !scheduleValue) {
+        diagnostics.error(config, ERROR_MESSAGES.MANDATORY_FIELD('schedule', 'when scheduleSource is "sla_definition"'))
+    }
+}
+
+/**
+ * Validates timezone source restrictions (Behavior 9)
+ */
+export function validateTimezoneSource(
+    config: ObjectShape,
+    timezoneSource: string | undefined,
+    diagnostics: Diagnostics
+) {
+    const timezone = config.get('timezone')
+
+    // Only allow timezone field when timezoneSource is 'sla.timezone'
+    // Existing values from XML are preserved (pass-through) with a warning.
+    if (timezoneSource !== 'sla.timezone' && timezone && !timezone.isUndefined()) {
+        const currentValue = timezone.ifString()?.getValue()
+        if (currentValue) {
+            diagnostics.hint(
+                timezone,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('timezone', 'unless timezoneSource is "sla.timezone"')
+            )
+        }
+    }
+}
+
+/**
+ * Validates no_match resume restrictions (Behavior 10)
+ */
+export function validateNoMatchResume(conditions: ObjectShape | undefined, diagnostics: Diagnostics) {
+    const resumeCondition = conditions?.get('resume')
+
+    // When whenToResume is "no_match", conditions.resume is restricted.
+    // Existing values from XML are preserved (pass-through) with a warning.
+    if (resumeCondition && !resumeCondition.isUndefined()) {
+        const currentValue = resumeCondition.ifString()?.getValue()
+        if (currentValue) {
+            diagnostics.hint(
+                resumeCondition,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('conditions.resume', 'when whenToResume is "no_match"')
+            )
+        }
+    }
+}
+
+/**
+ * Validates cancel condition restrictions (Behavior 11)
+ */
+export function validateCancelCondition(
+    whenToCancel: string | undefined,
+    conditions: ObjectShape | undefined,
+    diagnostics: Diagnostics
+) {
+    const cancelCondition = conditions?.get('cancel')
+
+    // Only allow conditions.cancel when whenToCancel is 'on_condition'
+    // Existing values from XML are preserved (pass-through) with a warning.
+    if (whenToCancel !== 'on_condition' && cancelCondition && !cancelCondition.isUndefined()) {
+        const currentValue = cancelCondition.ifString()?.getValue()
+        if (currentValue) {
+            diagnostics.hint(
+                cancelCondition,
+                ERROR_MESSAGES.WARNING_FIELD_PERSISTENCE('conditions.cancel', 'unless whenToCancel is "on_condition"')
+            )
+        }
+    }
+}

package/src/sla-plugin.ts

@@ -0,0 +1,358 @@
+import { CallExpressionShape, Plugin, DurationShape } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+import {
+    validateUserSpecifiedDuration,
+    validateRelativeDuration,
+    validateRetroactiveStart,
+    validateRetroactiveFieldsWithoutStart,
+    validateNoScheduleRestrictions,
+    validateTaskFieldSchedule,
+    validateSlaDefinitionSchedule,
+    validateTimezoneSource,
+    validateNoMatchResume,
+    validateCancelCondition,
+    DEFAULT_WHEN_TO_RESUME,
+    DEFAULT_WHEN_TO_CANCEL,
+    DEFAULT_TIMEZONE_SOURCE,
+    DEFAULT_RETROACTIVE_PAUSE,
+    DEFAULT_NO_SCHEDULE_ID,
+} from './sla/sla-validators'
+
+const DEFAULT_SLA_FLOW = '828f267973333300e289235f04f6a7a3'
+const DEFAULT_COLLECTION = 'incident'
+const DEFAULT_TYPE = 'SLA'
+const DEFAULT_ACTIVE = true
+const DEFAULT_ADV_CONDITION_TYPE = 'none'
+const DEFAULT_SCHEDULE_SOURCE = 'sla_definition'
+const DEFAULT_RELATIVE_DURATION_WORKS_ON = 'Task record'
+const DEFAULT_RESET_ACTION = 'cancel'
+const DEFAULT_RETROACTIVE = false
+const DEFAULT_ENABLE_LOGGING = false
+const DEFAULT_SYS_DOMAIN_PATH = '/'
+const DEFAULT_DURATION_ON_PLATFORM = '1970-01-01 00:00:00'
+
+/**
+ * See ./sla/sla-validators.ts for validation behavior documentation.
+ */
+export const SLAPlugin = Plugin.create({
+    name: 'SLAPlugin',
+
+    records: {
+        contract_sla: {
+            async toShape(record) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'Sla',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $.map((v) => v.ifString()?.ifNotEmpty()?.getValue()),
+                                table: $.from('collection'),
+                                duration: $.from('duration').map((v) => {
+                                    const stringShape = v.ifString()?.ifNotEmpty()
+                                    if (!stringShape) {
+                                        return DurationShape.zero(record)
+                                    }
+                                    const value = stringShape.getValue()
+                                    if (value === DEFAULT_DURATION_ON_PLATFORM) {
+                                        return DurationShape.zero(record)
+                                    }
+                                    return DurationShape.from(record, stringShape)
+                                }),
+                                // Return empty string when scheduleSource is 'no_schedule'
+                                schedule: $.from('schedule', 'schedule_source').map((schedule, schedule_source) => {
+                                    const scheduleSourceValue = schedule_source.ifString()?.getValue()
+                                    if (scheduleSourceValue === 'no_schedule') {
+                                        return ''
+                                    }
+                                    return schedule.ifString()?.ifNotEmpty()?.getValue() ?? ''
+                                }),
+
+                                type: $.def(DEFAULT_TYPE),
+                                active: $.toBoolean().def(DEFAULT_ACTIVE),
+                                advancedConditionType: $.from('adv_condition_type').def(DEFAULT_ADV_CONDITION_TYPE),
+
+                                // Duration & Schedule
+                                durationType: $.from('duration_type').def(''),
+                                scheduleSource: $.from('schedule_source').def(DEFAULT_SCHEDULE_SOURCE),
+                                scheduleSourceField: $.from('schedule_source_field').def(''),
+                                relativeDurationWorksOn: $.from('relative_duration_works_on').def(
+                                    DEFAULT_RELATIVE_DURATION_WORKS_ON
+                                ),
+
+                                // Conditions
+                                conditions: $.from(
+                                    'start_condition',
+                                    'stop_condition',
+                                    'pause_condition',
+                                    'resume_condition',
+                                    'reset_condition',
+                                    'cancel_condition'
+                                ).map(
+                                    (
+                                        start_condition,
+                                        stop_condition,
+                                        pause_condition,
+                                        resume_condition,
+                                        reset_condition,
+                                        cancel_condition
+                                    ) => {
+                                        const conditions: Record<string, string> = {}
+
+                                        const startStr = start_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (startStr) {
+                                            conditions['start'] = startStr
+                                        }
+
+                                        const stopStr = stop_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (stopStr) {
+                                            conditions['stop'] = stopStr
+                                        }
+
+                                        const pauseStr = pause_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (pauseStr) {
+                                            conditions['pause'] = pauseStr
+                                        }
+
+                                        const resumeStr = resume_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (resumeStr) {
+                                            conditions['resume'] = resumeStr
+                                        }
+
+                                        const resetStr = reset_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (resetStr) {
+                                            conditions['reset'] = resetStr
+                                        }
+
+                                        const cancelStr = cancel_condition.ifString()?.ifNotEmpty()?.getValue()
+                                        if (cancelStr) {
+                                            conditions['cancel'] = cancelStr
+                                        }
+
+                                        return Object.keys(conditions).length > 0 ? conditions : undefined
+                                    }
+                                ),
+
+                                // Condition Behavior
+                                conditionType: $.from('condition_class').def(''),
+                                resetAction: $.from('reset_action').def(DEFAULT_RESET_ACTION),
+                                whenTo: $.from('when_to_resume', 'when_to_cancel').map(
+                                    (when_to_resume, when_to_cancel) => {
+                                        const resumeValue = when_to_resume.ifString()?.getValue()
+                                        const cancelValue = when_to_cancel.ifString()?.getValue()
+                                        return {
+                                            resume: resumeValue || DEFAULT_WHEN_TO_RESUME,
+                                            cancel: cancelValue || DEFAULT_WHEN_TO_CANCEL,
+                                        }
+                                    }
+                                ),
+
+                                // Retroactive
+                                retroactive: $.from('retroactive', 'retroactive_pause', 'set_start_to').map(
+                                    (retroactive, retroactive_pause, set_start_to) => {
+                                        const startValue = retroactive.ifBoolean()?.getValue() ?? DEFAULT_RETROACTIVE
+                                        const pauseValue = retroactive_pause.ifBoolean()?.getValue()
+                                        const setStartToValue = set_start_to.ifString()?.ifNotEmpty()?.getValue()
+
+                                        const result: { start: boolean; pause?: boolean; setStartTo?: string } = {
+                                            start: startValue,
+                                        }
+
+                                        // Only include pause when start is true (per Behavior 6/7)
+                                        if (startValue) {
+                                            result.pause = pauseValue ?? DEFAULT_RETROACTIVE_PAUSE
+                                        }
+
+                                        // Only include setStartTo if it has a valid value
+                                        if (setStartToValue) {
+                                            result.setStartTo = setStartToValue
+                                        }
+
+                                        return result
+                                    }
+                                ),
+
+                                // References
+                                overrides: $.from('sys_overrides').def(''),
+                                workflow: $.def(''),
+                                flow: $.def(''),
+                                vendor: $.def(''),
+
+                                // Time Zones
+                                timezone: $.def(''),
+                                timezoneSource: $.from('timezone_source').def(DEFAULT_TIMEZONE_SOURCE),
+
+                                // Metadata
+                                enableLogging: $.from('enable_logging').toBoolean().def(DEFAULT_ENABLE_LOGGING),
+                                target: $.def(''),
+
+                                // Domain
+                                domainPath: $.from('sys_domain_path').def(DEFAULT_SYS_DOMAIN_PATH),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics }) {
+                if (callExpression.getCallee() !== 'Sla') {
+                    return { success: false }
+                }
+
+                const config = callExpression.getArgument(0).asObject()
+
+                // Extract Control Fields
+                const durationType = config.get('durationType')
+                const durationTypeValue = durationType?.ifString()?.getValue()
+                const isUserSpecifiedOrEmptyDuration = !durationTypeValue || durationTypeValue === ''
+
+                const scheduleSource = config.get('scheduleSource')
+                const scheduleSourceValue = scheduleSource?.ifString()?.getValue() || DEFAULT_SCHEDULE_SOURCE
+
+                const retroactive = config.get('retroactive')?.ifDefined()?.asObject()
+                const retroactiveStartValue = retroactive?.get('start')?.ifBoolean()?.getValue() || false
+
+                const whenTo = config.get('whenTo')?.ifDefined()?.asObject()
+                const whenToResumeValue = whenTo?.get('resume')?.ifString()?.getValue() || DEFAULT_WHEN_TO_RESUME
+                const whenToCancelValue = whenTo?.get('cancel')?.ifString()?.getValue() || DEFAULT_WHEN_TO_CANCEL
+
+                const timezoneSource = config.get('timezoneSource')
+                const timezoneSourceValue = timezoneSource?.ifString()?.getValue() || DEFAULT_TIMEZONE_SOURCE
+
+                // Extract conditions object
+                const conditions = config.get('conditions').ifDefined()?.asObject()
+
+                if (isUserSpecifiedOrEmptyDuration) {
+                    // Behavior 1: User specified duration
+                    // Validate duration field uses Duration() helper (only when duration is expected)
+                    const duration = config.get('duration')
+                    if (duration && duration.isDefined()) {
+                        if (!(duration instanceof CallExpressionShape) || duration.getCallee() !== 'Duration') {
+                            diagnostics.error(duration, "SLA 'duration' field must use the Duration() helper function")
+                        }
+                    }
+                    validateUserSpecifiedDuration(config, diagnostics)
+                } else {
+                    // Behavior 2: Relative duration
+                    validateRelativeDuration(config, conditions, diagnostics)
+                }
+
+                // Schedule Source Validations
+                if (scheduleSourceValue === 'no_schedule') {
+                    // Behavior 5: No schedule
+                    validateNoScheduleRestrictions(config, diagnostics)
+                } else if (scheduleSourceValue === 'task_field') {
+                    // Behavior 6: Task field schedule
+                    validateTaskFieldSchedule(config, diagnostics)
+                } else if (scheduleSourceValue === 'sla_definition') {
+                    // Behavior 7: SLA definition schedule (default)
+                    validateSlaDefinitionSchedule(config, diagnostics)
+                }
+
+                // Condition Field Validations
+                // Behavior 8: Timezone source
+                validateTimezoneSource(config, timezoneSourceValue, diagnostics)
+
+                // Behavior 9: When to resume = "no_match"
+                if (whenToResumeValue === 'no_match') {
+                    validateNoMatchResume(conditions, diagnostics)
+                }
+
+                // Behavior 10: When to cancel validation
+                validateCancelCondition(whenToCancelValue, conditions, diagnostics)
+
+                // Retroactive Validations
+                if (retroactiveStartValue && retroactive) {
+                    // Behaviors 6 & 8: Retroactive start validations
+                    validateRetroactiveStart(retroactive, isUserSpecifiedOrEmptyDuration, diagnostics)
+                } else {
+                    // Behavior 7: Validate that retroactive-dependent fields are not set when retroactive.start is false
+                    validateRetroactiveFieldsWithoutStart(retroactive, diagnostics)
+                }
+
+                return {
+                    success: true,
+                    value: await factory.createRecord({
+                        source: callExpression,
+                        table: 'contract_sla',
+                        explicitId: config.get('$id'),
+                        properties: config.transform(({ $ }) => ({
+                            // Core
+                            name: $.map((v) => v.ifString()?.ifNotEmpty()?.getValue()),
+                            collection: $.from('table').def(DEFAULT_COLLECTION),
+                            type: $.def(DEFAULT_TYPE),
+                            active: $.def(DEFAULT_ACTIVE),
+                            adv_condition_type: $.from('advancedConditionType').def(DEFAULT_ADV_CONDITION_TYPE),
+
+                            // Duration & Schedule
+                            duration: $.map((v) => v.toString()),
+                            duration_type: $.from('durationType').toString(),
+                            // Conditional schedule: force default when no_schedule
+                            schedule: $.map((v) => {
+                                if (scheduleSourceValue === 'no_schedule') {
+                                    return DEFAULT_NO_SCHEDULE_ID
+                                }
+                                return v.ifString()?.ifNotEmpty()?.getValue()
+                            }),
+                            schedule_source: $.from('scheduleSource').def(DEFAULT_SCHEDULE_SOURCE),
+                            schedule_source_field: $.from('scheduleSourceField'),
+                            relative_duration_works_on: $.from('relativeDurationWorksOn').def(
+                                DEFAULT_RELATIVE_DURATION_WORKS_ON
+                            ),
+
+                            // Conditions
+                            start_condition: $.val(conditions?.get('start')),
+                            reset_condition: $.val(conditions?.get('reset')),
+                            stop_condition: $.val(conditions?.get('stop')),
+                            cancel_condition: $.val(conditions?.get('cancel')),
+                            pause_condition: $.val(conditions?.get('pause')),
+                            resume_condition: $.val(conditions?.get('resume')),
+
+                            // Condition Behavior
+                            condition_class: $.from('conditionType').toString(),
+                            reset_action: $.from('resetAction').def(DEFAULT_RESET_ACTION),
+                            when_to_resume: $.val(whenTo?.get('resume')).def(DEFAULT_WHEN_TO_RESUME),
+                            when_to_cancel: $.val(whenTo?.get('cancel')).def(DEFAULT_WHEN_TO_CANCEL),
+
+                            // Retroactive
+                            retroactive: $.val(retroactive?.get('start')).def(DEFAULT_RETROACTIVE),
+                            retroactive_pause: $.map(() => {
+                                const value = retroactive?.get('pause')?.ifBoolean()?.getValue()
+                                if (value !== undefined) {
+                                    return value
+                                }
+                                return isUserSpecifiedOrEmptyDuration ? DEFAULT_RETROACTIVE_PAUSE : undefined
+                            }),
+                            set_start_to: $.val(retroactive?.get('setStartTo')),
+
+                            // References
+                            sys_overrides: $.from('overrides'),
+                            workflow: $,
+                            flow: $.from('flow').def(DEFAULT_SLA_FLOW),
+                            vendor: $,
+
+                            // Time Zones
+                            timezone: $,
+                            timezone_source: $.from('timezoneSource').def(DEFAULT_TIMEZONE_SOURCE),
+
+                            // Metadata
+                            enable_logging: $.from('enableLogging').def(DEFAULT_ENABLE_LOGGING),
+                            target: $,
+
+                            // Domain
+                            sys_domain_path: $.from('domainPath').def(DEFAULT_SYS_DOMAIN_PATH),
+                        })),
+                    }),
+                }
+            },
+        },
+    ],
+})