@pgpmjs/export 1.0.2 → 1.1.1

package/esm/export-data.js

@@ -0,0 +1,180 @@
+/**
+ * Generic, deterministic table-data export.
+ *
+ * Emits INSERT/DELETE/verify SQL for a set of tables so callers can ship row
+ * data inside a pgpm change (replayed under `session_replication_role =
+ * replica`). This is the shared data-dump capability behind the meta export
+ * flow and downstream scoped-plane data exports — column introspection,
+ * non-deterministic-default exclusion, and script assembly live here so
+ * consumers do not re-implement them.
+ *
+ * All emitted SQL is built through @constructive-io/query-builder (pg-ast +
+ * pgsql-deparser) — no string concatenation, no manual identifier quoting.
+ */
+import { cast, col, div, eq, fn, gte, lit, QueryBuilder } from '@constructive-io/query-builder';
+/**
+ * Introspect the exportable columns of a table: name, formatted type,
+ * default expression, and whether that default depends on a non-immutable
+ * function. Single canonical column introspection for data exports.
+ */
+export const getDataExportColumns = async (db, schema, table) => {
+    const result = await db.query(`
+      SELECT a.attname AS name,
+             format_type(a.atttypid, a.atttypmod) AS type,
+             pg_get_expr(d.adbin, d.adrelid) AS column_default,
+             COALESCE((
+               SELECT bool_or(p.provolatile <> 'i')
+               FROM regexp_matches(d.adbin::text, ':funcid (\\d+)', 'g') m
+               JOIN pg_proc p ON p.oid = m[1]::oid
+             ), d.adbin::text ~ 'SQLVALUEFUNCTION', false) AS volatile_default
+      FROM pg_attribute a
+      JOIN pg_class c ON c.oid = a.attrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum
+      WHERE n.nspname = $1 AND c.relname = $2
+        AND a.attnum > 0 AND NOT a.attisdropped
+      ORDER BY a.attnum
+    `, [schema, table]);
+    return result.rows.map((row) => ({
+        name: row.name,
+        type: row.type,
+        columnDefault: row.column_default,
+        volatileDefault: row.volatile_default
+    }));
+};
+/**
+ * True for columns whose value must be omitted from exported rows so the DDL
+ * DEFAULT re-supplies it at deploy time: timestamp/timestamptz columns whose
+ * default depends on a non-immutable function (wall-clock defaults).
+ */
+export const isVolatileTimestampColumn = (column) => column.volatileDefault && /^timestamp/.test(column.type);
+const RAW_ID = '__raw_id';
+/**
+ * Export a table's rows as a single deterministic INSERT statement.
+ * Values are text-cast server-side, emitted as literals re-cast to the
+ * column type; rows are ordered by id when present, otherwise by all
+ * exported columns, so output is reproducible.
+ */
+export const exportTableData = async (db, spec, options = {}) => {
+    const excluded = new Set(options.excludeColumns ?? []);
+    const allColumns = await getDataExportColumns(db, spec.schema, spec.table);
+    const columns = allColumns.filter(c => !excluded.has(c.name) && !isVolatileTimestampColumn(c));
+    const base = {
+        schema: spec.schema,
+        table: spec.table,
+        columns,
+        rowCount: 0,
+        ids: null,
+        insert: null
+    };
+    if (columns.length === 0)
+        return base;
+    const hasId = columns.some(c => c.name === 'id');
+    const selectQb = new QueryBuilder()
+        .schema(spec.schema)
+        .table(spec.table)
+        .select([]);
+    for (const c of columns) {
+        selectQb.selectExpr(c.name, cast(col(c.name), 'text'));
+    }
+    if (hasId) {
+        selectQb.selectExpr(RAW_ID, cast(col('id'), 'text'));
+        selectQb.orderBy(cast(col('id'), 'text'));
+    }
+    else {
+        for (const c of columns) {
+            selectQb.orderBy(col(c.name));
+        }
+    }
+    if (spec.filter) {
+        selectQb.where({ [spec.filter.column]: { equalTo: spec.filter.value } });
+    }
+    const { text: selectSql, values: selectValues } = selectQb.build();
+    const rowsRes = await db.query(selectSql, selectValues);
+    if (rowsRes.rows.length === 0)
+        return base;
+    const insertQb = new QueryBuilder()
+        .schema(spec.schema)
+        .table(spec.table)
+        .insert(rowsRes.rows.map((row) => Object.fromEntries(columns.map(c => [c.name, cast(lit(row[c.name]), c.type)]))));
+    if (options.conflictDoNothing) {
+        insertQb.onConflict({ action: 'nothing' });
+    }
+    return {
+        ...base,
+        rowCount: rowsRes.rows.length,
+        ids: hasId ? rowsRes.rows.map((r) => r[RAW_ID]) : null,
+        insert: `${insertQb.build().text};`
+    };
+};
+/**
+ * Export multiple tables in the given (FK-dependency) order.
+ */
+export const exportTablesData = async (db, specs, options = {}) => {
+    const results = [];
+    for (const spec of specs) {
+        results.push(await exportTableData(db, spec, options));
+    }
+    return results;
+};
+const REPLICA_HEADER = 'SET session_replication_role TO replica;';
+const REPLICA_FOOTER = 'SET session_replication_role TO DEFAULT;';
+const wrapReplica = (body) => [REPLICA_HEADER, '', ...body, '', REPLICA_FOOTER, ''].join('\n');
+/**
+ * Assemble the deploy script body: every table's INSERT in dependency order,
+ * replayed with triggers/FKs suppressed. Callers prepend the pgpm change
+ * header.
+ */
+export const buildDataDeployScript = (exports) => {
+    const inserts = exports
+        .filter(e => e.insert !== null)
+        .map(e => e.insert);
+    return wrapReplica([inserts.join('\n\n')]);
+};
+/**
+ * Assemble the revert script body: per-table DELETEs of the exported rows in
+ * reverse dependency order. Tables exported without an id column cannot be
+ * precisely reverted and are skipped with a comment.
+ */
+export const buildDataRevertScript = (exports) => {
+    const statements = [];
+    for (const e of [...exports].reverse()) {
+        if (e.rowCount === 0)
+            continue;
+        if (!e.ids) {
+            statements.push(`-- ${e.schema}.${e.table}: exported without an id column; rows not reverted`);
+            continue;
+        }
+        const { text } = new QueryBuilder()
+            .schema(e.schema)
+            .table(e.table)
+            .delete()
+            .where({ id: { in: e.ids.map(id => lit(id)) } })
+            .build();
+        statements.push(`${text};`);
+    }
+    return wrapReplica([statements.join('\n\n')]);
+};
+/**
+ * Assemble the verify script body: per-table checks that the exported rows
+ * are present (exact id match when ids were exported, row-count floor
+ * otherwise). Divide-by-zero style, per pgpm verify conventions.
+ */
+export const buildDataVerifyScript = (exports) => {
+    const statements = [];
+    for (const e of exports) {
+        if (e.rowCount === 0)
+            continue;
+        const countCheck = e.ids ? eq : gte;
+        const qb = new QueryBuilder()
+            .schema(e.schema)
+            .table(e.table)
+            .select([])
+            .selectExpr('verified', div(lit(1), cast(countCheck(fn('count', [col('*')]), lit(e.rowCount)), 'int')));
+        if (e.ids) {
+            qb.where({ id: { in: e.ids.map(id => lit(id)) } });
+        }
+        statements.push(`${qb.build().text};`);
+    }
+    return statements.join('\n\n') + '\n';
+};

