@adobe/acc-js-sdk 1.0.6 → 1.0.9

package/src/campaign.js

@@ -37,6 +37,7 @@ const { Util } = require("./util.js");
   static SOAP_UNKNOWN_METHOD(schema, method, details)     { return new CampaignException(undefined, 400, 16384, `SDK-000009 Unknown method '${method}' of schema '${schema}'`, details); }
   static NOT_LOGGED_IN(call, details)                     { return new CampaignException(     call, 400, 16384, `SDK-000010 Cannot call API because client is not logged in`, details); }
   static DECRYPT_ERROR(details)                           { return new CampaignException(undefined, 400, 16384, `SDK-000011 "Cannot decrypt password: password marker is missing`, details); }
+  static SESSION_EXPIRED()                                { return new CampaignException(undefined, 401, 16384, `SDK-000012 "Session has expired or is invalid. Please reconnect.`); }
   
 
   /**
@@ -223,6 +224,9 @@ function makeCampaignException(call, err) {
       faultString = err.data;
       details = undefined;
     }
+    // Session expiration case must return a 401
+    if (err.data && err.data.indexOf(`XSV-350008`) != -1)
+        return CampaignException.SESSION_EXPIRED();
     return new CampaignException(call, err.statusCode, "", faultString, details, err);
   }
 

package/src/client.js

@@ -225,16 +225,16 @@ class Credentials {
 
 /**
  * @typedef {Object} ConnectionOptions
- * @property {string} representation - the representation to use, i.e. "SimpleJson" (the default), "BadgerFish", or "xml"
- * @property {boolean} rememberMe - The Campaign `rememberMe` attribute which can be used to extend the lifetime of session tokens
- * @property {number} entityCacheTTL - The TTL (in milliseconds) after which cached XTK entities expire. Defaults to 5 minutes
- * @property {number} methodCacheTTL - The TTL (in milliseconds) after which cached XTK methods expire. Defaults to 5 minutes
- * @property {number} optionCacheTTL - The TTL (in milliseconds) after which cached XTK options expire. Defaults to 5 minutes
- * @property {boolean} traceAPICalls - Activates the tracing of all API calls
- * @property {Utils.Transport} transport - Overrides the transport (i.e. HTTP layer)
- * @property {boolean} noStorage - De-activate using of local storage. By default, and in addition to in-memory cache, entities, methods, and options are also persisted in local storage if there is one.
- * @property {Storage} storage - Overrides the storage interface (i.e. LocalStorage)
- * @memberOf Campaign
+    * @property {string} representation - the representation to use, i.e. "SimpleJson" (the default), "BadgerFish", or "xml"
+    * @property {boolean} rememberMe - The Campaign `rememberMe` attribute which can be used to extend the lifetime of session tokens
+    * @property {number} entityCacheTTL - The TTL (in milliseconds) after which cached XTK entities expire. Defaults to 5 minutes
+    * @property {number} methodCacheTTL - The TTL (in milliseconds) after which cached XTK methods expire. Defaults to 5 minutes
+    * @property {number} optionCacheTTL - The TTL (in milliseconds) after which cached XTK options expire. Defaults to 5 minutes
+    * @property {boolean} traceAPICalls - Activates the tracing of all API calls
+    * @property {Utils.Transport} transport - Overrides the transport (i.e. HTTP layer)
+    * @property {boolean} noStorage - De-activate using of local storage. By default, and in addition to in-memory cache, entities, methods, and options are also persisted in local storage if there is one.
+    * @property {Storage} storage - Overrides the storage interface (i.e. LocalStorage)
+    * @memberOf Campaign
  */
  
 
@@ -296,6 +296,7 @@ class ConnectionParameters {
             }    
         }
         this._options._storage = storage;
