@tsctl/cli 0.2.0

package/src/__tests__/config-loader.test.ts

@@ -0,0 +1,217 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
+import { resolve } from "path";
+import { loadConfig, findConfigFile } from "../config/loader.js";
+
+const TEST_DIR = resolve("/tmp/tsctl-config-test");
+
+describe("config loader", () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe("JSON config", () => {
+    test("loads tsctl.config.json", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.json");
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          collections: [
+            {
+              name: "products",
+              fields: [{ name: "title", type: "string" }],
+            },
+          ],
+        })
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.collections).toHaveLength(1);
+      expect(config.collections![0]!.name).toBe("products");
+    });
+
+    test("loads .tsctlrc.json", async () => {
+      const configPath = resolve(TEST_DIR, ".tsctlrc.json");
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          aliases: [{ name: "test", collection: "products" }],
+        })
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.aliases).toHaveLength(1);
+    });
+  });
+
+  describe("YAML config", () => {
+    test("loads tsctl.config.yaml", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.yaml");
+      writeFileSync(
+        configPath,
+        `collections:
+  - name: products
+    fields:
+      - name: title
+        type: string
+      - name: price
+        type: float
+`
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.collections).toHaveLength(1);
+      expect(config.collections![0]!.fields).toHaveLength(2);
+    });
+
+    test("loads tsctl.config.yml", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.yml");
+      writeFileSync(
+        configPath,
+        `aliases:
+  - name: products_live
+    collection: products
+`
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.aliases).toHaveLength(1);
+    });
+  });
+
+  describe("TypeScript config", () => {
+    test("loads tsctl.config.ts", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.ts");
+      writeFileSync(
+        configPath,
+        `export default {
+  collections: [
+    {
+      name: "products",
+      fields: [{ name: "title", type: "string" }],
+    },
+  ],
+};
+`
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.collections).toHaveLength(1);
+    });
+  });
+
+  describe("validation", () => {
+    test("validates field types", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.json");
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          collections: [
+            {
+              name: "bad",
+              fields: [{ name: "x", type: "invalid_type" }],
+            },
+          ],
+        })
+      );
+
+      expect(loadConfig(configPath)).rejects.toThrow();
+    });
+
+    test("validates collection requires fields", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.json");
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          collections: [{ name: "bad" }],
+        })
+      );
+
+      expect(loadConfig(configPath)).rejects.toThrow();
+    });
+
+    test("accepts empty config", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.json");
+      writeFileSync(configPath, "{}");
+
+      const config = await loadConfig(configPath);
+      expect(config.collections).toBeUndefined();
+    });
+
+    test("validates full config with all resource types", async () => {
+      const configPath = resolve(TEST_DIR, "tsctl.config.json");
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          collections: [
+            { name: "products", fields: [{ name: "title", type: "string" }] },
+          ],
+          aliases: [{ name: "products_live", collection: "products" }],
+          stopwords: [{ id: "english", stopwords: ["the", "a"] }],
+          presets: [{ name: "default", value: { q: "*" } }],
+          apiKeys: [
+            { description: "key1", actions: ["documents:search"], collections: ["*"] },
+          ],
+          curationSets: [
+            {
+              name: "curations",
+              items: [
+                { id: "rule1", rule: { query: "test", match: "exact" }, filter_by: "x:=1" },
+              ],
+            },
+          ],
+          stemmingDictionaries: [
+            { id: "dict1", words: [{ word: "dogs", root: "dog" }] },
+          ],
+        })
+      );
+
+      const config = await loadConfig(configPath);
+      expect(config.collections).toHaveLength(1);
+      expect(config.stopwords).toHaveLength(1);
+      expect(config.presets).toHaveLength(1);
+      expect(config.curationSets).toHaveLength(1);
+      expect(config.stemmingDictionaries).toHaveLength(1);
+    });
+  });
+
+  describe("findConfigFile", () => {
+    test("finds tsctl.config.json in directory", async () => {
+      writeFileSync(
+        resolve(TEST_DIR, "tsctl.config.json"),
+        JSON.stringify({ collections: [] })
+      );
+
+      const found = await findConfigFile(TEST_DIR);
+      expect(found).not.toBeNull();
+      expect(found!).toContain("tsctl.config.json");
+    });
+
+    test("returns null when no config exists", async () => {
+      const emptyDir = resolve(TEST_DIR, "empty");
+      mkdirSync(emptyDir, { recursive: true });
+      // findConfigFile searches up to root, so it might find the repo's config
+      // Just test it doesn't throw
+      const found = await findConfigFile(emptyDir);
+      // May or may not find a config in parent dirs
+      expect(typeof found === "string" || found === null).toBe(true);
+    });
+  });
+
+  describe("error handling", () => {
+    test("throws on non-existent file", async () => {
+      expect(
+        loadConfig(resolve(TEST_DIR, "nonexistent.json"))
+      ).rejects.toThrow();
+    });
+  });
+});

