@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.1

package/lib/utils/parseFieldExpression.js

@@ -1,51 +1,73 @@
-'use strict';
-
-const jsonFieldExpressionParser = require('../queryBuilder/parsers/jsonFieldExpressionParser');
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFieldExpression = parseFieldExpression;
+const jsonFieldExpressionParser = __importStar(require("../queryBuilder/parsers/jsonFieldExpressionParser"));
 const cache = new Map();
-
 function parseFieldExpression(expr) {
-  let parsedExpr = cache.get(expr);
-
-  if (parsedExpr !== undefined) {
-    return parsedExpr;
-  } else {
-    parsedExpr = jsonFieldExpressionParser.parse(expr);
-    parsedExpr = preprocessParsedExpression(parsedExpr);
-
-    // We don't take a copy of the parsedExpr each time we
-    // use if from cache. Instead to make sure it's never
-    // mutated we deep-freeze it.
-    parsedExpr = freezeParsedExpr(parsedExpr);
-
-    cache.set(expr, parsedExpr);
-    return parsedExpr;
-  }
+    let parsedExpr = cache.get(expr);
+    if (parsedExpr !== undefined) {
+        return parsedExpr;
+    }
+    else {
+        const parserOutput = jsonFieldExpressionParser.parse(expr);
+        parsedExpr = preprocessParsedExpression(parserOutput);
+        // We don't take a copy of the parsedExpr each time we
+        // use if from cache. Instead to make sure it's never
+        // mutated we deep-freeze it.
+        parsedExpr = freezeParsedExpr(parsedExpr);
+        cache.set(expr, parsedExpr);
+        return parsedExpr;
+    }
 }
-
 function preprocessParsedExpression(parsedExpr) {
-  const columnParts = parsedExpr.columnName.split('.').map((part) => part.trim());
-  parsedExpr.column = columnParts[columnParts.length - 1];
-
-  if (columnParts.length >= 2) {
-    parsedExpr.table = columnParts.slice(0, columnParts.length - 1).join('.');
-  } else {
-    parsedExpr.table = null;
-  }
-
-  return parsedExpr;
+    const columnParts = parsedExpr.columnName.split('.').map((part) => part.trim());
+    parsedExpr.column = columnParts[columnParts.length - 1];
+    if (columnParts.length >= 2) {
+        parsedExpr.table = columnParts.slice(0, columnParts.length - 1).join('.');
+    }
+    else {
+        parsedExpr.table = null;
+    }
+    return parsedExpr;
 }
-
 function freezeParsedExpr(parsedExpr) {
-  for (const access of parsedExpr.access) {
-    Object.freeze(access);
-  }
-
-  Object.freeze(parsedExpr.access);
-  Object.freeze(parsedExpr);
-
-  return parsedExpr;
+    for (const access of parsedExpr.access) {
+        Object.freeze(access);
+    }
+    Object.freeze(parsedExpr.access);
+    Object.freeze(parsedExpr);
+    return parsedExpr;
 }
-
-module.exports = {
-  parseFieldExpression,
-};

package/lib/utils/postgresJsonPath.js

