supatypes 1.0.0

package/README.md

@@ -0,0 +1,108 @@
+# supatypes
+
+Generate TypeScript types from a remote Supabase PostgreSQL database via SSH.
+
+Connects to your server, dumps the database schema, parses tables/views/functions, and generates a fully typed `database.types.ts` file — all in one command.
+
+## Features
+
+- Generates types for **tables**, **views**, and **RPC functions**
+- Handles PostgreSQL **array types** (`TEXT[]` → `string[]`)
+- Multi-word types (`character varying`, `double precision`, `timestamp with time zone`)
+- Supports SSH key and password authentication
+- Uploads the generator to the server, runs it there, downloads the result, and cleans up
+- Config file so you only set up once per project
+
+## Install
+
+```bash
+# Global
+npm install -g supatypes
+
+# Per project
+npm install --save-dev supatypes
+```
+
+## Quick start
+
+```bash
+# 1. Create config file
+npx supatypes init
+
+# 2. Generate types
+npx supatypes generate
+```
+
+## Configuration
+
+Running `init` creates a `.supatypes.json` file:
+
+```json
+{
+  "server": "root@1.2.3.4",
+  "sshKey": "~/.ssh/id_rsa",
+  "dbContainer": "supabase-db-abc123",
+  "output": "./database.types.ts"
+}
+```
+
+### Options
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `server` | Yes | SSH connection string (e.g. `root@1.2.3.4`) |
+| `sshKey` | One of these | Path to SSH private key |
+| `sshPassword` | One of these | SSH password (uses `sshpass`) |
+| `dbContainer` | Yes | Docker container name for the Supabase PostgreSQL instance |
+| `output` | No | Output file path (default: `./database.types.ts`) |
+
+The config file is automatically added to `.gitignore` since it may contain server credentials.
+
+## CLI
+
+```bash
+# Generate with default config
+npx supatypes generate
+
+# Custom config file
+npx supatypes generate -c ./config/typegen.json
+
+# Override output path
+npx supatypes generate -o ./src/types/database.ts
+
+# Preview what would happen
+npx supatypes generate --dry-run
+```
+
+## How it works
+
+1. Reads your `.supatypes.json` config
+2. Uploads a self-contained generator script to the server via SCP
+3. SSHs in and runs it — the script calls `pg_dump` on the Docker container
+4. Parses the SQL schema into TypeScript types (tables, views, functions)
+5. Downloads the generated file to your chosen output path
+6. Cleans up all remote files
+
+The generator runs on the server because it needs direct access to the Docker container running PostgreSQL. No ports need to be exposed beyond SSH.
+
+## Type mapping
+
+| PostgreSQL | TypeScript |
+|-----------|-----------|
+| `text`, `varchar`, `char`, `uuid` | `string` |
+| `integer`, `bigint`, `serial`, `real`, `numeric` | `number` |
+| `boolean` | `boolean` |
+| `jsonb`, `json` | `Json` |
+| `timestamptz`, `date`, `time` | `string` |
+| `text[]`, `integer[]`, etc. | `string[]`, `number[]`, etc. |
+
+## Requirements
+
+- Node.js >= 18
+- SSH access to the server running Supabase
+- `sshpass` installed locally (only if using password auth)
+- Docker must be accessible on the server (the SSH user needs docker permissions)
+
+## Licence
+
+MIT

