blendsdk 5.33.0

package/dist/codegen/database/introspect/introspect-query.js

@@ -0,0 +1,416 @@
+export const INTROSPECTION_SQL = `
+-- ===========================================================
+-- Enhanced introspect.sql
+-- Includes user-defined types (UDTs) and
+-- FILTERS composite types to ONLY those created by hand
+-- (standalone composites: pg_class.relkind = 'c').
+-- ===========================================================
+
+WITH base AS (
+SELECT
+  current_database()                                   AS database_name,
+  n.nspname                                            AS schema_name,
+  c.relname                                            AS relation_name,
+  CASE c.relkind
+    WHEN 'r' THEN 'table'
+    WHEN 'p' THEN 'partitioned table'
+    WHEN 'v' THEN 'view'
+    WHEN 'm' THEN 'materialized view'
+    WHEN 'f' THEN 'foreign table'
+    ELSE c.relkind::text
+  END                                                  AS relation_kind,
+
+  obj_description(c.oid, 'pg_class')                   AS table_comment,
+
+  a.attname                                            AS column_name,
+  col_description(a.attrelid, a.attnum)                AS column_comment,
+
+  (NOT a.attnotnull)                                   AS is_nullable,
+
+  (ad.adbin IS NOT NULL)                               AS has_default,
+  CASE
+    WHEN ad.adbin IS NOT NULL THEN pg_get_expr(ad.adbin, ad.adrelid)
+    ELSE NULL
+  END                                                  AS column_default,
+
+  COALESCE(bt.typname, t.typname)                      AS pg_type,
+
+  format_type(a.atttypid, a.atttypmod)                 AS formatted_type,
+
+  (et.typcategory = 'A')                               AS is_array,
+
+  CASE WHEN et.typcategory = 'A'
+       THEN COALESCE(elem_bt.typname, elem.typname)
+  END                                                  AS array_element_pg_type,
+  CASE WHEN et.typcategory = 'A'
+       THEN format_type(COALESCE(elem_bt.oid, elem.oid), a.atttypmod)
+  END                                                  AS array_element_formatted_type,
+
+  CASE
+    WHEN (
+      (et.typcategory = 'A' AND COALESCE(elem_bt.typname, elem.typname) IN ('varchar','bpchar'))
+      OR (et.typcategory <> 'A' AND COALESCE(bt.typname, t.typname) IN ('varchar','bpchar'))
+    ) THEN NULLIF(a.atttypmod - 4, -1)
+    ELSE NULL
+  END                                                  AS length,
+
+  CASE
+    WHEN (
+      (et.typcategory = 'A' AND COALESCE(elem_bt.typname, elem.typname) = 'numeric')
+      OR (et.typcategory <> 'A' AND COALESCE(bt.typname, t.typname) = 'numeric')
+    ) THEN information_schema._pg_numeric_precision(COALESCE(elem_bt.oid, elem.oid, a.atttypid), a.atttypmod)
+    ELSE NULL
+  END                                                  AS precision,
+
+  CASE
+    WHEN (
+      (et.typcategory = 'A' AND COALESCE(elem_bt.typname, elem.typname) = 'numeric')
+      OR (et.typcategory <> 'A' AND COALESCE(bt.typname, t.typname) = 'numeric')
+    ) THEN information_schema._pg_numeric_scale(COALESCE(elem_bt.oid, elem.oid, a.atttypid), a.atttypmod)
+    ELSE NULL
+  END                                                  AS scale,
+
+  EXISTS (
+    SELECT 1
+    FROM pg_index i
+    WHERE i.indrelid = c.oid
+      AND i.indisprimary
+      AND a.attnum = ANY(i.indkey)
+  )                                                    AS is_primary_key,
+
+  EXISTS (
+    SELECT 1
+    FROM pg_index i
+    WHERE i.indrelid = c.oid
+      AND i.indisunique
+      AND a.attnum = ANY(i.indkey)
+  )                                                    AS is_unique,
+
+  EXISTS (
+    SELECT 1
+    FROM pg_constraint con
+    WHERE con.conrelid = c.oid
+      AND con.contype = 'f'
+      AND a.attnum = ANY(con.conkey)
+  )                                                    AS is_foreign_key,
+
+  (
+    SELECT jsonb_agg(jsonb_build_object(
+      'constraint_name', con.conname,
+      'schema', n2.nspname,
+      'table', c2.relname,
+      'columns',
+        (
+          SELECT jsonb_agg(a2.attname ORDER BY k2.ord)
+          FROM unnest(con.confkey) WITH ORDINALITY AS k2(attnum, ord)
+          JOIN pg_attribute a2 ON a2.attrelid = con.confrelid AND a2.attnum = k2.attnum
+        ),
+      'referenced_columns',
+        (
+          SELECT jsonb_agg(a1.attname ORDER BY k1.ord)
+          FROM unnest(con.conkey) WITH ORDINALITY AS k1(attnum, ord)
+          JOIN pg_attribute a1 ON a1.attrelid = con.conrelid AND a1.attnum = k1.attnum
+        )
+    ) ORDER BY con.conname)
+    FROM pg_constraint con
+    JOIN pg_class      c2 ON c2.oid = con.confrelid
+    JOIN pg_namespace  n2 ON n2.oid = c2.relnamespace
+    WHERE con.conrelid = c.oid
+      AND con.contype = 'f'
+      AND a.attnum = ANY(con.conkey)
+  )                                                    AS fk_info,
+
+  EXISTS (
+    SELECT 1
+    FROM pg_constraint con
+    WHERE con.conrelid = c.oid
+      AND con.contype = 'c'
+      AND a.attnum = ANY(con.conkey)
+  )                                                    AS is_check_constrained,
+
+  (
+    SELECT string_agg(pg_get_constraintdef(con.oid), ' AND ')
+    FROM pg_constraint con
+    WHERE con.conrelid = c.oid
+      AND con.contype = 'c'
+      AND a.attnum = ANY(con.conkey)
+  )                                                    AS check_constraints,
+
+  CASE
+    WHEN et.typcategory = 'A' THEN EXISTS (
+      SELECT 1 FROM pg_type tt
+      WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid)
+        AND tt.typtype = 'e'
+    )
+    ELSE EXISTS (
+      SELECT 1 FROM pg_type tt
+      WHERE tt.oid = COALESCE(bt.oid, t.oid)
+        AND tt.typtype = 'e'
+    )
+  END                                                  AS is_enum,
+
+  CASE
+    WHEN et.typcategory = 'A' THEN (
+      SELECT ns.nspname || '.' || tt.typname
+      FROM pg_type tt
+      JOIN pg_namespace ns ON ns.oid = tt.typnamespace
+      WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid)
+        AND tt.typtype = 'e'
+    )
+    ELSE (
+      SELECT ns.nspname || '.' || tt.typname
+      FROM pg_type tt
+      JOIN pg_namespace ns ON ns.oid = tt.typnamespace
+      WHERE tt.oid = COALESCE(bt.oid, t.oid)
+        AND tt.typtype = 'e'
+    )
+  END                                                  AS enum_type_name,
+
+  CASE
+    WHEN et.typcategory = 'A' THEN (
+      SELECT array_agg(e.enumlabel ORDER BY e.enumsortorder)
+      FROM pg_enum e
+      WHERE e.enumtypid = COALESCE(elem_bt.oid, elem.oid)
+    )
+    ELSE (
+      SELECT array_agg(e.enumlabel ORDER BY e.enumsortorder)
+      FROM pg_enum e
+      WHERE e.enumtypid = COALESCE(bt.oid, t.oid)
+    )
+  END                                                  AS enum_labels,
+
+  t.oid                                                AS type_oid
+
+FROM pg_attribute      a
+JOIN pg_class          c        ON c.oid = a.attrelid
+JOIN pg_namespace      n        ON n.oid = c.relnamespace
+JOIN pg_type           t        ON t.oid = a.atttypid
+LEFT  JOIN pg_type     bt       ON t.typtype = 'd' AND bt.oid = t.typbasetype
+LEFT  JOIN pg_type     et       ON et.oid = COALESCE(bt.oid, t.oid)
+LEFT  JOIN pg_type     elem     ON elem.oid = CASE WHEN et.typcategory = 'A' THEN et.typelem END
+LEFT  JOIN pg_type     elem_bt  ON elem.typtype = 'd' AND elem_bt.oid = elem.typbasetype
+LEFT  JOIN pg_attrdef  ad       ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+WHERE
+  a.attnum > 0
+  AND NOT a.attisdropped
+  AND c.relkind IN ('r','p','v','m','f')
+  AND n.nspname NOT IN ('pg_catalog','information_schema')
+)
+
+-- 1) Standalone composite types only (created by hand)
+, composite AS (
+  SELECT
+    current_database()                                   AS database_name,
+    n.nspname                                            AS schema_name,
+    t.typname                                            AS relation_name,
+    'composite type'                                     AS relation_kind,
+    obj_description(t.oid, 'pg_type')                    AS table_comment,
+
+    a.attname                                            AS column_name,
+    col_description(c.oid, a.attnum)                     AS column_comment,
+
+    NOT a.attnotnull                                     AS is_nullable,
+    FALSE                                                AS has_default,
+    NULL::text                                           AS column_default,
+
+    COALESCE(bt.typname, ty.typname)                     AS pg_type,
+    format_type(a.atttypid, a.atttypmod)                 AS formatted_type,
+
+    (et.typcategory = 'A')                               AS is_array,
+    CASE WHEN et.typcategory = 'A' THEN COALESCE(elem_bt.typname, elem.typname) END AS array_element_pg_type,
+    CASE WHEN et.typcategory = 'A' THEN format_type(COALESCE(elem_bt.oid, elem.oid), a.atttypmod) END AS array_element_formatted_type,
+
+    CASE
+      WHEN et.typcategory IN ('S','E','P','R') THEN NULL
+      WHEN et.typcategory = 'A' THEN NULL
+      ELSE information_schema._pg_char_max_length(a.atttypid, a.atttypmod)
+    END                                                 AS length,
+
+    information_schema._pg_numeric_precision(COALESCE(elem_bt.oid, elem.oid, a.atttypid), a.atttypmod) AS precision,
+    information_schema._pg_numeric_scale(COALESCE(elem_bt.oid, elem.oid, a.atttypid), a.atttypmod)     AS scale,
+
+    FALSE                                               AS is_primary_key,
+    FALSE                                               AS is_unique,
+    FALSE                                               AS is_foreign_key,
+    NULL::jsonb                                         AS fk_info,
+
+    FALSE                                               AS is_check_constrained,
+    NULL::text                                          AS check_constraints,
+
+    EXISTS (
+      SELECT 1 FROM pg_type tt
+      WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid, bt.oid, ty.oid) AND tt.typtype = 'e'
+    )                                                   AS is_enum,
+
+    CASE
+      WHEN EXISTS (
+        SELECT 1 FROM pg_type tt
+        WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid) AND tt.typtype = 'e'
+      ) THEN (
+        SELECT ns.nspname || '.' || tt.typname
+        FROM pg_type tt JOIN pg_namespace ns ON ns.oid = tt.typnamespace
+        WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid)
+      )
+      WHEN EXISTS (
+        SELECT 1 FROM pg_type tt
+        WHERE tt.oid = COALESCE(bt.oid, ty.oid) AND tt.typtype = 'e'
+      ) THEN (
+        SELECT ns.nspname || '.' || tt.typname
+        FROM pg_type tt JOIN pg_namespace ns ON ns.oid = tt.typnamespace
+        WHERE tt.oid = COALESCE(bt.oid, ty.oid)
+      )
+      ELSE NULL
+    END                                                 AS enum_type_name,
+
+    CASE
+      WHEN EXISTS (
+        SELECT 1 FROM pg_type tt
+        WHERE tt.oid = COALESCE(elem_bt.oid, elem.oid) AND tt.typtype = 'e'
+      ) THEN (
+        SELECT array_agg(e.enumlabel ORDER BY e.enumsortorder)
+        FROM pg_enum e WHERE e.enumtypid = COALESCE(elem_bt.oid, elem.oid)
+      )
+      WHEN EXISTS (
+        SELECT 1 FROM pg_type tt
+        WHERE tt.oid = COALESCE(bt.oid, ty.oid) AND tt.typtype = 'e'
+      ) THEN (
+        SELECT array_agg(e.enumlabel ORDER BY e.enumsortorder)
+        FROM pg_enum e WHERE e.enumtypid = COALESCE(bt.oid, ty.oid)
+      )
+      ELSE NULL
+    END                                                 AS enum_labels,
+
+    a.atttypid                                          AS type_oid
+
+  FROM pg_type t
+  JOIN pg_namespace n ON n.oid = t.typnamespace
+  JOIN pg_class c ON c.oid = t.typrelid
+  JOIN pg_attribute a ON a.attrelid = c.oid
+  JOIN pg_type ty ON ty.oid = a.atttypid
+  LEFT JOIN pg_type bt      ON ty.typtype = 'd' AND bt.oid = ty.typbasetype
+  LEFT JOIN pg_type et      ON et.oid = COALESCE(bt.oid, ty.oid)
+  LEFT JOIN pg_type elem    ON elem.oid = CASE WHEN et.typcategory = 'A' THEN et.typelem END
+  LEFT JOIN pg_type elem_bt ON elem.typtype = 'd' AND elem_bt.oid = elem.typbasetype
+  WHERE t.typtype = 'c'
+    AND c.relkind = 'c'                     -- <<< filter to standalone composites created by hand
+    AND a.attnum > 0 AND NOT a.attisdropped
+    AND n.nspname NOT IN ('pg_catalog','information_schema')
+)
+
+-- 2) Enum types: one row per label
+, enum_rows AS (
+  SELECT
+    current_database()                       AS database_name,
+    n.nspname                                 AS schema_name,
+    t.typname                                 AS relation_name,
+    'enum type'                               AS relation_kind,
+    obj_description(t.oid, 'pg_type')         AS table_comment,
+
+    e.enumlabel                               AS column_name,
+    NULL::text                                AS column_comment,
+
+    NULL::boolean                             AS is_nullable,
+    FALSE                                     AS has_default,
+    NULL::text                                AS column_default,
+
+    'text'                                    AS pg_type,
+    'text'                                    AS formatted_type,
+
+    FALSE                                     AS is_array,
+    NULL::text                                AS array_element_pg_type,
+    NULL::text                                AS array_element_formatted_type,
+
+    NULL::integer                             AS length,
+    NULL::integer                             AS precision,
+    NULL::integer                             AS scale,
+
+    FALSE                                     AS is_primary_key,
+    FALSE                                     AS is_unique,
+    FALSE                                     AS is_foreign_key,
+    NULL::jsonb                               AS fk_info,
+
+    TRUE                                      AS is_check_constrained,
+    NULL::text                                AS check_constraints,
+
+    TRUE                                      AS is_enum,
+    n.nspname || '.' || t.typname             AS enum_type_name,
+    NULL::text[]                              AS enum_labels,
+
+    t.oid                                     AS type_oid
+  FROM pg_type t
+  JOIN pg_namespace n ON n.oid = t.typnamespace
+  JOIN pg_enum e ON e.enumtypid = t.oid
+  WHERE t.typtype = 'e'
+    AND n.nspname NOT IN ('pg_catalog','information_schema')
+)
+
+-- 3) Domain types: one synthetic "(base)" row with CHECKs
+, domain_rows AS (
+  SELECT
+    current_database()                                   AS database_name,
+    n.nspname                                            AS schema_name,
+    t.typname                                            AS relation_name,
+    'domain type'                                        AS relation_kind,
+    obj_description(t.oid, 'pg_type')                    AS table_comment,
+
+    '(base)'                                             AS column_name,
+    NULL::text                                           AS column_comment,
+
+    NULL::boolean                                        AS is_nullable,
+    FALSE                                                AS has_default,
+    NULL::text                                           AS column_default,
+
+    COALESCE(bt.typname, baset.typname)                  AS pg_type,
+    format_type(t.typbasetype, t.typtypmod)              AS formatted_type,
+
+    FALSE                                                AS is_array,
+    NULL::text                                           AS array_element_pg_type,
+    NULL::text                                           AS array_element_formatted_type,
+
+    information_schema._pg_char_max_length(t.typbasetype, t.typtypmod) AS length,
+    information_schema._pg_numeric_precision(t.typbasetype, t.typtypmod) AS precision,
+    information_schema._pg_numeric_scale(t.typbasetype, t.typtypmod)     AS scale,
+
+    FALSE                                                AS is_primary_key,
+    FALSE                                                AS is_unique,
+    FALSE                                                AS is_foreign_key,
+    NULL::jsonb                                          AS fk_info,
+
+    (EXISTS (SELECT 1 FROM pg_constraint con WHERE con.contypid = t.oid AND con.contype = 'c')) AS is_check_constrained,
+    (
+      SELECT string_agg(pg_get_constraintdef(con.oid), ' AND ')
+      FROM pg_constraint con
+      WHERE con.contypid = t.oid AND con.contype = 'c'
+    )                                                    AS check_constraints,
+
+    EXISTS (SELECT 1 FROM pg_type tt WHERE tt.oid = t.typbasetype AND tt.typtype = 'e') AS is_enum,
+    CASE
+      WHEN EXISTS (SELECT 1 FROM pg_type tt WHERE tt.oid = t.typbasetype AND tt.typtype = 'e')
+      THEN (
+        SELECT ns.nspname || '.' || tt.typname
+        FROM pg_type tt JOIN pg_namespace ns ON ns.oid = tt.typnamespace
+        WHERE tt.oid = t.typbasetype
+      )
+      ELSE NULL
+    END                                                  AS enum_type_name,
+    NULL::text[]                                         AS enum_labels,
+
+    t.oid                                                AS type_oid
+  FROM pg_type t
+  JOIN pg_namespace n ON n.oid = t.typnamespace
+  LEFT JOIN pg_type baset ON baset.oid = t.typbasetype
+  LEFT JOIN pg_type bt ON baset.typtype = 'd' AND bt.oid = baset.typbasetype
+  WHERE t.typtype = 'd'
+    AND n.nspname NOT IN ('pg_catalog','information_schema')
+)
+
+SELECT * FROM base
+UNION ALL
+SELECT * FROM composite
+UNION ALL
+SELECT * FROM enum_rows
+UNION ALL
+SELECT * FROM domain_rows
+ORDER BY schema_name, relation_name, column_name;
+`;
+//# sourceMappingURL=introspect-query.js.map

