@backstage/backend-defaults 0.3.0-next.2 → 0.3.0

package/dist/database.cjs.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var backendCommon = require('@backstage/backend-common');
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var config = require('@backstage/config');
 var errors = require('@backstage/errors');
@@ -9,39 +8,15 @@ var lodash = require('lodash');
 var limiterFactory = require('p-limit');
 var yn = require('yn');
 var backendDevUtils = require('@backstage/backend-dev-utils');
-var fsExtra = require('fs-extra');
-var path = require('path');
+var fs = require('fs-extra');
+var platformPath = require('path');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
 var knexFactory__default = /*#__PURE__*/_interopDefaultCompat(knexFactory);
 var limiterFactory__default = /*#__PURE__*/_interopDefaultCompat(limiterFactory);
 var yn__default = /*#__PURE__*/_interopDefaultCompat(yn);
-var path__default = /*#__PURE__*/_interopDefaultCompat(path);
-
-const databaseServiceFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.database,
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig,
-    lifecycle: backendPluginApi.coreServices.lifecycle,
-    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
-  },
-  async createRootContext({ config: config$1 }) {
-    return config$1.getOptional("backend.database") ? backendCommon.DatabaseManager.fromConfig(config$1) : backendCommon.DatabaseManager.fromConfig(
-      new config.ConfigReader({
-        backend: {
-          database: { client: "better-sqlite3", connection: ":memory:" }
-        }
-      })
-    );
-  },
-  async factory({ pluginMetadata, lifecycle }, databaseManager) {
-    return databaseManager.forPlugin(pluginMetadata.getId(), {
-      pluginMetadata,
-      lifecycle
-    });
-  }
-});
+var platformPath__default = /*#__PURE__*/_interopDefaultCompat(platformPath);
 
 function defaultNameOverride(name) {
   return {
@@ -174,45 +149,28 @@ async function dropMysqlDatabase(dbConfig, ...databases) {
     await admin.destroy();
   }
 }
-const mysqlConnector = Object.freeze({
-  createClient: createMysqlDatabaseClient,
-  ensureDatabaseExists: ensureMysqlDatabaseExists,
-  createNameOverride: defaultNameOverride,
-  parseConnectionString: parseMysqlConnectionString,
-  dropDatabase: dropMysqlDatabase
-});
 function pluginPath$3(pluginId) {
   return `plugin.${pluginId}`;
 }
-function normalizeConnection$2(connection, client) {
+function normalizeConnection$2(connection) {
   if (typeof connection === "undefined" || connection === null) {
     return {};
   }
-  return typeof connection === "string" || connection instanceof String ? mysqlConnector.parseConnectionString(connection, client) : connection;
-}
-function createNameOverride$2(client, name) {
-  try {
-    return mysqlConnector.createNameOverride(name);
-  } catch (e) {
-    throw new errors.InputError(
-      `Unable to create database name override for '${client}' connector`,
-      e
-    );
-  }
+  return typeof connection === "string" || connection instanceof String ? parseMysqlConnectionString(connection) : connection;
 }
 class MysqlConnector {
   constructor(config, prefix) {
     this.config = config;
     this.prefix = prefix;
   }
-  async getClient(pluginId, deps) {
+  async getClient(pluginId, _deps) {
     const pluginConfig = new config.ConfigReader(
       this.getConfigForPlugin(pluginId)
     );
     const databaseName = this.getDatabaseName(pluginId);
     if (databaseName && this.getEnsureExistsConfig(pluginId)) {
       try {
-        await mysqlConnector.ensureDatabaseExists(pluginConfig, databaseName);
+        await ensureMysqlDatabaseExists(pluginConfig, databaseName);
       } catch (error) {
         throw new Error(
           `Failed to connect to the database to make sure that '${databaseName}' exists, ${error}`
@@ -229,10 +187,9 @@ class MysqlConnector {
       {},
       this.getDatabaseOverrides(pluginId)
     );
-    const client = mysqlConnector.createClient(
+    const client = createMysqlDatabaseClient(
       pluginConfig,
-      databaseClientOverrides,
-      deps
+      databaseClientOverrides
     );
     return client;
   }
@@ -309,17 +266,13 @@ class MysqlConnector {
    * unless `pluginDivisionMode` is set to `schema`.
    */
   getConnectionConfig(pluginId) {
-    const { client, overridden } = this.getClientType(pluginId);
-    let baseConnection = normalizeConnection$2(
-      this.config.get("connection"),
-      this.config.getString("client")
-    );
+    const { overridden } = this.getClientType(pluginId);
+    let baseConnection = normalizeConnection$2(this.config.get("connection"));
     if (this.getPluginDivisionModeConfig() !== "schema") {
       baseConnection = lodash.omit(baseConnection, "database");
     }
     const connection = normalizeConnection$2(
-      this.config.getOptional(`${pluginPath$3(pluginId)}.connection`),
-      client
+      this.config.getOptional(`${pluginPath$3(pluginId)}.connection`)
     );
     return {
       // include base connection if client type has not been overridden
@@ -353,7 +306,7 @@ class MysqlConnector {
    */
   getDatabaseOverrides(pluginId) {
     const databaseName = this.getDatabaseName(pluginId);
-    return databaseName ? createNameOverride$2(this.getClientType(pluginId).client, databaseName) : {};
+    return databaseName ? defaultNameOverride(databaseName) : {};
   }
 }
 
@@ -475,57 +428,28 @@ async function dropPgDatabase(dbConfig, ...databases) {
     await admin.destroy();
   }
 }
-const pgConnector = Object.freeze({
-  createClient: createPgDatabaseClient,
-  ensureDatabaseExists: ensurePgDatabaseExists,
-  ensureSchemaExists: ensurePgSchemaExists,
-  createNameOverride: defaultNameOverride,
-  createSchemaOverride: defaultSchemaOverride,
-  parseConnectionString: parsePgConnectionString,
-  dropDatabase: dropPgDatabase
-});
 function pluginPath$2(pluginId) {
   return `plugin.${pluginId}`;
 }
-function normalizeConnection$1(connection, client) {
+function normalizeConnection$1(connection) {
   if (typeof connection === "undefined" || connection === null) {
     return {};
   }
-  return typeof connection === "string" || connection instanceof String ? pgConnector.parseConnectionString(connection, client) : connection;
-}
-function createSchemaOverride(client, name) {
-  try {
-    return pgConnector.createSchemaOverride?.(name);
-  } catch (e) {
-    throw new errors.InputError(
-      `Unable to create database schema override for '${client}' connector`,
-      e
-    );
-  }
-}
-function createNameOverride$1(client, name) {
-  try {
-    return pgConnector.createNameOverride(name);
-  } catch (e) {
-    throw new errors.InputError(
-      `Unable to create database name override for '${client}' connector`,
-      e
-    );
-  }
+  return typeof connection === "string" || connection instanceof String ? parsePgConnectionString(connection) : connection;
 }
 class PgConnector {
   constructor(config, prefix) {
     this.config = config;
     this.prefix = prefix;
   }
-  async getClient(pluginId, deps) {
+  async getClient(pluginId, _deps) {
     const pluginConfig = new config.ConfigReader(
       this.getConfigForPlugin(pluginId)
     );
     const databaseName = this.getDatabaseName(pluginId);
     if (databaseName && this.getEnsureExistsConfig(pluginId)) {
       try {
-        await pgConnector.ensureDatabaseExists(pluginConfig, databaseName);
+        await ensurePgDatabaseExists(pluginConfig, databaseName);
       } catch (error) {
         throw new Error(
           `Failed to connect to the database to make sure that '${databaseName}' exists, ${error}`
@@ -534,10 +458,10 @@ class PgConnector {
     }
     let schemaOverrides;
     if (this.getPluginDivisionModeConfig() === "schema") {
-      schemaOverrides = this.getSchemaOverrides(pluginId);
+      schemaOverrides = defaultSchemaOverride(pluginId);
       if (this.getEnsureSchemaExistsConfig(pluginId) || this.getEnsureExistsConfig(pluginId)) {
         try {
-          await pgConnector.ensureSchemaExists(pluginConfig, pluginId);
+          await ensurePgSchemaExists(pluginConfig, pluginId);
         } catch (error) {
           throw new Error(
             `Failed to connect to the database to make sure that schema for plugin '${pluginId}' exists, ${error}`
@@ -550,10 +474,9 @@ class PgConnector {
       this.getDatabaseOverrides(pluginId),
       schemaOverrides
     );
-    const client = pgConnector.createClient(
+    const client = createPgDatabaseClient(
       pluginConfig,
-      databaseClientOverrides,
-      deps
+      databaseClientOverrides
     );
     return client;
   }
@@ -640,17 +563,13 @@ class PgConnector {
    * unless `pluginDivisionMode` is set to `schema`.
    */
   getConnectionConfig(pluginId) {
-    const { client, overridden } = this.getClientType(pluginId);
-    let baseConnection = normalizeConnection$1(
-      this.config.get("connection"),
-      this.config.getString("client")
-    );
+    const { overridden } = this.getClientType(pluginId);
+    let baseConnection = normalizeConnection$1(this.config.get("connection"));
     if (this.getPluginDivisionModeConfig() !== "schema") {
       baseConnection = lodash.omit(baseConnection, "database");
     }
     const connection = normalizeConnection$1(
-      this.config.getOptional(`${pluginPath$2(pluginId)}.connection`),
-      client
+      this.config.getOptional(`${pluginPath$2(pluginId)}.connection`)
     );
     baseConnection.application_name ||= `backstage_plugin_${pluginId}`;
     return {
@@ -677,16 +596,6 @@ class PgConnector {
       ...role && { role }
     };
   }
-  /**
-   * Provides a partial `Knex.Config` database schema override for a given
-   * plugin.
-   *
-   * @param pluginId - Target plugin to get database schema override
-   * @returns Partial `Knex.Config` with database schema override
-   */
-  getSchemaOverrides(pluginId) {
-    return createSchemaOverride(this.getClientType(pluginId).client, pluginId);
-  }
   /**
    * Provides a partial `Knex.Config`• database name override for a given plugin.
    *
@@ -695,7 +604,7 @@ class PgConnector {
    */
   getDatabaseOverrides(pluginId) {
     const databaseName = this.getDatabaseName(pluginId);
-    return databaseName ? createNameOverride$1(this.getClientType(pluginId).client, databaseName) : {};
+    return databaseName ? defaultNameOverride(databaseName) : {};
   }
 }
 
@@ -704,8 +613,8 @@ function createSqliteDatabaseClient(dbConfig, overrides, deps) {
   const connConfig = knexConfig.connection;
   const filename = connConfig.filename ?? ":memory:";
   if (filename !== ":memory:") {
-    const directory = path__default.default.dirname(filename);
-    fsExtra.ensureDirSync(directory);
+    const directory = platformPath__default.default.dirname(filename);
+    fs.ensureDirSync(directory);
   }
   let database;
   if (deps && filename === ":memory:") {
@@ -773,29 +682,14 @@ function parseSqliteConnectionString(name) {
     filename: name
   };
 }
-const sqliteConnector = Object.freeze({
-  createClient: createSqliteDatabaseClient,
-  createNameOverride: createSqliteNameOverride,
-  parseConnectionString: parseSqliteConnectionString
-});
 function pluginPath$1(pluginId) {
   return `plugin.${pluginId}`;
 }
-function normalizeConnection(connection, client) {
+function normalizeConnection(connection) {
   if (typeof connection === "undefined" || connection === null) {
     return {};
   }
-  return typeof connection === "string" || connection instanceof String ? sqliteConnector.parseConnectionString(connection, client) : connection;
-}
-function createNameOverride(client, name) {
-  try {
-    return sqliteConnector.createNameOverride(name);
-  } catch (e) {
-    throw new errors.InputError(
-      `Unable to create database name override for '${client}' connector`,
-      e
-    );
-  }
+  return typeof connection === "string" || connection instanceof String ? parseSqliteConnectionString(connection) : connection;
 }
 class Sqlite3Connector {
   constructor(config) {
@@ -808,14 +702,14 @@ class Sqlite3Connector {
     const pluginDivisionMode = this.getPluginDivisionModeConfig();
     if (pluginDivisionMode !== "database") {
       throw new Error(
-        `The SQLite driver does not suppoert plugin division mode '${pluginDivisionMode}'`
+        `The SQLite driver does not support plugin division mode '${pluginDivisionMode}'`
       );
     }
     const databaseClientOverrides = mergeDatabaseConfig(
       {},
       this.getDatabaseOverrides(pluginId)
     );
-    const client = sqliteConnector.createClient(
+    const client = createSqliteDatabaseClient(
       pluginConfig,
       databaseClientOverrides,
       deps
@@ -843,7 +737,7 @@ class Sqlite3Connector {
       return sqliteFilename;
     }
     const sqliteDirectory = connection.directory ?? ".";
-    return path__default.default.join(sqliteDirectory, sqliteFilename ?? `${pluginId}.sqlite`);
+    return platformPath__default.default.join(sqliteDirectory, sqliteFilename ?? `${pluginId}.sqlite`);
   }
   /**
    * Provides the client type which should be used for a given plugin.
@@ -897,10 +791,7 @@ class Sqlite3Connector {
    */
   getConnectionConfig(pluginId) {
     const { client, overridden } = this.getClientType(pluginId);
-    let baseConnection = normalizeConnection(
-      this.config.get("connection"),
-      this.config.getString("client")
-    );
+    let baseConnection = normalizeConnection(this.config.get("connection"));
     if (client.includes("sqlite3") && "filename" in baseConnection && baseConnection.filename !== ":memory:") {
       throw new Error(
         "`connection.filename` is not supported for the base sqlite connection. Prefer `connection.directory` or provide a filename for the plugin connection instead."
@@ -910,8 +801,7 @@ class Sqlite3Connector {
       baseConnection = lodash.omit(baseConnection, "database");
     }
     const connection = normalizeConnection(
-      this.config.getOptional(`${pluginPath$1(pluginId)}.connection`),
-      client
+      this.config.getOptional(`${pluginPath$1(pluginId)}.connection`)
     );
     return {
       // include base connection if client type has not been overridden
@@ -945,7 +835,7 @@ class Sqlite3Connector {
    */
   getDatabaseOverrides(pluginId) {
     const databaseName = this.getDatabaseName(pluginId);
-    return databaseName ? createNameOverride(this.getClientType(pluginId).client, databaseName) : {};
+    return databaseName ? createSqliteNameOverride(databaseName) : {};
   }
 }
 
@@ -1087,6 +977,30 @@ async function dropDatabase(dbConfig, ...databaseNames) {
   }
 }
 
+const databaseServiceFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.database,
+  deps: {
+    config: backendPluginApi.coreServices.rootConfig,
+    lifecycle: backendPluginApi.coreServices.lifecycle,
+    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
+  },
+  async createRootContext({ config: config$1 }) {
+    return config$1.getOptional("backend.database") ? DatabaseManager.fromConfig(config$1) : DatabaseManager.fromConfig(
+      new config.ConfigReader({
+        backend: {
+          database: { client: "better-sqlite3", connection: ":memory:" }
+        }
+      })
+    );
+  },
+  async factory({ pluginMetadata, lifecycle }, databaseManager) {
+    return databaseManager.forPlugin(pluginMetadata.getId(), {
+      pluginMetadata,
+      lifecycle
+    });
+  }
+});
+
 exports.DatabaseManager = DatabaseManager;
 exports.databaseServiceFactory = databaseServiceFactory;
 exports.dropDatabase = dropDatabase;