@useatlas/create 0.0.2 → 0.0.4

package/templates/nextjs-standalone/src/lib/db/__tests__/snowflake.test.ts

@@ -1,217 +0,0 @@
-/**
- * Tests for Snowflake URL parsing, detectDBType integration, and connection behavior.
- */
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-import { resolve } from "path";
-
-// Track all SQL statements executed via the mock connection.
-// Reset in each describe block's beforeEach to prevent cross-test pollution.
-let executedStatements: string[] = [];
-
-// Flag to make the QUERY_TAG ALTER SESSION fail in specific tests
-let queryTagShouldFail = false;
-
-// Mock logger to capture structured log output
-const mockWarn = mock(() => {});
-mock.module("@atlas/api/lib/logger", () => ({
-  createLogger: () => ({
-    info: mock(() => {}),
-    warn: mockWarn,
-    error: mock(() => {}),
-    debug: mock(() => {}),
-    child: () => ({ info: mock(() => {}), warn: mockWarn, error: mock(() => {}), debug: mock(() => {}) }),
-  }),
-}));
-
-// Mock database drivers before importing connection module
-mock.module("pg", () => ({
-  Pool: class MockPool {
-    async query() { return { rows: [], fields: [] }; }
-    async connect() { return { async query() { return { rows: [], fields: [] }; }, release() {} }; }
-    async end() {}
-  },
-}));
-
-mock.module("mysql2/promise", () => ({
-  createPool: () => ({
-    async getConnection() { return { async execute() { return [[], []]; }, release() {} }; },
-    async end() {},
-  }),
-}));
-
-mock.module("snowflake-sdk", () => ({
-  configure: () => {},
-  createPool: () => ({
-    use: async (fn: (conn: unknown) => Promise<unknown>) => {
-      const mockConn = {
-        execute: (opts: { sqlText: string; complete: (err: Error | null, stmt: unknown, rows: unknown[]) => void }) => {
-          executedStatements.push(opts.sqlText);
-          if (queryTagShouldFail && opts.sqlText.includes("QUERY_TAG")) {
-            opts.complete(new Error("Insufficient privileges to set QUERY_TAG"), null, []);
-            return;
-          }
-          opts.complete(null, { getColumns: () => [] }, []);
-        },
-      };
-      return fn(mockConn);
-    },
-    drain: async () => {},
-    clear: async () => {},
-  }),
-}));
-
-// Cache-busting import to get a fresh module instance, avoiding interference
-// from global mock.module("@atlas/api/lib/db/connection") in other test files
-// (e.g. sql.test.ts) that don't export parseSnowflakeURL.
-const connModPath = resolve(__dirname, "../connection.ts");
-const connMod = await import(`${connModPath}?t=${Date.now()}`);
-const parseSnowflakeURL = connMod.parseSnowflakeURL as typeof import("../connection").parseSnowflakeURL;
-const detectDBType = connMod.detectDBType as typeof import("../connection").detectDBType;
-
-describe("parseSnowflakeURL", () => {
-  it("parses full Snowflake URL with all components", () => {
-    const opts = parseSnowflakeURL(
-      "snowflake://myuser:mypass@xy12345.us-east-1/mydb/myschema?warehouse=COMPUTE_WH&role=ANALYST"
-    );
-    expect(opts.account).toBe("xy12345.us-east-1");
-    expect(opts.username).toBe("myuser");
-    expect(opts.password).toBe("mypass");
-    expect(opts.database).toBe("mydb");
-    expect(opts.schema).toBe("myschema");
-    expect(opts.warehouse).toBe("COMPUTE_WH");
-    expect(opts.role).toBe("ANALYST");
-  });
-
-  it("parses URL with database only (no schema)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123/mydb");
-    expect(opts.account).toBe("account123");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("pass");
-    expect(opts.database).toBe("mydb");
-    expect(opts.schema).toBeUndefined();
-    expect(opts.warehouse).toBeUndefined();
-    expect(opts.role).toBeUndefined();
-  });
-
-  it("parses minimal URL (account only)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123");
-    expect(opts.account).toBe("account123");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("pass");
-    expect(opts.database).toBeUndefined();
-    expect(opts.schema).toBeUndefined();
-  });
-
-  it("decodes URL-encoded credentials", () => {
-    const opts = parseSnowflakeURL("snowflake://my%40user:p%40ss%23word@account123/db");
-    expect(opts.username).toBe("my@user");
-    expect(opts.password).toBe("p@ss#word");
-  });
-
-  it("handles warehouse query parameter only", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123/db/schema?warehouse=WH");
-    expect(opts.warehouse).toBe("WH");
-    expect(opts.role).toBeUndefined();
-  });
-
-  it("throws for non-snowflake protocol", () => {
-    expect(() => parseSnowflakeURL("postgresql://user:pass@localhost:5432/db")).toThrow(
-      "Invalid Snowflake URL"
-    );
-  });
-
-  it("accepts empty password (key-pair auth scenario)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:@account123/db");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("");
-    expect(opts.database).toBe("db");
-  });
-
-  it("throws for missing username", () => {
-    expect(() => parseSnowflakeURL("snowflake://:pass@account123/db")).toThrow(
-      "missing username"
-    );
-  });
-
-  it("throws for missing account (unparseable URL)", () => {
-    // snowflake://user:pass@/db is not a valid URL — the URL constructor throws
-    expect(() => parseSnowflakeURL("snowflake://user:pass@/db")).toThrow();
-  });
-});
-
-describe("detectDBType — Snowflake", () => {
-  it("returns 'snowflake' for snowflake:// URLs", () => {
-    expect(detectDBType("snowflake://user:pass@account123/db")).toBe("snowflake");
-  });
-
-  it("still returns 'postgres' for postgresql:// URLs", () => {
-    expect(detectDBType("postgresql://user:pass@localhost:5432/db")).toBe("postgres");
-  });
-
-  it("still returns 'mysql' for mysql:// URLs", () => {
-    expect(detectDBType("mysql://user:pass@localhost:3306/db")).toBe("mysql");
-  });
-
-  it("throws for unsupported URL schemes", () => {
-    expect(() => detectDBType("sqlite:///test.db")).toThrow("Unsupported database URL");
-  });
-});
-
-describe("createSnowflakeDB — defense-in-depth", () => {
-  const ConnectionRegistry = connMod.ConnectionRegistry as typeof import("../connection").ConnectionRegistry;
-
-  beforeEach(() => {
-    executedStatements = [];
-    queryTagShouldFail = false;
-    mockWarn.mockClear();
-  });
-
-  it("logs a startup warning recommending a SELECT-only role", () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-test", { url: "snowflake://user:pass@account123/db" });
-    expect(mockWarn).toHaveBeenCalledWith(
-      expect.stringContaining("no session-level read-only mode"),
-    );
-  });
-
-  it("sets QUERY_TAG before each query", async () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-tag", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-tag");
-    await db.query("SELECT 1");
-
-    expect(executedStatements).toContain("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    // QUERY_TAG should come after timeout and before the actual query
-    const tagIdx = executedStatements.indexOf("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    const queryIdx = executedStatements.indexOf("SELECT 1");
-    expect(tagIdx).toBeLessThan(queryIdx);
-  });
-
-  it("sets statement timeout before QUERY_TAG", async () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-order", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-order");
-    await db.query("SELECT 1", 15000);
-
-    const timeoutIdx = executedStatements.findIndex((s) => s.includes("STATEMENT_TIMEOUT_IN_SECONDS"));
-    const tagIdx = executedStatements.indexOf("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    expect(timeoutIdx).toBeLessThan(tagIdx);
-  });
-
-  it("proceeds with the query when QUERY_TAG fails (best-effort)", async () => {
-    queryTagShouldFail = true;
-    const registry = new ConnectionRegistry();
-    registry.register("sf-tag-fail", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-tag-fail");
-    const result = await db.query("SELECT 42");
-
-    // The actual query should still execute despite QUERY_TAG failure
-    expect(executedStatements).toContain("SELECT 42");
-    expect(result).toEqual({ columns: [], rows: [] });
-
-    // A warning should be logged
-    expect(mockWarn).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to set QUERY_TAG"),
-    );
-  });
-});

