@budibase/server 0.9.184 → 0.9.185-alpha.11

package/dist/integrations/base/sql.js

@@ -1,210 +1,282 @@
 "use strict";
+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 BASE_LIMIT = 5000;
 const datasource_1 = require("../../definitions/datasource");
 const utils_1 = require("../utils");
-function parseBody(body) {
-    for (let [key, value] of Object.entries(body)) {
-        if (typeof value !== "string") {
-            continue;
-        }
-        if (utils_1.isIsoDateString(value)) {
-            body[key] = new Date(value);
-        }
-    }
-    return body;
-}
-// right now we only do filters on the specific table being queried
-function addFilters(tableName, query, filters) {
-    function iterate(structure, fn) {
-        for (let [key, value] of Object.entries(structure)) {
-            fn(`${tableName}.${key}`, value);
-        }
-    }
-    if (!filters) {
-        return query;
-    }
-    // if all or specified in filters, then everything is an or
-    const allOr = filters.allOr;
-    if (filters.oneOf) {
-        iterate(filters.oneOf, (key, array) => {
-            const fnc = allOr ? "orWhereIn" : "whereIn";
-            query = query[fnc](key, array);
-        });
-    }
-    if (filters.string) {
-        iterate(filters.string, (key, value) => {
-            const fnc = allOr ? "orWhere" : "where";
-            query = query[fnc](key, "ilike", `${value}%`);
-        });
-    }
-    if (filters.fuzzy) {
-        iterate(filters.fuzzy, (key, value) => {
-            const fnc = allOr ? "orWhere" : "where";
-            query = query[fnc](key, "ilike", `%${value}%`);
-        });
+const sqlTable_1 = __importDefault(require("./sqlTable"));
+const BASE_LIMIT = 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 parse(input) {
+    if (Array.isArray(input)) {
+        return JSON.stringify(input);
     }
-    if (filters.range) {
-        iterate(filters.range, (key, value) => {
-            if (!value.high || !value.low) {
-                return;
-            }
-            const fnc = allOr ? "orWhereBetween" : "whereBetween";
-            query = query[fnc](key, [value.low, value.high]);
-        });
+    if (typeof input !== "string") {
+        return input;
     }
-    if (filters.equal) {
-        iterate(filters.equal, (key, value) => {
-            const fnc = allOr ? "orWhere" : "where";
-            query = query[fnc]({ [key]: value });
-        });
+    if (input === MAX_ISO_DATE) {
+        return new Date(8640000000000000);
     }
-    if (filters.notEqual) {
-        iterate(filters.notEqual, (key, value) => {
-            const fnc = allOr ? "orWhereNot" : "whereNot";
-            query = query[fnc]({ [key]: value });
-        });
+    if (input === MIN_ISO_DATE) {
+        return new Date(-8640000000000000);
     }
-    if (filters.empty) {
-        iterate(filters.empty, key => {
-            const fnc = allOr ? "orWhereNull" : "whereNull";
-            query = query[fnc](key);
-        });
+    if (utils_1.isIsoDateString(input)) {
+        return new Date(input);
     }
-    if (filters.notEmpty) {
-        iterate(filters.notEmpty, key => {
-            const fnc = allOr ? "orWhereNotNull" : "whereNotNull";
-            query = query[fnc](key);
-        });
-    }
-    return query;
+    return input;
 }
-function addRelationships(knex, query, fields, fromTable, relationships) {
-    if (!relationships) {
-        return query;
+function parseBody(body) {
+    for (let [key, value] of Object.entries(body)) {
+        body[key] = parse(value);
     }
-    for (let relationship of relationships) {
-        const from = relationship.from, to = relationship.to, toTable = relationship.tableName;
-        if (!relationship.through) {
-            // @ts-ignore
-            query = query.leftJoin(toTable, `${fromTable}.${from}`, `${toTable}.${to}`);
+    return body;
+}
+function parseFilters(filters) {
+    for (let [key, value] of Object.entries(filters)) {
+        let parsed;
+        if (typeof value === "object") {
+            parsed = parseFilters(value);
         }
         else {
-            const throughTable = relationship.through;
-            const fromPrimary = relationship.fromPrimary;
-            const toPrimary = relationship.toPrimary;
-            query = query
-                // @ts-ignore
-                .leftJoin(throughTable, `${fromTable}.${fromPrimary}`, `${throughTable}.${from}`)
-                .leftJoin(toTable, `${toTable}.${toPrimary}`, `${throughTable}.${to}`);
+            parsed = parse(value);
         }
+        // @ts-ignore
+        filters[key] = parsed;
     }
-    return query.limit(BASE_LIMIT);
+    return filters;
 }
-function buildCreate(knex, json, opts) {
-    const { endpoint, body } = json;
-    let query = knex(endpoint.entityId);
-    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("*");
+class InternalBuilder {
+    constructor(client) {
+        this.client = client;
     }
-}
-function buildRead(knex, json, limit) {
-    let { endpoint, resource, filters, sort, paginate, relationships } = 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 = resource.fields.map(field => `${field} as ${field}`);
-    }
-    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;
+    // right now we only do filters on the specific table being queried
+    addFilters(tableName, query, filters) {
+        function iterate(structure, fn) {
+            for (let [key, value] of Object.entries(structure)) {
+                fn(`${tableName}.${key}`, value);
+            }
+        }
+        if (!filters) {
+            return query;
+        }
+        filters = parseFilters(filters);
+        // if all or specified in filters, then everything is an or
+        const allOr = filters.allOr;
+        if (filters.oneOf) {
+            iterate(filters.oneOf, (key, array) => {
+                const fnc = allOr ? "orWhereIn" : "whereIn";
+                query = query[fnc](key, array);
+            });
+        }
+        if (filters.string) {
+            iterate(filters.string, (key, value) => {
+                const fnc = allOr ? "orWhere" : "where";
+                // postgres supports ilike, nothing else does
+                if (this.client === utils_1.SqlClients.POSTGRES) {
+                    query = query[fnc](key, "ilike", `${value}%`);
+                }
+                else {
+                    const rawFnc = `${fnc}Raw`;
+                    // @ts-ignore
+                    query = query[rawFnc](`LOWER(${key}) LIKE ?`, [`${value}%`]);
+                }
+            });
+        }
+        if (filters.fuzzy) {
+            iterate(filters.fuzzy, (key, value) => {
+                const fnc = allOr ? "orWhere" : "where";
+                // postgres supports ilike, nothing else does
+                if (this.client === utils_1.SqlClients.POSTGRES) {
+                    query = query[fnc](key, "ilike", `%${value}%`);
+                }
+                else {
+                    const rawFnc = `${fnc}Raw`;
+                    // @ts-ignore
+                    query = query[rawFnc](`LOWER(${key}) LIKE ?`, [`%${value}%`]);
+                }
+            });
+        }
+        if (filters.range) {
+            iterate(filters.range, (key, value) => {
+                if (!value.high || !value.low) {
+                    return;
+                }
+                const fnc = allOr ? "orWhereBetween" : "whereBetween";
+                query = query[fnc](key, [value.low, value.high]);
+            });
+        }
+        if (filters.equal) {
+            iterate(filters.equal, (key, value) => {
+                const fnc = allOr ? "orWhere" : "where";
+                query = query[fnc]({ [key]: value });
+            });
+        }
+        if (filters.notEqual) {
+            iterate(filters.notEqual, (key, value) => {
+                const fnc = allOr ? "orWhereNot" : "whereNot";
+                query = query[fnc]({ [key]: 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);
+            });
+        }
+        return query;
     }
-    else if (paginate && paginate.limit) {
-        foundLimit = paginate.limit;
+    addRelationships(knex, query, fields, fromTable, relationships) {
+        if (!relationships) {
+            return query;
+        }
+        for (let relationship of relationships) {
+            const from = relationship.from, to = relationship.to, toTable = relationship.tableName;
+            if (!relationship.through) {
+                // @ts-ignore
+                query = query.leftJoin(toTable, `${fromTable}.${from}`, `${toTable}.${to}`);
+            }
+            else {
+                const throughTable = relationship.through;
+                const fromPrimary = relationship.fromPrimary;
+                const toPrimary = relationship.toPrimary;
+                query = query
+                    // @ts-ignore
+                    .leftJoin(throughTable, `${fromTable}.${fromPrimary}`, `${throughTable}.${from}`)
+                    .leftJoin(toTable, `${toTable}.${toPrimary}`, `${throughTable}.${to}`);
+            }
+        }
+        return query.limit(BASE_LIMIT);
     }
-    // start building the query
-    let query = knex(tableName).limit(foundLimit);
-    if (foundOffset) {
-        query = query.offset(foundOffset);
+    create(knex, json, opts) {
+        const { endpoint, body } = json;
+        let query = knex(endpoint.entityId);
+        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("*");
+        }
     }
-    if (sort) {
-        for (let [key, value] of Object.entries(sort)) {
-            const direction = value === datasource_1.SortDirection.ASCENDING ? "asc" : "desc";
-            query = query.orderBy(key, direction);
+    bulkCreate(knex, json) {
+        const { endpoint, body } = json;
+        let query = knex(endpoint.entityId);
+        if (!Array.isArray(body)) {
+            return query;
         }
+        const parsedBody = body.map(row => parseBody(row));
+        return query.insert(parsedBody);
     }
-    query = addFilters(tableName, query, filters);
-    // @ts-ignore
-    let preQuery = knex({
+    read(knex, json, limit) {
+        var _a, _b;
+        let { endpoint, resource, filters, sort, paginate, relationships } = 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 = resource.fields.map(field => `${field} as ${field}`);
+        }
+        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 = knex(tableName).limit(foundLimit);
+        if (foundOffset) {
+            query = query.offset(foundOffset);
+        }
+        if (sort) {
+            for (let [key, value] of Object.entries(sort)) {
+                const direction = value === datasource_1.SortDirection.ASCENDING ? "asc" : "desc";
+                query = query.orderBy(key, direction);
+            }
+        }
+        if (this.client === utils_1.SqlClients.MS_SQL && !sort && (paginate === null || paginate === void 0 ? void 0 : paginate.limit)) {
+            // @ts-ignore
+            query = query.orderBy((_b = (_a = json.meta) === null || _a === void 0 ? void 0 : _a.table) === null || _b === void 0 ? void 0 : _b.primary[0]);
+        }
+        query = this.addFilters(tableName, query, filters);
         // @ts-ignore
-        [tableName]: query,
-    }).select(selectStatement);
-    // handle joins
-    return addRelationships(knex, preQuery, selectStatement, tableName, relationships);
-}
-function buildUpdate(knex, json, opts) {
-    const { endpoint, body, filters } = json;
-    let query = knex(endpoint.entityId);
-    const parsedBody = parseBody(body);
-    query = addFilters(endpoint.entityId, query, filters);
-    // mysql can't use returning
-    if (opts.disableReturning) {
-        return query.update(parsedBody);
-    }
-    else {
-        return query.update(parsedBody).returning("*");
+        let preQuery = knex({
+            // @ts-ignore
+            [tableName]: query,
+        }).select(selectStatement);
+        // handle joins
+        return this.addRelationships(knex, preQuery, selectStatement, tableName, relationships);
     }
-}
-function buildDelete(knex, json, opts) {
-    const { endpoint, filters } = json;
-    let query = knex(endpoint.entityId);
-    query = addFilters(endpoint.entityId, query, filters);
-    // mysql can't use returning
-    if (opts.disableReturning) {
-        return query.delete();
+    update(knex, json, opts) {
+        const { endpoint, body, filters } = json;
+        let query = knex(endpoint.entityId);
+        const parsedBody = parseBody(body);
+        query = this.addFilters(endpoint.entityId, query, filters);
+        // mysql can't use returning
+        if (opts.disableReturning) {
+            return query.update(parsedBody);
+        }
+        else {
+            return query.update(parsedBody).returning("*");
+        }
     }
-    else {
-        return query.delete().returning("*");
+    delete(knex, json, opts) {
+        const { endpoint, filters } = json;
+        let query = knex(endpoint.entityId);
+        query = this.addFilters(endpoint.entityId, query, filters);
+        // mysql can't use returning
+        if (opts.disableReturning) {
+            return query.delete();
+        }
+        else {
+            return query.delete().returning("*");
+        }
     }
 }
-class SqlQueryBuilder {
+class SqlQueryBuilder extends sqlTable_1.default {
     // pass through client to get flavour of SQL
     constructor(client, limit = BASE_LIMIT) {
-        this.sqlClient = client;
+        super(client);
         this.limit = limit;
     }
-    /**
-     * @param json the input JSON structure from which an SQL query will be built.
-     * @return {string} the operation that was found in the JSON.
-     */
-    _operation(json) {
-        return json.endpoint.operation;
-    }
     /**
      * @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
@@ -212,26 +284,108 @@ class SqlQueryBuilder {
      * @return {{ sql: string, bindings: object }} the query ready to be passed to the driver.
      */
     _query(json, opts = {}) {
-        const client = knex_1.knex({ client: this.sqlClient });
+        const sqlClient = this.getSqlClient();
+        const client = knex_1.knex({ client: sqlClient });
         let query;
+        const builder = new InternalBuilder(sqlClient);
         switch (this._operation(json)) {
             case datasource_1.Operation.CREATE:
-                query = buildCreate(client, json, opts);
+                query = builder.create(client, json, opts);
                 break;
             case datasource_1.Operation.READ:
-                query = buildRead(client, json, this.limit);
+                query = builder.read(client, json, this.limit);
                 break;
             case datasource_1.Operation.UPDATE:
-                query = buildUpdate(client, json, opts);
+                query = builder.update(client, json, opts);
                 break;
             case datasource_1.Operation.DELETE:
-                query = buildDelete(client, json, opts);
+                query = builder.delete(client, json, opts);
+                break;
+            case datasource_1.Operation.BULK_CREATE:
+                query = builder.bulkCreate(client, json);
                 break;
+            case datasource_1.Operation.CREATE_TABLE:
+            case datasource_1.Operation.UPDATE_TABLE:
+            case datasource_1.Operation.DELETE_TABLE:
+                return this._tableQuery(json);
             default:
                 throw `Operation type is not supported by SQL query builder`;
         }
         // @ts-ignore
         return query.toSQL().toNative();
     }
+    getReturningRow(queryFn, json) {
+        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: datasource_1.Operation.READ }),
+                resource: {
+                    fields: [],
+                },
+                filters: json.extra.idFilter,
+                paginate: {
+                    limit: 1,
+                },
+                meta: json.meta,
+            });
+            return queryFn(input, datasource_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, _b;
+        if (!id || !((_a = json.meta) === null || _a === void 0 ? void 0 : _a.table) || !json.meta.table.primary) {
+            return json;
+        }
+        const primaryKey = (_b = json.meta.table.primary) === null || _b === void 0 ? void 0 : _b[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 === datasource_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 === datasource_1.Operation.CREATE || operation === datasource_1.Operation.UPDATE) {
+                let id;
+                if (sqlClient === utils_1.SqlClients.MS_SQL) {
+                    id = results === null || results === void 0 ? void 0 : results[0].id;
+                }
+                else if (sqlClient === utils_1.SqlClients.MY_SQL) {
+                    id = results === null || results === void 0 ? void 0 : results.insertId;
+                }
+                row = processFn(yield this.getReturningRow(queryFn, this.checkLookupKeys(id, json)));
+            }
+            if (operation !== datasource_1.Operation.READ) {
+                return row;
+            }
+            return results.length ? results : [{ [operation.toLowerCase()]: true }];
+        });
+    }
 }
 module.exports = SqlQueryBuilder;