@objectstack/service-datasource 9.11.0 → 10.2.0

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  allowAllConnectPolicy
+} from "./chunk-XLS4RP7B.js";
+
 // src/external-datasource-service.ts
 import {
   suggestFieldType,
@@ -47,6 +51,28 @@ var ExternalDatasourceService = class {
     }
     return tables;
   }
+  /**
+   * Probe a *saved* datasource by name with a live round-trip. Reuses the
+   * introspection path (driver connect + schema read) as a cheap connectivity
+   * check, so the secret is resolved through the same wired pool as the rest of
+   * the introspection surface — the caller never handles cleartext. Returns a
+   * structured result rather than throwing so the route can render ok/error
+   * uniformly. This backs the `datasource` `test_connection` action
+   * (`POST /datasources/:name/test`).
+   */
+  async testConnection(datasource) {
+    const started = Date.now();
+    try {
+      const schema = await this.config.introspect(datasource);
+      return {
+        ok: true,
+        latencyMs: Date.now() - started,
+        tableCount: Object.keys(schema.tables).length
+      };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
   async generateObjectDraft(datasource, remoteName, opts = {}) {
     const schema = await this.config.introspect(datasource);
     const table = this.findTable(schema, remoteName);
@@ -346,6 +372,179 @@ function safeGetService(ctx, name) {
   }
 }
 
+// src/datasource-connection-service.ts
+function isDatasourceAddressed(ds, ctx) {
+  if (ds.schemaMode && ds.schemaMode !== "managed") return true;
+  if (ds.autoConnect === true) return true;
+  if (ctx.objects?.some((o) => o?.datasource === ds.name)) return true;
+  return false;
+}
+var DatasourceConnectionService = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.policy = cfg.policy ?? allowAllConnectPolicy;
+    this.logger = cfg.logger;
+  }
+  /**
+   * Auto-connect the declared (code-defined) datasources that pass the D2 gate.
+   * Called from `AppPlugin.start()` with the app bundle's datasources + objects.
+   * Each connected external datasource also has its bound objects' read metadata
+   * synced so they are immediately queryable with zero app code.
+   */
+  async connectDeclared(input) {
+    const objects = input.objects ?? [];
+    const results = [];
+    for (const ds of input.datasources) {
+      if (!ds?.name) continue;
+      if (ds.active === false) continue;
+      if (!isDatasourceAddressed(ds, { objects })) continue;
+      const bound = objects.filter((o) => o?.datasource === ds.name && typeof o?.name === "string").map((o) => o.name);
+      results.push(
+        await this.connect(ds, { objects: bound, context: { origin: ds.origin ?? "code", trigger: "declared-auto" } })
+      );
+    }
+    return results;
+  }
+  /**
+   * Build + connect + register a single datasource's live driver. The shared
+   * core used by both auto-connect and the runtime-admin pool registration.
+   *
+   * Failure policy (ADR-0062 D5): an `external` datasource with
+   * `validation.onMismatch: 'fail'` fails fast (re-throws, bricking boot as
+   * intended); everything else degrades with a warning so an optional replica's
+   * connectivity blip never bricks boot.
+   */
+  async connect(record, opts = {}) {
+    const name = record.name;
+    const engine = this.cfg.engine();
+    const factory = this.cfg.factory();
+    if (engine?.getDriverByName?.(name)) {
+      return { name, status: "already-registered" };
+    }
+    let decision;
+    try {
+      decision = await this.policy.canConnect(
+        { name, driver: record.driver, schemaMode: record.schemaMode, external: record.external },
+        opts.context
+      );
+    } catch (err) {
+      decision = { allow: false, reason: `connect policy threw: ${errMsg(err)}` };
+    }
+    if (!decision.allow) {
+      this.logger?.info?.(`datasource '${name}': connect denied by policy${decision.reason ? ` (${decision.reason})` : ""}`);
+      return { name, status: "skipped-policy", reason: decision.reason };
+    }
+    if (!factory || !engine?.registerDriver) {
+      this.logger?.debug?.(`datasource '${name}': no driver factory / engine \u2014 left metadata-only`);
+      return { name, status: "skipped-no-infra" };
+    }
+    if (!factory.supports(record.driver)) {
+      return this.handleFailure(
+        record,
+        "skipped-unsupported",
+        `no driver factory supports driver '${record.driver}'`,
+        opts.context
+      );
+    }
+    let secret;
+    const credentialsRef = record.external?.credentialsRef;
+    if (credentialsRef) {
+      const resolver = this.cfg.secrets?.resolve;
+      if (!resolver) {
+        return this.handleFailure(
+          record,
+          "failed-credentials",
+          `requires credential '${credentialsRef}' but no secret store (SecretBinder/ICryptoProvider) is configured`,
+          opts.context
+        );
+      }
+      try {
+        secret = await resolver(credentialsRef);
+      } catch (err) {
+        return this.handleFailure(record, "failed-credentials", `resolving credential '${credentialsRef}' threw: ${errMsg(err)}`, opts.context);
+      }
+      if (secret == null || secret === "") {
+        return this.handleFailure(
+          record,
+          "failed-credentials",
+          `credential '${credentialsRef}' could not be resolved or decrypted (missing sys_secret row, or the encryption key changed)`,
+          opts.context
+        );
+      }
+    }
+    try {
+      const handle = await factory.create({ ...toSpec(record), ...secret ? { secret } : {} });
+      if (typeof handle?.connect === "function") await handle.connect();
+      const engineDriver = handle.driver ?? handle;
+      try {
+        engineDriver.name = name;
+      } catch {
+      }
+      engine.registerDriver(engineDriver);
+      engine.registerDatasourceDef?.({
+        name,
+        schemaMode: record.schemaMode,
+        external: record.external
+      });
+      for (const objectName of opts.objects ?? []) {
+        try {
+          await engine.syncObjectSchema?.(objectName);
+        } catch (err) {
+          this.logger?.warn?.(`datasource '${name}': syncObjectSchema('${objectName}') failed: ${errMsg(err)}`);
+        }
+      }
+      this.logger?.info?.(`datasource '${name}': connected (driver=${record.driver}, schemaMode=${record.schemaMode ?? "managed"})`);
+      return { name, status: "connected" };
+    } catch (err) {
+      return this.handleFailure(record, "failed-degraded", errMsg(err), opts.context);
+    }
+  }
+  /** Gracefully disconnect a previously-registered datasource pool. */
+  async disconnect(name) {
+    const driver = this.cfg.engine()?.getDriverByName?.(name);
+    if (typeof driver?.disconnect === "function") {
+      try {
+        await driver.disconnect();
+      } catch (err) {
+        this.logger?.warn?.(`datasource '${name}': disconnect failed: ${errMsg(err)}`);
+      }
+    }
+  }
+  /**
+   * Apply the D5 connect-failure policy (also covers D3 credential failures). A
+   * code-defined `external` datasource with `onMismatch:'fail'` auto-connected at
+   * boot re-throws (fail-fast, bricking boot as intended). Runtime-admin
+   * create/update + boot rehydration always degrade-with-warning — a UI action
+   * or a replica blip must never brick the running server (preserves the
+   * pre-ADR-0062 admin behavior). Either way the datasource is left unconnected
+   * with a clear message — never a silent skip.
+   */
+  handleFailure(record, status, reason, context) {
+    const isExternal = record.schemaMode && record.schemaMode !== "managed";
+    const failFast = context?.trigger === "declared-auto" && isExternal && record.external?.validation?.onMismatch === "fail";
+    const msg = `datasource '${record.name}': connect failed \u2014 ${reason}`;
+    if (failFast) {
+      throw new Error(
+        `${msg}. (schemaMode=${record.schemaMode}, validation.onMismatch='fail' \u21D2 fail-fast per ADR-0062 D5)`
+      );
+    }
+    this.logger?.warn?.(`${msg} \u2014 degrading (datasource left unconnected)`);
+    return { name: record.name, status, reason };
+  }
+};
+function toSpec(record) {
+  return {
+    name: record.name,
+    driver: record.driver,
+    config: record.config ?? {},
+    external: record.external,
+    pool: record.pool
+  };
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/datasource-admin-service.ts
 var NAME_RE = /^[a-z_][a-z0-9_]*$/;
 var DatasourceAdminService = class {
@@ -382,6 +581,29 @@ var DatasourceAdminService = class {
     }
     return summaries;
   }
+  /**
+   * Read one datasource's full detail for editing, with the credential stripped.
+   * Returns `config` (non-sensitive — credentials live in `sys_secret`, never in
+   * config), `origin`, and a `hasSecret` flag so the UI can show "leave blank to
+   * keep" without ever receiving the `credentialsRef` or any cleartext. Returns
+   * `undefined` when the name is unknown.
+   */
+  async getDatasource(name) {
+    const rec = await this.config.getDatasourceRecord(name);
+    if (!rec) return void 0;
+    const hasSecret = Boolean(rec.external?.credentialsRef);
+    return {
+      name: rec.name,
+      label: rec.label,
+      driver: rec.driver,
+      schemaMode: rec.schemaMode ?? "managed",
+      config: rec.config ?? {},
+      active: rec.active ?? true,
+      origin: rec.origin === "runtime" ? "runtime" : "code",
+      hasSecret,
+      ...rec.definedIn ? { definedIn: rec.definedIn } : {}
+    };
+  }
   async testConnection(input, secret) {
     if (!input?.driver) {
       return { ok: false, error: "A driver is required to test a connection." };
@@ -525,6 +747,57 @@ var DatasourceAdminService = class {
 
 // src/datasource-admin-plugin.ts
 import { registerMetadataTypeActions } from "@objectstack/spec/kernel";
+var DS_META_TYPE = "datasource";
+var SYS_METADATA = "sys_metadata";
+function newMetaId() {
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `meta_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+async function persistDatasourceRow(engine, record) {
+  if (!engine?.insert || !engine.findOne) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await engine.findOne(SYS_METADATA, {
+    where: { type: DS_META_TYPE, name: record.name, state: "active" }
+  });
+  if (existing) {
+    await engine.update?.(
+      SYS_METADATA,
+      { metadata: JSON.stringify(record), updated_at: now, version: (existing.version || 0) + 1, state: "active" },
+      { where: { id: existing.id } }
+    );
+  } else {
+    await engine.insert(SYS_METADATA, {
+      id: newMetaId(),
+      name: record.name,
+      type: DS_META_TYPE,
+      scope: "platform",
+      metadata: JSON.stringify(record),
+      state: "active",
+      version: 1,
+      created_at: now,
+      updated_at: now
+    });
+  }
+}
+async function deleteDatasourceRow(engine, name) {
+  if (!engine?.findOne) return;
+  const existing = await engine.findOne(SYS_METADATA, { where: { type: DS_META_TYPE, name, state: "active" } });
+  if (!existing) return;
+  if (engine.delete) await engine.delete(SYS_METADATA, { where: { id: existing.id } });
+  else await engine.update?.(SYS_METADATA, { state: "inactive" }, { where: { id: existing.id } });
+}
+async function loadDatasourceRows(engine) {
+  if (!engine?.find) return [];
+  const rows = await engine.find(SYS_METADATA, { where: { type: DS_META_TYPE, state: "active" } });
+  const out = [];
+  for (const r of rows ?? []) {
+    const raw = r.metadata;
+    try {
+      out.push(typeof raw === "string" ? JSON.parse(raw) : raw);
+    } catch {
+    }
+  }
+  return out;
+}
 var DatasourceAdminServicePlugin = class {
   constructor(options = {}) {
     this.name = "com.objectstack.service-datasource-admin";
@@ -551,6 +824,14 @@ var DatasourceAdminServicePlugin = class {
     const metadataOf = () => safeGetService2(ctx, "metadata");
     const engineOf = () => safeGetService2(ctx, "data");
     const factory = () => this.options.driverFactory ?? safeGetService2(ctx, "datasource-driver-factory");
+    this.connection = new DatasourceConnectionService({
+      factory,
+      engine: () => engineOf(),
+      secrets: { resolve: (ref) => this.options.secrets?.resolve?.(ref) ?? Promise.resolve(void 0) },
+      policy: this.options.connectPolicy,
+      logger: this.options.logger
+    });
+    ctx.registerService("datasource-connection", this.connection);
     const config = {
       probe: (input) => this.probe(factory(), input),
       listDatasourceRecords: async () => {
@@ -567,6 +848,7 @@ var DatasourceAdminServicePlugin = class {
           throw new Error("Metadata service is unavailable; cannot persist datasource.");
         }
         await metadata.register("datasource", record.name, record);
+        await persistDatasourceRow(engineOf(), record);
       },
       deleteDatasourceRecord: async (name) => {
         const metadata = metadataOf();
@@ -574,6 +856,7 @@ var DatasourceAdminServicePlugin = class {
           throw new Error("Metadata service is unavailable; cannot remove datasource.");
         }
         await metadata.unregister("datasource", name);
+        await deleteDatasourceRow(engineOf(), name);
       },
       writeSecret: async (input, hint) => {
         const binder = this.options.secrets;
@@ -592,40 +875,90 @@ var DatasourceAdminServicePlugin = class {
         const objects = await metadata?.listObjects?.() ?? await metadata?.list("object") ?? [];
         return objects.filter((o) => o?.datasource === datasource).length;
       },
+      // Hot pool (de)registration converges on the shared
+      // DatasourceConnectionService (ADR-0062 D1) — one connect path for code-
+      // and runtime-origin datasources. `connect()` builds the driver via the
+      // factory, dereferences `external.credentialsRef` through the SecretBinder,
+      // opens the connection, and registers the live driver + datasource def.
+      // Runtime-admin connects always degrade-with-warning on failure (never
+      // fail-fast), preserving the pre-ADR-0062 admin behavior.
       registerPool: async (record) => {
-        const f = factory();
-        const engine = engineOf();
-        if (!f || !engine?.registerDriver || !f.supports(record.driver)) return;
-        const credentialsRef = record.external?.credentialsRef;
-        const secret = credentialsRef ? await this.options.secrets?.resolve?.(credentialsRef) : void 0;
-        const handle = await f.create({ ...this.toSpec(record), ...secret ? { secret } : {} });
-        if (typeof handle?.connect === "function") await handle.connect();
-        const engineDriver = handle.driver ?? handle;
-        try {
-          engineDriver.name = record.name;
-        } catch {
-        }
-        engine.registerDriver(engineDriver);
-        engine.registerDatasourceDef?.({
-          name: record.name,
-          schemaMode: record.schemaMode,
-          external: record.external
+        await this.connection?.connect(record, {
+          context: { origin: record.origin ?? "runtime", trigger: "runtime-admin" }
         });
       },
       unregisterPool: async (name) => {
-        const driver = engineOf()?.getDriverByName?.(name);
-        if (typeof driver?.disconnect === "function") await driver.disconnect();
+        await this.connection?.disconnect(name);
       },
       logger
     };
     this.config = config;
     this.service = new DatasourceAdminService(config);
     ctx.registerService("datasource-admin", this.service);
+    try {
+      const manifest = ctx.getService("manifest");
+      if (manifest && typeof manifest.register === "function") {
+        manifest.register({
+          id: "com.objectstack.service-datasource.nav",
+          namespace: "sys",
+          version: this.version,
+          type: "plugin",
+          scope: "system",
+          name: "Datasource Navigation",
+          description: "Contributes the Datasources entry to the Setup app Integrations group.",
+          navigationContributions: [
+            {
+              app: "setup",
+              group: "group_integrations",
+              priority: 100,
+              items: [
+                {
+                  id: "nav_datasources",
+                  type: "url",
+                  label: "Datasources",
+                  url: "/apps/setup/component/metadata/resource?type=datasource",
+                  icon: "database",
+                  requiredPermissions: ["manage_platform_settings"]
+                }
+              ]
+            }
+          ]
+        });
+      }
+    } catch (err) {
+      this.options.logger?.warn?.("datasource nav contribution skipped", err);
+    }
   }
   async start(ctx) {
+    await this.restoreRuntimeDatasources(ctx);
     await this.rehydratePools();
     if (this.service) await ctx.trigger("datasource-admin:ready", this.service);
   }
+  /** Reload persisted runtime datasource rows (sys_metadata) into the registry. */
+  async restoreRuntimeDatasources(ctx) {
+    const engine = safeGetService2(ctx, "data");
+    const metadata = safeGetService2(ctx, "metadata");
+    if (!engine?.find || !metadata?.register) return;
+    let rows;
+    try {
+      rows = await loadDatasourceRows(engine);
+    } catch (err) {
+      this.options.logger?.warn?.("datasource restore: reading sys_metadata failed", err);
+      return;
+    }
+    let restored = 0;
+    for (const rec of rows) {
+      const name = rec.name;
+      if (!name) continue;
+      try {
+        await metadata.register("datasource", name, rec);
+        restored += 1;
+      } catch (err) {
+        this.options.logger?.warn?.(`datasource restore: register '${name}' failed`, err);
+      }
+    }
+    if (restored > 0) this.options.logger?.info?.(`datasource: restored ${restored} runtime record(s) from sys_metadata`);
+  }
   /**
    * Boot-time rehydration: list persisted runtime datasources and re-register
    * each one's connection pool (driver build → connect → registerDriver),
@@ -664,15 +997,6 @@ var DatasourceAdminServicePlugin = class {
     this.service = void 0;
   }
   // --- internals -----------------------------------------------------------
-  toSpec(record) {
-    return {
-      name: record.name,
-      driver: record.driver,
-      config: record.config ?? {},
-      external: record.external,
-      pool: record.pool
-    };
-  }
   /** Probe a connection via the driver factory: build → connect → ping → close. */
   async probe(factory, input) {
     if (!factory) {
@@ -690,7 +1014,7 @@ var DatasourceAdminServicePlugin = class {
         external: input.external
       });
     } catch (err) {
-      return { ok: false, error: `Failed to build driver: ${errMsg(err)}` };
+      return { ok: false, error: `Failed to build driver: ${errMsg2(err)}` };
     }
     const startedAt = monotonicNow();
     try {
@@ -706,7 +1030,7 @@ var DatasourceAdminServicePlugin = class {
       }
       return { ok: true, latencyMs, ...serverVersion ? { serverVersion } : {} };
     } catch (err) {
-      return { ok: false, error: errMsg(err) };
+      return { ok: false, error: errMsg2(err) };
     } finally {
       try {
         if (typeof driver?.disconnect === "function") await driver.disconnect();
@@ -722,7 +1046,7 @@ function safeGetService2(ctx, name) {
     return void 0;
   }
 }
-function errMsg(err) {
+function errMsg2(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function monotonicNow() {
@@ -914,6 +1238,92 @@ function createDatasourceSecretBinder(deps) {
   };
 }
 
+// src/driver-catalog.ts
+var SSL_PROP = {
+  ssl: { type: "boolean", title: "Use SSL/TLS", default: false }
+};
+var DRIVER_CATALOG = [
+  {
+    id: "memory",
+    label: "In-Memory",
+    description: "Ephemeral in-memory driver for dev, tests, and prototyping. No connection settings.",
+    icon: "memory-stick",
+    configSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    id: "sqlite",
+    label: "SQLite",
+    description: "File-backed (or in-memory) SQL database. Great for local dev and small deployments.",
+    icon: "database",
+    configSchema: {
+      type: "object",
+      properties: {
+        filename: {
+          type: "string",
+          title: "Filename",
+          description: 'Database file path, or ":memory:" for an ephemeral in-memory database.',
+          default: ":memory:"
+        }
+      },
+      required: ["filename"],
+      additionalProperties: false
+    }
+  },
+  {
+    id: "postgres",
+    label: "PostgreSQL",
+    description: "PostgreSQL connection. Supply host/port/database or a connection URL.",
+    icon: "database",
+    configSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", title: "Connection URL", description: "postgres://user:pass@host:5432/db (overrides the fields below when set)." },
+        host: { type: "string", title: "Host", default: "localhost" },
+        port: { type: "number", title: "Port", default: 5432 },
+        database: { type: "string", title: "Database" },
+        username: { type: "string", title: "User" },
+        password: { type: "string", title: "Password", format: "password" },
+        schema: { type: "string", title: "Schema", default: "public" },
+        ...SSL_PROP
+      },
+      additionalProperties: true
+    }
+  },
+  {
+    id: "mysql",
+    label: "MySQL / MariaDB",
+    description: "MySQL or MariaDB connection.",
+    icon: "database",
+    configSchema: {
+      type: "object",
+      properties: {
+        host: { type: "string", title: "Host", default: "localhost" },
+        port: { type: "number", title: "Port", default: 3306 },
+        database: { type: "string", title: "Database" },
+        username: { type: "string", title: "User" },
+        password: { type: "string", title: "Password", format: "password" },
+        ...SSL_PROP
+      },
+      additionalProperties: true
+    }
+  },
+  {
+    id: "mongo",
+    label: "MongoDB",
+    description: "MongoDB connection via a connection URI.",
+    icon: "database",
+    configSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", title: "Connection URI", description: "mongodb://host:27017" },
+        database: { type: "string", title: "Database" }
+      },
+      required: ["url"],
+      additionalProperties: true
+    }
+  }
+];
+
 // src/admin-routes.ts
 function registerDatasourceAdminRoutes(server, ctx, basePath = "/api/v1") {
   const root = `${basePath}/datasources`;
@@ -924,6 +1334,13 @@ function registerDatasourceAdminRoutes(server, ctx, basePath = "/api/v1") {
       return void 0;
     }
   };
+  const externalService = () => {
+    try {
+      return ctx.getService("external-datasource");
+    } catch {
+      return void 0;
+    }
+  };
   const unavailable = (res) => res.status(503).json({ error: "datasource_admin_unavailable" });
   const badRequest = (res, err) => res.status(400).json({ error: "datasource_admin_error", message: err instanceof Error ? err.message : String(err) });
   const splitSecret = (body) => {
@@ -937,6 +1354,52 @@ function registerDatasourceAdminRoutes(server, ctx, basePath = "/api/v1") {
     const datasources = await svc.listDatasources();
     res.json({ datasources });
   });
+  server.get(`${root}/drivers`, async (_req, res) => {
+    res.json({ drivers: DRIVER_CATALOG });
+  });
+  server.get(`${root}/:name/remote-tables`, async (req, res) => {
+    const svc = externalService();
+    if (!svc?.listRemoteTables) return unavailable(res);
+    try {
+      const tables = await svc.listRemoteTables(req.params.name);
+      res.json({ tables });
+    } catch (err) {
+      badRequest(res, err);
+    }
+  });
+  server.get(`${root}/:name`, async (req, res) => {
+    const svc = adminService();
+    if (!svc?.getDatasource) return unavailable(res);
+    try {
+      const datasource = await svc.getDatasource(req.params.name);
+      if (!datasource) return res.status(404).json({ error: "not_found" });
+      res.json({ datasource });
+    } catch (err) {
+      badRequest(res, err);
+    }
+  });
+  server.post(`${root}/:name/test`, async (req, res) => {
+    const svc = externalService();
+    if (!svc?.testConnection) return unavailable(res);
+    try {
+      const result = await svc.testConnection(req.params.name);
+      res.json(result);
+    } catch (err) {
+      badRequest(res, err);
+    }
+  });
+  server.post(`${root}/:name/object-draft`, async (req, res) => {
+    const svc = externalService();
+    if (!svc?.generateObjectDraft) return unavailable(res);
+    const { table, ...opts } = req.body ?? {};
+    if (!table) return badRequest(res, new Error('Body field "table" is required.'));
+    try {
+      const draft = await svc.generateObjectDraft(req.params.name, String(table), opts);
+      res.json({ draft });
+    } catch (err) {
+      badRequest(res, err);
+    }
+  });
   server.post(`${root}/test`, async (req, res) => {
     const svc = adminService();
     if (!svc?.testConnection) return unavailable(res);
@@ -984,10 +1447,13 @@ function registerDatasourceAdminRoutes(server, ctx, basePath = "/api/v1") {
 export {
   DatasourceAdminService,
   DatasourceAdminServicePlugin,
+  DatasourceConnectionService,
   ExternalDatasourceService,
   ExternalDatasourceServicePlugin,
+  allowAllConnectPolicy,
   createDatasourceSecretBinder,
   createDefaultDatasourceDriverFactory,
+  isDatasourceAddressed,
   parseCredentialsRef,
   registerDatasourceAdminRoutes,
   toCredentialsRef