@budibase/backend-core 2.27.4 → 2.27.5

package/dist/src/sql/sql.js

@@ -0,0 +1,752 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const knex_1 = require("knex");
+const dbCore = __importStar(require("../db"));
+const utils_1 = require("./utils");
+const sqlStatements_1 = require("./sqlStatements");
+const sqlTable_1 = __importDefault(require("./sqlTable"));
+const types_1 = require("@budibase/types");
+const environment_1 = __importDefault(require("../environment"));
+const shared_core_1 = require("@budibase/shared-core");
+const envLimit = environment_1.default.SQL_MAX_ROWS
+    ? parseInt(environment_1.default.SQL_MAX_ROWS)
+    : null;
+const BASE_LIMIT = envLimit || 5000;
+// these are invalid dates sent by the client, need to convert them to a real max date
+const MIN_ISO_DATE = "0000-00-00T00:00:00.000Z";
+const MAX_ISO_DATE = "9999-00-00T00:00:00.000Z";
+function likeKey(client, key) {
+    let start, end;
+    switch (client) {
+        case types_1.SqlClient.MY_SQL:
+            start = end = "`";
+            break;
+        case types_1.SqlClient.SQL_LITE:
+        case types_1.SqlClient.ORACLE:
+        case types_1.SqlClient.POSTGRES:
+            start = end = '"';
+            break;
+        case types_1.SqlClient.MS_SQL:
+            start = "[";
+            end = "]";
+            break;
+        default:
+            throw new Error("Unknown client generating like key");
+    }
+    const parts = key.split(".");
+    key = parts.map(part => `${start}${part}${end}`).join(".");
+    return key;
+}
+function parse(input) {
+    if (Array.isArray(input)) {
+        return JSON.stringify(input);
+    }
+    if (input == undefined) {
+        return null;
+    }
+    if (typeof input !== "string") {
+        return input;
+    }
+    if (input === MAX_ISO_DATE || input === MIN_ISO_DATE) {
+        return null;
+    }
+    if ((0, utils_1.isIsoDateString)(input)) {
+        return new Date(input.trim());
+    }
+    return input;
+}
+function parseBody(body) {
+    for (let [key, value] of Object.entries(body)) {
+        body[key] = parse(value);
+    }
+    return body;
+}
+function parseFilters(filters) {
+    if (!filters) {
+        return {};
+    }
+    for (let [key, value] of Object.entries(filters)) {
+        let parsed;
+        if (typeof value === "object") {
+            parsed = parseFilters(value);
+        }
+        else {
+            parsed = parse(value);
+        }
+        // @ts-ignore
+        filters[key] = parsed;
+    }
+    return filters;
+}
+function generateSelectStatement(json, knex) {
+    var _a;
+    const { resource, meta } = json;
+    if (!resource) {
+        return "*";
+    }
+    const schema = (_a = meta === null || meta === void 0 ? void 0 : meta.table) === null || _a === void 0 ? void 0 : _a.schema;
+    return resource.fields.map(field => {
+        const fieldNames = field.split(/\./g);
+        const tableName = fieldNames[0];
+        const columnName = fieldNames[1];
+        const columnSchema = schema === null || schema === void 0 ? void 0 : schema[columnName];
+        if (columnSchema && knex.client.config.client === types_1.SqlClient.POSTGRES) {
+            const externalType = schema[columnName].externalType;
+            if (externalType === null || externalType === void 0 ? void 0 : externalType.includes("money")) {
+                return knex.raw(`"${tableName}"."${columnName}"::money::numeric as "${field}"`);
+            }
+        }
+        if (knex.client.config.client === types_1.SqlClient.MS_SQL &&
+            (columnSchema === null || columnSchema === void 0 ? void 0 : columnSchema.type) === types_1.FieldType.DATETIME &&
+            columnSchema.timeOnly) {
+            // Time gets returned as timestamp from mssql, not matching the expected HH:mm format
+            return knex.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
+        }
+        return `${field} as ${field}`;
+    });
+}
+function getTableName(table) {
+    // SQS uses the table ID rather than the table name
+    if ((table === null || table === void 0 ? void 0 : table.sourceType) === types_1.TableSourceType.INTERNAL ||
+        (table === null || table === void 0 ? void 0 : table.sourceId) === types_1.INTERNAL_TABLE_SOURCE_ID) {
+        return table === null || table === void 0 ? void 0 : table._id;
+    }
+    else {
+        return table === null || table === void 0 ? void 0 : table.name;
+    }
+}
+function convertBooleans(query) {
+    if (Array.isArray(query)) {
+        return query.map((q) => convertBooleans(q));
+    }
+    else {
+        if (query.bindings) {
+            query.bindings = query.bindings.map(binding => {
+                if (typeof binding === "boolean") {
+                    return binding ? 1 : 0;
+                }
+                return binding;
+            });
+        }
+    }
+    return query;
+}
+class InternalBuilder {
+    constructor(client) {
+        this.client = client;
+    }
+    // right now we only do filters on the specific table being queried
+    addFilters(query, filters, table, opts) {
+        var _a;
+        if (!filters) {
+            return query;
+        }
+        filters = parseFilters(filters);
+        // if all or specified in filters, then everything is an or
+        const allOr = filters.allOr;
+        const sqlStatements = new sqlStatements_1.SqlStatements(this.client, table, { allOr });
+        const tableName = this.client === types_1.SqlClient.SQL_LITE ? table._id : table.name;
+        function getTableAlias(name) {
+            var _a;
+            const alias = (_a = opts.aliases) === null || _a === void 0 ? void 0 : _a[name];
+            return alias || name;
+        }
+        function iterate(structure, fn) {
+            for (let [key, value] of Object.entries(structure)) {
+                const updatedKey = dbCore.removeKeyNumbering(key);
+                const isRelationshipField = updatedKey.includes(".");
+                if (!opts.relationship && !isRelationshipField) {
+                    const alias = getTableAlias(tableName);
+                    fn(alias ? `${alias}.${updatedKey}` : updatedKey, value);
+                }
+                if (opts.relationship && isRelationshipField) {
+                    const [filterTableName, property] = updatedKey.split(".");
+                    const alias = getTableAlias(filterTableName);
+                    fn(alias ? `${alias}.${property}` : property, value);
+                }
+            }
+        }
+        const like = (key, value) => {
+            const fuzzyOr = filters === null || filters === void 0 ? void 0 : filters.fuzzyOr;
+            const fnc = fuzzyOr || allOr ? "orWhere" : "where";
+            // postgres supports ilike, nothing else does
+            if (this.client === types_1.SqlClient.POSTGRES) {
+                query = query[fnc](key, "ilike", `%${value}%`);
+            }
+            else {
+                const rawFnc = `${fnc}Raw`;
+                // @ts-ignore
+                query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
+                    `%${value.toLowerCase()}%`,
+                ]);
+            }
+        };
+        const contains = (mode, any = false) => {
+            const rawFnc = allOr ? "orWhereRaw" : "whereRaw";
+            const not = mode === (filters === null || filters === void 0 ? void 0 : filters.notContains) ? "NOT " : "";
+            function stringifyArray(value, quoteStyle = '"') {
+                for (let i in value) {
+                    if (typeof value[i] === "string") {
+                        value[i] = `${quoteStyle}${value[i]}${quoteStyle}`;
+                    }
+                }
+                return `[${value.join(",")}]`;
+            }
+            if (this.client === types_1.SqlClient.POSTGRES) {
+                iterate(mode, (key, value) => {
+                    const wrap = any ? "" : "'";
+                    const op = any ? "\\?| array" : "@>";
+                    const fieldNames = key.split(/\./g);
+                    const table = fieldNames[0];
+                    const col = fieldNames[1];
+                    query = query[rawFnc](`${not}COALESCE("${table}"."${col}"::jsonb ${op} ${wrap}${stringifyArray(value, any ? "'" : '"')}${wrap}, FALSE)`);
+                });
+            }
+            else if (this.client === types_1.SqlClient.MY_SQL) {
+                const jsonFnc = any ? "JSON_OVERLAPS" : "JSON_CONTAINS";
+                iterate(mode, (key, value) => {
+                    query = query[rawFnc](`${not}COALESCE(${jsonFnc}(${key}, '${stringifyArray(value)}'), FALSE)`);
+                });
+            }
+            else {
+                const andOr = mode === (filters === null || filters === void 0 ? void 0 : filters.containsAny) ? " OR " : " AND ";
+                iterate(mode, (key, value) => {
+                    let statement = "";
+                    for (let i in value) {
+                        if (typeof value[i] === "string") {
+                            value[i] = `%"${value[i].toLowerCase()}"%`;
+                        }
+                        else {
+                            value[i] = `%${value[i]}%`;
+                        }
+                        statement +=
+                            (statement ? andOr : "") +
+                                `COALESCE(LOWER(${likeKey(this.client, key)}), '') LIKE ?`;
+                    }
+                    if (statement === "") {
+                        return;
+                    }
+                    // @ts-ignore
+                    query = query[rawFnc](`${not}(${statement})`, value);
+                });
+            }
+        };
+        if (filters.oneOf) {
+            iterate(filters.oneOf, (key, array) => {
+                const fnc = allOr ? "orWhereIn" : "whereIn";
+                query = query[fnc](key, Array.isArray(array) ? array : [array]);
+            });
+        }
+        if (filters.string) {
+            iterate(filters.string, (key, value) => {
+                const fnc = allOr ? "orWhere" : "where";
+                // postgres supports ilike, nothing else does
+                if (this.client === types_1.SqlClient.POSTGRES) {
+                    query = query[fnc](key, "ilike", `${value}%`);
+                }
+                else {
+                    const rawFnc = `${fnc}Raw`;
+                    // @ts-ignore
+                    query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
+                        `${value.toLowerCase()}%`,
+                    ]);
+                }
+            });
+        }
+        if (filters.fuzzy) {
+            iterate(filters.fuzzy, like);
+        }
+        if (filters.range) {
+            iterate(filters.range, (key, value) => {
+                const isEmptyObject = (val) => {
+                    return (val &&
+                        Object.keys(val).length === 0 &&
+                        Object.getPrototypeOf(val) === Object.prototype);
+                };
+                if (isEmptyObject(value.low)) {
+                    value.low = "";
+                }
+                if (isEmptyObject(value.high)) {
+                    value.high = "";
+                }
+                const lowValid = (0, utils_1.isValidFilter)(value.low), highValid = (0, utils_1.isValidFilter)(value.high);
+                if (lowValid && highValid) {
+                    query = sqlStatements.between(query, key, value.low, value.high);
+                }
+                else if (lowValid) {
+                    query = sqlStatements.lte(query, key, value.low);
+                }
+                else if (highValid) {
+                    query = sqlStatements.gte(query, key, value.high);
+                }
+            });
+        }
+        if (filters.equal) {
+            iterate(filters.equal, (key, value) => {
+                const fnc = allOr ? "orWhereRaw" : "whereRaw";
+                if (this.client === types_1.SqlClient.MS_SQL) {
+                    query = query[fnc](`CASE WHEN ${likeKey(this.client, key)} = ? THEN 1 ELSE 0 END = 1`, [value]);
+                }
+                else {
+                    query = query[fnc](`COALESCE(${likeKey(this.client, key)} = ?, FALSE)`, [value]);
+                }
+            });
+        }
+        if (filters.notEqual) {
+            iterate(filters.notEqual, (key, value) => {
+                const fnc = allOr ? "orWhereRaw" : "whereRaw";
+                if (this.client === types_1.SqlClient.MS_SQL) {
+                    query = query[fnc](`CASE WHEN ${likeKey(this.client, key)} = ? THEN 1 ELSE 0 END = 0`, [value]);
+                }
+                else {
+                    query = query[fnc](`COALESCE(${likeKey(this.client, key)} != ?, TRUE)`, [value]);
+                }
+            });
+        }
+        if (filters.empty) {
+            iterate(filters.empty, key => {
+                const fnc = allOr ? "orWhereNull" : "whereNull";
+                query = query[fnc](key);
+            });
+        }
+        if (filters.notEmpty) {
+            iterate(filters.notEmpty, key => {
+                const fnc = allOr ? "orWhereNotNull" : "whereNotNull";
+                query = query[fnc](key);
+            });
+        }
+        if (filters.contains) {
+            contains(filters.contains);
+        }
+        if (filters.notContains) {
+            contains(filters.notContains);
+        }
+        if (filters.containsAny) {
+            contains(filters.containsAny, true);
+        }
+        // when searching internal tables make sure long looking for rows
+        if (filters.documentType && !(0, utils_1.isExternalTable)(table)) {
+            const tableRef = ((_a = opts === null || opts === void 0 ? void 0 : opts.aliases) === null || _a === void 0 ? void 0 : _a[table._id]) || table._id;
+            // has to be its own option, must always be AND onto the search
+            query.andWhereLike(`${tableRef}._id`, `${(0, types_1.prefixed)(filters.documentType)}%`);
+        }
+        return query;
+    }
+    addSorting(query, json) {
+        let { sort, paginate } = json;
+        const table = json.meta.table;
+        const tableName = getTableName(table);
+        const aliases = json.tableAliases;
+        const aliased = tableName && (aliases === null || aliases === void 0 ? void 0 : aliases[tableName]) ? aliases[tableName] : table === null || table === void 0 ? void 0 : table.name;
+        if (sort && Object.keys(sort || {}).length > 0) {
+            for (let [key, value] of Object.entries(sort)) {
+                const direction = value.direction === types_1.SortDirection.ASCENDING ? "asc" : "desc";
+                let nulls;
+                if (this.client === types_1.SqlClient.POSTGRES) {
+                    // All other clients already sort this as expected by default, and adding this to the rest of the clients is causing issues
+                    nulls = value.direction === types_1.SortDirection.ASCENDING ? "first" : "last";
+                }
+                query = query.orderBy(`${aliased}.${key}`, direction, nulls);
+            }
+        }
+        else if (this.client === types_1.SqlClient.MS_SQL && (paginate === null || paginate === void 0 ? void 0 : paginate.limit)) {
+            // @ts-ignore
+            query = query.orderBy(`${aliased}.${table === null || table === void 0 ? void 0 : table.primary[0]}`);
+        }
+        return query;
+    }
+    tableNameWithSchema(tableName, opts) {
+        let withSchema = (opts === null || opts === void 0 ? void 0 : opts.schema) ? `${opts.schema}.${tableName}` : tableName;
+        if (opts === null || opts === void 0 ? void 0 : opts.alias) {
+            withSchema += ` as ${opts.alias}`;
+        }
+        return withSchema;
+    }
+    addRelationships(query, fromTable, relationships, schema, aliases) {
+        if (!relationships) {
+            return query;
+        }
+        const tableSets = {};
+        // aggregate into table sets (all the same to tables)
+        for (let relationship of relationships) {
+            const keyObj = {
+                toTable: relationship.tableName,
+                throughTable: undefined,
+            };
+            if (relationship.through) {
+                keyObj.throughTable = relationship.through;
+            }
+            const key = JSON.stringify(keyObj);
+            if (tableSets[key]) {
+                tableSets[key].push(relationship);
+            }
+            else {
+                tableSets[key] = [relationship];
+            }
+        }
+        for (let [key, relationships] of Object.entries(tableSets)) {
+            const { toTable, throughTable } = JSON.parse(key);
+            const toAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[toTable]) || toTable, throughAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[throughTable]) || throughTable, fromAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[fromTable]) || fromTable;
+            let toTableWithSchema = this.tableNameWithSchema(toTable, {
+                alias: toAlias,
+                schema,
+            });
+            let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
+                alias: throughAlias,
+                schema,
+            });
+            if (!throughTable) {
+                // @ts-ignore
+                query = query.leftJoin(toTableWithSchema, function () {
+                    for (let relationship of relationships) {
+                        const from = relationship.from, to = relationship.to;
+                        // @ts-ignore
+                        this.orOn(`${fromAlias}.${from}`, "=", `${toAlias}.${to}`);
+                    }
+                });
+            }
+            else {
+                query = query
+                    // @ts-ignore
+                    .leftJoin(throughTableWithSchema, function () {
+                    for (let relationship of relationships) {
+                        const fromPrimary = relationship.fromPrimary;
+                        const from = relationship.from;
+                        // @ts-ignore
+                        this.orOn(`${fromAlias}.${fromPrimary}`, "=", `${throughAlias}.${from}`);
+                    }
+                })
+                    .leftJoin(toTableWithSchema, function () {
+                    for (let relationship of relationships) {
+                        const toPrimary = relationship.toPrimary;
+                        const to = relationship.to;
+                        // @ts-ignore
+                        this.orOn(`${toAlias}.${toPrimary}`, `${throughAlias}.${to}`);
+                    }
+                });
+            }
+        }
+        return query.limit(BASE_LIMIT);
+    }
+    knexWithAlias(knex, endpoint, aliases) {
+        const tableName = endpoint.entityId;
+        const tableAlias = aliases === null || aliases === void 0 ? void 0 : aliases[tableName];
+        const query = knex(this.tableNameWithSchema(tableName, {
+            alias: tableAlias,
+            schema: endpoint.schema,
+        }));
+        return query;
+    }
+    create(knex, json, opts) {
+        const { endpoint, body } = json;
+        let query = this.knexWithAlias(knex, endpoint);
+        const parsedBody = parseBody(body);
+        // make sure no null values in body for creation
+        for (let [key, value] of Object.entries(parsedBody)) {
+            if (value == null) {
+                delete parsedBody[key];
+            }
+        }
+        // mysql can't use returning
+        if (opts.disableReturning) {
+            return query.insert(parsedBody);
+        }
+        else {
+            return query.insert(parsedBody).returning("*");
+        }
+    }
+    bulkCreate(knex, json) {
+        const { endpoint, body } = json;
+        let query = this.knexWithAlias(knex, endpoint);
+        if (!Array.isArray(body)) {
+            return query;
+        }
+        const parsedBody = body.map(row => parseBody(row));
+        return query.insert(parsedBody);
+    }
+    read(knex, json, limit) {
+        let { endpoint, resource, filters, paginate, relationships, tableAliases } = json;
+        const tableName = endpoint.entityId;
+        // select all if not specified
+        if (!resource) {
+            resource = { fields: [] };
+        }
+        let selectStatement = "*";
+        // handle select
+        if (resource.fields && resource.fields.length > 0) {
+            // select the resources as the format "table.columnName" - this is what is provided
+            // by the resource builder further up
+            selectStatement = generateSelectStatement(json, knex);
+        }
+        let foundLimit = limit || BASE_LIMIT;
+        // handle pagination
+        let foundOffset = null;
+        if (paginate && paginate.page && paginate.limit) {
+            // @ts-ignore
+            const page = paginate.page <= 1 ? 0 : paginate.page - 1;
+            const offset = page * paginate.limit;
+            foundLimit = paginate.limit;
+            foundOffset = offset;
+        }
+        else if (paginate && paginate.limit) {
+            foundLimit = paginate.limit;
+        }
+        // start building the query
+        let query = this.knexWithAlias(knex, endpoint, tableAliases);
+        query = query.limit(foundLimit);
+        if (foundOffset) {
+            query = query.offset(foundOffset);
+        }
+        query = this.addFilters(query, filters, json.meta.table, {
+            aliases: tableAliases,
+        });
+        // add sorting to pre-query
+        query = this.addSorting(query, json);
+        const alias = (tableAliases === null || tableAliases === void 0 ? void 0 : tableAliases[tableName]) || tableName;
+        let preQuery = knex({
+            [alias]: query,
+        }).select(selectStatement);
+        // have to add after as well (this breaks MS-SQL)
+        if (this.client !== types_1.SqlClient.MS_SQL) {
+            preQuery = this.addSorting(preQuery, json);
+        }
+        // handle joins
+        query = this.addRelationships(preQuery, tableName, relationships, endpoint.schema, tableAliases);
+        return this.addFilters(query, filters, json.meta.table, {
+            relationship: true,
+            aliases: tableAliases,
+        });
+    }
+    update(knex, json, opts) {
+        const { endpoint, body, filters, tableAliases } = json;
+        let query = this.knexWithAlias(knex, endpoint, tableAliases);
+        const parsedBody = parseBody(body);
+        query = this.addFilters(query, filters, json.meta.table, {
+            aliases: tableAliases,
+        });
+        // mysql can't use returning
+        if (opts.disableReturning) {
+            return query.update(parsedBody);
+        }
+        else {
+            return query.update(parsedBody).returning("*");
+        }
+    }
+    delete(knex, json, opts) {
+        const { endpoint, filters, tableAliases } = json;
+        let query = this.knexWithAlias(knex, endpoint, tableAliases);
+        query = this.addFilters(query, filters, json.meta.table, {
+            aliases: tableAliases,
+        });
+        // mysql can't use returning
+        if (opts.disableReturning) {
+            return query.delete();
+        }
+        else {
+            return query.delete().returning(generateSelectStatement(json, knex));
+        }
+    }
+}
+class SqlQueryBuilder extends sqlTable_1.default {
+    // pass through client to get flavour of SQL
+    constructor(client, limit = BASE_LIMIT) {
+        super(client);
+        this.limit = limit;
+    }
+    /**
+     * @param json The JSON query DSL which is to be converted to SQL.
+     * @param opts extra options which are to be passed into the query builder, e.g. disableReturning
+     * which for the sake of mySQL stops adding the returning statement to inserts, updates and deletes.
+     * @return the query ready to be passed to the driver.
+     */
+    _query(json, opts = {}) {
+        const sqlClient = this.getSqlClient();
+        const config = {
+            client: sqlClient,
+        };
+        if (sqlClient === types_1.SqlClient.SQL_LITE) {
+            config.useNullAsDefault = true;
+        }
+        const client = (0, knex_1.knex)(config);
+        let query;
+        const builder = new InternalBuilder(sqlClient);
+        switch (this._operation(json)) {
+            case types_1.Operation.CREATE:
+                query = builder.create(client, json, opts);
+                break;
+            case types_1.Operation.READ:
+                query = builder.read(client, json, this.limit);
+                break;
+            case types_1.Operation.UPDATE:
+                query = builder.update(client, json, opts);
+                break;
+            case types_1.Operation.DELETE:
+                query = builder.delete(client, json, opts);
+                break;
+            case types_1.Operation.BULK_CREATE:
+                query = builder.bulkCreate(client, json);
+                break;
+            case types_1.Operation.CREATE_TABLE:
+            case types_1.Operation.UPDATE_TABLE:
+            case types_1.Operation.DELETE_TABLE:
+                return this._tableQuery(json);
+            default:
+                throw `Operation type is not supported by SQL query builder`;
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.disableBindings) {
+            return { sql: query.toString() };
+        }
+        else {
+            let native = (0, utils_1.getNativeSql)(query);
+            if (sqlClient === types_1.SqlClient.SQL_LITE) {
+                native = convertBooleans(native);
+            }
+            return native;
+        }
+    }
+    getReturningRow(queryFn, json) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!json.extra || !json.extra.idFilter) {
+                return {};
+            }
+            const input = this._query({
+                endpoint: Object.assign(Object.assign({}, json.endpoint), { operation: types_1.Operation.READ }),
+                resource: {
+                    fields: [],
+                },
+                filters: (_a = json.extra) === null || _a === void 0 ? void 0 : _a.idFilter,
+                paginate: {
+                    limit: 1,
+                },
+                meta: json.meta,
+            });
+            return queryFn(input, types_1.Operation.READ);
+        });
+    }
+    // when creating if an ID has been inserted need to make sure
+    // the id filter is enriched with it before trying to retrieve the row
+    checkLookupKeys(id, json) {
+        var _a;
+        if (!id || !json.meta.table || !json.meta.table.primary) {
+            return json;
+        }
+        const primaryKey = (_a = json.meta.table.primary) === null || _a === void 0 ? void 0 : _a[0];
+        json.extra = {
+            idFilter: {
+                equal: {
+                    [primaryKey]: id,
+                },
+            },
+        };
+        return json;
+    }
+    // this function recreates the returning functionality of postgres
+    queryWithReturning(json, queryFn, processFn = (result) => result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sqlClient = this.getSqlClient();
+            const operation = this._operation(json);
+            const input = this._query(json, { disableReturning: true });
+            if (Array.isArray(input)) {
+                const responses = [];
+                for (let query of input) {
+                    responses.push(yield queryFn(query, operation));
+                }
+                return responses;
+            }
+            let row;
+            // need to manage returning, a feature mySQL can't do
+            if (operation === types_1.Operation.DELETE) {
+                row = processFn(yield this.getReturningRow(queryFn, json));
+            }
+            const response = yield queryFn(input, operation);
+            const results = processFn(response);
+            // same as delete, manage returning
+            if (operation === types_1.Operation.CREATE || operation === types_1.Operation.UPDATE) {
+                let id;
+                if (sqlClient === types_1.SqlClient.MS_SQL) {
+                    id = results === null || results === void 0 ? void 0 : results[0].id;
+                }
+                else if (sqlClient === types_1.SqlClient.MY_SQL) {
+                    id = results === null || results === void 0 ? void 0 : results.insertId;
+                }
+                row = processFn(yield this.getReturningRow(queryFn, this.checkLookupKeys(id, json)));
+            }
+            if (operation !== types_1.Operation.READ) {
+                return row;
+            }
+            return results.length ? results : [{ [operation.toLowerCase()]: true }];
+        });
+    }
+    convertJsonStringColumns(table, results, aliases) {
+        const tableName = getTableName(table);
+        for (const [name, field] of Object.entries(table.schema)) {
+            if (!this._isJsonColumn(field)) {
+                continue;
+            }
+            const aliasedTableName = (tableName && (aliases === null || aliases === void 0 ? void 0 : aliases[tableName])) || tableName;
+            const fullName = `${aliasedTableName}.${name}`;
+            for (let row of results) {
+                if (typeof row[fullName] === "string") {
+                    row[fullName] = JSON.parse(row[fullName]);
+                }
+                if (typeof row[name] === "string") {
+                    row[name] = JSON.parse(row[name]);
+                }
+            }
+        }
+        return results;
+    }
+    _isJsonColumn(field) {
+        return (types_1.JsonTypes.includes(field.type) &&
+            !shared_core_1.helpers.schema.isDeprecatedSingleUserColumn(field));
+    }
+    log(query, values) {
+        if (!environment_1.default.SQL_LOGGING_ENABLE) {
+            return;
+        }
+        const sqlClient = this.getSqlClient();
+        let string = `[SQL] [${sqlClient.toUpperCase()}] query="${query}"`;
+        if (values) {
+            string += ` values="${values.join(", ")}"`;
+        }
+        console.log(string);
+    }
+}
+exports.default = SqlQueryBuilder;
+//# sourceMappingURL=sql.js.map