@useatlas/create 0.0.2 → 0.0.4

package/templates/docker/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/docker/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();
-}

package/templates/docker/src/lib/tools/__tests__/salesforce-tool.test.ts

@@ -1,154 +0,0 @@
-/**
- * Tests for the querySalesforce agent tool.
- */
-import { describe, it, expect, beforeEach, mock } from "bun:test";
-
-// Mock Salesforce registry
-const mockQuery = mock(() =>
-  Promise.resolve({
-    columns: ["Id", "Name"],
-    rows: [
-      { Id: "001", Name: "Acme" },
-      { Id: "002", Name: "Widget Co" },
-    ],
-  }),
-);
-
-const mockSources = new Map<string, { query: typeof mockQuery; close: () => Promise<void> }>();
-
-mock.module("@atlas/api/lib/db/salesforce", () => ({
-  getSalesforceSource: (id: string) => {
-    const source = mockSources.get(id);
-    if (!source) throw new Error(`Salesforce source "${id}" is not registered.`);
-    return source;
-  },
-  listSalesforceSources: () => Array.from(mockSources.keys()),
-}));
-
-// Mock semantic layer
-mock.module("@atlas/api/lib/semantic", () => ({
-  getWhitelistedTables: () => new Set(["account", "contact", "opportunity"]),
-  _resetWhitelists: () => {},
-}));
-
-// Mock audit log (no-op)
-mock.module("@atlas/api/lib/auth/audit", () => ({
-  logQueryAudit: () => {},
-}));
-
-const { querySalesforce } = await import("@atlas/api/lib/tools/salesforce");
-
-// Helper to call the tool's execute function
-async function executeTool(params: {
-  soql: string;
-  explanation: string;
-  connectionId?: string;
-}) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (querySalesforce as any).execute(params);
-}
-
-describe("querySalesforce tool", () => {
-  beforeEach(() => {
-    mockQuery.mockClear();
-    mockQuery.mockImplementation(() =>
-      Promise.resolve({
-        columns: ["Id", "Name"],
-        rows: [
-          { Id: "001", Name: "Acme" },
-          { Id: "002", Name: "Widget Co" },
-        ],
-      }),
-    );
-    mockSources.clear();
-    mockSources.set("default", {
-      query: mockQuery,
-      close: async () => {},
-    });
-  });
-
-  it("executes a valid query and returns results", async () => {
-    const result = await executeTool({
-      soql: "SELECT Id, Name FROM Account",
-      explanation: "Get all accounts",
-    });
-    expect(result.success).toBe(true);
-    expect(result.columns).toEqual(["Id", "Name"]);
-    expect(result.rows).toHaveLength(2);
-    expect(result.row_count).toBe(2);
-  });
-
-  it("rejects invalid SOQL (mutation)", async () => {
-    const result = await executeTool({
-      soql: "DELETE FROM Account",
-      explanation: "Delete accounts",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Forbidden");
-  });
-
-  it("rejects queries against non-whitelisted objects", async () => {
-    const result = await executeTool({
-      soql: "SELECT Id FROM CustomObject__c",
-      explanation: "Get custom objects",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("not in the allowed list");
-  });
-
-  it("returns error for unregistered connection", async () => {
-    const result = await executeTool({
-      soql: "SELECT Id FROM Account",
-      explanation: "test",
-      connectionId: "nonexistent",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("not registered");
-  });
-
-  it("appends LIMIT when not present", async () => {
-    await executeTool({
-      soql: "SELECT Id FROM Account",
-      explanation: "test",
-    });
-    // The mockQuery should have been called with a SOQL that includes LIMIT
-    const calledWith = (mockQuery.mock.calls as unknown as string[][])[0][0];
-    expect(calledWith).toContain("LIMIT");
-  });
-
-  it("does not double-append LIMIT", async () => {
-    await executeTool({
-      soql: "SELECT Id FROM Account LIMIT 5",
-      explanation: "test",
-    });
-    const calledWith = (mockQuery.mock.calls as unknown as string[][])[0][0];
-    // Should not have two LIMIT clauses
-    const limitCount = (calledWith.match(/LIMIT/gi) ?? []).length;
-    expect(limitCount).toBe(1);
-  });
-
-  it("scrubs sensitive error messages", async () => {
-    mockQuery.mockImplementationOnce(() =>
-      Promise.reject(new Error("INVALID_SESSION_ID: Session expired")),
-    );
-    const result = await executeTool({
-      soql: "SELECT Id FROM Account",
-      explanation: "test",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("check server logs");
-    expect(result.error).not.toContain("INVALID_SESSION_ID");
-  });
-
-  it("surfaces non-sensitive errors to the agent", async () => {
-    mockQuery.mockImplementationOnce(() =>
-      Promise.reject(new Error("INVALID_FIELD: No such column 'Foo'")),
-    );
-    const result = await executeTool({
-      soql: "SELECT Foo FROM Account",
-      explanation: "test",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("INVALID_FIELD");
-  });
-});