true-pg 0.6.0 → 0.7.0

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

@@ -16,7 +16,7 @@ export declare const routineKindMap: {
     readonly f: "function";
 };
 export type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
-export declare const pgTypeKinds: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
+export declare const pgTypeKinds: ("function" | "composite" | "domain" | "enum" | "range" | "table" | "view" | "materializedView")[];
 export type Kind = (typeof pgTypeKinds)[number];
 /**
  * Base type for Postgres objects.

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,8 +18,11 @@ export class Import {
         return new Import({
             from: files => {
                 const schema = files.children[t.schema];
-                const kind = schema.children[t.kind];
-                const type = kind.children[t.name];
+                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);
             },

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);

package/lib/kysely/index.js

@@ -31,6 +31,8 @@ export const Kysely = createGenerator(opts => {
             qualified = `Generated<${qualified}>`;
             ky(ctx, "Generated");
         }
+        // TODO: Use ColumnType for appropriate cases:
+        // composite, jsonb, json, date types, etc
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
         out += `: ${qualified}`;

package/lib/types.d.ts

@@ -1,6 +1,6 @@
 import { Canonical, type TableDetails, type ViewDetails, type MaterializedViewDetails, type EnumDetails, type CompositeTypeDetails, type DomainDetails, type RangeDetails, type FunctionDetails, type SchemaType, type Schema, type FunctionReturnType } from "./extractor/index.ts";
 import type { ImportList } from "./imports.ts";
-export declare const allowed_kind_names: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
+export declare const allowed_kind_names: ("function" | "composite" | "domain" | "enum" | "range" | "table" | "view" | "materializedView")[];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
     name: string;

package/lib/util.d.ts

@@ -1,3 +1,10 @@
+export declare const unreachable: (value: never) => never;
+export declare class Deferred<T> {
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+    constructor();
+}
 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;

package/lib/util.js

@@ -1,3 +1,17 @@
+export const unreachable = (value) => {
+    throw new Error(`Fatal: Reached unreachable code: ${value}`);
+};
+export class Deferred {
+    resolve;
+    reject;
+    promise;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
 export const eq = (a, b) => {
     if (a === b)
         return true;

package/lib/zod/index.js

@@ -22,16 +22,12 @@ export const Zod = createGenerator(opts => {
         out += quoteI(col.name);
         const nullable = col.isNullable || col.generated === "BY DEFAULT" || col.defaultValue;
         let type = generator.formatType(ctx, col.type, { nullable });
-        if (nullable)
-            type += `.optional()`;
         out += `: ${type}`;
         return `\t${out},\n`;
     };
     const composite_attribute = (ctx, attr) => {
         let out = quoteI(attr.name);
         out += `: ${generator.formatType(ctx, attr.type, { nullable: attr.isNullable })}`;
-        if (attr.isNullable)
-            out += ".optional()";
         return out;
     };
     const generator = {
@@ -80,7 +76,7 @@ export const Zod = createGenerator(opts => {
             if ("dimensions" in type)
                 base += ".array()".repeat(type.dimensions);
             if (attr?.nullable)
-                base += ".nullable()";
+                base += ".optional()";
             return base;
         },
         table(ctx, table) {
@@ -163,8 +159,6 @@ export const Zod = createGenerator(opts => {
                 for (const param of inputParams) {
                     // TODO: update imports for non-primitive types based on typeInfo.kind
                     out += "\t\t" + this.formatType(ctx, param.type, { nullable: param.hasDefault });
-                    if (param.hasDefault)
-                        out += ".optional()";
                     out += `, // ${param.name}\n`;
                 }
                 out += "\t])";
@@ -249,9 +243,7 @@ export const Zod = createGenerator(opts => {
         fullIndex(ctx, schemas, main_generator) {
             const generator = main_generator ?? this;
             const parts = [];
-            parts.push(schemas
-                .map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
-                .join("\n"));
+            parts.push(schemas.map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`).join("\n"));
             {
                 let validator = `export const Validators = {\n`;
                 validator += join(schemas.map(schema => {

package/package.json

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