@supawatch/target-supabase-types 0.7.1 → 0.9.0

package/dist/index.js

@@ -20,6 +20,8 @@ function tsType(runtime, jsonRef) {
             return el.includes("|") ? `(${el})[]` : `${el}[]`;
         }
         case "enum":
+            if (runtime.labels.length === 0)
+                return "never";
             return runtime.labels.map((l) => JSON.stringify(l)).join(" | ");
     }
 }
@@ -30,14 +32,6 @@ function bridgeRuntime(col, snapshot) {
     if (col.runtime.kind === "array") {
         return arrayRuntimeFor(runtimeFromName(col.runtime.element, snapshot), 1, "supabase-js");
     }
-    if (col.runtime.kind === "string" && col.runtime.format === "array-literal") {
-        // postgres-js collapses enum arrays to a raw literal; PostgREST
-        // parses them. Recover the element labels via the enum reference.
-        const e = snapshot.enums.find((x) => x.name === col.enumRef);
-        if (e) {
-            return { kind: "array", element: { kind: "enum", labels: e.labels } };
-        }
-    }
     return runtimeFor(col.pgTypeName, kindOf(col, snapshot), { enums: snapshot.enums }, "supabase-js");
 }
 function kindOf(col, snapshot) {
@@ -50,6 +44,11 @@ function kindOf(col, snapshot) {
 function runtimeFromName(element, _snapshot) {
     return element;
 }
+// Database identifiers are free-form ("Order Log", "café", "select");
+// quote any key that is not a plain TS identifier.
+function tsKey(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
 function writableColumns(table) {
     return table.columns.filter((c) => !c.generated && c.identity !== "always");
 }
@@ -61,7 +60,7 @@ function fieldLine(col, snapshot, optional, indent) {
     let t = tsType(runtime, "Json");
     if (col.nullable && t !== "unknown")
         t = `${t} | null`;
-    return `${indent}${col.name}${optional ? "?" : ""}: ${t}`;
+    return `${indent}${tsKey(col.name)}${optional ? "?" : ""}: ${t}`;
 }
 export class SupabaseTypesTarget {
     name = "supabase-types";
@@ -89,14 +88,15 @@ export class SupabaseTypesTarget {
             "export interface Database {",
         ];
         for (const schema of schemas) {
-            const tables = snapshot.tables.filter((t) => t.schema === schema && t.kind === "table");
+            // PostgREST exposes foreign tables beside plain ones.
+            const tables = snapshot.tables.filter((t) => t.schema === schema && t.kind !== "view");
             const views = snapshot.tables.filter((t) => t.schema === schema && t.kind === "view");
             const enums = snapshot.enums.filter((e) => e.schema === schema);
             const composites = snapshot.composites.filter((c) => c.schema === schema);
-            lines.push(`  ${schema}: {`);
+            lines.push(`  ${tsKey(schema)}: {`);
             lines.push("    Tables: {");
             for (const table of tables) {
-                lines.push(`      ${table.name}: {`);
+                lines.push(`      ${tsKey(table.name)}: {`);
                 lines.push("        Row: {");
                 for (const col of table.columns) {
                     lines.push(fieldLine(col, snapshot, false, "          ") + ";");
@@ -128,7 +128,7 @@ export class SupabaseTypesTarget {
             lines.push("    };");
             lines.push("    Views: {");
             for (const view of views) {
-                lines.push(`      ${view.name}: {`);
+                lines.push(`      ${tsKey(view.name)}: {`);
                 lines.push("        Row: {");
                 for (const col of view.columns) {
                     lines.push(fieldLine(col, snapshot, false, "          ") + ";");
@@ -143,36 +143,48 @@ export class SupabaseTypesTarget {
             }
             else {
                 lines.push("    Functions: {");
+                // Overloaded names share one key: Args and Returns become unions
+                // of the signatures, never duplicate keys (invalid TS).
+                const byName = new Map();
                 for (const fn of fns) {
-                    lines.push(`      ${fn.name}: {`);
-                    if (fn.args.length === 0) {
-                        lines.push("        Args: Record<string, never>;");
-                    }
-                    else {
-                        lines.push("        Args: {");
-                        for (const arg of fn.args) {
+                    const group = byName.get(fn.name) ?? [];
+                    group.push(fn);
+                    byName.set(fn.name, group);
+                }
+                for (const [name, group] of byName) {
+                    const argShapes = group.map((fn) => {
+                        if (fn.args.length === 0)
+                            return "Record<string, never>";
+                        const fields = fn.args.map((arg) => {
                             const t = tsType(runtimeFor(arg.pgTypeName, "b", { enums: snapshot.enums }, "supabase-js"), "Json");
-                            lines.push(`          ${arg.name}${arg.hasDefault ? "?" : ""}: ${t};`);
-                        }
-                        lines.push("        };");
-                    }
-                    const ret = tsType(runtimeFor(fn.returns.pgTypeName, "b", { enums: snapshot.enums }, "supabase-js"), "Json");
-                    lines.push(`        Returns: ${fn.returns.isSet ? `(${ret})[]` : ret};`);
+                            return `${tsKey(arg.name)}${arg.hasDefault ? "?" : ""}: ${t}`;
+                        });
+                        return `{ ${fields.join("; ")} }`;
+                    });
+                    const returnShapes = [
+                        ...new Set(group.map((fn) => {
+                            const ret = tsType(runtimeFor(fn.returns.pgTypeName, "b", { enums: snapshot.enums }, "supabase-js"), "Json");
+                            return fn.returns.isSet ? `(${ret})[]` : ret;
+                        })),
+                    ];
+                    lines.push(`      ${tsKey(name)}: {`);
+                    lines.push(`        Args: ${[...new Set(argShapes)].join(" | ")};`);
+                    lines.push(`        Returns: ${returnShapes.join(" | ")};`);
                     lines.push("      };");
                 }
                 lines.push("    };");
             }
             lines.push("    Enums: {");
             for (const e of enums) {
-                lines.push(`      ${e.name}: ${e.labels.map((l) => JSON.stringify(l)).join(" | ")};`);
+                lines.push(`      ${tsKey(e.name)}: ${e.labels.length === 0 ? "never" : e.labels.map((l) => JSON.stringify(l)).join(" | ")};`);
             }
             lines.push("    };");
             lines.push("    CompositeTypes: {");
             for (const c of composites) {
-                lines.push(`      ${c.name}: {`);
+                lines.push(`      ${tsKey(c.name)}: {`);
                 for (const f of c.fields) {
                     const t = tsType(f.runtime, "Json");
-                    lines.push(`        ${f.name}: ${t} | null;`);
+                    lines.push(`        ${tsKey(f.name)}: ${t} | null;`);
                 }
                 lines.push("      };");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supawatch/target-supabase-types",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "A supabase-js compatible Database interface generated from live Postgres by supawatch, foreign-key relationships included.",
   "keywords": [
     "supabase",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "dependencies": {
-    "@supawatch/core": "0.7.1"
+    "@supawatch/core": "0.9.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",