package/templates/nextjs-standalone/src/lib/db/duckdb.ts

@@ -1,122 +0,0 @@
-/**
- * DuckDB adapter implementing the DBConnection interface.
- *
- * Uses @duckdb/node-api (the "Neo" API) for in-process analytical queries
- * on CSV, Parquet, and persistent DuckDB database files. DuckDB runs fully
- * in-process — no external server required.
- *
- * Connection URL formats:
- *   - `duckdb://path/to/file.duckdb` — persistent database file
- *   - `duckdb://:memory:` — in-memory database
- *   - `duckdb://` — in-memory (shorthand)
- *
- * Read-only enforcement: the database is opened with `access_mode: 'READ_ONLY'`
- * when the file already exists. For newly-created databases (e.g. during CLI
- * ingestion), the caller is responsible for opening in read-write mode first,
- * then re-opening as read-only for runtime use.
- */
-
-import type { DBConnection, QueryResult } from "./connection";
-import { createLogger } from "@atlas/api/lib/logger";
-
-const log = createLogger("duckdb");
-
-export interface DuckDBConfig {
-  /** Path to the .duckdb file, or ":memory:" for in-memory. */
-  path: string;
-  /** Open in read-only mode (default: true for runtime). */
-  readOnly?: boolean;
-}
-
-/**
- * Parse a duckdb:// URL into a DuckDBConfig.
- *
- * - `duckdb://` or `duckdb://:memory:` → in-memory
- * - `duckdb:///absolute/path.duckdb` → absolute path
- * - `duckdb://relative/path.duckdb` → relative path
- */
-export function parseDuckDBUrl(url: string): DuckDBConfig {
-  if (!url.startsWith("duckdb://")) {
-    throw new Error(`Invalid DuckDB URL: expected duckdb:// scheme, got "${url.slice(0, 20)}..."`);
-  }
-
-  const rest = url.slice("duckdb://".length);
-
-  if (!rest || rest === ":memory:") {
-    return { path: ":memory:" };
-  }
-
-  // duckdb:///absolute/path → /absolute/path
-  // duckdb://relative/path → relative/path
-  return { path: rest };
-}
-
-export function createDuckDBConnection(config: DuckDBConfig): DBConnection {
-  // Lazy-load to avoid requiring @duckdb/node-api when not needed
-  let instancePromise: Promise<{ instance: unknown; connection: unknown }> | null = null;
-
-  async function getConnection() {
-    if (!instancePromise) {
-      instancePromise = (async () => {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { DuckDBInstance } = require("@duckdb/node-api");
-
-        const options: Record<string, string> = {};
-        if (config.readOnly !== false && config.path !== ":memory:") {
-          options.access_mode = "READ_ONLY";
-        }
-
-        const instance = await DuckDBInstance.create(config.path, options);
-        const connection = await instance.connect();
-        return { instance, connection };
-      })();
-      // Allow retry on transient failures — don't cache rejected promises
-      instancePromise.catch(() => { instancePromise = null; });
-    }
-    return instancePromise;
-  }
-
-  return {
-    async query(sql: string, timeoutMs?: number): Promise<QueryResult> {
-      const { connection } = await getConnection();
-
-      const runQuery = async () => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const reader = await (connection as any).runAndReadAll(sql);
-        const columns: string[] = reader.columnNames();
-        const rowObjects: Record<string, unknown>[] = reader.getRowObjects();
-        return { columns, rows: rowObjects };
-      };
-
-      if (timeoutMs && timeoutMs > 0) {
-        const timeout = new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error(
-            `DuckDB query timed out after ${timeoutMs}ms`
-          )), timeoutMs)
-        );
-        return Promise.race([runQuery(), timeout]);
-      }
-
-      return runQuery();
-    },
-
-    async close(): Promise<void> {
-      if (instancePromise) {
-        try {
-          const { connection, instance } = await instancePromise;
-          // DuckDB Neo API uses synchronous cleanup methods
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          (connection as any).disconnectSync();
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          (instance as any).closeSync();
-        } catch (err) {
-          log.warn(
-            { err: err instanceof Error ? err.message : String(err) },
-            "Failed to close DuckDB connection"
-          );
-        }
-        instancePromise = null;
-      }
-    },
-  };
-}