package/dist/codegen/database/introspect/introspect-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect-query.js","sourceRoot":"","sources":["../../../src/database/introspect/introspect-query.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ZhC,CAAC"}

package/dist/codegen/database/introspect/introspect-types.d.ts

@@ -0,0 +1,45 @@
+export interface ColumnIntrospection {
+    database_name: string;
+    schema_name: string;
+    relation_name: string;
+    relation_kind: 'table' | 'view' | 'materialized view' | 'partitioned table' | 'foreign table' | 'enum type' | 'composite type';
+    table_comment: string | null;
+    column_name: string;
+    column_comment: string | null;
+    is_nullable: boolean;
+    has_default: boolean;
+    column_default: string | null;
+    pg_type: string;
+    formatted_type: string;
+    is_array: boolean;
+    array_element_pg_type: string | null;
+    array_element_formatted_type: string | null;
+    length: number | null;
+    precision: number | null;
+    scale: number | null;
+    is_primary_key: boolean;
+    is_unique: boolean;
+    is_foreign_key: boolean;
+    fk_info: ForeignKeyInfo[] | null;
+    is_check_constrained: boolean;
+    check_constraints: CheckConstraintInfo[] | null;
+    is_enum: boolean;
+    enum_type_name: string | null;
+    enum_labels: string[] | string | null;
+    type_oid: number;
+}
+export interface ForeignKeyInfo {
+    constraint_name: string;
+    ref_schema: string;
+    ref_table: string;
+    ref_columns: string[];
+    column_positions: number[];
+    update_action: 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+    delete_action: 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+    match_type: 'SIMPLE' | 'FULL' | 'PARTIAL';
+}
+export interface CheckConstraintInfo {
+    constraint_name: string;
+    definition: string;
+}
+//# sourceMappingURL=introspect-types.d.ts.map

