true-pg 0.5.1 → 0.7.0

package/lib/extractor/index.js

@@ -10,18 +10,19 @@ import extractFunction, {} from "./kinds/function.js";
 import extractDomain, {} from "./kinds/domain.js";
 import extractRange, {} from "./kinds/range.js";
 import fetchTypes from "./fetchTypes.js";
-import { canonicalise, Canonical } from "./canonicalise.js";
+export { pgTypeKinds } from "./pgtype.js";
+import { canonicalise, Canonical, canonicaliseFromOids } from "./canonicalise.js";
 export { Canonical };
 export { FunctionReturnTypeKind } from "./kinds/function.js";
 const emptySchema = {
-    tables: [],
-    views: [],
-    materializedViews: [],
-    enums: [],
-    composites: [],
-    functions: [],
-    domains: [],
-    ranges: [],
+    table: [],
+    view: [],
+    materializedView: [],
+    enum: [],
+    composite: [],
+    function: [],
+    domain: [],
+    range: [],
 };
 const populatorMap = {
     table: extractTable,
@@ -62,9 +63,6 @@ export class Extractor {
         }
         this.db = new DbAdapter(pg, opts.pg ? true : false);
     }
-    async canonicalise(types) {
-        return canonicalise(this.db, types);
-    }
     async getBuiltinTypes() {
         await this.db.connect();
         const db = this.db;
@@ -133,10 +131,7 @@ export class Extractor {
                     ...emptySchema,
                 };
             }
-            schemas[p.schemaName][`${p.kind}s`] = [
-                ...schemas[p.schemaName][`${p.kind}s`],
-                p,
-            ];
+            schemas[p.schemaName][p.kind] = [...schemas[p.schemaName][p.kind], p];
         }
         const result = 
         //  options?.resolveViews

package/lib/extractor/kinds/composite.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 /**
  * Composite type in a schema with details.
  */

package/lib/extractor/kinds/composite.js

