Script Include Inheritance Pattern in…

advancedTested on Xanadu

The Script Include Inheritance Pattern leverages JavaScript's prototype-based inheritance within ServiceNow's Type.extend() framework to create hierarchical relationships between Script Includes. This pattern allows you to define a base class with common functionality and create specialized child classes that inherit and extend those capabilities.

This pattern solves the problem of code duplication across related Script Includes by establishing a clear inheritance chain. For example, you might have a base NotificationHandler class with common email functionality, then create specialized classes like IncidentNotificationHandler and ChangeNotificationHandler that inherit the base methods while adding their own specific logic. The pattern uses Type.extend() to properly set up the prototype chain and provides mechanisms for method overriding and super method calls.

The inheritance pattern works by defining a parent Script Include with shared methods and properties, then using Type.extend() in child Script Includes to establish the prototype relationship. Child classes can override parent methods while still accessing the original implementation through the parent object reference, enabling controlled extension of functionality.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Use This When

Use this pattern when you have multiple Script Includes that share common functionality but require specialized behavior, such as different types of integrations, notification handlers, or data processors. It's ideal when you want to enforce consistent interfaces across related classes while avoiding code duplication.

Avoid When

Avoid this pattern for simple, unrelated utility functions where inheritance adds unnecessary complexity. Don't use it when the relationship between classes is weak or when composition would be more appropriate than inheritance, as deep inheritance chains can become difficult to maintain and debug.

Implementation

Server-side

// Base Script Include: BaseNotificationHandler
var BaseNotificationHandler = Class.create();
BaseNotificationHandler.prototype = {
    initialize: function(tableName) {
        this.tableName = tableName || 'task';
        this.logger = new GSLog('NotificationHandler', this.type);
    },
    
    type: 'BaseNotificationHandler',
    
    // Common method to get record data
    getRecordData: function(sysId) {
        var gr = new GlideRecord(this.tableName);
        if (gr.get(sysId)) {
            return {
                number: gr.getDisplayValue('number'),
                short_description: gr.getDisplayValue('short_description'),
                state: gr.getDisplayValue('state'),
                assigned_to: gr.getDisplayValue('assigned_to')
            };
        }
        return null;
    },
    
    // Base notification method to be overridden
    sendNotification: function(sysId, recipients) {
        this.logger.info('Base sendNotification called for: ' + sysId);
        var recordData = this.getRecordData(sysId);
        if (!recordData) {
            this.logger.error('Record not found: ' + sysId);
            return false;
        }
        return this._executeNotification(recordData, recipients);
    },
    
    // Protected method for actual notification sending
    _executeNotification: function(recordData, recipients) {
        this.logger.info('Executing base notification for: ' + recordData.number);
        return true;
    },
    
    // Utility method for formatting messages
    formatMessage: function(template, recordData) {
        return template.replace(/\{([^}]+)\}/g, function(match, key) {
            return recordData[key] || match;
        });
    }
};

// Child Script Include: IncidentNotificationHandler
var IncidentNotificationHandler = Class.create();
IncidentNotificationHandler.prototype = Object.extendsObject(BaseNotificationHandler, {
    initialize: function() {
        BaseNotificationHandler.prototype.initialize.call(this, 'incident');
        this.priority_threshold = 3; // High and Critical only
    },
    
    type: 'IncidentNotificationHandler',
    
    // Override getRecordData to include incident-specific fields
    getRecordData: function(sysId) {
        // Call parent method first
        var baseData = BaseNotificationHandler.prototype.getRecordData.call(this, sysId);
        if (!baseData) return null;
        
        // Add incident-specific data
        var gr = new GlideRecord('incident');
        if (gr.get(sysId)) {
            baseData.priority = gr.getDisplayValue('priority');
            baseData.category = gr.getDisplayValue('category');
            baseData.caller_id = gr.getDisplayValue('caller_id');
            baseData.urgency = gr.getDisplayValue('urgency');
        }
        return baseData;
    },
    
    // Override sendNotification with incident-specific logic
    sendNotification: function(sysId, recipients) {
        this.logger.info('Incident notification handler called for: ' + sysId);
        
        var recordData = this.getRecordData(sysId);
        if (!recordData) return false;
        
        // Incident-specific logic: check priority threshold
        var gr = new GlideRecord('incident');
        if (gr.get(sysId) && parseInt(gr.priority) > this.priority_threshold) {
            this.logger.info('Incident priority below threshold, skipping notification');
            return false;
        }
        
        // Call parent implementation
        return BaseNotificationHandler.prototype.sendNotification.call(this, sysId, recipients);
    },
    
    // Override _executeNotification with incident-specific email logic
    _executeNotification: function(recordData, recipients) {
        var template = 'Incident {number}: {short_description}\nPriority: {priority}\nCaller: {caller_id}';
        var message = this.formatMessage(template, recordData);
        
        var mail = new GlideEmailOutbound();
        mail.setSubject('Incident Notification: ' + recordData.number);
        mail.setBody(message);
        mail.setRecipients(recipients);
        
        this.logger.info('Sending incident notification for: ' + recordData.number);
        return mail.send().hasNext();
    },
    
    // Incident-specific method
    escalateToManager: function(sysId) {
        var recordData = this.getRecordData(sysId);
        if (recordData && recordData.assigned_to) {
            var userGr = new GlideRecord('sys_user');
            if (userGr.get('name', recordData.assigned_to) && userGr.manager) {
                return this.sendNotification(sysId, userGr.manager.getDisplayValue('email'));
            }
        }
        return false;
    }
});

The code demonstrates proper ServiceNow inheritance using Object.extendsObject() to establish the prototype chain between BaseNotificationHandler and IncidentNotificationHandler. The child class calls parent methods using ParentClass.prototype.methodName.call(this) syntax, enabling method overriding while preserving access to parent functionality. Notice how the initialize methods chain together and each class maintains its own type property for identification.

Alternatives

Composition Pattern

Use composition by injecting helper objects instead of inheritance when relationships aren't strictly hierarchical. This provides more flexibility but requires explicit delegation and doesn't establish is-a relationships.

Static Utility Classes

Create Script Includes with only static methods when you don't need instance state or complex relationships. This is simpler and more performant but doesn't provide the extensibility and polymorphism benefits of inheritance.

Factory Pattern with Strategy

Combine a factory method with strategy objects when you need runtime selection of behavior rather than compile-time inheritance. This offers maximum flexibility but adds complexity and may be harder to understand for maintenance developers.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue