@useatlas/create 0.0.6 → 0.0.7

package/templates/docker/src/lib/tools/__tests__/registry-actions.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it, afterEach } from "bun:test";
-import { tool } from "ai";
-import { z } from "zod";
-
-const { ToolRegistry } = await import("@atlas/api/lib/tools/registry");
-
-function makeTool(name: string) {
-  return tool({
-    description: `Test tool: ${name}`,
-    inputSchema: z.object({ input: z.string() }),
-    execute: async ({ input }) => input,
-  });
-}
-
-function makeAction(name: string, opts?: { requiredCredentials?: string[] }) {
-  return {
-    name,
-    description: `Action: ${name}`,
-    tool: tool({
-      description: name,
-      inputSchema: z.object({ input: z.string() }),
-      execute: async ({ input }) => input,
-    }),
-    actionType: `test:${name}`,
-    reversible: true,
-    defaultApproval: "manual" as const,
-    requiredCredentials: opts?.requiredCredentials ?? [],
-  };
-}
-
-describe("ToolRegistry — getActions", () => {
-  it("returns empty array when no actions registered", () => {
-    const registry = new ToolRegistry();
-    expect(registry.getActions()).toEqual([]);
-  });
-
-  it("returns only tools that are actions (have actionType field)", () => {
-    const registry = new ToolRegistry();
-    const action1 = makeAction("sendEmail");
-    const action2 = makeAction("createTicket");
-    registry.register(action1);
-    registry.register(action2);
-
-    const actions = registry.getActions();
-    expect(actions).toHaveLength(2);
-    expect(actions[0].name).toBe("sendEmail");
-    expect(actions[1].name).toBe("createTicket");
-  });
-
-  it("doesn't return regular tools (without actionType)", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "explore", description: "Explore", tool: makeTool("explore") });
-    registry.register({ name: "executeSQL", description: "SQL", tool: makeTool("sql") });
-
-    const actions = registry.getActions();
-    expect(actions).toEqual([]);
-  });
-});
-
-describe("ToolRegistry — validateActionCredentials", () => {
-  const origTestApiKey = process.env.TEST_API_KEY;
-  const origTestSecret = process.env.TEST_SECRET;
-  const origMissingKeyA = process.env.MISSING_KEY_A;
-  const origMissingKeyB = process.env.MISSING_KEY_B;
-  const origPresentKey = process.env.PRESENT_KEY;
-
-  afterEach(() => {
-    if (origTestApiKey !== undefined) process.env.TEST_API_KEY = origTestApiKey; else delete process.env.TEST_API_KEY;
-    if (origTestSecret !== undefined) process.env.TEST_SECRET = origTestSecret; else delete process.env.TEST_SECRET;
-    if (origMissingKeyA !== undefined) process.env.MISSING_KEY_A = origMissingKeyA; else delete process.env.MISSING_KEY_A;
-    if (origMissingKeyB !== undefined) process.env.MISSING_KEY_B = origMissingKeyB; else delete process.env.MISSING_KEY_B;
-    if (origPresentKey !== undefined) process.env.PRESENT_KEY = origPresentKey; else delete process.env.PRESENT_KEY;
-  });
-
-  it("returns empty array when no actions", () => {
-    const registry = new ToolRegistry();
-    expect(registry.validateActionCredentials()).toEqual([]);
-  });
-
-  it("returns empty array when all credentials present", () => {
-    process.env.TEST_API_KEY = "key-123";
-    process.env.TEST_SECRET = "secret-456";
-
-    const registry = new ToolRegistry();
-    registry.register(
-      makeAction("myAction", { requiredCredentials: ["TEST_API_KEY", "TEST_SECRET"] }),
-    );
-
-    expect(registry.validateActionCredentials()).toEqual([]);
-  });
-
-  it("returns missing credentials for each action", () => {
-    delete process.env.MISSING_KEY_A;
-    delete process.env.MISSING_KEY_B;
-    process.env.PRESENT_KEY = "exists";
-
-    const registry = new ToolRegistry();
-    registry.register(
-      makeAction("actionA", { requiredCredentials: ["MISSING_KEY_A", "PRESENT_KEY"] }),
-    );
-    registry.register(
-      makeAction("actionB", { requiredCredentials: ["MISSING_KEY_B"] }),
-    );
-
-    const result = registry.validateActionCredentials();
-    expect(result).toHaveLength(2);
-    expect(result[0]).toEqual({ action: "actionA", missing: ["MISSING_KEY_A"] });
-    expect(result[1]).toEqual({ action: "actionB", missing: ["MISSING_KEY_B"] });
-  });
-});
-
-describe("ToolRegistry — actions alongside regular tools", () => {
-  it("actions can be registered alongside regular tools", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "explore", description: "Explore", tool: makeTool("explore") });
-    registry.register(makeAction("sendEmail"));
-    registry.register({ name: "executeSQL", description: "SQL", tool: makeTool("sql") });
-    registry.register(makeAction("createTicket"));
-
-    const all = registry.getAll();
-    expect(Object.keys(all).sort()).toEqual([
-      "createTicket",
-      "executeSQL",
-      "explore",
-      "sendEmail",
-    ]);
-
-    const actions = registry.getActions();
-    expect(actions).toHaveLength(2);
-    expect(actions.map((a) => a.name).sort()).toEqual(["createTicket", "sendEmail"]);
-  });
-});

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

