@useatlas/create 0.0.2 → 0.0.3

package/templates/nextjs-standalone/src/lib/plugins/__tests__/migrate.test.ts

@@ -1,6 +1,8 @@
 import { describe, test, expect } from "bun:test";
 import {
   generateMigrationSQL,
+  generateColumnMigrations,
+  runPluginMigrations,
   applyMigrations,
   ensureMigrationsTable,
   getAppliedMigrations,
@@ -22,11 +24,14 @@ interface QueryLog {
 function makeMockDB(opts?: {
   existingMigrations?: Array<{ plugin_id: string; table_name: string; sql_hash: string }>;
   existingTables?: string[];
+  /** Map of table name → existing column names (for information_schema.columns queries) */
+  existingColumns?: Record<string, string[]>;
   failOnCreate?: boolean;
 }): MigrateDB & { queries: QueryLog[] } {
   const queries: QueryLog[] = [];
-  const existingMigrations = opts?.existingMigrations ?? [];
+  const existingMigrations = [...(opts?.existingMigrations ?? [])];
   const existingTables = opts?.existingTables ?? [];
+  const existingColumns = opts?.existingColumns ?? {};
 
   return {
     queries,
@@ -39,9 +44,23 @@ function makeMockDB(opts?: {
       if (sql.includes("FROM plugin_migrations")) {
         return { rows: existingMigrations };
       }
+      // Track migrations inserted via applyMigrations
+      if (sql.includes("INSERT INTO plugin_migrations") && params) {
+        existingMigrations.push({
+          plugin_id: String(params[0]),
+          table_name: String(params[1]),
+          sql_hash: String(params[2]),
+        });
+        return { rows: [] };
+      }
       if (sql.includes("FROM pg_tables")) {
         return { rows: existingTables.map((t) => ({ tablename: t })) };
       }
+      if (sql.includes("information_schema.columns") && params?.[0]) {
+        const tableName = String(params[0]);
+        const cols = existingColumns[tableName] ?? [];
+        return { rows: cols.map((c) => ({ column_name: c })) };
+      }
       return { rows: [] };
     },
   };
@@ -519,3 +538,338 @@ describe("diffSchema", () => {
     expect(diff.existingTables).toHaveLength(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// generateColumnMigrations
+// ---------------------------------------------------------------------------
+
+describe("generateColumnMigrations", () => {
+  test("generates ALTER TABLE for missing columns", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "name", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            name: { type: "string", required: true },
+            priority: { type: "number" },
+            active: { type: "boolean" },
+          },
+        },
+      }),
+    ];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+
+    // name already exists, priority and active are new
+    expect(stmts).toHaveLength(2);
+    expect(stmts[0].sql).toContain('ALTER TABLE "plugin_test_items"');
+    expect(stmts[0].sql).toContain('"priority" INTEGER');
+    expect(stmts[1].sql).toContain('"active" BOOLEAN');
+  });
+
+  test("skips tables that don't exist yet", async () => {
+    const db = makeMockDB({
+      existingColumns: {},  // no tables in DB
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: { fields: { name: { type: "string" } } },
+      }),
+    ];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    expect(stmts).toHaveLength(0);
+  });
+
+  test("returns empty when all columns already exist", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "name", "count", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            name: { type: "string" },
+            count: { type: "number" },
+          },
+        },
+      }),
+    ];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    expect(stmts).toHaveLength(0);
+  });
+
+  test("handles case-insensitive column matching", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "MyColumn", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            mycolumn: { type: "string" },
+          },
+        },
+      }),
+    ];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    // MyColumn matches mycolumn (case-insensitive)
+    expect(stmts).toHaveLength(0);
+  });
+
+  test("skips plugins without schema", async () => {
+    const db = makeMockDB();
+    const plugins = [{ id: "no-schema" }];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    expect(stmts).toHaveLength(0);
+  });
+
+  test("generates columns with constraints", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            email: { type: "string", required: true, unique: true },
+            priority: { type: "number", defaultValue: 0 },
+          },
+        },
+      }),
+    ];
+
+    const stmts = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    expect(stmts).toHaveLength(2);
+    expect(stmts[0].sql).toContain('"email" TEXT NOT NULL UNIQUE');
+    expect(stmts[1].sql).toContain('"priority" INTEGER DEFAULT 0');
+  });
+
+  test("generates deterministic hashes for ALTER statements", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: { fields: { name: { type: "string" } } },
+      }),
+    ];
+
+    const stmts1 = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    const stmts2 = await generateColumnMigrations(
+      db,
+      plugins as Parameters<typeof generateColumnMigrations>[1],
+    );
+    expect(stmts1[0].hash).toBe(stmts2[0].hash);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPluginMigrations
+// ---------------------------------------------------------------------------
+
+describe("runPluginMigrations", () => {
+  test("runs CREATE TABLE and ALTER TABLE in sequence", async () => {
+    const db = makeMockDB({
+      // Simulate a table that was just created with only auto-columns —
+      // Phase 2 detects the missing user-declared column
+      existingColumns: {
+        plugin_test_items: ["id", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            name: { type: "string" },
+          },
+        },
+      }),
+    ];
+
+    const result = await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+
+    // Phase 1: CREATE TABLE (1 table) + Phase 2: ALTER TABLE ADD COLUMN (1 column)
+    expect(result.applied).toEqual(["plugin_test_items", "plugin_test_items"]);
+    // Should have both CREATE TABLE and ALTER TABLE queries
+    const createQuery = db.queries.find((q) =>
+      q.sql.includes("CREATE TABLE") && q.sql.includes("plugin_test_items"),
+    );
+    expect(createQuery).toBeDefined();
+    const alterQuery = db.queries.find((q) =>
+      q.sql.includes("ALTER TABLE") && q.sql.includes('"name"'),
+    );
+    expect(alterQuery).toBeDefined();
+  });
+
+  test("merges results from both phases correctly", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_a_items: ["id", "x", "created_at", "updated_at"],
+        // plugin_b_things doesn't exist — no columns, Phase 2 skips it
+      },
+    });
+    const plugins = [
+      makePlugin("a", { items: { fields: { x: { type: "string" }, y: { type: "number" } } } }),
+      makePlugin("b", { things: { fields: { z: { type: "boolean" } } } }),
+    ];
+
+    const result = await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+
+    // Phase 1: 2 CREATE TABLE statements applied
+    // Phase 2: 1 ALTER TABLE for plugin_a_items.y (x already exists, plugin_b skipped)
+    expect(result.applied).toEqual([
+      "plugin_a_items", "plugin_b_things", "plugin_a_items",
+    ]);
+  });
+
+  test("handles plugins with no schema", async () => {
+    const db = makeMockDB();
+    const plugins = [{ id: "no-schema" }];
+
+    const result = await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+    expect(result.applied).toEqual([]);
+    expect(result.skipped).toEqual([]);
+  });
+
+  test("skips column migrations when no new columns needed", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "name", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: {
+            name: { type: "string" },
+          },
+        },
+      }),
+    ];
+
+    await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+
+    // ALTER TABLE should not appear (no new columns)
+    const alterQuery = db.queries.find((q) => q.sql.includes("ALTER TABLE"));
+    expect(alterQuery).toBeUndefined();
+  });
+
+  test("propagates Phase 1 errors and skips Phase 2", async () => {
+    const db = makeMockDB({ failOnCreate: true });
+    const plugins = [
+      makePlugin("test", {
+        items: { fields: { name: { type: "string" } } },
+      }),
+    ];
+
+    await expect(
+      runPluginMigrations(db, plugins as Parameters<typeof runPluginMigrations>[1]),
+    ).rejects.toThrow(/permission denied/);
+
+    // No ALTER TABLE queries should have been attempted
+    const alterQuery = db.queries.find((q) => q.sql.includes("ALTER TABLE"));
+    expect(alterQuery).toBeUndefined();
+  });
+
+  test("idempotent when run twice", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "name", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: {
+          fields: { name: { type: "string" } },
+        },
+      }),
+    ];
+
+    const result1 = await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+    const result2 = await runPluginMigrations(
+      db,
+      plugins as Parameters<typeof runPluginMigrations>[1],
+    );
+
+    // First run applies CREATE TABLE
+    expect(result1.applied).toEqual(["plugin_test_items"]);
+    // Second run skips it (already tracked in plugin_migrations)
+    expect(result2.applied).toEqual([]);
+    expect(result2.skipped).toEqual(["plugin_test_items"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// generateColumnMigrations — error context
+// ---------------------------------------------------------------------------
+
+describe("generateColumnMigrations error context", () => {
+  test("wraps fieldToSQL errors with plugin and table context", async () => {
+    const db = makeMockDB({
+      existingColumns: {
+        plugin_test_items: ["id", "created_at", "updated_at"],
+      },
+    });
+    const plugins = [
+      makePlugin("test", {
+        items: { fields: { "bad name!": { type: "string" } } },
+      }),
+    ];
+
+    await expect(
+      generateColumnMigrations(db, plugins as Parameters<typeof generateColumnMigrations>[1]),
+    ).rejects.toThrow(/Plugin "test", table "plugin_test_items"/);
+  });
+});

package/templates/nextjs-standalone/src/lib/plugins/__tests__/registry.test.ts

@@ -13,7 +13,7 @@ const minimalCtx: PluginContextLike = {
 function makePlugin(overrides: Partial<PluginLike> = {}): PluginLike {
   return {
     id: "test-plugin",
-    type: "datasource",
+    types: ["datasource"],
     version: "1.0.0",
     ...overrides,
   };
@@ -282,12 +282,12 @@ describe("PluginRegistry", () => {
 
   describe("getByType", () => {
     test("filters by type and health status", async () => {
-      registry.register(makePlugin({ id: "ds1", type: "datasource" }));
-      registry.register(makePlugin({ id: "ctx1", type: "context" }));
+      registry.register(makePlugin({ id: "ds1", types: ["datasource"] }));
+      registry.register(makePlugin({ id: "ctx1", types: ["context"] }));
       registry.register(
         makePlugin({
           id: "ds2",
-          type: "datasource",
+          types: ["datasource"],
           initialize: async () => {
             throw new Error("fail");
           },
@@ -300,13 +300,40 @@ describe("PluginRegistry", () => {
     });
 
     test("returns empty array when no plugins of type", async () => {
-      registry.register(makePlugin({ id: "ds1", type: "datasource" }));
+      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", () => {