supatypes 1.0.2 → 1.0.4

package/README.md

@@ -40,6 +40,7 @@ Running `init` creates a `.supatypes.json` file:
 ```json
 {
   "server": "root@1.2.3.4",
+  "sshPort": 2222,
   "sshKey": "~/.ssh/id_rsa",
   "dbContainer": "supabase-db-abc123",
   "output": "./database.types.ts"
@@ -51,6 +52,7 @@ Running `init` creates a `.supatypes.json` file:
 | Field | Required | Description |
 |-------|----------|-------------|
 | `server` | Yes | SSH connection string (e.g. `root@1.2.3.4`) |
+| `sshPort` | No | SSH port (default: `22`) |
 | `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 |

package/bin/cli.js

@@ -3,6 +3,7 @@
 import { parseArgs } from "node:util";
 import { init } from "../lib/init.js";
 import { generate } from "../lib/generate.js";
+import { testConnection } from "../lib/test-connection.js";
 
 const HELP = `
 supatypes — Generate TypeScript types from a remote Supabase database
@@ -10,6 +11,7 @@ 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 test [options]        Test SSH and database connectivity
   supatypes help                  Show this help message
 
 Options (generate):
@@ -20,6 +22,7 @@ Options (generate):
 Config file (.supatypes.json):
   {
     "server": "root@1.2.3.4",
+    "sshPort": 2222,
     "sshKey": "~/.ssh/id_rsa",
     "dbContainer": "supabase-db-abc123",
     "output": "./database.types.ts"
@@ -28,6 +31,7 @@ Config file (.supatypes.json):
   You can also use a password instead of an SSH key:
   {
     "server": "root@1.2.3.4",
+    "sshPort": 2222,
     "sshPassword": "your-password",
     "dbContainer": "supabase-db-abc123",
     "output": "./database.types.ts"
@@ -65,6 +69,19 @@ if (command === "generate") {
   process.exit(0);
 }
 
+if (command === "test") {
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: {
+      config: { type: "string", short: "c", default: "./.supatypes.json" },
+    },
+    strict: false,
+  });
+
+  await testConnection({ configPath: values.config });
+  process.exit(0);
+}
+
 console.error(`Unknown command: ${command}`);
 console.log('Run "supatypes help" for usage.');
 process.exit(1);

package/lib/generate.js

@@ -1,167 +1,171 @@
-import fs from "node:fs";
-import path from "node:path";
-import { execFileSync } 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 "npx 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}:${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}:${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 [bin, ...args] = base;
-  return execFileSync(bin, [...args, command], {
-    encoding: "utf8",
-    maxBuffer: 50 * 1024 * 1024,
-  });
-}
-
-function scp(base, src, dest) {
-  const [bin, ...args] = base;
-  execFileSync(bin, [...args, src, dest], { encoding: "utf8" });
-}
-
-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`;
-}
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } 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 "npx supatypes init" to create one.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(resolvedConfig, "utf8"));
+  const { server, dbContainer } = config;
+  const sshPort = config.sshPort || 22;
+  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, sshPort, sshKey, sshPassword);
+  const scpBase = buildScpBase(server, sshPort, 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(`  Port:      ${sshPort}`);
+  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}:${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}`);
+      console.log(`  Enums:     ${stats.enums}`);
+      console.log(`  Composites:${stats.compositeTypes ? " " + stats.compositeTypes : " 0"}`);
+    }
+
+    // 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}:${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, port, sshKey, sshPassword) {
+  const opts = ["-p", String(port), "-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, port, sshKey, sshPassword) {
+  const opts = ["-P", String(port), "-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 [bin, ...args] = base;
+  return execFileSync(bin, [...args, command], {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+  });
+}
+
+function scp(base, src, dest) {
+  const [bin, ...args] = base;
+  execFileSync(bin, [...args, src, dest], { encoding: "utf8" });
+}
+
+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

@@ -33,6 +33,7 @@ export async function init() {
 
   const sshUser = await ask(rl, "SSH username", "root");
   const sshHost = await ask(rl, "SSH server host (e.g. 1.2.3.4)", "");
+  const sshPort = await ask(rl, "SSH port", "22");
   const server = `${sshUser}@${sshHost}`;
   const authMethod = await ask(rl, "Auth method: key or password?", "key");
 
@@ -52,6 +53,8 @@ export async function init() {
 
   const config = { server, dbContainer, output };
 
+  const parsedPort = parseInt(sshPort, 10);
+  if (parsedPort !== 22) config.sshPort = parsedPort;
   if (sshKey) config.sshKey = sshKey;
   if (sshPassword) config.sshPassword = sshPassword;
 

package/lib/remote-generator.js

@@ -23,10 +23,51 @@ const schema = execSync(
   { encoding: "utf8", maxBuffer: 50 * 1024 * 1024 }
 );
 
-// Step 2: Parse tables
+// Step 2: Parse enums
+const enums = {};
+const enumRegex = /CREATE TYPE (?:public\.)?(\w+) AS ENUM\s*\(\s*([\s\S]*?)\)/g;
+let match;
+
+while ((match = enumRegex.exec(schema)) !== null) {
+  const enumName = match[1];
+  const valuesStr = match[2];
+  const values = valuesStr
+    .split(",")
+    .map((v) => v.trim().replace(/^'|'$/g, ""))
+    .filter((v) => v.length > 0);
+  if (values.length > 0) {
+    enums[enumName] = values;
+  }
+}
+
+// Step 3: Parse composite types
+const compositeTypes = {};
+const compositeRegex = /CREATE TYPE (?:public\.)?(\w+) AS\s*\(\s*([\s\S]*?)\)/g;
+
+while ((match = compositeRegex.exec(schema)) !== null) {
+  const typeName = match[1];
+  if (enums[typeName]) continue; // skip enums already parsed
+  const fieldsStr = match[2];
+  const fields = [];
+  for (const line of fieldsStr.split(",").map((l) => l.trim())) {
+    const fieldMatch = line.match(
+      /^"?(\w+)"?\s+((?:character varying|double precision|timestamp with(?:out)? time zone|\w+)(?:\[\])?)/
+    );
+    if (fieldMatch) {
+      fields.push({
+        name: fieldMatch[1],
+        type: mapPostgresType(fieldMatch[2], enums),
+      });
+    }
+  }
+  if (fields.length > 0) {
+    compositeTypes[typeName] = fields;
+  }
+}
+
+// Step 4: 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];
@@ -44,7 +85,7 @@ while ((match = tableRegex.exec(schema)) !== null) {
       const [, name, type, constraints = ""] = colMatch;
       columns.push({
         name,
-        type: mapPostgresType(type),
+        type: mapPostgresType(type, enums, compositeTypes),
         nullable: !constraints.includes("NOT NULL"),
         hasDefault: constraints.includes("DEFAULT"),
       });
@@ -144,7 +185,7 @@ while ((match = funcRegex.exec(schema)) !== null) {
       if (paramMatch) {
         params.push({
           name: paramMatch[1],
-          type: mapPostgresType(paramMatch[2]),
+          type: mapPostgresType(paramMatch[2], enums, compositeTypes),
         });
       }
     }
@@ -152,7 +193,7 @@ while ((match = funcRegex.exec(schema)) !== null) {
 
   functions[funcName] = {
     params,
-    returnType: returnType === "void" ? "undefined" : mapPostgresType(returnType),
+    returnType: returnType === "void" ? "undefined" : mapPostgresType(returnType, enums, compositeTypes),
   };
 }
 
@@ -217,17 +258,33 @@ if (funcEntries.length === 0) {
   }
 }
 
-output += `    }
-    Enums: {
-      [_ in never]: never
-    }
-    CompositeTypes: {
-      [_ in never]: never
+output += `    }\n    Enums: {\n`;
+
+const enumEntries = Object.entries(enums);
+if (enumEntries.length === 0) {
+  output += `      [_ in never]: never\n`;
+} else {
+  for (const [enumName, values] of enumEntries) {
+    output += `      ${enumName}: ${values.map((v) => `"${v}"`).join(" | ")}\n`;
+  }
+}
+
+output += `    }\n    CompositeTypes: {\n`;
+
+const compositeEntries = Object.entries(compositeTypes);
+if (compositeEntries.length === 0) {
+  output += `      [_ in never]: never\n`;
+} else {
+  for (const [typeName, fields] of compositeEntries) {
+    output += `      ${typeName}: {\n`;
+    for (const field of fields) {
+      output += `        ${field.name}: ${field.type}\n`;
     }
+    output += `      }\n`;
   }
 }
 
-type DatabaseWithoutInternals = Omit<Database, "__InternalSupabase">
+output += `    }\n  }\n}\n\ntype DatabaseWithoutInternals = Omit<Database, "__InternalSupabase">
 
 type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, "public">]
 
@@ -346,7 +403,9 @@ export type CompositeTypes<
 
 export const Constants = {
   public: {
-    Enums: {},
+    Enums: {${enumEntries.length > 0 ? "\n" + enumEntries.map(([name, values]) =>
+      `      ${name}: [${values.map((v) => `"${v}"`).join(", ")}]`
+    ).join(",\n") + ",\n    " : ""}},
   },
 } as const
 `;
@@ -358,15 +417,28 @@ const stats = {
   tables: Object.keys(tables).length,
   views: Object.keys(views).length,
   functions: Object.keys(functions).length,
+  enums: Object.keys(enums).length,
+  compositeTypes: Object.keys(compositeTypes).length,
 };
 console.log("__STATS__" + JSON.stringify(stats));
 
 // Helper functions
 
-function mapPostgresType(pgType) {
+function mapPostgresType(pgType, enumDefs, compositeDefs) {
   const type = pgType.toLowerCase();
   const isArray = type.endsWith("[]") || type.startsWith("_");
   const baseType = type.replace("[]", "").replace(/^_/, "");
+
+  if (enumDefs && enumDefs[baseType]) {
+    const mapped = `Database["public"]["Enums"]["${baseType}"]`;
+    return isArray ? `(${mapped})[]` : mapped;
+  }
+
+  if (compositeDefs && compositeDefs[baseType]) {
+    const mapped = `Database["public"]["CompositeTypes"]["${baseType}"]`;
+    return isArray ? `(${mapped})[]` : mapped;
+  }
+
   const mapped = mapBaseType(baseType);
   return isArray ? `${mapped}[]` : mapped;
 }

package/lib/test-connection.js

@@ -0,0 +1,126 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+export async function testConnection({ configPath }) {
+  const resolvedConfig = path.resolve(configPath);
+  if (!fs.existsSync(resolvedConfig)) {
+    console.error(`Config file not found: ${resolvedConfig}`);
+    console.error('Run "npx supatypes init" to create one.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(resolvedConfig, "utf8"));
+  const { server, dbContainer } = config;
+  const sshPort = config.sshPort || 22;
+  const sshKey = config.sshKey ? expandHome(config.sshKey) : null;
+  const sshPassword = config.sshPassword || null;
+
+  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, sshPort, sshKey, sshPassword);
+
+  console.log("supatypes — connection test\n");
+  console.log(`  Server:    ${server}`);
+  console.log(`  Port:      ${sshPort}`);
+  console.log(`  Container: ${dbContainer}`);
+  console.log(`  Auth:      ${sshKey ? "SSH key" : "password"}\n`);
+
+  // Test 1: SSH connectivity
+  process.stdout.write("1. Testing SSH connection...");
+  try {
+    ssh(sshBase, "echo ok");
+    console.log(" passed");
+  } catch (err) {
+    console.log(" FAILED");
+    console.error(`   ${err.message}`);
+    process.exit(1);
+  }
+
+  // Test 2: Docker available
+  process.stdout.write("2. Checking Docker access...");
+  try {
+    ssh(sshBase, "docker --version");
+    console.log(" passed");
+  } catch (err) {
+    console.log(" FAILED");
+    console.error(`   Docker is not available on the server.`);
+    process.exit(1);
+  }
+
+  // Test 3: Container running
+  process.stdout.write(`3. Checking container '${dbContainer}'...`);
+  try {
+    const status = ssh(sshBase, `docker inspect -f '{{.State.Status}}' ${dbContainer}`).trim();
+    if (status === "running") {
+      console.log(" running");
+    } else {
+      console.log(` ${status}`);
+      console.error(`   Container exists but is not running (status: ${status}).`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log(" FAILED");
+    console.error(`   Container '${dbContainer}' not found.`);
+    process.exit(1);
+  }
+
+  // Test 4: PostgreSQL accessible
+  process.stdout.write("4. Checking PostgreSQL access...");
+  try {
+    ssh(sshBase, `docker exec ${dbContainer} pg_isready -U postgres`);
+    console.log(" passed");
+  } catch (err) {
+    console.log(" FAILED");
+    console.error(`   PostgreSQL is not ready in the container.`);
+    process.exit(1);
+  }
+
+  // Test 5: Node.js on server
+  process.stdout.write("5. Checking Node.js on server...");
+  try {
+    const nodeVersion = ssh(sshBase, "node --version").trim();
+    console.log(` ${nodeVersion}`);
+  } catch (err) {
+    console.log(" FAILED");
+    console.error(`   Node.js is not installed on the server. It's required to run the generator.`);
+    process.exit(1);
+  }
+
+  console.log("\nAll checks passed. Ready to generate types.");
+}
+
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return path.join(process.env.HOME || process.env.USERPROFILE || "", p.slice(2));
+  }
+  return p;
+}
+
+function buildSshBase(server, port, sshKey, sshPassword) {
+  const opts = ["-p", String(port), "-o", "StrictHostKeyChecking=accept-new", "-o", "ConnectTimeout=10"];
+
+  if (sshPassword) {
+    return ["sshpass", "-p", sshPassword, "ssh", ...opts, server];
+  }
+
+  if (sshKey) {
+    return ["ssh", "-i", sshKey, ...opts, server];
+  }
+
+  return ["ssh", ...opts, server];
+}
+
+function ssh(base, command) {
+  const [bin, ...args] = base;
+  return execFileSync(bin, [...args, command], {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+  });
+}

package/package.json

@@ -1,27 +1,30 @@
-{
-  "name": "supatypes",
-  "version": "1.0.2",
-  "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"
-  }
-}
+{
+  "name": "supatypes",
+  "version": "1.0.4",
+  "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"
+  ],
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}