@tsproxy/cli 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,63 @@
+# @tsproxy/cli
+
+CLI for [tsproxy](https://github.com/akshitkrnagpal/tsproxy) — a Typesense search proxy framework.
+
+> **This project is under heavy development.**
+
+## Quick Start
+
+```bash
+npx @tsproxy/cli init
+docker compose up -d
+npx tsproxy dev
+```
+
+## Commands
+
+```bash
+tsproxy init         # Interactive project setup
+tsproxy dev          # Start proxy in dev mode (hot reload)
+tsproxy start        # Start proxy in production mode
+tsproxy build        # Build for production
+tsproxy seed <file>  # Seed data via the ingest API
+tsproxy migrate      # Sync Typesense schema with config
+tsproxy health       # Check Typesense + Redis status
+```
+
+## `tsproxy init`
+
+Interactive setup that asks:
+
+1. **What to set up** — Backend / Frontend / Both
+2. **How you run Typesense** — Docker / Typesense Cloud / Self-hosted
+3. **Persistent queue** — Redis (optional)
+4. **Frontend framework** — React / Vanilla JS
+
+Generates `tsproxy.config.ts`, `docker-compose.yml`, `.env`, and installs dependencies.
+
+## `tsproxy migrate`
+
+Diffs your `tsproxy.config.ts` collections against live Typesense schema:
+
+```bash
+npx tsproxy migrate          # dry run
+npx tsproxy migrate --apply  # apply changes
+npx tsproxy migrate --apply --drop  # drop and recreate
+```
+
+## `tsproxy seed`
+
+Seeds data through the proxy's ingest API (applies computed fields, uses queue):
+
+```bash
+npx tsproxy seed products.json --collection products
+npx tsproxy seed products.json --collection products --locale en
+```
+
+## Documentation
+
+[tsproxy.akshit.io](https://tsproxy.akshit.io)
+
+## License
+
+MIT

package/dist/index.js

@@ -310,8 +310,8 @@ function findCliEntry() {
     resolve2(process.cwd(), "node_modules/@tsproxy/api/dist/cli.js"),
     resolve2(process.cwd(), "node_modules/@tsproxy/api/src/cli.ts")
   ];
-  for (const p2 of paths) {
-    if (existsSync2(p2)) return p2;
+  for (const p3 of paths) {
+    if (existsSync2(p3)) return p3;
   }
   return null;
 }
@@ -597,6 +597,72 @@ Dry run \u2014 ${pendingActions.length} change(s). Run with --apply to execute.`
       );
     }
   }
+  for (const [name, def] of Object.entries(collections)) {
+    const names = [name];
+    if (def.locales?.length) {
+      for (const locale of def.locales) {
+        names.push(`${name}_${locale}`);
+      }
+    }
+    for (const colName of names) {
+      if (def.synonyms) {
+        for (const [synName, synDef] of Object.entries(def.synonyms)) {
+          try {
+            const body = {};
+            if (synDef.synonyms) {
+              body.synonyms = synDef.synonyms;
+            } else if (synDef.root && synDef.words) {
+              body.root = synDef.root;
+              body.synonyms = synDef.words;
+            }
+            await fetch(`${baseUrl}/collections/${colName}/synonyms/${synName}`, {
+              method: "PUT",
+              headers: {
+                "Content-Type": "application/json",
+                "X-TYPESENSE-API-KEY": tsApiKey
+              },
+              body: JSON.stringify(body)
+            });
+            console.log(`  ${pc3.green("\u2713")} ${colName}/synonyms/${synName}`);
+          } catch (err) {
+            console.error(`  ${pc3.red("\u2717")} ${colName}/synonyms/${synName} \u2014 ${err.message}`);
+          }
+        }
+      }
+      if (def.curations) {
+        for (const [curName, curDef] of Object.entries(def.curations)) {
+          try {
+            const body = {
+              rule: {
+                query: curDef.query,
+                match: curDef.match || "exact"
+              }
+            };
+            if (curDef.pinnedIds?.length) {
+              body.includes = curDef.pinnedIds.map((id, i) => ({
+                id,
+                position: i + 1
+              }));
+            }
+            if (curDef.hiddenIds?.length) {
+              body.excludes = curDef.hiddenIds.map((id) => ({ id }));
+            }
+            await fetch(`${baseUrl}/collections/${colName}/overrides/${curName}`, {
+              method: "PUT",
+              headers: {
+                "Content-Type": "application/json",
+                "X-TYPESENSE-API-KEY": tsApiKey
+              },
+              body: JSON.stringify(body)
+            });
+            console.log(`  ${pc3.green("\u2713")} ${colName}/overrides/${curName}`);
+          } catch (err) {
+            console.error(`  ${pc3.red("\u2717")} ${colName}/overrides/${curName} \u2014 ${err.message}`);
+          }
+        }
+      }
+    }
+  }
   console.log(pc3.green("\nMigration complete."));
 }
 function buildSchema(name, def) {
@@ -620,8 +686,8 @@ function findConfig() {
   const root = resolve5("/");
   while (dir !== root) {
     for (const name of names) {
-      const p2 = resolve5(dir, name);
-      if (existsSync4(p2)) return p2;
+      const p3 = resolve5(dir, name);
+      if (existsSync4(p3)) return p3;
     }
     dir = resolve5(dir, "..");
   }
@@ -663,6 +729,135 @@ async function health() {
   }
 }
 
+// src/commands/generate.ts
+import * as p2 from "@clack/prompts";
+import pc5 from "picocolors";
+import { writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
+import { resolve as resolve6 } from "path";
+async function generate(opts) {
+  p2.intro(pc5.bgCyan(pc5.black(" tsproxy generate ")));
+  const tsHost = opts.host || process.env.TYPESENSE_HOST || "localhost";
+  const tsPort = opts.port || process.env.TYPESENSE_PORT || "8108";
+  const tsApiKey = opts.key || process.env.TYPESENSE_API_KEY;
+  if (!tsApiKey) {
+    p2.log.error("Typesense API key is required. Set TYPESENSE_API_KEY or pass --key.");
+    process.exit(1);
+  }
+  const s = p2.spinner();
+  s.start("Fetching collections from Typesense");
+  let collections;
+  try {
+    const res = await fetch(`http://${tsHost}:${tsPort}/collections`, {
+      headers: { "X-TYPESENSE-API-KEY": tsApiKey }
+    });
+    if (!res.ok) {
+      throw new Error(`${res.status} ${res.statusText}`);
+    }
+    collections = await res.json();
+  } catch (err) {
+    s.stop("Failed to connect");
+    p2.log.error(`Cannot connect to Typesense at ${tsHost}:${tsPort}`);
+    p2.log.error(err.message);
+    process.exit(1);
+  }
+  s.stop(`Found ${collections.length} collection(s)`);
+  if (collections.length === 0) {
+    p2.log.warn("No collections found. Create some collections first.");
+    process.exit(0);
+  }
+  const selected = await p2.multiselect({
+    message: "Which collections to include?",
+    options: collections.map((col) => ({
+      value: col.name,
+      label: `${col.name} (${col.num_documents} docs, ${col.fields.length} fields)`
+    })),
+    required: true
+  });
+  if (p2.isCancel(selected)) return process.exit(0);
+  const TYPE_MAP = {
+    string: "string",
+    "string[]": "string[]",
+    int32: "int32",
+    "int32[]": "int32[]",
+    int64: "int64",
+    "int64[]": "int64[]",
+    float: "float",
+    "float[]": "float[]",
+    bool: "bool",
+    "bool[]": "bool[]",
+    geopoint: "geopoint",
+    "geopoint[]": "geopoint[]",
+    auto: "auto",
+    object: "object",
+    "object[]": "object[]"
+  };
+  const collectionConfigs = [];
+  for (const colName of selected) {
+    const col = collections.find((c) => c.name === colName);
+    if (!col) continue;
+    const fieldLines = [];
+    for (const field of col.fields) {
+      if (field.name === ".*") continue;
+      const type = TYPE_MAP[field.type] || "string";
+      const props = [`type: "${type}"`];
+      if ((field.type === "string" || field.type === "string[]") && field.index !== false) {
+        props.push("searchable: true");
+      }
+      if (field.facet) props.push("facet: true");
+      if (field.sort) props.push("sortable: true");
+      if (field.optional) props.push("optional: true");
+      if (field.infix) props.push("infix: true");
+      fieldLines.push(`        ${field.name}: { ${props.join(", ")} },`);
+    }
+    const sortField = col.default_sorting_field ? `
+      defaultSortBy: "${col.default_sorting_field}",` : "";
+    collectionConfigs.push(`    ${colName}: {
+      fields: {
+${fieldLines.join("\n")}
+      },${sortField}
+    },`);
+  }
+  const configContent = `import { defineConfig } from "@tsproxy/api";
+
+export default defineConfig({
+  typesense: {
+    host: "${tsHost}",
+    port: ${tsPort},
+    protocol: "http",
+    apiKey: process.env.TYPESENSE_API_KEY || "${tsApiKey}",
+  },
+
+  server: {
+    port: 3000,
+    apiKey: process.env.PROXY_API_KEY || "change-me",
+  },
+
+  cache: { ttl: 60, maxSize: 1000 },
+  queue: { concurrency: 5, maxSize: 10000 },
+  rateLimit: { search: 100, ingest: 30 },
+
+  collections: {
+${collectionConfigs.join("\n\n")}
+  },
+});
+`;
+  const outputPath = resolve6(process.cwd(), opts.output || "tsproxy.config.ts");
+  if (existsSync5(outputPath)) {
+    const overwrite = await p2.confirm({
+      message: `${opts.output || "tsproxy.config.ts"} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p2.isCancel(overwrite) || !overwrite) {
+      p2.log.info("Generated config:");
+      console.log(configContent);
+      p2.outro("Config printed to stdout (file not written).");
+      return;
+    }
+  }
+  writeFileSync2(outputPath, configContent);
+  p2.outro(pc5.green(`Config written to ${opts.output || "tsproxy.config.ts"}`));
+}
+
 // src/index.ts
 var program = new Command();
 program.name("tsproxy").description("Typesense search proxy framework").version("0.1.0");
@@ -673,4 +868,5 @@ program.command("build").description("Build the proxy for production").action(bu
 program.command("seed [file]").description("Seed Typesense with data from a JSON/JSONL file").option("--collection <name>", "Collection name").option("--locale <locale>", "Locale for the collection").option("--locales", "Create locale-specific collections").action(seed);
 program.command("migrate").description("Sync Typesense schema with config").option("--apply", "Apply changes (default is dry-run)").option("--drop", "Drop and recreate collections").action(migrate);
 program.command("health").description("Check Typesense and Redis connectivity").action(health);
+program.command("generate").description("Generate tsproxy.config.ts from existing Typesense schema").option("--host <host>", "Typesense host").option("--port <port>", "Typesense port").option("--key <key>", "Typesense API key").option("-o, --output <path>", "Output file path", "tsproxy.config.ts").action(generate);
 program.parse();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@tsproxy/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "CLI for tsproxy — Typesense search proxy framework",
   "type": "module",
   "bin": {
     "tsproxy": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -24,6 +25,11 @@
     "proxy",
     "cli"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node22",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
   "dependencies": {
     "@clack/prompts": "^0.10.0",
     "commander": "^13.1.0",
@@ -33,10 +39,7 @@
     "@types/node": "^20",
     "tsup": "^8.4.0",
     "tsx": "^4.19.0",
-    "typescript": "^5"
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --target node22",
-    "dev": "tsx src/index.ts"
+    "typescript": "^5",
+    "vitest": "^3.2.4"
   }
-}
+}