@jskit-ai/database-runtime 0.1.159 → 0.1.161

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@jskit-ai/database-runtime",
-  "version": "0.1.159",
+  "version": "0.1.161",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
     "./client": "./src/client/index.js",
-    "./server/providers/DatabaseRuntimeServiceProvider": "./src/server/providers/DatabaseRuntimeServiceProvider.js",
+    "./server/providers/DatabaseProvider": "./src/server/providers/DatabaseProvider.js",
+    "./server/databaseSetup": "./src/server/databaseSetup.js",
+    "./server/knexMigrationConfig": "./src/server/knexMigrationConfig.js",
     "./shared": "./src/shared/index.js",
     "./shared/dateUtils": "./src/shared/dateUtils.js",
     "./shared/databaseClient": "./src/shared/databaseClient.js",
@@ -25,7 +27,8 @@
     "./shared/transactions": "./src/shared/transactions.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.159"
+    "@jskit-ai/kernel": "0.1.161",
+    "knex": "^3.1.0"
   },
   "jskit": {
     "kind": "runtime",
@@ -39,11 +42,10 @@
     },
     "runtime": {
       "server": {
-        "providerEntrypoint": "src/server/providers/DatabaseRuntimeServiceProvider.js",
         "providers": [
           {
-            "entrypoint": "src/server/providers/DatabaseRuntimeServiceProvider.js",
-            "export": "DatabaseRuntimeServiceProvider"
+            "entrypoint": "src/server/providers/DatabaseProvider.js",
+            "export": "DatabaseProvider"
           }
         ]
       },
@@ -56,7 +58,15 @@
         "surfaces": [
           {
             "subpath": "./server",
-            "summary": "Exports DatabaseRuntimeServiceProvider plus registerDatabaseRuntime for server container wiring."
+            "summary": "Provides the cohesive runtime.database capability with Knex, transactions, the selected driver, and repository utilities."
+          },
+          {
+            "subpath": "./server/databaseSetup",
+            "summary": "Migrates the installed package graph and runs one explicit app-owned seed operation without a CLI or persistent setup record."
+          },
+          {
+            "subpath": "./server/knexMigrationConfig",
+            "summary": "Builds fixed-dialect Knex migration configuration and discovers immutable migrations directly from installed JSKIT packages."
           },
           {
             "subpath": "./shared",
@@ -66,71 +76,8 @@
             "subpath": "./client",
             "summary": "Exports no runtime API today (reserved client entrypoint)."
           }
-        ],
-        "containerTokens": {
-          "server": [
-            "runtime.database",
-            "runtime.database.driver",
-            "jskit.database.knex",
-            "jskit.database.transactionManager"
-          ],
-          "client": []
-        }
+        ]
       }
-    },
-    "ci": {
-      "environment": {},
-      "services": [],
-      "steps": [
-        {
-          "id": "database-migrations",
-          "phase": "before-verify",
-          "label": "Apply database migrations",
-          "command": "npm run db:migrate"
-        }
-      ]
-    },
-    "mutations": {
-      "dependencies": {
-        "runtime": {
-          "@jskit-ai/kernel": "0.1.159",
-          "dotenv": "^16.4.5",
-          "knex": "^3.1.0"
-        },
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {
-          "db:migrations:sync": "jskit migrations sync",
-          "db:migrate": "npm run db:migrations:sync && knex --knexfile ./knexfile.js migrate:latest",
-          "db:migrate:rollback": "knex --knexfile ./knexfile.js migrate:rollback",
-          "db:migrate:status": "npm run db:migrations:sync && knex --knexfile ./knexfile.js migrate:list"
-        }
-      },
-      "procfile": {},
-      "files": [
-        {
-          "from": "templates/knexfile.js",
-          "to": "knexfile.js",
-          "reason": "Install root Knex configuration so app scripts can run migrations through Knex CLI.",
-          "category": "database-runtime",
-          "id": "database-runtime-knexfile"
-        },
-        {
-          "from": "templates/migrations/.gitkeep",
-          "to": "migrations/.gitkeep",
-          "reason": "Ensure migrations directory exists so Knex migration commands can run before any module installs migrations.",
-          "category": "database-runtime",
-          "id": "database-runtime-migrations-dir"
-        },
-        {
-          "from": "templates/migrations/constraints/.gitkeep",
-          "to": "migrations/constraints/.gitkeep",
-          "reason": "Ensure the ordered deferred-constraint migration directory exists.",
-          "category": "database-runtime",
-          "id": "database-runtime-constraint-migrations-dir"
-        }
-      ]
     }
   }
 }

