@tsctl/cli 0.2.0

package/src/resources/alias.ts

@@ -0,0 +1,59 @@
+import { getClient } from "../client/index.js";
+import type { AliasConfig } from "../types/index.js";
+
+/**
+ * Get an alias from Typesense
+ */
+export async function getAlias(name: string): Promise<AliasConfig | null> {
+  const client = getClient();
+
+  try {
+    const alias = await client.aliases(name).retrieve();
+    return {
+      name: alias.name,
+      collection: alias.collection_name,
+    };
+  } catch (error: unknown) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "httpStatus" in error &&
+      error.httpStatus === 404
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * List all aliases from Typesense
+ */
+export async function listAliases(): Promise<AliasConfig[]> {
+  const client = getClient();
+  const response = await client.aliases().retrieve();
+
+  return response.aliases.map((alias: { name: string; collection_name: string }) => ({
+    name: alias.name,
+    collection: alias.collection_name,
+  }));
+}
+
+/**
+ * Create or update an alias in Typesense
+ * Aliases are upserted in Typesense
+ */
+export async function upsertAlias(config: AliasConfig): Promise<void> {
+  const client = getClient();
+  await client.aliases().upsert(config.name, {
+    collection_name: config.collection,
+  });
+}
+
+/**
+ * Delete an alias from Typesense
+ */
+export async function deleteAlias(name: string): Promise<void> {
+  const client = getClient();
+  await client.aliases(name).delete();
+}

package/src/resources/analyticsrule.ts

@@ -0,0 +1,134 @@
+import { getClient } from "../client/index.js";
+import type { AnalyticsRuleConfig } from "../types/index.js";
+
+/**
+ * Get an analytics rule from Typesense
+ */
+export async function getAnalyticsRule(
+  name: string
+): Promise<AnalyticsRuleConfig | null> {
+  const client = getClient();
+
+  try {
+    const data = await client.analytics.rules(name).retrieve();
+
+    return {
+      name: data.name,
+      type: data.type as AnalyticsRuleConfig["type"],
+      collection: data.collection,
+      event_type: data.event_type as AnalyticsRuleConfig["event_type"],
+      rule_tag: data.rule_tag,
+      params: data.params,
+    };
+  } catch (error: unknown) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "httpStatus" in error &&
+      (error.httpStatus === 404 || error.httpStatus === 400)
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * List all analytics rules from Typesense
+ */
+export async function listAnalyticsRules(): Promise<AnalyticsRuleConfig[]> {
+  const client = getClient();
+
+  try {
+    const response = await client.analytics.rules().retrieve();
+    const rules = response.rules || [];
+
+    return rules.map((rule) => {
+      const config: AnalyticsRuleConfig = {
+        name: rule.name,
+        type: rule.type as AnalyticsRuleConfig["type"],
+        collection: rule.collection,
+        event_type: rule.event_type as AnalyticsRuleConfig["event_type"],
+      };
+      if (rule.rule_tag) config.rule_tag = rule.rule_tag;
+      if (rule.params) config.params = rule.params;
+      return config;
+    });
+  } catch (error: unknown) {
+    // If analytics feature isn't available, return empty array
+    if (
+      error &&
+      typeof error === "object" &&
+      "httpStatus" in error &&
+      (error.httpStatus === 404 || error.httpStatus === 400)
+    ) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+/**
+ * Create an analytics rule in Typesense
+ */
+export async function createAnalyticsRule(
+  config: AnalyticsRuleConfig
+): Promise<void> {
+  const client = getClient();
+
+  await client.analytics.rules().upsert(config.name, {
+    type: config.type,
+    collection: config.collection,
+    event_type: config.event_type,
+    rule_tag: config.rule_tag,
+    params: config.params,
+  });
+}
+
+/**
+ * Update an analytics rule in Typesense
+ */
+export async function updateAnalyticsRule(
+  config: AnalyticsRuleConfig
+): Promise<void> {
+  const client = getClient();
+
+  await client.analytics.rules().upsert(config.name, {
+    type: config.type,
+    collection: config.collection,
+    event_type: config.event_type,
+    rule_tag: config.rule_tag,
+    params: config.params,
+  });
+}
+
+/**
+ * Delete an analytics rule from Typesense
+ */
+export async function deleteAnalyticsRule(name: string): Promise<void> {
+  const client = getClient();
+  await client.analytics.rules(name).delete();
+}
+
+/**
+ * Compare two analytics rule configs for equality
+ */
+export function analyticsRuleConfigsEqual(
+  a: AnalyticsRuleConfig,
+  b: AnalyticsRuleConfig
+): boolean {
+  // Normalize by removing undefined values
+  const normalize = (config: AnalyticsRuleConfig) => {
+    const result: Record<string, unknown> = {
+      name: config.name,
+      type: config.type,
+      collection: config.collection,
+      event_type: config.event_type,
+    };
+    if (config.rule_tag !== undefined) result.rule_tag = config.rule_tag;
+    if (config.params !== undefined) result.params = config.params;
+    return result;
+  };
+
+  return JSON.stringify(normalize(a)) === JSON.stringify(normalize(b));
+}

package/src/resources/apikey.ts

@@ -0,0 +1,203 @@
+import { getClient } from "../client/index.js";
+import type { ApiKeyConfig } from "../types/index.js";
+
+/**
+ * Stored API key with its Typesense ID
+ * We need to track the ID to be able to delete keys later
+ */
+export interface StoredApiKey extends ApiKeyConfig {
+  id: number;
+}
+
+/**
+ * Convert our ApiKeyConfig to Typesense API format for creation
+ */
+function toTypesenseApiKey(config: ApiKeyConfig): {
+  description: string;
+  actions: string[];
+  collections: string[];
+  value?: string;
+  expires_at?: number;
+  autodelete?: boolean;
+} {
+  const result: {
+    description: string;
+    actions: string[];
+    collections: string[];
+    value?: string;
+    expires_at?: number;
+    autodelete?: boolean;
+  } = {
+    description: config.description,
+    actions: config.actions,
+    collections: config.collections,
+  };
+
+  if (config.value) result.value = config.value;
+  if (config.expires_at !== undefined) result.expires_at = config.expires_at;
+  if (config.autodelete !== undefined) result.autodelete = config.autodelete;
+
+  return result;
+}
+
+/**
+ * Convert Typesense API key to our ApiKeyConfig format
+ */
+function fromTypesenseApiKey(apiKey: {
+  id: number;
+  description: string;
+  actions: string[];
+  collections: string[];
+  expires_at?: number;
+}): StoredApiKey {
+  const config: StoredApiKey = {
+    id: apiKey.id,
+    description: apiKey.description,
+    actions: apiKey.actions,
+    collections: apiKey.collections,
+  };
+
+  if (apiKey.expires_at !== undefined) config.expires_at = apiKey.expires_at;
+
+  return config;
+}
+
+/**
+ * Get an API key by description from Typesense
+ * We use description as the identifier since we don't know IDs upfront
+ */
+export async function getApiKey(description: string): Promise<StoredApiKey | null> {
+  const client = getClient();
+
+  try {
+    const response = await client.keys().retrieve();
+    const key = response.keys.find((k) => k.description === description);
+    if (!key || !key.description) return null;
+    return fromTypesenseApiKey({
+      id: key.id,
+      description: key.description,
+      actions: key.actions,
+      collections: key.collections,
+      expires_at: key.expires_at,
+    });
+  } catch (error: unknown) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "httpStatus" in error &&
+      error.httpStatus === 404
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Get an API key by ID from Typesense
+ */
+export async function getApiKeyById(id: number): Promise<StoredApiKey | null> {
+  const client = getClient();
+
+  try {
+    const key = await client.keys(id).retrieve();
+    return fromTypesenseApiKey(key as {
+      id: number;
+      description: string;
+      actions: string[];
+      collections: string[];
+      expires_at?: number;
+      autodelete?: boolean;
+    });
+  } catch (error: unknown) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "httpStatus" in error &&
+      error.httpStatus === 404
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * List all API keys from Typesense
+ */
+export async function listApiKeys(): Promise<StoredApiKey[]> {
+  const client = getClient();
+
+  const response = await client.keys().retrieve();
+  return response.keys
+    .filter((key) => key.description) // Only include keys with descriptions
+    .map((key) =>
+      fromTypesenseApiKey({
+        id: key.id,
+        description: key.description!,
+        actions: key.actions,
+        collections: key.collections,
+        expires_at: key.expires_at,
+      })
+    );
+}
+
+/**
+ * Create an API key in Typesense
+ * Returns the created key with its ID and value (value is only shown once!)
+ */
+export async function createApiKey(config: ApiKeyConfig): Promise<{
+  id: number;
+  value: string;
+}> {
+  const client = getClient();
+  const result = await client.keys().create(toTypesenseApiKey(config));
+  if (!result.value) {
+    throw new Error("API key creation did not return a value");
+  }
+  return {
+    id: result.id,
+    value: result.value,
+  };
+}
+
+/**
+ * Delete an API key from Typesense by ID
+ */
+export async function deleteApiKey(id: number): Promise<void> {
+  const client = getClient();
+  await client.keys(id).delete();
+}
+
+/**
+ * Delete an API key by description
+ * Finds the key by description first, then deletes it
+ */
+export async function deleteApiKeyByDescription(description: string): Promise<void> {
+  const key = await getApiKey(description);
+  if (key) {
+    await deleteApiKey(key.id);
+  }
+}
+
+/**
+ * Compare two API key configs for equality
+ * Used to determine if an update is needed
+ */
+export function apiKeyConfigsEqual(a: ApiKeyConfig, b: ApiKeyConfig): boolean {
+  // Compare actions and collections as sets
+  const actionsEqual =
+    a.actions.length === b.actions.length &&
+    a.actions.every((action) => b.actions.includes(action));
+
+  const collectionsEqual =
+    a.collections.length === b.collections.length &&
+    a.collections.every((collection) => b.collections.includes(collection));
+
+  return (
+    actionsEqual &&
+    collectionsEqual &&
+    a.expires_at === b.expires_at &&
+    a.autodelete === b.autodelete
+  );
+}