@@ -1,242 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-import { tool } from "ai";
-import { z } from "zod";
-
-// Mock the action tools so buildRegistry({ includeActions: true }) works
-// without needing JIRA/email credentials or external services.
-const mockJiraTool = tool({
-  description: "Mock createJiraTicket tool",
-  inputSchema: z.object({ summary: z.string() }),
-  execute: async ({ summary }) => summary,
-});
-const mockEmailTool = tool({
-  description: "Mock sendEmailReport tool",
-  inputSchema: z.object({ to: z.string() }),
-  execute: async ({ to }) => to,
-});
-
-mock.module("@atlas/api/lib/tools/actions", () => ({
-  createJiraTicket: {
-    name: "createJiraTicket",
-    description: "### Create JIRA Ticket\nMock description",
-    tool: mockJiraTool,
-    actionType: "jira:create",
-    reversible: true,
-    defaultApproval: "manual",
-    requiredCredentials: ["JIRA_BASE_URL", "JIRA_EMAIL", "JIRA_API_TOKEN"],
-  },
-  sendEmailReport: {
-    name: "sendEmailReport",
-    description: "### Send Email Report\nMock description",
-    tool: mockEmailTool,
-    actionType: "email:send",
-    reversible: false,
-    defaultApproval: "admin-only",
-    requiredCredentials: ["RESEND_API_KEY"],
-  },
-}));
-
-const { ToolRegistry, defaultRegistry, buildRegistry } = await import(
-  "@atlas/api/lib/tools/registry"
-);
-
-function makeTool(name: string) {
-  return tool({
-    description: `Test tool: ${name}`,
-    inputSchema: z.object({ input: z.string() }),
-    execute: async ({ input }) => input,
-  });
-}
-
-describe("ToolRegistry", () => {
-  it("register + get — stores and retrieves a tool", () => {
-    const registry = new ToolRegistry();
-    const entry = { name: "foo", description: "Foo desc", tool: makeTool("foo") };
-    registry.register(entry);
-    expect(registry.get("foo")).toBe(entry);
-  });
-
-  it("get returns undefined for unknown name", () => {
-    const registry = new ToolRegistry();
-    expect(registry.get("nonexistent")).toBeUndefined();
-  });
-
-  it("getAll returns a ToolSet with all registered tools", () => {
-    const registry = new ToolRegistry();
-    const fooTool = makeTool("foo");
-    const barTool = makeTool("bar");
-    registry.register({ name: "foo", description: "Foo", tool: fooTool });
-    registry.register({ name: "bar", description: "Bar", tool: barTool });
-
-    const all = registry.getAll();
-    expect(Object.keys(all).sort()).toEqual(["bar", "foo"]);
-    expect(all.foo).toBe(fooTool);
-    expect(all.bar).toBe(barTool);
-  });
-
-  it("describe concatenates descriptions with \\n\\n separator", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "a", description: "Desc A", tool: makeTool("a") });
-    registry.register({ name: "b", description: "Desc B", tool: makeTool("b") });
-    expect(registry.describe()).toBe("Desc A\n\nDesc B");
-  });
-
-  it("describe returns empty string for empty registry", () => {
-    const registry = new ToolRegistry();
-    expect(registry.describe()).toBe("");
-  });
-
-  it("duplicate registration overwrites the previous entry", () => {
-    const registry = new ToolRegistry();
-    const tool1 = makeTool("v1");
-    const tool2 = makeTool("v2");
-    registry.register({ name: "x", description: "First", tool: tool1 });
-    registry.register({ name: "x", description: "Second", tool: tool2 });
-
-    expect(registry.get("x")!.description).toBe("Second");
-    expect(registry.get("x")!.tool).toBe(tool2);
-    expect(Object.keys(registry.getAll())).toEqual(["x"]);
-  });
-
-  it("describe() preserves registration order", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "a", description: "Desc A", tool: makeTool("a") });
-    registry.register({ name: "b", description: "Desc B", tool: makeTool("b") });
-    registry.register({ name: "c", description: "Desc C", tool: makeTool("c") });
-    expect(registry.describe()).toBe("Desc A\n\nDesc B\n\nDesc C");
-  });
-
-  it("getAll() returns a fresh object", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "a", description: "A", tool: makeTool("a") });
-    registry.register({ name: "b", description: "B", tool: makeTool("b") });
-
-    const first = registry.getAll();
-    delete first.a;
-
-    const second = registry.getAll();
-    expect(second.a).toBeDefined();
-  });
-
-  it("register() throws on empty name", () => {
-    const registry = new ToolRegistry();
-    expect(() =>
-      registry.register({ name: "", description: "X", tool: makeTool("x") })
-    ).toThrow();
-  });
-
-  it("register() throws on empty description", () => {
-    const registry = new ToolRegistry();
-    expect(() =>
-      registry.register({ name: "x", description: "", tool: makeTool("x") })
-    ).toThrow();
-  });
-
-  it("register() throws on frozen registry", () => {
-    const registry = new ToolRegistry();
-    registry.register({ name: "a", description: "A", tool: makeTool("a") });
-    registry.freeze();
-    expect(() =>
-      registry.register({ name: "b", description: "B", tool: makeTool("b") })
-    ).toThrow();
-  });
-});
-
-describe("defaultRegistry", () => {
-  it("contains all 2 core tools", () => {
-    expect(defaultRegistry.get("explore")).toBeDefined();
-    expect(defaultRegistry.get("executeSQL")).toBeDefined();
-  });
-
-  it("getAll returns exactly the 2 core tools", () => {
-    const all = defaultRegistry.getAll();
-    expect(Object.keys(all).sort()).toEqual(["executeSQL", "explore"]);
-  });
-
-  it("describe produces the expected workflow text", () => {
-    const text = defaultRegistry.describe();
-    expect(text).toContain("### 2. Explore the Semantic Layer");
-    expect(text).toContain("### 3. Write and Execute SQL");
-  });
-
-  it("is frozen — cannot register additional tools", () => {
-    expect(() =>
-      defaultRegistry.register({ name: "rogue", description: "X", tool: makeTool("x") })
-    ).toThrow("Cannot register tools on a frozen registry");
-  });
-});
-
-describe("buildRegistry", () => {
-  it("throws when ATLAS_PYTHON_ENABLED=true but ATLAS_SANDBOX_URL is not set", async () => {
-    const saved = {
-      enabled: process.env.ATLAS_PYTHON_ENABLED,
-      url: process.env.ATLAS_SANDBOX_URL,
-    };
-    try {
-      process.env.ATLAS_PYTHON_ENABLED = "true";
-      delete process.env.ATLAS_SANDBOX_URL;
-      await expect(buildRegistry()).rejects.toThrow("ATLAS_SANDBOX_URL");
-    } finally {
-      if (saved.enabled !== undefined) process.env.ATLAS_PYTHON_ENABLED = saved.enabled;
-      else delete process.env.ATLAS_PYTHON_ENABLED;
-      if (saved.url !== undefined) process.env.ATLAS_SANDBOX_URL = saved.url;
-      else delete process.env.ATLAS_SANDBOX_URL;
-    }
-  });
-
-  it("includes executePython when ATLAS_PYTHON_ENABLED and ATLAS_SANDBOX_URL are set", async () => {
-    const saved = {
-      enabled: process.env.ATLAS_PYTHON_ENABLED,
-      url: process.env.ATLAS_SANDBOX_URL,
-    };
-    try {
-      process.env.ATLAS_PYTHON_ENABLED = "true";
-      process.env.ATLAS_SANDBOX_URL = "http://localhost:8080";
-      const registry = await buildRegistry();
-      const names = Object.keys(registry.getAll()).sort();
-      expect(names).toEqual(["executePython", "executeSQL", "explore"]);
-      expect(registry.describe()).toContain("### 4. Analyze Data with Python");
-    } finally {
-      if (saved.enabled !== undefined) process.env.ATLAS_PYTHON_ENABLED = saved.enabled;
-      else delete process.env.ATLAS_PYTHON_ENABLED;
-      if (saved.url !== undefined) process.env.ATLAS_SANDBOX_URL = saved.url;
-      else delete process.env.ATLAS_SANDBOX_URL;
-    }
-  });
-
-  it("returns 2 core tools by default", async () => {
-    const registry = await buildRegistry();
-    const names = Object.keys(registry.getAll()).sort();
-    expect(names).toEqual(["executeSQL", "explore"]);
-  });
-
-  it("with includeActions returns 4 tools including createJiraTicket and sendEmailReport", async () => {
-    const registry = await buildRegistry({ includeActions: true });
-    const names = Object.keys(registry.getAll()).sort();
-    expect(names).toEqual([
-      "createJiraTicket",
-      "executeSQL",
-      "explore",
-      "sendEmailReport",
-    ]);
-  });
-
-  it("returned registry is frozen", async () => {
-    const registry = await buildRegistry();
-    expect(() =>
-      registry.register({ name: "extra", description: "X", tool: makeTool("x") })
-    ).toThrow("Cannot register tools on a frozen registry");
-  });
-
-  it("getActions returns action tools with correct metadata", async () => {
-    const registry = await buildRegistry({ includeActions: true });
-    const actions = registry.getActions();
-    const actionTypes = actions.map((a) => a.actionType).sort();
-    expect(actionTypes).toEqual(["email:send", "jira:create"]);
-  });
-
-  it("core-only registry has no actions", async () => {
-    const registry = await buildRegistry();
-    expect(registry.getActions()).toEqual([]);
-  });
-});

