@useatlas/create 0.0.5 → 0.0.7

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

@@ -1,373 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from "bun:test";
-import { PluginRegistry } from "../registry";
-import type { PluginLike, PluginContextLike } from "../registry";
-
-const minimalCtx: PluginContextLike = {
-  db: null,
-  connections: { get: () => ({}), list: () => [] },
-  tools: { register: () => {} },
-  logger: {},
-  config: {},
-};
-
-function makePlugin(overrides: Partial<PluginLike> = {}): PluginLike {
-  return {
-    id: "test-plugin",
-    types: ["datasource"],
-    version: "1.0.0",
-    ...overrides,
-  };
-}
-
-describe("PluginRegistry", () => {
-  let registry: PluginRegistry;
-
-  beforeEach(() => {
-    registry = new PluginRegistry();
-  });
-
-  // --- register ---
-
-  describe("register", () => {
-    test("stores plugin", () => {
-      const plugin = makePlugin();
-      registry.register(plugin);
-      expect(registry.get("test-plugin")).toBe(plugin);
-      expect(registry.size).toBe(1);
-    });
-
-    test("throws on empty id", () => {
-      expect(() => registry.register(makePlugin({ id: "" }))).toThrow("must not be empty");
-      expect(() => registry.register(makePlugin({ id: "  " }))).toThrow("must not be empty");
-    });
-
-    test("throws on duplicate id", () => {
-      registry.register(makePlugin({ id: "a" }));
-      expect(() => registry.register(makePlugin({ id: "a" }))).toThrow("already registered");
-    });
-  });
-
-  // --- initializeAll ---
-
-  describe("initializeAll", () => {
-    test("marks healthy on success", async () => {
-      const init = mock(() => Promise.resolve());
-      registry.register(makePlugin({ initialize: init }));
-
-      const result = await registry.initializeAll(minimalCtx);
-
-      expect(result.succeeded).toEqual(["test-plugin"]);
-      expect(result.failed).toEqual([]);
-      expect(registry.getStatus("test-plugin")).toBe("healthy");
-      expect(init).toHaveBeenCalledTimes(1);
-    });
-
-    test("marks healthy with no init method", async () => {
-      registry.register(makePlugin());
-
-      const result = await registry.initializeAll(minimalCtx);
-
-      expect(result.succeeded).toEqual(["test-plugin"]);
-      expect(registry.getStatus("test-plugin")).toBe("healthy");
-    });
-
-    test("passes context to initialize", async () => {
-      let receivedCtx: PluginContextLike | undefined;
-      registry.register(
-        makePlugin({
-          initialize: async (ctx: PluginContextLike) => {
-            receivedCtx = ctx;
-          },
-        }),
-      );
-
-      const fakeCtx: PluginContextLike = {
-        db: null,
-        connections: { get: () => ({}), list: () => [] },
-        tools: { register: () => {} },
-        logger: {},
-        config: { test: true },
-      };
-
-      await registry.initializeAll(fakeCtx);
-
-      expect(receivedCtx).toBeDefined();
-      expect((receivedCtx as PluginContextLike).config).toEqual({ test: true });
-    });
-
-    test("marks unhealthy on failure without crashing", async () => {
-      registry.register(
-        makePlugin({
-          id: "good",
-          initialize: async () => {},
-        }),
-      );
-      registry.register(
-        makePlugin({
-          id: "bad",
-          initialize: async () => {
-            throw new Error("init boom");
-          },
-        }),
-      );
-
-      const result = await registry.initializeAll(minimalCtx);
-
-      expect(result.succeeded).toEqual(["good"]);
-      expect(result.failed).toEqual(["bad"]);
-      expect(registry.getStatus("good")).toBe("healthy");
-      expect(registry.getStatus("bad")).toBe("unhealthy");
-    });
-
-    test("creates scoped child logger when ctx.logger has child()", async () => {
-      let receivedLogger: unknown;
-      registry.register(
-        makePlugin({
-          initialize: async (ctx: PluginContextLike) => {
-            receivedLogger = ctx.logger;
-          },
-        }),
-      );
-
-      const childLogger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} };
-      const parentLogger = {
-        child: mock(() => childLogger),
-      };
-
-      await registry.initializeAll({
-        ...minimalCtx,
-        logger: parentLogger as unknown as Record<string, unknown>,
-      });
-
-      expect(parentLogger.child).toHaveBeenCalledWith({ pluginId: "test-plugin" });
-      expect(receivedLogger).toBe(childLogger);
-    });
-
-    test("throws on double initialization", async () => {
-      registry.register(makePlugin());
-      await registry.initializeAll(minimalCtx);
-
-      expect(() => registry.initializeAll(minimalCtx)).toThrow("already initialized");
-    });
-  });
-
-  // --- healthCheckAll ---
-
-  describe("healthCheckAll", () => {
-    test("returns results", async () => {
-      registry.register(
-        makePlugin({
-          healthCheck: async () => ({ healthy: true, latencyMs: 5 }),
-        }),
-      );
-      await registry.initializeAll(minimalCtx);
-
-      const results = await registry.healthCheckAll();
-      const entry = results.get("test-plugin");
-      expect(entry?.healthy).toBe(true);
-      expect(entry?.latencyMs).toBe(5);
-    });
-
-    test("handles plugins without healthCheck", async () => {
-      registry.register(makePlugin());
-      await registry.initializeAll(minimalCtx);
-
-      const results = await registry.healthCheckAll();
-      const entry = results.get("test-plugin");
-      expect(entry?.healthy).toBe(true);
-      expect(entry?.status).toBe("healthy");
-    });
-
-    test("catches health check exceptions", async () => {
-      registry.register(
-        makePlugin({
-          healthCheck: async () => {
-            throw new Error("probe failed");
-          },
-        }),
-      );
-      await registry.initializeAll(minimalCtx);
-
-      const results = await registry.healthCheckAll();
-      const entry = results.get("test-plugin");
-      expect(entry?.healthy).toBe(false);
-      expect(entry?.message).toBe("probe failed");
-    });
-
-    test("updates status to unhealthy when probe returns false", async () => {
-      registry.register(
-        makePlugin({
-          healthCheck: async () => ({ healthy: false, message: "degraded" }),
-        }),
-      );
-      await registry.initializeAll(minimalCtx);
-      expect(registry.getStatus("test-plugin")).toBe("healthy");
-
-      const results = await registry.healthCheckAll();
-      const entry = results.get("test-plugin");
-      expect(entry?.healthy).toBe(false);
-      expect(entry?.status).toBe("unhealthy");
-      expect(registry.getStatus("test-plugin")).toBe("unhealthy");
-    });
-
-    test("updates status to unhealthy when probe throws", async () => {
-      registry.register(
-        makePlugin({
-          healthCheck: async () => {
-            throw new Error("probe failed");
-          },
-        }),
-      );
-      await registry.initializeAll(minimalCtx);
-
-      await registry.healthCheckAll();
-      expect(registry.getStatus("test-plugin")).toBe("unhealthy");
-    });
-  });
-
-  // --- teardownAll ---
-
-  describe("teardownAll", () => {
-    test("calls in reverse order", async () => {
-      const order: string[] = [];
-      registry.register(
-        makePlugin({
-          id: "first",
-          teardown: async () => { order.push("first"); },
-        }),
-      );
-      registry.register(
-        makePlugin({
-          id: "second",
-          teardown: async () => { order.push("second"); },
-        }),
-      );
-
-      await registry.teardownAll();
-
-      expect(order).toEqual(["second", "first"]);
-    });
-
-    test("continues on failure", async () => {
-      const order: string[] = [];
-      registry.register(
-        makePlugin({
-          id: "first",
-          teardown: async () => { order.push("first"); },
-        }),
-      );
-      registry.register(
-        makePlugin({
-          id: "failing",
-          teardown: async () => {
-            throw new Error("teardown boom");
-          },
-        }),
-      );
-      registry.register(
-        makePlugin({
-          id: "third",
-          teardown: async () => { order.push("third"); },
-        }),
-      );
-
-      await registry.teardownAll();
-
-      // "failing" threw but "first" still ran
-      expect(order).toEqual(["third", "first"]);
-    });
-  });
-
-  // --- getByType ---
-
-  describe("getByType", () => {
-    test("filters by type and health status", async () => {
-      registry.register(makePlugin({ id: "ds1", types: ["datasource"] }));
-      registry.register(makePlugin({ id: "ctx1", types: ["context"] }));
-      registry.register(
-        makePlugin({
-          id: "ds2",
-          types: ["datasource"],
-          initialize: async () => {
-            throw new Error("fail");
-          },
-        }),
-      );
-      await registry.initializeAll(minimalCtx);
-
-      const healthy = registry.getByType("datasource");
-      expect(healthy.map((p) => p.id)).toEqual(["ds1"]);
-    });
-
-    test("returns empty array when no plugins of type", async () => {
-      registry.register(makePlugin({ id: "ds1", types: ["datasource"] }));
-      await registry.initializeAll(minimalCtx);
-
-      expect(registry.getByType("action")).toEqual([]);
-    });
-  });
-
-  // --- getAll ---
-
-  describe("getAll", () => {
-    test("returns all plugins regardless of status", async () => {
-      registry.register(makePlugin({ id: "healthy1", types: ["datasource"] }));
-      registry.register(makePlugin({
-        id: "unhealthy1",
-        types: ["context"],
-        initialize: async () => { throw new Error("fail"); },
-      }));
-      registry.register(makePlugin({ id: "healthy2", types: ["action"] }));
-      await registry.initializeAll(minimalCtx);
-
-      const all = registry.getAll();
-      expect(all.map((p) => p.id)).toEqual(["healthy1", "unhealthy1", "healthy2"]);
-      expect(all).toHaveLength(3);
-    });
-
-    test("returns plugins in registration order", () => {
-      registry.register(makePlugin({ id: "c" }));
-      registry.register(makePlugin({ id: "a" }));
-      registry.register(makePlugin({ id: "b" }));
-
-      expect(registry.getAll().map((p) => p.id)).toEqual(["c", "a", "b"]);
-    });
-  });
-
-  // --- getStatus ---
-
-  describe("getStatus", () => {
-    test("returns undefined for unknown id", () => {
-      expect(registry.getStatus("nonexistent")).toBeUndefined();
-    });
-  });
-
-  // --- describe ---
-
-  describe("describe", () => {
-    test("returns metadata with name fallback to id", () => {
-      registry.register(makePlugin({ id: "with-name", name: "My Plugin" }));
-      registry.register(makePlugin({ id: "no-name" }));
-
-      const descriptions = registry.describe();
-      expect(descriptions).toHaveLength(2);
-      expect(descriptions[0].name).toBe("My Plugin");
-      expect(descriptions[1].name).toBe("no-name");
-    });
-  });
-
-  // --- _reset ---
-
-  describe("_reset", () => {
-    test("clears all entries", () => {
-      registry.register(makePlugin({ id: "a" }));
-      registry.register(makePlugin({ id: "b" }));
-      expect(registry.size).toBe(2);
-
-      registry._reset();
-
-      expect(registry.size).toBe(0);
-      expect(registry.get("a")).toBeUndefined();
-    });
-  });
-});

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