package/esm/index.js

@@ -1,3 +1,4 @@
+export * from './export-data';
 export * from './export-meta';
 export * from './export-migrations';
 export * from './export-graphql';

package/export-data.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Minimal query interface satisfied by pg.Pool, pg.Client, and test clients.
+ */
+export interface Queryable {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: any[];
+    }>;
+}
+export interface DataExportColumn {
+    /** Column name. */
+    name: string;
+    /** Fully formatted SQL type (format_type), used for value casts. */
+    type: string;
+    /** The column's default expression, if any (pg_get_expr). */
+    columnDefault: string | null;
+    /**
+     * True when the default expression depends on a non-immutable function
+     * (now(), CURRENT_TIMESTAMP, clock_timestamp(), gen_random_uuid(), ...).
+     * Detected from the compiled default expression's function references
+     * (pg_proc.provolatile), not by pattern-matching the expression text.
+     */
+    volatileDefault: boolean;
+}
+/**
+ * Introspect the exportable columns of a table: name, formatted type,
+ * default expression, and whether that default depends on a non-immutable
+ * function. Single canonical column introspection for data exports.
+ */
+export declare const getDataExportColumns: (db: Queryable, schema: string, table: string) => Promise<DataExportColumn[]>;
+/**
+ * True for columns whose value must be omitted from exported rows so the DDL
+ * DEFAULT re-supplies it at deploy time: timestamp/timestamptz columns whose
+ * default depends on a non-immutable function (wall-clock defaults).
+ */
+export declare const isVolatileTimestampColumn: (column: DataExportColumn) => boolean;
+export interface DataExportTableSpec {
+    schema: string;
+    table: string;
+    /** Optional equality filter, e.g. { column: 'database_id', value: id }. */
+    filter?: {
+        column: string;
+        value: string;
+    };
+}
+export interface ExportTableDataOptions {
+    /**
+     * Columns excluded from the export in addition to volatile timestamp
+     * defaults (e.g. environment-stamped columns like dbname, or trigger
+     * maintained stamps like created_at/updated_at).
+     */
+    excludeColumns?: string[];
+    /** Emit ON CONFLICT DO NOTHING on the INSERT. */
+    conflictDoNothing?: boolean;
+}
+export interface TableDataExport {
+    schema: string;
+    table: string;
+    /** Columns included in the INSERT, in table order. */
+    columns: DataExportColumn[];
+    rowCount: number;
+    /** Exported id values (text) when an id column is exported, else null. */
+    ids: string[] | null;
+    /** The INSERT statement, or null when the table had no exportable rows. */
+    insert: string | null;
+}
+/**
+ * Export a table's rows as a single deterministic INSERT statement.
+ * Values are text-cast server-side, emitted as literals re-cast to the
+ * column type; rows are ordered by id when present, otherwise by all
+ * exported columns, so output is reproducible.
+ */
+export declare const exportTableData: (db: Queryable, spec: DataExportTableSpec, options?: ExportTableDataOptions) => Promise<TableDataExport>;
+/**
+ * Export multiple tables in the given (FK-dependency) order.
+ */
+export declare const exportTablesData: (db: Queryable, specs: DataExportTableSpec[], options?: ExportTableDataOptions) => Promise<TableDataExport[]>;
+/**
+ * Assemble the deploy script body: every table's INSERT in dependency order,
+ * replayed with triggers/FKs suppressed. Callers prepend the pgpm change
+ * header.
+ */
+export declare const buildDataDeployScript: (exports: TableDataExport[]) => string;
+/**
+ * Assemble the revert script body: per-table DELETEs of the exported rows in
+ * reverse dependency order. Tables exported without an id column cannot be
+ * precisely reverted and are skipped with a comment.
+ */
+export declare const buildDataRevertScript: (exports: TableDataExport[]) => string;
+/**
+ * Assemble the verify script body: per-table checks that the exported rows
+ * are present (exact id match when ids were exported, row-count floor
+ * otherwise). Divide-by-zero style, per pgpm verify conventions.
+ */
+export declare const buildDataVerifyScript: (exports: TableDataExport[]) => string;

