@google/adk 1.6.0 → 2.1.0

package/dist/cjs/sessions/database_session_service.js

@@ -5,10 +5,13 @@
   */
 
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -21,6 +24,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var database_session_service_exports = {};
 __export(database_session_service_exports, {
@@ -28,11 +39,8 @@ __export(database_session_service_exports, {
   isDatabaseConnectionString: () => isDatabaseConnectionString
 });
 module.exports = __toCommonJS(database_session_service_exports);
-var import_core = require("@mikro-orm/core");
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_base_session_service = require("./base_session_service.js");
-var import_operations = require("./db/operations.js");
-var import_schema = require("./db/schema.js");
 var import_session = require("./session.js");
 var import_state = require("./state.js");
 /**
@@ -40,13 +48,45 @@ var import_state = require("./state.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+let MikroORM;
+let LockMode;
+let ENTITIES;
+let StorageAppState;
+let StorageEvent;
+let StorageSession;
+let StorageUserState;
+let ensureDatabaseCreated;
+let getConnectionOptionsFromUri;
+let validateDatabaseSchemaVersion;
+let mikroOrmLoad;
+function loadMikroOrm() {
+  mikroOrmLoad != null ? mikroOrmLoad : mikroOrmLoad = importMikroOrm();
+  return mikroOrmLoad;
+}
+__name(loadMikroOrm, "loadMikroOrm");
+async function importMikroOrm() {
+  const [core, schema, operations] = await Promise.all([
+    Promise.resolve().then(() => __toESM(require("@mikro-orm/core"), 1)),
+    Promise.resolve().then(() => __toESM(require("./db/schema.js"), 1)),
+    Promise.resolve().then(() => __toESM(require("./db/operations.js"), 1))
+  ]);
+  ({ MikroORM, LockMode } = core);
+  ({ ENTITIES, StorageAppState, StorageEvent, StorageSession, StorageUserState } = schema);
+  ({
+    ensureDatabaseCreated,
+    getConnectionOptionsFromUri,
+    validateDatabaseSchemaVersion
+  } = operations);
+}
+__name(importMikroOrm, "importMikroOrm");
 function isDatabaseConnectionString(uri) {
   if (!uri) {
     return false;
   }
   return uri.startsWith("postgres://") || uri.startsWith("postgresql://") || uri.startsWith("mysql://") || uri.startsWith("mariadb://") || uri.startsWith("mssql://") || uri.startsWith("sqlite://");
 }
-class DatabaseSessionService extends import_base_session_service.BaseSessionService {
+__name(isDatabaseConnectionString, "isDatabaseConnectionString");
+const _DatabaseSessionService = class _DatabaseSessionService extends import_base_session_service.BaseSessionService {
   constructor(connectionStringOrOptions) {
     super();
     this.initialized = false;
@@ -56,22 +96,19 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
       }
-      this.options = {
-        ...connectionStringOrOptions,
-        entities: import_schema.ENTITIES
-      };
+      this.options = connectionStringOrOptions;
     }
   }
   async init() {
     if (this.initialized) {
       return;
     }
-    if (this.connectionString && (!this.options || !this.options.driver)) {
-      this.options = await (0, import_operations.getConnectionOptionsFromUri)(this.connectionString);
-    }
-    this.orm = await import_core.MikroORM.init(this.options);
-    await (0, import_operations.ensureDatabaseCreated)(this.orm);
-    await (0, import_operations.validateDatabaseSchemaVersion)(this.orm);
+    await loadMikroOrm();
+    const options = this.connectionString ? await getConnectionOptionsFromUri(this.connectionString) : { ...this.options, entities: ENTITIES };
+    this.options = options;
+    this.orm = await MikroORM.init(options);
+    await ensureDatabaseCreated(this.orm);
+    await validateDatabaseSchemaVersion(this.orm);
     this.initialized = true;
   }
   async createSession({
@@ -84,7 +121,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     const em = this.orm.em.fork();
     const id = sessionId || (0, import_env_aware_utils.randomUUID)();
     const now = /* @__PURE__ */ new Date();
-    const existing = await em.findOne(import_schema.StorageSession, {
+    const existing = await em.findOne(StorageSession, {
       id,
       appName,
       userId
@@ -92,18 +129,18 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     if (existing) {
       throw new Error(`Session with id ${id} already exists.`);
     }
-    let appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
+    let appStateModel = await em.findOne(StorageAppState, { appName });
     if (!appStateModel) {
-      appStateModel = em.create(import_schema.StorageAppState, {
+      appStateModel = em.create(StorageAppState, {
         appName,
         state: {},
         updateTime: now
       });
       em.persist(appStateModel);
     }
-    let userStateModel = await em.findOne(import_schema.StorageUserState, { appName, userId });
+    let userStateModel = await em.findOne(StorageUserState, { appName, userId });
     if (!userStateModel) {
-      userStateModel = em.create(import_schema.StorageUserState, {
+      userStateModel = em.create(StorageUserState, {
         appName,
         userId,
         state: {}
@@ -130,7 +167,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     if (Object.keys(userStateDelta).length > 0) {
       userStateModel.state = { ...userStateModel.state, ...userStateDelta };
     }
-    const storageSession = em.create(import_schema.StorageSession, {
+    const storageSession = em.create(StorageSession, {
       id,
       appName,
       userId,
@@ -162,7 +199,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
   }) {
     await this.init();
     const em = this.orm.em.fork();
-    const storageSession = await em.findOne(import_schema.StorageSession, {
+    const storageSession = await em.findOne(StorageSession, {
       appName,
       userId,
       id: sessionId
@@ -178,13 +215,13 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     if (config == null ? void 0 : config.afterTimestamp) {
       eventWhere.timestamp = { $gt: new Date(config.afterTimestamp) };
     }
-    const storageEvents = await em.find(import_schema.StorageEvent, eventWhere, {
+    const storageEvents = await em.find(StorageEvent, eventWhere, {
       orderBy: { timestamp: "DESC" },
       limit: config == null ? void 0 : config.numRecentEvents
     });
     storageEvents.reverse();
-    const appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
-    const userStateModel = await em.findOne(import_schema.StorageUserState, {
+    const appStateModel = await em.findOne(StorageAppState, { appName });
+    const userStateModel = await em.findOne(StorageUserState, {
       appName,
       userId
     });
@@ -220,7 +257,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     let storageSessions;
     let paginationMeta;
     if (limit !== void 0) {
-      const totalItems = await em.count(import_schema.StorageSession, where);
+      const totalItems = await em.count(StorageSession, where);
       const totalPages = limit === 0 ? 0 : Math.ceil(totalItems / limit);
       let effectiveOffset;
       let effectivePage;
@@ -231,15 +268,15 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
         effectiveOffset = offset != null ? offset : 0;
         effectivePage = limit === 0 ? 1 : Math.floor(effectiveOffset / limit) + 1;
       }
-      storageSessions = await em.find(import_schema.StorageSession, where, {
+      storageSessions = await em.find(StorageSession, where, {
         orderBy,
         limit,
         offset: effectiveOffset
       });
       paginationMeta = { page: effectivePage, limit, totalItems, totalPages };
     } else if (offset) {
-      const totalItems = await em.count(import_schema.StorageSession, where);
-      storageSessions = await em.find(import_schema.StorageSession, where, {
+      const totalItems = await em.count(StorageSession, where);
+      storageSessions = await em.find(StorageSession, where, {
         orderBy,
         offset
       });
@@ -250,7 +287,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
         totalPages: totalItems === 0 ? 0 : 1
       };
     } else {
-      storageSessions = await em.find(import_schema.StorageSession, where, { orderBy });
+      storageSessions = await em.find(StorageSession, where, { orderBy });
       const totalItems = storageSessions.length;
       paginationMeta = {
         page: 1,
@@ -259,14 +296,14 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
         totalPages: totalItems === 0 ? 0 : 1
       };
     }
-    const appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
+    const appStateModel = await em.findOne(StorageAppState, { appName });
     const appState = (appStateModel == null ? void 0 : appStateModel.state) || {};
     const userStateMap = {};
     if (userId) {
-      const u = await em.findOne(import_schema.StorageUserState, { appName, userId });
+      const u = await em.findOne(StorageUserState, { appName, userId });
       if (u) userStateMap[userId] = u.state;
     } else {
-      const allUserStates = await em.find(import_schema.StorageUserState, { appName });
+      const allUserStates = await em.find(StorageUserState, { appName });
       for (const u of allUserStates) {
         userStateMap[u.userId] = u.state;
       }
@@ -292,8 +329,8 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
   }) {
     await this.init();
     const em = this.orm.em.fork();
-    await em.nativeDelete(import_schema.StorageSession, { appName, userId, id: sessionId });
-    await em.nativeDelete(import_schema.StorageEvent, { appName, userId, sessionId });
+    await em.nativeDelete(StorageSession, { appName, userId, id: sessionId });
+    await em.nativeDelete(StorageEvent, { appName, userId, sessionId });
   }
   async appendEvent({
     session,
@@ -307,34 +344,34 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     const trimmedEvent = (0, import_base_session_service.trimTempDeltaState)(event);
     await em.transactional(async (txEm) => {
       const storageSession = await txEm.findOne(
-        import_schema.StorageSession,
+        StorageSession,
         {
           appName: session.appName,
           userId: session.userId,
           id: session.id
         },
-        { lockMode: import_core.LockMode.PESSIMISTIC_WRITE }
+        { lockMode: LockMode.PESSIMISTIC_WRITE }
       );
       if (!storageSession) {
         throw new Error(`Session ${session.id} not found for appendEvent`);
       }
-      let appStateModel = await txEm.findOne(import_schema.StorageAppState, {
+      let appStateModel = await txEm.findOne(StorageAppState, {
         appName: session.appName
       });
       if (!appStateModel) {
-        appStateModel = txEm.create(import_schema.StorageAppState, {
+        appStateModel = txEm.create(StorageAppState, {
           appName: session.appName,
           state: {},
           updateTime: /* @__PURE__ */ new Date()
         });
         txEm.persist(appStateModel);
       }
-      let userStateModel = await txEm.findOne(import_schema.StorageUserState, {
+      let userStateModel = await txEm.findOne(StorageUserState, {
         appName: session.appName,
         userId: session.userId
       });
       if (!userStateModel) {
-        userStateModel = txEm.create(import_schema.StorageUserState, {
+        userStateModel = txEm.create(StorageUserState, {
           appName: session.appName,
           userId: session.userId,
           state: {}
@@ -343,7 +380,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
       }
       if (storageSession.updateTime.getTime() > session.lastUpdateTime) {
         const events = await txEm.find(
-          import_schema.StorageEvent,
+          StorageEvent,
           {
             appName: session.appName,
             userId: session.userId,
@@ -382,7 +419,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
           storageSession.state = { ...storageSession.state, ...sessionDelta };
         }
       }
-      const existingStorageEvent = await txEm.findOne(import_schema.StorageEvent, {
+      const existingStorageEvent = await txEm.findOne(StorageEvent, {
         id: trimmedEvent.id,
         appName: session.appName,
         userId: session.userId,
@@ -393,7 +430,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
         existingStorageEvent.timestamp = new Date(trimmedEvent.timestamp);
         txEm.persist(existingStorageEvent);
       } else {
-        const newStorageEvent = txEm.create(import_schema.StorageEvent, {
+        const newStorageEvent = txEm.create(StorageEvent, {
           id: trimmedEvent.id,
           appName: session.appName,
           userId: session.userId,
@@ -404,8 +441,8 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
         });
         txEm.persist(newStorageEvent);
       }
-      await txEm.commit();
       storageSession.updateTime = new Date(event.timestamp);
+      txEm.persist([appStateModel, userStateModel, storageSession]);
       const newMergedState = (0, import_base_session_service.mergeStates)(
         appStateModel.state,
         userStateModel.state,
@@ -422,7 +459,9 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     });
     return event;
   }
-}
+};
+__name(_DatabaseSessionService, "DatabaseSessionService");
+let DatabaseSessionService = _DatabaseSessionService;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DatabaseSessionService,

package/dist/cjs/sessions/db/operations.js

@@ -11,6 +11,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -39,49 +40,282 @@ __export(operations_exports, {
   validateDatabaseSchemaVersion: () => validateDatabaseSchemaVersion
 });
 module.exports = __toCommonJS(operations_exports);
+var import_logger = require("../../utils/logger.js");
+var import_optional_peer = require("../../utils/optional_peer.js");
+var import_redact_uri = require("../../utils/redact_uri.js");
 var import_schema = require("./schema.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function driverPeer(packageName, scheme) {
+  return {
+    packageName,
+    feature: `DatabaseSessionService with a "${scheme}" connection string`
+  };
+}
+__name(driverPeer, "driverPeer");
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return void 0;
+  }
+}
+__name(safeDecode, "safeDecode");
+function decodeOrRaw(raw) {
+  var _a;
+  return ((_a = safeDecode(raw)) != null ? _a : raw) || void 0;
+}
+__name(decodeOrRaw, "decodeOrRaw");
+function remainingParams(params, exclude) {
+  const result = {};
+  for (const [key, value] of params.entries()) {
+    if (!exclude.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(remainingParams, "remainingParams");
+const RESERVED_OPTION_KEYS = [
+  "host",
+  "schema",
+  "socketPath",
+  "driver",
+  "entities",
+  "user",
+  "password",
+  "dbName",
+  "port",
+  "clientUrl",
+  "driverOptions"
+];
+function parseSocketUri(uri) {
+  var _a, _b;
+  const schemeEnd = uri.indexOf("://");
+  if (schemeEnd === -1) {
+    return null;
+  }
+  const afterScheme = uri.slice(schemeEnd + 3);
+  const authorityEnd = afterScheme.search(/[/?#]/);
+  const authorityRegion = authorityEnd === -1 ? afterScheme : afterScheme.slice(0, authorityEnd);
+  const rest = authorityEnd === -1 ? "" : afterScheme.slice(authorityEnd);
+  const atIndex = authorityRegion.lastIndexOf("@");
+  const rawUserinfo = atIndex === -1 ? void 0 : authorityRegion.slice(0, atIndex);
+  const rawAuthority = atIndex === -1 ? authorityRegion : authorityRegion.slice(atIndex + 1);
+  const restMatch = /^(\/[^?#]*)?(?:\?([^#]*))?/.exec(rest);
+  const rawPath = restMatch == null ? void 0 : restMatch[1];
+  const rawQuery = restMatch == null ? void 0 : restMatch[2];
+  const params = new URLSearchParams(rawQuery != null ? rawQuery : "");
+  const queryHost = params.get("host");
+  const decodedAuthority = (_a = safeDecode(rawAuthority)) != null ? _a : "";
+  let socketPath;
+  let dbNameOverride;
+  let matchedBareSocket = false;
+  if (queryHost == null ? void 0 : queryHost.startsWith("/")) {
+    socketPath = queryHost;
+    if (decodedAuthority && !decodedAuthority.startsWith("/")) {
+      import_logger.logger.warn(
+        `Connection URI names host "${decodedAuthority}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+      );
+    }
+  } else if (decodedAuthority.startsWith("/")) {
+    socketPath = decodedAuthority;
+  } else if (!decodedAuthority && rawPath) {
+    const segments = rawPath.split("/");
+    const colonIndex = segments.findIndex((segment) => segment.includes(":"));
+    if (colonIndex !== -1) {
+      socketPath = segments.slice(0, colonIndex + 1).join("/");
+      dbNameOverride = segments[colonIndex + 1];
+      matchedBareSocket = true;
+    }
+  }
+  if (!socketPath) {
+    return null;
+  }
+  let user;
+  let password;
+  if (rawUserinfo) {
+    const colonIndex = rawUserinfo.indexOf(":");
+    const rawUser = colonIndex === -1 ? rawUserinfo : rawUserinfo.slice(0, colonIndex);
+    const rawPassword = colonIndex === -1 ? void 0 : rawUserinfo.slice(colonIndex + 1);
+    user = rawUser ? decodeOrRaw(rawUser) : void 0;
+    password = rawPassword ? decodeOrRaw(rawPassword) : void 0;
+  }
+  return {
+    socketPath,
+    user,
+    password,
+    dbName: matchedBareSocket ? dbNameOverride ? decodeOrRaw(dbNameOverride) : void 0 : rawPath ? decodeOrRaw(rawPath.slice(1)) : void 0,
+    schema: (_b = params.get("schema")) != null ? _b : void 0,
+    extraParams: remainingParams(params, RESERVED_OPTION_KEYS)
+  };
+}
+__name(parseSocketUri, "parseSocketUri");
+function buildPostgresOptions(uri, driver) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(uri);
+  } catch {
+    parsedUrl = null;
+  }
+  if (parsedUrl) {
+    const queryHost = parsedUrl.searchParams.get("host");
+    const decodedHostname = parsedUrl.hostname ? safeDecode(parsedUrl.hostname) : void 0;
+    const socketPath = (queryHost == null ? void 0 : queryHost.startsWith("/")) ? queryHost : (decodedHostname == null ? void 0 : decodedHostname.startsWith("/")) ? decodedHostname : void 0;
+    if (socketPath) {
+      if ((queryHost == null ? void 0 : queryHost.startsWith("/")) && decodedHostname && !decodedHostname.startsWith("/")) {
+        import_logger.logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: import_schema.ENTITIES,
+        driver,
+        host: socketPath,
+        user: parsedUrl.username ? decodeOrRaw(parsedUrl.username) : void 0,
+        password: parsedUrl.password ? decodeOrRaw(parsedUrl.password) : void 0,
+        dbName: decodeOrRaw(parsedUrl.pathname.slice(1)),
+        ...parsedUrl.port ? { port: Number(parsedUrl.port) } : {},
+        ...schema ? { schema } : {},
+        driverOptions: extraParams
+      };
+    }
+    return { entities: import_schema.ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: import_schema.ENTITIES,
+      driver,
+      host: socket.socketPath,
+      user: socket.user,
+      password: socket.password,
+      dbName: socket.dbName,
+      ...socket.schema ? { schema: socket.schema } : {},
+      driverOptions: socket.extraParams
+    };
+  }
+  throw new Error(
+    `Unrecognized postgres connection URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+  );
+}
+__name(buildPostgresOptions, "buildPostgresOptions");
+function buildMySqlFamilyOptions(uri, driver) {
+  let parsedUrl = null;
+  try {
+    parsedUrl = new URL(uri);
+  } catch {
+  }
+  if (parsedUrl) {
+    const queryHost = parsedUrl.searchParams.get("host");
+    const decodedHostname = parsedUrl.hostname ? safeDecode(parsedUrl.hostname) : void 0;
+    const socketPath = (queryHost == null ? void 0 : queryHost.startsWith("/")) ? queryHost : (decodedHostname == null ? void 0 : decodedHostname.startsWith("/")) ? decodedHostname : void 0;
+    if (socketPath) {
+      if ((queryHost == null ? void 0 : queryHost.startsWith("/")) && decodedHostname && !decodedHostname.startsWith("/")) {
+        import_logger.logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: import_schema.ENTITIES,
+        driver,
+        user: parsedUrl.username ? decodeOrRaw(parsedUrl.username) : void 0,
+        password: parsedUrl.password ? decodeOrRaw(parsedUrl.password) : void 0,
+        dbName: decodeOrRaw(parsedUrl.pathname.slice(1)),
+        driverOptions: {
+          socketPath,
+          ...schema ? { schema } : {},
+          ...extraParams
+        }
+      };
+    }
+    return { entities: import_schema.ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: import_schema.ENTITIES,
+      driver,
+      user: socket.user,
+      password: socket.password,
+      dbName: socket.dbName,
+      driverOptions: {
+        socketPath: socket.socketPath,
+        ...socket.schema ? { schema: socket.schema } : {},
+        ...socket.extraParams
+      }
+    };
+  }
+  throw new Error(
+    `Unrecognized MySQL/MariaDB connection URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+  );
+}
+__name(buildMySqlFamilyOptions, "buildMySqlFamilyOptions");
 async function getConnectionOptionsFromUri(uri) {
-  let driver;
   if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
-    const { PostgreSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1));
-    driver = PostgreSqlDriver;
-  } else if (uri.startsWith("mysql://")) {
-    const { MySqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1));
-    driver = MySqlDriver;
-  } else if (uri.startsWith("mariadb://")) {
-    const { MariaDbDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1));
-    driver = MariaDbDriver;
-  } else if (uri.startsWith("sqlite://")) {
-    const { SqliteDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1));
-    driver = SqliteDriver;
-  } else if (uri.startsWith("mssql://")) {
-    const { MsSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1));
-    driver = MsSqlDriver;
-  } else {
-    throw new Error(`Unsupported database URI: ${uri}`);
+    const { PostgreSqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
+      driverPeer("@mikro-orm/postgresql", "postgres"),
+      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1))
+    );
+    return buildPostgresOptions(uri, PostgreSqlDriver);
+  }
+  if (uri.startsWith("mysql://")) {
+    const { MySqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
+      driverPeer("@mikro-orm/mysql", "mysql"),
+      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1))
+    );
+    return buildMySqlFamilyOptions(uri, MySqlDriver);
+  }
+  if (uri.startsWith("mariadb://")) {
+    const { MariaDbDriver } = await (0, import_optional_peer.loadOptionalPeer)(
+      driverPeer("@mikro-orm/mariadb", "mariadb"),
+      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1))
+    );
+    return buildMySqlFamilyOptions(uri, MariaDbDriver);
   }
   if (uri.startsWith("sqlite://")) {
+    const { SqliteDriver } = await (0, import_optional_peer.loadOptionalPeer)(
+      driverPeer("@mikro-orm/sqlite", "sqlite"),
+      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1))
+    );
     return {
       entities: import_schema.ENTITIES,
       dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
-      driver
+      driver: SqliteDriver
     };
   }
-  return {
-    entities: import_schema.ENTITIES,
-    clientUrl: uri,
-    driver
-  };
+  if (uri.startsWith("mssql://")) {
+    const { MsSqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
+      driverPeer("@mikro-orm/mssql", "mssql"),
+      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1))
+    );
+    return {
+      entities: import_schema.ENTITIES,
+      clientUrl: uri,
+      driver: MsSqlDriver
+    };
+  }
+  throw new Error(`Unsupported database URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`);
 }
+__name(getConnectionOptionsFromUri, "getConnectionOptionsFromUri");
 async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema({ safe: true });
+  await orm.schema.update({ safe: true });
 }
+__name(ensureDatabaseCreated, "ensureDatabaseCreated");
 async function validateDatabaseSchemaVersion(orm) {
   const em = orm.em.fork();
   const existing = await em.findOne(import_schema.StorageMetadata, {
@@ -101,6 +335,7 @@ async function validateDatabaseSchemaVersion(orm) {
   });
   await em.persist(newVersion).flush();
 }
+__name(validateDatabaseSchemaVersion, "validateDatabaseSchemaVersion");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ensureDatabaseCreated,