knex 0.95.13 → 1.0.1

package/lib/migrations/seed/Seeder.js

@@ -2,17 +2,10 @@
 // -------
 
 const path = require('path');
-const flatten = require('lodash/flatten');
-const extend = require('lodash/extend');
-const includes = require('lodash/includes');
-const { ensureDirectoryExists, getFilepathsInFolder } = require('../util/fs');
+const { ensureDirectoryExists } = require('../util/fs');
 const { writeJsFileUsingTemplate } = require('../util/template');
 const { yyyymmddhhmmss } = require('../util/timestamp');
-
-const filterByLoadExtensions = (extensions) => (value) => {
-  const extension = path.extname(value);
-  return includes(extensions, extension);
-};
+const { getMergedConfig } = require('./seeder-configuration-merger');
 
 // The new seeds we're performing, typically called from the `knex.seed`
 // interface on the main `knex` object. Passes the `knex` instance performing
@@ -20,27 +13,19 @@ const filterByLoadExtensions = (extensions) => (value) => {
 class Seeder {
   constructor(knex) {
     this.knex = knex;
-    this.config = this.setConfig(knex.client.config.seeds);
+    this.config = this.resolveConfig(knex.client.config.seeds);
   }
 
   // Runs seed files for the given environment.
   async run(config) {
-    this.config = this.setConfig(config);
-    let files = await this._listAll();
-    if (config && config.specific) {
-      files = files.filter((file) => path.basename(file) === config.specific);
-      if (files.length === 0) {
-        throw new Error(
-          `Invalid argument provided: the specific seed "${config.specific}" does not exist.`
-        );
-      }
-    }
+    this.config = this.resolveConfig(config);
+    const files = await this.config.seedSource.getSeeds(this.config);
     return this._runSeeds(files);
   }
 
   // Creates a new seed file, with a given name.
   async make(name, config) {
-    this.config = this.setConfig(config);
+    this.config = this.resolveConfig(config);
     if (!name)
       throw new Error('A name must be specified for the generated seed');
     await this._ensureFolder(config);
@@ -48,45 +33,26 @@ class Seeder {
     return seedPath;
   }
 
-  // Lists all available seed files as a sorted array.
-  async _listAll(config) {
-    this.config = this.setConfig(config);
-    const { loadExtensions, recursive } = this.config;
-    const seeds = flatten(
-      await Promise.all(
-        this._absoluteConfigDirs().map((d) =>
-          getFilepathsInFolder(d, recursive)
-        )
-      )
-    );
-    // if true, each dir are already sorted
-    // (getFilepathsInFolderRecursively does this)
-    // if false, we need to sort all the seeds
-    if (this.config.sortDirsSeparately) {
-      return seeds.filter(filterByLoadExtensions(loadExtensions));
-    } else {
-      return seeds.filter(filterByLoadExtensions(loadExtensions)).sort();
-    }
-  }
-
   // Ensures a folder for the seeds exist, dependent on the
   // seed config settings.
   _ensureFolder() {
-    const dirs = this._absoluteConfigDirs();
+    const dirs = this.config.seedSource._getConfigDirectories(
+      this.config.logger
+    );
     const promises = dirs.map(ensureDirectoryExists);
     return Promise.all(promises);
   }
 
   // Run seed files, in sequence.
-  _runSeeds(seeds) {
-    seeds.forEach((seed) => this._validateSeedStructure(seed));
+  async _runSeeds(seeds) {
+    for (const seed of seeds) {
+      await this._validateSeedStructure(seed);
+    }
     return this._waterfallBatch(seeds);
   }
 
-  // Validates seed files by requiring and checking for a `seed` function.
   async _validateSeedStructure(filepath) {
-    const importFile = require('../util/import-file'); // late import
-    const seed = await importFile(filepath);
+    const seed = await this.config.seedSource.getSeed(filepath);
     if (typeof seed.seed !== 'function') {
       throw new Error(
         `Invalid seed file: ${filepath} must have a seed function`
@@ -114,7 +80,9 @@ class Seeder {
 
   _getNewStubFilePath(name) {
     const fileName = this._getNewStubFileName(name);
-    const dirs = this._absoluteConfigDirs();
+    const dirs = this.config.seedSource._getConfigDirectories(
+      this.config.logger
+    );
     const dir = dirs.slice(-1)[0]; // Get last specified directory
     return path.join(dir, fileName);
   }
@@ -132,13 +100,17 @@ class Seeder {
     return seedPath;
   }
 
+  async _listAll(config) {
+    this.config = this.resolveConfig(config);
+    return this.config.seedSource.getSeeds(this.config);
+  }
+
   // Runs a batch of seed files.
   async _waterfallBatch(seeds) {
     const { knex } = this;
     const log = [];
     for (const seedPath of seeds) {
-      const importFile = require('../util/import-file'); // late import
-      const seed = await importFile(seedPath);
+      const seed = await this.config.seedSource.getSeed(seedPath);
       try {
         await seed.seed(knex);
         log.push(seedPath);
@@ -157,47 +129,8 @@ class Seeder {
     return [log];
   }
 
-  /**
-   * Return all the config directories
-   * @returns {string[]}
-   */
-  _absoluteConfigDirs() {
-    const directories = Array.isArray(this.config.directory)
-      ? this.config.directory
-      : [this.config.directory];
-    return directories.map((directory) => {
-      if (!directory) {
-        console.warn(
-          'Failed to resolve config file, knex cannot determine where to run or make seeds'
-        );
-      }
-      return path.resolve(process.cwd(), directory);
-    });
-  }
-
-  setConfig(config) {
-    return extend(
-      {
-        extension: 'js',
-        directory: './seeds',
-        loadExtensions: [
-          '.co',
-          '.coffee',
-          '.eg',
-          '.iced',
-          '.js',
-          '.litcoffee',
-          '.ls',
-          '.ts',
-          '.cjs',
-        ],
-        timestampFilenamePrefix: false,
-        sortDirsSeparately: false,
-        recursive: false,
-      },
-      this.config || {},
-      config
-    );
+  resolveConfig(config) {
+    return getMergedConfig(config, this.config, this.knex.client.logger);
   }
 }
 

package/lib/migrations/seed/seeder-configuration-merger.js

@@ -0,0 +1,60 @@
+const { FsSeeds } = require('./sources/fs-seeds');
+const Logger = require('../../logger');
+const { DEFAULT_LOAD_EXTENSIONS } = require('../common/MigrationsLoader');
+const defaultLogger = new Logger();
+
+const CONFIG_DEFAULT = Object.freeze({
+  extension: 'js',
+  directory: './seeds',
+  loadExtensions: DEFAULT_LOAD_EXTENSIONS,
+  specific: null,
+  timestampFilenamePrefix: false,
+  recursive: false,
+  sortDirsSeparately: false,
+});
+
+function getMergedConfig(config, currentConfig, logger = defaultLogger) {
+  // config is the user specified config, mergedConfig has defaults and current config
+  // applied to it.
+  const mergedConfig = Object.assign(
+    {},
+    CONFIG_DEFAULT,
+    currentConfig || {},
+    config,
+    {
+      logger,
+    }
+  );
+
+  if (
+    config &&
+    // If user specifies any FS related config,
+    // clear specified migrationSource to avoid ambiguity
+    (config.directory ||
+      config.sortDirsSeparately !== undefined ||
+      config.loadExtensions)
+  ) {
+    if (config.seedSource) {
+      logger.warn(
+        'FS-related option specified for seed configuration. This resets seedSource to default FsMigrations'
+      );
+    }
+    mergedConfig.seedSource = null;
+  }
+
+  // If the user has not specified any configs, we need to
+  // default to fs migrations to maintain compatibility
+  if (!mergedConfig.seedSource) {
+    mergedConfig.seedSource = new FsSeeds(
+      mergedConfig.directory,
+      mergedConfig.sortDirsSeparately,
+      mergedConfig.loadExtensions
+    );
+  }
+
+  return mergedConfig;
+}
+
+module.exports = {
+  getMergedConfig,
+};

package/lib/migrations/seed/sources/fs-seeds.js

@@ -0,0 +1,65 @@
+const path = require('path');
+const flatten = require('lodash/flatten');
+const includes = require('lodash/includes');
+const { AbstractMigrationsLoader } = require('../../common/MigrationsLoader');
+const { getFilepathsInFolder } = require('../../util/fs');
+
+const filterByLoadExtensions = (extensions) => (value) => {
+  const extension = path.extname(value);
+  return includes(extensions, extension);
+};
+
+class FsSeeds extends AbstractMigrationsLoader {
+  _getConfigDirectories(logger) {
+    const directories = this.migrationsPaths;
+    return directories.map((directory) => {
+      if (!directory) {
+        logger.warn(
+          'Empty value passed as a directory for Seeder, this is not supported.'
+        );
+      }
+      return path.resolve(process.cwd(), directory);
+    });
+  }
+
+  async getSeeds(config) {
+    const { loadExtensions, recursive, specific } = config;
+
+    const seeds = flatten(
+      await Promise.all(
+        this._getConfigDirectories(config.logger).map((d) =>
+          getFilepathsInFolder(d, recursive)
+        )
+      )
+    );
+
+    // if true, each dir are already sorted
+    // (getFilepathsInFolderRecursively does this)
+    // if false, we need to sort all the seeds
+    let files = seeds.filter(filterByLoadExtensions(loadExtensions));
+    if (!this.sortDirsSeparately) {
+      files.sort();
+    }
+
+    if (specific) {
+      files = files.filter((file) => path.basename(file) === specific);
+      if (files.length === 0) {
+        throw new Error(
+          `Invalid argument provided: the specific seed "${specific}" does not exist.`
+        );
+      }
+    }
+
+    return files;
+  }
+
+  async getSeed(filepath) {
+    const importFile = require('../../util/import-file'); // late import
+    const seed = await importFile(filepath);
+    return seed;
+  }
+}
+
+module.exports = {
+  FsSeeds,
+};

package/lib/migrations/seed/stub/js.stub

@@ -1,4 +1,7 @@
-
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> } 
+ */
 exports.seed = function(knex) {
   // Deletes ALL existing entries
   return knex('table_name').del()

package/lib/migrations/util/import-file.js

@@ -4,7 +4,6 @@ const isModuleType = require('./is-module-type');
  * imports 'mjs', else requires.
  * NOTE: require me late!
  * @param {string} filepath
- * @todo WARN on version 10 and '--experimental-modules' and '--esm'
  */
 module.exports = async function importFile(filepath) {
   return (await isModuleType(filepath))

package/lib/query/joinclause.js

@@ -70,16 +70,33 @@ class JoinClause {
     return this;
   }
 
-  // Adds a "using" clause to the current join.
-  using(column) {
-    return this.clauses.push({ type: 'onUsing', column, bool: this._bool() });
-  }
-
   // Adds an "or on" clause to the current join object.
   orOn(first, operator, second) {
     return this._bool('or').on.apply(this, arguments);
   }
 
+  onJsonPathEquals(columnFirst, jsonPathFirst, columnSecond, jsonPathSecond) {
+    this.clauses.push({
+      type: 'onJsonPathEquals',
+      columnFirst: columnFirst,
+      jsonPathFirst: jsonPathFirst,
+      columnSecond: columnSecond,
+      jsonPathSecond: jsonPathSecond,
+      bool: this._bool(),
+      not: this._not(),
+    });
+    return this;
+  }
+
+  orOnJsonPathEquals(columnFirst, jsonPathFirst, columnSecond, jsonPathSecond) {
+    return this._bool('or').onJsonPathEquals.apply(this, arguments);
+  }
+
+  // Adds a "using" clause to the current join.
+  using(column) {
+    return this.clauses.push({ type: 'onUsing', column, bool: this._bool() });
+  }
+
   onVal(first) {
     if (typeof first === 'object' && typeof first.toSQL !== 'function') {
       const keys = Object.keys(first);
@@ -247,5 +264,7 @@ JoinClause.prototype.andOnExists = JoinClause.prototype.onExists;
 JoinClause.prototype.andOnNotExists = JoinClause.prototype.onNotExists;
 JoinClause.prototype.andOnBetween = JoinClause.prototype.onBetween;
 JoinClause.prototype.andOnNotBetween = JoinClause.prototype.onNotBetween;
+JoinClause.prototype.andOnJsonPathEquals =
+  JoinClause.prototype.onJsonPathEquals;
 
 module.exports = JoinClause;

package/lib/query/method-constants.js

@@ -9,6 +9,7 @@ module.exports = [
   'column',
   'from',
   'fromJS',
+  'fromRaw',
   'into',
   'withSchema',
   'table',
@@ -24,6 +25,8 @@ module.exports = [
   'fullOuterJoin',
   'crossJoin',
   'where',
+  'whereLike',
+  'whereILike',
   'andWhere',
   'orWhere',
   'whereNot',
@@ -89,4 +92,38 @@ module.exports = [
   'truncate',
   'transacting',
   'connection',
+
+  // JSON methods
+
+  // Json manipulation functions
+  'jsonExtract',
+  'jsonSet',
+  'jsonInsert',
+  'jsonRemove',
+
+  // Wheres Json
+  'whereJsonObject',
+  'orWhereJsonObject',
+  'andWhereJsonObject',
+  'whereNotJsonObject',
+  'orWhereNotJsonObject',
+  'andWhereNotJsonObject',
+
+  'whereJsonPath',
+  'orWhereJsonPath',
+  'andWhereJsonPath',
+
+  'whereJsonSupersetOf',
+  'orWhereJsonSupersetOf',
+  'andWhereJsonSupersetOf',
+  'whereJsonNotSupersetOf',
+  'orWhereJsonNotSupersetOf',
+  'andWhereJsonNotSupersetOf',
+
+  'whereJsonSubsetOf',
+  'orWhereJsonSubsetOf',
+  'andWhereJsonSubsetOf',
+  'whereJsonNotSubsetOf',
+  'orWhereJsonNotSubsetOf',
+  'andWhereJsonNotSubsetOf',
 ];