orcaq 1.0.26 → 1.0.28

package/.output/server/chunks/_/tables.factory.mjs

@@ -0,0 +1,788 @@
+import { D as DatabaseClientType } from './db-connection.mjs';
+import { c as createError } from '../nitro/nitro.mjs';
+import { Readable } from 'node:stream';
+import { to } from 'pg-copy-streams';
+import QueryStream from 'pg-query-stream';
+import { c as createDatabaseHttpError } from './error.mjs';
+import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
+
+class PostgresTableAdvancedObjectsAdapter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  parsePolicyRoles(rawRoles) {
+    if (Array.isArray(rawRoles)) {
+      return rawRoles.map((role) => String(role));
+    }
+    if (typeof rawRoles !== "string") {
+      return [];
+    }
+    const value = rawRoles.trim();
+    if (!value) return [];
+    const normalized = value.startsWith("{") && value.endsWith("}") ? value.slice(1, -1) : value;
+    if (!normalized) return [];
+    return normalized.split(",").map((role) => role.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  }
+  async getTableIndexes(schema, tableName) {
+    const query = `
+      SELECT
+        i.relname AS index_name,
+        ix.indisunique AS is_unique,
+        ix.indisprimary AS is_primary,
+        am.amname AS method,
+        pg_get_indexdef(ix.indexrelid) AS definition
+      FROM pg_class t
+      JOIN pg_namespace n ON t.relnamespace = n.oid
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_am am ON i.relam = am.oid
+      WHERE t.relname = ?
+        AND n.nspname = ?
+      ORDER BY i.relname;
+    `;
+    const rows = await this.adapter.rawQuery(query, [tableName, schema]);
+    return rows.map(
+      (row) => ({
+        indexName: row.index_name,
+        isUnique: row.is_unique,
+        isPrimary: row.is_primary,
+        method: row.method,
+        definition: row.definition
+      })
+    );
+  }
+  async getTableRlsStatus(schema, tableName) {
+    var _a;
+    const query = `
+      SELECT c.relrowsecurity AS enabled
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = ?
+        AND n.nspname = ?;
+    `;
+    const rows = await this.adapter.rawQuery(query, [tableName, schema]);
+    const row = rows == null ? void 0 : rows[0];
+    return {
+      enabled: (_a = row == null ? void 0 : row.enabled) != null ? _a : false
+    };
+  }
+  async getTableRlsPolicies(schema, tableName) {
+    const query = `
+      SELECT
+        policyname,
+        permissive,
+        cmd AS command,
+        roles,
+        qual AS using_expression,
+        with_check AS with_check_expression
+      FROM pg_policies
+      WHERE schemaname = ?
+        AND tablename = ?
+      ORDER BY policyname;
+    `;
+    const rows = await this.adapter.rawQuery(query, [schema, tableName]);
+    return rows.map(
+      (row) => {
+        var _a, _b;
+        return {
+          policyName: row.policyname,
+          permissive: row.permissive,
+          command: row.command,
+          roles: this.parsePolicyRoles(row.roles),
+          usingExpression: (_a = row.using_expression) != null ? _a : null,
+          withCheckExpression: (_b = row.with_check_expression) != null ? _b : null
+        };
+      }
+    );
+  }
+  async getTableRules(schema, tableName) {
+    const query = `
+      SELECT
+        r.rulename,
+        r.ev_type,
+        r.is_instead,
+        pg_get_ruledef(r.oid) AS definition
+      FROM pg_rewrite r
+      JOIN pg_class c ON r.ev_class = c.oid
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = ?
+        AND n.nspname = ?
+        AND r.rulename != '_RETURN'
+      ORDER BY r.rulename;
+    `;
+    const rows = await this.adapter.rawQuery(query, [tableName, schema]);
+    const eventMap = {
+      "1": "SELECT",
+      "2": "UPDATE",
+      "3": "INSERT",
+      "4": "DELETE"
+    };
+    return rows.map(
+      (row) => {
+        var _a;
+        return {
+          ruleName: row.rulename,
+          event: (_a = eventMap[String(row.ev_type)]) != null ? _a : String(row.ev_type),
+          actionType: row.is_instead ? "INSTEAD" : "ALSO",
+          definition: row.definition
+        };
+      }
+    );
+  }
+  async getTableTriggers(schema, tableName) {
+    const query = `
+      SELECT
+        tg.tgname AS trigger_name,
+        pg_get_triggerdef(tg.oid) AS definition,
+        tg.tgenabled AS enabled_mode,
+        CASE
+          WHEN (tg.tgtype & 2) = 2 THEN 'BEFORE'
+          WHEN (tg.tgtype & 64) = 64 THEN 'INSTEAD OF'
+          ELSE 'AFTER'
+        END AS timing,
+        ARRAY_REMOVE(
+          ARRAY[
+            CASE WHEN (tg.tgtype & 4) = 4 THEN 'INSERT' END,
+            CASE WHEN (tg.tgtype & 8) = 8 THEN 'DELETE' END,
+            CASE WHEN (tg.tgtype & 16) = 16 THEN 'UPDATE' END,
+            CASE WHEN (tg.tgtype & 32) = 32 THEN 'TRUNCATE' END
+          ],
+          NULL
+        ) AS events,
+        CASE
+          WHEN (tg.tgtype & 1) = 1 THEN 'FOR EACH ROW'
+          ELSE 'FOR EACH STATEMENT'
+        END AS orientation
+      FROM pg_trigger tg
+      JOIN pg_class c ON tg.tgrelid = c.oid
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = ?
+        AND n.nspname = ?
+        AND NOT tg.tgisinternal
+      ORDER BY tg.tgname;
+    `;
+    const rows = await this.adapter.rawQuery(query, [tableName, schema]);
+    return rows.map(
+      (row) => ({
+        triggerName: row.trigger_name,
+        enabled: row.enabled_mode !== "D",
+        timing: row.timing,
+        events: Array.isArray(row.events) ? row.events.map((event) => String(event)) : [],
+        orientation: row.orientation,
+        definition: row.definition
+      })
+    );
+  }
+}
+
+const BATCH_SIZE = 1e4;
+const SQL_BATCH_SIZE = 1e4;
+class PostgresTableExportAdapter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async exportTableData(schema, tableName, format) {
+    const columnsResult = await this.adapter.rawQuery(
+      `SELECT column_name FROM information_schema.columns WHERE table_schema = ? AND table_name = ? ORDER BY ordinal_position`,
+      [schema, tableName]
+    );
+    const columns = columnsResult.map(
+      (r) => r.column_name
+    );
+    if (!columns.length) {
+      throw createError({
+        statusCode: 404,
+        message: `Table ${schema}.${tableName} not found`
+      });
+    }
+    if (format === "csv") {
+      const client = await this.adapter.acquireRawConnection();
+      try {
+        const sql = `COPY "${schema}"."${tableName}" TO STDOUT WITH (FORMAT CSV, HEADER)`;
+        const stream2 = client.query(to(sql));
+        stream2.on("finish", () => {
+          this.adapter.releaseRawConnection(client);
+        });
+        stream2.on("error", () => {
+          this.adapter.releaseRawConnection(client);
+        });
+        return stream2;
+      } catch (err) {
+        client.release();
+        throw err;
+      }
+    }
+    const handler = {
+      json: {
+        header: () => "[\n",
+        row: (row, isFirst) => (isFirst ? "" : ",\n") + JSON.stringify(row),
+        footer: (totalRows) => "\n]"
+      },
+      sql: { row: () => "" }
+    }[format];
+    const stream = new Readable({ read() {
+    } });
+    if (format === "sql") {
+      (async () => {
+        const client = await this.adapter.acquireRawConnection();
+        try {
+          const queryStream = new QueryStream(
+            `SELECT * FROM "${schema}"."${tableName}"`,
+            [],
+            { batchSize: BATCH_SIZE }
+          );
+          const dbStream = client.query(queryStream);
+          stream.push(
+            `-- Export of ${schema}.${tableName}
+-- Generated at ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`
+          );
+          let batch = [];
+          let totalRows = 0;
+          for await (const row of dbStream) {
+            batch.push(row);
+            totalRows++;
+            if (batch.length >= SQL_BATCH_SIZE) {
+              stream.push(
+                this.generateSQLBatch(schema, tableName, columns, batch)
+              );
+              batch = [];
+            }
+          }
+          if (batch.length > 0) {
+            stream.push(
+              this.generateSQLBatch(schema, tableName, columns, batch)
+            );
+          }
+          stream.push(`
+-- Total rows exported: ${totalRows}
+`);
+          stream.push(null);
+        } catch (err) {
+          stream.destroy(err);
+        } finally {
+          await this.adapter.releaseRawConnection(client);
+        }
+      })();
+      return stream;
+    }
+    if (format === "json") {
+      (async () => {
+        const client = await this.adapter.acquireRawConnection();
+        try {
+          const queryStream = new QueryStream(
+            `SELECT * FROM "${schema}"."${tableName}"`,
+            [],
+            { batchSize: BATCH_SIZE }
+          );
+          const dbStream = client.query(queryStream);
+          let isFirstRow = true;
+          let totalRows = 0;
+          if (handler.header) stream.push(handler.header());
+          for await (const row of dbStream) {
+            totalRows++;
+            stream.push(handler.row(row, isFirstRow));
+            isFirstRow = false;
+          }
+          if (handler.footer) stream.push(handler.footer(totalRows));
+          stream.push(null);
+        } catch (err) {
+          stream.destroy(err);
+        } finally {
+          await this.adapter.releaseRawConnection(client);
+        }
+      })();
+      return stream;
+    }
+    throw createError({ statusCode: 400, message: "Invalid format" });
+  }
+  generateSQLBatch(schemaName, tableName, columns, rows) {
+    const cols = columns.map((c) => `"${c}"`).join(", ");
+    const values = rows.map((row) => `(${this.formatSQLValues(columns, row)})`).join(",\n");
+    return `INSERT INTO "${schemaName}"."${tableName}" (${cols}) VALUES
+${values};
+
+`;
+  }
+  formatSQLValues(columns, row) {
+    return columns.map((col) => {
+      const value = row[col];
+      if (value === null || value === void 0) return "NULL";
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+      if (value instanceof Date) return `'${value.toISOString()}'`;
+      if (typeof value === "object") {
+        return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+      }
+      return `'${String(value).replace(/'/g, "''")}'`;
+    }).join(", ");
+  }
+}
+
+class PostgresTableMetadataAdapter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async getOverviewTables(schema) {
+    const query = `
+        SELECT 
+            c.relname AS name,
+            n.nspname AS schema,
+            CASE 
+                WHEN c.relkind = 'r' THEN 'TABLE'
+                ELSE c.relkind
+            END AS kind,
+            pg_get_userbyid(c.relowner) AS owner,
+            s.n_live_tup AS estimated_row,
+            pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+            pg_size_pretty(pg_relation_size(c.oid)) AS data_size,
+            pg_size_pretty(pg_indexes_size(c.oid)) AS index_size,
+            d.description AS comment
+        FROM 
+            pg_class c
+        JOIN 
+            pg_namespace n ON c.relnamespace = n.oid
+        LEFT JOIN 
+            pg_stat_all_tables s ON c.oid = s.relid
+        LEFT JOIN 
+            pg_description d ON c.oid = d.objoid
+        WHERE 
+            n.nspname = ?
+            AND c.relkind = 'r'
+        ORDER BY 
+            c.relname;
+    `;
+    return this.adapter.rawQuery(query, [schema]);
+  }
+  async getTableMeta(schema, tableName) {
+    const query = `
+      SELECT
+        CASE c.relkind
+          WHEN 'r' THEN 'table'
+          WHEN 'p' THEN 'partitioned'
+          WHEN 'f' THEN 'foreign'
+          ELSE c.relkind::text
+        END AS table_type,
+        pg_get_userbyid(c.relowner) AS owner,
+        COALESCE(s.n_live_tup::bigint, c.reltuples::bigint) AS row_estimate,
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      LEFT JOIN pg_stat_all_tables s ON s.relid = c.oid
+      WHERE n.nspname = ?
+        AND c.relname = ?
+        AND c.relkind IN ('r', 'p', 'f')
+      LIMIT 1;
+    `;
+    const [row] = await this.adapter.rawQuery(query, [schema, tableName]);
+    if (!row) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Table not found"
+      });
+    }
+    const rawRowEstimate = row.row_estimate != null ? Number(row.row_estimate) : void 0;
+    const rowEstimate = rawRowEstimate != null && rawRowEstimate >= 0 ? rawRowEstimate : void 0;
+    return {
+      type: row.table_type,
+      owner: row.owner,
+      rowEstimate,
+      totalSize: row.total_size,
+      tableSize: row.table_size,
+      indexSize: row.index_size
+    };
+  }
+}
+
+class PostgresTableMutationAdapter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async executeBulkStatements(statements) {
+    const startTime = performance.now();
+    const client = await this.adapter.acquireRawConnection();
+    try {
+      await client.query("BEGIN");
+      const results = [];
+      for (const statement of statements) {
+        const queryResult = await client.query({ text: statement });
+        results.push({
+          query: statement,
+          affectedRows: queryResult.rowCount || 0,
+          results: queryResult.rows || []
+        });
+      }
+      await client.query("COMMIT");
+      const endTime = performance.now();
+      return {
+        success: true,
+        data: results,
+        queryTime: Number((endTime - startTime).toFixed(2))
+      };
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw createDatabaseHttpError(DatabaseClientType.POSTGRES, e);
+    } finally {
+      await this.adapter.releaseRawConnection(client);
+    }
+  }
+  async executeBulkDelete(statements) {
+    return this.executeBulkStatements(statements);
+  }
+  async executeBulkUpdate(statements) {
+    return this.executeBulkStatements(statements);
+  }
+}
+
+class PostgresTableStructureAdapter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async getTableStructure(schema, tableName) {
+    const query = `
+      SELECT
+        a.attname AS column_name,
+        CASE
+          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character varying%' 
+              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character varying', 'varchar')
+          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character%' 
+              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character', 'char')
+          WHEN format_type(a.atttypid, a.atttypmod) = 'double precision' THEN 'float8'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'integer' THEN 'int4'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'smallint' THEN 'int2'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'bigint' THEN 'int8'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'real' THEN 'float4'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'serial' THEN 'serial4'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'smallserial' THEN 'serial2'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'bigserial' THEN 'serial8'
+          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'bit varying%' 
+              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'bit varying', 'varbit')
+          WHEN format_type(a.atttypid, a.atttypmod) = 'boolean' THEN 'bool'
+          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'numeric%' 
+          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'numeric', 'decimal')
+          WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp with time zone' THEN 'timestamptz'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp without time zone' THEN 'timestamp'
+          WHEN format_type(a.atttypid, a.atttypmod) = 'time with time zone' THEN 'timetz'
+          ELSE format_type(a.atttypid, a.atttypmod)
+        END as data_type,
+        NOT a.attnotnull AS is_nullable,
+        PG_GET_EXPR(d.adbin, d.adrelid) AS default_value,
+        COALESCE(fk_info.fk_text, '') AS foreign_keys,
+        fk_info.on_update,
+        fk_info.on_delete,
+        COALESCE(COL_DESCRIPTION(a.attrelid, a.attnum), '') AS column_comment
+      FROM
+        pg_attribute a
+        JOIN pg_class c ON a.attrelid = c.oid
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        JOIN pg_type t ON a.atttypid = t.oid
+        LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid
+        AND a.attnum = d.adnum
+        LEFT JOIN LATERAL (
+          SELECT
+            STRING_AGG(
+              '\u2192 ' || confrel.relname || '.' || af.attname ,
+              '
+'
+            ) AS fk_text,
+            MAX(
+              CASE rc.confdeltype
+                WHEN 'a' THEN 'NO ACTION'
+                WHEN 'r' THEN 'RESTRICT'
+                WHEN 'c' THEN 'CASCADE'
+                WHEN 'n' THEN 'SET NULL'
+                WHEN 'd' THEN 'SET DEFAULT'
+              END
+            ) AS on_delete,
+            MAX(
+              CASE rc.confupdtype
+                WHEN 'a' THEN 'NO ACTION'
+                WHEN 'r' THEN 'RESTRICT'
+                WHEN 'c' THEN 'CASCADE'
+                WHEN 'n' THEN 'SET NULL'
+                WHEN 'd' THEN 'SET DEFAULT'
+              END
+            ) AS on_update
+          FROM
+            pg_constraint rc
+            JOIN pg_class confrel ON rc.confrelid = confrel.oid
+            JOIN pg_attribute af ON af.attrelid = rc.confrelid
+            AND af.attnum = rc.confkey[1]
+          WHERE
+            rc.conrelid = a.attrelid
+            AND rc.contype = 'f'
+            AND a.attnum = ANY (rc.conkey)
+        ) fk_info ON TRUE
+      WHERE
+        c.relname = ?
+        AND n.nspname = ?
+        AND a.attnum > 0
+        AND NOT a.attisdropped
+      ORDER BY
+        a.attnum
+    `;
+    return this.adapter.rawQuery(query, [tableName, schema]);
+  }
+  async getTableSize(schema, tableName) {
+    const query = `
+      SELECT
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_table_size(c.oid)) AS data_size,
+        pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      LEFT JOIN pg_description d ON d.objoid = c.oid AND d.classoid = 'pg_class'::regclass
+      WHERE n.nspname = ? AND c.relname = ?
+      LIMIT 1;
+    `;
+    const [result] = await this.adapter.rawQuery(query, [schema, tableName]);
+    if (!result) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return {
+      tableSize: result.table_size,
+      dataSize: result.data_size,
+      indexSize: result.index_size
+    };
+  }
+  async getTableDdl(schema, tableName) {
+    const ddlQuery = `
+      WITH table_info AS (
+        SELECT
+          c.oid AS table_oid,
+          c.relname AS table_name,
+          n.nspname AS schema_name,
+          pg_get_userbyid(c.relowner) AS table_owner
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = ?
+          AND c.relname = ?
+          AND c.relkind = 'r'
+      ),
+      columns AS (
+        SELECT
+          a.attname AS column_name,
+          a.attnum AS ordinal_position,
+          CASE
+            WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character varying%'
+              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character varying', 'varchar')
+            WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character%'
+              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character', 'char')
+            WHEN format_type(a.atttypid, a.atttypmod) = 'double precision' THEN 'float8'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'integer' THEN 'int4'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'smallint' THEN 'int2'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'bigint' THEN 'int8'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'boolean' THEN 'bool'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp without time zone' THEN 'timestamp'
+            WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp with time zone' THEN 'timestamptz'
+            ELSE format_type(a.atttypid, a.atttypmod)
+          END AS data_type,
+          CASE WHEN a.attnotnull THEN 'NOT NULL' ELSE 'NULL' END AS nullable,
+          pg_get_expr(d.adbin, d.adrelid) AS default_value
+        FROM pg_attribute a
+        JOIN table_info ti ON a.attrelid = ti.table_oid
+        LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+        WHERE a.attnum > 0
+          AND NOT a.attisdropped
+        ORDER BY a.attnum
+      ),
+      constraints AS (
+        SELECT
+          con.conname AS constraint_name,
+          con.contype AS constraint_type,
+          pg_get_constraintdef(con.oid) AS constraint_def
+        FROM pg_constraint con
+        JOIN table_info ti ON con.conrelid = ti.table_oid
+        WHERE con.contype IN ('p', 'u', 'c')
+      ),
+      indexes AS (
+        SELECT
+          i.relname AS index_name,
+          pg_get_indexdef(i.oid) AS index_def
+        FROM pg_index ix
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN table_info ti ON ix.indrelid = ti.table_oid
+        WHERE NOT ix.indisprimary
+          AND NOT ix.indisunique
+      ),
+      foreign_keys AS (
+        SELECT
+          con.conname AS fk_name,
+          'ALTER TABLE "' || ti.schema_name || '"."' || ti.table_name || '" ADD CONSTRAINT ' || con.conname || ' FOREIGN KEY (' ||
+            string_agg(att.attname, ', ' ORDER BY u.seq) ||
+            ') REFERENCES ' || nf.nspname || '.' || cf.relname || '(' ||
+            string_agg(af.attname, ', ' ORDER BY u.seq) || ')' AS fk_def
+        FROM pg_constraint con
+        JOIN table_info ti ON con.conrelid = ti.table_oid
+        CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS u(conkey, confkey, seq)
+        JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = u.conkey
+        JOIN pg_class cf ON cf.oid = con.confrelid
+        JOIN pg_namespace nf ON nf.oid = cf.relnamespace
+        JOIN pg_attribute af ON af.attrelid = con.confrelid AND af.attnum = u.confkey
+        WHERE con.contype = 'f'
+        GROUP BY con.conname, nf.nspname, cf.relname, ti.schema_name, ti.table_name
+      ),
+      grants AS (
+        SELECT
+          'GRANT ' || privilege_type || ' ON TABLE "' || table_schema || '"."' || table_name || '" TO ' || grantee || ';' AS grant_def
+        FROM information_schema.table_privileges
+        WHERE table_schema = ?
+          AND table_name = ?
+      )
+      SELECT
+        json_build_object(
+          'schema_name', (SELECT schema_name FROM table_info),
+          'table_name', (SELECT table_name FROM table_info),
+          'table_owner', (SELECT table_owner FROM table_info),
+          'columns', (SELECT json_agg(row_to_json(columns.*) ORDER BY ordinal_position) FROM columns),
+          'constraints', (SELECT json_agg(row_to_json(constraints.*)) FROM constraints),
+          'indexes', (SELECT json_agg(row_to_json(indexes.*)) FROM indexes),
+          'foreign_keys', (SELECT json_agg(fk_def) FROM foreign_keys),
+          'grants', (SELECT json_agg(grant_def) FROM grants)
+        ) AS ddl_data
+    `;
+    const result = await this.adapter.rawQuery(ddlQuery, [
+      schema,
+      tableName,
+      schema,
+      tableName
+    ]);
+    if (!result || result.length === 0 || !result[0].ddl_data || !result[0].ddl_data.schema_name) {
+      throw createError({
+        statusCode: 404,
+        message: `Table ${schema}.${tableName} not found`
+      });
+    }
+    const ddlData = result[0].ddl_data;
+    const lines = [];
+    lines.push(`-- ${schema}.${tableName} definition`);
+    lines.push("");
+    lines.push("-- Drop table");
+    lines.push("");
+    lines.push(`-- DROP TABLE ${schema}.${tableName};`);
+    lines.push("");
+    lines.push(`CREATE TABLE ${schema}.${tableName} (`);
+    const columns = ddlData.columns || [];
+    const constraints = ddlData.constraints || [];
+    const columnDefs = columns.map(
+      (col) => {
+        const parts = ["	" + col.column_name, col.data_type];
+        if (col.default_value) parts.push("DEFAULT " + col.default_value);
+        parts.push(col.nullable);
+        return parts.join(" ");
+      }
+    );
+    const constraintDefs = constraints.map(
+      (con) => '	CONSTRAINT "' + con.constraint_name + '" ' + con.constraint_def
+    );
+    lines.push([...columnDefs, ...constraintDefs].join(",\n"));
+    lines.push(");");
+    const indexes = ddlData.indexes || [];
+    indexes.forEach((idx) => {
+      lines.push(idx.index_def + ";");
+    });
+    const tableOwner = ddlData.table_owner;
+    if (tableOwner) {
+      lines.push("");
+      lines.push("-- Permissions");
+      lines.push("");
+      lines.push(`ALTER TABLE ${schema}.${tableName} OWNER TO ${tableOwner};`);
+      const grants = ddlData.grants || [];
+      grants.forEach((grant) => {
+        lines.push(grant);
+      });
+    }
+    const foreignKeys = ddlData.foreign_keys || [];
+    if (foreignKeys.length > 0) {
+      lines.push("");
+      lines.push("");
+      lines.push(`-- ${schema}.${tableName} foreign keys`);
+      lines.push("");
+      foreignKeys.forEach((fk) => {
+        lines.push(fk + ";");
+      });
+    }
+    return lines.join("\n");
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PostgresTableAdapter extends BaseDomainAdapter {
+  constructor(adapter) {
+    super(adapter);
+    __publicField(this, "dbType", DatabaseClientType.POSTGRES);
+    __publicField(this, "metadataAdapter");
+    __publicField(this, "structureAdapter");
+    __publicField(this, "mutationAdapter");
+    __publicField(this, "exportAdapter");
+    __publicField(this, "advancedObjectsAdapter");
+    this.metadataAdapter = new PostgresTableMetadataAdapter(this.adapter);
+    this.structureAdapter = new PostgresTableStructureAdapter(this.adapter);
+    this.mutationAdapter = new PostgresTableMutationAdapter(this.adapter);
+    this.exportAdapter = new PostgresTableExportAdapter(this.adapter);
+    this.advancedObjectsAdapter = new PostgresTableAdvancedObjectsAdapter(
+      this.adapter
+    );
+  }
+  static async create(params) {
+    const adapter = await PostgresTableAdapter.resolveAdapter(
+      params,
+      DatabaseClientType.POSTGRES
+    );
+    return new PostgresTableAdapter(adapter);
+  }
+  async getOverviewTables(schema) {
+    return this.metadataAdapter.getOverviewTables(schema);
+  }
+  async getTableStructure(schema, tableName) {
+    return this.structureAdapter.getTableStructure(schema, tableName);
+  }
+  async getTableSize(schema, tableName) {
+    return this.structureAdapter.getTableSize(schema, tableName);
+  }
+  async getTableMeta(schema, tableName) {
+    return this.metadataAdapter.getTableMeta(schema, tableName);
+  }
+  async getTableDdl(schema, tableName) {
+    return this.structureAdapter.getTableDdl(schema, tableName);
+  }
+  async executeBulkDelete(statements) {
+    return this.mutationAdapter.executeBulkDelete(statements);
+  }
+  async executeBulkUpdate(statements) {
+    return this.mutationAdapter.executeBulkUpdate(statements);
+  }
+  async exportTableData(schema, tableName, format) {
+    return this.exportAdapter.exportTableData(schema, tableName, format);
+  }
+  async getTableIndexes(schema, tableName) {
+    return this.advancedObjectsAdapter.getTableIndexes(schema, tableName);
+  }
+  async getTableRlsStatus(schema, tableName) {
+    return this.advancedObjectsAdapter.getTableRlsStatus(schema, tableName);
+  }
+  async getTableRlsPolicies(schema, tableName) {
+    return this.advancedObjectsAdapter.getTableRlsPolicies(schema, tableName);
+  }
+  async getTableRules(schema, tableName) {
+    return this.advancedObjectsAdapter.getTableRules(schema, tableName);
+  }
+  async getTableTriggers(schema, tableName) {
+    return this.advancedObjectsAdapter.getTableTriggers(schema, tableName);
+  }
+}
+
+async function createTableAdapter(dbType, params) {
+  return createDomainAdapter(dbType, params, "table", {
+    postgres: PostgresTableAdapter.create
+  });
+}
+
+export { createTableAdapter as c };
+//# sourceMappingURL=tables.factory.mjs.map