tthr 0.0.41 → 0.0.44

package/dist/chunk-2IDRK6NG.js

@@ -0,0 +1,416 @@
+// 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
+};

package/dist/chunk-TU5LOAQ5.js

@@ -0,0 +1,418 @@
+// 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} {`);
+    lines.push("  _id: string;");
+    for (const col of table.columns) {
+      const typeStr = col.nullable ? `${col.type} | null` : col.type;
+      lines.push(`  ${col.name}: ${typeStr};`);
+    }
+    lines.push("  _createdAt: string;");
+    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
+};

package/dist/generate-F7VDD6JW.js

@@ -0,0 +1,8 @@
+import {
+  generateCommand,
+  generateTypes
+} from "./chunk-2IDRK6NG.js";
+export {
+  generateCommand,
+  generateTypes
+};

package/dist/generate-HRIVNCH3.js

@@ -0,0 +1,8 @@
+import {
+  generateCommand,
+  generateTypes
+} from "./chunk-TU5LOAQ5.js";
+export {
+  generateCommand,
+  generateTypes
+};

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   requireAuth,
   resolvePath,
   saveCredentials
-} from "./chunk-LXODXQ5V.js";
+} from "./chunk-TU5LOAQ5.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -98,8 +98,7 @@ async function deploySchemaToServer(projectId, token, schemaPath, environment, d
       return;
     }
     spinner.text = "Deploying schema...";
