Reusable GlideAjax Script Include Pattern

intermediateTested on Xanadu

The Reusable GlideAjax Script Include pattern provides a secure, structured way to execute server-side logic from client-side scripts in ServiceNow. By extending AbstractAjaxProcessor, these Script Includes can receive parameters from client scripts and return JSON responses, enabling dynamic form updates, data validation, and complex calculations without full page reloads.

This pattern solves the common need for client-side scripts to access server-side data or perform operations that require elevated privileges or server-side APIs. Unlike direct database queries from client scripts (which are impossible), GlideAjax Script Includes run with appropriate server-side permissions while maintaining security boundaries through parameter validation and controlled access.

The pattern works by creating a Script Include that extends AbstractAjaxProcessor, defining public methods that can be called via GlideAjax from client scripts. Parameters are passed through the sysparm object and responses are returned as JSON strings, providing a clean interface for client-server communication.

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 client scripts need to retrieve server data, perform complex calculations, or execute operations requiring server-side APIs like GlideRecord queries, web service calls, or privileged system functions. It's ideal for form validations, dependent field population, and real-time data lookups without page refreshes.

Avoid When

Avoid this pattern for simple operations that can be handled with reference qualifiers, UI policies, or catalog client scripts. Don't use it for frequent polling or operations that could impact performance, as each call creates a server round-trip and should be used judiciously to prevent system overload.

Implementation

Server-side

var UserDataProcessor = Class.create();
UserDataProcessor.prototype = Object.extendsObject(AbstractAjaxProcessor, {

    // Get user details by user ID
    getUserDetails: function() {
        var userId = this.getParameter('sysparm_user_id');
        if (!userId) {
            return this._buildErrorResponse('User ID is required');
        }
        
        var userGr = new GlideRecord('sys_user');
        if (userGr.get(userId)) {
            var userData = {
                name: userGr.getDisplayValue('name'),
                email: userGr.getDisplayValue('email'),
                department: userGr.getDisplayValue('department'),
                title: userGr.getDisplayValue('title'),
                active: userGr.active.toString()
            };
            return JSON.stringify({
                success: true,
                data: userData
            });
        } else {
            return this._buildErrorResponse('User not found');
        }
    },
    
    // Validate if user has specific role
    validateUserRole: function() {
        var userId = this.getParameter('sysparm_user_id');
        var roleName = this.getParameter('sysparm_role_name');
        
        if (!userId || !roleName) {
            return this._buildErrorResponse('User ID and role name are required');
        }
        
        var userGr = new GlideRecord('sys_user');
        if (userGr.get(userId)) {
            var hasRole = userGr.hasRole(roleName);
            return JSON.stringify({
                success: true,
                data: {
                    hasRole: hasRole,
                    userId: userId,
                    roleName: roleName
                }
            });
        } else {
            return this._buildErrorResponse('User not found');
        }
    },
    
    // Get department statistics
    getDepartmentStats: function() {
        var deptId = this.getParameter('sysparm_dept_id');
        if (!deptId) {
            return this._buildErrorResponse('Department ID is required');
        }
        
        var userGr = new GlideAggregate('sys_user');
        userGr.addQuery('department', deptId);
        userGr.addQuery('active', true);
        userGr.addAggregate('COUNT');
        userGr.query();
        
        var activeCount = 0;
        if (userGr.next()) {
            activeCount = parseInt(userGr.getAggregate('COUNT'));
        }
        
        return JSON.stringify({
            success: true,
            data: {
                departmentId: deptId,
                activeUserCount: activeCount
            }
        });
    },
    
    // Private method to build consistent error responses
    _buildErrorResponse: function(message) {
        return JSON.stringify({
            success: false,
            error: message
        });
    },
    
    type: 'UserDataProcessor'
});

Client-side

function getAndDisplayUserDetails(userId) {
    if (!userId) {
        alert('Please provide a user ID');
        return;
    }
    
    var ajax = new GlideAjax('UserDataProcessor');
    ajax.addParam('sysparm_name', 'getUserDetails');
    ajax.addParam('sysparm_user_id', userId);
    
    ajax.getXML(function(response) {
        var responseText = response.responseXML.documentElement.getAttribute('answer');
        var result = JSON.parse(responseText);
        
        if (result.success) {
            // Populate form fields with user data
            g_form.setValue('user_name', result.data.name);
            g_form.setValue('email', result.data.email);
            g_form.setValue('department', result.data.department);
            g_form.setValue('title', result.data.title);
            
            if (result.data.active === 'false') {
                g_form.showFieldMsg('user_name', 'This user is inactive', 'warning');
            }
        } else {
            g_form.showFieldMsg('user_id', result.error, 'error');
        }
    });
}

// Example usage in onChange client script
function onChange(control, oldValue, newValue, isLoading) {
    if (isLoading || newValue === '') {
        return;
    }
    
    // Validate user role when user field changes
    var ajax = new GlideAjax('UserDataProcessor');
    ajax.addParam('sysparm_name', 'validateUserRole');
    ajax.addParam('sysparm_user_id', newValue);
    ajax.addParam('sysparm_role_name', 'itil');
    
    ajax.getXML(function(response) {
        var responseText = response.responseXML.documentElement.getAttribute('answer');
        var result = JSON.parse(responseText);
        
        if (result.success && !result.data.hasRole) {
            g_form.showFieldMsg('assigned_to', 'Selected user does not have ITIL role', 'warning');
        } else {
            g_form.hideFieldMsg('assigned_to');
        }
    });
}

The Script Include extends AbstractAjaxProcessor and defines public methods that can be called via GlideAjax. Each method uses this.getParameter() to retrieve client-passed parameters and returns JSON.stringify() responses for consistent data structure. The client code demonstrates proper parameter passing with sysparm_name to specify the method and additional parameters for method arguments, with JSON parsing of the XML response.

Alternatives

REST Table API

Better for CRUD operations on table records with built-in authentication and standardized responses, but less flexible for custom business logic and requires API knowledge rather than familiar ServiceNow scripting patterns.

Client-side GlideRecord (Scoped Apps)

Available in scoped applications for direct client-side database access with simpler syntax, but limited to the application scope and not available in global scope, making it unsuitable for many enterprise implementations.

UI Policy with Advanced Conditions

No-code solution that's easier to maintain and performs better for simple field show/hide and value setting based on other field values, but cannot handle complex logic, external integrations, or dynamic data lookups.

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