@tsctl/cli 0.2.0

package/src/apply/index.ts

@@ -0,0 +1,336 @@
+import chalk from "chalk";
+import ora from "ora";
+import { loadState, saveState, formatResourceId } from "../state/index.js";
+import {
+  createCollection,
+  updateCollection,
+  deleteCollection,
+  getCollection,
+} from "../resources/collection.js";
+import { upsertAlias, deleteAlias } from "../resources/alias.js";
+import { upsertSynonym, deleteSynonym } from "../resources/synonym.js";
+import {
+  createSynonymSet,
+  updateSynonymSet,
+  deleteSynonymSet,
+  getSynonymSet,
+} from "../resources/synonymset.js";
+import { upsertOverride, deleteOverride } from "../resources/override.js";
+import {
+  createCurationSet,
+  updateCurationSet,
+  deleteCurationSet,
+  getCurationSet,
+} from "../resources/curationset.js";
+import {
+  createAnalyticsRule,
+  updateAnalyticsRule,
+  deleteAnalyticsRule,
+} from "../resources/analyticsrule.js";
+import {
+  createApiKey,
+  deleteApiKeyByDescription,
+  getApiKey,
+} from "../resources/apikey.js";
+import {
+  upsertStopwordSet,
+  deleteStopwordSet,
+} from "../resources/stopword.js";
+import {
+  upsertPreset,
+  deletePreset,
+} from "../resources/preset.js";
+import {
+  upsertStemmingDictionary,
+} from "../resources/stemmingdictionary.js";
+import { buildNewState } from "../plan/index.js";
+import type {
+  Plan,
+  ResourceChange,
+  TypesenseConfig,
+  CollectionConfig,
+  AliasConfig,
+  SynonymConfig,
+  SynonymSetConfig,
+  OverrideConfig,
+  CurationSetConfig,
+  AnalyticsRuleConfig,
+  ApiKeyConfig,
+  StopwordSetConfig,
+  PresetConfig,
+  StemmingDictionaryConfig,
+} from "../types/index.js";
+
+export interface ApplyResult {
+  success: boolean;
+  applied: ResourceChange[];
+  failed: Array<{ change: ResourceChange; error: Error }>;
+}
+
+/**
+ * Apply a single resource change
+ */
+async function applyChange(change: ResourceChange): Promise<void> {
+  const { action, identifier } = change;
+
+  switch (identifier.type) {
+    case "collection": {
+      if (action === "create") {
+        await createCollection(change.after as CollectionConfig);
+      } else if (action === "update") {
+        const existing = await getCollection(identifier.name);
+        if (!existing) {
+          throw new Error(`Collection ${identifier.name} not found for update`);
+        }
+        // Update handles field modifications by dropping and re-adding
+        await updateCollection(change.after as CollectionConfig, existing);
+      } else if (action === "delete") {
+        await deleteCollection(identifier.name);
+      }
+      break;
+    }
+
+    case "alias": {
+      if (action === "create" || action === "update") {
+        await upsertAlias(change.after as AliasConfig);
+      } else if (action === "delete") {
+        await deleteAlias(identifier.name);
+      }
+      break;
+    }
+
+    case "synonym": {
+      if (action === "create" || action === "update") {
+        await upsertSynonym(change.after as SynonymConfig);
+      } else if (action === "delete") {
+        await deleteSynonym(identifier.name, identifier.collection!);
+      }
+      break;
+    }
+
+    case "synonymSet": {
+      if (action === "create") {
+        await createSynonymSet(change.after as SynonymSetConfig);
+      } else if (action === "update") {
+        const existing = await getSynonymSet(identifier.name);
+        if (existing) {
+          await updateSynonymSet(change.after as SynonymSetConfig, existing);
+        }
+      } else if (action === "delete") {
+        await deleteSynonymSet(identifier.name);
+      }
+      break;
+    }
+
+    case "override": {
+      if (action === "create" || action === "update") {
+        await upsertOverride(change.after as OverrideConfig);
+      } else if (action === "delete") {
+        await deleteOverride(identifier.name, identifier.collection!);
+      }
+      break;
+    }
+
+    case "analyticsRule": {
+      if (action === "create") {
+        await createAnalyticsRule(change.after as AnalyticsRuleConfig);
+      } else if (action === "update") {
+        await updateAnalyticsRule(change.after as AnalyticsRuleConfig);
+      } else if (action === "delete") {
+        await deleteAnalyticsRule(identifier.name);
+      }
+      break;
+    }
+
+    case "apiKey": {
+      if (action === "create") {
+        const apiKeyConfig = change.after as ApiKeyConfig;
+        const result = await createApiKey(apiKeyConfig);
+        console.log(
+          chalk.cyan(
+            `\n   API Key created! Save this value (shown only once):\n   ${result.value}\n`
+          )
+        );
+      } else if (action === "update") {
+        // API keys can't be updated, so delete and recreate
+        const existing = await getApiKey(identifier.name);
+        if (existing) {
+          await deleteApiKeyByDescription(identifier.name);
+        }
+        const apiKeyConfig = change.after as ApiKeyConfig;
+        const result = await createApiKey(apiKeyConfig);
+        console.log(
+          chalk.cyan(
+            `\n   API Key recreated! Save this value (shown only once):\n   ${result.value}\n`
+          )
+        );
+      } else if (action === "delete") {
+        await deleteApiKeyByDescription(identifier.name);
+      }
+      break;
+    }
+
+    case "curationSet": {
+      if (action === "create") {
+        await createCurationSet(change.after as CurationSetConfig);
+      } else if (action === "update") {
+        const existing = await getCurationSet(identifier.name);
+        if (existing) {
+          await updateCurationSet(change.after as CurationSetConfig, existing);
+        }
+      } else if (action === "delete") {
+        await deleteCurationSet(identifier.name);
+      }
+      break;
+    }
+
+    case "stopword": {
+      if (action === "create" || action === "update") {
+        await upsertStopwordSet(change.after as StopwordSetConfig);
+      } else if (action === "delete") {
+        await deleteStopwordSet(identifier.name);
+      }
+      break;
+    }
+
+    case "preset": {
+      if (action === "create" || action === "update") {
+        await upsertPreset(change.after as PresetConfig);
+      } else if (action === "delete") {
+        await deletePreset(identifier.name);
+      }
+      break;
+    }
+
+    case "stemmingDictionary": {
+      if (action === "create" || action === "update") {
+        await upsertStemmingDictionary(change.after as StemmingDictionaryConfig);
+      }
+      // Note: Typesense does not support deleting stemming dictionaries via API
+      break;
+    }
+
+    default:
+      throw new Error(`Unknown resource type: ${identifier.type}`);
+  }
+}
+
+/**
+ * Apply a plan to Typesense
+ */
+export async function applyPlan(
+  plan: Plan,
+  config: TypesenseConfig,
+  options: {
+    autoApprove?: boolean;
+    forceRecreate?: boolean;
+  } = {}
+): Promise<ApplyResult> {
+  const result: ApplyResult = {
+    success: true,
+    applied: [],
+    failed: [],
+  };
+
+  // Filter to only changes that need to be applied
+  const changesToApply = plan.changes.filter((c) => c.action !== "no-change");
+
+  if (changesToApply.length === 0) {
+    console.log(chalk.green("\nNo changes to apply."));
+    return result;
+  }
+
+  // Resource type priority for ordering (lower = first)
+  // SynonymSets must be created before collections that reference them
+  const createOrder: Record<string, number> = {
+    stemmingDictionary: 0,
+    synonymSet: 1,
+    curationSet: 2,
+    stopword: 3,
+    preset: 4,
+    collection: 5,
+    alias: 6,
+    synonym: 7,
+    override: 8,
+    analyticsRule: 9,
+    apiKey: 10,
+  };
+  // For deletes, reverse the order
+  const deleteOrder: Record<string, number> = {
+    apiKey: 0,
+    analyticsRule: 1,
+    override: 2,
+    synonym: 3,
+    alias: 4,
+    collection: 5,
+    preset: 6,
+    stopword: 7,
+    curationSet: 8,
+    synonymSet: 9,
+    stemmingDictionary: 10,
+  };
+
+  const sortByType = (a: ResourceChange, b: ResourceChange, order: Record<string, number>) => {
+    return (order[a.identifier.type] ?? 99) - (order[b.identifier.type] ?? 99);
+  };
+
+  // Apply changes in order: creates first (with dependency order), then updates, then deletes
+  const creates = changesToApply
+    .filter((c) => c.action === "create")
+    .sort((a, b) => sortByType(a, b, createOrder));
+  const updates = changesToApply
+    .filter((c) => c.action === "update")
+    .sort((a, b) => sortByType(a, b, createOrder));
+  const deletes = changesToApply
+    .filter((c) => c.action === "delete")
+    .sort((a, b) => sortByType(a, b, deleteOrder));
+
+  const orderedChanges = [...creates, ...updates, ...deletes];
+
+  console.log(chalk.bold(`\nApplying ${orderedChanges.length} changes...\n`));
+
+  for (const change of orderedChanges) {
+    const resourceId = formatResourceId(change.identifier);
+    const actionSymbol =
+      change.action === "create"
+        ? chalk.green("+")
+        : change.action === "update"
+          ? chalk.yellow("~")
+          : chalk.red("-");
+
+    const spinner = ora(`${actionSymbol} ${resourceId}`).start();
+
+    try {
+      await applyChange(change);
+      spinner.succeed(`${actionSymbol} ${resourceId}`);
+      result.applied.push(change);
+    } catch (error) {
+      spinner.fail(`${actionSymbol} ${resourceId}`);
+      console.error(
+        chalk.red(`   Error: ${error instanceof Error ? error.message : String(error)}`)
+      );
+      result.failed.push({
+        change,
+        error: error instanceof Error ? error : new Error(String(error)),
+      });
+      result.success = false;
+    }
+  }
+
+  // Update state if any changes were applied
+  if (result.applied.length > 0) {
+    const currentState = await loadState();
+    const newState = buildNewState(currentState, config);
+    await saveState(newState);
+    console.log(chalk.gray("\nState saved."));
+  }
+
+  // Print summary
+  console.log(chalk.bold("\nApply complete:"));
+  console.log(`  ${chalk.green(`${result.applied.length} applied`)}`);
+  if (result.failed.length > 0) {
+    console.log(`  ${chalk.red(`${result.failed.length} failed`)}`);
+  }
+
+  return result;
+}