true-pg 0.4.5 → 0.5.1

package/lib/types.js

@@ -1,6 +1,4 @@
 import { Canonical, } from "./extractor/index.js";
-import { dirname, relative } from "node:path/posix";
-import { join } from "./util.js";
 // To be updated when we add support for other kinds
 export const allowed_kind_names = [
     "tables",
@@ -12,168 +10,5 @@ export const allowed_kind_names = [
     "domains",
     "ranges",
 ];
-export var Nodes;
-(function (Nodes) {
-    class ExternalImport {
-        // what to import
-        name;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an external import
-        external;
-        // what module to import from
-        module;
-        constructor(args) {
-            this.name = args.name;
-            this.typeOnly = args.typeOnly;
-            this.star = args.star;
-            this.external = true;
-            this.module = args.module;
-        }
-    }
-    Nodes.ExternalImport = ExternalImport;
-    class InternalImport {
-        // what to import
-        name;
-        // underlying type that is being imported
-        canonical_type;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an internal import
-        external;
-        constructor(args) {
-            this.name = args.name;
-            this.canonical_type = args.canonical_type;
-            this.star = args.star;
-            this.typeOnly = args.typeOnly;
-            this.external = false;
-        }
-    }
-    Nodes.InternalImport = InternalImport;
-    class ImportList {
-        imports;
-        constructor(imports) {
-            this.imports = imports;
-        }
-        static merge(lists) {
-            return new ImportList(lists.flatMap(l => l.imports));
-        }
-        add(item) {
-            this.imports.push(item);
-        }
-        stringify(context_file, files) {
-            const externals = this.imports.filter(i => i.external);
-            const internals = this.imports.filter(i => !i.external);
-            const modulegroups = {};
-            for (const item of externals) {
-                const group = modulegroups[item.module];
-                if (group)
-                    group.push(item);
-                else
-                    modulegroups[item.module] = [item];
-            }
-            const out = [];
-            // TODO: normalise external and internal imports and handle the stringification of the imports in a single place
-            {
-                // EXTERNAL IMPORTS
-                const imports = [];
-                for (const module in modulegroups) {
-                    const items = modulegroups[module];
-                    const star = items.find(i => i.star);
-                    const unique = items.filter((i, index, arr) => {
-                        if (i.star)
-                            return false;
-                        if (arr.findIndex(i2 => i2.name === i.name) !== index)
-                            return false;
-                        return true;
-                    });
-                    const bits = [];
-                    const typeOnlys = unique.filter(i => i.typeOnly);
-                    const values = unique.filter(i => !i.typeOnly);
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    let import_line = `import `;
-                    for (const type of typeOnlys)
-                        bits.push(typeInline ? "type " : "" + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (bits.length && star)
-                        import_line += `, `;
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    if (bits.length || star)
-                        import_line += ` from `;
-                    import_line += `"${module}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            {
-                // INTERNAL IMPORTS
-                const imports = [];
-                const unique_types = internals
-                    .filter(({ name: name1, canonical_type: int }, index, arr) => {
-                    return (arr.findIndex(({ name: name2, canonical_type: int2 }) => {
-                        return (
-                        // adapter-assigned name
-                        name2 === name1 &&
-                            // canonical type details
-                            int2.name === int.name &&
-                            int2.schema === int.schema &&
-                            int2.kind === int.kind);
-                    }) === index);
-                })
-                    .filter(imp => imp.canonical_type.kind === Canonical.Kind.Base ||
-                    allowed_kind_names.includes(`${imp.canonical_type.kind}s`))
-                    .map(imp => {
-                    const t = imp.canonical_type;
-                    const schema = files.children[t.schema];
-                    const kind = schema.children[`${t.kind}s`];
-                    const type = kind.children[t.name];
-                    const located_file = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
-                    return { ...imp, located_file };
-                });
-                const group_by_file = {};
-                for (const type of unique_types) {
-                    const file = group_by_file[type.located_file] || [];
-                    file.push(type);
-                    group_by_file[type.located_file] = file;
-                }
-                for (const group in group_by_file) {
-                    let relative_path = relative(dirname(context_file), group);
-                    if (/^[^\.+\/]/.test(relative_path))
-                        relative_path = "./" + relative_path;
-                    const items = group_by_file[group];
-                    const typeOnlys = items.filter(i => i.typeOnly);
-                    const values = items.filter(i => !i.typeOnly);
-                    const star = values.find(i => i.star);
-                    let import_line = "import ";
-                    const bits = [];
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    for (const type of typeOnlys)
-                        bits.push((typeInline ? "type " : "") + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    import_line += ` from "${relative_path}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            return join(out);
-        }
-    }
-    Nodes.ImportList = ImportList;
-})(Nodes || (Nodes = {}));
 /* convenience function to create a generator with type inference */
 export const createGenerator = (generatorCreator) => generatorCreator;

package/lib/util.d.ts

@@ -1,3 +1,6 @@
+export declare const eq: <T>(a: T, b: T) => boolean;
+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> = {
@@ -7,6 +10,7 @@ export type Deunionise<B extends object | undefined, T = B> = Simplify<T extends
 export type Simplify<T> = {
     [KeyType in keyof T]: T[KeyType];
 } & {};
+export declare const parens: (str: string, type?: string) => string;
 export declare const quote: (str: string, using?: string) => string;
 export declare const quoteI: (str: string, using?: string) => string;
 export {};

package/lib/util.js

@@ -1,7 +1,130 @@
+export const eq = (a, b) => {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    for (const key in a)
+        if (!eq(a[key], b[key]))
+            return false;
+    return true;
+};
+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_]/);
     return invalid !== null;
 };
+export const parens = (str, type = "()") => `${type[0]}${str}${type[1]}`;
 export const quote = (str, using = '"') => `${using}${str.replaceAll(using, "\\" + using)}${using}`;
 export const quoteI = (str, using = '"') => (isIdentifierInvalid(str) ? quote(str, using) : str);

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");
+    });
+});