-    const envPath = environment !== "production" ? `/env/${environment}` : "";
-    const schemaUrl = `${API_URL}/projects/${projectId}${envPath}/deploy/schema`;
+    const schemaUrl = `${API_URL}/projects/${projectId}/env/${environment}/deploy/schema`;
     console.log(chalk.dim(`
   URL: ${schemaUrl}`));
     const requestBody = {
@@ -179,8 +178,7 @@ async function deployFunctionsToServer(projectId, token, functionsDir, environme
       return;
     }
     spinner.text = "Deploying functions...";
-    const envPath = environment !== "production" ? `/env/${environment}` : "";
-    const functionsUrl = `${API_URL}/projects/${projectId}${envPath}/deploy/functions`;
+    const functionsUrl = `${API_URL}/projects/${projectId}/env/${environment}/deploy/functions`;
     console.log(chalk.dim(`
   URL: ${functionsUrl}`));
     const response = await fetch(functionsUrl, {
@@ -279,9 +277,18 @@ function parseSchema(source) {
       const colName = colMatch[1];
       const colType = colMatch[2];
       const modifiers = colMatch[3];
+      if (modifiers.includes(".primaryKey()")) {
+        throw new Error(
+          `Cannot use .primaryKey() on column "${colName}" in table "${tableName}". Tether automatically adds a "_id" primary key column to all tables. Remove the .primaryKey() modifier from your schema.`
+        );
+      }
+      if (colName === "id") {
+        throw new Error(
+          `Cannot use column name "id" in table "${tableName}". Tether automatically adds a "_id" primary key column. Use a different column name or rely on the system-provided "_id".`
+        );
+      }
       columns[colName] = {
         type: colType,
-        primaryKey: modifiers.includes(".primaryKey()"),
         notNull: modifiers.includes(".notNull()"),
         unique: modifiers.includes(".unique()"),
         hasDefault: modifiers.includes(".default("),
@@ -308,6 +315,9 @@ function getColumnSqlType(type) {
       return "INTEGER";
     case "json":
       return "JSON";
+    case "asset":
+      return "TEXT";
+    // Stores asset ID (UUID reference to _tether_files)
     default:
       return "TEXT";
   }
@@ -315,10 +325,8 @@ function getColumnSqlType(type) {
 function buildColumnSql(colName, def, forAlterTable = false) {
   const sqlType = getColumnSqlType(def.type);
   let colSql = `${colName} ${sqlType}`;
-  const addingPrimaryKey = def.primaryKey && !forAlterTable;
-  if (addingPrimaryKey) colSql += " PRIMARY KEY";
   if (def.notNull && !forAlterTable) colSql += " NOT NULL";
-  if (def.unique && !addingPrimaryKey) colSql += " UNIQUE";
+  if (def.unique) colSql += " UNIQUE";
   if (def.hasDefault && def.type === "timestamp" && !forAlterTable) {
     colSql += " DEFAULT (datetime('now'))";
   }
@@ -703,40 +711,28 @@ export default defineConfig({
 
   // API endpoint (defaults to Tether Cloud)
   url: process.env.TETHER_URL || 'https://tether-api.strands.gg',
-
-  // Schema file location
-  schema: './tether/schema.ts',
-
-  // Functions directory
-  functions: './tether/functions',
-
-  // Generated types output
-  output: './tether/_generated',
 });
 `
   );
   await fs2.writeFile(
     path2.join(projectPath, "tether", "schema.ts"),
-    `import { defineSchema, text, integer, timestamp } from '@tthr/schema';
+    `import { defineSchema, text, timestamp } from '@tthr/schema';
 
 export default defineSchema({
   // Example: posts table
+  // Note: _id and _createdAt are automatically added by Tether
   posts: {
-    id: text().primaryKey(),
     title: text().notNull(),
     content: text(),
     authorId: text().notNull(),
-    createdAt: timestamp().notNull().default('now'),
     updatedAt: timestamp().notNull().default('now'),
   },
 
   // Example: comments table
   comments: {
-    id: text().primaryKey(),
-    postId: text().notNull().references('posts.id'),
+    postId: text().notNull().references('posts._id'),
     content: text().notNull(),
     authorId: text().notNull(),
-    createdAt: timestamp().notNull().default('now'),
   },
 });
 `
@@ -752,59 +748,55 @@ export const list = query({
   }),
   handler: async ({ args, db }) => {
     return db.posts.findMany({
-      orderBy: { createdAt: 'desc' },
+      orderBy: { _createdAt: 'desc' },
       limit: args.limit,
     });
   },
 });
 
-// Get a single post
+// Get a single post by _id
 export const get = query({
   args: z.object({
-    id: z.string(),
+    _id: z.string(),
   }),
   handler: async ({ args, db }) => {
     return db.posts.findUnique({
-      where: { id: args.id },
+      where: { _id: args._id },
     });
   },
 });
 
 // Create a new post
+// Note: _id and _createdAt are automatically added by Tether
 export const create = mutation({
   args: z.object({
     title: z.string().min(1),
     content: z.string().optional(),
   }),
   handler: async ({ args, ctx, db }) => {
-    const id = crypto.randomUUID();
-    const now = new Date().toISOString();
-
-    await db.posts.create({
+    const post = await db.posts.create({
       data: {
-        id,
         title: args.title,
         content: args.content ?? '',
         authorId: ctx.userId ?? 'anonymous',
-        createdAt: now,
-        updatedAt: now,
+        updatedAt: new Date().toISOString(),
       },
     });
 
-    return { id };
+    return { _id: post._id };
   },
 });
 
 // Update a post
 export const update = mutation({
   args: z.object({
-    id: z.string(),
+    _id: z.string(),
     title: z.string().min(1).optional(),
     content: z.string().optional(),
   }),
   handler: async ({ args, db }) => {
     await db.posts.update({
-      where: { id: args.id },
+      where: { _id: args._id },
       data: {
         ...(args.title && { title: args.title }),
         ...(args.content !== undefined && { content: args.content }),
@@ -817,11 +809,11 @@ export const update = mutation({
 // Delete a post
 export const remove = mutation({
   args: z.object({
-    id: z.string(),
+    _id: z.string(),
   }),
   handler: async ({ args, db }) => {
     await db.posts.delete({
-      where: { id: args.id },
+      where: { _id: args._id },
     });
   },
 });
@@ -847,7 +839,7 @@ export const list = query({
   }),
   handler: async ({ args, db }) => {
     return db.comments.findMany({
-      orderBy: { createdAt: 'desc' },
+      orderBy: { _createdAt: 'desc' },
       limit: args.limit,
     });
   },
@@ -862,44 +854,40 @@ export const listByPost = query({
   handler: async ({ args, db }) => {
     return db.comments.findMany({
       where: { postId: args.postId },
-      orderBy: { createdAt: 'asc' },
+      orderBy: { _createdAt: 'asc' },
       limit: args.limit,
     });
   },
 });
 
 // Create a new comment
+// Note: _id and _createdAt are automatically added by Tether
 export const create = mutation({
   args: z.object({
     postId: z.string(),
     content: z.string().min(1),
   }),
   handler: async ({ args, ctx, db }) => {
-    const id = crypto.randomUUID();
-    const now = new Date().toISOString();
-
-    await db.comments.create({
+    const comment = await db.comments.create({
       data: {
-        id,
         postId: args.postId,
         content: args.content,
         authorId: ctx.userId ?? 'anonymous',
-        createdAt: now,
       },
     });
 
-    return { id };
+    return { _id: comment._id };
   },
 });
 
 // Delete a comment
 export const remove = mutation({
   args: z.object({
-    id: z.string(),
+    _id: z.string(),
   }),
   handler: async ({ args, db }) => {
     await db.comments.delete({
-      where: { id: args.id },
+      where: { _id: args._id },
     });
   },
 });
@@ -1522,7 +1510,7 @@ async function runGenerate(spinner) {
   }
   isGenerating = true;
   try {
-    const { generateTypes } = await import("./generate-YQ4QRPXF.js");
+    const { generateTypes } = await import("./generate-HRIVNCH3.js");
     spinner.text = "Regenerating types...";
     await generateTypes({ silent: true });
     spinner.succeed("Types regenerated");
@@ -1703,7 +1691,7 @@ async function devCommand(options) {
       }
     }
     spinner.text = "Generating types...";
-    const { generateTypes } = await import("./generate-YQ4QRPXF.js");
+    const { generateTypes } = await import("./generate-HRIVNCH3.js");
     await generateTypes({ silent: true });
     spinner.succeed("Types generated");
     spinner.start("Setting up file watchers...");

package/package.json

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