ServiceNow Fluent language constructs

  • Release version: Zurich
  • Updated March 12, 2026
  • 2 minutes to read
  • Summarize
    Summarized using AI
    This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete.

    Summary of ServiceNow Fluent language constructs

    ServiceNow Fluent language constructs enhance source code development by providing specialized APIs to define and manage metadata, references, code inclusions, and attachments within ServiceNow applications. These constructs enable clear, maintainable, and reusable code by connecting source files, metadata, and resources effectively.

    Show full answer Show less

    Key Constructs and Their Practical Use

    • Now.ID: Defines human-readable unique IDs for metadata in source code, which are hashed into unique sysids when building applications. IDs are only for defining metadata, not for cross-referencing; referencing within the same app should use constant variables.
    • Now.ref: References metadata from different applications not defined in source code, using table names and identifiers (sysid or column-value pairs). It supports referencing by GUID and coalescing ID, enabling linkage across applications.
    • Now.include: Includes external text content like scripts or styles from files in the same application instead of inline coding. This supports proper syntax highlighting, works well with multiple languages (JavaScript, HTML, CSS), and maintains two-way synchronization between source code and metadata in the instance.
    • Now.attach: Attaches image files (various formats such as .jpg, .png, .svg, etc.) from the application’s file system to metadata records supporting user images. It supports two-way synchronization, allowing image updates in source code and ServiceNow UI to stay in sync. Images can be reused by assigning them to variables and referencing these variables in multiple properties.

    Benefits and Expected Outcomes

    • Improved clarity and maintainability of application source code through explicit, human-readable IDs and references.
    • Seamless integration of external files (scripts, styles, images) with automated synchronization, reducing manual update errors and improving developer productivity.
    • Cross-application metadata referencing that facilitates modular and scalable application design.
    • Support for common file formats and languages ensures flexibility and consistency in managing application resources.

    ServiceNow Fluent language constructs provide additional functionality for development in source code with ServiceNow Fluent APIs.

    Note:
    For the latest ServiceNow Fluent API documentation and examples, see the ServiceNow Fluent API reference and ServiceNow SDK examples repository on GitHub.

    Now.ID

    The Now.ID construct is used to specify human-readable unique IDs for metadata defined in source code. Now.ID uses the format Now.ID['String' or Number] with the $id property in ServiceNow Fluent APIs. When you build an application, the ID is hashed into a unique sys_id.

    You can use Now.ID only to define IDs for metadata and not to reference other metadata in an application. To reference other metadata within the same application, you can assign the object to a const variable and reference the variable identifier in other objects.

    import { Role } from "@servicenow/sdk/core"
    
    const managerRole = Role({ 
       $id: Now.ID['manager_role'], 
       name: 'x_snc_example.manager' 
    })
    
    Record({
      table: 'some_table',
      data: {
         role: managerRole //"role" is a reference field to sys_user_role
      }
    })

    Now.ref

    The Now.ref construct is used to reference metadata in a different application that's not defined in source code. Now.ref uses the format Now.ref['table', 'sys_id' or {column: 'value'}, {column: 'value'}] with Reference properties in ServiceNow Fluent APIs.

    import { Role } from "@servicenow/sdk/core"
    
    Role({
        name: 'x_test.admin',
        contains_roles: [
            'x_test.manager',
            Now.ref('sys_user_role', { name: 'x_test.itil' }),           // Coalescing ID reference
            Now.ref('sys_user_role', '${itomId}'),                       // GUID-based reference
            Now.ref('sys_user_role', '3D82d1a88947942a90b6d8aa25126d439b', { name: 'x_test.csm' }),   // GUID with coalescing ID reference
        ],
    })

    Now.include

    The Now.include construct is used to refer to text content in another file in the same application rather than including the content inline. Now.include uses relative file paths in the format Now.include('./path/to/file') with any property in ServiceNow Fluent APIs. Using Now.include allows you to code with the appropriate syntax highlighting for the file type and is especially helpful with properties that support other languages like JavaScript, HTML, CSS, and more.

    Now.include supports two-way synchronization so that changes to fields from other ServiceNow AI Platform user interfaces are synced into the referenced file's source code and changes to the source code are synced back to metadata across the instance.

    import { ScriptInclude } from '@servicenow/sdk/core'
    
    ScriptInclude({
        $id: Now.ID['my-script-include'],
        name: 'MyScriptInclude',
        active: true,
        apiName: 'x_scriptincludes.MyScriptInclude',
        script: Now.include('./MyScriptInclude.server.js') //The actual content of the "script" field is contained in the file specified
    })

    Now.attach

    The Now.attach construct is used to refer to an image file in the same application and attach it to records associated with metadata defined in source code. Now.attach uses relative file paths in the format Now.attach('./path/to/file') with properties that support user images (the user_image field type) in ServiceNow Fluent APIs. Now.attach supports the following file formats: .jpg, .jpeg, .png, .gif, .bmp, .ico, and .svg.

    Now.attach supports two-way synchronization so that changes to image files from other ServiceNow AI Platform user interfaces are synced into the application in source code and changes to image files in source code are synced back to metadata across the instance.

    import { Record } from '@servicenow/sdk/core'
    
    Record({
        $id: Now.ID['sample-service-portal'],
        table: 'sp_portal',
        data: {
            title: 'Sample Portal',
            url_suffix: 'sample',
            icon: Now.attach('../../assets/servicenow.jpg')
        }
    })

    You can also reuse an image in an application by assigning the Now.attach construct to a const variable and referencing the variable identifier in other properties. For example:

    import { Record } from '@servicenow/sdk/core'
    
    const image = Now.attach('../../assets/servicenow.jpg')
    
    Record({
        $id: Now.ID['test'],
        table: 'sp_portal',
        data: {
            title: 'Test Portal',
            url_suffix: 'test',
            icon: image,
            logo: image,
        }
    })