true-pg 0.6.0 → 0.7.0

package/lib/extractor/adapter.d.ts

@@ -1,16 +1,21 @@
 import Pg from "pg";
 import { PGlite as Pglite } from "@electric-sql/pglite";
+import { type Canonical } from "./canonicalise.ts";
 export declare class DbAdapter {
     private client;
     private external?;
+    rawTypeCache: Map<string, Promise<Canonical>>;
+    canonicalCache: Map<string, Promise<Canonical>>;
     constructor(client: Pg.Client | Pg.Pool | Pglite, external?: boolean | undefined);
+    clearCache(): void;
+    canonicalise(types: string[]): Promise<Canonical[]>;
     connect(): Promise<void>;
     /**
      * Execute a read query and return just the rows
      */
     query<R, I extends any[] = []>(text: string, params?: I): Promise<R[]>;
     /**
-     * Close the connection if needed
+     * Close the connection and clear the cache
      */
     close(): Promise<void>;
 }

package/lib/extractor/adapter.js

@@ -1,11 +1,23 @@
 import Pg from "pg";
 import { PGlite as Pglite } from "@electric-sql/pglite";
+import { canonicalise } from "./canonicalise.js";
 export class DbAdapter {
     client;
     external;
+    rawTypeCache;
+    canonicalCache;
     constructor(client, external) {
         this.client = client;
         this.external = external;
+        this.canonicalCache = new Map();
+        this.rawTypeCache = new Map();
+    }
+    clearCache() {
+        this.canonicalCache.clear();
+        this.rawTypeCache.clear();
+    }
+    async canonicalise(types) {
+        return await canonicalise(this, types, this.rawTypeCache, this.canonicalCache);
     }
     async connect() {
         if (this.external)
@@ -19,6 +31,7 @@ export class DbAdapter {
         else if (this.client instanceof Pglite) {
             // Pglite doesn't have an explicit connect method
         }
+        this.clearCache();
     }
     /**
      * Execute a read query and return just the rows
@@ -47,11 +60,12 @@ export class DbAdapter {
         }
     }
     /**
-     * Close the connection if needed
+     * Close the connection and clear the cache
      */
     async close() {
         if (this.external)
             return;
+        this.clearCache();
         if (this.client instanceof Pg.Pool) {
             this.client.end();
         }

package/lib/extractor/canonicalise.d.ts

@@ -1,6 +1,49 @@
 import { DbAdapter } from "./adapter.ts";
+interface ParsedTypeName {
+    /** Name after removing modifiers and brackets, e.g. "varchar" in "varchar(50)" */
+    base: string;
+    /** Modifiers, e.g. "50" in "varchar(50)" */
+    modifiers: string | null;
+    /** Number of dimensions from explicit brackets, e.g. 1 in "int[]" */
+    dimensions: number;
+    /** Original type name, e.g. "varchar(50)" */
+    original: string;
+}
+/**
+ * Parses a PostgreSQL type name string to extract its base name,
+ * modifiers, and dimensions from explicit '[]' brackets.
+ *
+ * Examples:
+ *
+ * - `parseTypeName("varchar(50)")`
+ *
+ *		`⤷ { baseTypeName: "varchar", modifiers: "50", dimensions: 0, originalTypeName: "varchar(50)" }`
+ *
+ * - `parseTypeName("int[]")`
+ *
+ *		`⤷ { baseTypeName: "int", modifiers: null, dimensions: 1, originalTypeName: "int[]" }`
+ *
+ * - `parseTypeName("public.my_table[][]")`
+ *
+ *		`⤷ { baseTypeName: "public.my_table", modifiers: null, dimensions: 2, originalTypeName: "public.my_table[][]" }`
+ *
+ * - `parseTypeName("numeric(10, 2)[]")`
+ *
+ *		`⤷ { baseTypeName: "numeric", modifiers: "10, 2", dimensions: 1, originalTypeName: "numeric(10, 2)[]" }`
+ *
+ * - `parseTypeName("geometry(Point, 4326)")`
+ *
+ *		`⤷ { baseTypeName: "geometry", modifiers: "Point, 4326", dimensions: 0, originalTypeName: "geometry(Point, 4326)" }`
+ *
+ * - `parseTypeName("_text")`
+ *
+ *		`⤷ { baseTypeName: "_text", modifiers: null, dimensions: 0, originalTypeName: "_text" }`
+ *
+ *		Internal arrays aren't handled here
+ */
+export declare function parseTypeName(type: string): ParsedTypeName;
 export declare namespace Canonical {
-    export enum Kind {
+    enum Kind {
         Base = "base",
         Composite = "composite",
         Domain = "domain",
@@ -18,14 +61,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 +86,25 @@ 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 ExclusiveCanonProps = Omit<Canonical, keyof Canonical.Abstract>;
+export declare const canonicalise: (db: DbAdapter, types: string[], rawTypeCache: Map<string, Promise<Canonical>>, canonicalCache: Map<string, Promise<ExclusiveCanonProps>>) => Promise<Canonical[]>;
+export declare const oidsToQualifiedNames: (db: DbAdapter, oids: number[]) => Promise<string[]>;
+export declare const canonicaliseFromOids: (db: DbAdapter, oids: number[]) => Promise<Canonical[]>;
+export {};