package/templates/nextjs-standalone/src/lib/db/salesforce.ts

@@ -1,342 +0,0 @@
-/**
- * Salesforce DataSource adapter via jsforce.
- *
- * Salesforce uses SOQL, not SQL, so it cannot be a DBConnection (which has
- * `query(sql)`). Instead, it exposes a separate DataSource interface and
- * a separate registry.
- *
- * Connection URL format: salesforce://user:pass@login.salesforce.com?token=TOKEN
- */
-
-import type { QueryResult, ConnectionMetadata } from "@atlas/api/lib/db/connection";
-import { createLogger } from "@atlas/api/lib/logger";
-
-const log = createLogger("salesforce");
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface SObjectInfo {
-  name: string;
-  label: string;
-  queryable: boolean;
-}
-
-export interface SObjectField {
-  name: string;
-  type: string;
-  label: string;
-  picklistValues: { value: string; label: string; active: boolean }[];
-  referenceTo: string[];
-  nillable: boolean;
-  length: number;
-}
-
-export interface SObjectDescribe {
-  name: string;
-  label: string;
-  fields: SObjectField[];
-}
-
-export interface SalesforceConfig {
-  loginUrl: string;
-  username: string;
-  password: string;
-  securityToken?: string;
-  clientId?: string;
-  clientSecret?: string;
-}
-
-export interface SalesforceDataSource {
-  query(soql: string, timeoutMs?: number): Promise<QueryResult>;
-  describe(objectName: string): Promise<SObjectDescribe>;
-  listObjects(): Promise<SObjectInfo[]>;
-  close(): Promise<void>;
-}
-
-// ---------------------------------------------------------------------------
-// URL parser
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a Salesforce connection URL into SalesforceConfig.
- *
- * Format: salesforce://user:pass@login.salesforce.com?token=TOKEN
- *
- * - hostname → loginUrl (default `login.salesforce.com`)
- * - URL username/password → credentials
- * - Query params: `token` (security token), `clientId`, `clientSecret`
- */
-export function parseSalesforceURL(url: string): SalesforceConfig {
-  const parsed = new URL(url);
-  if (parsed.protocol !== "salesforce:") {
-    throw new Error(
-      `Invalid Salesforce URL: expected salesforce:// scheme, got "${parsed.protocol}"`,
-    );
-  }
-
-  const username = decodeURIComponent(parsed.username);
-  if (!username) {
-    throw new Error("Invalid Salesforce URL: missing username.");
-  }
-
-  const password = decodeURIComponent(parsed.password);
-  if (!password) {
-    throw new Error("Invalid Salesforce URL: missing password.");
-  }
-
-  const hostname = parsed.hostname || "login.salesforce.com";
-  const loginUrl = `https://${hostname}`;
-
-  const securityToken = parsed.searchParams.get("token") ?? undefined;
-  const clientId = parsed.searchParams.get("clientId") ?? undefined;
-  const clientSecret = parsed.searchParams.get("clientSecret") ?? undefined;
-
-  return { loginUrl, username, password, securityToken, clientId, clientSecret };
-}
-
-// ---------------------------------------------------------------------------
-// DataSource factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a Salesforce DataSource backed by jsforce.
- */
-export function createSalesforceDataSource(
-  config: SalesforceConfig,
-): SalesforceDataSource {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let jsforce: any;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    jsforce = require("jsforce");
-  } catch {
-    throw new Error(
-      "Salesforce support requires the jsforce package. Install it with: bun add jsforce",
-    );
-  }
-
-  const connOpts: Record<string, unknown> = {
-    loginUrl: config.loginUrl,
-  };
-
-  if (config.clientId && config.clientSecret) {
-    connOpts.oauth2 = {
-      clientId: config.clientId,
-      clientSecret: config.clientSecret,
-      loginUrl: config.loginUrl,
-    };
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const conn = new jsforce.Connection(connOpts) as any;
-
-  let loginPromise: Promise<void> | null = null;
-
-  async function ensureLoggedIn(): Promise<void> {
-    if (loginPromise) return loginPromise;
-    loginPromise = (async () => {
-      const loginPassword = config.securityToken
-        ? config.password + config.securityToken
-        : config.password;
-      try {
-        await conn.login(config.username, loginPassword);
-      } catch (err) {
-        loginPromise = null;
-        log.error(
-          {
-            err: err instanceof Error ? err : new Error(String(err)),
-            loginUrl: config.loginUrl,
-            username: config.username,
-          },
-          "Salesforce login failed",
-        );
-        throw err;
-      }
-      log.info("Salesforce login successful");
-    })();
-    return loginPromise;
-  }
-
-  function isSessionExpiredError(err: unknown): boolean {
-    if (!(err instanceof Error)) return false;
-    const msg = err.message;
-    return (
-      msg.includes("INVALID_SESSION_ID") ||
-      msg.includes("Session expired") ||
-      msg.includes("session has expired")
-    );
-  }
-
-  async function withSessionRetry<T>(fn: () => Promise<T>): Promise<T> {
-    try {
-      return await fn();
-    } catch (err) {
-      if (isSessionExpiredError(err)) {
-        log.warn("Salesforce session expired — re-authenticating and retrying");
-        loginPromise = null;
-        await ensureLoggedIn();
-        return await fn();
-      }
-      throw err;
-    }
-  }
-
-  return {
-    async query(soql: string, timeoutMs = 30000): Promise<QueryResult> {
-      return withSessionRetry(async () => {
-        await ensureLoggedIn();
-
-        let timeoutId: ReturnType<typeof setTimeout>;
-        const result = await Promise.race([
-          conn.query(soql),
-          new Promise<never>((_, reject) => {
-            timeoutId = setTimeout(
-              () => reject(new Error("Salesforce query timed out")),
-              timeoutMs,
-            );
-          }),
-        ]).finally(() => clearTimeout(timeoutId!));
-
-        const records = (result.records ?? []) as Record<string, unknown>[];
-
-        if (records.length === 0) {
-          return { columns: [], rows: [] };
-        }
-
-        // Extract columns from first record, filtering out the `attributes` metadata key
-        const columns = Object.keys(records[0]).filter(
-          (k) => k !== "attributes",
-        );
-
-        const rows = records.map((record) => {
-          const row: Record<string, unknown> = {};
-          for (const col of columns) {
-            row[col] = record[col];
-          }
-          return row;
-        });
-
-        return { columns, rows };
-      });
-    },
-
-    async describe(objectName: string): Promise<SObjectDescribe> {
-      return withSessionRetry(async () => {
-        await ensureLoggedIn();
-        const desc = await conn.describe(objectName);
-        return {
-          name: desc.name,
-          label: desc.label,
-          fields: (desc.fields ?? []).map(
-            (f: Record<string, unknown>) => ({
-              name: f.name as string,
-              type: f.type as string,
-              label: f.label as string,
-              picklistValues: Array.isArray(f.picklistValues)
-                ? f.picklistValues.map(
-                    (pv: Record<string, unknown>) => ({
-                      value: pv.value as string,
-                      label: pv.label as string,
-                      active: pv.active as boolean,
-                    }),
-                  )
-                : [],
-              referenceTo: Array.isArray(f.referenceTo)
-                ? (f.referenceTo as string[])
-                : [],
-              nillable: f.nillable as boolean,
-              length: (f.length as number) ?? 0,
-            }),
-          ),
-        };
-      });
-    },
-
-    async listObjects(): Promise<SObjectInfo[]> {
-      return withSessionRetry(async () => {
-        await ensureLoggedIn();
-        const result = await conn.describeGlobal();
-        return (result.sobjects ?? [])
-          .filter((obj: Record<string, unknown>) => obj.queryable === true)
-          .map((obj: Record<string, unknown>) => ({
-            name: obj.name as string,
-            label: obj.label as string,
-            queryable: true,
-          }));
-      });
-    },
-
-    async close(): Promise<void> {
-      if (loginPromise) {
-        try {
-          await loginPromise;
-          await conn.logout();
-        } catch (err) {
-          log.warn(
-            { err: err instanceof Error ? err.message : String(err) },
-            "Failed to logout from Salesforce",
-          );
-        }
-        loginPromise = null;
-      }
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Source registry (parallel to ConnectionRegistry)
-// ---------------------------------------------------------------------------
-
-const _sources = new Map<string, SalesforceDataSource>();
-
-export function registerSalesforceSource(
-  id: string,
-  config: SalesforceConfig,
-): void {
-  const existing = _sources.get(id);
-  const newSource = createSalesforceDataSource(config);
-  _sources.set(id, newSource);
-  if (existing) {
-    existing.close().catch((err) => {
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err), sourceId: id },
-        "Failed to close previous Salesforce source during re-registration",
-      );
-    });
-  }
-}
-
-export function getSalesforceSource(id: string): SalesforceDataSource {
-  const source = _sources.get(id);
-  if (!source) {
-    throw new Error(`Salesforce source "${id}" is not registered.`);
-  }
-  return source;
-}
-
-export function listSalesforceSources(): string[] {
-  return Array.from(_sources.keys());
-}
-
-/** Return ConnectionMetadata for each registered Salesforce source. */
-export function describeSalesforceSources(): ConnectionMetadata[] {
-  return Array.from(_sources.keys()).map((id) => ({
-    id,
-    dbType: "salesforce" as const,
-  }));
-}
-
-/** Test helper — clears all registered sources. */
-export function _resetSalesforceSources(): void {
-  for (const [id, source] of _sources.entries()) {
-    source.close().catch((err) => {
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err), sourceId: id },
-        "Failed to close Salesforce source during registry reset",
-      );
-    });
-  }
-  _sources.clear();
-}