package/src/__tests__/curationsets.test.ts

@@ -0,0 +1,190 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { setupClient, cleanupTypesense } from "./setup.js";
+import { getTypesenseVersion } from "./helpers.js";
+import {
+  createCurationSet,
+  getCurationSet,
+  listCurationSets,
+  updateCurationSet,
+  deleteCurationSet,
+  curationSetConfigsEqual,
+} from "../resources/curationset.js";
+import type { CurationSetConfig } from "../types/index.js";
+
+describe("curation sets (v30+)", () => {
+  let version: number;
+
+  beforeEach(async () => {
+    setupClient();
+    await cleanupTypesense();
+    version = await getTypesenseVersion();
+  });
+
+  afterEach(async () => {
+    await cleanupTypesense();
+  });
+
+  test("createCurationSet creates a curation set", async () => {
+    if (version < 30) return; // Skip on pre-v30
+
+    const config: CurationSetConfig = {
+      name: "product-curations",
+      items: [
+        {
+          id: "pin-featured",
+          rule: { query: "featured", match: "exact" },
+          includes: [{ id: "product-123", position: 1 }],
+        },
+      ],
+    };
+
+    await createCurationSet(config);
+    const result = await getCurationSet("product-curations");
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe("product-curations");
+    expect(result!.items).toHaveLength(1);
+    expect(result!.items[0]!.id).toBe("pin-featured");
+  });
+
+  test("getCurationSet returns null for non-existent", async () => {
+    if (version < 30) return;
+
+    const result = await getCurationSet("nonexistent");
+    expect(result).toBeNull();
+  });
+
+  test("createCurationSet with filter_by rule", async () => {
+    if (version < 30) return;
+
+    const config: CurationSetConfig = {
+      name: "category-boost",
+      items: [
+        {
+          id: "boost-shoes",
+          rule: { query: "shoes", match: "contains" },
+          filter_by: "category:=footwear",
+          sort_by: "popularity:desc",
+        },
+      ],
+    };
+
+    await createCurationSet(config);
+    const result = await getCurationSet("category-boost");
+    expect(result).not.toBeNull();
+    expect(result!.items[0]!.filter_by).toBe("category:=footwear");
+  });
+
+  test("listCurationSets returns all curation sets", async () => {
+    if (version < 30) return;
+
+    await createCurationSet({
+      name: "set1",
+      items: [
+        {
+          id: "rule1",
+          rule: { query: "a", match: "exact" },
+          filter_by: "x:=1",
+        },
+      ],
+    });
+    await createCurationSet({
+      name: "set2",
+      items: [
+        {
+          id: "rule2",
+          rule: { query: "b", match: "exact" },
+          filter_by: "y:=2",
+        },
+      ],
+    });
+
+    const sets = await listCurationSets();
+    const names = sets.map((s) => s.name);
+    expect(names).toContain("set1");
+    expect(names).toContain("set2");
+  });
+
+  test("updateCurationSet modifies items", async () => {
+    if (version < 30) return;
+
+    const initial: CurationSetConfig = {
+      name: "my-curations",
+      items: [
+        {
+          id: "rule1",
+          rule: { query: "a", match: "exact" },
+          filter_by: "x:=1",
+        },
+      ],
+    };
+    await createCurationSet(initial);
+
+    const updated: CurationSetConfig = {
+      name: "my-curations",
+      items: [
+        {
+          id: "rule1",
+          rule: { query: "a", match: "exact" },
+          filter_by: "x:=1",
+        },
+        {
+          id: "rule2",
+          rule: { query: "b", match: "contains" },
+          filter_by: "y:=2",
+        },
+      ],
+    };
+    await updateCurationSet(updated, initial);
+
+    const result = await getCurationSet("my-curations");
+    expect(result!.items).toHaveLength(2);
+  });
+
+  test("deleteCurationSet removes set", async () => {
+    if (version < 30) return;
+
+    await createCurationSet({
+      name: "to-delete",
+      items: [
+        {
+          id: "rule1",
+          rule: { query: "x", match: "exact" },
+          filter_by: "a:=1",
+        },
+      ],
+    });
+    await deleteCurationSet("to-delete");
+    const result = await getCurationSet("to-delete");
+    expect(result).toBeNull();
+  });
+
+  test("curationSetConfigsEqual compares correctly", () => {
+    const a: CurationSetConfig = {
+      name: "test",
+      items: [
+        { id: "a", rule: { query: "x", match: "exact" } },
+        { id: "b", rule: { query: "y", match: "contains" } },
+      ],
+    };
+    const b: CurationSetConfig = {
+      name: "test",
+      items: [
+        { id: "b", rule: { query: "y", match: "contains" } },
+        { id: "a", rule: { query: "x", match: "exact" } },
+      ],
+    };
+    expect(curationSetConfigsEqual(a, b)).toBe(true);
+  });
+
+  test("curationSetConfigsEqual detects differences", () => {
+    const a: CurationSetConfig = {
+      name: "test",
+      items: [{ id: "a", rule: { query: "x", match: "exact" } }],
+    };
+    const b: CurationSetConfig = {
+      name: "test",
+      items: [{ id: "a", rule: { query: "y", match: "exact" } }],
+    };
+    expect(curationSetConfigsEqual(a, b)).toBe(false);
+  });
+});

