@backstage/backend-test-utils 0.3.8-next.2 → 0.3.9-next.0

package/dist/index.cjs.js

@@ -6,11 +6,11 @@ var crypto = require('crypto');
 var createConnection = require('knex');
 var uuid = require('uuid');
 var os = require('os');
+var backendPluginApi = require('@backstage/backend-plugin-api');
 var fs = require('fs-extra');
 var textextensions = require('textextensions');
 var path = require('path');
 var backendAppApi = require('@backstage/backend-app-api');
-var backendPluginApi = require('@backstage/backend-plugin-api');
 var errors = require('@backstage/errors');
 var cookie = require('cookie');
 var pluginEventsNode = require('@backstage/plugin-events-node');
@@ -29,14 +29,13 @@ function isDockerDisabledForTests() {
 }
 
 async function waitForMysqlReady(connection) {
-  var _a;
   const startTime = Date.now();
   const db = createConnection__default.default({ client: "mysql2", connection });
   try {
     for (; ; ) {
       try {
         const result = await db.select(db.raw("version() AS version"));
-        if ((_a = result[0]) == null ? void 0 : _a.version) {
+        if (result[0]?.version) {
           return;
         }
       } catch (e) {
@@ -67,14 +66,13 @@ async function startMysqlContainer(image) {
 }
 
 async function waitForPostgresReady(connection) {
-  var _a;
   const startTime = Date.now();
   const db = createConnection__default.default({ client: "pg", connection });
   try {
     for (; ; ) {
       try {
         const result = await db.select(db.raw("version()"));
-        if (Array.isArray(result) && ((_a = result[0]) == null ? void 0 : _a.version)) {
+        if (Array.isArray(result) && result[0]?.version) {
           return;
         }
       } catch (e) {
@@ -163,25 +161,16 @@ const allDatabases = Object.freeze({
   }
 });
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 const LARGER_POOL_CONFIG = {
   pool: {
     min: 0,
     max: 50
   }
 };
-const _TestDatabases = class _TestDatabases {
-  constructor(supportedIds) {
-    __publicField$3(this, "instanceById");
-    __publicField$3(this, "supportedIds");
-    this.instanceById = /* @__PURE__ */ new Map();
-    this.supportedIds = supportedIds;
-  }
+class TestDatabases {
+  instanceById;
+  supportedIds;
+  static defaultIds;
   /**
    * Creates an empty `TestDatabases` instance, and sets up Jest to clean up
    * all of its acquired resources after all tests finish.
@@ -194,14 +183,13 @@ const _TestDatabases = class _TestDatabases {
    * is very fast.
    */
   static create(options) {
-    var _a;
-    const ids = options == null ? void 0 : options.ids;
-    const disableDocker = (_a = options == null ? void 0 : options.disableDocker) != null ? _a : isDockerDisabledForTests();
+    const ids = options?.ids;
+    const disableDocker = options?.disableDocker ?? isDockerDisabledForTests();
     let testDatabaseIds;
     if (ids) {
       testDatabaseIds = ids;
-    } else if (_TestDatabases.defaultIds) {
-      testDatabaseIds = _TestDatabases.defaultIds;
+    } else if (TestDatabases.defaultIds) {
+      testDatabaseIds = TestDatabases.defaultIds;
     } else {
       testDatabaseIds = Object.keys(allDatabases);
     }
@@ -221,7 +209,7 @@ const _TestDatabases = class _TestDatabases {
       }
       return true;
     });
-    const databases = new _TestDatabases(supportedIds);
+    const databases = new TestDatabases(supportedIds);
     if (supportedIds.length > 0) {
       afterAll(async () => {
         await databases.shutdown();
@@ -230,7 +218,11 @@ const _TestDatabases = class _TestDatabases {
     return databases;
   }
   static setDefaults(options) {
-    _TestDatabases.defaultIds = options.ids;
+    TestDatabases.defaultIds = options.ids;
+  }
+  constructor(supportedIds) {
+    this.instanceById = /* @__PURE__ */ new Map();
+    this.supportedIds = supportedIds;
   }
   supports(id) {
     return this.supportedIds.includes(id);
@@ -396,14 +388,14 @@ const _TestDatabases = class _TestDatabases {
         }
       }
       try {
-        await (dropDatabases == null ? void 0 : dropDatabases());
+        await dropDatabases?.();
       } catch (error) {
         console.warn(`TestDatabases: Failed to drop databases`, {
           error
         });
       }
       try {
-        await (stopContainer == null ? void 0 : stopContainer());
+        await stopContainer?.();
       } catch (error) {
         console.warn(`TestDatabases: Failed to stop container`, {
           databaseManager,
@@ -412,9 +404,7 @@ const _TestDatabases = class _TestDatabases {
       }
     }
   }
-};
-__publicField$3(_TestDatabases, "defaultIds");
-let TestDatabases = _TestDatabases;
+}
 
 function setupRequestMockHandlers(worker) {
   beforeAll(() => worker.listen({ onUnhandledRequest: "error" }));
@@ -422,63 +412,27 @@ function setupRequestMockHandlers(worker) {
   afterEach(() => worker.resetHandlers());
 }
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck$5 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd$5 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$5 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var __privateMethod$4 = (obj, member, method) => {
-  __accessCheck$5(obj, member, "access private method");
-  return method;
-};
-var _root, _transformInput, transformInput_fn;
 const tmpdirMarker = Symbol("os-tmpdir-mock");
 class MockDirectoryImpl {
+  #root;
   constructor(root) {
-    __privateAdd$5(this, _transformInput);
-    __privateAdd$5(this, _root, void 0);
-    __publicField$2(this, "clear", () => {
-      this.setContent({});
-    });
-    __publicField$2(this, "remove", () => {
-      fs__default.default.rmSync(__privateGet$5(this, _root), { recursive: true, force: true, maxRetries: 10 });
-    });
-    __privateSet$5(this, _root, root);
+    this.#root = root;
   }
   get path() {
-    return __privateGet$5(this, _root);
+    return this.#root;
   }
   resolve(...paths) {
-    return path.resolve(__privateGet$5(this, _root), ...paths);
+    return path.resolve(this.#root, ...paths);
   }
   setContent(root) {
     this.remove();
     return this.addContent(root);
   }
   addContent(root) {
-    const entries = __privateMethod$4(this, _transformInput, transformInput_fn).call(this, root);
+    const entries = this.#transformInput(root);
     for (const entry of entries) {
-      const fullPath = path.resolve(__privateGet$5(this, _root), entry.path);
-      if (!backendCommon.isChildPath(__privateGet$5(this, _root), fullPath)) {
+      const fullPath = path.resolve(this.#root, entry.path);
+      if (!backendPluginApi.isChildPath(this.#root, fullPath)) {
         throw new Error(
           `Provided path must resolve to a child path of the mock directory, got '${fullPath}'`
         );
@@ -500,10 +454,9 @@ class MockDirectoryImpl {
     }
   }
   content(options) {
-    var _a, _b;
-    const shouldReadAsText = (_a = typeof (options == null ? void 0 : options.shouldReadAsText) === "boolean" ? () => options == null ? void 0 : options.shouldReadAsText : options == null ? void 0 : options.shouldReadAsText) != null ? _a : (path$1) => textextensions__default.default.includes(path.extname(path$1).slice(1));
-    const root = path.resolve(__privateGet$5(this, _root), (_b = options == null ? void 0 : options.path) != null ? _b : "");
-    if (!backendCommon.isChildPath(__privateGet$5(this, _root), root)) {
+    const shouldReadAsText = (typeof options?.shouldReadAsText === "boolean" ? () => options?.shouldReadAsText : options?.shouldReadAsText) ?? ((path$1) => textextensions__default.default.includes(path.extname(path$1).slice(1)));
+    const root = path.resolve(this.#root, options?.path ?? "");
+    if (!backendPluginApi.isChildPath(this.#root, root)) {
       throw new Error(
         `Provided path must resolve to a child path of the mock directory, got '${root}'`
       );
@@ -530,37 +483,41 @@ class MockDirectoryImpl {
     }
     return read(root);
   }
-}
-_root = new WeakMap();
-_transformInput = new WeakSet();
-transformInput_fn = function(input) {
-  const entries = [];
-  function traverse(node, path) {
-    if (typeof node === "string") {
-      entries.push({
-        type: "file",
-        path,
-        content: Buffer.from(node, "utf8")
-      });
-    } else if (node instanceof Buffer) {
-      entries.push({ type: "file", path, content: node });
-    } else if (typeof node === "function") {
-      entries.push({ type: "callback", path, callback: node });
-    } else {
-      entries.push({ type: "dir", path });
-      for (const [name, child] of Object.entries(node)) {
-        traverse(child, path ? `${path}/${name}` : name);
+  clear = () => {
+    this.setContent({});
+  };
+  remove = () => {
+    fs__default.default.rmSync(this.#root, { recursive: true, force: true, maxRetries: 10 });
+  };
+  #transformInput(input) {
+    const entries = [];
+    function traverse(node, path) {
+      if (typeof node === "string") {
+        entries.push({
+          type: "file",
+          path,
+          content: Buffer.from(node, "utf8")
+        });
+      } else if (node instanceof Buffer) {
+        entries.push({ type: "file", path, content: node });
+      } else if (typeof node === "function") {
+        entries.push({ type: "callback", path, callback: node });
+      } else {
+        entries.push({ type: "dir", path });
+        for (const [name, child] of Object.entries(node)) {
+          traverse(child, path ? `${path}/${name}` : name);
+        }
       }
     }
+    traverse(input, "");
+    return entries;
   }
-  traverse(input, "");
-  return entries;
-};
+}
 function createMockDirectory(options) {
   const tmpDir = process.env.RUNNER_TEMP || os__default.default.tmpdir();
   const root = fs__default.default.mkdtempSync(path.join(tmpDir, "backstage-tmp-test-dir-"));
   const mocker = new MockDirectoryImpl(root);
-  const origTmpdir = (options == null ? void 0 : options.mockOsTmpDir) ? os__default.default.tmpdir : void 0;
+  const origTmpdir = options?.mockOsTmpDir ? os__default.default.tmpdir : void 0;
   if (origTmpdir) {
     if (Object.hasOwn(origTmpdir, tmpdirMarker)) {
       throw new Error(
@@ -585,7 +542,7 @@ function createMockDirectory(options) {
     });
   } catch {
   }
-  if (options == null ? void 0 : options.content) {
+  if (options?.content) {
     mocker.setContent(options.content);
   }
   return mocker;
@@ -604,29 +561,6 @@ class MockIdentityService {
   }
 }
 
-var __accessCheck$4 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd$4 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var __privateMethod$3 = (obj, member, method) => {
-  __accessCheck$4(obj, member, "access private method");
-  return method;
-};
-var _level, _meta, _log, log_fn;
 const levels = {
   none: 0,
   error: 1,
@@ -634,50 +568,43 @@ const levels = {
   info: 3,
   debug: 4
 };
-const _MockRootLoggerService = class _MockRootLoggerService {
-  constructor(level, meta) {
-    __privateAdd$4(this, _log);
-    __privateAdd$4(this, _level, void 0);
-    __privateAdd$4(this, _meta, void 0);
-    __privateSet$4(this, _level, level);
-    __privateSet$4(this, _meta, meta);
-  }
+class MockRootLoggerService {
+  #level;
+  #meta;
   static create(options) {
-    var _a;
-    const level = (_a = options == null ? void 0 : options.level) != null ? _a : "none";
+    const level = options?.level ?? "none";
     if (!(level in levels)) {
       throw new Error(`Invalid log level '${level}'`);
     }
-    return new _MockRootLoggerService(levels[level], {});
+    return new MockRootLoggerService(levels[level], {});
   }
   error(message, meta) {
-    __privateMethod$3(this, _log, log_fn).call(this, "error", message, meta);
+    this.#log("error", message, meta);
   }
   warn(message, meta) {
-    __privateMethod$3(this, _log, log_fn).call(this, "warn", message, meta);
+    this.#log("warn", message, meta);
   }
   info(message, meta) {
-    __privateMethod$3(this, _log, log_fn).call(this, "info", message, meta);
+    this.#log("info", message, meta);
   }
   debug(message, meta) {
-    __privateMethod$3(this, _log, log_fn).call(this, "debug", message, meta);
+    this.#log("debug", message, meta);
   }
   child(meta) {
-    return new _MockRootLoggerService(__privateGet$4(this, _level), { ...__privateGet$4(this, _meta), ...meta });
+    return new MockRootLoggerService(this.#level, { ...this.#meta, ...meta });
   }
-};
-_level = new WeakMap();
-_meta = new WeakMap();
-_log = new WeakSet();
-log_fn = function(level, message, meta) {
-  var _a;
-  const levelValue = (_a = levels[level]) != null ? _a : 0;
-  if (levelValue <= __privateGet$4(this, _level)) {
-    const labels = Object.entries(__privateGet$4(this, _meta)).map(([key, value]) => `${key}=${value}`).join(",");
-    console[level](`${labels} ${message}`, meta);
+  constructor(level, meta) {
+    this.#level = level;
+    this.#meta = meta;
   }
-};
-let MockRootLoggerService = _MockRootLoggerService;
+  #log(level, message, meta) {
+    const levelValue = levels[level] ?? 0;
+    if (levelValue <= this.#level) {
+      const labels = Object.entries(this.#meta).map(([key, value]) => `${key}=${value}`).join(",");
+      console[level](`${labels} ${message}`, meta);
+    }
+  }
+}
 
 const DEFAULT_MOCK_USER_ENTITY_REF = "user:default/mock";
 const DEFAULT_MOCK_SERVICE_SUBJECT = "external:test-service";
@@ -781,7 +708,7 @@ exports.mockCredentials = void 0;
     function token(options) {
       if (options) {
         const { targetPluginId, onBehalfOf } = options;
-        const oboPrincipal = onBehalfOf == null ? void 0 : onBehalfOf.principal;
+        const oboPrincipal = onBehalfOf?.principal;
         const obo = oboPrincipal.type === "user" ? oboPrincipal.userEntityRef : void 0;
         const subject = oboPrincipal.type === "service" ? oboPrincipal.subject : void 0;
         return `${MOCK_SERVICE_TOKEN_PREFIX}${JSON.stringify({
@@ -808,16 +735,10 @@ exports.mockCredentials = void 0;
   })(service = mockCredentials2.service || (mockCredentials2.service = {}));
 })(exports.mockCredentials || (exports.mockCredentials = {}));
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 class MockAuthService {
+  pluginId;
+  disableDefaultAuthPolicy;
   constructor(options) {
-    __publicField$1(this, "pluginId");
-    __publicField$1(this, "disableDefaultAuthPolicy");
     this.pluginId = options.pluginId;
     this.disableDefaultAuthPolicy = options.disableDefaultAuthPolicy;
   }
@@ -843,7 +764,7 @@ class MockAuthService {
       return exports.mockCredentials.user(userEntityRef);
     }
     if (token.startsWith(MOCK_USER_LIMITED_TOKEN_PREFIX)) {
-      if (!(options == null ? void 0 : options.allowLimitedAccess)) {
+      if (!options?.allowLimitedAccess) {
         throw new errors.AuthenticationError("Limited user token is not allowed");
       }
       const { sub: userEntityRef } = JSON.parse(
@@ -918,60 +839,63 @@ class MockAuthService {
   }
 }
 
-var __accessCheck$3 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd$3 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$3 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$3(obj, member, "access private method");
-  return method;
-};
-var _auth, _defaultCredentials, _getCredentials, getCredentials_fn;
 class MockHttpAuthService {
+  #auth;
+  #defaultCredentials;
   constructor(pluginId, defaultCredentials) {
-    __privateAdd$3(this, _getCredentials);
-    __privateAdd$3(this, _auth, void 0);
-    __privateAdd$3(this, _defaultCredentials, void 0);
-    __privateSet$3(this, _auth, new MockAuthService({
+    this.#auth = new MockAuthService({
       pluginId,
       disableDefaultAuthPolicy: false
-    }));
-    __privateSet$3(this, _defaultCredentials, defaultCredentials);
+    });
+    this.#defaultCredentials = defaultCredentials;
+  }
+  async #getCredentials(req, allowLimitedAccess) {
+    const header = req.headers.authorization;
+    const token = typeof header === "string" ? header.match(/^Bearer[ ]+(\S+)$/i)?.[1] : void 0;
+    if (token) {
+      if (token === MOCK_NONE_TOKEN) {
+        return this.#auth.getNoneCredentials();
+      }
+      return await this.#auth.authenticate(token, {
+        allowLimitedAccess
+      });
+    }
+    if (allowLimitedAccess) {
+      const cookieHeader = req.headers.cookie;
+      if (cookieHeader) {
+        const cookies = cookie.parse(cookieHeader);
+        const cookie$1 = cookies[MOCK_AUTH_COOKIE];
+        if (cookie$1) {
+          return await this.#auth.authenticate(cookie$1, {
+            allowLimitedAccess: true
+          });
+        }
+      }
+    }
+    return this.#defaultCredentials;
   }
   async credentials(req, options) {
-    var _a;
-    const credentials = await __privateMethod$2(this, _getCredentials, getCredentials_fn).call(this, req, (_a = options == null ? void 0 : options.allowLimitedAccess) != null ? _a : false);
-    const allowedPrincipalTypes = options == null ? void 0 : options.allow;
+    const credentials = await this.#getCredentials(
+      req,
+      options?.allowLimitedAccess ?? false
+    );
+    const allowedPrincipalTypes = options?.allow;
     if (!allowedPrincipalTypes) {
       return credentials;
     }
-    if (__privateGet$3(this, _auth).isPrincipal(credentials, "none")) {
+    if (this.#auth.isPrincipal(credentials, "none")) {
       if (allowedPrincipalTypes.includes("none")) {
         return credentials;
       }
       throw new errors.AuthenticationError("Missing credentials");
-    } else if (__privateGet$3(this, _auth).isPrincipal(credentials, "user")) {
+    } else if (this.#auth.isPrincipal(credentials, "user")) {
       if (allowedPrincipalTypes.includes("user")) {
         return credentials;
       }
       throw new errors.NotAllowedError(
         `This endpoint does not allow 'user' credentials`
       );
-    } else if (__privateGet$3(this, _auth).isPrincipal(credentials, "service")) {
+    } else if (this.#auth.isPrincipal(credentials, "service")) {
       if (allowedPrincipalTypes.includes("service")) {
         return credentials;
       }
@@ -984,8 +908,7 @@ class MockHttpAuthService {
     );
   }
   async issueUserCookie(res, options) {
-    var _a;
-    const credentials = (_a = options == null ? void 0 : options.credentials) != null ? _a : await this.credentials(res.req, { allow: ["user"] });
+    const credentials = options?.credentials ?? await this.credentials(res.req, { allow: ["user"] });
     res.setHeader(
       "Set-Cookie",
       exports.mockCredentials.limitedUser.cookie(credentials.principal.userEntityRef)
@@ -993,46 +916,11 @@ class MockHttpAuthService {
     return { expiresAt: new Date(Date.now() + 36e5) };
   }
 }
-_auth = new WeakMap();
-_defaultCredentials = new WeakMap();
-_getCredentials = new WeakSet();
-getCredentials_fn = async function(req, allowLimitedAccess) {
-  var _a;
-  const header = req.headers.authorization;
-  const token = typeof header === "string" ? (_a = header.match(/^Bearer[ ]+(\S+)$/i)) == null ? void 0 : _a[1] : void 0;
-  if (token) {
-    if (token === MOCK_NONE_TOKEN) {
-      return __privateGet$3(this, _auth).getNoneCredentials();
-    }
-    return await __privateGet$3(this, _auth).authenticate(token, {
-      allowLimitedAccess
-    });
-  }
-  if (allowLimitedAccess) {
-    const cookieHeader = req.headers.cookie;
-    if (cookieHeader) {
-      const cookies = cookie.parse(cookieHeader);
-      const cookie$1 = cookies[MOCK_AUTH_COOKIE];
-      if (cookie$1) {
-        return await __privateGet$3(this, _auth).authenticate(cookie$1, {
-          allowLimitedAccess: true
-        });
-      }
-    }
-  }
-  return __privateGet$3(this, _defaultCredentials);
-};
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, key + "" , value);
-  return value;
-};
 class MockUserInfoService {
+  customInfo;
   constructor(customInfo) {
-    __publicField(this, "customInfo");
-    this.customInfo = customInfo != null ? customInfo : {};
+    this.customInfo = customInfo ?? {};
   }
   async getUserInfo(credentials) {
     const principal = credentials.principal;
@@ -1049,6 +937,15 @@ class MockUserInfoService {
   }
 }
 
+function createLoggerMock() {
+  return {
+    child: jest.fn().mockImplementation(createLoggerMock),
+    debug: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn()
+  };
+}
 function simpleFactory(ref, factory) {
   return backendPluginApi.createServiceFactory((options) => ({
     service: ref,
@@ -1082,7 +979,7 @@ function simpleMock(ref, mockFactory) {
 exports.mockServices = void 0;
 ((mockServices2) => {
   function rootConfig(options) {
-    return new config.ConfigReader(options == null ? void 0 : options.data, "mock-config");
+    return new config.ConfigReader(options?.data, "mock-config");
   }
   mockServices2.rootConfig = rootConfig;
   ((rootConfig2) => {
@@ -1136,10 +1033,9 @@ exports.mockServices = void 0;
     }));
   })(identity = mockServices2.identity || (mockServices2.identity = {}));
   function auth(options) {
-    var _a;
     return new MockAuthService({
-      pluginId: (_a = options == null ? void 0 : options.pluginId) != null ? _a : "test",
-      disableDefaultAuthPolicy: Boolean(options == null ? void 0 : options.disableDefaultAuthPolicy)
+      pluginId: options?.pluginId ?? "test",
+      disableDefaultAuthPolicy: Boolean(options?.disableDefaultAuthPolicy)
     });
   }
   mockServices2.auth = auth;
@@ -1192,10 +1088,9 @@ exports.mockServices = void 0;
     }));
   })(discovery = mockServices2.discovery || (mockServices2.discovery = {}));
   function httpAuth(options) {
-    var _a, _b;
     return new MockHttpAuthService(
-      (_a = options == null ? void 0 : options.pluginId) != null ? _a : "test",
-      (_b = options == null ? void 0 : options.defaultCredentials) != null ? _b : exports.mockCredentials.user()
+      options?.pluginId ?? "test",
+      options?.defaultCredentials ?? exports.mockCredentials.user()
     );
   }
   mockServices2.httpAuth = httpAuth;
@@ -1204,13 +1099,10 @@ exports.mockServices = void 0;
       (options) => ({
         service: backendPluginApi.coreServices.httpAuth,
         deps: { plugin: backendPluginApi.coreServices.pluginMetadata },
-        factory: ({ plugin }) => {
-          var _a;
-          return new MockHttpAuthService(
-            plugin.getId(),
-            (_a = options == null ? void 0 : options.defaultCredentials) != null ? _a : exports.mockCredentials.user()
-          );
-        }
+        factory: ({ plugin }) => new MockHttpAuthService(
+          plugin.getId(),
+          options?.defaultCredentials ?? exports.mockCredentials.user()
+        )
       })
     );
     httpAuth2.mock = simpleMock(backendPluginApi.coreServices.httpAuth, () => ({
@@ -1271,13 +1163,10 @@ exports.mockServices = void 0;
   })(mockServices2.lifecycle || (mockServices2.lifecycle = {}));
   ((logger2) => {
     logger2.factory = backendAppApi.loggerServiceFactory;
-    logger2.mock = simpleMock(backendPluginApi.coreServices.logger, () => ({
-      child: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn()
-    }));
+    logger2.mock = simpleMock(
+      backendPluginApi.coreServices.logger,
+      () => createLoggerMock()
+    );
   })(mockServices2.logger || (mockServices2.logger = {}));
   ((permissions2) => {
     permissions2.factory = backendAppApi.permissionsServiceFactory;
@@ -1442,16 +1331,15 @@ function unwrapFeature(feature) {
 }
 const backendInstancesToCleanUp = new Array();
 async function startTestBackend(options) {
-  var _a, _b;
   const { extensionPoints, ...otherOptions } = options;
   const features = await Promise.all(
-    (_b = (_a = options.features) == null ? void 0 : _a.map(async (val) => {
+    options.features?.map(async (val) => {
       if (isPromise(val)) {
         const { default: feature } = await val;
         return unwrapFeature(feature);
       }
       return unwrapFeature(val);
-    })) != null ? _b : []
+    }) ?? []
   );
   let server;
   const rootHttpRouterFactory = backendPluginApi.createServiceFactory({
@@ -1552,29 +1440,6 @@ function isInternalBackendFeature(feature) {
   return typeof feature.getRegistrations === "function";
 }
 
-var __accessCheck$2 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$2(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd$2 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$2 = (obj, member, value, setter) => {
-  __accessCheck$2(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var __privateMethod$1 = (obj, member, method) => {
-  __accessCheck$2(obj, member, "access private method");
-  return method;
-};
-var _nodeIds, _cycleKeys, _getCycleKey, getCycleKey_fn, _nodes, _allProvided;
 class Node {
   constructor(value, consumes, provides) {
     this.value = value;
@@ -1589,45 +1454,29 @@ class Node {
     );
   }
 }
-const _CycleKeySet = class _CycleKeySet {
-  constructor(nodes) {
-    __privateAdd$2(this, _getCycleKey);
-    __privateAdd$2(this, _nodeIds, void 0);
-    __privateAdd$2(this, _cycleKeys, void 0);
-    __privateSet$2(this, _nodeIds, new Map(nodes.map((n, i) => [n.value, i])));
-    __privateSet$2(this, _cycleKeys, /* @__PURE__ */ new Set());
-  }
+class CycleKeySet {
   static from(nodes) {
-    return new _CycleKeySet(nodes);
+    return new CycleKeySet(nodes);
+  }
+  #nodeIds;
+  #cycleKeys;
+  constructor(nodes) {
+    this.#nodeIds = new Map(nodes.map((n, i) => [n.value, i]));
+    this.#cycleKeys = /* @__PURE__ */ new Set();
   }
   tryAdd(path) {
-    const cycleKey = __privateMethod$1(this, _getCycleKey, getCycleKey_fn).call(this, path);
-    if (__privateGet$2(this, _cycleKeys).has(cycleKey)) {
+    const cycleKey = this.#getCycleKey(path);
+    if (this.#cycleKeys.has(cycleKey)) {
       return false;
     }
-    __privateGet$2(this, _cycleKeys).add(cycleKey);
+    this.#cycleKeys.add(cycleKey);
     return true;
   }
-};
-_nodeIds = new WeakMap();
-_cycleKeys = new WeakMap();
-_getCycleKey = new WeakSet();
-getCycleKey_fn = function(path) {
-  return path.map((n) => __privateGet$2(this, _nodeIds).get(n)).sort().join(",");
-};
-let CycleKeySet = _CycleKeySet;
-const _DependencyGraph = class _DependencyGraph {
-  constructor(nodes) {
-    __privateAdd$2(this, _nodes, void 0);
-    __privateAdd$2(this, _allProvided, void 0);
-    __privateSet$2(this, _nodes, nodes);
-    __privateSet$2(this, _allProvided, /* @__PURE__ */ new Set());
-    for (const node of __privateGet$2(this, _nodes).values()) {
-      for (const produced of node.provides) {
-        __privateGet$2(this, _allProvided).add(produced);
-      }
-    }
+  #getCycleKey(path) {
+    return path.map((n) => this.#nodeIds.get(n)).sort().join(",");
   }
+}
+class DependencyGraph {
   static fromMap(nodes) {
     return this.fromIterable(
       Object.entries(nodes).map(([key, node]) => ({
@@ -1641,16 +1490,27 @@ const _DependencyGraph = class _DependencyGraph {
     for (const nodeInput of nodeInputs) {
       nodes.push(Node.from(nodeInput));
     }
-    return new _DependencyGraph(nodes);
+    return new DependencyGraph(nodes);
+  }
+  #nodes;
+  #allProvided;
+  constructor(nodes) {
+    this.#nodes = nodes;
+    this.#allProvided = /* @__PURE__ */ new Set();
+    for (const node of this.#nodes.values()) {
+      for (const produced of node.provides) {
+        this.#allProvided.add(produced);
+      }
+    }
   }
   /**
    * Find all nodes that consume dependencies that are not provided by any other node.
    */
   findUnsatisfiedDeps() {
     const unsatisfiedDependencies = [];
-    for (const node of __privateGet$2(this, _nodes).values()) {
+    for (const node of this.#nodes.values()) {
       const unsatisfied = Array.from(node.consumes).filter(
-        (id) => !__privateGet$2(this, _allProvided).has(id)
+        (id) => !this.#allProvided.has(id)
       );
       if (unsatisfied.length > 0) {
         unsatisfiedDependencies.push({ value: node.value, unsatisfied });
@@ -1670,8 +1530,8 @@ const _DependencyGraph = class _DependencyGraph {
    * form a cycle, with the same node as the first and last element of the array.
    */
   *detectCircularDependencies() {
-    const cycleKeys = CycleKeySet.from(__privateGet$2(this, _nodes));
-    for (const startNode of __privateGet$2(this, _nodes)) {
+    const cycleKeys = CycleKeySet.from(this.#nodes);
+    for (const startNode of this.#nodes) {
       const visited = /* @__PURE__ */ new Set();
       const stack = new Array([
         startNode,
@@ -1684,7 +1544,7 @@ const _DependencyGraph = class _DependencyGraph {
         }
         visited.add(node);
         for (const consumed of node.consumes) {
-          const providerNodes = __privateGet$2(this, _nodes).filter(
+          const providerNodes = this.#nodes.filter(
             (other) => other.provides.has(consumed)
           );
           for (const provider of providerNodes) {
@@ -1713,9 +1573,9 @@ const _DependencyGraph = class _DependencyGraph {
    * Dependencies of nodes that are not produced by any other nodes will be ignored.
    */
   async parallelTopologicalTraversal(fn) {
-    const allProvided = __privateGet$2(this, _allProvided);
+    const allProvided = this.#allProvided;
     const producedSoFar = /* @__PURE__ */ new Set();
-    const waiting = new Set(__privateGet$2(this, _nodes).values());
+    const waiting = new Set(this.#nodes.values());
     const visited = /* @__PURE__ */ new Set();
     const results = new Array();
     let inFlight = 0;
@@ -1756,34 +1616,8 @@ const _DependencyGraph = class _DependencyGraph {
     await processMoreNodes();
     return results;
   }
-};
-_nodes = new WeakMap();
-_allProvided = new WeakMap();
-let DependencyGraph = _DependencyGraph;
+}
 
-var __accessCheck$1 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$1 = (obj, member, getter) => {
-  __accessCheck$1(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd$1 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$1 = (obj, member, value, setter) => {
-  __accessCheck$1(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck$1(obj, member, "access private method");
-  return method;
-};
-var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _addedFactoryIds, _instantiatedFactories, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
 function toInternalServiceFactory(factory) {
   const f = factory;
   if (f.$$type !== "@backstage/BackendFeature") {
@@ -1798,33 +1632,77 @@ const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.pluginMetadata,
     deps: {},
-    factory: async () => ({ getId: () => options == null ? void 0 : options.pluginId })
+    factory: async () => ({ getId: () => options?.pluginId })
   })
 );
-const _ServiceRegistry = class _ServiceRegistry {
-  constructor(factories) {
-    __privateAdd$1(this, _resolveFactory);
-    __privateAdd$1(this, _checkForMissingDeps);
-    __privateAdd$1(this, _providedFactories, void 0);
-    __privateAdd$1(this, _loadedDefaultFactories, void 0);
-    __privateAdd$1(this, _implementations, void 0);
-    __privateAdd$1(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
-    __privateAdd$1(this, _addedFactoryIds, /* @__PURE__ */ new Set());
-    __privateAdd$1(this, _instantiatedFactories, /* @__PURE__ */ new Set());
-    __privateSet$1(this, _providedFactories, new Map(
-      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
-    ));
-    __privateSet$1(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
-    __privateSet$1(this, _implementations, /* @__PURE__ */ new Map());
-  }
+class ServiceRegistry {
   static create(factories) {
-    const registry = new _ServiceRegistry(factories);
+    const registry = new ServiceRegistry(factories);
     registry.checkForCircularDeps();
     return registry;
   }
+  #providedFactories;
+  #loadedDefaultFactories;
+  #implementations;
+  #rootServiceImplementations = /* @__PURE__ */ new Map();
+  #addedFactoryIds = /* @__PURE__ */ new Set();
+  #instantiatedFactories = /* @__PURE__ */ new Set();
+  constructor(factories) {
+    this.#providedFactories = new Map(
+      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
+    );
+    this.#loadedDefaultFactories = /* @__PURE__ */ new Map();
+    this.#implementations = /* @__PURE__ */ new Map();
+  }
+  #resolveFactory(ref, pluginId) {
+    if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+      return Promise.resolve(
+        toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
+      );
+    }
+    let resolvedFactory = this.#providedFactories.get(ref.id);
+    const { __defaultFactory: defaultFactory } = ref;
+    if (!resolvedFactory && !defaultFactory) {
+      return void 0;
+    }
+    if (!resolvedFactory) {
+      let loadedFactory = this.#loadedDefaultFactories.get(defaultFactory);
+      if (!loadedFactory) {
+        loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
+          (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
+        );
+        this.#loadedDefaultFactories.set(defaultFactory, loadedFactory);
+      }
+      resolvedFactory = loadedFactory.catch((error) => {
+        throw new Error(
+          `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
+            error
+          )}`
+        );
+      });
+    }
+    return Promise.resolve(resolvedFactory);
+  }
+  #checkForMissingDeps(factory, pluginId) {
+    const missingDeps = Object.values(factory.deps).filter((ref) => {
+      if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+        return false;
+      }
+      if (this.#providedFactories.get(ref.id)) {
+        return false;
+      }
+      return !ref.__defaultFactory;
+    });
+    if (missingDeps.length) {
+      const missing = missingDeps.map((r) => `'${r.id}'`).join(", ");
+      throw new Error(
+        `Failed to instantiate service '${factory.service.id}' for '${pluginId}' because the following dependent services are missing: ${missing}`
+      );
+    }
+  }
   checkForCircularDeps() {
     const graph = DependencyGraph.fromIterable(
-      Array.from(__privateGet$1(this, _providedFactories)).map(
+      Array.from(this.#providedFactories).map(
         ([serviceId, serviceFactory]) => ({
           value: serviceId,
           provides: [serviceId],
@@ -1846,21 +1724,21 @@ const _ServiceRegistry = class _ServiceRegistry {
         `The ${backendPluginApi.coreServices.pluginMetadata.id} service cannot be overridden`
       );
     }
-    if (__privateGet$1(this, _addedFactoryIds).has(factoryId)) {
+    if (this.#addedFactoryIds.has(factoryId)) {
       throw new Error(
         `Duplicate service implementations provided for ${factoryId}`
       );
     }
-    if (__privateGet$1(this, _instantiatedFactories).has(factoryId)) {
+    if (this.#instantiatedFactories.has(factoryId)) {
       throw new Error(
         `Unable to set service factory with id ${factoryId}, service has already been instantiated`
       );
     }
-    __privateGet$1(this, _addedFactoryIds).add(factoryId);
-    __privateGet$1(this, _providedFactories).set(factoryId, toInternalServiceFactory(factory));
+    this.#addedFactoryIds.add(factoryId);
+    this.#providedFactories.set(factoryId, toInternalServiceFactory(factory));
   }
   async initializeEagerServicesWithScope(scope, pluginId = "root") {
-    for (const factory of __privateGet$1(this, _providedFactories).values()) {
+    for (const factory of this.#providedFactories.values()) {
       if (factory.service.scope === scope) {
         if (scope === "root" && factory.initialization !== "lazy") {
           await this.get(factory.service, pluginId);
@@ -1871,13 +1749,12 @@ const _ServiceRegistry = class _ServiceRegistry {
     }
   }
   get(ref, pluginId) {
-    var _a;
-    __privateGet$1(this, _instantiatedFactories).add(ref.id);
-    return (_a = __privateMethod(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
+    this.#instantiatedFactories.add(ref.id);
+    return this.#resolveFactory(ref, pluginId)?.then((factory) => {
       if (factory.service.scope === "root") {
-        let existing = __privateGet$1(this, _rootServiceImplementations).get(factory);
+        let existing = this.#rootServiceImplementations.get(factory);
         if (!existing) {
-          __privateMethod(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+          this.#checkForMissingDeps(factory, pluginId);
           const rootDeps = new Array();
           for (const [name, serviceRef] of Object.entries(factory.deps)) {
             if (serviceRef.scope !== "root") {
@@ -1891,13 +1768,13 @@ const _ServiceRegistry = class _ServiceRegistry {
           existing = Promise.all(rootDeps).then(
             (entries) => factory.factory(Object.fromEntries(entries), void 0)
           );
-          __privateGet$1(this, _rootServiceImplementations).set(factory, existing);
+          this.#rootServiceImplementations.set(factory, existing);
         }
         return existing;
       }
-      let implementation = __privateGet$1(this, _implementations).get(factory);
+      let implementation = this.#implementations.get(factory);
       if (!implementation) {
-        __privateMethod(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+        this.#checkForMissingDeps(factory, pluginId);
         const rootDeps = new Array();
         for (const [name, serviceRef] of Object.entries(factory.deps)) {
           if (serviceRef.scope === "root") {
@@ -1907,10 +1784,7 @@ const _ServiceRegistry = class _ServiceRegistry {
         }
         implementation = {
           context: Promise.all(rootDeps).then(
-            (entries) => {
-              var _a2;
-              return (_a2 = factory.createRootContext) == null ? void 0 : _a2.call(factory, Object.fromEntries(entries));
-            }
+            (entries) => factory.createRootContext?.(Object.fromEntries(entries))
           ).catch((error) => {
             const cause = errors.stringifyError(error);
             throw new Error(
@@ -1919,7 +1793,7 @@ const _ServiceRegistry = class _ServiceRegistry {
           }),
           byPlugin: /* @__PURE__ */ new Map()
         };
-        __privateGet$1(this, _implementations).set(factory, implementation);
+        this.#implementations.set(factory, implementation);
       }
       let result = implementation.byPlugin.get(pluginId);
       if (!result) {
@@ -1943,89 +1817,11 @@ const _ServiceRegistry = class _ServiceRegistry {
       return result;
     });
   }
-};
-_providedFactories = new WeakMap();
-_loadedDefaultFactories = new WeakMap();
-_implementations = new WeakMap();
-_rootServiceImplementations = new WeakMap();
-_addedFactoryIds = new WeakMap();
-_instantiatedFactories = new WeakMap();
-_resolveFactory = new WeakSet();
-resolveFactory_fn = function(ref, pluginId) {
-  if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-    return Promise.resolve(
-      toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
-    );
-  }
-  let resolvedFactory = __privateGet$1(this, _providedFactories).get(ref.id);
-  const { __defaultFactory: defaultFactory } = ref;
-  if (!resolvedFactory && !defaultFactory) {
-    return void 0;
-  }
-  if (!resolvedFactory) {
-    let loadedFactory = __privateGet$1(this, _loadedDefaultFactories).get(defaultFactory);
-    if (!loadedFactory) {
-      loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
-        (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
-      );
-      __privateGet$1(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
-    }
-    resolvedFactory = loadedFactory.catch((error) => {
-      throw new Error(
-        `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
-          error
-        )}`
-      );
-    });
-  }
-  return Promise.resolve(resolvedFactory);
-};
-_checkForMissingDeps = new WeakSet();
-checkForMissingDeps_fn = function(factory, pluginId) {
-  const missingDeps = Object.values(factory.deps).filter((ref) => {
-    if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-      return false;
-    }
-    if (__privateGet$1(this, _providedFactories).get(ref.id)) {
-      return false;
-    }
-    return !ref.__defaultFactory;
-  });
-  if (missingDeps.length) {
-    const missing = missingDeps.map((r) => `'${r.id}'`).join(", ");
-    throw new Error(
-      `Failed to instantiate service '${factory.service.id}' for '${pluginId}' because the following dependent services are missing: ${missing}`
-    );
-  }
-};
-let ServiceRegistry = _ServiceRegistry;
+}
 
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  member.set(obj, value);
-  return value;
-};
-var _subject, _registry;
-const _ServiceFactoryTester = class _ServiceFactoryTester {
-  constructor(subject, registry) {
-    __privateAdd(this, _subject, void 0);
-    __privateAdd(this, _registry, void 0);
-    __privateSet(this, _subject, subject);
-    __privateSet(this, _registry, registry);
-  }
+class ServiceFactoryTester {
+  #subject;
+  #registry;
   /**
    * Creates a new {@link ServiceFactoryTester} used to test the provided subject.
    *
@@ -2034,16 +1830,19 @@ const _ServiceFactoryTester = class _ServiceFactoryTester {
    * @returns A new tester instance for the provided subject.
    */
   static from(subject, options) {
-    var _a, _b;
     const subjectFactory = typeof subject === "function" ? subject() : subject;
     const registry = ServiceRegistry.create([
       ...defaultServiceFactories,
-      ...(_b = (_a = options == null ? void 0 : options.dependencies) == null ? void 0 : _a.map(
+      ...options?.dependencies?.map(
         (f) => typeof f === "function" ? f() : f
-      )) != null ? _b : [],
+      ) ?? [],
       subjectFactory
     ]);
-    return new _ServiceFactoryTester(subjectFactory.service, registry);
+    return new ServiceFactoryTester(subjectFactory.service, registry);
+  }
+  constructor(subject, registry) {
+    this.#subject = subject;
+    this.#registry = registry;
   }
   /**
    * Returns the service instance for the subject.
@@ -2057,7 +1856,7 @@ const _ServiceFactoryTester = class _ServiceFactoryTester {
    */
   async get(...args) {
     const [pluginId] = args;
-    return __privateGet(this, _registry).get(__privateGet(this, _subject), pluginId != null ? pluginId : "test");
+    return this.#registry.get(this.#subject, pluginId ?? "test");
   }
   /**
    * Return the service instance for any of the provided dependencies or built-in services.
@@ -2068,16 +1867,13 @@ const _ServiceFactoryTester = class _ServiceFactoryTester {
    */
   async getService(service, ...args) {
     const [pluginId] = args;
-    const instance = await __privateGet(this, _registry).get(service, pluginId != null ? pluginId : "test");
+    const instance = await this.#registry.get(service, pluginId ?? "test");
     if (instance === void 0) {
       throw new Error(`Service '${service.id}' not found`);
     }
     return instance;
   }
-};
-_subject = new WeakMap();
-_registry = new WeakMap();
-let ServiceFactoryTester = _ServiceFactoryTester;
+}
 
 exports.ServiceFactoryTester = ServiceFactoryTester;
 exports.TestDatabases = TestDatabases;