@@ -1,7 +1,11 @@
-'use strict';
-
-const { getDialect } = require('./knexUtils');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPgTextArray = toPgTextArray;
+exports.toPgStringLiteral = toPgStringLiteral;
+exports.toPgJsonPathLiteral = toPgJsonPathLiteral;
+exports.toPgQuotedColumn = toPgQuotedColumn;
+exports.getJsonDialect = getJsonDialect;
+const knexUtils_1 = require("./knexUtils");
 // Characters that force an element of a postgres text array literal to be
 // double quoted: the array syntax characters, whitespace and control chars.
 const ARRAY_ELEMENT_NEEDS_QUOTES = /[{}",\\\s\x00-\x1f\x7f]|^$|^null$/i;
@@ -10,30 +14,26 @@ const ARRAY_ELEMENT_NEEDS_QUOTES = /[{}",\\\s\x00-\x1f\x7f]|^$|^null$/i;
 const NEEDS_ESCAPE_STRING = /[\\\x00-\x1f\x7f]/;
 const POSTGRES_DIALECTS = ['postgresql', 'redshift'];
 const MYSQL_DIALECTS = ['mysql', 'mysql2'];
-
 /**
  * Converts the `access` part of a parsed field expression into a postgres
  * text array literal like `{a,b,1}`. Elements are quoted and escaped so that
  * keys containing array syntax characters can't change the path.
  */
 function toPgTextArray(access) {
-  const elements = access.map((it) => {
-    if (it.type === 'array' && Number.isInteger(it.ref)) {
-      return String(it.ref);
-    }
-
-    const ref = String(it.ref);
-
-    if (ARRAY_ELEMENT_NEEDS_QUOTES.test(ref)) {
-      return `"${ref.replace(/[\\"]/g, '\\$&')}"`;
-    } else {
-      return ref;
-    }
-  });
-
-  return `{${elements.join(',')}}`;
+    const elements = access.map((it) => {
+        if (it.type === 'array' && Number.isInteger(it.ref)) {
+            return String(it.ref);
+        }
+        const ref = String(it.ref);
+        if (ARRAY_ELEMENT_NEEDS_QUOTES.test(ref)) {
+            return `"${ref.replace(/[\\"]/g, '\\$&')}"`;
+        }
+        else {
+            return ref;
+        }
+    });
+    return `{${elements.join(',')}}`;
 }
-
 /**
  * Converts a string into a postgres string literal that is safe to embed
  * into a knex raw query. Single quotes are doubled and `?` characters are
@@ -45,42 +45,37 @@ function toPgTextArray(access) {
  * backslash ever ends up next to a `?` (knex would eat it).
  */
 function toPgStringLiteral(str) {
-  let sql = str.replace(/'/g, "''");
-
-  if (NEEDS_ESCAPE_STRING.test(sql)) {
-    sql = sql.replace(/[\\\x00-\x1f\x7f]/g, (char) => {
-      return '\\' + char.charCodeAt(0).toString(8).padStart(3, '0');
-    });
-
-    sql = `E'${sql}'`;
-  } else {
-    sql = `'${sql}'`;
-  }
-
-  return sql.replace(/\?/g, '\\?');
+    let sql = str.replace(/'/g, "''");
+    if (NEEDS_ESCAPE_STRING.test(sql)) {
+        sql = sql.replace(/[\\\x00-\x1f\x7f]/g, (char) => {
+            return '\\' + char.charCodeAt(0).toString(8).padStart(3, '0');
+        });
+        sql = `E'${sql}'`;
+    }
+    else {
+        sql = `'${sql}'`;
+    }
+    return sql.replace(/\?/g, '\\?');
 }
-
 /**
  * Converts the `access` part of a parsed field expression into a string
  * literal that can be used as the right hand side of `#>`, `#>>` and as the
  * path argument of `jsonb_set`.
  */
 function toPgJsonPathLiteral(access) {
-  return toPgStringLiteral(toPgTextArray(access));
+    return toPgStringLiteral(toPgTextArray(access));
 }
-
 /**
  * Quotes a (possibly table qualified) column name like `Table.column` as
  * `"Table"."column"` for postgres.
  */
 function toPgQuotedColumn(columnName) {
-  return columnName
-    .split('.')
-    .map((part) => `"${part.replace(/"/g, '""')}"`)
-    .join('.')
-    .replace(/\?/g, '\\?');
+    return columnName
+        .split('.')
+        .map((part) => `"${part.replace(/"/g, '""')}"`)
+        .join('.')
+        .replace(/\?/g, '\\?');
 }
-
 /**
  * Returns the flavor of JSON SQL to generate for field expressions: `'postgres'`
  * or `'mysql'`. Other databases throw, since postgres SQL is invalid at best and
@@ -88,23 +83,14 @@ function toPgQuotedColumn(columnName) {
  * when the query has no knex instance bound yet, in which case postgres is used.
  */
 function getJsonDialect(knex, expression) {
-  const dialect = knex ? getDialect(knex) : null;
-
-  if (dialect === null || POSTGRES_DIALECTS.includes(dialect)) {
-    return 'postgres';
-  } else if (MYSQL_DIALECTS.includes(dialect)) {
-    return 'mysql';
-  } else {
-    throw new Error(
-      `JSON field expressions are only supported on postgres and mysql. Tried to use "${expression}" with dialect "${dialect}".`,
-    );
-  }
+    const dialect = knex ? (0, knexUtils_1.getDialect)(knex) : null;
+    if (dialect === null || POSTGRES_DIALECTS.includes(dialect)) {
+        return 'postgres';
+    }
+    else if (MYSQL_DIALECTS.includes(dialect)) {
+        return 'mysql';
+    }
+    else {
+        throw new Error(`JSON field expressions are only supported on postgres and mysql. Tried to use "${expression}" with dialect "${dialect}".`);
+    }
 }
-
-module.exports = {
-  toPgTextArray,
-  toPgStringLiteral,
-  toPgJsonPathLiteral,
-  toPgQuotedColumn,
-  getJsonDialect,
-};

package/lib/utils/promiseUtils/after.js

@@ -1,17 +1,14 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.after = after;
+const isPromise_1 = require("./isPromise");
 // Call `func` after `obj` has been resolved. Call `func` synchronously if
 // `obj` is not a promise for performance reasons.
 function after(obj, func) {
-  if (isPromise(obj)) {
-    return obj.then(func);
-  } else {
-    return func(obj);
-  }
+    if ((0, isPromise_1.isPromise)(obj)) {
+        return obj.then(func);
+    }
+    else {
+        return func(obj);
+    }
 }
-
-module.exports = {
-  after,
-};

package/lib/utils/promiseUtils/afterReturn.js

@@ -1,17 +1,14 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterReturn = afterReturn;
+const isPromise_1 = require("./isPromise");
 // Return `returnValue` after `obj` has been resolved. Return `returnValue`
 // synchronously if `obj` is not a promise for performance reasons.
 function afterReturn(obj, returnValue) {
-  if (isPromise(obj)) {
-    return obj.then(() => returnValue);
-  } else {
-    return returnValue;
-  }
+    if ((0, isPromise_1.isPromise)(obj)) {
+        return obj.then(() => returnValue);
+    }
+    else {
+        return returnValue;
+    }
 }
-
-module.exports = {
-  afterReturn,
-};

package/lib/utils/promiseUtils/index.js

@@ -1,17 +1,15 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-const { after } = require('./after');
-const { afterReturn } = require('./afterReturn');
-const { mapAfterAllReturn } = require('./mapAfterAllReturn');
-const { promiseMap } = require('./map');
-const { promiseTry } = require('./try');
-
-module.exports = {
-  isPromise,
-  after,
-  afterReturn,
-  mapAfterAllReturn,
-  map: promiseMap,
-  try: promiseTry,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.try = exports.map = exports.mapAfterAllReturn = exports.afterReturn = exports.after = exports.isPromise = void 0;
+const isPromise_1 = require("./isPromise");
+Object.defineProperty(exports, "isPromise", { enumerable: true, get: function () { return isPromise_1.isPromise; } });
+const after_1 = require("./after");
+Object.defineProperty(exports, "after", { enumerable: true, get: function () { return after_1.after; } });
+const afterReturn_1 = require("./afterReturn");
+Object.defineProperty(exports, "afterReturn", { enumerable: true, get: function () { return afterReturn_1.afterReturn; } });
+const mapAfterAllReturn_1 = require("./mapAfterAllReturn");
+Object.defineProperty(exports, "mapAfterAllReturn", { enumerable: true, get: function () { return mapAfterAllReturn_1.mapAfterAllReturn; } });
+const map_1 = require("./map");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return map_1.promiseMap; } });
+const try_1 = require("./try");
+Object.defineProperty(exports, "try", { enumerable: true, get: function () { return try_1.promiseTry; } });

package/lib/utils/promiseUtils/isPromise.js

@@ -1,11 +1,8 @@
-'use strict';
-
-const { isObject, isFunction } = require('../objectUtils');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = isPromise;
+const objectUtils_1 = require("../objectUtils");
+// The `T &` keeps an `any` argument `any`.
 function isPromise(obj) {
-  return isObject(obj) && isFunction(obj.then);
+    return (0, objectUtils_1.isObject)(obj) && (0, objectUtils_1.isFunction)(obj.then);
 }
-
-module.exports = {
-  isPromise,
-};

package/lib/utils/promiseUtils/map.js

@@ -1,110 +1,96 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseMap = promiseMap;
+const isPromise_1 = require("./isPromise");
 // Works like Bluebird.map.
 function promiseMap(items, mapper, opt) {
-  switch (items.length) {
-    case 0:
-      return mapZero();
-    case 1:
-      return mapOne(items, mapper);
-    default:
-      return mapMany(items, mapper, opt);
-  }
+    switch (items.length) {
+        case 0:
+            return mapZero();
+        case 1:
+            return mapOne(items, mapper);
+        default:
+            return mapMany(items, mapper, opt);
+    }
 }
-
 function mapZero() {
-  return Promise.resolve([]);
+    return Promise.resolve([]);
 }
-
 function mapOne(items, mapper) {
-  try {
-    const maybePromise = mapper(items[0], 0);
-
-    if (isPromise(maybePromise)) {
-      return maybePromise.then(wrapArray);
-    } else {
-      return Promise.resolve(wrapArray(maybePromise));
+    try {
+        const maybePromise = mapper(items[0], 0);
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            return maybePromise.then(wrapArray);
+        }
+        else {
+            return Promise.resolve(wrapArray(maybePromise));
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
     }
-  } catch (err) {
-    return Promise.reject(err);
-  }
 }
-
 function wrapArray(item) {
-  return [item];
+    return [item];
 }
-
 function mapMany(items, mapper, opt = {}) {
-  return new Promise((resolve, reject) => {
-    const concurrency = opt.concurrency || Number.MAX_SAFE_INTEGER;
-
-    const ctx = {
-      reject,
-      resolve,
-      rejected: false,
-      index: 0,
-      numFinished: 0,
-      results: new Array(items.length),
-      items,
-      mapper,
-    };
-
-    while (ctx.index < concurrency && ctx.index < items.length && !ctx.rejected) {
-      executeNext(ctx);
-    }
-  });
+    return new Promise((resolve, reject) => {
+        const concurrency = opt.concurrency || Number.MAX_SAFE_INTEGER;
+        const ctx = {
+            reject,
+            resolve,
+            rejected: false,
+            index: 0,
+            numFinished: 0,
+            results: new Array(items.length),
+            items,
+            mapper,
+        };
+        while (ctx.index < concurrency && ctx.index < items.length && !ctx.rejected) {
+            executeNext(ctx);
+        }
+    });
 }
-
 function executeNext(ctx) {
-  try {
-    if (ctx.rejected) {
-      return;
+    try {
+        if (ctx.rejected) {
+            return;
+        }
+        const index = ctx.index++;
+        const item = ctx.items[index];
+        const maybePromise = ctx.mapper(item, index);
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            // `catch` is called on the result of `then`, so the value is used as a
+            // promise. Promises and query builders have both.
+            maybePromise
+                .then((result) => afterExecute(ctx, result, index))
+                .catch((err) => onError(ctx, err));
+        }
+        else {
+            process.nextTick(() => afterExecute(ctx, maybePromise, index));
+        }
+        return null;
     }
-
-    const index = ctx.index++;
-    const item = ctx.items[index];
-    const maybePromise = ctx.mapper(item, index);
-
-    if (isPromise(maybePromise)) {
-      maybePromise
-        .then((result) => afterExecute(ctx, result, index))
-        .catch((err) => onError(ctx, err));
-    } else {
-      process.nextTick(() => afterExecute(ctx, maybePromise, index));
+    catch (err) {
+        onError(ctx, err);
+        return undefined;
     }
-
-    return null;
-  } catch (err) {
-    onError(ctx, err);
-  }
 }
-
 function afterExecute(ctx, result, index) {
-  if (ctx.rejected) {
+    if (ctx.rejected) {
+        return null;
+    }
+    ctx.results[index] = result;
+    ctx.numFinished++;
+    if (ctx.numFinished === ctx.items.length) {
+        ctx.resolve(ctx.results);
+    }
+    if (ctx.index < ctx.items.length) {
+        executeNext(ctx);
+    }
     return null;
-  }
-
-  ctx.results[index] = result;
-  ctx.numFinished++;
-
-  if (ctx.numFinished === ctx.items.length) {
-    ctx.resolve(ctx.results);
-  }
-
-  if (ctx.index < ctx.items.length) {
-    executeNext(ctx);
-  }
-
-  return null;
 }
-
 function onError(ctx, err) {
-  ctx.rejected = true;
-  ctx.reject(err);
+    ctx.rejected = true;
+    ctx.reject(err);
 }
-
-module.exports = {
-  promiseMap,
-};

package/lib/utils/promiseUtils/mapAfterAllReturn.js

@@ -1,29 +1,23 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAfterAllReturn = mapAfterAllReturn;
+const isPromise_1 = require("./isPromise");
 // Map `arr` with `mapper` and after that return `returnValue`. If none of
 // the mapped values is a promise, return synchronously for performance
 // reasons.
 function mapAfterAllReturn(arr, mapper, returnValue) {
-  const results = new Array(arr.length);
-  let containsPromise = false;
-
-  for (let i = 0, l = arr.length; i < l; ++i) {
-    results[i] = mapper(arr[i]);
-
-    if (isPromise(results[i])) {
-      containsPromise = true;
+    const results = new Array(arr.length);
+    let containsPromise = false;
+    for (let i = 0, l = arr.length; i < l; ++i) {
+        results[i] = mapper(arr[i]);
+        if ((0, isPromise_1.isPromise)(results[i])) {
+            containsPromise = true;
+        }
+    }
+    if (containsPromise) {
+        return Promise.all(results).then(() => returnValue);
+    }
+    else {
+        return returnValue;
     }
-  }
-
-  if (containsPromise) {
-    return Promise.all(results).then(() => returnValue);
-  } else {
-    return returnValue;
-  }
 }
-
-module.exports = {
-  mapAfterAllReturn,
-};

package/lib/utils/promiseUtils/try.js

@@ -1,22 +1,19 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTry = promiseTry;
+const isPromise_1 = require("./isPromise");
 // Works like Bluebird.try.
 function promiseTry(callback) {
-  try {
-    const maybePromise = callback();
-
-    if (isPromise(maybePromise)) {
-      return maybePromise;
-    } else {
-      return Promise.resolve(maybePromise);
+    try {
+        const maybePromise = callback();
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            return maybePromise;
+        }
+        else {
+            return Promise.resolve(maybePromise);
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
     }
-  } catch (err) {
-    return Promise.reject(err);
-  }
 }
-
-module.exports = {
-  promiseTry,
-};