package/templates/docker/src/lib/tools/__tests__/sql-audit.test.ts

@@ -1,227 +0,0 @@
-/**
- * Integration tests: executeSQL → logQueryAudit → internal DB.
- *
- * Tests the full audit path without mocking @/lib/auth/audit or @/lib/logger.
- * Instead, uses _resetPool() to inject a mock pg.Pool that captures INSERT
- * queries from internalExecute. This avoids bun mock.module leaking across
- * test files.
- */
-
-import { describe, expect, it, beforeEach, afterEach, mock, type Mock } from "bun:test";
-import { _resetPool, type InternalPool } from "@atlas/api/lib/db/internal";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyResult = any;
-
-// --- Mocks for sql.ts dependencies (NOT audit or logger) ---
-
-mock.module("@atlas/api/lib/semantic", () => ({
-  getWhitelistedTables: () => new Set(["companies", "people"]),
-  _resetWhitelists: () => {},
-}));
-
-let queryFn: Mock<(sql: string, timeout: number) => Promise<{ columns: string[]; rows: Record<string, unknown>[] }>>;
-
-const mockConn = {
-  query: (...args: [string, number]) => queryFn(...args),
-  close: async () => {},
-};
-
-mock.module("@atlas/api/lib/db/connection", () => ({
-  getDB: () => mockConn,
-  connections: {
-    get: () => mockConn,
-    getDefault: () => mockConn,
-    getDBType: () => "postgres",
-    getTargetHost: () => "localhost",
-    getValidator: () => undefined,
-    getParserDialect: () => undefined,
-    getForbiddenPatterns: () => [],
-    list: () => ["default"],
-  },
-  detectDBType: () => "postgres",
-}));
-
-mock.module("@atlas/api/lib/tracing", () => ({
-  withSpan: async (
-    _name: string,
-    _attrs: Record<string, unknown>,
-    fn: () => Promise<unknown>,
-  ) => fn(),
-}));
-
-mock.module("@atlas/api/lib/db/source-rate-limit", () => ({
-  acquireSourceSlot: () => ({ acquired: true }),
-  decrementSourceConcurrency: () => {},
-}));
-
-// Import after mocks
-const { executeSQL } = await import("@atlas/api/lib/tools/sql");
-
-// --- Internal DB mock pool to capture audit inserts ---
-
-let auditInserts: Array<{ sql: string; params?: unknown[] }> = [];
-
-const mockPool: InternalPool = {
-  query: async (sql: string, params?: unknown[]) => {
-    auditInserts.push({ sql, params });
-    return { rows: [] };
-  },
-  end: async () => {},
-  on: () => {},
-};
-
-/**
- * Audit INSERT parameters are positional ($1-$8).
- * This helper extracts named fields from the params array so tests
- * are not coupled to column ordering.
- */
-function extractAuditParams(params: unknown[]) {
-  return {
-    userId: params[0],
-    userLabel: params[1],
-    authMode: params[2],
-    sql: params[3] as string,
-    durationMs: params[4] as number,
-    rowCount: params[5] as number | null,
-    success: params[6] as boolean,
-    error: params[7] as string | null,
-    sourceId: params[8] as string | null,
-    sourceType: params[9] as string | null,
-    targetHost: params[10] as string | null,
-  };
-}
-
-describe("executeSQL audit logging", () => {
-  const origDbUrl = process.env.DATABASE_URL;
-  const origDatasource = process.env.ATLAS_DATASOURCE_URL;
-
-  beforeEach(() => {
-    auditInserts = [];
-    process.env.ATLAS_DATASOURCE_URL = "postgresql://test:test@localhost:5432/test";
-    // Enable internal DB so audit inserts are captured
-    process.env.DATABASE_URL = "postgresql://test:test@localhost:5432/atlas";
-    _resetPool(mockPool);
-    queryFn = mock(() =>
-      Promise.resolve({
-        columns: ["id", "name"],
-        rows: [{ id: 1, name: "Acme" }],
-      }),
-    );
-  });
-
-  afterEach(() => {
-    if (origDbUrl) {
-      process.env.DATABASE_URL = origDbUrl;
-    } else {
-      delete process.env.DATABASE_URL;
-    }
-    if (origDatasource) {
-      process.env.ATLAS_DATASOURCE_URL = origDatasource;
-    } else {
-      delete process.env.ATLAS_DATASOURCE_URL;
-    }
-    _resetPool(null);
-  });
-
-  const exec = (sql: string) =>
-    executeSQL.execute!(
-      { sql, explanation: "test" },
-      { toolCallId: "test", messages: [], abortSignal: undefined as never },
-    ) as Promise<AnyResult>;
-
-  /** Find audit INSERT queries from the mock pool */
-  const getAuditInserts = () =>
-    auditInserts.filter((q) => q.sql.includes("INSERT INTO audit_log"));
-
-  it("logs audit with success: true on successful query", async () => {
-    const result = await exec("SELECT id, name FROM companies");
-
-    expect(result.success).toBe(true);
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.success).toBe(true);
-    expect(audit.sql).toContain("SELECT id, name FROM companies");
-    expect(audit.rowCount).toBe(1);
-  });
-
-  it("logs audit with success: false on query execution failure", async () => {
-    queryFn = mock(() => Promise.reject(new Error("column \"nope\" does not exist")));
-
-    const result = await exec("SELECT nope FROM companies");
-
-    expect(result.success).toBe(false);
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.success).toBe(false);
-    expect(audit.error).toContain("column \"nope\" does not exist");
-    expect(audit.rowCount).toBeNull();
-  });
-
-  it("logs audit with 'Validation rejected:' prefix on validation failure", async () => {
-    const result = await exec("DROP TABLE companies");
-
-    expect(result.success).toBe(false);
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.success).toBe(false);
-    expect((audit.error as string).startsWith("Validation rejected:")).toBe(true);
-    expect(audit.durationMs).toBe(0);
-    expect(audit.rowCount).toBeNull();
-  });
-
-  it("logs audit for non-whitelisted table access attempt", async () => {
-    const result = await exec("SELECT * FROM unknown_table");
-
-    expect(result.success).toBe(false);
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.success).toBe(false);
-    expect(audit.error).toContain("Validation rejected:");
-    expect(audit.error).toContain("not in the allowed list");
-  });
-
-  it("truncates SQL to 2000 chars in validation-rejected audit entries", async () => {
-    const longSql = "DROP TABLE " + "x".repeat(3000);
-    await exec(longSql);
-
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.sql.length).toBeLessThanOrEqual(2000);
-  });
-
-  it("auto-appends LIMIT to the SQL logged on success", async () => {
-    await exec("SELECT id FROM companies");
-
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.sql).toContain("LIMIT");
-  });
-
-  it("includes sourceId and targetHost in audit entries on success", async () => {
-    await exec("SELECT id FROM companies");
-
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.sourceId).toBe("default");
-    expect(audit.sourceType).toBe("postgres");
-    expect(audit.targetHost).toBe("localhost");
-  });
-
-  it("includes sourceId in validation-rejected audit entries", async () => {
-    await exec("DROP TABLE companies");
-
-    const inserts = getAuditInserts();
-    expect(inserts).toHaveLength(1);
-    const audit = extractAuditParams(inserts[0].params!);
-    expect(audit.sourceId).toBe("default");
-    expect(audit.sourceType).toBe("postgres");
-  });
-});