new SyncConnection(options: Object)#


appConfig: Objectinstance #

AdminUI settings

appName: Stringinstance #

Name of UnityBase application

authMethods: Array<string>instance #

Possible server authentication method

authNeed: Booleaninstance #

Is UnityBase server require authorization

clientRequest: ClientRequestinstance #

Internal instance of HTTP client

encryptContent: Booleaninstance #

Is server require content encryption

onRequestAuthParams: functioninstance #

Callback for resolving user credential. Take a SyncConnection as a parameter, must return authorization parameters object:

 {authSchema: authType, login: login, password: password, [apiKey: ]}

For a internal usage (requests from a locahost or other systems, etc.) and in case authShema == 'UB' it is possible to pass a apiKey instead of a password. apiKey is actually a uba_user.uPasswordHashHexa content

queryMethod: stringinstance #

Endpoint name for query (runList before 1.12, ubql after 1.12)

serverCertificate: Booleaninstance #

base64 encoded server certificate used for cryptographic operation

servicePath: Stringinstance #

Root path to all application-level method

sessionKeyLifeTime: Numberinstance #

Lifetime (in second) of session encryption

UBQLv2instance #

Server support UBQL v2 (value instead of values)

Name Type Description
UBQLv2 Boolean


get(endpoint: String, URLParamsopt: *)→ArrayBuffer | Object | Stringinstance#

Perform get request to endpoint with optional URLParams.


Return information about how application is configured as returned by getAppInfo endpoint

getDocument(params: Object, optionsopt: Object)→ArrayBuffer | Stringinstance#

