@sap/xsodata/lib/utils/typeConverter.js

Expose data from a HANA database as OData V2 service with help of .xsodata files.

'use strict';

//Include
const dbToJson = require('./typeConverters/dbToJson').dbToJson;
const dbToXml = require('./typeConverters/dbToXml').dbToXml;
const dbToUri = require('./typeConverters/dbToUri').dbToUri;
const jsonToDb = require('./typeConverters/jsonToDb').jsonToDb;
const uriToDb = require('./typeConverters/uriToDb').uriToDb;
const xmlValueToOdataJson =
    require('./typeConverters/xmlValueToJson').xmlValueToODataJson;
const XsODataTypeError = require('./errors/typeError');

exports.converterFunctions = {
    dbNameToUri: dbToUri,
    dbNameToXmlPayload: dbToXml,
    dbNameToJsonPayload: dbToJson,
    jsonPayloadToDbName: jsonToDb,
    uriPayloadToDbName: uriToDb,
    xmlValueToODataJson: xmlValueToOdataJson,
};

exports.serializeDbValueToUriLiteral = function (value, propertyInfo) {
    const dbTypeName = propertyInfo.DATA_TYPE_NAME;
    return exports.converterFunctions.dbNameToUri[dbTypeName](value);
};

/**
 * Returns the corresponding Xml value for given json payload value.
 *
 * The propertyInfo object hold metadata information about the provided
 * value like the and MUST HAVE .DATA_TYPE_NAME field which contains the
 * db field declaration like "NVARCHAR"
 *
 * @throws {XsODataTypeError} Throws XsODataTypeError on invalid value
 * @param value {String | Number} Value to convert
 * @param propertyInfo {Object} Metadata object describing value parameter
 * @returns {string|number|boolean} Corresponding DbJson value
 */
exports.serializeXmlValueToODataJsonValue = function (value, propertyInfo) {
    const dbTypeName = propertyInfo.DATA_TYPE_NAME;
    const edmTypeName = dbTypeNameToODataTypeName[dbTypeName];

    /*jshint eqnull:true */
    if (edmTypeName == null) {
        throw new XsODataTypeError(
            'Can not find edm type for db type name ' + dbTypeName,
            propertyInfo
        );
    }

    const convert = exports.converterFunctions.xmlValueToODataJson[edmTypeName];
    if (typeof convert !== 'function') {
        throw new Error(
            'Converter function for ' +
                edmTypeName +
                '(dbTypeName: ' +
                dbTypeName +
                ') could not be found!'
        );
    }
    return convert(value, dbTypeName);
};

//Supported OData types
exports.oDataTypeIDs = [
    //order is important
    'Edm.Time', //  0
    'Edm.DateTime', //  1
    'Edm.Byte', //  2
    'Edm.Int16', //  3
    'Edm.Int32', //  4
    'Edm.Int64', //  5
    'Edm.Decimal', //  6
    'Edm.Single', //  7
    'Edm.Double', //  8
    'Edm.String', //  9
    'Edm.Binary', // 10
    'Edm.Guid', // 11
];

const conversionODataTypeNameToODataTypeID = {
    'Edm.Time': 0,
    'Edm.DateTime': 1,
    'Edm.Byte': 2,
    'Edm.Int16': 3,
    'Edm.Int32': 4,
    'Edm.Int64': 5,
    'Edm.Decimal': 6,
    'Edm.Single': 7,
    'Edm.Double': 8,
    'Edm.String': 9,
    'Edm.Binary': 10,
    'Edm.Guid': 11,
};

const dbTypeNameToODataTypeName = {
    DATE: 'Edm.DateTime',
    DAYDATE: 'Edm.DateTime',
    TIME: 'Edm.Time',
    SECONDTIME: 'Edm.Time',
    SECONDDATE: 'Edm.DateTime',
    TIMESTAMP: 'Edm.DateTime',
    TINYINT: 'Edm.Byte',
    SMALLINT: 'Edm.Int16',
    INTEGER: 'Edm.Int32',
    BIGINT: 'Edm.Int64', //l
    SMALLDECIMAL: 'Edm.Decimal', //m
    DECIMAL: 'Edm.Decimal', //m
    REAL: 'Edm.Single', //f
    DOUBLE: 'Edm.Double', //d
    FLOAT: 'Edm.Single', //d
    VARCHAR: 'Edm.String',
    NVARCHAR: 'Edm.String',
    ALPHANUM: 'Edm.String',
    SHORTTEXT: 'Edm.String',
    CHAR: 'Edm.String',
    NCHAR: 'Edm.String',
    BLOB: 'Edm.Binary',
    CLOB: 'Edm.String',
    NCLOB: 'Edm.String',
    BINARY: 'Edm.Binary',
    VARBINARY: 'Edm.Binary',
    LONGDATE: 'Edm.DateTime',
};

exports.dbTypeNameToODataTypeName = dbTypeNameToODataTypeName;

function oDataTypeNameToODataTypeID(oDataTypeName) {
    const tmp = conversionODataTypeNameToODataTypeID[oDataTypeName];
    if (tmp !== undefined) {
        return tmp;
    }
    throw new XsODataTypeError('invalid ODataType name: ' + oDataTypeName);
}

const _to_ID = oDataTypeNameToODataTypeID;
const conversionDbTypeNameToODataTypeID = {
    DATE: _to_ID('Edm.DateTime'),
    DAYDATE: _to_ID('Edm.DateTime'), // new
    TIME: _to_ID('Edm.Time'),
    SECONDTIME: _to_ID('Edm.Time'), // new
    SECONDDATE: _to_ID('Edm.DateTime'),
    TIMESTAMP: _to_ID('Edm.DateTime'),
    TINYINT: _to_ID('Edm.Byte'),
    SMALLINT: _to_ID('Edm.Int16'),
    INTEGER: _to_ID('Edm.Int32'),
    BIGINT: _to_ID('Edm.Int64'),
    SMALLDECIMAL: _to_ID('Edm.Decimal'),
    DECIMAL: _to_ID('Edm.Decimal'),
    REAL: _to_ID('Edm.Single'),
    DOUBLE: _to_ID('Edm.Double'),
    FLOAT: _to_ID('Edm.Single'),
    VARCHAR: _to_ID('Edm.String'),
    NVARCHAR: _to_ID('Edm.String'),
    ALPHANUM: _to_ID('Edm.String'),
    SHORTTEXT: _to_ID('Edm.String'),
    CHAR: _to_ID('Edm.String'),
    NCHAR: _to_ID('Edm.String'),
    BLOB: _to_ID('Edm.Binary'),
    CLOB: _to_ID('Edm.String'),
    NCLOB: _to_ID('Edm.String'),
    BINARY: _to_ID('Edm.Binary'),
    VARBINARY: _to_ID('Edm.Binary'),
    LONGDATE: _to_ID('Edm.DateTime'),
};

function dbTypeNameToODataTypeID(dbTypeName) {
    //TYPE_ID seem is not unique

    const tmp = conversionDbTypeNameToODataTypeID[dbTypeName];

    if (tmp !== undefined) {
        return tmp;
    }
    throw new XsODataTypeError('invalid dbTypeName name: ' + dbTypeName);
}

exports.dbTypeNameToODataTypeID = dbTypeNameToODataTypeID;