knex 0.95.13 → 1.0.1

package/lib/dialects/sqlite3/schema/internal/sqlite-ddl-operations.js

@@ -1,13 +1,9 @@
-function createNewTable(sql, tablename, alteredName) {
-  return sql.replace(tablename, alteredName);
-}
-
 function copyData(sourceTable, targetTable, columns) {
-  return `INSERT INTO ${targetTable} SELECT ${
+  return `INSERT INTO "${targetTable}" SELECT ${
     columns === undefined
       ? '*'
       : columns.map((column) => `"${column}"`).join(', ')
-  } FROM ${sourceTable};`;
+  } FROM "${sourceTable}";`;
 }
 
 function dropOriginal(tableName) {
@@ -19,13 +15,27 @@ function renameTable(tableName, alteredName) {
 }
 
 function getTableSql(tableName) {
-  return `SELECT type, sql FROM sqlite_master WHERE (type="table" OR (type="index" AND sql IS NOT NULL)) AND tbl_name="${tableName}"`;
+  return `SELECT type, sql FROM sqlite_master WHERE (type='table' OR (type='index' AND sql IS NOT NULL)) AND tbl_name='${tableName}'`;
+}
+
+function isForeignCheckEnabled() {
+  return `PRAGMA foreign_keys`;
+}
+
+function setForeignCheck(enable) {
+  return `PRAGMA foreign_keys = ${enable ? 'ON' : 'OFF'}`;
+}
+
+function executeForeignCheck() {
+  return `PRAGMA foreign_key_check`;
 }
 
 module.exports = {
-  createNewTable,
   copyData,
   dropOriginal,
   renameTable,
   getTableSql,
+  isForeignCheckEnabled,
+  setForeignCheck,
+  executeForeignCheck,
 };

package/lib/dialects/sqlite3/schema/sqlite-columncompiler.js

@@ -7,6 +7,7 @@ class ColumnCompiler_SQLite3 extends ColumnCompiler {
   constructor() {
     super(...arguments);
     this.modifiers = ['nullable', 'defaultTo'];
+    this._addCheckModifiers();
   }
 
   // Types
@@ -17,6 +18,21 @@ class ColumnCompiler_SQLite3 extends ColumnCompiler {
       this.args[0]
     )} in ('${allowed.join("', '")}'))`;
   }
+
+  _pushAlterCheckQuery(checkPredicate, constraintName) {
+    throw new Error(
+      `Alter table with to add constraints is not permitted in SQLite`
+    );
+  }
+
+  checkRegex(regexes, constraintName) {
+    return this._check(
+      `${this.formatter.wrap(
+        this.getColumnName()
+      )} REGEXP ${this.client._escapeBinding(regexes)}`,
+      constraintName
+    );
+  }
 }
 
 ColumnCompiler_SQLite3.prototype.json = 'json';
@@ -26,5 +42,9 @@ ColumnCompiler_SQLite3.prototype.double =
   ColumnCompiler_SQLite3.prototype.floating =
     'float';
 ColumnCompiler_SQLite3.prototype.timestamp = 'datetime';
+// autoincrement without primary key is a syntax error in SQLite, so it's necessary
+ColumnCompiler_SQLite3.prototype.increments =
+  ColumnCompiler_SQLite3.prototype.bigincrements =
+    'integer not null primary key autoincrement';
 
 module.exports = ColumnCompiler_SQLite3;

package/lib/dialects/sqlite3/schema/sqlite-compiler.js

@@ -17,7 +17,7 @@ class SchemaCompiler_SQLite3 extends SchemaCompiler {
     const sql =
       `select * from sqlite_master ` +
       `where type = 'table' and name = ${this.client.parameter(
-        tableName,
+        this.formatter.wrap(tableName).replace(/`/g, ''),
         this.builder,
         this.bindingsHolder
       )}`;
@@ -55,21 +55,25 @@ class SchemaCompiler_SQLite3 extends SchemaCompiler {
       this[query.method].apply(this, query.args);
     }
 
-    const result = [];
     const commandSources = this.sequence;
-    for (const commandSource of commandSources) {
-      const command = commandSource.statementsProducer
-        ? await commandSource.statementsProducer()
-        : commandSource.sql;
 
-      if (Array.isArray(command)) {
-        result.push(...command);
-      } else {
-        result.push(command);
+    if (commandSources.length === 1 && commandSources[0].statementsProducer) {
+      return commandSources[0].statementsProducer();
+    } else {
+      const result = [];
+
+      for (const commandSource of commandSources) {
+        const command = commandSource.sql;
+
+        if (Array.isArray(command)) {
+          result.push(...command);
+        } else {
+          result.push(command);
+        }
       }
-    }
 
-    return { pre: [], sql: result, post: [] };
+      return { pre: [], sql: result, check: null, post: [] };
+    }
   }
 }
 

package/lib/dialects/sqlite3/schema/sqlite-tablecompiler.js

@@ -27,9 +27,14 @@ class TableCompiler_SQLite3 extends TableCompiler {
       sql += ' (' + columns.sql.join(', ');
       sql += this.foreignKeys() || '';
       sql += this.primaryKeys() || '';
+      sql += this._addChecks();
       sql += ')';
     }
     this.pushQuery(sql);
+
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   addColumns(columns, prefix, colCompilers) {
@@ -57,9 +62,9 @@ class TableCompiler_SQLite3 extends TableCompiler {
 
       this.pushQuery({
         sql: `PRAGMA table_info(${this.tableName()})`,
-        output(pragma) {
+        statementsProducer(pragma, connection) {
           return compiler.client
-            .ddl(compiler, pragma, this.connection)
+            .ddl(compiler, pragma, connection)
             .alterColumn(columnsInfo);
         },
       });
@@ -257,9 +262,14 @@ class TableCompiler_SQLite3 extends TableCompiler {
       if (constraintName) {
         constraintName = ' constraint ' + this.formatter.wrap(constraintName);
       }
-      return `,${constraintName} primary key (${this.formatter.columnize(
-        columns
-      )})`;
+      const needUniqueCols =
+        this.grouped.columns.filter((t) => t.builder._type === 'increments')
+          .length > 0;
+      // SQLite dont support autoincrement columns and composite primary keys (autoincrement is always primary key).
+      // You need to add unique index instead when you have autoincrement columns (https://stackoverflow.com/a/6154876/1535159)
+      return `,${constraintName} ${
+        needUniqueCols ? 'unique' : 'primary key'
+      } (${this.formatter.columnize(columns)})`;
     }
   }
 

package/lib/dialects/sqlite3/schema/sqlite-viewcompiler.js

@@ -1,11 +1,40 @@
 /* eslint max-len: 0 */
 
 const ViewCompiler = require('../../../schema/viewcompiler.js');
+const {
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
-class ViewCompiler_PG extends ViewCompiler {
+class ViewCompiler_SQLite3 extends ViewCompiler {
   constructor(client, viewCompiler) {
     super(client, viewCompiler);
   }
+  createOrReplace() {
+    const columns = this.columns;
+    const selectQuery = this.selectQuery.toString();
+    const viewName = this.viewName();
+
+    const columnList = columns
+      ? ' (' +
+        columnize_(
+          columns,
+          this.viewBuilder,
+          this.client,
+          this.bindingsHolder
+        ) +
+        ')'
+      : '';
+
+    const dropSql = `drop view if exists ${viewName}`;
+    const createSql = `create view ${viewName}${columnList} as ${selectQuery}`;
+
+    this.pushQuery({
+      sql: dropSql,
+    });
+    this.pushQuery({
+      sql: createSql,
+    });
+  }
 }
 
-module.exports = ViewCompiler_PG;
+module.exports = ViewCompiler_SQLite3;

package/lib/execution/runner.js

@@ -228,12 +228,47 @@ class Runner {
         undefined,
         this.connection
       );
-      const queryObjects = statements.map((statement) => ({
+
+      const sqlQueryObjects = statements.sql.map((statement) => ({
+        sql: statement,
+        bindings: query.bindings,
+      }));
+      const preQueryObjects = statements.pre.map((statement) => ({
         sql: statement,
         bindings: query.bindings,
       }));
+      const postQueryObjects = statements.post.map((statement) => ({
+        sql: statement,
+        bindings: query.bindings,
+      }));
+
+      let results = [];
+
+      await this.queryArray(preQueryObjects);
+
+      try {
+        await this.client.transaction(
+          async (trx) => {
+            const transactionRunner = new Runner(trx.client, this.builder);
+            transactionRunner.connection = this.connection;
+
+            results = await transactionRunner.queryArray(sqlQueryObjects);
+
+            if (statements.check) {
+              const foreignViolations = await trx.raw(statements.check);
+
+              if (foreignViolations.length > 0) {
+                throw new Error('FOREIGN KEY constraint failed');
+              }
+            }
+          },
+          { connection: this.connection }
+        );
+      } finally {
+        await this.queryArray(postQueryObjects);
+      }
 
-      return this.queryArray(queryObjects);
+      return results;
     }
 
     const results = [];

package/lib/knex-builder/FunctionHelper.js

@@ -13,6 +13,27 @@ class FunctionHelper {
     }
     return this.client.raw('CURRENT_TIMESTAMP');
   }
+
+  uuidToBin(uuid) {
+    const buf = Buffer.from(uuid.replace(/-/g, ''), 'hex');
+    return Buffer.concat([
+      buf.slice(6, 8),
+      buf.slice(4, 6),
+      buf.slice(0, 4),
+      buf.slice(8, 16),
+    ]);
+  }
+
+  binToUuid(bin) {
+    const buf = new Buffer(bin, 'hex');
+    return [
+      buf.toString('hex', 4, 8),
+      buf.toString('hex', 2, 4),
+      buf.toString('hex', 0, 2),
+      buf.toString('hex', 8, 10),
+      buf.toString('hex', 10, 16),
+    ].join('-');
+  }
 }
 
 module.exports = FunctionHelper;

package/lib/migrations/common/MigrationsLoader.js

@@ -0,0 +1,36 @@
+const path = require('path');
+const DEFAULT_LOAD_EXTENSIONS = Object.freeze([
+  '.co',
+  '.coffee',
+  '.eg',
+  '.iced',
+  '.js',
+  '.cjs',
+  '.litcoffee',
+  '.ls',
+  '.ts',
+]);
+
+class AbstractMigrationsLoader {
+  constructor(migrationDirectories, sortDirsSeparately, loadExtensions) {
+    this.sortDirsSeparately = sortDirsSeparately;
+
+    if (!Array.isArray(migrationDirectories)) {
+      migrationDirectories = [migrationDirectories];
+    }
+    this.migrationsPaths = migrationDirectories;
+    this.loadExtensions = loadExtensions || DEFAULT_LOAD_EXTENSIONS;
+  }
+
+  getFile(migrationsInfo) {
+    const absoluteDir = path.resolve(process.cwd(), migrationsInfo.directory);
+    const _path = path.join(absoluteDir, migrationsInfo.file);
+    const importFile = require('../util/import-file'); // late import
+    return importFile(_path);
+  }
+}
+
+module.exports = {
+  DEFAULT_LOAD_EXTENSIONS,
+  AbstractMigrationsLoader,
+};

package/lib/migrations/migrate/MigrationGenerator.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const { writeJsFileUsingTemplate } = require('../util/template');
-const { getMergedConfig } = require('./configuration-merger');
+const { getMergedConfig } = require('./migrator-configuration-merger');
 const { ensureDirectoryExists } = require('../util/fs');
 const { yyyymmddhhmmss } = require('../util/timestamp');
 

package/lib/migrations/migrate/Migrator.js

@@ -4,7 +4,6 @@ const differenceWith = require('lodash/differenceWith');
 const get = require('lodash/get');
 const isEmpty = require('lodash/isEmpty');
 const max = require('lodash/max');
-const { inherits } = require('util');
 const {
   getLockTableName,
   getTable,
@@ -13,16 +12,16 @@ const {
 const { getSchemaBuilder } = require('./table-creator');
 const migrationListResolver = require('./migration-list-resolver');
 const MigrationGenerator = require('./MigrationGenerator');
-const { getMergedConfig } = require('./configuration-merger');
+const { getMergedConfig } = require('./migrator-configuration-merger');
 const { isBoolean, isFunction } = require('../../util/is');
 
-function LockError(msg) {
-  this.name = 'MigrationLocked';
-  this.message = msg;
+class LockError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'MigrationLocked';
+  }
 }
 
-inherits(LockError, Error);
-
 // The new migration we're performing, typically called from the `knex.migrate`
 // interface on the main `knex` object. Passes the `knex` instance performing
 // the migration.
@@ -187,9 +186,11 @@ class Migrator {
           return all
             ? allMigrations
                 .filter((migration) => {
-                  return completedMigrations.includes(
-                    this.config.migrationSource.getMigrationName(migration)
-                  );
+                  return completedMigrations
+                    .map((migration) => migration.name)
+                    .includes(
+                      this.config.migrationSource.getMigrationName(migration)
+                    );
                 })
                 .reverse()
             : this._getLastBatch(val);
@@ -215,9 +216,9 @@ class Migrator {
       })
       .then(([all, completed]) => {
         const completedMigrations = all.filter((migration) => {
-          return completed.includes(
-            this.config.migrationSource.getMigrationName(migration)
-          );
+          return completed
+            .map((migration) => migration.name)
+            .includes(this.config.migrationSource.getMigrationName(migration));
         });
 
         let migrationToRun;
@@ -265,7 +266,7 @@ class Migrator {
     return migrationListResolver
       .listCompleted(this.config.tableName, this.config.schemaName, this.knex)
       .then((completed) => {
-        const val = max(completed.map((value) => value.split('_')[0]));
+        const val = max(completed.map((value) => value.name.split('_')[0]));
         return val === undefined ? 'none' : val;
       });
   }
@@ -327,7 +328,7 @@ class Migrator {
       .where('is_locked', '=', 0)
       .update({ is_locked: 1 })
       .then((rowCount) => {
-        if (rowCount != 1) {
+        if (rowCount !== 1) {
           throw new Error('Migration table is already locked');
         }
       });
@@ -570,18 +571,14 @@ function validateMigrationList(migrationSource, migrations) {
 }
 
 function getMissingMigrations(migrationSource, completed, all) {
-  return differenceWith(completed, all, (completedMigration, allMigration) => {
-    return (
-      completedMigration === migrationSource.getMigrationName(allMigration)
-    );
+  return differenceWith(completed, all, (c, a) => {
+    return c.name === migrationSource.getMigrationName(a);
   });
 }
 
 function getNewMigrations(migrationSource, all, completed) {
-  return differenceWith(all, completed, (allMigration, completedMigration) => {
-    return (
-      completedMigration === migrationSource.getMigrationName(allMigration)
-    );
+  return differenceWith(all, completed, (a, c) => {
+    return c.name === migrationSource.getMigrationName(a);
   });
 }
 

package/lib/migrations/migrate/migration-list-resolver.js

@@ -10,14 +10,11 @@ function listAll(migrationSource, loadExtensions) {
 // array.
 async function listCompleted(tableName, schemaName, trxOrKnex) {
   await ensureTable(tableName, schemaName, trxOrKnex);
-  const completedMigrations = await trxOrKnex
+
+  return await trxOrKnex
     .from(getTableName(tableName, schemaName))
     .orderBy('id')
     .select('name');
-
-  return completedMigrations.map((migration) => {
-    return migration.name;
-  });
 }
 
 // Gets the migration list from the migration directory specified in config, as well as

package/lib/migrations/migrate/{configuration-merger.js → migrator-configuration-merger.js}

@@ -1,8 +1,6 @@
-const {
-  FsMigrations,
-  DEFAULT_LOAD_EXTENSIONS,
-} = require('./sources/fs-migrations');
+const { FsMigrations } = require('./sources/fs-migrations');
 const Logger = require('../../logger');
+const { DEFAULT_LOAD_EXTENSIONS } = require('../common/MigrationsLoader');
 const defaultLogger = new Logger();
 
 const CONFIG_DEFAULT = Object.freeze({

package/lib/migrations/migrate/sources/fs-migrations.js

@@ -2,30 +2,9 @@ const path = require('path');
 const sortBy = require('lodash/sortBy');
 
 const { readdir } = require('../../util/fs');
+const { AbstractMigrationsLoader } = require('../../common/MigrationsLoader');
 
-const DEFAULT_LOAD_EXTENSIONS = Object.freeze([
-  '.co',
-  '.coffee',
-  '.eg',
-  '.iced',
-  '.js',
-  '.cjs',
-  '.litcoffee',
-  '.ls',
-  '.ts',
-]);
-
-class FsMigrations {
-  constructor(migrationDirectories, sortDirsSeparately, loadExtensions) {
-    this.sortDirsSeparately = sortDirsSeparately;
-
-    if (!Array.isArray(migrationDirectories)) {
-      migrationDirectories = [migrationDirectories];
-    }
-    this.migrationsPaths = migrationDirectories;
-    this.loadExtensions = loadExtensions || DEFAULT_LOAD_EXTENSIONS;
-  }
-
+class FsMigrations extends AbstractMigrationsLoader {
   /**
    * Gets the migration names
    * @returns Promise<string[]>
@@ -77,11 +56,8 @@ class FsMigrations {
     return migration.file;
   }
 
-  getMigration(migration) {
-    const absoluteDir = path.resolve(process.cwd(), migration.directory);
-    const _path = path.join(absoluteDir, migration.file);
-    const importFile = require('../../util/import-file'); // late import
-    return importFile(_path);
+  getMigration(migrationInfo) {
+    return this.getFile(migrationInfo);
   }
 }
 
@@ -94,6 +70,5 @@ function filterMigrations(migrationSource, migrations, loadExtensions) {
 }
 
 module.exports = {
-  DEFAULT_LOAD_EXTENSIONS,
   FsMigrations,
 };

package/lib/migrations/migrate/stub/js.stub

@@ -1,4 +1,7 @@
-
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
 exports.up = function(knex) {
   <% if (d.tableName) { %>
   return knex.schema.createTable("<%= d.tableName %>", function(t) {
@@ -8,6 +11,10 @@ exports.up = function(knex) {
   <% } %>
 };
 
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
 exports.down = function(knex) {
   <% if (d.tableName) { %>
   return knex.schema.dropTable("<%= d.tableName %>");

package/lib/migrations/migrate/stub/knexfile-js.stub

@@ -1,5 +1,8 @@
 // Update with your config settings.
 
+/**
+ * @type { Object.<string, import("knex").Knex.Config> }
+ */
 module.exports = {
 
   development: {

package/lib/migrations/migrate/stub/knexfile-ts.stub

@@ -1,7 +1,8 @@
-// Update with your config settings.
+import type { Knex } from "knex";
 
-module.exports = {
+// Update with your config settings.
 
+const config: { [key: string]: Knex.Config } = {
   development: {
     client: "sqlite3",
     connection: {
@@ -42,3 +43,5 @@ module.exports = {
   }
 
 };
+
+module.exports = config;

package/lib/migrations/migrate/table-creator.js

@@ -55,11 +55,12 @@ function _createMigrationLockTable(tableName, schemaName, trxOrKnex) {
 function _insertLockRowIfNeeded(tableName, schemaName, trxOrKnex) {
   const lockTableWithSchema = getLockTableNameWithSchema(tableName, schemaName);
   return trxOrKnex
-    .from(trxOrKnex.raw('?? (??)', [lockTableWithSchema, 'is_locked']))
-    .insert(function () {
-      return this.select(trxOrKnex.raw('?', [0])).whereNotExists(function () {
-        return this.select('*').from(lockTableWithSchema);
-      });
+    .select('*')
+    .from(lockTableWithSchema)
+    .then((data) => {
+      return !data.length
+        ? trxOrKnex.from(lockTableWithSchema).insert({ is_locked: 0 })
+        : null;
     });
 }