Retrieve content of document type attribute field from server. Usage samples:

 //Retrieve content of document as string using GET
 let frmContent = conn.getDocument({
     attribute: 'formDef',
     ID: 100000232003
  console.log(typeof frmContent)

 //The same, but using POST for bypass cache
 let frmContent = conn.getDocument({
     attribute: 'formDef',
     ID: 100000232003
  }, {
     bypassCache: true
  console.log(typeof frmContent) // string

 //Retrieve content of document as ArrayBuffer and bypass cache
 let frmContent = conn.getDocument({
     attribute: 'formDef',
     ID: 100000232003
  }, {
     bypassCache: true, resultIsBinary: true
  console.log('Result is', typeof frmContent, 'of length' , frmContent.byteLength, 'bytes'); //output: Result is object of length 2741 bytes


Document content (either ArrayBuffer in case options.resultIsBinary===true or text/json)

Arguments info:

  • params: Object
    • entity: String

      Code of entity to retrieve from

    • attribute: String

      document type attribute code

    • id: Number

      Instance ID

    • forceMime: String

      If passed and server support transformation from source MIME type to forceMime server perform transformation and return documenRt representation in the passed MIME

    • revision: Number

      Optional revision of the documnet (if supported by server-side store configuration). Default is current revision.

    • fileName: String


    • isDirty: Boolean

      Optional ability to retrieve document in dirty state

    • store: String


  • options: Object
    • resultIsBinary: Boolean

      if true - return document content as arrayBuffer

    • bypassCache: Boolean

      HTTP POST verb will be used instead of GET for bypass browser cache

    Additional request options

getDomainInfo(isExtendedopt: Boolean)→UBDomaininstance#

Retrieve application domain information.

Arguments info:

  • isExtended = false : Boolean

    For member of admin group cen return a addinitonal domain information, such as mappings, connection details, indexes

insert(ubq: ubRequest)→*instance#

Execute insert method by add method: 'insert' to ubq query (if req.method not already set)

If ubq.fieldList contain only ID return inserted ID, else return array of attribute values passed to fieldList. If no field list passed at all - return response.resultData (null usually).

    var testRole = conn.insert({
        entity: 'uba_role',
        fieldList: ['ID', 'mi_modifyDate'],
        execParams: {
            name: 'testRole1',
            allowedAppMethods: 'runList'
    console.log(testRole); //[3000000000200,"2014-10-21T11:56:37Z"]

    var testRoleID = conn.insert({
        entity: 'uba_role',
        fieldList: ['ID'],
        execParams: {
            name: 'testRole1',
            allowedAppMethods: 'runList'
    console.log(testRoleID); //3000000000200


Check is current connection already perform authentication request


Logout from server if logged in

lookup(aEntity: String, lookupAttribute: String, aCondition: String, doNotUseCacheopt: Boolean)→*instance#

Lookup value in entity using aCondition.

 // create condition using Repository
 var myID = conn.lookup('ubm_enum', 'ID',
      conn.Repository('ubm_enum').where('eGroup', '=', 'UBA_RULETYPE').where('code', '=', 'A').ubql().whereList
 // or pass condition directly
 var adminID = conn.lookup('uba_user', 'ID', {
     expression: 'name', condition: 'equal', value: 'admin'}


lookupAttribute value of first result row or null if not found.

Arguments info:

  • aEntity: String

    entity to lookup

  • lookupAttribute: String

    attribute to lookup

  • aCondition: String

    lookup condition. String in case of custom expression, or whereListItem {expression: condition: value: }, or whereList {condition1: {expression: condition: value: }, condition2: {}, ....}

post(endpoint: String, data: ArrayBuffer)→ArrayBuffer | Object | String | Array<object>instance#

Shortcut method to perform authorized POST request to application we connected

query(ubq: Object)→Object | Arrayinstance#

Perform authorized UBQL request. Can take one QB Query or an array of UB Query and execute it at once.

Repository(entityName: String)→ServerRepositoryinstance#

Create a new instance of repository

Arguments info:

  • entityName: String

    name of Entity we create for

run(request: ubRequest)→Objectinstancedeprecated#

Since UB 1.11 use SyncConnection.query

Shortcut method to perform authorized POST request to ubql endpoint. Can take one ubRequest and wrap it to array


Send request to any endpoint. For entity-level method execution (ubql endpoint) better to use SyncConnection.query


body of HTTP request result. If !simpleTextResult and response type is json - then parsed to object

setDocument(entity: string, attribute: string, id: number, data: ArrayBuffer, origName: string, fileNameopt: string, dataEncoding: string)→stringinstance#

Saves a file content as a potential value of the specified entity instance attribute to the TEMP store.

Call this function before entity insert of update. Result of this function is what shall be assigned to the attribute value, to "execParams".

Arguments info:

  • entity: string

    Entity name

  • attribute: string

    Entity attribute name

  • id: number

    ID of the record

  • data: ArrayBuffer

    File content

  • fileName: string

    If not specified, origName will be used.

  • dataEncoding: string

    Specify data parameter encoding. Either omit for binary data or set to base64 for base64 encoded data


        const myObj = conn.Repository(entityName)
      .attrs('ID', 'mi_modifyDate')
      .where('code', '=', code)
    const {ID, mi_modifyDate} = myObj
    const data = fs.readFileSync(fileName, {encoding: 'bin'})
    const tempStoreResult = conn.setDocument(entityName, 'configuration', ID, data, fn)
      entity: entityName,
      method: 'update',
      execParams: {ID, configuration: tempStoreResult, mi_modifyDate}

Execute update method by add method: 'update' to ubq query (if req.method not already set)

userData(keyopt: String)→*instance#

Return custom data for logged in user, or {lang: 'en'} in case not logged in

If key is provided - return only key part of user data:

 // or the same but dedicated alias

Arguments info:


Return current user language or 'en' in case not logged in


Return current user logon or 'anonymous' in case not logged in

xhr(options: Object)→ArrayBuffer | Object | String | Array<Object>instance#

HTTP request to UB server. In case of success response return body parsed to {Object} or {ArrayBuffer} depending of Content-Type response header

Arguments info:

  • options: Object
    • endpoint: String

    • UBMethod: String

      This parameter is DEPRECATED. Use options.endpoint instead

    • HTTPMethod='POST': String

    • headers: Object

      Optional request headers in format {headerName: headerValue, ..}

    • simpleTextResult: Boolean

      do not parse response and return it as is even if response content type is JSON

    • URLParams: *

      Optional parameters added to URL using http.buildURL

    • data: ArrayBuffer

      Optional body

    • responseType: String

      see responseType. Currently only arraybuffer supported.


     endpoint: 'runSQL',
     URLParams: {CONNECTION: 'dba'},
     data: 'DROP SCHEMA IF EXISTS ub_autotest CASCADE; DROP USER IF EXISTS ub_autotest;'