@@ -1,49 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { setDialectHints, getDialectHints, setContextFragments, getContextFragments } from "../tools";
-import type { DialectHint } from "../wiring";
-
-describe("setDialectHints / getDialectHints", () => {
-  beforeEach(() => {
-    setDialectHints([]);
-  });
-
-  test("defaults to empty array", () => {
-    expect(getDialectHints()).toEqual([]);
-  });
-
-  test("round-trips DialectHint[]", () => {
-    const hints: DialectHint[] = [
-      { pluginId: "bq", dialect: "Use SAFE_DIVIDE for BigQuery." },
-      { pluginId: "redshift", dialect: "Use GETDATE() instead of NOW()." },
-    ];
-    setDialectHints(hints);
-    expect(getDialectHints()).toEqual(hints);
-  });
-
-  test("overwrites previous hints", () => {
-    setDialectHints([{ pluginId: "a", dialect: "first" }]);
-    setDialectHints([{ pluginId: "b", dialect: "second" }]);
-    expect(getDialectHints()).toEqual([{ pluginId: "b", dialect: "second" }]);
-  });
-
-  test("set empty clears hints", () => {
-    setDialectHints([{ pluginId: "a", dialect: "hint" }]);
-    setDialectHints([]);
-    expect(getDialectHints()).toEqual([]);
-  });
-});
-
-describe("setContextFragments / getContextFragments", () => {
-  beforeEach(() => {
-    setContextFragments([]);
-  });
-
-  test("defaults to empty array", () => {
-    expect(getContextFragments()).toEqual([]);
-  });
-
-  test("round-trips fragments", () => {
-    setContextFragments(["frag1", "frag2"]);
-    expect(getContextFragments()).toEqual(["frag1", "frag2"]);
-  });
-});