package/dist/codegen/database/introspect/introspect-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect-types.d.ts","sourceRoot":"","sources":["../../../src/database/introspect/introspect-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EACT,OAAO,GACP,MAAM,GACN,mBAAmB,GACnB,mBAAmB,GACnB,eAAe,GACf,WAAW,GACX,gBAAgB,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,4BAA4B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iBAAiB,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAAC;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;IACjF,aAAa,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;IACjF,UAAU,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/codegen/database/introspect/introspect-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=introspect-types.js.map

package/dist/codegen/database/introspect/introspect-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect-types.js","sourceRoot":"","sources":["../../../src/database/introspect/introspect-types.ts"],"names":[],"mappings":""}

package/dist/codegen/database/introspect/introspect.d.ts

@@ -0,0 +1,21 @@
+import { PostgreSQLDatabase } from '../../../postgresql/index.js';
+import { SchemaContainer } from '../../schema/schema-container.js';
+import { SchemaObject } from '../../schema/schema-object.js';
+import { SchemaScope } from '../../schema/schema-scope.js';
+import { ColumnIntrospection } from './introspect-types.js';
+export type ColumnMapper = (r: ColumnIntrospection, s: SchemaScope) => SchemaObject | unknown;
+type TypesIndex = Record<string, SchemaObject>;
+export interface ConstantType {
+    [name: string]: string[];
+}
+export declare class PostgreSQLIntrospector {
+    protected db: PostgreSQLDatabase;
+    constructor(db: PostgreSQLDatabase);
+    protected createTypes(schema: SchemaContainer, records: ColumnIntrospection[], mapper: ColumnMapper | undefined, index: TypesIndex): void;
+    protected createEnumTypes(schema: SchemaContainer, records: ColumnIntrospection[]): void;
+    introstectConstantTypes(): Promise<ConstantType>;
+    introspect(schema: SchemaContainer, mapper?: ColumnMapper): Promise<void>;
+    protected mapPgTypeToTypescript(data: ColumnIntrospection, s: SchemaScope): SchemaObject | null;
+}
+export {};
+//# sourceMappingURL=introspect.d.ts.map

package/dist/codegen/database/introspect/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../../src/database/introspect/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,WAAW,KAAK,YAAY,GAAG,OAAO,CAAC;AAE9F,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,qBAAa,sBAAsB;IACjC,SAAS,CAAC,EAAE,EAAE,kBAAkB,CAAC;gBAErB,EAAE,EAAE,kBAAkB;IAIlC,SAAS,CAAC,WAAW,CACnB,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,mBAAmB,EAAE,EAC9B,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,KAAK,EAAE,UAAU;IAiFnB,SAAS,CAAC,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,mBAAmB,EAAE;IAe3E,uBAAuB;IA6BvB,UAAU,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,YAAY;IA4B/D,SAAS,CAAC,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI;CAmIhG"}