@objectstack/service-datasource 9.10.0 → 10.0.0

package/dist/index.js

@@ -47,6 +47,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);
@@ -382,6 +404,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 +570,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";
@@ -567,6 +663,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 +671,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;
@@ -621,11 +719,70 @@ var DatasourceAdminServicePlugin = class {
     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),
@@ -914,6 +1071,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 +1167,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 +1187,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);