@jakub.knejzlik/ts-query-server/dist/client-timestream.js

TypeScript library for executing SQL queries built with ts-query across diverse server environments.

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueryRouterClientAWSTimestream = void 0;
const client_timestream_query_1 = require("@aws-sdk/client-timestream-query");
const ts_query_1 = require("@jakub.knejzlik/ts-query");
const client_1 = require("./client");
const timestreamQuery = new client_timestream_query_1.TimestreamQueryClient({ region: "eu-central-1" });
class CustomAWSTimestreamFlavor extends ts_query_1.AWSTimestreamFlavor {
    constructor(databaseName) {
        super();
        this.databaseName = databaseName;
    }
    escapeTable(table) {
        return `"${this.databaseName}"."${table}"`;
    }
}
class QueryRouterClientAWSTimestream extends client_1.QueryRouterClient {
    constructor(_a) {
        var { flavor } = _a, opts = __rest(_a, ["flavor"]);
        super(Object.assign({ flavor: flavor !== null && flavor !== void 0 ? flavor : new CustomAWSTimestreamFlavor(opts.databaseName) }, opts));
    }
    executeRawQueries(queries) {
        return Promise.all(queries.map((query) => queryTimestream(query)));
    }
}
exports.QueryRouterClientAWSTimestream = QueryRouterClientAWSTimestream;
function parseDatum(columnType, datum) {
    if (!datum.ScalarValue) {
        return null;
    }
    switch (columnType) {
        case "VARCHAR":
            return datum.ScalarValue;
        case "BIGINT":
            return parseInt(datum.ScalarValue);
        case "DOUBLE":
            return parseFloat(datum.ScalarValue);
        case "BOOLEAN":
            return datum.ScalarValue === "true";
        case "TIMESTAMP":
            return new Date(datum.ScalarValue);
        default:
            return datum.ScalarValue;
    }
}
async function queryTimestream(queryString) {
    try {
        const command = new client_timestream_query_1.QueryCommand({ QueryString: queryString });
        const response = await timestreamQuery.send(command);
        if (!response.Rows || !response.ColumnInfo) {
            throw new Error("Invalid response format");
        }
        // Extract column names and types from ColumnInfo
        const columnInfo = response.ColumnInfo;
        // Map rows to objects with column names as keys and properly typed values
        return response.Rows.map((row) => {
            var _a;
            const rowObject = {};
            (_a = row.Data) === null || _a === void 0 ? void 0 : _a.forEach((datum, index) => {
                var _a;
                const info = columnInfo[index];
                if (info.Name) {
                    rowObject[info.Name] = parseDatum((_a = info.Type) === null || _a === void 0 ? void 0 : _a.ScalarType, datum);
                }
            });
            return rowObject;
        });
    }
    catch (error) {
        console.error("Error querying Timestream:", error);
        throw error;
    }
}