true-pg 0.4.2 → 0.4.4

package/lib/extractor/index.js

@@ -33,6 +33,16 @@ const populatorMap = {
     domain: extractDomain,
     range: extractRange,
 };
+const supported_kinds = [
+    "table",
+    "view",
+    "materializedView",
+    "enum",
+    "composite",
+    "function",
+    "domain",
+    "range",
+];
 export class Extractor {
     db;
     /**
@@ -103,11 +113,11 @@ export class Extractor {
         }
         const pgTypes = await fetchTypes(db, schemaNames);
         const filtered = options?.typeFilter ? pgTypes.filter(element => options.typeFilter(element)) : pgTypes;
-        const typesToExtract = filtered.filter(x => x.kind);
-        const skipped = filtered.filter(x => !x.kind).map(x => x.name);
+        const typesToExtract = filtered.filter(x => supported_kinds.includes(x.kind));
+        const skipped = filtered.filter(x => !supported_kinds.includes(x.kind)).map(x => `${x} (${x.kind})`);
         if (skipped.length) {
             console.warn("Skipping types of unsupported kinds:", skipped.join(", "));
-            console.warn("This is a bug!");
+            console.warn("This is a bug! Proceeding as if nothing happened.");
         }
         options?.onProgressStart?.(typesToExtract.length);
         const populated = (await Promise.all(typesToExtract.map(async (pgType) => {

package/lib/index.js

@@ -10,6 +10,16 @@ const time = (start) => {
     const end = performance.now();
     return (end - start).toFixed(2);
 };
+const filter_overloaded_functions = (functions) => {
+    const counts = functions.reduce((acc, func) => {
+        acc[func.name] = (acc[func.name] ?? 0) + 1;
+        return acc;
+    }, {});
+    return [
+        functions.filter(func => counts[func.name] === 1),
+        functions.filter(func => counts[func.name] > 1),
+    ];
+};
 const filter_function = (func) => {
     const typesToFilter = [
         "pg_catalog.trigger",
@@ -44,6 +54,11 @@ const filter_function = (func) => {
     }
     return func;
 };
+const filter_unsupported_functions = (functions) => {
+    const filtered = functions.filter(filter_function);
+    const unsupported = filtered.filter(func => !filtered.includes(func));
+    return [filtered, unsupported];
+};
 const write = (filename, file) => writeFile(filename, file + "\n");
 const multifile = async (generators, schemas, opts) => {
     const { out } = opts;
@@ -78,13 +93,20 @@ const multifile = async (generators, schemas, opts) => {
     for (const schema of Object.values(schemas)) {
         console.log("Selected schema '%s':\n", schema.name);
         const schemaDir = joinpath(out, schema.name);
-        // skip functions that cannot be represented in JavaScript
-        schema.functions = schema.functions.filter(filter_function);
+        const [supported_functions, unsupported_functions] = filter_unsupported_functions(schema.functions);
+        const [unique_functions, overloaded_functions] = filter_overloaded_functions(supported_functions);
+        schema.functions = unique_functions;
+        {
+            const skipped = unsupported_functions.map(f => `  - ${f.name}`);
+            if (skipped.length) {
+                warnings.push(`Skipping ${skipped.length} functions not representable in JavaScript (safe to ignore):\n` +
+                    skipped.join("\n"));
+            }
+        }
         {
-            const skipped = schema.functions.filter(f => !filter_function(f));
-            const skipped_functions = skipped.map(f => `  - ${f.name}`).join("\n");
+            const skipped = overloaded_functions.map(f => `  - ${f.name}`);
             if (skipped.length) {
-                warnings.push(`Skipping ${skipped.length} functions because they cannot be represented in JavaScript (safe to ignore):\n${skipped_functions}`);
+                warnings.push(`Skipping ${skipped.length} overloaded functions (not supported):\n` + skipped.join("\n"));
             }
         }
         let createIndex = false;

package/lib/kysely/builtins.js

@@ -17,7 +17,6 @@ export const builtins = {
     "pg_catalog.varchar": "string",
     "pg_catalog.text": "string",
     "pg_catalog.uuid": "string",
-    "pg_catalog.inet": "string",
     "pg_catalog.date": "Date",
     "pg_catalog.time": "Date",
     "pg_catalog.timetz": "Date",
@@ -32,6 +31,12 @@ export const builtins = {
     "pg_catalog.record": "Record<string, unknown>",
     "pg_catalog.void": "void",
     "pg_catalog.bytea": "string",
+    "pg_catalog.inet": "string",
+    "pg_catalog.cidr": "string",
+    "pg_catalog.macaddr": "string",
+    "pg_catalog.macaddr8": "string",
+    "pg_catalog.oid": "number",
+    "pg_catalog.refcursor": "string",
     "pg_catalog.vector": "number[]",
     "pg_catalog.tsvector": "string[]",
 };

package/lib/zod/builtins.js

@@ -17,7 +17,6 @@ export const builtins = {
     "pg_catalog.varchar": "z.string()",
     "pg_catalog.text": "z.string()",
     "pg_catalog.uuid": "z.string()",
-    "pg_catalog.inet": "z.string()",
     "pg_catalog.date": "z.coerce.date()",
     "pg_catalog.time": "z.coerce.date()",
     "pg_catalog.timetz": "z.coerce.date()",
@@ -32,6 +31,12 @@ export const builtins = {
     "pg_catalog.record": "z.record(z.string(), z.unknown())",
     "pg_catalog.void": "z.void()",
     "pg_catalog.bytea": "z.string()",
+    "pg_catalog.inet": "z.string()",
+    "pg_catalog.cidr": "z.string()",
+    "pg_catalog.macaddr": "z.string()",
+    "pg_catalog.macaddr8": "z.string()",
+    "pg_catalog.oid": "z.number()",
+    "pg_catalog.refcursor": "z.string()",
     "pg_catalog.vector": "z.number().array()",
     "pg_catalog.tsvector": "z.string().array()",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.4.2",
+	"version": "0.4.4",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",