supatypes 1.0.3 → 1.0.4

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):
@@ -67,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

@@ -80,6 +80,8 @@ export async function generate({ configPath, outputOverride, dryRun }) {
       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

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,6 +1,6 @@
 {
   "name": "supatypes",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Generate TypeScript types from a remote Supabase PostgreSQL database via SSH",
   "license": "MIT",
   "author": "MadStoneDev",
@@ -21,7 +21,10 @@
     "postgresql",
     "database"
   ],
+  "scripts": {
+    "test": "node --test test/"
+  },
   "engines": {
     "node": ">=18"
   }
-}
+}