package/bin/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+import { init } from "../lib/init.js";
+import { generate } from "../lib/generate.js";
+
+const HELP = `
+supatypes — Generate TypeScript types from a remote Supabase database
+
+Usage:
+  supatypes init                  Create a config file in the current directory
+  supatypes generate [options]    Generate types from the remote database
+  supatypes help                  Show this help message
+
+Options (generate):
+  -c, --config <path>    Path to config file (default: ./.supatypes.json)
+  -o, --output <path>    Override output file path from config
+  --dry-run              Show what would be done without executing
+
+Config file (.supatypes.json):
+  {
+    "server": "root@1.2.3.4",
+    "sshKey": "~/.ssh/id_rsa",
+    "dbContainer": "supabase-db-abc123",
+    "output": "./database.types.ts"
+  }
+
+  You can also use a password instead of an SSH key:
+  {
+    "server": "root@1.2.3.4",
+    "sshPassword": "your-password",
+    "dbContainer": "supabase-db-abc123",
+    "output": "./database.types.ts"
+  }
+`;
+
+const command = process.argv[2];
+
+if (!command || command === "help" || command === "--help" || command === "-h") {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (command === "init") {
+  await init();
+  process.exit(0);
+}
+
+if (command === "generate") {
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: {
+      config: { type: "string", short: "c", default: "./.supatypes.json" },
+      output: { type: "string", short: "o" },
+      "dry-run": { type: "boolean", default: false },
+    },
+    strict: false,
+  });
+
+  await generate({
+    configPath: values.config,
+    outputOverride: values.output,
+    dryRun: values["dry-run"],
+  });
+  process.exit(0);
+}
+
+console.error(`Unknown command: ${command}`);
+console.log('Run "supatypes help" for usage.');
+process.exit(1);

