tthr 0.3.19 → 0.3.21

package/dist/{chunk-DR6CWO75.js → chunk-5S4QNCO2.js}

@@ -86,7 +86,7 @@ async function resolveEnvironmentFromApiKey(cwd = process.cwd()) {
       return prefix;
   }
 }
-var DEFAULT_API_URL = "https://api.tether.ngo";
+var DEFAULT_API_URL = "https://api.tetherdb.co.uk";
 function getApiUrl(config) {
   if (process.env.TETHER_API_URL) {
     return process.env.TETHER_API_URL.replace(/\/+$/, "");

package/dist/{generate-26HERX3T.js → generate-FEUPHOUR.js}

@@ -1,7 +1,7 @@
 import {
   generateCommand,
   generateTypes
-} from "./chunk-ZWLVHKNL.js";
+} from "./chunk-5S4QNCO2.js";
 export {
   generateCommand,
   generateTypes

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   resolveEnvironmentFromApiKey,
   resolvePath,
   saveCredentials
-} from "./chunk-DR6CWO75.js";
+} from "./chunk-5S4QNCO2.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -35,6 +35,42 @@ import ora from "ora";
 import fs from "fs-extra";
 import path from "path";
 import * as esbuild from "esbuild";
+async function describeHttpError(response, action) {
+  const status = response.status;
+  const contentType = response.headers.get("content-type") ?? "";
+  const text = await response.text().catch(() => "");
+  if (contentType.includes("application/json")) {
+    try {
+      const json = JSON.parse(text);
+      if (typeof json?.error === "string") return json.error;
+    } catch {
+    }
+  }
+  const looksLikeHtml = contentType.includes("text/html") || /^\s*<(!doctype|html)/i.test(text);
+  if (looksLikeHtml) {
+    const hint = (() => {
+      switch (status) {
+        case 401:
+        case 403:
+          return "Authentication failed or insufficient permissions. Try `tthr login` first.";
+        case 404:
+          return `Route or resource not found. Common causes: wrong project ID, environment doesn't exist on this server, or TETHER_API_URL points at the wrong host.`;
+        case 429:
+          return "Rate-limited by the server or upstream proxy. Wait a moment and retry.";
+        case 502:
+        case 503:
+        case 504:
+          return "Server is unreachable, restarting, or under load. Check status and retry.";
+        default:
+          return `Upstream proxy returned a generic ${status} page (likely a Cloudflare / nginx fallback).`;
+      }
+    })();
+    return `Failed to ${action}: ${hint} (HTTP ${status})`;
+  }
+  const trimmed = text.trim();
+  if (trimmed) return `${trimmed.slice(0, 300)}${trimmed.length > 300 ? "\u2026" : ""} (HTTP ${status})`;
+  return `HTTP ${status}: ${response.statusText || "request failed"}`;
+}
 async function deployCommand(options) {
   const credentials = await requireAuth();
   const configPath = path.resolve(process.cwd(), "tether.config.ts");
@@ -146,16 +182,7 @@ async function deploySchemaToServer(projectId, token, schemaPath, environment, d
     console.log(chalk.dim(`  Response: ${response.status} ${response.statusText}`));
     console.log(chalk.dim(`  Content-Type: ${response.headers.get("content-type")}`));
     if (!response.ok) {
-      const text = await response.text();
-      console.log(chalk.dim(`  Body: ${text.slice(0, 500)}`));
-      let errorMessage;
-      try {
-        const error = JSON.parse(text);
-        errorMessage = error.error || `HTTP ${response.status}`;
-      } catch {
-        errorMessage = text || `HTTP ${response.status}: ${response.statusText}`;
-      }
-      throw new Error(errorMessage);
+      throw new Error(await describeHttpError(response, "deploy schema"));
     }
     spinner.succeed(`Schema deployed (${tables.length} table(s))`);
   } catch (error) {
@@ -269,16 +296,7 @@ ${helperSource}`;
     console.log(chalk.dim(`  Response: ${response.status} ${response.statusText}`));
     console.log(chalk.dim(`  Content-Type: ${response.headers.get("content-type")}`));
     if (!response.ok) {
-      const text = await response.text();
-      console.log(chalk.dim(`  Body: ${text.slice(0, 500)}`));
-      let errorMessage;
-      try {
-        const error = JSON.parse(text);
-        errorMessage = error.error || `HTTP ${response.status}`;
-      } catch {
-        errorMessage = text || `HTTP ${response.status}: ${response.statusText}`;
-      }
-      throw new Error(errorMessage);
+      throw new Error(await describeHttpError(response, "deploy functions"));
     }
     spinner.succeed(`Functions deployed (${functions.length} function(s))`);
     const queries = functions.filter((f) => f.type === "query");
@@ -1705,7 +1723,7 @@ async function runGenerate(spinner) {
   }
   isGenerating = true;
   try {
-    const { generateTypes: generateTypes2 } = await import("./generate-M7G5AXMR.js");
+    const { generateTypes: generateTypes2 } = await import("./generate-FEUPHOUR.js");
     spinner.text = "Regenerating types...";
     await generateTypes2({ silent: true });
     spinner.succeed("Types regenerated");
@@ -1977,7 +1995,7 @@ async function devCommand(options) {
       }
     }
     spinner.text = "Generating types...";
-    const { generateTypes: generateTypes2 } = await import("./generate-M7G5AXMR.js");
+    const { generateTypes: generateTypes2 } = await import("./generate-FEUPHOUR.js");
     await generateTypes2({ silent: true });
     spinner.succeed("Types generated");
     if (config.projectId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tthr",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "description": "Tether CLI - project scaffolding and deployment",
   "type": "module",
   "bin": {
@@ -18,8 +18,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts --format esm --watch",
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch --clean",
     "typecheck": "tsc --noEmit",
     "start": "TETHER_DEV=true node dist/index.js"
   },

package/dist/chunk-2IDRK6NG.js

@@ -1,416 +0,0 @@
-// src/commands/generate.ts
-import chalk2 from "chalk";
-import ora from "ora";
-import fs3 from "fs-extra";
-import path3 from "path";
-
-// src/utils/auth.ts
-import chalk from "chalk";
-import fs from "fs-extra";
-import path from "path";
-var CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".tether");
-var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
-async function getCredentials() {
-  try {
-    if (await fs.pathExists(CREDENTIALS_FILE)) {
-      return await fs.readJSON(CREDENTIALS_FILE);
-    }
-  } catch {
-  }
-  return null;
-}
-async function requireAuth() {
-  const credentials = await getCredentials();
-  if (!credentials) {
-    console.error(chalk.red("\n\u2717 Not logged in\n"));
-    console.log(chalk.dim("Run `tthr login` to authenticate\n"));
-    process.exit(1);
-  }
-  if (credentials.expiresAt) {
-    const expiresAt = new Date(credentials.expiresAt);
-    if (/* @__PURE__ */ new Date() > expiresAt) {
-      console.error(chalk.red("\n\u2717 Session expired\n"));
-      console.log(chalk.dim("Run `tthr login` to authenticate\n"));
-      process.exit(1);
-    }
-  }
-  return credentials;
-}
-async function saveCredentials(credentials) {
-  await fs.ensureDir(CONFIG_DIR);
-  await fs.writeJSON(CREDENTIALS_FILE, credentials, { spaces: 2, mode: 384 });
-}
-async function clearCredentials() {
-  try {
-    await fs.remove(CREDENTIALS_FILE);
-  } catch {
-  }
-}
-
-// src/utils/config.ts
-import fs2 from "fs-extra";
-import path2 from "path";
-var DEFAULT_CONFIG = {
-  schema: "./tether/schema.ts",
-  functions: "./tether/functions",
-  output: "./tether/_generated",
-  dev: {
-    port: 3001,
-    host: "localhost"
-  },
-  database: {
-    walMode: true
-  }
-};
-async function loadConfig(cwd = process.cwd()) {
-  const configPath = path2.resolve(cwd, "tether.config.ts");
-  if (!await fs2.pathExists(configPath)) {
-    return DEFAULT_CONFIG;
-  }
-  const configSource = await fs2.readFile(configPath, "utf-8");
-  const config = {};
-  const schemaMatch = configSource.match(/schema\s*:\s*['"]([^'"]+)['"]/);
-  if (schemaMatch) {
-    config.schema = schemaMatch[1];
-  }
-  const functionsMatch = configSource.match(/functions\s*:\s*['"]([^'"]+)['"]/);
-  if (functionsMatch) {
-    config.functions = functionsMatch[1];
-  }
-  const outputMatch = configSource.match(/output\s*:\s*['"]([^'"]+)['"]/);
-  if (outputMatch) {
-    config.output = outputMatch[1];
-  }
-  const envMatch = configSource.match(/environment\s*:\s*['"]([^'"]+)['"]/);
-  if (envMatch) {
-    config.environment = envMatch[1];
-  }
-  const portMatch = configSource.match(/port\s*:\s*(\d+)/);
-  if (portMatch) {
-    config.dev = { ...config.dev, port: parseInt(portMatch[1], 10) };
-  }
-  const hostMatch = configSource.match(/host\s*:\s*['"]([^'"]+)['"]/);
-  if (hostMatch) {
-    config.dev = { ...config.dev, host: hostMatch[1] };
-  }
-  return {
-    ...DEFAULT_CONFIG,
-    ...config,
-    dev: { ...DEFAULT_CONFIG.dev, ...config.dev },
-    database: { ...DEFAULT_CONFIG.database, ...config.database }
-  };
-}
-function resolvePath(configPath, cwd = process.cwd()) {
-  const normalised = configPath.replace(/^\.\//, "");
-  return path2.resolve(cwd, normalised);
-}
-async function detectFramework(cwd = process.cwd()) {
-  const packageJsonPath = path2.resolve(cwd, "package.json");
-  if (!await fs2.pathExists(packageJsonPath)) {
-    return "unknown";
-  }
-  try {
-    const packageJson = await fs2.readJson(packageJsonPath);
-    const deps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    if (deps.nuxt || deps["@nuxt/kit"]) {
-      return "nuxt";
-    }
-    if (deps.next) {
-      return "next";
-    }
-    if (deps["@sveltejs/kit"]) {
-      return "sveltekit";
-    }
-    if (deps.vite && !deps.nuxt && !deps.next && !deps["@sveltejs/kit"]) {
-      return "vite";
-    }
-    return "vanilla";
-  } catch {
-    return "unknown";
-  }
-}
-function getFrameworkDevCommand(framework) {
-  switch (framework) {
-    case "nuxt":
-      return "nuxt dev";
-    case "next":
-      return "next dev";
-    case "sveltekit":
-      return "vite dev";
-    case "vite":
-      return "vite dev";
-    case "vanilla":
-      return null;
-    // No default dev server for vanilla
-    default:
-      return null;
-  }
-}
-
-// src/commands/generate.ts
-function parseSchemaFile(source) {
-  const tables = [];
-  const schemaMatch = source.match(/defineSchema\s*\(\s*\{([\s\S]*)\}\s*\)/);
-  if (!schemaMatch) return tables;
-  const schemaContent = schemaMatch[1];
-  const tableStartRegex = /(\w+)\s*:\s*\{/g;
-  let match;
-  while ((match = tableStartRegex.exec(schemaContent)) !== null) {
-    const tableName = match[1];
-    const startOffset = match.index + match[0].length;
-    let braceCount = 1;
-    let endOffset = startOffset;
-    for (let i = startOffset; i < schemaContent.length && braceCount > 0; i++) {
-      const char = schemaContent[i];
-      if (char === "{") braceCount++;
-      else if (char === "}") braceCount--;
-      endOffset = i;
-    }
-    const columnsContent = schemaContent.slice(startOffset, endOffset);
-    const columns = parseColumns(columnsContent);
-    tables.push({ name: tableName, columns });
-  }
-  return tables;
-}
-function parseColumns(content) {
-  const columns = [];
-  const columnRegex = /(\w+)\s*:\s*(\w+)\s*\(\s*\)([^,\n}]*)/g;
-  let match;
-  while ((match = columnRegex.exec(content)) !== null) {
-    const name = match[1];
-    const schemaType = match[2];
-    const modifiers = match[3] || "";
-    const nullable = !modifiers.includes(".notNull()");
-    columns.push({
-      name,
-      type: schemaTypeToTS(schemaType),
-      nullable
-    });
-  }
-  return columns;
-}
-function schemaTypeToTS(schemaType) {
-  switch (schemaType) {
-    case "text":
-      return "string";
-    case "integer":
-      return "number";
-    case "real":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "timestamp":
-      return "string";
-    case "json":
-      return "unknown";
-    case "blob":
-      return "Uint8Array";
-    default:
-      return "unknown";
-  }
-}
-function tableNameToInterface(tableName) {
-  let name = tableName;
-  if (name.endsWith("ies")) {
-    name = name.slice(0, -3) + "y";
-  } else if (name.endsWith("s") && !name.endsWith("ss")) {
-    name = name.slice(0, -1);
-  }
-  return name.charAt(0).toUpperCase() + name.slice(1);
-}
-function generateDbFile(tables) {
-  const lines = [
-    "// Auto-generated by Tether CLI - do not edit manually",
-    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "import { createDatabaseProxy, type TetherDatabase } from '@tthr/client';",
-    ""
-  ];
-  for (const table of tables) {
-    const interfaceName = tableNameToInterface(table.name);
-    lines.push(`export interface ${interfaceName} {`);
-    for (const col of table.columns) {
-      const typeStr = col.nullable ? `${col.type} | null` : col.type;
-      lines.push(`  ${col.name}: ${typeStr};`);
-    }
-    lines.push("}");
-    lines.push("");
-  }
-  lines.push("export interface Schema {");
-  for (const table of tables) {
-    const interfaceName = tableNameToInterface(table.name);
-    lines.push(`  ${table.name}: ${interfaceName};`);
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push("// Database client with typed tables");
-  lines.push("// This is a proxy that will be populated by the Tether runtime");
-  lines.push("export const db: TetherDatabase<Schema> = createDatabaseProxy<Schema>();");
-  lines.push("");
-  return lines.join("\n");
-}
-async function parseFunctionsDir(functionsDir) {
-  const functions = [];
-  if (!await fs3.pathExists(functionsDir)) {
-    return functions;
-  }
-  const files = await fs3.readdir(functionsDir);
-  for (const file of files) {
-    if (!file.endsWith(".ts") && !file.endsWith(".js")) continue;
-    const filePath = path3.join(functionsDir, file);
-    const stat = await fs3.stat(filePath);
-    if (!stat.isFile()) continue;
-    const moduleName = file.replace(/\.(ts|js)$/, "");
-    const source = await fs3.readFile(filePath, "utf-8");
-    const exportRegex = /export\s+const\s+(\w+)\s*=\s*(query|mutation|action)\s*\(/g;
-    let match;
-    while ((match = exportRegex.exec(source)) !== null) {
-      functions.push({
-        name: match[1],
-        moduleName
-      });
-    }
-  }
-  return functions;
-}
-async function generateApiFile(functionsDir) {
-  const functions = await parseFunctionsDir(functionsDir);
-  const moduleMap = /* @__PURE__ */ new Map();
-  for (const fn of functions) {
-    if (!moduleMap.has(fn.moduleName)) {
-      moduleMap.set(fn.moduleName, []);
-    }
-    moduleMap.get(fn.moduleName).push(fn.name);
-  }
-  const lines = [
-    "// Auto-generated by Tether CLI - do not edit manually",
-    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "import { createApiProxy } from '@tthr/client';",
-    "",
-    "/**",
-    " * API function reference type for useQuery/useMutation.",
-    ' * The _name property contains the function path (e.g., "users.list").',
-    " */",
-    "export interface ApiFunction<TArgs = unknown, TResult = unknown> {",
-    "  _name: string;",
-    "  _args?: TArgs;",
-    "  _result?: TResult;",
-    "}",
-    ""
-  ];
-  if (moduleMap.size > 0) {
-    for (const [moduleName, fnNames] of moduleMap) {
-      const interfaceName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1) + "Api";
-      lines.push(`export interface ${interfaceName} {`);
-      for (const fnName of fnNames) {
-        lines.push(`  ${fnName}: ApiFunction;`);
-      }
-      lines.push("}");
-      lines.push("");
-    }
-    lines.push("export interface Api {");
-    for (const moduleName of moduleMap.keys()) {
-      const interfaceName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1) + "Api";
-      lines.push(`  ${moduleName}: ${interfaceName};`);
-    }
-    lines.push("}");
-  } else {
-    lines.push("/**");
-    lines.push(" * Flexible API type that allows access to any function path.");
-    lines.push(" * Functions are accessed as api.moduleName.functionName");
-    lines.push(" * The actual types depend on your function definitions.");
-    lines.push(" */");
-    lines.push("export type Api = {");
-    lines.push("  [module: string]: {");
-    lines.push("    [fn: string]: ApiFunction;");
-    lines.push("  };");
-    lines.push("};");
-  }
-  lines.push("");
-  lines.push("// API client proxy - provides typed access to your functions");
-  lines.push("// On the client: returns { _name } references for useQuery/useMutation");
-  lines.push("// In Tether functions: calls the actual function implementation");
-  lines.push("export const api = createApiProxy<Api>();");
-  lines.push("");
-  return lines.join("\n");
-}
-async function generateTypes(options = {}) {
-  const config = await loadConfig();
-  const schemaPath = resolvePath(config.schema);
-  const outputDir = resolvePath(config.output);
-  const functionsDir = resolvePath(config.functions);
-  if (!await fs3.pathExists(schemaPath)) {
-    throw new Error(`Schema file not found: ${schemaPath}`);
-  }
-  const schemaSource = await fs3.readFile(schemaPath, "utf-8");
-  const tables = parseSchemaFile(schemaSource);
-  await fs3.ensureDir(outputDir);
-  await fs3.writeFile(
-    path3.join(outputDir, "db.ts"),
-    generateDbFile(tables)
-  );
-  await fs3.writeFile(
-    path3.join(outputDir, "api.ts"),
-    await generateApiFile(functionsDir)
-  );
-  await fs3.writeFile(
-    path3.join(outputDir, "index.ts"),
-    `// Auto-generated by Tether CLI - do not edit manually
-export * from './db';
-export * from './api';
-`
-  );
-  return { tables, outputDir };
-}
-async function generateCommand() {
-  await requireAuth();
-  const configPath = path3.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs3.pathExists(configPath)) {
-    console.log(chalk2.red("\nError: Not a Tether project"));
-    console.log(chalk2.dim("Run `tthr init` to create a new project\n"));
-    process.exit(1);
-  }
-  console.log(chalk2.bold("\n\u26A1 Generating types from schema\n"));
-  const spinner = ora("Reading schema...").start();
-  try {
-    spinner.text = "Generating types...";
-    const { tables, outputDir } = await generateTypes();
-    if (tables.length === 0) {
-      spinner.warn("No tables found in schema");
-      console.log(chalk2.dim("  Make sure your schema uses defineSchema({ ... })\n"));
-      return;
-    }
-    spinner.succeed(`Types generated for ${tables.length} table(s)`);
-    console.log("\n" + chalk2.green("\u2713") + " Tables:");
-    for (const table of tables) {
-      console.log(chalk2.dim(`  - ${table.name} (${table.columns.length} columns)`));
-    }
-    const relativeOutput = path3.relative(process.cwd(), outputDir);
-    console.log("\n" + chalk2.green("\u2713") + " Generated files:");
-    console.log(chalk2.dim(`  ${relativeOutput}/db.ts`));
-    console.log(chalk2.dim(`  ${relativeOutput}/api.ts`));
-    console.log(chalk2.dim(`  ${relativeOutput}/index.ts
-`));
-  } catch (error) {
-    spinner.fail("Failed to generate types");
-    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
-    process.exit(1);
-  }
-}
-
-export {
-  getCredentials,
-  requireAuth,
-  saveCredentials,
-  clearCredentials,
-  loadConfig,
-  resolvePath,
-  detectFramework,
-  getFrameworkDevCommand,
-  generateTypes,
-  generateCommand
-};