@@ -1,9 +1,8 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractComposite = async (db, composite) => {
     // Form the fully qualified type name
     const fullTypeName = `"${composite.schemaName}"."${composite.name}"`;
     // Get canonical type information with all the metadata
-    const [canonical] = await canonicalise(db, [fullTypeName]);
+    const [canonical] = await db.canonicalise([fullTypeName]);
     // Return the composite type with its canonical representation
     return {
         ...composite,

package/lib/extractor/kinds/domain.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 /**
  * Domain type in a schema with details.
  */

package/lib/extractor/kinds/domain.js

@@ -1,9 +1,8 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractDomain = async (db, domain) => {
     // Form the fully qualified type name
     const fullTypeName = `"${domain.schemaName}"."${domain.name}"`;
     // Get canonical type information with all the metadata
-    const [canonical] = await canonicalise(db, [fullTypeName]);
+    const [canonical] = await db.canonicalise([fullTypeName]);
     // Return the composite type with its canonical representation
     return {
         ...domain,

package/lib/extractor/kinds/function.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 declare const parameterModeMap: {
     readonly i: "IN";
     readonly o: "OUT";

package/lib/extractor/kinds/function.js

@@ -1,4 +1,3 @@
-import { canonicalise, Canonical } from "../canonicalise.js";
 import { parsePostgresTableDefinition } from "./util/parseInlineTable.js";
 const parameterModeMap = {
     i: "IN",
@@ -75,13 +74,13 @@ async function extractFunction(db, pgType) {
         if (row.arg_names && !row.arg_modes)
             row.arg_modes = row.arg_names.map(() => "i");
         const argModes = row.arg_modes?.map(mode => parameterModeMap[mode]) ?? [];
-        const canonical_arg_types = row.arg_types ? await canonicalise(db, row.arg_types) : [];
+        const canonical_arg_types = row.arg_types ? await db.canonicalise(row.arg_types) : [];
         let returnType;
         const tableMatch = row.declared_return_type.match(/^TABLE\((.*)\)$/i);
         if (tableMatch) {
             const columnDefs = parsePostgresTableDefinition(row.declared_return_type);
             const columnTypes = columnDefs.map(col => col.type);
-            const canonicalColumnTypes = await canonicalise(db, columnTypes);
+            const canonicalColumnTypes = await db.canonicalise(columnTypes);
             returnType = {
                 kind: FunctionReturnTypeKind.InlineTable,
                 columns: columnDefs.map((col, i) => ({
@@ -111,7 +110,7 @@ async function extractFunction(db, pgType) {
                 else if (
                 // "c" = composite type
                 row.return_type_relation_kind === "c") {
-                    const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                    const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
                         type: canonicalReturnType,
@@ -120,7 +119,7 @@ async function extractFunction(db, pgType) {
                 }
                 else {
                     console.warn(`Composite return type '${row.return_type_string}' has unexpected relkind '${row.return_type_relation_kind}' for function ${pgType.schemaName}.${row.name}`);
-                    const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                    const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
                         type: canonicalReturnType,
@@ -129,7 +128,7 @@ async function extractFunction(db, pgType) {
                 }
             }
             else {
-                const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                const canonicalReturnType = (await db.canonicalise([row.return_type_string]))[0];
                 returnType = {
                     kind: FunctionReturnTypeKind.Regular,
                     type: canonicalReturnType,

package/lib/extractor/kinds/materialized-view.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 export interface MaterializedViewColumn {
     name: string;
     type: Canonical;

package/lib/extractor/kinds/materialized-view.js

@@ -1,4 +1,3 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractMaterializedView = async (db, mview) => {
     // 1. Query for columns (using pg_attribute for potentially more accurate nullability)
     const columnQuery = await db.query(`
@@ -26,7 +25,7 @@ const extractMaterializedView = async (db, mview) => {
 		`, [mview.name, mview.schemaName]);
     // 2. Get canonical types
     const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await canonicalise(db, definedTypes);
+    const canonicalTypes = await db.canonicalise(definedTypes);
     const columns = columnQuery.map((row, index) => ({
         name: row.name,
         type: canonicalTypes[index],

package/lib/extractor/kinds/range.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 /**
  * Range type in a schema with details.
  */

package/lib/extractor/kinds/range.js

@@ -1,9 +1,8 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractRange = async (db, range) => {
     // Form the fully qualified type name
     const fullTypeName = `"${range.schemaName}"."${range.name}"`;
     // Get canonical type information with all the metadata
-    const [canonical] = await canonicalise(db, [fullTypeName]);
+    const [canonical] = await db.canonicalise([fullTypeName]);
     // Return the composite type with its canonical representation
     return {
         ...range,

package/lib/extractor/kinds/table.d.ts

@@ -1,6 +1,6 @@
 import { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 export declare const updateActionMap: {
     readonly a: "NO ACTION";
     readonly r: "RESTRICT";

package/lib/extractor/kinds/table.js

@@ -1,7 +1,6 @@
 import { DbAdapter } from "../adapter.js";
 import commentMapQueryPart from "./parts/commentMapQueryPart.js";
 import indexMapQueryPart from "./parts/indexMapQueryPart.js";
-import { Canonical, canonicalise } from "../canonicalise.js";
 export const updateActionMap = {
     a: "NO ACTION",
     r: "RESTRICT",
@@ -109,7 +108,7 @@ const extractTable = async (db, table) => {
     // Get the expanded type names from the query result
     const definedTypes = columnsQuery.map(row => row.definedType);
     // Use canonicaliseTypes to get detailed type information
-    const canonicalTypes = await canonicalise(db, definedTypes);
+    const canonicalTypes = await db.canonicalise(definedTypes);
     // Combine the column information with the canonical type information
     const columns = columnsQuery.map((row, index) => ({
         name: row.name,

package/lib/extractor/kinds/view.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter } from "../adapter.ts";
 import type { PgType } from "../pgtype.ts";
-import { Canonical } from "../canonicalise.ts";
+import type { Canonical } from "../canonicalise.ts";
 export interface ViewColumn {
     name: string;
     type: Canonical;

package/lib/extractor/kinds/view.js

@@ -1,4 +1,3 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractView = async (db, view) => {
     // 1. Query for columns (information_schema.columns + pg_attribute)
     const columnQuery = await db.query(`
@@ -25,7 +24,7 @@ const extractView = async (db, view) => {
 		`, [view.name, view.schemaName]);
     // 2. Get canonical types
     const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await canonicalise(db, definedTypes);
+    const canonicalTypes = await db.canonicalise(definedTypes);
     const columns = columnQuery.map((row, index) => ({
         name: row.name,
         type: canonicalTypes[index],

package/lib/extractor/pgtype.d.ts

@@ -1,9 +1,9 @@
 export declare const typeKindMap: {
-    readonly d: "domain";
     readonly e: "enum";
+    readonly d: "domain";
     readonly r: "range";
 };
-type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
+export type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
 export declare const classKindMap: {
     readonly r: "table";
     readonly p: "table";
@@ -11,12 +11,13 @@ export declare const classKindMap: {
     readonly m: "materializedView";
     readonly c: "composite";
 };
-type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
+export type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
 export declare const routineKindMap: {
     readonly f: "function";
 };
-type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
-export type Kind = TypeKind | ClassKind | RoutineKind;
+export type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
+export declare const pgTypeKinds: ("function" | "composite" | "domain" | "enum" | "range" | "table" | "view" | "materializedView")[];
+export type Kind = (typeof pgTypeKinds)[number];
 /**
  * Base type for Postgres objects.
  */
@@ -38,4 +39,3 @@ export type PgType<K extends Kind = Kind> = {
      */
     comment: string | null;
 };
-export {};

package/lib/extractor/pgtype.js

@@ -1,6 +1,6 @@
 export const typeKindMap = {
-    d: "domain",
     e: "enum",
+    d: "domain",
     r: "range",
     // Not supported (yet):
     // m: 'multiRange',
@@ -28,3 +28,9 @@ export const routineKindMap = {
     // a: 'aggregate',
     // w: 'windowFunction',
 };
+const unique = (arr) => [...new Set(arr)];
+export const pgTypeKinds = unique([
+    ...Object.values(classKindMap),
+    ...Object.values(typeKindMap),
+    ...Object.values(routineKindMap),
+]);

package/lib/imports.d.ts

@@ -1,11 +1,16 @@
 import type { Canonical } from "./extractor/index.ts";
 import type { FunctionReturnType } from "./extractor/index.ts";
-import type { FolderStructure } from "./types.ts";
+import type { allowed_kind_names, FolderStructure } from "./types.ts";
 export interface ImportIdentifier {
     name: string;
     alias?: string;
     typeOnly?: boolean;
 }
+type Supported<T> = {
+    [key in allowed_kind_names]: T extends {
+        kind: key;
+    } ? T : never;
+}[allowed_kind_names];
 export declare class Import {
     from: string | ((files: FolderStructure) => string);
     namedImports?: (string | ImportIdentifier)[];
@@ -21,7 +26,7 @@ export declare class Import {
     });
     static fromInternal(opts: {
         source: string;
-        type: Canonical | FunctionReturnType.ExistingTable;
+        type: Supported<Canonical | FunctionReturnType.ExistingTable>;
         withName?: string;
         typeOnly?: boolean;
     }): Import;
@@ -33,3 +38,4 @@ export declare class ImportList {
     add(item: Import): void;
     stringify(files: FolderStructure): string;
 }
+export {};

package/lib/imports.js

@@ -1,4 +1,4 @@
-import { dirname, relative } from "node:path";
+import { dirname, relative } from "node:path/posix";
 import { eq } from "./util.js";
 export class Import {
     from;
@@ -18,9 +18,12 @@ export class Import {
         return new Import({
             from: files => {
                 const schema = files.children[t.schema];
-                const kind = schema.children[`${t.kind}s`];
-                const type = kind.children[t.name];
-                const path = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
+                const kind = schema?.children[t.kind];
+                const type = kind?.children[t.name];
+                if (!schema || !kind || !type) {
+                    throw new Error(`Type ${t.kind}/${t.name} not found in schema "${t.schema}"`);
+                }
+                const path = `${files.name}/${schema.name}/${kind.kind}s/${type.name}.ts`;
                 return relative(dirname(opts.source), path);
             },
             namedImports: [opts.withName ?? t.name],

package/lib/imports.test.d.ts

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

package/lib/imports.test.js

@@ -0,0 +1,188 @@
+import { Canonical } from "./extractor/canonicalise.js";
+import { Import, ImportList } from "./imports.js";
+import { describe, it, expect } from "bun:test";
+const files = {
+    name: "root",
+    type: "root",
+    children: {
+        public: {
+            name: "public",
+            type: "schema",
+            children: {
+                function: {
+                    kind: "function",
+                    type: "kind",
+                    children: {},
+                },
+                view: {
+                    kind: "view",
+                    type: "kind",
+                    children: {},
+                },
+                materializedView: {
+                    kind: "materializedView",
+                    type: "kind",
+                    children: {},
+                },
+                composite: {
+                    kind: "composite",
+                    type: "kind",
+                    children: {},
+                },
+                table: {
+                    kind: "table",
+                    type: "kind",
+                    children: {
+                        testTable: {
+                            name: "testTable",
+                            type: "type",
+                        },
+                    },
+                },
+                range: {
+                    kind: "range",
+                    type: "kind",
+                    children: {},
+                },
+                enum: {
+                    kind: "enum",
+                    type: "kind",
+                    children: {
+                        testEnum: {
+                            name: "testEnum",
+                            type: "type",
+                        },
+                    },
+                },
+                domain: {
+                    kind: "domain",
+                    type: "kind",
+                    children: {},
+                },
+            },
+        },
+    },
+};
+describe("Import Class", () => {
+    it("should initialize correctly with constructor arguments", () => {
+        const importInstance = new Import({
+            from: "module/path",
+            namedImports: ["component"],
+            star: "starImport",
+            default: "defaultImport",
+            typeOnly: true,
+        });
+        expect(importInstance.from).toBe("module/path");
+        expect(importInstance.namedImports).toEqual(["component"]);
+        expect(importInstance.star).toBe("starImport");
+        expect(importInstance.default).toBe("defaultImport");
+        expect(importInstance.typeOnly).toBe(true);
+    });
+    it("should create import fromInternal method correctly", () => {
+        const importInstance = Import.fromInternal({
+            source: "root/public/testEnum/testEnum.ts",
+            type: {
+                schema: "public",
+                kind: Canonical.Kind.Enum,
+                name: "testEnum",
+                canonical_name: "test",
+                dimensions: 1,
+                enum_values: ["test1", "test2", "test3"],
+                original_type: "string",
+            },
+        });
+        expect(importInstance).toBeInstanceOf(Import);
+        expect(typeof importInstance.from === "function" ||
+            typeof importInstance.from === "string").toBe(true);
+        if (typeof importInstance.from === "function") {
+            const generatedPath = importInstance.from(files);
+            expect(generatedPath).toBe("../enums/testEnum.ts");
+        }
+    });
+    it("should handle missing properties in fromInternal method", () => {
+        const importInstance = Import.fromInternal({
+            source: "root/public/testEnum/testEnum.ts",
+            type: {
+                schema: "public",
+                kind: Canonical.Kind.Enum,
+                name: "testEnum",
+                canonical_name: "test",
+                dimensions: 1,
+                enum_values: ["test1", "test2", "test3"],
+                original_type: "string",
+            },
+        });
+        expect(importInstance).toBeInstanceOf(Import);
+        expect(typeof importInstance.from === "function" ||
+            typeof importInstance.from === "string").toBe(true);
+        if (typeof importInstance.from === "function") {
+            const generatedPath = importInstance.from(files);
+            expect(generatedPath).toBe("../enums/testEnum.ts");
+        }
+    });
+    it("should handle missing `namedImports` or other constructor properties", () => {
+        const importInstance = new Import({ from: "module/path" });
+        expect(importInstance.from).toBe("module/path");
+        expect(importInstance.namedImports).toBeUndefined();
+        expect(importInstance.star).toBeUndefined();
+        expect(importInstance.default).toBeUndefined();
+        expect(importInstance.typeOnly).toBe(false);
+    });
+});
+describe("ImportList Class", () => {
+    it("should add imports correctly", () => {
+        const importList = new ImportList();
+        const newImport = new Import({
+            from: "module/path",
+            namedImports: ["MyComponent"],
+        });
+        importList.add(newImport);
+        expect(importList.imports).toHaveLength(1);
+        expect(importList.imports[0]).toBe(newImport);
+    });
+    it("should merge import lists correctly", () => {
+        const list1 = new ImportList([
+            new Import({ from: "module1", namedImports: ["a"] }),
+        ]);
+        const list2 = new ImportList([
+            new Import({ from: "module2", namedImports: ["b"] }),
+        ]);
+        const mergedList = ImportList.merge([list1, list2]);
+        expect(mergedList.imports).toHaveLength(2);
+    });
+    it("should merge import lists correctly with empty list", () => {
+        const list1 = new ImportList([
+            new Import({ from: "module1", namedImports: ["a"] }),
+        ]);
+        const list2 = new ImportList([]);
+        const mergedList = ImportList.merge([list1, list2]);
+        expect(mergedList.imports).toHaveLength(1);
+    });
+    it("should stringify imports correctly", () => {
+        const importList = new ImportList([
+            new Import({ from: "module1", namedImports: ["a"] }),
+            new Import({ from: "module1", namedImports: ["b"] }),
+        ]);
+        const result = importList.stringify(files);
+        expect(result).toContain('import { a, b } from "module1";');
+    });
+    it("should handle empty ImportList gracefully", () => {
+        const importList = new ImportList();
+        const files = {
+            name: "root",
+            type: "root",
+            children: {},
+        };
+        const result = importList.stringify(files);
+        expect(result).toBe("");
+    });
+    it("should handle duplicate imports and avoid repetition", () => {
+        const importList = new ImportList([
+            new Import({ from: "module1", namedImports: ["a"] }),
+            new Import({ from: "module1", namedImports: ["a"] }),
+        ]);
+        const result = importList.stringify(files);
+        expect(result).toBe('import { a } from "module1";');
+        expect(result.split("\n")).toBeArrayOfSize(1);
+    });
+});

package/lib/index.js

@@ -14,11 +14,27 @@ const yellow = (str) => (NO_COLOR ? str : `\x1b[33m${str}\x1b[0m`);
 const blue = (str) => (NO_COLOR ? str : `\x1b[34m${str}\x1b[0m`);
 const bold = (str) => (NO_COLOR ? str : `\x1b[1m${str}\x1b[0m`);
 const underline = (str) => (NO_COLOR ? str : `\x1b[4m${str}\x1b[0m`);
+const formatTime = (time) => {
+    const mins = Math.floor(time / 60000);
+    const secs = Math.floor((time % 60000) / 1000);
+    const ms = Math.floor(time % 1000);
+    const us = Math.floor((time * 1000) % 1000)
+        .toString()
+        .padStart(3, "0");
+    const parts = [];
+    if (mins)
+        parts.push(mins + "m");
+    if (secs)
+        parts.push(secs + "s");
+    if (!mins)
+        parts.push(ms + (!secs && us ? "." + us : "") + "ms");
+    return parts.join("");
+};
 const THRESHOLD1 = 800;
 const THRESHOLD2 = 1500;
 const time = (start, addParens = true) => {
     const diff = performance.now() - start;
-    const diffstr = diff.toFixed(2) + "ms";
+    const diffstr = formatTime(diff);
     const str = addParens ? parens(diffstr) : diffstr;
     if (diff < THRESHOLD1)
         return green(str);
@@ -115,9 +131,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 [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.functions);
+        const [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.function);
         const [supported_functions, unsupported_functions] = filter_unsupported_functions(unique_functions);
-        schema.functions = supported_functions;
+        schema.function = supported_functions;
         {
             const skipped = unsupported_functions.map(f => `  - ${f.name}`);
             if (skipped.length) {
@@ -136,11 +152,12 @@ const multifile = async (generators, schemas, opts) => {
             if (schema[kind].length < 1)
                 continue;
             createIndex = true;
-            await mkdir(joinpath(schemaDir, kind), { recursive: true });
-            console.log(" Creating %s:\n", kind);
+            const kindDir = joinpath(schemaDir, kind + "s");
+            await mkdir(kindDir, { recursive: true });
+            console.log(" Creating %s:\n", kind + "s");
             for (const [i, item] of schema[kind].entries()) {
                 const index = "[" + (i + 1 + "]").padEnd(3, " ");
-                const filename = joinpath(schemaDir, kind, def_gen.formatSchemaMemberName(item) + ".ts");
+                const filename = joinpath(kindDir, def_gen.formatSchemaMemberName(item) + ".ts");
                 const exists = await existsSync(filename);
                 if (exists) {
                     warnings.add(`Skipping ${item.kind} "${item.name}": formatted name clashes. Wanted to create ${filename}`);
@@ -159,7 +176,7 @@ const multifile = async (generators, schemas, opts) => {
             {
                 const start = performance.now();
                 const imports = new ImportList();
-                const fileName = joinpath(schemaDir, kind, "index.ts");
+                const fileName = joinpath(kindDir, "index.ts");
                 const kindIndex = join(gens.map(gen => gen.schemaKindIndex({ source: fileName, imports }, schema, kind, def_gen)));
                 const file = join([imports.stringify(files), kindIndex]);
                 await write(fileName, file);