true-pg 0.2.3 → 0.3.1

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

@@ -0,0 +1,212 @@
+import { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+export declare const updateActionMap: {
+    readonly a: "NO ACTION";
+    readonly r: "RESTRICT";
+    readonly c: "CASCADE";
+    readonly n: "SET NULL";
+    readonly d: "SET DEFAULT";
+};
+export type UpdateAction = (typeof updateActionMap)[keyof typeof updateActionMap];
+/**
+ * Column reference.
+ */
+export type ColumnReference = {
+    /**
+     * Schema name of the referenced table.
+     */
+    schemaName: string;
+    /**
+     * Table name of the referenced column.
+     */
+    tableName: string;
+    /**
+     * Name of the referenced column.
+     */
+    columnName: string;
+    /**
+     * Action to take on delete.
+     */
+    onDelete: UpdateAction;
+    /**
+     * Action to take on update.
+     */
+    onUpdate: UpdateAction;
+    /**
+     * Name of the foreign key constraint.
+     */
+    name: string;
+};
+/**
+ * Index for a column.
+ */
+export type Index = {
+    /**
+     * Name of the index.
+     */
+    name: string;
+    /**
+     * Whether the index is a primary key.
+     */
+    isPrimary: boolean;
+};
+/**
+ * Check constraint on a table.
+ */
+export interface TableCheck {
+    /**
+     * Name of the check constraint.
+     */
+    name: string;
+    /**
+     * Check constraint clause.
+     */
+    clause: string;
+}
+/**
+ * Column in a table.
+ */
+export interface TableColumn {
+    /**
+     * Column name.
+     */
+    name: string;
+    /**
+     * Fully-detailed canonical type information
+     */
+    type: Canonical;
+    /**
+     * Comment on the column.
+     */
+    comment: string | null;
+    /**
+     * Default value of the column.
+     */
+    defaultValue: any;
+    /**
+     * Array of references from this column.
+     */
+    references: ColumnReference[];
+    /**
+     * Whether the column is nullable.
+     */
+    isNullable: boolean;
+    /**
+     * Whether the column is a primary key.
+     */
+    isPrimaryKey: boolean;
+    /**
+     * Behavior of the generated column. "ALWAYS" if always generated,
+     * "NEVER" if never generated, "BY DEFAULT" if generated when value
+     * is not provided.
+     */
+    generated: "ALWAYS" | "NEVER" | "BY DEFAULT";
+    /**
+     * Whether the column is updatable.
+     */
+    isUpdatable: boolean;
+    /**
+     * Whether the column is an identity column.
+     */
+    isIdentity: boolean;
+    /**
+     * Ordinal position of the column in the table. Starts from 1.
+     */
+    ordinalPosition: number;
+}
+/**
+ * Column in an index.
+ */
+export interface TableIndexColumn {
+    /**
+     * Column name or null if functional index.
+     */
+    name: string | null;
+    /**
+     * Definition of index column.
+     */
+    definition: string;
+}
+/**
+ * Index on a table.
+ */
+export interface TableIndex {
+    /**
+     * Name of the index.
+     */
+    name: string;
+    /**
+     * Whether the index is a primary key.
+     */
+    isPrimary: boolean;
+    /**
+     * Whether the index is unique.
+     */
+    isUnique: boolean;
+    /**
+     * Array of index columns in order.
+     */
+    columns: TableIndexColumn[];
+}
+/**
+ * Security policy on a table.
+ */
+export interface TableSecurityPolicy {
+    /**
+     * Name of the security policy.
+     */
+    name: string;
+    /**
+     * Whether the policy is permissive.
+     */
+    isPermissive: boolean;
+    /**
+     * Array of roles the policy is applied to. ["public"] if applied to all
+     * roles.
+     */
+    rolesAppliedTo: string[];
+    /**
+     * Command type the policy applies to. "ALL" if all commands.
+     */
+    commandType: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE";
+    /**
+     * Visibility expression of the policy specified by the USING clause.
+     */
+    visibilityExpression: string | null;
+    /**
+     * Modifiability expression of the policy specified by the WITH CHECK clause.
+     */
+    modifiabilityExpression: string | null;
+}
+/**
+ * Table in a schema.
+ */
+export interface TableDetails extends PgType<"table"> {
+    /**
+     * Array of columns in the table.
+     */
+    columns: TableColumn[];
+    /**
+     * Array of indices in the table.
+     */
+    indices: TableIndex[];
+    /**
+     * Array of check constraints in the table.
+     */
+    checks: TableCheck[];
+    /**
+     * Whether row level security is enabled on the table.
+     */
+    isRowLevelSecurityEnabled: boolean;
+    /**
+     * Whether row level security is enforced on the table.
+     */
+    isRowLevelSecurityEnforced: boolean;
+    /**
+     * Array of security policies on the table.
+     */
+    securityPolicies: TableSecurityPolicy[];
+}
+declare const extractTable: (db: DbAdapter, table: PgType<"table">) => Promise<TableDetails>;
+export default extractTable;

package/lib/extractor/kinds/table.js

@@ -0,0 +1,217 @@
+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",
+    c: "CASCADE",
+    n: "SET NULL",
+    d: "SET DEFAULT",
+};
+const referenceMapQueryPart = `
+			SELECT
+				source_attr.attname AS "column_name",
+				json_agg(json_build_object(
+					'schemaName', expanded_constraint.target_schema,
+					'tableName', expanded_constraint.target_table,
+					'columnName', target_attr.attname,
+					'onUpdate', case expanded_constraint.confupdtype
+						${Object.entries(updateActionMap)
+    .map(([key, action]) => `when '${key}' then '${action}'`)
+    .join("\n")}
+						end,
+					'onDelete', case expanded_constraint.confdeltype
+						${Object.entries(updateActionMap)
+    .map(([key, action]) => `when '${key}' then '${action}'`)
+    .join("\n")}
+						end,
+					'name', expanded_constraint.conname
+				)) AS references
+			FROM (
+				SELECT
+					unnest(conkey) AS "source_attnum",
+					unnest(confkey) AS "target_attnum",
+					target_namespace.nspname as "target_schema",
+					target_class.relname as "target_table",
+					confrelid,
+					conrelid,
+					conname,
+					confupdtype,
+					confdeltype
+				FROM
+					pg_constraint
+					JOIN pg_class source_class ON conrelid = source_class.oid
+					JOIN pg_namespace source_namespace ON source_class.relnamespace = source_namespace.oid
+		
+					JOIN pg_class target_class ON confrelid = target_class.oid
+					JOIN pg_namespace target_namespace ON target_class.relnamespace = target_namespace.oid
+				WHERE
+					source_class.relname = $1
+					AND source_namespace.nspname = $2
+					AND contype = 'f') expanded_constraint
+				JOIN pg_attribute target_attr ON target_attr.attrelid = expanded_constraint.confrelid
+					AND target_attr.attnum = expanded_constraint.target_attnum
+				JOIN pg_attribute source_attr ON source_attr.attrelid = expanded_constraint.conrelid
+					AND source_attr.attnum = expanded_constraint.source_attnum
+				JOIN pg_class target_class ON target_class.oid = expanded_constraint.confrelid
+			WHERE
+				target_class.relispartition = FALSE
+			GROUP BY
+				source_attr.attname
+`;
+const extractTable = async (db, table) => {
+    const columnsQuery = await db.query(`
+		WITH
+		reference_map AS (
+			${referenceMapQueryPart}
+		),
+		index_map AS (
+			${indexMapQueryPart}
+		),
+		comment_map AS (
+			${commentMapQueryPart}
+		)
+		SELECT
+			col.column_name AS "name",
+			format_type(attr.atttypid, attr.atttypmod)
+			|| CASE
+				WHEN attr.attndims > 1 THEN repeat('[]', attr.attndims - 1)
+				ELSE ''
+			END AS "definedType",
+			comment_map.comment AS "comment",
+			col.column_default AS "defaultValue",
+			col.is_nullable = 'YES' AS "isNullable",
+			col.is_identity = 'YES' AS "isIdentity",
+			col.is_updatable = 'YES' AS "isUpdatable",
+			col.ordinal_position AS "ordinalPosition",
+			CASE
+				WHEN col.is_identity = 'YES' THEN col.identity_generation
+				ELSE col.is_generated
+			END AS "generated",
+			COALESCE(index_map.is_primary, FALSE) AS "isPrimaryKey",
+			COALESCE(reference_map.references, '[]'::json) AS "references",
+			row_to_json(col.*) AS "informationSchemaValue"
+		FROM
+			information_schema.columns col
+			JOIN pg_class c ON col.table_name = c.relname
+			JOIN pg_namespace n ON c.relnamespace = n.oid AND col.table_schema = n.nspname
+			JOIN pg_attribute attr ON c.oid = attr.attrelid AND col.column_name = attr.attname
+			LEFT JOIN index_map ON index_map.column_name = col.column_name
+			LEFT JOIN reference_map ON reference_map.column_name = col.column_name
+			LEFT JOIN comment_map ON comment_map.column_name = col.column_name
+		WHERE
+			col.table_name = $1
+			AND col.table_schema = $2
+			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) => ({
+        name: row.name,
+        type: canonicalTypes[index],
+        comment: row.comment,
+        defaultValue: row.defaultValue,
+        isPrimaryKey: row.isPrimaryKey,
+        references: row.references,
+        ordinalPosition: row.ordinalPosition,
+        isNullable: row.isNullable,
+        isIdentity: row.isIdentity,
+        isUpdatable: row.isUpdatable,
+        generated: row.generated,
+        informationSchemaValue: row.informationSchemaValue,
+    }));
+    const indicesQuery = await db.query(`
+		WITH index_columns AS (
+			SELECT
+				ix.indexrelid,
+				json_agg(json_build_object(
+					'name', a.attname,
+					'definition', pg_get_indexdef(ix.indexrelid, keys.key_order::integer, true)
+				) ORDER BY keys.key_order) AS columns
+			FROM
+				pg_index ix
+				CROSS JOIN unnest(ix.indkey) WITH ORDINALITY AS keys(key, key_order)
+				LEFT JOIN pg_attribute a ON ix.indrelid = a.attrelid AND key = a.attnum
+			GROUP BY ix.indexrelid, ix.indrelid
+		)
+		SELECT
+			i.relname AS "name",
+			ix.indisprimary AS "isPrimary",
+			ix.indisunique AS "isUnique",
+			index_columns.columns
+		FROM
+			pg_index ix
+			INNER JOIN pg_class i ON ix.indexrelid = i.oid
+			INNER JOIN pg_class t ON ix.indrelid = t.oid
+			INNER JOIN pg_namespace n ON t.relnamespace = n.oid
+			INNER JOIN index_columns ON ix.indexrelid = index_columns.indexrelid
+		WHERE
+			t.relname = $1
+			AND n.nspname = $2
+		`, [table.name, table.schemaName]);
+    const indices = indicesQuery;
+    const checkQuery = await db.query(`
+		SELECT
+			source_namespace.nspname as "schema",
+			source_class.relname as "table",
+			json_agg(json_build_object(
+								 'name', con.conname,
+								 'clause', SUBSTRING(pg_get_constraintdef(con.oid) FROM 7)
+			)) as checks
+		FROM
+		 pg_constraint con,
+		 pg_class source_class,
+		 pg_namespace source_namespace 
+		WHERE
+		 source_class.relname = $1
+		 AND source_namespace.nspname = $2
+		 AND conrelid = source_class.oid 
+		 AND source_class.relnamespace = source_namespace.oid 
+		 AND con.contype = 'c'
+		GROUP BY source_namespace.nspname, source_class.relname;
+	`, [table.name, table.schemaName]);
+    const checks = checkQuery
+        .flatMap(row => row.checks)
+        .map(({ name, clause }) => {
+        const numberOfBrackets = clause.startsWith("((") && clause.endsWith("))") ? 2 : 1;
+        return {
+            name,
+            clause: clause.slice(numberOfBrackets, clause.length - numberOfBrackets),
+        };
+    });
+    const rlsQuery = await db.query(`
+		SELECT
+			c.relrowsecurity AS "isRowLevelSecurityEnabled",
+			c.relforcerowsecurity AS "isRowLevelSecurityEnforced",
+			coalesce(json_agg(json_build_object(
+				'name', p.policyname,
+				'isPermissive', p.permissive = 'PERMISSIVE',
+				'rolesAppliedTo', p.roles,
+				'commandType', p.cmd,
+				'visibilityExpression', p.qual,
+				'modifiabilityExpression', p.with_check
+			)) FILTER (WHERE p.policyname IS NOT NULL), '[]'::json) AS "securityPolicies"
+		FROM
+			pg_class c
+			INNER JOIN pg_namespace n ON c.relnamespace = n.oid
+			LEFT JOIN pg_policies p ON c.relname = p.tablename AND n.nspname = p.schemaname
+		WHERE
+			c.relname = $1
+			AND n.nspname = $2
+		GROUP BY c.relrowsecurity, c.relforcerowsecurity
+		`, [table.name, table.schemaName]);
+    const rls = rlsQuery[0];
+    return {
+        ...table,
+        indices,
+        checks,
+        columns,
+        ...rls,
+    };
+};
+export default extractTable;

package/lib/extractor/kinds/util/parseInlineTable.d.ts

@@ -0,0 +1,9 @@
+interface TableColumn {
+    name: string;
+    type: string;
+}
+/**
+ * Parse a Postgres RETURNS TABLE() definition string to extract column name and type pairs
+ */
+export declare function parsePostgresTableDefinition(tableDefinition: string): TableColumn[];
+export {};

package/lib/extractor/kinds/util/parseInlineTable.js

@@ -0,0 +1,135 @@
+/**
+ * Parse a Postgres RETURNS TABLE() definition string to extract column name and type pairs
+ */
+export function parsePostgresTableDefinition(tableDefinition) {
+    // Check if we have a table definition
+    if (!tableDefinition || !tableDefinition.toLowerCase().trim().startsWith("table(")) {
+        throw new Error('Invalid table definition format. Expected string starting with "TABLE("');
+    }
+    // Extract the content inside the TABLE() parentheses
+    const tableContentMatch = tableDefinition.match(/TABLE\s*\(\s*(.*?)\s*\)$/is);
+    if (!tableContentMatch || !tableContentMatch[1]) {
+        return [];
+    }
+    const columnsDefinition = tableContentMatch[1];
+    const columns = [];
+    let currentPos = 0;
+    let columnStart = 0;
+    let parenLevel = 0;
+    let inQuotes = false;
+    let quoteChar = null;
+    let escaping = false;
+    const len = columnsDefinition.length;
+    while (currentPos <= columnsDefinition.length) {
+        // add a virtual comma to the end
+        const char = currentPos === len ? "," : columnsDefinition[currentPos];
+        if (escaping) {
+            escaping = false;
+            currentPos++;
+            continue;
+        }
+        if (inQuotes) {
+            if (char === "\\") {
+                escaping = true;
+                currentPos++;
+                continue;
+            }
+            if (char === quoteChar) {
+                inQuotes = false;
+            }
+            currentPos++;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuotes = true;
+            quoteChar = char;
+            currentPos++;
+            continue;
+        }
+        // Track parentheses nesting level
+        if (char === "(") {
+            parenLevel++;
+        }
+        else if (char === ")") {
+            parenLevel--;
+        }
+        // At column boundary (comma outside of any parentheses or quotes)
+        // or at the end of the string (when we add the virtual comma)
+        if (char === "," && parenLevel === 0 && !inQuotes && currentPos >= columnStart) {
+            const columnDef = columnsDefinition.substring(columnStart, currentPos).trim();
+            if (columnDef) {
+                try {
+                    columns.push(parseColumnDefinition(columnDef));
+                }
+                catch (error) {
+                    console.warn(`Skipping malformed column definition: ${columnDef}`, error);
+                }
+            }
+            columnStart = currentPos + 1;
+        }
+        currentPos++;
+    }
+    return columns;
+}
+const unquote = (str) => {
+    if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+        return str
+            .substring(1, str.length - 1)
+            .replace(/\\"/g, '"')
+            .replace(/\\'/g, "'");
+    }
+    return str;
+};
+/**
+ * Parse a single column definition like "id integer" or "\"User Name\" text"
+ */
+function parseColumnDefinition(columnDef) {
+    let pos = 0;
+    let inQuotes = false;
+    let quoteChar = null;
+    let escaping = false;
+    let nameEndPos = -1;
+    while (pos < columnDef.length) {
+        const char = columnDef[pos];
+        if (escaping) {
+            escaping = false;
+            pos++;
+            continue;
+        }
+        if (inQuotes) {
+            if (char === "\\") {
+                escaping = true;
+            }
+            else if (char === quoteChar) {
+                inQuotes = false;
+            }
+            pos++;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuotes = true;
+            quoteChar = char;
+            pos++;
+            continue;
+        }
+        // Found whitespace outside quotes - this is where the name ends
+        if (/\s/.test(char) && !inQuotes) {
+            nameEndPos = pos;
+            break;
+        }
+        pos++;
+    }
+    if (nameEndPos === -1) {
+        throw new Error(`Could not parse column definition: ${columnDef}`);
+    }
+    // Extract the column name, removing quotes if present
+    let name = columnDef.substring(0, nameEndPos).trim();
+    name = unquote(name);
+    // Everything after the column name is the type
+    const type = columnDef.substring(nameEndPos).trim();
+    return { name, type };
+}
+// Example usage with complex types
+// const tableDefinition = 'TABLE("id" integer, "User Name" text, "complex field" varchar(255)[], "nested type" decimal(10,2), tags text[], "quoted""identifier" json)';
+// const columns = parsePostgresTableDefinition(tableDefinition);
+// console.log(columns);

package/lib/extractor/kinds/util/parseInlineTable.test.d.ts

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

package/lib/extractor/kinds/util/parseInlineTable.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "bun:test";
+import { parsePostgresTableDefinition } from "./parseInlineTable.js";
+describe("parsePostgresTableDefinition", () => {
+    it("should parse a table definition with a single column", () => {
+        const tableDefinition = "TABLE(id integer)";
+        const expectedColumns = [{ name: "id", type: "integer" }];
+        expect(parsePostgresTableDefinition(tableDefinition)).toEqual(expectedColumns);
+    });
+    it("should parse a table definition with a fully qualified column type", () => {
+        const tableDefinition = 'TABLE("Complex Type" "schema"."type")';
+        const expectedColumns = [{ name: "Complex Type", type: '"schema"."type"' }];
+        expect(parsePostgresTableDefinition(tableDefinition)).toEqual(expectedColumns);
+    });
+    it("should parse a complex table definition", () => {
+        const tableDefinition = 'TABLE("id" integer, "User Name" text, "complex field" varchar(255)[], "nested type" decimal(10,2), tags text[], "quoted\\"identifier" json)';
+        const expectedColumns = [
+            { name: "id", type: "integer" },
+            { name: "User Name", type: "text" },
+            { name: "complex field", type: "varchar(255)[]" },
+            { name: "nested type", type: "decimal(10,2)" },
+            { name: "tags", type: "text[]" },
+            { name: 'quoted"identifier', type: "json" },
+        ];
+        expect(parsePostgresTableDefinition(tableDefinition)).toEqual(expectedColumns);
+    });
+});

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

@@ -0,0 +1,17 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+export interface ViewColumn {
+    name: string;
+    type: Canonical;
+    isNullable: boolean;
+    isUpdatable: boolean;
+    ordinalPosition: number;
+}
+export interface ViewDetails extends PgType<"view"> {
+    columns: ViewColumn[];
+    isUpdatable: boolean;
+    checkOption: "NONE" | "LOCAL" | "CASCADED";
+}
+declare const extractView: (db: DbAdapter, view: PgType<"view">) => Promise<ViewDetails>;
+export default extractView;

package/lib/extractor/kinds/view.js

@@ -0,0 +1,63 @@
+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(`
+		SELECT
+			col.column_name AS "name",
+			format_type(attr.atttypid, attr.atttypmod)
+			|| CASE
+				WHEN attr.attndims > 1 THEN repeat('[]', attr.attndims - 1)
+				ELSE ''
+			END AS "definedType",
+			col.is_nullable = 'YES' AS "isNullable",
+			col.is_updatable = 'YES' AS "isUpdatable",
+			col.ordinal_position AS "ordinalPosition"
+		FROM
+			information_schema.columns col
+			JOIN pg_class c ON col.table_name = c.relname AND c.relkind = 'v'
+			JOIN pg_namespace n ON c.relnamespace = n.oid AND col.table_schema = n.nspname
+			JOIN pg_attribute attr ON c.oid = attr.attrelid AND col.column_name = attr.attname
+		WHERE
+			col.table_name = $1
+			AND col.table_schema = $2
+			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) => ({
+        name: row.name,
+        type: canonicalTypes[index],
+        isNullable: row.isNullable,
+        isUpdatable: row.isUpdatable,
+        ordinalPosition: row.ordinalPosition,
+    }));
+    // 3. Query for view definition, comment, and other properties
+    const viewInfoQuery = await db.query(`
+		SELECT
+			d.description AS "comment",
+			v.is_updatable = 'YES' AS "isUpdatable",
+			v.check_option AS "checkOption"
+		FROM
+			information_schema.views v
+			JOIN pg_catalog.pg_class c ON v.table_name = c.relname AND c.relkind = 'v'
+			JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid AND v.table_schema = n.nspname
+			LEFT JOIN pg_catalog.pg_description d ON c.oid = d.objoid AND d.objsubid = 0
+		WHERE
+			v.table_name = $1
+			AND v.table_schema = $2;
+		`, [view.name, view.schemaName]);
+    const viewInfo = viewInfoQuery[0];
+    if (!viewInfo) {
+        throw new Error(`Could not find view "${view.schemaName}"."${view.name}".`);
+    }
+    return {
+        ...view,
+        columns,
+        comment: viewInfo.comment ?? view.comment,
+        isUpdatable: viewInfo.isUpdatable,
+        checkOption: viewInfo.checkOption,
+    };
+};
+export default extractView;