package/export-data.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDataVerifyScript = exports.buildDataRevertScript = exports.buildDataDeployScript = exports.exportTablesData = exports.exportTableData = exports.isVolatileTimestampColumn = exports.getDataExportColumns = void 0;
+/**
+ * Generic, deterministic table-data export.
+ *
+ * Emits INSERT/DELETE/verify SQL for a set of tables so callers can ship row
+ * data inside a pgpm change (replayed under `session_replication_role =
+ * replica`). This is the shared data-dump capability behind the meta export
+ * flow and downstream scoped-plane data exports — column introspection,
+ * non-deterministic-default exclusion, and script assembly live here so
+ * consumers do not re-implement them.
+ *
+ * All emitted SQL is built through @constructive-io/query-builder (pg-ast +
+ * pgsql-deparser) — no string concatenation, no manual identifier quoting.
+ */
+const query_builder_1 = require("@constructive-io/query-builder");
+/**
+ * Introspect the exportable columns of a table: name, formatted type,
+ * default expression, and whether that default depends on a non-immutable
+ * function. Single canonical column introspection for data exports.
+ */
+const getDataExportColumns = async (db, schema, table) => {
+    const result = await db.query(`
+      SELECT a.attname AS name,
+             format_type(a.atttypid, a.atttypmod) AS type,
+             pg_get_expr(d.adbin, d.adrelid) AS column_default,
+             COALESCE((
+               SELECT bool_or(p.provolatile <> 'i')
+               FROM regexp_matches(d.adbin::text, ':funcid (\\d+)', 'g') m
+               JOIN pg_proc p ON p.oid = m[1]::oid
+             ), d.adbin::text ~ 'SQLVALUEFUNCTION', false) AS volatile_default
+      FROM pg_attribute a
+      JOIN pg_class c ON c.oid = a.attrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum
+      WHERE n.nspname = $1 AND c.relname = $2
+        AND a.attnum > 0 AND NOT a.attisdropped
+      ORDER BY a.attnum
+    `, [schema, table]);
+    return result.rows.map((row) => ({
+        name: row.name,
+        type: row.type,
+        columnDefault: row.column_default,
+        volatileDefault: row.volatile_default
+    }));
+};
+exports.getDataExportColumns = getDataExportColumns;
+/**
+ * True for columns whose value must be omitted from exported rows so the DDL
+ * DEFAULT re-supplies it at deploy time: timestamp/timestamptz columns whose
+ * default depends on a non-immutable function (wall-clock defaults).
+ */
+const isVolatileTimestampColumn = (column) => column.volatileDefault && /^timestamp/.test(column.type);
+exports.isVolatileTimestampColumn = isVolatileTimestampColumn;
+const RAW_ID = '__raw_id';
+/**
+ * Export a table's rows as a single deterministic INSERT statement.
+ * Values are text-cast server-side, emitted as literals re-cast to the
+ * column type; rows are ordered by id when present, otherwise by all
+ * exported columns, so output is reproducible.
+ */
+const exportTableData = async (db, spec, options = {}) => {
+    const excluded = new Set(options.excludeColumns ?? []);
+    const allColumns = await (0, exports.getDataExportColumns)(db, spec.schema, spec.table);
+    const columns = allColumns.filter(c => !excluded.has(c.name) && !(0, exports.isVolatileTimestampColumn)(c));
+    const base = {
+        schema: spec.schema,
+        table: spec.table,
+        columns,
+        rowCount: 0,
+        ids: null,
+        insert: null
+    };
+    if (columns.length === 0)
+        return base;
+    const hasId = columns.some(c => c.name === 'id');
+    const selectQb = new query_builder_1.QueryBuilder()
+        .schema(spec.schema)
+        .table(spec.table)
+        .select([]);
+    for (const c of columns) {
+        selectQb.selectExpr(c.name, (0, query_builder_1.cast)((0, query_builder_1.col)(c.name), 'text'));
+    }
+    if (hasId) {
+        selectQb.selectExpr(RAW_ID, (0, query_builder_1.cast)((0, query_builder_1.col)('id'), 'text'));
+        selectQb.orderBy((0, query_builder_1.cast)((0, query_builder_1.col)('id'), 'text'));
+    }
+    else {
+        for (const c of columns) {
+            selectQb.orderBy((0, query_builder_1.col)(c.name));
+        }
+    }
+    if (spec.filter) {
+        selectQb.where({ [spec.filter.column]: { equalTo: spec.filter.value } });
+    }
+    const { text: selectSql, values: selectValues } = selectQb.build();
+    const rowsRes = await db.query(selectSql, selectValues);
+    if (rowsRes.rows.length === 0)
+        return base;
+    const insertQb = new query_builder_1.QueryBuilder()
+        .schema(spec.schema)
+        .table(spec.table)
+        .insert(rowsRes.rows.map((row) => Object.fromEntries(columns.map(c => [c.name, (0, query_builder_1.cast)((0, query_builder_1.lit)(row[c.name]), c.type)]))));
+    if (options.conflictDoNothing) {
+        insertQb.onConflict({ action: 'nothing' });
+    }
+    return {
+        ...base,
+        rowCount: rowsRes.rows.length,
+        ids: hasId ? rowsRes.rows.map((r) => r[RAW_ID]) : null,
+        insert: `${insertQb.build().text};`
+    };
+};
+exports.exportTableData = exportTableData;
+/**
+ * Export multiple tables in the given (FK-dependency) order.
+ */
+const exportTablesData = async (db, specs, options = {}) => {
+    const results = [];
+    for (const spec of specs) {
+        results.push(await (0, exports.exportTableData)(db, spec, options));
+    }
+    return results;
+};
+exports.exportTablesData = exportTablesData;
+const REPLICA_HEADER = 'SET session_replication_role TO replica;';
+const REPLICA_FOOTER = 'SET session_replication_role TO DEFAULT;';
+const wrapReplica = (body) => [REPLICA_HEADER, '', ...body, '', REPLICA_FOOTER, ''].join('\n');
+/**
+ * Assemble the deploy script body: every table's INSERT in dependency order,
+ * replayed with triggers/FKs suppressed. Callers prepend the pgpm change
+ * header.
+ */
+const buildDataDeployScript = (exports) => {
+    const inserts = exports
+        .filter(e => e.insert !== null)
+        .map(e => e.insert);
+    return wrapReplica([inserts.join('\n\n')]);
+};
+exports.buildDataDeployScript = buildDataDeployScript;
+/**
+ * Assemble the revert script body: per-table DELETEs of the exported rows in
+ * reverse dependency order. Tables exported without an id column cannot be
+ * precisely reverted and are skipped with a comment.
+ */
+const buildDataRevertScript = (exports) => {
+    const statements = [];
+    for (const e of [...exports].reverse()) {
+        if (e.rowCount === 0)
+            continue;
+        if (!e.ids) {
+            statements.push(`-- ${e.schema}.${e.table}: exported without an id column; rows not reverted`);
+            continue;
+        }
+        const { text } = new query_builder_1.QueryBuilder()
+            .schema(e.schema)
+            .table(e.table)
+            .delete()
+            .where({ id: { in: e.ids.map(id => (0, query_builder_1.lit)(id)) } })
+            .build();
+        statements.push(`${text};`);
+    }
+    return wrapReplica([statements.join('\n\n')]);
+};
+exports.buildDataRevertScript = buildDataRevertScript;
+/**
+ * Assemble the verify script body: per-table checks that the exported rows
+ * are present (exact id match when ids were exported, row-count floor
+ * otherwise). Divide-by-zero style, per pgpm verify conventions.
+ */
+const buildDataVerifyScript = (exports) => {
+    const statements = [];
+    for (const e of exports) {
+        if (e.rowCount === 0)
+            continue;
+        const countCheck = e.ids ? query_builder_1.eq : query_builder_1.gte;
+        const qb = new query_builder_1.QueryBuilder()
+            .schema(e.schema)
+            .table(e.table)
+            .select([])
+            .selectExpr('verified', (0, query_builder_1.div)((0, query_builder_1.lit)(1), (0, query_builder_1.cast)(countCheck((0, query_builder_1.fn)('count', [(0, query_builder_1.col)('*')]), (0, query_builder_1.lit)(e.rowCount)), 'int')));
+        if (e.ids) {
+            qb.where({ id: { in: e.ids.map(id => (0, query_builder_1.lit)(id)) } });
+        }
+        statements.push(`${qb.build().text};`);
+    }
+    return statements.join('\n\n') + '\n';
+};
+exports.buildDataVerifyScript = buildDataVerifyScript;