package/src/server/databaseSetup.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { createKnexMigrationConfigFromApp } from "./knexMigrationConfig.js";
+import { loadKnexFactory } from "./knexFactory.js";
+
+function normalizeMigrationResult(result) {
+  const [batchValue, migrationValues] = Array.isArray(result) ? result : [];
+  const batch = Number.isSafeInteger(batchValue) ? batchValue : 0;
+  const migrations = Array.isArray(migrationValues)
+    ? migrationValues.map((value) => String(value || "").trim()).filter(Boolean)
+    : [];
+  return Object.freeze({ batch, migrations: Object.freeze(migrations) });
+}
+
+async function runDatabaseSetup({ knex, seed, appRoot = process.cwd(), environment = process.env } = {}) {
+  if (!knex || typeof knex !== "function" || typeof knex.migrate?.latest !== "function") {
+    throw new TypeError("runDatabaseSetup requires a Knex instance.");
+  }
+  if (typeof seed !== "undefined" && seed !== null && typeof seed !== "function") {
+    throw new TypeError("runDatabaseSetup seed must be a function when supplied.");
+  }
+
+  const migrationResult = normalizeMigrationResult(await knex.migrate.latest());
+  if (typeof seed !== "function") {
+    return Object.freeze({ ...migrationResult, seeded: false });
+  }
+  if (typeof knex.transaction !== "function") {
+    throw new TypeError("runDatabaseSetup requires Knex transaction support for seeding.");
+  }
+
+  await knex.transaction(async (transaction) => {
+    await seed(Object.freeze({
+      knex: transaction,
+      appRoot: path.resolve(appRoot),
+      environment
+    }));
+  });
+
+  return Object.freeze({ ...migrationResult, seeded: true });
+}
+
+async function prepareDatabaseFromApp({
+  client,
+  appRoot = process.cwd(),
+  environment = process.env,
+  migrationsDirectory = "migrations",
+  seed
+} = {}) {
+  const normalizedAppRoot = path.resolve(appRoot);
+  const config = await createKnexMigrationConfigFromApp({
+    client,
+    appRoot: normalizedAppRoot,
+    environment,
+    migrationsDirectory
+  });
+  const knex = loadKnexFactory()(config);
+
+  try {
+    return await runDatabaseSetup({
+      knex,
+      seed,
+      appRoot: normalizedAppRoot,
+      environment
+    });
+  } finally {
+    await knex.destroy();
+  }
+}
+
+export { prepareDatabaseFromApp, runDatabaseSetup };

package/src/server/knexFactory.js

@@ -0,0 +1,23 @@
+import { symlinkSafeRequire } from "@jskit-ai/kernel/server/support";
+
+function loadKnexFactory() {
+  let moduleValue;
+  try {
+    moduleValue = symlinkSafeRequire("knex");
+  } catch {
+    throw new Error("Knex package is not installed. Install the selected JSKIT database runtime package with npm.");
+  }
+
+  const knexFactory =
+    typeof moduleValue === "function"
+      ? moduleValue
+      : typeof moduleValue?.default === "function"
+        ? moduleValue.default
+        : null;
+  if (!knexFactory) {
+    throw new Error("Knex package resolved but did not expose a callable factory.");
+  }
+  return knexFactory;
+}
+
+export { loadKnexFactory };