package/src/__tests__/helpers.ts

@@ -0,0 +1,17 @@
+import { getClient } from "../client/index.js";
+
+/**
+ * Get the Typesense server version as a number (e.g., 27 or 30)
+ */
+export async function getTypesenseVersion(): Promise<number> {
+  const client = getClient();
+  try {
+    const debug = await client.debug.retrieve();
+    const version = (debug as any).version as string;
+    // Version string is like "30.0" or "27.1"
+    return parseInt(version.split(".")[0]!, 10);
+  } catch {
+    // Fallback: try health endpoint or default to 27
+    return 27;
+  }
+}

package/src/__tests__/import-drift.test.ts

@@ -0,0 +1,231 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { setupClient, cleanupTypesense } from "./setup.js";
+import { getTypesenseVersion } from "./helpers.js";
+import { importResources, detectDrift, buildPlan } from "../plan/index.js";
+import { applyPlan } from "../apply/index.js";
+import { loadState, saveState } from "../state/index.js";
+import { createCollection, deleteCollection } from "../resources/collection.js";
+import { upsertAlias, deleteAlias } from "../resources/alias.js";
+import { upsertStopwordSet, deleteStopwordSet } from "../resources/stopword.js";
+import { upsertPreset } from "../resources/preset.js";
+import { createApiKey } from "../resources/apikey.js";
+import type { TypesenseConfig, State } from "../types/index.js";
+
+describe("import", () => {
+  beforeEach(async () => {
+    setupClient();
+    await cleanupTypesense();
+  });
+
+  afterEach(async () => {
+    await cleanupTypesense();
+  });
+
+  test("imports collections and aliases", async () => {
+    await createCollection({
+      name: "products",
+      fields: [{ name: "title", type: "string" }],
+    });
+    await createCollection({
+      name: "users",
+      fields: [{ name: "name", type: "string" }],
+    });
+    await upsertAlias({ name: "products_live", collection: "products" });
+
+    const result = await importResources();
+
+    expect(result.collections.length).toBeGreaterThanOrEqual(2);
+    const collectionNames = result.collections.map((c) => c.name);
+    expect(collectionNames).toContain("products");
+    expect(collectionNames).toContain("users");
+
+    expect(result.aliases).toHaveLength(1);
+    expect(result.aliases[0]!.name).toBe("products_live");
+  });
+
+  test("imports stopwords", async () => {
+    await upsertStopwordSet({ id: "english", stopwords: ["the", "a", "an"] });
+
+    const result = await importResources();
+
+    expect(result.stopwords.length).toBeGreaterThanOrEqual(1);
+    const ids = result.stopwords.map((s) => s.id);
+    expect(ids).toContain("english");
+  });
+
+  test("imports presets", async () => {
+    await upsertPreset({ name: "listing", value: { q: "*" } });
+
+    const result = await importResources();
+
+    expect(result.presets.length).toBeGreaterThanOrEqual(1);
+    const names = result.presets.map((p) => p.name);
+    expect(names).toContain("listing");
+  });
+
+  test("imports API keys", async () => {
+    await createApiKey({
+      description: "Test search key",
+      actions: ["documents:search"],
+      collections: ["*"],
+    });
+
+    const result = await importResources();
+
+    const descriptions = result.apiKeys.map((k) => k.description);
+    expect(descriptions).toContain("Test search key");
+  });
+
+  test("imports empty state when no resources exist", async () => {
+    const result = await importResources();
+    expect(result.collections).toHaveLength(0);
+    expect(result.aliases).toHaveLength(0);
+    expect(result.stopwords).toHaveLength(0);
+    expect(result.presets).toHaveLength(0);
+  });
+});
+
+describe("drift detection", () => {
+  beforeEach(async () => {
+    setupClient();
+    await cleanupTypesense();
+  });
+
+  afterEach(async () => {
+    await cleanupTypesense();
+  });
+
+  test("reports no drift when state matches", async () => {
+    const config: TypesenseConfig = {
+      collections: [
+        { name: "products", fields: [{ name: "title", type: "string" }] },
+      ],
+    };
+    const plan = await buildPlan(config);
+    await applyPlan(plan, config);
+
+    const report = await detectDrift();
+    // May have no drift or just unmanaged resources
+    const managedDrift = report.items.filter(
+      (i) => i.type === "modified" || i.type === "deleted"
+    );
+    expect(managedDrift).toHaveLength(0);
+  });
+
+  test("detects deleted collection", async () => {
+    // Apply config
+    const config: TypesenseConfig = {
+      collections: [
+        { name: "products", fields: [{ name: "title", type: "string" }] },
+      ],
+    };
+    const plan = await buildPlan(config);
+    await applyPlan(plan, config);
+
+    // Delete outside tsctl
+    await deleteCollection("products");
+
+    const report = await detectDrift();
+    const deleted = report.items.filter((i) => i.type === "deleted");
+    expect(deleted.length).toBeGreaterThanOrEqual(1);
+    const deletedNames = deleted.map((i) => i.identifier.name);
+    expect(deletedNames).toContain("products");
+  });
+
+  test("detects unmanaged collection", async () => {
+    // Create collection outside tsctl (empty state)
+    await createCollection({
+      name: "unmanaged",
+      fields: [{ name: "title", type: "string" }],
+    });
+
+    const report = await detectDrift();
+    const unmanaged = report.items.filter((i) => i.type === "unmanaged");
+    const unmanagedNames = unmanaged.map((i) => i.identifier.name);
+    expect(unmanagedNames).toContain("unmanaged");
+  });
+
+  test("detects unmanaged alias", async () => {
+    await createCollection({
+      name: "products",
+      fields: [{ name: "title", type: "string" }],
+    });
+    await upsertAlias({ name: "unmanaged_alias", collection: "products" });
+
+    const report = await detectDrift();
+    const unmanaged = report.items.filter(
+      (i) => i.type === "unmanaged" && i.identifier.type === "alias"
+    );
+    expect(unmanaged.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("detects unmanaged stopword set", async () => {
+    await upsertStopwordSet({ id: "unmanaged-sw", stopwords: ["the"] });
+
+    const report = await detectDrift();
+    const unmanaged = report.items.filter(
+      (i) => i.type === "unmanaged" && i.identifier.type === "stopword"
+    );
+    const names = unmanaged.map((i) => i.identifier.name);
+    expect(names).toContain("unmanaged-sw");
+  });
+
+  test("detects unmanaged preset", async () => {
+    await upsertPreset({ name: "unmanaged-preset", value: { q: "*" } });
+
+    const report = await detectDrift();
+    const unmanaged = report.items.filter(
+      (i) => i.type === "unmanaged" && i.identifier.type === "preset"
+    );
+    const names = unmanaged.map((i) => i.identifier.name);
+    expect(names).toContain("unmanaged-preset");
+  });
+
+  test("detects deleted stopword set", async () => {
+    // Apply config with stopword
+    const config: TypesenseConfig = {
+      stopwords: [{ id: "english", stopwords: ["the", "a"] }],
+    };
+    const plan = await buildPlan(config);
+    await applyPlan(plan, config);
+
+    // Delete outside tsctl
+    await deleteStopwordSet("english");
+
+    const report = await detectDrift();
+    const deleted = report.items.filter(
+      (i) => i.type === "deleted" && i.identifier.type === "stopword"
+    );
+    expect(deleted.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("hasDrift is false when no drift exists", async () => {
+    // Empty state, no resources
+    const report = await detectDrift();
+    expect(report.hasDrift).toBe(false);
+  });
+
+  test("hasDrift is true when drift exists", async () => {
+    await createCollection({
+      name: "unmanaged",
+      fields: [{ name: "x", type: "string" }],
+    });
+
+    const report = await detectDrift();
+    expect(report.hasDrift).toBe(true);
+  });
+
+  test("summary counts are correct", async () => {
+    // Create unmanaged resources
+    await createCollection({
+      name: "unmanaged1",
+      fields: [{ name: "x", type: "string" }],
+    });
+    await upsertStopwordSet({ id: "unmanaged-sw", stopwords: ["the"] });
+
+    const report = await detectDrift();
+    expect(report.summary.unmanaged).toBeGreaterThanOrEqual(2);
+    expect(report.summary.deleted).toBe(0);
+    expect(report.summary.modified).toBe(0);
+  });
+});