@useatlas/create 0.0.2 → 0.0.3

package/templates/docker/src/lib/db/__tests__/connection.test.ts

@@ -1,28 +1,95 @@
 /**
- * Tests for detectDBType from connection.ts.
+ * Tests for detectDBType and resolveDatasourceUrl from connection.ts.
  *
  * sql.test.ts registers a global mock.module for @/lib/db/connection which
  * persists across bun's test runner. To test the real implementation, we
  * import the source file via a cache-busting query string that bypasses the mock.
  */
-import { describe, it, expect, beforeEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { resolve } from "path";
 
 const modulePath = resolve(__dirname, "../connection.ts");
 const mod = await import(`${modulePath}?t=${Date.now()}`);
-const detectDBType = mod.detectDBType as (url?: string) => "postgres" | "mysql" | "duckdb";
+const detectDBType = mod.detectDBType as (url?: string) => "postgres" | "mysql";
+const resolveDatasourceUrl = mod.resolveDatasourceUrl as () => string | undefined;
 
-describe("detectDBType", () => {
-  const origDatabaseUrl = process.env.ATLAS_DATASOURCE_URL;
+// Env vars touched by tests — save/restore
+const MANAGED_VARS = [
+  "ATLAS_DATASOURCE_URL",
+  "ATLAS_DEMO_DATA",
+  "DATABASE_URL",
+  "DATABASE_URL_UNPOOLED",
+] as const;
+const savedEnv: Record<string, string | undefined> = {};
+
+function saveEnv() {
+  for (const key of MANAGED_VARS) savedEnv[key] = process.env[key];
+}
+
+function restoreEnv() {
+  for (const key of MANAGED_VARS) {
+    if (savedEnv[key] !== undefined) process.env[key] = savedEnv[key];
+    else delete process.env[key];
+  }
+}
+
+describe("resolveDatasourceUrl", () => {
+  beforeEach(() => {
+    saveEnv();
+    for (const key of MANAGED_VARS) delete process.env[key];
+  });
+
+  afterEach(restoreEnv);
+
+  it("returns ATLAS_DATASOURCE_URL when set", () => {
+    process.env.ATLAS_DATASOURCE_URL = "postgresql://explicit@localhost/db";
+    expect(resolveDatasourceUrl()).toBe("postgresql://explicit@localhost/db");
+  });
+
+  it("returns ATLAS_DATASOURCE_URL even when ATLAS_DEMO_DATA=true", () => {
+    process.env.ATLAS_DATASOURCE_URL = "postgresql://explicit@localhost/db";
+    process.env.ATLAS_DEMO_DATA = "true";
+    process.env.DATABASE_URL = "postgresql://fallback@localhost/db";
+    expect(resolveDatasourceUrl()).toBe("postgresql://explicit@localhost/db");
+  });
+
+  it("returns DATABASE_URL_UNPOOLED when ATLAS_DEMO_DATA=true and both fallbacks set", () => {
+    process.env.ATLAS_DEMO_DATA = "true";
+    process.env.DATABASE_URL_UNPOOLED = "postgresql://unpooled@localhost/db";
+    process.env.DATABASE_URL = "postgresql://pooled@localhost/db";
+    expect(resolveDatasourceUrl()).toBe("postgresql://unpooled@localhost/db");
+  });
 
+  it("returns DATABASE_URL when ATLAS_DEMO_DATA=true and only DATABASE_URL set", () => {
+    process.env.ATLAS_DEMO_DATA = "true";
+    process.env.DATABASE_URL = "postgresql://pooled@localhost/db";
+    expect(resolveDatasourceUrl()).toBe("postgresql://pooled@localhost/db");
+  });
+
+  it("returns undefined when nothing is configured", () => {
+    expect(resolveDatasourceUrl()).toBeUndefined();
+  });
+
+  it("returns undefined when ATLAS_DEMO_DATA is not exactly 'true'", () => {
+    process.env.ATLAS_DEMO_DATA = "TRUE";
+    process.env.DATABASE_URL = "postgresql://fallback@localhost/db";
+    expect(resolveDatasourceUrl()).toBeUndefined();
+  });
+
+  it("returns undefined when ATLAS_DEMO_DATA=true but no DATABASE_URL vars set", () => {
+    process.env.ATLAS_DEMO_DATA = "true";
+    expect(resolveDatasourceUrl()).toBeUndefined();
+  });
+});
+
+describe("detectDBType", () => {
   beforeEach(() => {
-    if (origDatabaseUrl !== undefined) {
-      process.env.ATLAS_DATASOURCE_URL = origDatabaseUrl;
-    } else {
-      delete process.env.ATLAS_DATASOURCE_URL;
-    }
+    saveEnv();
+    for (const key of MANAGED_VARS) delete process.env[key];
   });
 
+  afterEach(restoreEnv);
+
   it("detects postgresql:// as postgres", () => {
     expect(detectDBType("postgresql://user:pass@localhost:5432/db")).toBe("postgres");
   });
@@ -53,12 +120,20 @@ describe("detectDBType", () => {
     expect(() => detectDBType("")).toThrow("No database URL provided");
   });
 
-  it("detects duckdb:// as duckdb", () => {
-    expect(detectDBType("duckdb://:memory:")).toBe("duckdb");
+  it("throws for non-core adapter URLs with plugin migration hint", () => {
+    expect(() => detectDBType("duckdb://:memory:")).toThrow("now a plugin");
+    expect(() => detectDBType("clickhouse://localhost:8123/default")).toThrow("now a plugin");
+    expect(() => detectDBType("snowflake://user:pass@account/db")).toThrow("now a plugin");
+    expect(() => detectDBType("salesforce://user:pass@login.salesforce.com")).toThrow("now a plugin");
+  });
+
+  it("suggests correct plugin name for TLS scheme variants", () => {
+    expect(() => detectDBType("clickhouses://localhost:8443/default")).toThrow("@useatlas/clickhouse");
   });
 
-  it("detects duckdb://path as duckdb", () => {
-    expect(detectDBType("duckdb:///tmp/test.duckdb")).toBe("duckdb");
+  it("includes the detected scheme in the error message", () => {
+    expect(() => detectDBType("duckdb://:memory:")).toThrow("duckdb://");
+    expect(() => detectDBType("clickhouse://localhost")).toThrow("clickhouse://");
   });
 
   it("unrecognized URL throws an error", () => {

package/templates/docker/src/lib/db/__tests__/registry-health.test.ts

@@ -24,24 +24,7 @@ mock.module("mysql2/promise", () => ({
   }),
 }));
 
-mock.module("@duckdb/node-api", () => ({
-  DuckDBInstance: {
-    async create() {
-      return {
-        async connect() {
-          return {
-            async runAndReadAll() {
-              return { columnNames: () => [], getRowObjects: () => [] };
-            },
-            async run() {},
-            async close() {},
-          };
-        },
-        async close() {},
-      };
-    },
-  },
-}));
+// Note: DuckDB mock removed — adapter is now a plugin.
 
 // Cache-busting import
 const connModPath = resolve(__dirname, "../connection.ts");

package/templates/docker/src/lib/db/__tests__/registry-pool-limits.test.ts

@@ -26,25 +26,6 @@ mock.module("mysql2/promise", () => ({
   }),
 }));
 
-mock.module("@duckdb/node-api", () => ({
-  DuckDBInstance: {
-    async create() {
-      return {
-        async connect() {
-          return {
-            async runAndReadAll() {
-              return { columnNames: () => [], getRowObjects: () => [] };
-            },
-            async run() {},
-            async close() {},
-          };
-        },
-        async close() {},
-      };
-    },
-  },
-}));
-
 // Cache-busting import
 const connModPath = resolve(__dirname, "../connection.ts");
 const connMod = await import(`${connModPath}?t=${Date.now()}`);

package/templates/docker/src/lib/db/__tests__/registry.test.ts

@@ -40,70 +40,8 @@ mock.module("mysql2/promise", () => ({
   }),
 }));
 
-// ClickHouse mock with spies to capture arguments
-let lastCreateClientOpts: Record<string, unknown> | null = null;
-let lastQueryOpts: Record<string, unknown> | null = null;
-let mockJsonResponse: { meta: { name: string }[]; data: Record<string, unknown>[] } = {
-  meta: [],
-  data: [],
-};
-
-mock.module("@clickhouse/client", () => ({
-  createClient: (opts: Record<string, unknown>) => {
-    lastCreateClientOpts = opts;
-    return {
-      async query(qOpts: Record<string, unknown>) {
-        lastQueryOpts = qOpts;
-        return {
-          async json() {
-            return mockJsonResponse;
-          },
-        };
-      },
-      async close() {},
-    };
-  },
-}));
-
-mock.module("@duckdb/node-api", () => ({
-  DuckDBInstance: {
-    async create() {
-      return {
-        async connect() {
-          return {
-            async runAndReadAll() {
-              return {
-                columnNames: () => [],
-                getRowObjects: () => [],
-              };
-            },
-            async run() {},
-            async close() {},
-          };
-        },
-        async close() {},
-      };
-    },
-  },
-}));
-
-mock.module("snowflake-sdk", () => ({
-  configure: () => {},
-  createPool: () => ({
-    use: async (fn: (conn: unknown) => Promise<unknown>) => {
-      const mockConn = {
-        execute: (opts: { sqlText: string; complete: (err: null, stmt: unknown, rows: unknown[]) => void }) => {
-          opts.complete(null, {
-            getColumns: () => [],
-          }, []);
-        },
-      };
-      return fn(mockConn);
-    },
-    drain: async () => {},
-    clear: async () => {},
-  }),
-}));
+// Note: ClickHouse, DuckDB, Snowflake adapter mocks removed — those
+// adapters are now plugins. See plugins/{clickhouse,duckdb,snowflake}-datasource/.
 
 // Cache-busting import to get a fresh module instance
 const connModPath = resolve(__dirname, "../connection.ts");
@@ -113,7 +51,6 @@ const ConnectionRegistry = connMod.ConnectionRegistry as typeof import("../conne
 const connections = connMod.connections as import("../connection").ConnectionRegistry;
 const getDB = connMod.getDB as typeof import("../connection").getDB;
 const detectDBType = connMod.detectDBType as typeof import("../connection").detectDBType;
-const rewriteClickHouseUrl = connMod.rewriteClickHouseUrl as typeof import("../connection").rewriteClickHouseUrl;
 
 // Import semantic module with cache-busting too
 const semModPath = resolve(__dirname, "../../semantic.ts");
@@ -129,9 +66,6 @@ describe("ConnectionRegistry", () => {
     connections._reset();
     delete process.env.ATLAS_DATASOURCE_URL;
     delete process.env.ATLAS_SCHEMA;
-    lastCreateClientOpts = null;
-    lastQueryOpts = null;
-    mockJsonResponse = { meta: [], data: [] };
   });
 
   afterEach(() => {
@@ -284,28 +218,10 @@ describe("ConnectionRegistry", () => {
       expect(connections.get("my")).toBeDefined();
     });
 
-    it("creates clickhouse connection for clickhouse:// URLs", () => {
-      connections.register("ch", {
-        url: "clickhouse://user:pass@localhost:8123/default",
-      });
-      const conn = connections.get("ch");
-      expect(conn).toBeDefined();
-      expect(conn.query).toBeFunction();
-      expect(conn.close).toBeFunction();
-    });
-
-    it("creates snowflake connection for snowflake:// URLs", () => {
-      connections.register("sf", {
-        url: "snowflake://user:pass@account123/mydb/myschema?warehouse=WH",
-      });
-      expect(connections.get("sf")).toBeDefined();
-    });
-
-    it("creates duckdb connection for duckdb:// URLs", () => {
-      connections.register("dk", {
-        url: "duckdb://:memory:",
-      });
-      expect(connections.get("dk")).toBeDefined();
+    it("throws for non-core adapter URLs with plugin migration hint", () => {
+      expect(() => connections.register("ch", { url: "clickhouse://user:pass@localhost:8123/default" })).toThrow("plugin");
+      expect(() => connections.register("sf", { url: "snowflake://user:pass@account123/mydb" })).toThrow("plugin");
+      expect(() => connections.register("dk", { url: "duckdb://:memory:" })).toThrow("plugin");
     });
 
     it("throws for unrecognized URL scheme", () => {
@@ -335,21 +251,12 @@ describe("ConnectionRegistry", () => {
       expect(connections.getDBType("my")).toBe("mysql");
     });
 
-    it("returns correct type for clickhouse connection", () => {
-      connections.register("ch", { url: "clickhouse://user:pass@localhost:8123/default" });
+    it("returns correct type for plugin-registered connection", async () => {
+      const conn = { async query() { return { columns: [], rows: [] }; }, async close() {} };
+      await connections.registerDirect("ch", conn, "clickhouse");
       expect(connections.getDBType("ch")).toBe("clickhouse");
     });
 
-    it("returns correct type for snowflake connection", () => {
-      connections.register("sf", { url: "snowflake://user:pass@account123/mydb/myschema?warehouse=WH" });
-      expect(connections.getDBType("sf")).toBe("snowflake");
-    });
-
-    it("returns correct type for duckdb connection", () => {
-      connections.register("dk", { url: "duckdb://:memory:" });
-      expect(connections.getDBType("dk")).toBe("duckdb");
-    });
-
     it("throws for unregistered connection ID", () => {
       expect(() => connections.getDBType("nonexistent")).toThrow(
         'Connection "nonexistent" is not registered.'
@@ -426,10 +333,6 @@ describe("ConnectionRegistry", () => {
   });
 
   describe("detectDBType", () => {
-    it("returns 'clickhouse' for clickhouse:// URLs", () => {
-      expect(detectDBType("clickhouse://user:pass@localhost:8123/default")).toBe("clickhouse");
-    });
-
     it("returns 'postgres' for postgresql:// URLs", () => {
       expect(detectDBType("postgresql://user:pass@localhost:5432/db")).toBe("postgres");
     });
@@ -438,8 +341,8 @@ describe("ConnectionRegistry", () => {
       expect(detectDBType("mysql://user:pass@localhost:3306/db")).toBe("mysql");
     });
 
-    it("returns 'duckdb' for duckdb:// URLs", () => {
-      expect(detectDBType("duckdb://:memory:")).toBe("duckdb");
+    it("throws for non-core URL schemes with plugin suggestion", () => {
+      expect(() => detectDBType("clickhouse://user:pass@localhost:8123/default")).toThrow("plugin");
     });
 
     it("throws for unsupported URL scheme", () => {
@@ -447,106 +350,6 @@ describe("ConnectionRegistry", () => {
     });
   });
 
-  describe("ClickHouse adapter", () => {
-    it("passes readonly: 1 and max_execution_time in query settings", async () => {
-      connections.register("ch", {
-        url: "clickhouse://user:pass@localhost:8123/default",
-      });
-      const conn = connections.get("ch");
-      await conn.query("SELECT 1", 30000);
-
-      expect(lastQueryOpts).toBeDefined();
-      const settings = (lastQueryOpts as Record<string, unknown>)
-        .clickhouse_settings as Record<string, unknown>;
-      expect(settings.readonly).toBe(1);
-      expect(settings.max_execution_time).toBe(Math.ceil(30000 / 1000));
-    });
-
-    it("computes max_execution_time correctly from timeout", async () => {
-      connections.register("ch", {
-        url: "clickhouse://user:pass@localhost:8123/default",
-      });
-      const conn = connections.get("ch");
-      // 7500ms → ceil(7.5) = 8 seconds
-      await conn.query("SELECT 1", 7500);
-
-      const settings = (lastQueryOpts as Record<string, unknown>)
-        .clickhouse_settings as Record<string, unknown>;
-      expect(settings.max_execution_time).toBe(8);
-    });
-
-    it("rewrites clickhouse:// URL to http:// for createClient", () => {
-      connections.register("ch", {
-        url: "clickhouse://user:pass@host:8123/db",
-      });
-
-      expect(lastCreateClientOpts).toBeDefined();
-      expect((lastCreateClientOpts as Record<string, unknown>).url).toBe(
-        "http://user:pass@host:8123/db"
-      );
-    });
-
-    it("rewrites clickhouses:// URL to https:// for createClient", () => {
-      connections.register("chs", {
-        url: "clickhouses://user:pass@host:8443/db",
-      });
-
-      expect(lastCreateClientOpts).toBeDefined();
-      expect((lastCreateClientOpts as Record<string, unknown>).url).toBe(
-        "https://user:pass@host:8443/db"
-      );
-    });
-
-    it("extracts columns and rows from ClickHouse JSON response", async () => {
-      mockJsonResponse = {
-        meta: [{ name: "id" }, { name: "name" }],
-        data: [{ id: 1, name: "test" }],
-      };
-
-      connections.register("ch", {
-        url: "clickhouse://user:pass@localhost:8123/default",
-      });
-      const conn = connections.get("ch");
-      const result = await conn.query("SELECT id, name FROM companies");
-
-      expect(result.columns).toEqual(["id", "name"]);
-      expect(result.rows).toEqual([{ id: 1, name: "test" }]);
-    });
-
-    it("describe() reports dbType as 'clickhouse' with description", () => {
-      connections.register("ch", {
-        url: "clickhouse://user:pass@localhost:8123/default",
-        description: "Analytics warehouse",
-      });
-
-      const meta = connections.describe();
-      const chMeta = meta.find((m) => m.id === "ch");
-      expect(chMeta).toBeDefined();
-      expect(chMeta!.dbType).toBe("clickhouse");
-      expect(chMeta!.description).toBe("Analytics warehouse");
-    });
-  });
-
-  describe("rewriteClickHouseUrl", () => {
-    it("rewrites clickhouse:// to http://", () => {
-      expect(rewriteClickHouseUrl("clickhouse://user:pass@host:8123/db")).toBe(
-        "http://user:pass@host:8123/db"
-      );
-    });
-
-    it("rewrites clickhouses:// to https://", () => {
-      expect(rewriteClickHouseUrl("clickhouses://user:pass@host:8443/db")).toBe(
-        "https://user:pass@host:8443/db"
-      );
-    });
-  });
-
-  describe("detectDBType — ClickHouse schemes", () => {
-    it("returns 'clickhouse' for clickhouses:// URLs", () => {
-      expect(detectDBType("clickhouses://user:pass@host:8443/db")).toBe("clickhouse");
-    });
-  });
-
   describe("constructor creates independent instances", () => {
     it("new ConnectionRegistry is independent", () => {
       const reg = new ConnectionRegistry();