+        this._options.refreshClient = options.refreshClient;
     }
 
     /**
@@ -478,6 +479,7 @@ class Client {
         this._transport = connectionParameters._options.transport;
         this._traceAPICalls = connectionParameters._options.traceAPICalls;
         this._observers = [];
+        this._refreshClient = connectionParameters._options.refreshClient;
 
         // expose utilities
 
@@ -676,6 +678,38 @@ class Client {
         return soapCall;
     }
 
+    /**
+     * Retry a a SOAP call
+     *
+     * @private
+     * @return {SOAP.SoapMethodCall} a SoapMethodCall to retry
+     * parameters should be set
+     */
+    async _retrySoapCall(soapCall) {
+        soapCall.retry = false;
+        var newClient = await this._refreshClient(this); 
+        soapCall.finalize(newClient._soapEndPoint(), newClient);
+        if (this._traceAPICalls) {
+            const safeCallData = Util.trim(soapCall.request.data);
+            console.log(`RETRY SOAP//request ${safeCallData}`);
+        }
+        await soapCall.execute();
+        if (this._traceAPICalls) {
+            const safeCallResponse = Util.trim(soapCall.response);
+            console.log(`SOAP//response ${safeCallResponse}`);
+        }
+        return;
+    }
+
+    /**
+     *  SOAP Endpoint
+     *
+     * @private
+     * @return {string} soap call End point
+     */
+    _soapEndPoint() {
+        return this._connectionParameters._endpoint + "/nl/jsp/soaprouter.jsp";
+    }
     /**
      * After a SOAP method call has been prepared with '_prepareSoapCall', and parameters have been added,
      * this function actually executes the SOAP call
@@ -687,8 +721,7 @@ class Client {
         const that = this;
         if (soapCall.requiresLogon() && !that.isLogged())
             throw CampaignException.NOT_LOGGED_IN(soapCall, `Cannot execute SOAP call ${soapCall.urn}#${soapCall.methodName}: you are not logged in. Use the Logon function first`);
-        var soapEndpoint = that._connectionParameters._endpoint + "/nl/jsp/soaprouter.jsp";
-        soapCall.finalize(soapEndpoint);
+        soapCall.finalize(this._soapEndPoint());
         
         const safeCallData = Util.trim(soapCall.request.data);
         if (that._traceAPICalls)
@@ -707,7 +740,12 @@ class Client {
                 if (that._traceAPICalls)
                     console.log(`SOAP//failure ${ex.toString()}`);
                 that._notifyObservers((observer) => observer.onSOAPCallFailure && observer.onSOAPCallFailure(soapCall, ex) );
-                return Promise.reject(ex);
+                // Call session expiration callback in case of 401
+                if (ex.statusCode == 401 && that._refreshClient && soapCall.retry) {
+                    return this._retrySoapCall(soapCall);
+                }
+                else
+                    return Promise.reject(ex);
             });
     }
 
@@ -745,6 +783,8 @@ class Client {
         }
         else if (credentials._type == "UserPassword" || credentials._type == "BearerToken") {
             const soapCall = that._prepareSoapCall("xtk:session", credentials._type === "UserPassword" ? "Logon" : "BearerTokenLogon");
+            // No retry for logon SOAP methods
+            soapCall.retry = false;
             if (credentials._type == "UserPassword") {
                 const user = credentials._getUser();
                 const password = credentials._getPassword();
@@ -813,7 +853,6 @@ class Client {
     logoff() {
         var that = this;
         if (!that.isLogged()) return;
-        
         const credentials = this._connectionParameters._credentials;
         if (credentials._type != "SessionToken" && credentials._type != "AnonymousUser") {
             var soapCall = that._prepareSoapCall("xtk:session", "Logoff");
@@ -1063,6 +1102,14 @@ class Client {
         var urn = that._methodCache.getSoapUrn(schemaId, methodName);
         var soapCall = that._prepareSoapCall(urn, methodName);
 
+        // If method is called with one parameter which is a function, then we assume it's a hook: the function will return
+        // the actual list of parameters
+        let isfunc = parameters && typeof parameters === "function";
+        if (!isfunc && parameters && parameters.length >= 1 && typeof parameters[0] === "function")
+            isfunc = true;
+        if (isfunc)
+            parameters = parameters[0](method, callContext);
+
         const isStatic = DomUtil.getAttributeAsBoolean(method, "static");
         var object = callContext.object;
         if (!isStatic) {

package/src/domUtil.js

@@ -19,7 +19,7 @@ var JSDOM;
 
 /* istanbul ignore else */
 if (!Util.isBrowser()) {
-  JSDOM = require("jsdom").JSDOM;
+    JSDOM = require("jsdom").JSDOM;
 }
 
 /**********************************************************************************
@@ -40,7 +40,7 @@ else {
         return new XMLSerializer().serializeToString(dom);
     };
   };
-
+  
   JSDOM = jsdom;
 }
 
@@ -562,7 +562,10 @@ class XPathElement {
 class XPath {
 
     constructor(path) {
-        this._path = (path || "").trim();
+        path = (path || "").trim();
+        if (path && path.startsWith("[") && path.endsWith("]"))
+            path = path.substring(1, path.length - 1).trim();
+        this._path = path;
     }
 
     /**

package/src/entityAccessor.js

@@ -69,7 +69,7 @@ class EntityAccessor {
      */
     static getAttributeAsString(entity, name) {
         if (entity.documentElement) entity = entity.documentElement;
-        if (entity.insertAdjacentElement)
+        if (entity.nodeType && entity.tagName)
             return DomUtil.getAttributeAsString(entity, name);
         else if (entity instanceof BadgerFishObject)
             return XtkCaster.asString(entity[`@${name}`]);
@@ -95,7 +95,7 @@ class EntityAccessor {
      */
     static getAttributeAsLong(entity, name) {
         if (entity.documentElement) entity = entity.documentElement;
-        if (entity.insertAdjacentElement)
+        if (entity.nodeType && entity.tagName)
             return DomUtil.getAttributeAsLong(entity, name);
         else if (entity instanceof BadgerFishObject)
             return XtkCaster.asLong(entity[`@${name}`]);
@@ -121,7 +121,7 @@ class EntityAccessor {
      */
     static getAttributeAsBoolean(entity, name) {
         if (entity.documentElement) entity = entity.documentElement;
-        if (entity.insertAdjacentElement)
+        if (entity.nodeType && entity.tagName)
             return DomUtil.getAttributeAsBoolean(entity, name);
         else if (entity instanceof BadgerFishObject)
             return XtkCaster.asBoolean(entity[`@${name}`]);
@@ -148,7 +148,7 @@ class EntityAccessor {
      */
     static getChildElements(entity, tagName) {
         if (entity.documentElement) entity = entity.documentElement;
-        if (entity.insertAdjacentElement) {
+        if (entity.nodeType && entity.tagName) {
             const elements = [];
             var child = DomUtil.getFirstChildElement(entity);
             while (child) {
@@ -184,7 +184,7 @@ class EntityAccessor {
      */
     static getElement(entity, tagName) {
         if (entity.documentElement) entity = entity.documentElement;
-        if (entity.insertAdjacentElement) {
+        if (entity.nodeType && entity.tagName) {
             var child = DomUtil.getFirstChildElement(entity);
             while (child) {
                 if (tagName == child.tagName)

package/src/index.js

@@ -23,6 +23,7 @@ const DomUtil = require('./domUtil.js').DomUtil;
 const XtkCaster = require('./xtkCaster.js').XtkCaster;
 const { Client, Credentials, ConnectionParameters } = require('./client.js');
 const request = require('./transport.js').request;
+const { TestUtil } = require('./testUtil');
 
 /**
  * Get/Set the transport function (defaults to Axios). This function is used for testing / mocking the transport layer.
@@ -127,8 +128,7 @@ class SDK {
      * @example
      * expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
      */
-    escapeXtk(p1, ...p2)
-    {
+    escapeXtk(p1, ...p2) {
         // first syntax: only one parameter which is a string => returns the escaped string.
         // that's how the Campaign function in common.js behaves
         if (p1 === undefined || p1 === null)
@@ -147,9 +147,65 @@ class SDK {
         }
         return str;
     }
+
+    /**
+     * Escapes a string of characters so that in can be used in a SQL like statement.
+     * @param {string | any} text the text to escape. If not a string, it will be casted to a xtk string first
+     * @param {boolean?} escapeXtkParams indicates that the escape text contains Xtk parameters (using $ character)
+     * @returns the escaped string
+     */
+    escapeForLike(text, escapeXtkParams) {
+        text = XtkCaster.asString(text);
+        if (!text) return "";    
+        text = text.replace(/\\/g, "\\\\")
+                    .replace(/'/g,  "\\'")
+                    .replace(/%/g,  "\\%")
+                    .replace(/_/g,  "\\_");
+        if (escapeXtkParams)
+            text = text.replace(/\$/g, "' + Char('36') + '");
+      return text;
+    }
+
+    /**
+     * Expands an xpath, i.e. enclose it with [..] brackets if necessary
+     * @param {string} xpath the xpath
+     * @returns {string} the expanded xpath
+     */
+    expandXPath(xpath) {
+        if (!xpath) return xpath;
+        if (xpath.startsWith("[") && xpath.endsWith("]"))
+            return xpath;
+        if (xpath.indexOf('/') === -1 && xpath.indexOf('-') === -1 && xpath.indexOf(':') === -1)
+            return xpath;
+        return `[${xpath}]`;
+    }
+
+    unexpandXPath(xpath) {
+        if (!xpath) return xpath;
+        if (xpath.startsWith("[") && xpath.endsWith("]"))
+            return xpath.substring(1, xpath.length - 1);
+        return xpath;
+    }
+
+    /**
+     * Convert a javascript value into an xtk constant with proper quoting
+     * @param {any} value the value to convert
+     * @param {string} type the xtk type
+     * @returns 
+     */
+    xtkConstText(value, type) {
+        if (!type || type === 'string' || type === 'memo') {
+            return sdk.escapeXtk(XtkCaster.asString(value));
+        }
+        const constText = XtkCaster.asString(XtkCaster.as(value, type));
+        if (XtkCaster.isTimeType(type))
+            return `#${constText}#`;
+        return constText;
+    }
 }
 
 const sdk = new SDK();
+sdk.TestUtil = TestUtil;
 sdk.XtkCaster = XtkCaster;
 sdk.Credentials = Credentials;
 sdk.DomUtil = DomUtil;

package/src/soap.js

@@ -93,6 +93,8 @@ class SoapMethodCall {
         // Soap calls marked as internal are calls performed by the framework internally
         // (such as GetEntityIfMoreRecent calls needed to lookup schemas)
         this.internal = false;
+        // Enable soap retry
+        this.retry = true;
 
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
@@ -151,22 +153,6 @@ class SoapMethodCall {
         this._method.setAttribute(`xmlns:m`, urnPath);
         this._method.setAttribute(`SOAP-ENV:encodingStyle`, encoding);
         this._data.appendChild(this._method);
-
-        if (this._sessionToken) {
-            const cookieHeader = this._doc.createElement("Cookie");
-            cookieHeader.textContent = `__sessiontoken=${this._sessionToken}`;
-            this._header.appendChild(cookieHeader);
-        }
-
-        const securityTokenHeader = this._doc.createElement("X-Security-Token");
-        securityTokenHeader.textContent = this._securityToken;
-        this._header.appendChild(securityTokenHeader);
-
-        // Always write a sessiontoken element as the first parameter. Even when using SecurityToken authentication
-        // and when the session token is actually passed implicitely as a cookie, one must write a sessiontoken
-        // element. If not, authentication will fail because the first parameter is interpreted as the "authentication mode"
-        // and eventually passed as the first parameter of CXtkLocalSessionPart::GetXtkSecurity
-        this.writeString("sessiontoken", this._sessionToken);
     }
 
     /**
@@ -542,12 +528,50 @@ class SoapMethodCall {
             options.headers['User-Agent'] = this._userAgentString;
         return options;
     }
-
+    
     /**
      * Finalize a SOAP call just before sending
      * @param {string} url the endpoint (/nl/jsp/soaprouter.jsp)
+     * @param {client.Client} sdk client (optional)
      */
-    finalize(url) {
+    finalize(url, client) {
+        if (client) {
+            this._sessionToken = client._sessionToken;
+            this._securityToken = client._securityToken;
+        }
+
+        var cookieHeader = DomUtil.findElement(this._header, "Cookie");
+        if (this._sessionToken) {
+            if (!cookieHeader) {
+                cookieHeader = this._doc.createElement("Cookie");
+                this._header.appendChild(cookieHeader);
+            }
+            cookieHeader.textContent = `__sessiontoken=${this._sessionToken}`;
+        } else if (cookieHeader) {
+            cookieHeader.remove();
+        }
+
+        var securityTokenHeader = DomUtil.findElement(this._header, "X-Security-Token");
+        if (!securityTokenHeader) {
+            securityTokenHeader = this._doc.createElement("X-Security-Token");
+            this._header.appendChild(securityTokenHeader);
+        }
+        securityTokenHeader.textContent = this._securityToken;
+
+        // Always write a sessiontoken element as the first parameter. Even when using SecurityToken authentication
+        // and when the session token is actually passed implicitely as a cookie, one must write a sessiontoken
+        // element. If not, authentication will fail because the first parameter is interpreted as the "authentication mode"
+        // and eventually passed as the first parameter of CXtkLocalSessionPart::GetXtkSecurity
+        var sessionTokenElem = DomUtil.findElement(this._method, "sessiontoken");
+        if (sessionTokenElem) {
+            sessionTokenElem.textContent = this._sessionToken;
+        } else {
+            sessionTokenElem = this._doc.createElement("sessiontoken");
+            sessionTokenElem.setAttribute("xsi:type", "xsd:string");
+            // sessionTokenElem.setAttribute("SOAP-ENV:encodingStyle", SOAP_ENCODING_NATIVE);
+            sessionTokenElem.textContent = this._sessionToken;
+            this._method.prepend(sessionTokenElem);
+        }
         const options = this._createHTTPRequest(url);
         // Prepare request and empty response objects
         this.request = options;
@@ -565,6 +589,8 @@ class SoapMethodCall {
         const that = this;
         const promise = this._transport(this.request);
         return promise.then(function(body) {
+            if (body.indexOf(`XSV-350008`) != -1)
+                throw CampaignException.SESSION_EXPIRED();
             that.response = body;
             // Response is a serialized XML document with the following structure
             //

package/src/testUtil.js

@@ -0,0 +1,47 @@
+const { DomUtil } = require("./domUtil");
+
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+(function() {
+"use strict";    
+  
+const { newSchema } = require("./application");
+
+/**********************************************************************************
+ * 
+ * Utilities for testing
+ * 
+ *********************************************************************************/
+
+/**
+ * @namespace Utils
+ */
+
+/**
+ * @memberof Utils
+ * @class
+ * @constructor
+ */
+class TestUtil {
+
+  static newSchema(xml) {
+    if (typeof xml === "string") 
+      xml = DomUtil.parse(xml);
+    return newSchema(xml);
+  }
+}
+
+
+// Public expots
+exports.TestUtil = TestUtil;
+
+})();

package/src/xtkCaster.js

@@ -12,6 +12,8 @@ governing permissions and limitations under the License.
 (function() {
 "use strict";    
 
+const { Util } = require('./util.js');
+
 /**********************************************************************************
  * 
  * Helper class to cast values to and from their Xtk versions
@@ -37,11 +39,15 @@ governing permissions and limitations under the License.
 |     Xtk type |    | JS type | Comment |
 | ------------ |----|-------- | --- |
 |       string |  6 |  string | never null, defaults to "" |
-|         memo | 12 |  string |
-|        CDATA | 13 |  string |
+|         memo | 12 |  string | large strings. Never null, defaults to ""
+|        CDATA | 13 |  string | string in the CDATA section of an XML document. Never null, defaults to ""
+|         uuid |    |  string |
+|         blob |    |  string | 
+|         html |    |  string | 
 |         byte |  1 |  number | signed integer in the [-128, 128[ range. Never null, defaults to 0 |
 |        short |  2 |  number | signed 16 bits integer in the [-32768, 32768[ range. Never null, defaults to 0 |
 |         long |  3 |  number | signed 32 bits integer. Never null, defaults to 0 |
+|          int |    |  number | signed 32 bits integer. Never null, defaults to 0 |
 |        int64 |    | string  | signed 64 bits integer. As JavaScript handles all numbers as doubles, it's not possible to properly represent an int64 as a number, and it's therefore represented as a string.
 |        float |  4 |  number | single-percision numeric value. Never null, defaults to 0 |
 |       double |  5 |  number | single-percision numeric value. Never null, defaults to 0 |
@@ -49,10 +55,11 @@ governing permissions and limitations under the License.
 |   datetimetz |    |         | |
 | datetimenotz |    |         | |
 |         date | 10 |    Date | UTC timestamp with day precision. Can be null |
+|     timespan | 14 |  number | A timespan, in seconds
 |      boolean | 15 | boolean | boolean value, defaultint to false. Cannot be null |
-|     timespan |    |         | |
+|        array |    |   Array | a array or a collection
 
- * @typedef {(0|''|6|'string'|'int64'|12|13|'memo'|'CDATA'|1|'byte'|2|'short'|3|'long'|15|'boolean'|4|5|'float'|'double'|7|'datetime'|'datetimetz'|'datetimenotz'|10|'date')} XtkType
+ * @typedef {(0|''|6|'string'|'int64'|12|13|'memo'|'CDATA'|1|'byte'|2|'short'|3|'long'|15|'boolean'|4|5|'float'|'double'|7|'datetime'|'datetimetz'|'datetimenotz'|10|'date'|14|'timespan'|'array')} XtkType
  * @memberof Campaign
  */
 
@@ -85,10 +92,13 @@ class XtkCaster {
                 return null;
             case 6:             // FIELD_SZ
             case "string":
+            case "uuid":
             case "int64":
                 return "stringValue";
             case 12:            // FIELD_MEMO
             case 13:            // FIELD_MEMOSHORT
+            case "blob":
+            case "html":
             case "memo":
             case "CDATA": 
                     return "memoValue";
@@ -97,8 +107,10 @@ class XtkCaster {
             case 2:             // FIELD_SHORT
             case "short": 
             case 3:             // FIELD_LONG
+            case "int":
             case "long":
-            case 15:            // FIELD_BOOLEAN
+            case "timespan":
+                case 15:            // FIELD_BOOLEAN
             case "boolean":
                     return "longValue";
             case 4:             // FIELD_FLOAT
@@ -137,6 +149,9 @@ class XtkCaster {
             case 13:            // FIELD_MEMOSHORT
             case "string":
             case "memo":
+            case "uuid":
+            case "blob":
+            case "html":
             case "CDATA": {
                 return this.asString(value);
             }
@@ -149,6 +164,7 @@ class XtkCaster {
                 return this.asShort(value);
             }
             case 3:             // FIELD_LONG
+            case "int":
             case "long": {
                 return this.asLong(value);
             }
@@ -175,6 +191,13 @@ class XtkCaster {
             case "date": {
                 return this.asDate(value);
             }
+            case "array": {
+                return this.asArray(value);
+            }
+            case 14:            // FIELD_TIMESPAN
+            case "timespan": {
+                return this.asTimespan(value);
+            }
             default: {
                 throw CampaignException.BAD_PARAMETER("type", type, `Cannot convert value type='${type}', value='${value}'`);
             }
@@ -318,6 +341,16 @@ class XtkCaster {
         return number;
     }
 
+    /**
+     * Convert a raw value into a timestamp (alias to the "asTimestamp" function)
+     * 
+     * @param {*} value is the raw value to convert
+     * @return {Date} the timestamp, possibly null
+     */
+     static asDatetime(value) {
+        return this.asTimestamp(value);
+    }
+
     /**
      * Convert a raw value into a timestamp
      * 
@@ -354,7 +387,7 @@ class XtkCaster {
     }
 
     /**
-     * Convert a raw value into a  date. This is a UTC timestamp where time fields are 0
+     * Convert a raw value into a date. This is a UTC timestamp where time fields are 0
      *
      * @param {*} value is the raw value to convert
      * @return {Date} a date
@@ -369,8 +402,49 @@ class XtkCaster {
         }
         return timestamp;
     }
+
+    /**
+     * Convert a raw value into an array (if it is not an array yet). Null and undefined will be
+     * converted into an empty array
+     *
+     * @param {*} value is the raw value to convert
+     * @return {Array} a array
+     */
+     static asArray(value) {
+        if (value === null || value === undefined) return [];
+        if (Util.isArray(value)) return value;
+        return [value];
+    }
+
+    /**
+     * Convert a raw value into a timespan, in seconds
+     * @param {*} value is the raw value to convert
+     * @returns is the time span, in seconds
+     */
+    static asTimespan(value) {
+        if (value === null || value === undefined) return 0;
+        if ((typeof value) == "string") value = value.trim();
+        if (value === "" || value === true || value === false) return 0;
+        if (value !== value || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) return 0;
+        // Number to timespan -> Consider as number of seconds
+        var timespan = XtkCaster.asLong(value);
+        return timespan;
+    }
+
+    static isTimeType(type) {
+        return type === "datetime" || type === "datetimetz" || type === "datetimenotz" || type === "timestamp" || type === "date" || type === "time" || type === "timespan" || type === 7 || type === 10 || type === 14;
+    }
+
+    static isStringType(type) {
+        return type === "string" || type === "memo" || type === 6 || type === 12 || type === 13 || type === "blob" || type === "html" || type === "CDATA";
+    }
+
+    static isNumericType(type) {
+        return type === "byte" || type === 1 || type === "short" || type === 2 || type === "int" || type === "long" || type === 3 || type === "float" || type === 4 || type === "double" || type === 5 || type === "timespan" || type === 14;
+    }
 }
 
+
 exports.XtkCaster = XtkCaster;
 
 })();