tthr 0.0.18 → 0.0.20

package/dist/index.js

@@ -7,8 +7,8 @@ import { Command } from "commander";
 import chalk3 from "chalk";
 import ora2 from "ora";
 import prompts from "prompts";
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 import { execSync } from "child_process";
 
 // src/utils/auth.ts
@@ -57,22 +57,78 @@ async function clearCredentials() {
 // src/commands/deploy.ts
 import chalk2 from "chalk";
 import ora from "ora";
+import fs3 from "fs-extra";
+import path3 from "path";
+
+// 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 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);
+}
+
+// src/commands/deploy.ts
 var isDev = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
 var API_URL = isDev ? "http://localhost:3001/api/v1" : "https://tether-api.strands.gg/api/v1";
 async function deployCommand(options) {
   const credentials = await requireAuth();
-  const configPath = path2.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs2.pathExists(configPath)) {
+  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);
   }
-  const envPath = path2.resolve(process.cwd(), ".env");
+  const envPath = path3.resolve(process.cwd(), ".env");
   let projectId;
-  if (await fs2.pathExists(envPath)) {
-    const envContent = await fs2.readFile(envPath, "utf-8");
+  if (await fs3.pathExists(envPath)) {
+    const envContent = await fs3.readFile(envPath, "utf-8");
     const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
     projectId = match?.[1]?.trim();
   }
@@ -85,26 +141,30 @@ async function deployCommand(options) {
   console.log(chalk2.dim(`  Project: ${projectId}`));
   console.log(chalk2.dim(`  API: ${API_URL}
 `));
+  const config = await loadConfig();
   const deploySchema = options.schema || !options.schema && !options.functions;
   const deployFunctions = options.functions || !options.schema && !options.functions;
   if (deploySchema) {
-    await deploySchemaToServer(projectId, credentials.accessToken, options.dryRun);
+    const schemaPath = resolvePath(config.schema);
+    await deploySchemaToServer(projectId, credentials.accessToken, schemaPath, options.dryRun);
   }
   if (deployFunctions) {
-    await deployFunctionsToServer(projectId, credentials.accessToken, options.dryRun);
+    const functionsDir = resolvePath(config.functions);
+    await deployFunctionsToServer(projectId, credentials.accessToken, functionsDir, options.dryRun);
   }
   console.log(chalk2.green("\n\u2713 Deployment complete\n"));
 }
-async function deploySchemaToServer(projectId, token, dryRun) {
+async function deploySchemaToServer(projectId, token, schemaPath, dryRun) {
   const spinner = ora("Reading schema...").start();
   try {
-    const schemaPath = path2.resolve(process.cwd(), "tether", "schema.ts");
-    if (!await fs2.pathExists(schemaPath)) {
+    if (!await fs3.pathExists(schemaPath)) {
       spinner.warn("No schema file found");
-      console.log(chalk2.dim("  Create tether/schema.ts to define your database schema\n"));
+      const relativePath = path3.relative(process.cwd(), schemaPath);
+      console.log(chalk2.dim(`  Create ${relativePath} to define your database schema
+`));
       return;
     }
-    const schemaSource = await fs2.readFile(schemaPath, "utf-8");
+    const schemaSource = await fs3.readFile(schemaPath, "utf-8");
     const tables = parseSchema(schemaSource);
     spinner.text = `Found ${tables.length} table(s)`;
     if (dryRun) {
@@ -140,16 +200,17 @@ async function deploySchemaToServer(projectId, token, dryRun) {
     console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
   }
 }
-async function deployFunctionsToServer(projectId, token, dryRun) {
+async function deployFunctionsToServer(projectId, token, functionsDir, dryRun) {
   const spinner = ora("Reading functions...").start();
   try {
-    const functionsDir = path2.resolve(process.cwd(), "tether", "functions");
-    if (!await fs2.pathExists(functionsDir)) {
+    if (!await fs3.pathExists(functionsDir)) {
       spinner.warn("No functions directory found");
-      console.log(chalk2.dim("  Create tether/functions/ to define your API functions\n"));
+      const relativePath = path3.relative(process.cwd(), functionsDir);
+      console.log(chalk2.dim(`  Create ${relativePath}/ to define your API functions
+`));
       return;
     }
-    const files = await fs2.readdir(functionsDir);
+    const files = await fs3.readdir(functionsDir);
     const tsFiles = files.filter((f) => f.endsWith(".ts"));
     if (tsFiles.length === 0) {
       spinner.info("No function files found");
@@ -157,8 +218,8 @@ async function deployFunctionsToServer(projectId, token, dryRun) {
     }
     const functions = [];
     for (const file of tsFiles) {
-      const filePath = path2.join(functionsDir, file);
-      const source = await fs2.readFile(filePath, "utf-8");
+      const filePath = path3.join(functionsDir, file);
+      const source = await fs3.readFile(filePath, "utf-8");
       const moduleName = file.replace(".ts", "");
       const parsedFunctions = parseFunctions(moduleName, source);
       functions.push(...parsedFunctions);
@@ -429,8 +490,8 @@ ${packageManager} is not installed on your system.`));
     });
     template = response.template || "nuxt";
   }
-  const projectPath = path3.resolve(process.cwd(), projectName);
-  if (await fs3.pathExists(projectPath)) {
+  const projectPath = path4.resolve(process.cwd(), projectName);
+  if (await fs4.pathExists(projectPath)) {
     const { overwrite } = await prompts({
       type: "confirm",
       name: "overwrite",
@@ -441,7 +502,7 @@ ${packageManager} is not installed on your system.`));
       console.log(chalk3.yellow("Cancelled"));
       process.exit(0);
     }
-    await fs3.remove(projectPath);
+    await fs4.remove(projectPath);
   }
   const spinner = ora2(`Scaffolding ${template} project...`).start();
   let projectId;
@@ -516,7 +577,7 @@ function getPackageRunnerCommand(pm) {
   }
 }
 async function scaffoldNuxtProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path3.dirname(projectPath);
+  const parentDir = path4.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   spinner.stop();
   console.log(chalk3.dim("\nRunning nuxi init...\n"));
@@ -525,7 +586,7 @@ async function scaffoldNuxtProject(projectName, projectPath, spinner, packageMan
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+    if (!await fs4.pathExists(path4.join(projectPath, "package.json"))) {
       throw new Error("Nuxt project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -538,7 +599,7 @@ async function scaffoldNuxtProject(projectName, projectPath, spinner, packageMan
   }
 }
 async function scaffoldNextProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path3.dirname(projectPath);
+  const parentDir = path4.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   const pmFlag = packageManager === "npm" ? "--use-npm" : packageManager === "pnpm" ? "--use-pnpm" : packageManager === "yarn" ? "--use-yarn" : "--use-bun";
   spinner.stop();
@@ -548,7 +609,7 @@ async function scaffoldNextProject(projectName, projectPath, spinner, packageMan
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+    if (!await fs4.pathExists(path4.join(projectPath, "package.json"))) {
       throw new Error("Next.js project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -561,7 +622,7 @@ async function scaffoldNextProject(projectName, projectPath, spinner, packageMan
   }
 }
 async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packageManager) {
-  const parentDir = path3.dirname(projectPath);
+  const parentDir = path4.dirname(projectPath);
   const runner = getPackageRunnerCommand(packageManager);
   spinner.stop();
   console.log(chalk3.dim("\nRunning sv create...\n"));
@@ -570,7 +631,7 @@ async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packa
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
+    if (!await fs4.pathExists(path4.join(projectPath, "package.json"))) {
       throw new Error("SvelteKit project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -589,8 +650,8 @@ async function scaffoldSvelteKitProject(projectName, projectPath, spinner, packa
 }
 async function scaffoldVanillaProject(projectName, projectPath, spinner) {
   spinner.text = "Creating vanilla TypeScript project...";
-  await fs3.ensureDir(projectPath);
-  await fs3.ensureDir(path3.join(projectPath, "src"));
+  await fs4.ensureDir(projectPath);
+  await fs4.ensureDir(path4.join(projectPath, "src"));
   const packageJson = {
     name: projectName,
     version: "0.0.1",
@@ -607,9 +668,9 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
       "@types/node": "latest"
     }
   };
-  await fs3.writeJSON(path3.join(projectPath, "package.json"), packageJson, { spaces: 2 });
-  await fs3.writeJSON(
-    path3.join(projectPath, "tsconfig.json"),
+  await fs4.writeJSON(path4.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  await fs4.writeJSON(
+    path4.join(projectPath, "tsconfig.json"),
     {
       compilerOptions: {
         target: "ES2022",
@@ -630,8 +691,8 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
     },
     { spaces: 2 }
   );
-  await fs3.writeFile(
-    path3.join(projectPath, "src", "index.ts"),
+  await fs4.writeFile(
+    path4.join(projectPath, "src", "index.ts"),
     `import { createClient } from '@tthr/client';
 
 const tether = createClient({
@@ -650,8 +711,8 @@ async function main() {
 main().catch(console.error);
 `
   );
-  await fs3.writeFile(
-    path3.join(projectPath, ".gitignore"),
+  await fs4.writeFile(
+    path4.join(projectPath, ".gitignore"),
     `node_modules/
 dist/
 .env
@@ -661,11 +722,11 @@ dist/
   );
 }
 async function addTetherFiles(projectPath, projectId, apiKey, template) {
-  await fs3.ensureDir(path3.join(projectPath, "tether"));
-  await fs3.ensureDir(path3.join(projectPath, "tether", "functions"));
+  await fs4.ensureDir(path4.join(projectPath, "tether"));
+  await fs4.ensureDir(path4.join(projectPath, "tether", "functions"));
   const configPackage = template === "nuxt" ? "@tthr/vue" : template === "next" ? "@tthr/react" : template === "sveltekit" ? "@tthr/svelte" : "@tthr/client";
-  await fs3.writeFile(
-    path3.join(projectPath, "tether.config.ts"),
+  await fs4.writeFile(
+    path4.join(projectPath, "tether.config.ts"),
     `import { defineConfig } from '${configPackage}';
 
 export default defineConfig({
@@ -682,12 +743,12 @@ export default defineConfig({
   functions: './tether/functions',
 
   // Generated types output
-  output: './_generated',
+  output: './tether/_generated',
 });
 `
   );
-  await fs3.writeFile(
-    path3.join(projectPath, "tether", "schema.ts"),
+  await fs4.writeFile(
+    path4.join(projectPath, "tether", "schema.ts"),
     `import { defineSchema, text, integer, timestamp } from '@tthr/schema';
 
 export default defineSchema({
@@ -712,8 +773,8 @@ export default defineSchema({
 });
 `
   );
-  await fs3.writeFile(
-    path3.join(projectPath, "tether", "functions", "posts.ts"),
+  await fs4.writeFile(
+    path4.join(projectPath, "tether", "functions", "posts.ts"),
     `import { query, mutation, z } from '@tthr/server';
 
 // List all posts
@@ -798,8 +859,8 @@ export const remove = mutation({
 });
 `
   );
-  await fs3.writeFile(
-    path3.join(projectPath, "tether", "functions", "comments.ts"),
+  await fs4.writeFile(
+    path4.join(projectPath, "tether", "functions", "comments.ts"),
     `import { query, mutation, z } from '@tthr/server';
 
 // List all comments
@@ -871,27 +932,27 @@ export const remove = mutation({
 TETHER_PROJECT_ID=${projectId}
 TETHER_API_KEY=${apiKey}
 `;
-  const envPath = path3.join(projectPath, ".env");
-  if (await fs3.pathExists(envPath)) {
-    const existing = await fs3.readFile(envPath, "utf-8");
-    await fs3.writeFile(envPath, existing + "\n" + envContent);
+  const envPath = path4.join(projectPath, ".env");
+  if (await fs4.pathExists(envPath)) {
+    const existing = await fs4.readFile(envPath, "utf-8");
+    await fs4.writeFile(envPath, existing + "\n" + envContent);
   } else {
-    await fs3.writeFile(envPath, envContent);
+    await fs4.writeFile(envPath, envContent);
   }
-  const gitignorePath = path3.join(projectPath, ".gitignore");
+  const gitignorePath = path4.join(projectPath, ".gitignore");
   const tetherGitignore = `
 # Tether
 _generated/
 .env
 .env.local
 `;
-  if (await fs3.pathExists(gitignorePath)) {
-    const existing = await fs3.readFile(gitignorePath, "utf-8");
+  if (await fs4.pathExists(gitignorePath)) {
+    const existing = await fs4.readFile(gitignorePath, "utf-8");
     if (!existing.includes("_generated/")) {
-      await fs3.writeFile(gitignorePath, existing + tetherGitignore);
+      await fs4.writeFile(gitignorePath, existing + tetherGitignore);
     }
   } else {
-    await fs3.writeFile(gitignorePath, tetherGitignore.trim());
+    await fs4.writeFile(gitignorePath, tetherGitignore.trim());
   }
 }
 async function configureFramework(projectPath, template) {
@@ -904,9 +965,9 @@ async function configureFramework(projectPath, template) {
   }
 }
 async function configureNuxt(projectPath) {
-  const configPath = path3.join(projectPath, "nuxt.config.ts");
-  if (!await fs3.pathExists(configPath)) {
-    await fs3.writeFile(
+  const configPath = path4.join(projectPath, "nuxt.config.ts");
+  if (!await fs4.pathExists(configPath)) {
+    await fs4.writeFile(
       configPath,
       `// https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
@@ -924,7 +985,7 @@ export default defineNuxtConfig({
     );
     return;
   }
-  let config = await fs3.readFile(configPath, "utf-8");
+  let config = await fs4.readFile(configPath, "utf-8");
   if (config.includes("modules:")) {
     config = config.replace(
       /modules:\s*\[/,
@@ -951,11 +1012,11 @@ export default defineNuxtConfig({
 `
     );
   }
-  await fs3.writeFile(configPath, config);
+  await fs4.writeFile(configPath, config);
 }
 async function configureNext(projectPath) {
-  const providersPath = path3.join(projectPath, "src", "app", "providers.tsx");
-  await fs3.writeFile(
+  const providersPath = path4.join(projectPath, "src", "app", "providers.tsx");
+  await fs4.writeFile(
     providersPath,
     `'use client';
 
@@ -973,9 +1034,9 @@ export function Providers({ children }: { children: React.ReactNode }) {
 }
 `
   );
-  const layoutPath = path3.join(projectPath, "src", "app", "layout.tsx");
-  if (await fs3.pathExists(layoutPath)) {
-    let layout = await fs3.readFile(layoutPath, "utf-8");
+  const layoutPath = path4.join(projectPath, "src", "app", "layout.tsx");
+  if (await fs4.pathExists(layoutPath)) {
+    let layout = await fs4.readFile(layoutPath, "utf-8");
     if (!layout.includes("import { Providers }")) {
       layout = layout.replace(
         /^(import.*\n)+/m,
@@ -988,24 +1049,24 @@ export function Providers({ children }: { children: React.ReactNode }) {
         "$1<Providers>$2</Providers>$3"
       );
     }
-    await fs3.writeFile(layoutPath, layout);
+    await fs4.writeFile(layoutPath, layout);
   }
-  const envLocalPath = path3.join(projectPath, ".env.local");
+  const envLocalPath = path4.join(projectPath, ".env.local");
   const nextEnvContent = `# Tether Configuration (client-side)
 NEXT_PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 `;
-  if (await fs3.pathExists(envLocalPath)) {
-    const existing = await fs3.readFile(envLocalPath, "utf-8");
-    await fs3.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
+  if (await fs4.pathExists(envLocalPath)) {
+    const existing = await fs4.readFile(envLocalPath, "utf-8");
+    await fs4.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
   } else {
-    await fs3.writeFile(envLocalPath, nextEnvContent);
+    await fs4.writeFile(envLocalPath, nextEnvContent);
   }
 }
 async function configureSvelteKit(projectPath) {
-  const libPath = path3.join(projectPath, "src", "lib");
-  await fs3.ensureDir(libPath);
-  await fs3.writeFile(
-    path3.join(libPath, "tether.ts"),
+  const libPath = path4.join(projectPath, "src", "lib");
+  await fs4.ensureDir(libPath);
+  await fs4.writeFile(
+    path4.join(libPath, "tether.ts"),
     `import { createClient } from '@tthr/svelte';
 import { PUBLIC_TETHER_PROJECT_ID, PUBLIC_TETHER_URL } from '$env/static/public';
 
@@ -1015,14 +1076,14 @@ export const tether = createClient({
 });
 `
   );
-  const envPath = path3.join(projectPath, ".env");
+  const envPath = path4.join(projectPath, ".env");
   const svelteEnvContent = `# Tether Configuration (public)
 PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 `;
-  if (await fs3.pathExists(envPath)) {
-    const existing = await fs3.readFile(envPath, "utf-8");
+  if (await fs4.pathExists(envPath)) {
+    const existing = await fs4.readFile(envPath, "utf-8");
     if (!existing.includes("PUBLIC_TETHER_")) {
-      await fs3.writeFile(envPath, existing + "\n" + svelteEnvContent);
+      await fs4.writeFile(envPath, existing + "\n" + svelteEnvContent);
     }
   }
 }
@@ -1077,10 +1138,10 @@ async function installTetherPackages(projectPath, template, packageManager) {
 }
 async function createDemoPage(projectPath, template) {
   if (template === "nuxt") {
-    const nuxt4AppVuePath = path3.join(projectPath, "app", "app.vue");
-    const nuxt3AppVuePath = path3.join(projectPath, "app.vue");
-    const appVuePath = await fs3.pathExists(path3.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
-    await fs3.writeFile(
+    const nuxt4AppVuePath = path4.join(projectPath, "app", "app.vue");
+    const nuxt3AppVuePath = path4.join(projectPath, "app.vue");
+    const appVuePath = await fs4.pathExists(path4.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
+    await fs4.writeFile(
       appVuePath,
       `<template>
   <TetherWelcome />
@@ -1088,8 +1149,8 @@ async function createDemoPage(projectPath, template) {
 `
     );
   } else if (template === "next") {
-    const pagePath = path3.join(projectPath, "src", "app", "page.tsx");
-    await fs3.writeFile(
+    const pagePath = path4.join(projectPath, "src", "app", "page.tsx");
+    await fs4.writeFile(
       pagePath,
       `'use client';
 
@@ -1199,8 +1260,8 @@ export default function Home() {
 `
     );
   } else if (template === "sveltekit") {
-    const pagePath = path3.join(projectPath, "src", "routes", "+page.svelte");
-    await fs3.writeFile(
+    const pagePath = path4.join(projectPath, "src", "routes", "+page.svelte");
+    await fs4.writeFile(
       pagePath,
       `<script lang="ts">
   import { onMount } from 'svelte';
@@ -1468,22 +1529,24 @@ export default function Home() {
 // src/commands/dev.ts
 import chalk4 from "chalk";
 import ora3 from "ora";
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 async function devCommand(options) {
   await requireAuth();
-  const configPath = path4.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs4.pathExists(configPath)) {
+  const configPath = path5.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs5.pathExists(configPath)) {
     console.log(chalk4.red("\nError: Not a Tether project"));
     console.log(chalk4.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
+  const config = await loadConfig();
+  const port = options.port || String(config.dev?.port || 3001);
   console.log(chalk4.bold("\n\u26A1 Starting Tether development server\n"));
   const spinner = ora3("Starting server...").start();
   try {
-    spinner.succeed(`Development server running on port ${options.port}`);
-    console.log("\n" + chalk4.cyan(`  Local:   http://localhost:${options.port}`));
-    console.log(chalk4.cyan(`  WebSocket: ws://localhost:${options.port}/ws
+    spinner.succeed(`Development server running on port ${port}`);
+    console.log("\n" + chalk4.cyan(`  Local:   http://localhost:${port}`));
+    console.log(chalk4.cyan(`  WebSocket: ws://localhost:${port}/ws
 `));
     console.log(chalk4.dim("  Press Ctrl+C to stop\n"));
     process.on("SIGINT", () => {
@@ -1502,12 +1565,133 @@ async function devCommand(options) {
 // src/commands/generate.ts
 import chalk5 from "chalk";
 import ora4 from "ora";
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
+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()") && !modifiers.includes(".primaryKey()");
+    const primaryKey = modifiers.includes(".primaryKey()");
+    columns.push({
+      name,
+      type: schemaTypeToTS(schemaType),
+      nullable,
+      primaryKey
+    });
+  }
+  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");
+}
+function generateApiFile(functionsDir, tables) {
+  const lines = [
+    "// Auto-generated by Tether CLI - do not edit manually",
+    `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "import { createApiProxy } from '@tthr/client';",
+    "import type { Schema } from './db';",
+    "",
+    "// API type placeholder - will be populated based on your functions",
+    "// eslint-disable-next-line @typescript-eslint/no-empty-object-type",
+    "export interface Api {}",
+    "",
+    "// API client proxy - will be populated by the Tether runtime",
+    "export const api: Api = createApiProxy<Api>();",
+    ""
+  ];
+  return lines.join("\n");
+}
 async function generateCommand() {
   await requireAuth();
-  const configPath = path5.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs5.pathExists(configPath)) {
+  const configPath = path6.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs6.pathExists(configPath)) {
     console.log(chalk5.red("\nError: Not a Tether project"));
     console.log(chalk5.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
@@ -1515,85 +1699,51 @@ async function generateCommand() {
   console.log(chalk5.bold("\n\u26A1 Generating types from schema\n"));
   const spinner = ora4("Reading schema...").start();
   try {
-    const schemaPath = path5.resolve(process.cwd(), "tether", "schema.ts");
-    const outputDir = path5.resolve(process.cwd(), "_generated");
-    if (!await fs5.pathExists(schemaPath)) {
+    const config = await loadConfig();
+    const schemaPath = resolvePath(config.schema);
+    const outputDir = resolvePath(config.output);
+    const functionsDir = resolvePath(config.functions);
+    if (!await fs6.pathExists(schemaPath)) {
       spinner.fail("Schema file not found");
       console.log(chalk5.dim(`Expected: ${schemaPath}
 `));
       process.exit(1);
     }
-    spinner.text = "Generating types...";
-    await fs5.ensureDir(outputDir);
-    await fs5.writeFile(
-      path5.join(outputDir, "db.ts"),
-      `// Auto-generated by Tether CLI - do not edit manually
-// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-import type { TetherDatabase } from '@tthr/client';
-
-export interface Post {
-  id: string;
-  title: string;
-  content: string | null;
-  authorId: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface Comment {
-  id: string;
-  postId: string;
-  content: string;
-  authorId: string;
-  createdAt: string;
-}
-
-export interface Schema {
-  posts: Post;
-  comments: Comment;
-}
-
-// Database client with typed tables
-export declare const db: TetherDatabase<Schema>;
-`
+    const schemaSource = await fs6.readFile(schemaPath, "utf-8");
+    const tables = parseSchemaFile(schemaSource);
+    if (tables.length === 0) {
+      spinner.warn("No tables found in schema");
+      console.log(chalk5.dim("  Make sure your schema uses defineSchema({ ... })\n"));
+      return;
+    }
+    spinner.text = `Generating types for ${tables.length} table(s)...`;
+    await fs6.ensureDir(outputDir);
+    await fs6.writeFile(
+      path6.join(outputDir, "db.ts"),
+      generateDbFile(tables)
     );
-    await fs5.writeFile(
-      path5.join(outputDir, "api.ts"),
-      `// Auto-generated by Tether CLI - do not edit manually
-// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-import type { TetherClient } from '@tthr/client';
-import type { Schema } from './db';
-
-export interface PostsApi {
-  list: (args?: { limit?: number }) => Promise<Schema['posts'][]>;
-  get: (args: { id: string }) => Promise<Schema['posts'] | null>;
-  create: (args: { title: string; content?: string }) => Promise<{ id: string }>;
-  update: (args: { id: string; title?: string; content?: string }) => Promise<void>;
-  remove: (args: { id: string }) => Promise<void>;
-}
-
-export interface Api {
-  posts: PostsApi;
-}
-
-// Typed Tether client
-export declare const tether: TetherClient<Api>;
-`
+    await fs6.writeFile(
+      path6.join(outputDir, "api.ts"),
+      generateApiFile(functionsDir, tables)
     );
-    await fs5.writeFile(
-      path5.join(outputDir, "index.ts"),
+    await fs6.writeFile(
+      path6.join(outputDir, "index.ts"),
       `// Auto-generated by Tether CLI - do not edit manually
 export * from './db';
 export * from './api';
 `
     );
-    spinner.succeed("Types generated");
+    spinner.succeed(`Types generated for ${tables.length} table(s)`);
+    console.log("\n" + chalk5.green("\u2713") + " Tables:");
+    for (const table of tables) {
+      console.log(chalk5.dim(`  - ${table.name} (${table.columns.length} columns)`));
+    }
+    const relativeOutput = path6.relative(process.cwd(), outputDir);
     console.log("\n" + chalk5.green("\u2713") + " Generated files:");
-    console.log(chalk5.dim("  _generated/db.ts"));
-    console.log(chalk5.dim("  _generated/api.ts"));
-    console.log(chalk5.dim("  _generated/index.ts\n"));
+    console.log(chalk5.dim(`  ${relativeOutput}/db.ts`));
+    console.log(chalk5.dim(`  ${relativeOutput}/api.ts`));
+    console.log(chalk5.dim(`  ${relativeOutput}/index.ts
+`));
   } catch (error) {
     spinner.fail("Failed to generate types");
     console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
@@ -1604,18 +1754,18 @@ export * from './api';
 // src/commands/migrate.ts
 import chalk6 from "chalk";
 import ora5 from "ora";
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path7 from "path";
 import prompts2 from "prompts";
 async function migrateCommand(action, options) {
   await requireAuth();
-  const configPath = path6.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs6.pathExists(configPath)) {
+  const configPath = path7.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs7.pathExists(configPath)) {
     console.log(chalk6.red("\nError: Not a Tether project"));
     console.log(chalk6.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
-  const migrationsDir = path6.resolve(process.cwd(), "tether", "migrations");
+  const migrationsDir = path7.resolve(process.cwd(), "tether", "migrations");
   switch (action) {
     case "create":
       await createMigration(migrationsDir, options.name);
@@ -1650,11 +1800,11 @@ async function createMigration(migrationsDir, name) {
   }
   const spinner = ora5("Creating migration...").start();
   try {
-    await fs6.ensureDir(migrationsDir);
+    await fs7.ensureDir(migrationsDir);
     const timestamp = Date.now();
     const filename = `${timestamp}_${migrationName}.sql`;
-    const filepath = path6.join(migrationsDir, filename);
-    await fs6.writeFile(
+    const filepath = path7.join(migrationsDir, filename);
+    await fs7.writeFile(
       filepath,
       `-- Migration: ${migrationName}
 -- Created at: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -1690,12 +1840,12 @@ async function runMigrations(migrationsDir, direction) {
 `));
   const spinner = ora5("Checking migrations...").start();
   try {
-    if (!await fs6.pathExists(migrationsDir)) {
+    if (!await fs7.pathExists(migrationsDir)) {
       spinner.info("No migrations directory found");
       console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
-    const files = await fs6.readdir(migrationsDir);
+    const files = await fs7.readdir(migrationsDir);
     const migrations = files.filter((f) => f.endsWith(".sql")).sort((a, b) => direction === "up" ? a.localeCompare(b) : b.localeCompare(a));
     if (migrations.length === 0) {
       spinner.info("No migrations found");
@@ -1718,12 +1868,12 @@ async function runMigrations(migrationsDir, direction) {
 async function showStatus(migrationsDir) {
   console.log(chalk6.bold("\n\u26A1 Migration status\n"));
   try {
-    if (!await fs6.pathExists(migrationsDir)) {
+    if (!await fs7.pathExists(migrationsDir)) {
       console.log(chalk6.dim("No migrations directory found"));
       console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
-    const files = await fs6.readdir(migrationsDir);
+    const files = await fs7.readdir(migrationsDir);
     const migrations = files.filter((f) => f.endsWith(".sql")).sort();
     if (migrations.length === 0) {
       console.log(chalk6.dim("No migrations found"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tthr",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Tether CLI - project scaffolding, migrations, and deployment",
   "type": "module",
   "bin": {