package/lib/generate.js

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REMOTE_SCRIPT = path.join(__dirname, "remote-generator.js");
+const REMOTE_DIR = "/tmp/supatypes";
+const REMOTE_SCRIPT_PATH = `${REMOTE_DIR}/generator.js`;
+const REMOTE_OUTPUT_PATH = `${REMOTE_DIR}/output.ts`;
+
+export async function generate({ configPath, outputOverride, dryRun }) {
+  // Load config
+  const resolvedConfig = path.resolve(configPath);
+  if (!fs.existsSync(resolvedConfig)) {
+    console.error(`Config file not found: ${resolvedConfig}`);
+    console.error('Run "supatypes init" to create one.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(resolvedConfig, "utf8"));
+  const { server, dbContainer } = config;
+  const sshKey = config.sshKey ? expandHome(config.sshKey) : null;
+  const sshPassword = config.sshPassword || null;
+  const output = path.resolve(outputOverride || config.output || "./database.types.ts");
+
+  // Validate
+  if (!server) { console.error("Missing 'server' in config"); process.exit(1); }
+  if (!dbContainer) { console.error("Missing 'dbContainer' in config"); process.exit(1); }
+
+  if (sshKey && !fs.existsSync(sshKey)) {
+    console.error(`SSH key not found: ${sshKey}`);
+    process.exit(1);
+  }
+
+  const sshBase = buildSshBase(server, sshKey, sshPassword);
+  const scpBase = buildScpBase(server, sshKey, sshPassword);
+
+  if (dryRun) {
+    console.log("Dry run — would execute:");
+    console.log(`  1. Create ${REMOTE_DIR} on ${server}`);
+    console.log(`  2. Upload generator script to ${REMOTE_SCRIPT_PATH}`);
+    console.log(`  3. Run: node ${REMOTE_SCRIPT_PATH} ${dbContainer} ${REMOTE_OUTPUT_PATH}`);
+    console.log(`  4. Download ${REMOTE_OUTPUT_PATH} to ${output}`);
+    console.log(`  5. Clean up ${REMOTE_DIR} on server`);
+    return;
+  }
+
+  console.log("supatypes\n");
+  console.log(`  Server:    ${server}`);
+  console.log(`  Container: ${dbContainer}`);
+  console.log(`  Output:    ${output}`);
+  console.log(`  Auth:      ${sshKey ? "SSH key" : "password"}\n`);
+
+  try {
+    // Step 1: Create remote directory
+    process.stdout.write("Creating remote workspace...");
+    ssh(sshBase, `mkdir -p ${REMOTE_DIR}`);
+    console.log(" done");
+
+    // Step 2: Upload generator script
+    process.stdout.write("Uploading generator...");
+    scp(scpBase, REMOTE_SCRIPT, `${server.split("@").length > 1 ? server : `root@${server}`}:${REMOTE_SCRIPT_PATH}`);
+    console.log(" done");
+
+    // Step 3: Run generator on server
+    process.stdout.write("Generating types...");
+    const remoteOutput = ssh(
+      sshBase,
+      `cd ${REMOTE_DIR} && node generator.js ${dbContainer} ${REMOTE_OUTPUT_PATH}`
+    );
+    console.log(" done");
+
+    // Parse stats from output
+    const statsMatch = remoteOutput.match(/__STATS__(.+)/);
+    if (statsMatch) {
+      const stats = JSON.parse(statsMatch[1]);
+      console.log(`\n  Tables:    ${stats.tables}`);
+      console.log(`  Views:     ${stats.views}`);
+      console.log(`  Functions: ${stats.functions}`);
+    }
+
+    // Step 4: Download result
+    process.stdout.write("\nDownloading types...");
+    const outputDir = path.dirname(output);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    scp(scpBase, `${server.split("@").length > 1 ? server : `root@${server}`}:${REMOTE_OUTPUT_PATH}`, output);
+    console.log(" done");
+
+    // Step 5: Clean up
+    process.stdout.write("Cleaning up remote files...");
+    ssh(sshBase, `rm -rf ${REMOTE_DIR}`);
+    console.log(" done");
+
+    const fileSize = fs.statSync(output).size;
+    console.log(`\nTypes saved to ${output} (${formatBytes(fileSize)})`);
+  } catch (err) {
+    console.error(`\n\nFailed: ${err.message}`);
+
+    // Try to clean up even on failure
+    try {
+      ssh(sshBase, `rm -rf ${REMOTE_DIR}`);
+    } catch {
+      // ignore cleanup errors
+    }
+
+    process.exit(1);
+  }
+}
+
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return path.join(process.env.HOME || process.env.USERPROFILE || "", p.slice(2));
+  }
+  return p;
+}
+
+function buildSshBase(server, sshKey, sshPassword) {
+  const opts = ["-o", "StrictHostKeyChecking=accept-new", "-o", "ConnectTimeout=10"];
+
+  if (sshPassword) {
+    // Use sshpass for password-based auth
+    return ["sshpass", "-p", sshPassword, "ssh", ...opts, server];
+  }
+
+  if (sshKey) {
+    return ["ssh", "-i", sshKey, ...opts, server];
+  }
+
+  // Default: let SSH use its default key
+  return ["ssh", ...opts, server];
+}
+
+function buildScpBase(server, sshKey, sshPassword) {
+  const opts = ["-o", "StrictHostKeyChecking=accept-new", "-o", "ConnectTimeout=10"];
+
+  if (sshPassword) {
+    return ["sshpass", "-p", sshPassword, "scp", ...opts];
+  }
+
+  if (sshKey) {
+    return ["scp", "-i", sshKey, ...opts];
+  }
+
+  return ["scp", ...opts];
+}
+
+function ssh(base, command) {
+  const cmd = [...base, command].map(shellEscape).join(" ");
+  return execSync(cmd, { encoding: "utf8", maxBuffer: 50 * 1024 * 1024 });
+}
+
+function scp(base, src, dest) {
+  const cmd = [...base, src, dest].map(shellEscape).join(" ");
+  execSync(cmd, { encoding: "utf8" });
+}
+
+function shellEscape(arg) {
+  // Don't escape if it looks safe
+  if (/^[a-zA-Z0-9_./:@~=-]+$/.test(arg)) return arg;
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/lib/init.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+const CONFIG_FILE = ".supatypes.json";
+
+function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+export async function init() {
+  const configPath = path.resolve(CONFIG_FILE);
+
+  if (fs.existsSync(configPath)) {
+    console.log(`Config file already exists: ${configPath}`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const overwrite = await ask(rl, "Overwrite? (y/N)", "N");
+    rl.close();
+    if (overwrite.toLowerCase() !== "y") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log("\nSupaTypes — Configuration\n");
+
+  const server = await ask(rl, "SSH server (e.g. root@1.2.3.4)", "");
+  const authMethod = await ask(rl, "Auth method: key or password?", "key");
+
+  let sshKey = "";
+  let sshPassword = "";
+
+  if (authMethod === "password") {
+    sshPassword = await ask(rl, "SSH password", "");
+  } else {
+    sshKey = await ask(rl, "SSH key path", "~/.ssh/id_rsa");
+  }
+
+  const dbContainer = await ask(rl, "Docker container name (e.g. supabase-db-abc123)", "");
+  const output = await ask(rl, "Output file path", "./database.types.ts");
+
+  rl.close();
+
+  const config = { server, dbContainer, output };
+
+  if (sshKey) config.sshKey = sshKey;
+  if (sshPassword) config.sshPassword = sshPassword;
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+
+  console.log(`\nConfig saved to ${configPath}`);
+  console.log('Run "supatypes generate" to generate types.\n');
+
+  // Add to .gitignore if it exists
+  const gitignorePath = path.resolve(".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, "utf8");
+    if (!content.includes(CONFIG_FILE)) {
+      fs.appendFileSync(gitignorePath, `\n# SupaTypes config (contains server credentials)\n${CONFIG_FILE}\n`);
+      console.log(`Added ${CONFIG_FILE} to .gitignore`);
+    }
+  }
+}

package/lib/remote-generator.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+
+// ============================================
+// Remote Generator Script
+// This file is uploaded to the server and executed there.
+// It dumps the PostgreSQL schema and generates TypeScript types.
+// ============================================
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+
+const DB_CONTAINER = process.argv[2];
+const OUTPUT_FILE = process.argv[3] || "/tmp/supatypes-output.ts";
+
+if (!DB_CONTAINER) {
+  console.error("Usage: node remote-generator.js <db_container> [output_file]");
+  process.exit(1);
+}
+
+// Step 1: Dump schema
+const schema = execSync(
+  `docker exec ${DB_CONTAINER} pg_dump -U postgres -d postgres --schema-only --schema=public`,
+  { encoding: "utf8", maxBuffer: 50 * 1024 * 1024 }
+);
+
+// Step 2: Parse tables
+const tables = {};
+const tableRegex = /CREATE TABLE (?:public\.)?(\w+) \(([\s\S]*?)\);/g;
+let match;
+
+while ((match = tableRegex.exec(schema)) !== null) {
+  const tableName = match[1];
+  const columnDefs = match[2];
+  const columns = [];
+  const columnLines = columnDefs.split(",\n").map((l) => l.trim());
+
+  for (const line of columnLines) {
+    if (line.startsWith("CONSTRAINT") || line.startsWith("CHECK")) continue;
+
+    const colMatch = line.match(
+      /^"?(\w+)"?\s+((?:character varying|double precision|timestamp with(?:out)? time zone|\w+)(?:\[\])?)(?:\s+(.*))?/
+    );
+    if (colMatch) {
+      const [, name, type, constraints = ""] = colMatch;
+      columns.push({
+        name,
+        type: mapPostgresType(type),
+        nullable: !constraints.includes("NOT NULL"),
+        hasDefault: constraints.includes("DEFAULT"),
+      });
+    }
+  }
+
+  if (columns.length > 0) {
+    tables[tableName] = columns;
+  }
+}
+
+// Step 3: Parse views
+const views = {};
+const fullViewRegex =
+  /CREATE (?:OR REPLACE )?(?:MATERIALIZED )?VIEW (?:public\.)?(\w+)\s+AS\s+([\s\S]*?);(?=\s*(?:CREATE|ALTER|--|$))/g;
+
+while ((match = fullViewRegex.exec(schema)) !== null) {
+  const viewName = match[1];
+  let viewDefinition = match[2];
+
+  if (viewDefinition.trim().toUpperCase().startsWith("WITH")) {
+    let depth = 0;
+    let inCTE = false;
+    for (let i = 0; i < viewDefinition.length; i++) {
+      const char = viewDefinition[i];
+      if (char === "(") { depth++; if (!inCTE && depth === 1) inCTE = true; }
+      else if (char === ")") { depth--; if (inCTE && depth === 0) inCTE = false; }
+
+      if (depth === 0 && !inCTE) {
+        const remaining = viewDefinition.substring(i).trim();
+        if (remaining.toUpperCase().startsWith("SELECT")) {
+          viewDefinition = viewDefinition.substring(i);
+          break;
+        }
+      }
+    }
+  }
+
+  const selectMatch = viewDefinition.match(/SELECT\s+([\s\S]*?)\s+FROM/i);
+  if (!selectMatch) continue;
+
+  const columns = [];
+  const columnExpressions = splitSelectColumns(selectMatch[1]);
+
+  for (const expr of columnExpressions) {
+    const trimmed = expr.trim();
+    if (!trimmed) continue;
+
+    let name;
+    const asMatch = trimmed.match(/\s+[Aa][Ss]\s+(\w+)\s*$/);
+    if (asMatch) {
+      name = asMatch[1];
+    } else {
+      const simpleMatch = trimmed.match(/^(\w+)\.(\w+)$/);
+      if (simpleMatch) name = simpleMatch[2];
+      else {
+        const lastWord = trimmed.match(/(\w+)\s*$/);
+        if (lastWord) name = lastWord[1];
+      }
+    }
+
+    if (name) {
+      let type = "string";
+      const lower = name.toLowerCase();
+      if (
+        lower.includes("count") || lower.includes("total") ||
+        lower.includes("points") || lower.includes("rank")
+      ) {
+        type = "number";
+      }
+      columns.push({ name, type, nullable: true });
+    }
+  }
+
+  const unique = Array.from(new Map(columns.map((c) => [c.name, c])).values());
+  if (unique.length > 0) views[viewName] = unique;
+}
+
+// Step 4: Parse functions (RPC)
+const functions = {};
+const funcRegex =
+  /CREATE (?:OR REPLACE )?FUNCTION (?:public\.)?(\w+)\(([^)]*)\)\s*\n?\s*RETURNS\s+(\w+)/g;
+
+while ((match = funcRegex.exec(schema)) !== null) {
+  const funcName = match[1];
+  const paramsStr = match[2].trim();
+  const returnType = match[3].toLowerCase();
+
+  if (returnType === "trigger") continue;
+  if (funcName === "update_updated_at_column") continue;
+
+  const params = [];
+  if (paramsStr) {
+    for (const part of paramsStr.split(",").map((p) => p.trim())) {
+      const cleaned = part.replace(/^(?:IN|OUT|INOUT)\s+/i, "");
+      const paramMatch = cleaned.match(/^(\w+)\s+(\w+(?:\[\])?)$/);
+      if (paramMatch) {
+        params.push({
+          name: paramMatch[1],
+          type: mapPostgresType(paramMatch[2]),
+        });
+      }
+    }
+  }
+
+  functions[funcName] = {
+    params,
+    returnType: returnType === "void" ? "undefined" : mapPostgresType(returnType),
+  };
+}
+
+// Step 5: Generate TypeScript output
+let output = `export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export type Database = {
+  __InternalSupabase: {
+    PostgrestVersion: "12.2.12"
+  }
+  public: {
+    Tables: {
+`;
+
+for (const [tableName, columns] of Object.entries(tables)) {
+  output += `      ${tableName}: {\n        Row: {\n`;
+  for (const col of columns) {
+    output += `          ${col.name}: ${col.type}${col.nullable ? " | null" : ""}\n`;
+  }
+  output += `        }\n        Insert: {\n`;
+  for (const col of columns) {
+    const opt = col.hasDefault || col.nullable ? "?" : "";
+    output += `          ${col.name}${opt}: ${col.type}${col.nullable ? " | null" : ""}\n`;
+  }
+  output += `        }\n        Update: {\n`;
+  for (const col of columns) {
+    output += `          ${col.name}?: ${col.type}${col.nullable ? " | null" : ""}\n`;
+  }
+  output += `        }\n        Relationships: []\n      }\n`;
+}
+
+output += `    }\n    Views: {\n`;
+
+for (const [viewName, columns] of Object.entries(views)) {
+  output += `      ${viewName}: {\n        Row: {\n`;
+  for (const col of columns) {
+    output += `          ${col.name}: ${col.type}${col.nullable ? " | null" : ""}\n`;
+  }
+  output += `        }\n        Insert: {\n          [_ in never]: never\n        }\n`;
+  output += `        Update: {\n          [_ in never]: never\n        }\n`;
+  output += `        Relationships: []\n      }\n`;
+}
+
+output += `    }\n    Functions: {\n`;
+
+const funcEntries = Object.entries(functions);
+if (funcEntries.length === 0) {
+  output += `      [_ in never]: never\n`;
+} else {
+  for (const [funcName, func] of funcEntries) {
+    output += `      ${funcName}: {\n        Args: {\n`;
+    for (const param of func.params) {
+      output += `          ${param.name}: ${param.type}\n`;
+    }
+    output += `        }\n        Returns: ${func.returnType}\n      }\n`;
+  }
+}
+
+output += `    }
+    Enums: {
+      [_ in never]: never
+    }
+    CompositeTypes: {
+      [_ in never]: never
+    }
+  }
+}
+
+type DatabaseWithoutInternals = Omit<Database, "__InternalSupabase">
+
+type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, "public">]
+
+export type Tables<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof (DefaultSchema["Tables"] & DefaultSchema["Views"])
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+        DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])
+    : never = never,
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+      DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof (DefaultSchema["Tables"] &
+        DefaultSchema["Views"])
+    ? (DefaultSchema["Tables"] &
+        DefaultSchema["Views"])[DefaultSchemaTableNameOrOptions] extends {
+        Row: infer R
+      }
+      ? R
+      : never
+    : never
+
+export type TablesInsert<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
+    : never = never,
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
+        Insert: infer I
+      }
+      ? I
+      : never
+    : never
+
+export type TablesUpdate<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
+    : never = never,
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
+        Update: infer U
+      }
+      ? U
+      : never
+    : never
+
+export type Enums<
+  DefaultSchemaEnumNameOrOptions extends
+    | keyof DefaultSchema["Enums"]
+    | { schema: keyof DatabaseWithoutInternals },
+  EnumName extends DefaultSchemaEnumNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"]
+    : never = never,
+> = DefaultSchemaEnumNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"][EnumName]
+  : DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["Enums"]
+    ? DefaultSchema["Enums"][DefaultSchemaEnumNameOrOptions]
+    : never
+
+export type CompositeTypes<
+  PublicCompositeTypeNameOrOptions extends
+    | keyof DefaultSchema["CompositeTypes"]
+    | { schema: keyof DatabaseWithoutInternals },
+  CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
+    : never = never,
+> = PublicCompositeTypeNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
+  : PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"]
+    ? DefaultSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
+    : never
+
+export const Constants = {
+  public: {
+    Enums: {},
+  },
+} as const
+`;
+
+fs.writeFileSync(OUTPUT_FILE, output);
+
+// Output stats as JSON for the CLI to parse
+const stats = {
+  tables: Object.keys(tables).length,
+  views: Object.keys(views).length,
+  functions: Object.keys(functions).length,
+};
+console.log("__STATS__" + JSON.stringify(stats));
+
+// Helper functions
+
+function mapPostgresType(pgType) {
+  const type = pgType.toLowerCase();
+  const isArray = type.endsWith("[]") || type.startsWith("_");
+  const baseType = type.replace("[]", "").replace(/^_/, "");
+  const mapped = mapBaseType(baseType);
+  return isArray ? `${mapped}[]` : mapped;
+}
+
+function mapBaseType(type) {
+  if (type.includes("int") || type.includes("serial")) return "number";
+  if (type.includes("numeric") || type.includes("decimal") || type.includes("real") || type.includes("double")) return "number";
+  if (type.includes("bool")) return "boolean";
+  if (type.includes("json")) return "Json";
+  if (type.includes("uuid")) return "string";
+  if (type.includes("timestamp") || type.includes("date") || type.includes("time")) return "string";
+  if (type.includes("text") || type.includes("char") || type.includes("varchar")) return "string";
+  return "string";
+}
+
+function splitSelectColumns(selectClause) {
+  const columns = [];
+  let current = "";
+  let depth = 0;
+  for (const char of selectClause) {
+    if (char === "(") { depth++; current += char; }
+    else if (char === ")") { depth--; current += char; }
+    else if (char === "," && depth === 0) { columns.push(current.trim()); current = ""; }
+    else { current += char; }
+  }
+  if (current.trim()) columns.push(current.trim());
+  return columns;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "supatypes",
+  "version": "1.0.0",
+  "description": "Generate TypeScript types from a remote Supabase PostgreSQL database via SSH",
+  "license": "MIT",
+  "author": "MadStoneDev",
+  "type": "module",
+  "bin": {
+    "supatypes": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "keywords": [
+    "supabase",
+    "typescript",
+    "types",
+    "codegen",
+    "postgresql",
+    "database"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}