new SyncConnection(options : Object) #

Members

appConfig : Object instance #

AdminUI settings

appName : String instance #

Name of UnityBase application

authMethods : <string> instance #

Possible server authentication method

authNeed : Boolean instance #

Is UnityBase server require authorization

clientRequest : ClientRequest instance #

Internal instance of HTTP client

encryptContent : Boolean instance #

Is server require content encryption

onRequestAuthParams : function instance #

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 : string instance #

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

serverCertificate : Boolean instance #

base64 encoded server certificate used for cryptographic operation

servicePath : String instance #

Root path to all application-level method

sessionKeyLifeTime : Number instance #

Lifetime (in second) of session encryption

_domain : UBDomain inner #

Methods

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

Perform get request to endpoint with optional URLParams.

getAppInfo()→Object instance #

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

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

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

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

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


 //Retrieve content of document as ArrayBuffer and bypass cache
 let frmContent = conn.getDocument({
     entity:'ubm_form',
     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

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

  • 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)→UBDomain instance #

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

isAuthorized()→boolean instance #

Check is current connection already perform authentication request

logout() instance #

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', values: {nameVal: 'admin'}
     });

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: values: }, or whereList {condition1: {expression: condition: values: }, condition2: {}, ....}

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

Shortcut method to perform authorized POST request to application we connected

query(ubq : Object)→Object | Array instance #

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

Repository(entityName : String)→ServerRepository instance #

Create a new instance of repository

Arguments info:

  • entityName: String

    name of Entity we create for

run(request : ubRequest)→Object instance deprecated #

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

runCustom()→* instance #

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

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

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

Examples

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

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:

 $App.connection.userData('lang');
 // or the same but dedicated alias
 $App.connection.userLang()

Arguments info:

userLang()→String instance #

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

userLogin()→String instance #

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

xhr(options : Object)→ArrayBuffer | Object | String | <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.

Examples

    
        conn.xhr({
     endpoint: 'runSQL',
     URLParams: {CONNECTION: 'dba'},
     data: 'DROP SCHEMA IF EXISTS ub_autotest CASCADE; DROP USER IF EXISTS ub_autotest;'
 });