package/index.d.ts

@@ -1,3 +1,4 @@
+export * from './export-data';
 export * from './export-meta';
 export * from './export-migrations';
 export * from './export-graphql';

package/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePgInterval = exports.intervalToPostgres = exports.lookupByGqlType = exports.lookupByPgUdt = exports.PG_TYPE_MAP = exports.installMissingModules = exports.detectMissingModules = exports.normalizeOutdir = exports.preparePackage = exports.makeReplacer = exports.mapPgTypeToFieldType = exports.META_TABLE_OVERRIDES = exports.META_TABLE_CONFIG = exports.META_TABLE_ORDER = exports.META_COMMON_FOOTER = exports.META_COMMON_HEADER = exports.SERVICE_REQUIRED_EXTENSIONS = exports.DB_REQUIRED_EXTENSIONS = exports.unwrapGraphQLType = exports.mapGraphQLTypeToFieldType = exports.buildFieldsFragment = exports.graphqlRowToPostgresRow = exports.getGraphQLTypeName = exports.getGraphQLQueryName = exports.GraphQLClient = void 0;
+__exportStar(require("./export-data"), exports);
 __exportStar(require("./export-meta"), exports);
 __exportStar(require("./export-migrations"), exports);
 __exportStar(require("./export-graphql"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/export",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM export tools for SQL and GraphQL database migration extraction",
   "main": "index.js",
@@ -41,11 +41,12 @@
     "@pgsql/types": "^18.0.0",
     "@types/pg": "^8.20.0",
     "makage": "^0.3.0",
-    "pgsql-test": "^5.0.2"
+    "pgsql-test": "^5.0.4"
   },
   "dependencies": {
-    "@pgpmjs/core": "^7.2.0",
-    "@pgpmjs/migrate-client": "^1.0.2",
+    "@constructive-io/query-builder": "^3.0.1",
+    "@pgpmjs/core": "^7.2.2",
+    "@pgpmjs/migrate-client": "^1.0.4",
     "@pgpmjs/types": "^2.35.1",
     "csv-to-pg": "^4.0.0",
     "glob": "^13.0.6",
@@ -55,5 +56,5 @@
     "pg-cache": "^3.15.2",
     "pg-env": "^1.18.1"
   },
-  "gitHead": "15a831fa029544068ee64e3386e4b08715d2b86d"
+  "gitHead": "d48f39ebd4b7dcbab22df7c57438c06efd9e223d"
 }