true-pg 0.4.4 → 0.5.0

package/lib/index.js

@@ -17,7 +17,9 @@ const filter_overloaded_functions = (functions) => {
     }, {});
     return [
         functions.filter(func => counts[func.name] === 1),
-        functions.filter(func => counts[func.name] > 1),
+        Object.entries(counts)
+            .filter(([_, count]) => count > 1)
+            .map(([name]) => name),
     ];
 };
 const filter_function = (func) => {
@@ -93,9 +95,9 @@ 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);
-        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 [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.functions);
+        const [supported_functions, unsupported_functions] = filter_unsupported_functions(unique_functions);
+        schema.functions = supported_functions;
         {
             const skipped = unsupported_functions.map(f => `  - ${f.name}`);
             if (skipped.length) {
@@ -104,7 +106,7 @@ const multifile = async (generators, schemas, opts) => {
             }
         }
         {
-            const skipped = overloaded_functions.map(f => `  - ${f.name}`);
+            const skipped = overloaded_functions.map(f => `  - ${f}`);
             if (skipped.length) {
                 warnings.push(`Skipping ${skipped.length} overloaded functions (not supported):\n` + skipped.join("\n"));
             }

package/lib/kysely/index.js

@@ -1,13 +1,7 @@
 import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
 import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
 import { builtins } from "./builtins.js";
-import { join, quote, quoteI } from "../util.js";
-const toPascalCase = (str) => str
-    .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
-    .replace(/[^a-zA-Z0-9_]+/g, "") // remove non-alphanumeric/underscore characters
-    .replace(" ", "_") // replace spaces with underscores
-    .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()) // capitalize letters after underscores
-    .replace(/^([a-z])/, (_, letter) => letter.toUpperCase()); // capitalize first letter
+import { toPascalCase, join, quote, quoteI } from "../util.js";
 export const Kysely = createGenerator(opts => {
     const defaultSchema = opts?.defaultSchema ?? "public";
     const ky = (imports, name) => imports.add(new Nodes.ExternalImport({

package/lib/util.d.ts

@@ -1,3 +1,5 @@
+export declare const toPascalCase: (str: string) => string;
+export declare const to_snake_case: (str: string) => string;
 export declare const join: (parts: Iterable<string>, joiner?: string) => string;
 export type UnionKeys<T> = T extends unknown ? keyof T : never;
 type AddOptionalKeys<K extends PropertyKey> = {

package/lib/util.js

@@ -1,3 +1,113 @@
+export const toPascalCase = (str) => {
+    let result = "";
+    let index = 0;
+    let space = false;
+    let leading = true;
+    const len = str.length;
+    while (index < len) {
+        const char = str[index];
+        // keep trailing underscores
+        if (index === len - 1 && char === "_") {
+            // iterate backwards until a non-underscore character is found
+            let index = len - 1;
+            while (index >= 0 && str[index] === "_") {
+                result += "_";
+                index--;
+            }
+            break;
+        }
+        if (leading) {
+            if (char === "_") {
+                result += char;
+            }
+            else if (/[a-zA-Z]/.test(char)) {
+                result += char.toUpperCase();
+                leading = false;
+            }
+            else {
+                // skip leading non-alphabetic characters
+            }
+        }
+        else if (/[a-zA-Z0-9]/.test(char)) {
+            // valid characters
+            if (space)
+                result += char.toUpperCase();
+            else
+                result += char;
+            space = false;
+        }
+        else {
+            // invalid characters, space, underscore, or hyphen
+            // treat as space
+            space = true;
+        }
+        index++;
+    }
+    return result;
+};
+export const to_snake_case = (str) => {
+    let result = "";
+    let index = 0;
+    let space = false;
+    let leading = true;
+    let upper = false;
+    const len = str.length;
+    while (index < len) {
+        const char = str[index];
+        // keep trailing underscores
+        if (index === len - 1 && char === "_") {
+            // iterate backwards until a non-underscore character is found
+            let index = len - 1;
+            while (index >= 0 && str[index] === "_") {
+                result += "_";
+                index--;
+            }
+            break;
+        }
+        if (leading) {
+            if (char === "_") {
+                result += char;
+            }
+            else if (/[A-Z]/.test(char)) {
+                result += char.toLowerCase();
+                leading = false;
+                upper = true;
+            }
+            else if (/[a-z]/.test(char)) {
+                result += char.toLowerCase();
+                leading = false;
+            }
+            else {
+                // skip leading non-alphabetic characters
+            }
+        }
+        else if (/[A-Z]/.test(char)) {
+            if (!upper)
+                result += "_";
+            if (space)
+                result += "_";
+            // uppercase characters
+            result += char.toLowerCase();
+            space = false;
+            upper = true;
+        }
+        else if (/[a-z0-9]/.test(char)) {
+            // valid characters
+            if (space)
+                result += "_";
+            result += char;
+            space = false;
+            upper = false;
+        }
+        else {
+            // invalid characters, space, underscore, or hyphen
+            // treat as space
+            space = true;
+        }
+        index++;
+    }
+    return result;
+};
 export const join = (parts, joiner = "\n\n") => Array.from(parts).filter(Boolean).join(joiner);
 const isIdentifierInvalid = (str) => {
     const invalid = str.match(/[^a-zA-Z0-9_]/);

package/lib/util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/util.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "bun:test";
+import { toPascalCase, to_snake_case } from "./util.js";
+describe("toPascalCase", () => {
+    it("should convert a string to PascalCase", () => {
+        expect(toPascalCase("hello-world")).toBe("HelloWorld");
+    });
+    it("should skip leading invalid characters", () => {
+        expect(toPascalCase("123hello-world")).toBe("HelloWorld");
+    });
+    it("should skip leading spaces", () => {
+        expect(toPascalCase(" hello-world")).toBe("HelloWorld");
+    });
+    it("should keep leading underscores", () => {
+        expect(toPascalCase("__hello-world")).toBe("__HelloWorld");
+    });
+    it("should keep trailing underscores", () => {
+        expect(toPascalCase("hello_world___")).toBe("HelloWorld___");
+    });
+    it("should keep leading and trailing underscores", () => {
+        expect(toPascalCase("__hello_world__")).toBe("__HelloWorld__");
+    });
+    it("should convert spaces to uppercase", () => {
+        expect(toPascalCase("hello world")).toBe("HelloWorld");
+    });
+    it("should convert hyphens to uppercase", () => {
+        expect(toPascalCase("hello-world")).toBe("HelloWorld");
+    });
+    it("should convert camelCase to PascalCase", () => {
+        expect(toPascalCase("helloWorld")).toBe("HelloWorld");
+    });
+    it("should convert snake_case to PascalCase", () => {
+        expect(toPascalCase("hello_world")).toBe("HelloWorld");
+    });
+    it("should skip invalid characters", () => {
+        expect(toPascalCase("hello?world!")).toBe("HelloWorld");
+    });
+    it("should generate valid identifier", () => {
+        expect(toPascalCase("   _ hello ? world !")).toBe("_HelloWorld");
+    });
+});
+describe("to_snake_case", () => {
+    it("should convert a string to snake_case", () => {
+        expect(to_snake_case("hello-world")).toBe("hello_world");
+    });
+    it("should skip leading invalid characters", () => {
+        expect(to_snake_case("123hello-world")).toBe("hello_world");
+    });
+    it("should skip leading spaces", () => {
+        expect(to_snake_case(" hello-world")).toBe("hello_world");
+    });
+    it("should keep leading underscores", () => {
+        expect(to_snake_case("__hello-world")).toBe("__hello_world");
+    });
+    it("should keep trailing underscores", () => {
+        expect(to_snake_case("hello_world___")).toBe("hello_world___");
+    });
+    it("should keep leading and trailing underscores", () => {
+        expect(to_snake_case("__hello_world__")).toBe("__hello_world__");
+    });
+    it("should convert spaces to underscores", () => {
+        expect(to_snake_case("hello world")).toBe("hello_world");
+    });
+    it("should convert camelCase to snake_case", () => {
+        expect(to_snake_case("helloWorld")).toBe("hello_world");
+    });
+    it("should convert PascalCase to snake_case", () => {
+        expect(to_snake_case("HelloWorld")).toBe("hello_world");
+    });
+    it("should skip invalid characters", () => {
+        expect(to_snake_case("hello?world!")).toBe("hello_world");
+    });
+    it("should generate valid identifier", () => {
+        expect(to_snake_case("   _ hello ? world !")).toBe("_hello_world");
+    });
+    it("should convert uppercase characters to underscores", () => {
+        expect(to_snake_case("HELLO_WORLD")).toBe("hello_world");
+    });
+});

package/lib/zod/index.js

@@ -1,13 +1,8 @@
 import { FunctionReturnTypeKind, } from "../extractor/index.js";
 import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
 import { builtins } from "./builtins.js";
-import { join, quote, quoteI } from "../util.js";
-const to_snake_case = (str) => str
-    .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
-    .replace(/[^a-zA-Z0-9]+/g, "_") // replace non-alphanumeric characters with underscores
-    .replace(/([A-Z])/g, "_$1") // insert underscores before uppercase letters
-    .toLowerCase();
-// TODO: create an insert and update zod interface for each type
+import { to_snake_case, join, quote, quoteI } from "../util.js";
+// TODO: create an insert and update zod interface for each type?
 export const Zod = createGenerator(opts => {
     const defaultSchema = opts?.defaultSchema ?? "public";
     const zod = (imports, name) => imports.add(new Nodes.ExternalImport({

package/package.json

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