true-pg 0.6.0 → 0.8.0

package/lib/extractor/{canonicalise.d.ts → canonicalise/types.d.ts}

@@ -1,6 +1,5 @@
-import { DbAdapter } from "./adapter.ts";
 export declare namespace Canonical {
-    export enum Kind {
+    enum Kind {
         Base = "base",
         Composite = "composite",
         Domain = "domain",
@@ -18,14 +17,14 @@ export declare namespace Canonical {
         dimensions: number;
         modifiers?: string | null;
     }
-    export interface Base extends Abstract {
+    interface Base extends Abstract {
         kind: Kind.Base;
     }
-    export interface Enum extends Abstract {
+    interface Enum extends Abstract {
         kind: Kind.Enum;
         enum_values: string[];
     }
-    export interface CompositeAttribute {
+    interface CompositeAttribute {
         name: string;
         index: number;
         type: Canonical;
@@ -43,22 +42,29 @@ export declare namespace Canonical {
          */
         generated: "ALWAYS" | "NEVER" | "BY DEFAULT";
     }
-    export interface Composite extends Abstract {
+    interface Composite extends Abstract {
         kind: Kind.Composite;
         attributes: CompositeAttribute[];
     }
-    export interface Domain extends Abstract {
+    interface Domain extends Abstract {
         kind: Kind.Domain;
         domain_base_type: Canonical;
     }
-    export interface Range extends Abstract {
+    interface Range extends Abstract {
         kind: Kind.Range;
         range_subtype: Canonical;
     }
-    export interface Pseudo extends Abstract {
+    interface Pseudo extends Abstract {
         kind: Kind.Pseudo;
     }
-    export {};
 }
 export type Canonical = Canonical.Base | Canonical.Enum | Canonical.Composite | Canonical.Domain | Canonical.Range | Canonical.Pseudo;
-export declare const canonicalise: (db: DbAdapter, types: string[]) => Promise<Canonical[]>;
+type Exclusive<T> = Omit<T, Exclude<keyof Canonical.Abstract, "kind" | "canonical_name">>;
+export type ExclusiveBase = Exclusive<Canonical.Base>;
+export type ExclusiveEnum = Exclusive<Canonical.Enum>;
+export type ExclusiveComposite = Exclusive<Canonical.Composite>;
+export type ExclusiveDomain = Exclusive<Canonical.Domain>;
+export type ExclusiveRange = Exclusive<Canonical.Range>;
+export type ExclusivePseudo = Exclusive<Canonical.Pseudo>;
+export type ExclusiveCanonProps = ExclusiveBase | ExclusiveEnum | ExclusiveComposite | ExclusiveDomain | ExclusiveRange | ExclusivePseudo;
+export {};

package/lib/extractor/canonicalise/types.js

@@ -0,0 +1,13 @@
+export var Canonical;
+(function (Canonical) {
+    let Kind;
+    (function (Kind) {
+        Kind["Base"] = "base";
+        Kind["Composite"] = "composite";
+        Kind["Domain"] = "domain";
+        Kind["Enum"] = "enum";
+        Kind["Range"] = "range";
+        Kind["Pseudo"] = "pseudo";
+        Kind["Unknown"] = "unknown";
+    })(Kind = Canonical.Kind || (Canonical.Kind = {}));
+})(Canonical || (Canonical = {}));

package/lib/extractor/index.d.ts

@@ -1,5 +1,6 @@
 import Pg from "pg";
 import { PGlite as Pglite } from "@electric-sql/pglite";
+import { DbAdapter } from "./adapter.ts";
 import { type TableDetails } from "./kinds/table.ts";
 import { type ViewDetails } from "./kinds/view.ts";
 import { type MaterializedViewDetails } from "./kinds/materialized-view.ts";
@@ -10,7 +11,7 @@ import { type DomainDetails } from "./kinds/domain.ts";
 import { type RangeDetails } from "./kinds/range.ts";
 import type { PgType } from "./pgtype.ts";
 export { pgTypeKinds, type PgType, type Kind } from "./pgtype.ts";
-import { Canonical } from "./canonicalise.ts";
+import { Canonical } from "./canonicalise/index.ts";
 export { Canonical };
 export type { TableDetails, ViewDetails, MaterializedViewDetails, EnumDetails, CompositeTypeDetails, FunctionDetails, DomainDetails, RangeDetails, };
 export type { TableColumn } from "./kinds/table.ts";
@@ -72,7 +73,7 @@ export interface ExtractSchemaOptions {
     onProgressEnd?: () => void;
 }
 export declare class Extractor {
-    private db;
+    db: DbAdapter;
     /**
      * @param connectionConfig - Connection string or configuration object for Postgres connection
      */
@@ -81,7 +82,6 @@ export declare class Extractor {
         uri?: string;
         config?: Pg.ConnectionConfig;
     });
-    canonicalise(types: string[]): Promise<Canonical[]>;
     getBuiltinTypes(): Promise<{
         name: string;
         format: string;
@@ -92,5 +92,8 @@ export declare class Extractor {
      * @param options - Optional options
      * @returns A record of all the schemas extracted, indexed by schema name.
      */
-    extractSchemas(options?: ExtractSchemaOptions): Promise<Record<string, Schema>>;
+    extractSchemas(options?: ExtractSchemaOptions): Promise<{
+        schemas: Record<string, Schema>;
+        queryCount: number;
+    }>;
 }

package/lib/extractor/index.js

@@ -11,7 +11,7 @@ import extractDomain, {} from "./kinds/domain.js";
 import extractRange, {} from "./kinds/range.js";
 import fetchTypes from "./fetchTypes.js";
 export { pgTypeKinds } from "./pgtype.js";
-import { canonicalise, Canonical } from "./canonicalise.js";
+import { Canonical } from "./canonicalise/index.js";
 export { Canonical };
 export { FunctionReturnTypeKind } from "./kinds/function.js";
 const emptySchema = {
@@ -63,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;
@@ -136,13 +133,11 @@ export class Extractor {
             }
             schemas[p.schemaName][p.kind] = [...schemas[p.schemaName][p.kind], p];
         }
-        const result = 
-        //  options?.resolveViews
-        // 	? resolveViewColumns(schemas)
-        // :
-        schemas;
+        // resolve all canonical types and patch the results into their placeholders
+        await db.resolve();
+        const queryCount = db.queryCount;
         options?.onProgressEnd?.();
         await db.close();
-        return result;
+        return { schemas, queryCount };
     }
 }

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/index.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 = db.enqueue(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/index.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 = db.enqueue(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/index.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 ? row.arg_types.map(type => db.enqueue(type)) : [];
         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 = columnTypes.map(type => db.enqueue(type));
             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 = db.enqueue(row.return_type_string);
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
                         type: canonicalReturnType,
@@ -120,19 +119,17 @@ 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];
                     returnType = {
                         kind: FunctionReturnTypeKind.Regular,
-                        type: canonicalReturnType,
+                        type: db.enqueue(row.return_type_string),
                         isSet: row.returns_set,
                     };
                 }
             }
             else {
-                const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
                 returnType = {
                     kind: FunctionReturnTypeKind.Regular,
-                    type: canonicalReturnType,
+                    type: db.enqueue(row.return_type_string),
                     isSet: row.returns_set,
                 };
             }

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/index.ts";
 export interface MaterializedViewColumn {
     name: string;
     type: Canonical;

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

@@ -1,6 +1,5 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractMaterializedView = async (db, mview) => {
-    // 1. Query for columns (using pg_attribute for potentially more accurate nullability)
+    // Query for columns (using pg_attribute for potentially more accurate nullability)
     const columnQuery = await db.query(`
 		SELECT
 			attr.attname AS "name",
@@ -24,17 +23,14 @@ const extractMaterializedView = async (db, mview) => {
 			AND NOT attr.attisdropped
 		ORDER BY attr.attnum;
 		`, [mview.name, mview.schemaName]);
-    // 2. Get canonical types
-    const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await canonicalise(db, definedTypes);
-    const columns = columnQuery.map((row, index) => ({
+    const columns = columnQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         isNullable: row.isNullable,
         ordinalPosition: row.ordinalPosition,
         comment: row.comment,
     }));
-    // 3. Query for materialized view definition, comment, and properties
+    // Query for materialized view definition, comment, and properties
     const mviewInfoQuery = await db.query(`
 		SELECT
 			m.definition,

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/index.ts";
 /**
  * Range type in a schema with details.
  */

package/lib/extractor/kinds/range.js

@@ -1,9 +1,7 @@
-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 = db.enqueue(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/index.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",
@@ -106,14 +105,10 @@ const extractTable = async (db, table) => {
 			AND NOT attr.attisdropped
 		ORDER BY col.ordinal_position;
 	`, [table.name, table.schemaName]);
-    // 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);
     // Combine the column information with the canonical type information
-    const columns = columnsQuery.map((row, index) => ({
+    const columns = columnsQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         comment: row.comment,
         defaultValue: row.defaultValue,
         isPrimaryKey: row.isPrimaryKey,
@@ -123,7 +118,6 @@ const extractTable = async (db, table) => {
         isIdentity: row.isIdentity,
         isUpdatable: row.isUpdatable,
         generated: row.generated,
-        informationSchemaValue: row.informationSchemaValue,
     }));
     const indicesQuery = await db.query(`
 		WITH index_columns AS (

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/index.ts";
 export interface ViewColumn {
     name: string;
     type: Canonical;

package/lib/extractor/kinds/view.js

@@ -1,6 +1,5 @@
-import { Canonical, canonicalise } from "../canonicalise.js";
 const extractView = async (db, view) => {
-    // 1. Query for columns (information_schema.columns + pg_attribute)
+    // Query for columns (information_schema.columns + pg_attribute)
     const columnQuery = await db.query(`
 		SELECT
 			col.column_name AS "name",
@@ -23,17 +22,14 @@ const extractView = async (db, view) => {
 			AND NOT attr.attisdropped -- Exclude dropped columns
 		ORDER BY col.ordinal_position;
 		`, [view.name, view.schemaName]);
-    // 2. Get canonical types
-    const definedTypes = columnQuery.map(row => row.definedType);
-    const canonicalTypes = await canonicalise(db, definedTypes);
-    const columns = columnQuery.map((row, index) => ({
+    const columns = columnQuery.map(row => ({
         name: row.name,
-        type: canonicalTypes[index],
+        type: db.enqueue(row.definedType),
         isNullable: row.isNullable,
         isUpdatable: row.isUpdatable,
         ordinalPosition: row.ordinalPosition,
     }));
-    // 3. Query for view definition, comment, and other properties
+    // Query for view definition, comment, and other properties
     const viewInfoQuery = await db.query(`
 		SELECT
 			d.description AS "comment",

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,180 @@
+import { Canonical } from "./extractor/canonicalise/index.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);
@@ -201,8 +217,8 @@ export async function generate(opts, generators) {
     const out = validated.out;
     const extractor = new Extractor(opts);
     const start = performance.now();
-    const schemas = await extractor.extractSchemas();
-    console.log("Extracted schemas %s\n", time(start));
+    const { schemas, queryCount } = await extractor.extractSchemas();
+    console.log("Extracted schemas %s (made %s queries)\n", time(start), queryCount);
     console.info("Generators enabled: %s\n", validated.generators.join(", "));
     generators = validated.generators.map(generator => builtin_generators[generator]).concat(generators ?? []);
     console.log("Clearing directory and generating schemas at '%s'\n", out);