package/src/server/knexMigrationConfig.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { discoverInstalledPackages } from "@jskit-ai/kernel/server/support";
+import {
+  normalizeDatabaseClient,
+  toKnexClientId
+} from "../shared/databaseClient.js";
+import { resolveKnexConnectionFromEnvironment } from "../shared/databaseConnection.js";
+
+function createKnexMigrationConfig({
+  client,
+  environment = process.env,
+  appRoot = process.cwd(),
+  migrationsDirectory = "migrations",
+  packageMigrationDirectories = []
+} = {}) {
+  const dialectId = normalizeDatabaseClient(client);
+  const resolvedMigrationsDirectory = path.resolve(appRoot, migrationsDirectory);
+
+  return {
+    client: toKnexClientId(dialectId),
+    connection: resolveKnexConnectionFromEnvironment(environment, {
+      client: dialectId,
+      defaultPort: dialectId === "pg" ? 5432 : 3306,
+      context: "knex migrations"
+    }),
+    migrations: {
+      directory: [
+        resolvedMigrationsDirectory,
+        ...packageMigrationDirectories.map((directory) => path.resolve(directory)),
+        path.join(resolvedMigrationsDirectory, "constraints")
+      ],
+      extension: "cjs",
+      sortDirsSeparately: true
+    }
+  };
+}
+
+async function directoryExists(directory) {
+  try {
+    await access(directory);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function discoverPackageMigrationDirectories({ appRoot = process.cwd() } = {}) {
+  const normalizedAppRoot = path.resolve(appRoot);
+  const directories = [];
+
+  for (const installedPackage of await discoverInstalledPackages({ appRoot: normalizedAppRoot })) {
+    const declaredDirectories = installedPackage.packageMetadata?.migrations?.directories;
+    if (typeof declaredDirectories === "undefined") {
+      continue;
+    }
+    if (!Array.isArray(declaredDirectories) || declaredDirectories.length < 1) {
+      throw new TypeError(
+        `${installedPackage.packageId} package.json#jskit.migrations.directories must be a non-empty array.`
+      );
+    }
+
+    for (const declaredDirectory of declaredDirectories) {
+      const relativeDirectory = String(declaredDirectory || "").trim();
+      if (
+        !relativeDirectory ||
+        path.isAbsolute(relativeDirectory) ||
+        relativeDirectory === ".." ||
+        relativeDirectory.startsWith(`..${path.sep}`)
+      ) {
+        throw new TypeError(
+          `${installedPackage.packageId} declares an invalid package migration directory: ${relativeDirectory || "<empty>"}.`
+        );
+      }
+      const absoluteDirectory = path.resolve(installedPackage.packageRoot, relativeDirectory);
+      const relativeToPackage = path.relative(installedPackage.packageRoot, absoluteDirectory);
+      if (relativeToPackage.startsWith(`..${path.sep}`) || path.isAbsolute(relativeToPackage)) {
+        throw new TypeError(
+          `${installedPackage.packageId} package migration directory escapes its package root: ${relativeDirectory}.`
+        );
+      }
+      if (!(await directoryExists(absoluteDirectory))) {
+        throw new Error(
+          `${installedPackage.packageId} declares a missing package migration directory: ${relativeDirectory}.`
+        );
+      }
+      directories.push(absoluteDirectory);
+    }
+  }
+
+  return Object.freeze([...new Set(directories)].sort((left, right) => left.localeCompare(right)));
+}
+
+async function createKnexMigrationConfigFromApp(options = {}) {
+  const appRoot = path.resolve(options.appRoot || process.cwd());
+  const packageMigrationDirectories = await discoverPackageMigrationDirectories({ appRoot });
+  return createKnexMigrationConfig({
+    ...options,
+    appRoot,
+    packageMigrationDirectories
+  });
+}
+
+export {
+  createKnexMigrationConfig,
+  createKnexMigrationConfigFromApp,
+  discoverPackageMigrationDirectories
+};

package/src/server/providers/DatabaseProvider.js

@@ -0,0 +1,64 @@
+import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import * as databaseUtilities from "../../shared/index.js";
+import { normalizeDatabaseClient, toKnexClientId } from "../../shared/databaseClient.js";
+import { resolveKnexConnectionFromEnvironment } from "../../shared/databaseConnection.js";
+import { createTransactionManager } from "../../shared/transactionManager.js";
+import { loadKnexFactory } from "../knexFactory.js";
+
+function resolveDriverDialectId(driver) {
+  const dialectId = normalizeDatabaseClient(
+    driver?.DIALECT_ID || driver?.dialectId || driver?.dialect || driver?.getDialectId?.(),
+    { allowEmpty: true }
+  );
+  if (!dialectId) {
+    throw new Error("The installed database driver did not expose a valid dialect id.");
+  }
+  return dialectId;
+}
+
+function createDatabase({ driver, env }) {
+  const dialectId = resolveDriverDialectId(driver);
+  const configuredClient = normalizeDatabaseClient(env.DB_CLIENT, { allowEmpty: true });
+  if (configuredClient && configuredClient !== dialectId) {
+    throw new Error(`DB_CLIENT="${configuredClient}" does not match installed database driver "${dialectId}".`);
+  }
+
+  const knex = loadKnexFactory()({
+    client: toKnexClientId(dialectId),
+    connection: resolveKnexConnectionFromEnvironment(env, {
+      client: dialectId,
+      defaultPort: dialectId === "pg" ? 5432 : 3306,
+      context: "database runtime"
+    })
+  });
+  const transactionManager = createTransactionManager({ knex });
+
+  return Object.freeze({
+    ...databaseUtilities,
+    driver,
+    knex,
+    transactionManager
+  });
+}
+
+const DatabaseProvider = defineProvider({
+  id: "runtime.database",
+  requires: {
+    env: "runtime.env",
+    driver: "runtime.database.driver"
+  },
+  provides: {
+    database: "runtime.database"
+  },
+  setup({ driver, env }) {
+    return { database: createDatabase({ driver, env }) };
+  },
+  async shutdown(_dependencies, { outputs }) {
+    const knex = outputs.database?.knex;
+    if (knex && typeof knex.destroy === "function") {
+      await knex.destroy();
+    }
+  }
+});
+
+export { DatabaseProvider };

package/src/shared/databaseConnection.js

@@ -132,7 +132,8 @@ function resolveKnexConnectionFromEnvironment(
       ...connection,
       supportBigNumbers: true,
       bigNumberStrings: true,
-      dateStrings: ["DATE"]
+      dateStrings: ["DATE"],
+      timezone: "Z"
     };
   }
 

package/src/shared/index.js

@@ -5,7 +5,6 @@ export {
 } from "./runtimeErrors.js";
 export { TransactionManager, createTransactionManager } from "./transactionManager.js";
 export { BaseRepository, buildPaginationMeta } from "./repository.js";
-export { registerDatabaseRuntime } from "./runtime.js";
 export {
   normalizeDateInput,
   toIsoString,
@@ -46,7 +45,8 @@ export {
   parseJsonValue,
   toDbJson,
   runInTransaction,
-  createWithTransaction
+  createWithTransaction,
+  lockScopedRecordId
 } from "./repositoryOptions.js";
 export {
   normalizeBatchSize,

package/src/shared/repositoryOptions.js

@@ -242,6 +242,42 @@ function createWithTransaction(knex) {
   };
 }
 
+function requireSqlIdentifier(value, label) {
+  const identifier = String(value || "").trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(identifier)) {
+    throw new TypeError(`${label} must be a safe SQL identifier.`);
+  }
+  return identifier;
+}
+
+async function lockScopedRecordId({
+  trx,
+  tableName,
+  recordId,
+  scopeId,
+  idColumn = "id",
+  scopeColumn = "workspace_id"
+} = {}) {
+  if (typeof trx !== "function") {
+    throw new TypeError("lockScopedRecordId requires a transaction.");
+  }
+  const table = requireSqlIdentifier(tableName, "lockScopedRecordId tableName");
+  const recordKey = requireSqlIdentifier(idColumn, "lockScopedRecordId idColumn");
+  const scopeKey = requireSqlIdentifier(scopeColumn, "lockScopedRecordId scopeColumn");
+  const normalizedRecordId = normalizeDbRecordId(recordId);
+  const normalizedScopeId = normalizeDbRecordId(scopeId);
+  if (!normalizedRecordId || !normalizedScopeId) {
+    return null;
+  }
+  const row = await trx(table)
+    .select(recordKey)
+    .where(recordKey, normalizedRecordId)
+    .andWhere(scopeKey, normalizedScopeId)
+    .forUpdate()
+    .first();
+  return normalizeDbRecordId(row?.[recordKey]);
+}
+
 export {
   resolveQueryOptions,
   resolveRepoClient,
@@ -260,5 +296,6 @@ export {
   parseJsonValue,
   toDbJson,
   runInTransaction,
-  createWithTransaction
+  createWithTransaction,
+  lockScopedRecordId
 };

package/test/databaseConnection.test.js

@@ -87,6 +87,7 @@ test("resolveKnexConnectionFromEnvironment keeps only MySQL DATE columns as stri
   assert.deepEqual(mysqlConnection.dateStrings, ["DATE"]);
   assert.equal(mysqlConnection.supportBigNumbers, true);
   assert.equal(mysqlConnection.bigNumberStrings, true);
+  assert.equal(mysqlConnection.timezone, "Z");
 
   const postgresConnection = resolveKnexConnectionFromEnvironment({
     DB_CLIENT: "pg",
@@ -100,4 +101,5 @@ test("resolveKnexConnectionFromEnvironment keeps only MySQL DATE columns as stri
   });
 
   assert.equal(postgresConnection.dateStrings, undefined);
+  assert.equal(postgresConnection.timezone, undefined);
 });

package/test/databaseSetup.test.js

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { runDatabaseSetup } from "../src/server/databaseSetup.js";
+
+function fakeKnex({ migrationResult = [3, ["users.cjs"]] } = {}) {
+  const calls = [];
+  const transaction = Object.freeze({ id: "transaction" });
+  const knex = function knex() {};
+  knex.migrate = {
+    async latest() {
+      calls.push("migrate");
+      return migrationResult;
+    }
+  };
+  knex.transaction = async (callback) => {
+    calls.push("transaction:start");
+    await callback(transaction);
+    calls.push("transaction:commit");
+  };
+  return { calls, knex, transaction };
+}
+
+test("runDatabaseSetup migrates before one explicit app seed transaction", async () => {
+  const { calls, knex, transaction } = fakeKnex();
+  const environment = { DB_NAME: "session_database" };
+
+  const result = await runDatabaseSetup({
+    knex,
+    appRoot: "/srv/session/source",
+    environment,
+    async seed(context) {
+      calls.push("seed");
+      assert.equal(context.knex, transaction);
+      assert.equal(context.appRoot, "/srv/session/source");
+      assert.equal(context.environment, environment);
+    }
+  });
+
+  assert.deepEqual(calls, ["migrate", "transaction:start", "seed", "transaction:commit"]);
+  assert.deepEqual(result, {
+    batch: 3,
+    migrations: ["users.cjs"],
+    seeded: true
+  });
+});
+
+test("runDatabaseSetup supports applications with no seed operation", async () => {
+  const { calls, knex } = fakeKnex({ migrationResult: [0, []] });
+
+  assert.deepEqual(await runDatabaseSetup({ knex }), {
+    batch: 0,
+    migrations: [],
+    seeded: false
+  });
+  assert.deepEqual(calls, ["migrate"]);
+});
+
+test("runDatabaseSetup rejects a non-function seed", async () => {
+  const { knex } = fakeKnex();
+  await assert.rejects(
+    () => runDatabaseSetup({ knex, seed: "seed" }),
+    /seed must be a function/u
+  );
+});

package/test/entrypoints.boundary.test.js

@@ -4,15 +4,15 @@ import test from "node:test";
 
 import * as clientApi from "../src/client/index.js";
 import * as sharedApi from "../src/shared/index.js";
-import { DatabaseRuntimeServiceProvider } from "../src/server/providers/DatabaseRuntimeServiceProvider.js";
+import { DatabaseProvider } from "../src/server/providers/DatabaseProvider.js";
 
 test("package exports include explicit shared and provider entrypoints", async () => {
   const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
   const exportsMap = packageJson && typeof packageJson === "object" ? packageJson.exports : {};
   assert.equal(exportsMap["./server"], undefined);
   assert.equal(
-    exportsMap["./server/providers/DatabaseRuntimeServiceProvider"],
-    "./src/server/providers/DatabaseRuntimeServiceProvider.js"
+    exportsMap["./server/providers/DatabaseProvider"],
+    "./src/server/providers/DatabaseProvider.js"
   );
   assert.equal(exportsMap["./shared"], "./src/shared/index.js");
 });
@@ -21,14 +21,14 @@ test("client entrypoint exports no database runtime api", () => {
   assert.deepEqual(Object.keys(clientApi), []);
 });
 
-test("server provider module exports service provider only", () => {
-  assert.equal(typeof DatabaseRuntimeServiceProvider, "function");
+test("server provider module exports one declarative provider", () => {
+  assert.equal(DatabaseProvider.id, "runtime.database");
+  assert.deepEqual(DatabaseProvider.provides, { database: "runtime.database" });
 });
 
 test("shared entrypoint exports shared database utilities only", () => {
-  assert.equal(typeof sharedApi.registerDatabaseRuntime, "function");
   assert.equal(typeof sharedApi.createTransactionManager, "function");
   assert.equal(typeof sharedApi.isDuplicateEntryError, "function");
   assert.equal(typeof sharedApi.createRepositoryScope, "function");
-  assert.equal(typeof sharedApi.DatabaseRuntimeServiceProvider, "undefined");
+  assert.equal(typeof sharedApi.DatabaseProvider, "undefined");
 });

package/test/knexMigrationConfig.test.js

@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  createKnexMigrationConfig,
+  createKnexMigrationConfigFromApp,
+  discoverPackageMigrationDirectories
+} from "../src/server/knexMigrationConfig.js";
+
+const connectionEnvironment = Object.freeze({
+  DB_HOST: "127.0.0.1",
+  DB_NAME: "catalogue",
+  DB_USER: "catalogue_user",
+  DB_PASSWORD: "secret"
+});
+
+test("createKnexMigrationConfig fixes MySQL without requiring DB_CLIENT", () => {
+  const config = createKnexMigrationConfig({
+    client: "mysql2",
+    environment: connectionEnvironment,
+    appRoot: "/srv/catalogue"
+  });
+
+  assert.equal(config.client, "mysql2");
+  assert.equal(config.connection.port, 3306);
+  assert.deepEqual(config.migrations.directory, [
+    "/srv/catalogue/migrations",
+    "/srv/catalogue/migrations/constraints"
+  ]);
+});
+
+test("createKnexMigrationConfig fixes PostgreSQL without requiring DB_CLIENT", () => {
+  const config = createKnexMigrationConfig({
+    client: "pg",
+    environment: connectionEnvironment,
+    appRoot: "/srv/catalogue"
+  });
+
+  assert.equal(config.client, "pg");
+  assert.equal(config.connection.port, 5432);
+});
+
+test("installed package migrations run from their owning packages without copied projections", async (context) => {
+  const appRoot = await mkdtemp(path.join(os.tmpdir(), "jskit-package-migrations-"));
+  context.after(async () => {
+    await import("node:fs/promises").then(({ rm }) => rm(appRoot, { recursive: true, force: true }));
+  });
+
+  const packageRoot = path.join(appRoot, "node_modules", "@example", "accounts-core");
+  await mkdir(path.join(packageRoot, "migrations"), { recursive: true });
+  await writeFile(path.join(appRoot, "package.json"), JSON.stringify({
+    dependencies: { "@example/accounts-core": "1.0.0" }
+  }));
+  await writeFile(path.join(packageRoot, "package.json"), JSON.stringify({
+    name: "@example/accounts-core",
+    version: "1.0.0",
+    jskit: {
+      kind: "runtime",
+      runtime: { server: { providers: [] }, client: { providers: [] } },
+      migrations: { directories: ["migrations"] }
+    }
+  }));
+  await writeFile(path.join(packageRoot, "migrations", "accounts_initial.cjs"), "exports.up = async () => {};\n");
+
+  const directories = await discoverPackageMigrationDirectories({ appRoot });
+  assert.deepEqual(directories, [path.join(packageRoot, "migrations")]);
+
+  const config = await createKnexMigrationConfigFromApp({
+    client: "mysql2",
+    environment: connectionEnvironment,
+    appRoot
+  });
+  assert.deepEqual(config.migrations.directory, [
+    path.join(appRoot, "migrations"),
+    path.join(packageRoot, "migrations"),
+    path.join(appRoot, "migrations", "constraints")
+  ]);
+});