@akal/supaforge 0.0.36 → 0.0.38
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +12 -7
- package/dist/{chunk-YUJ2MHLM.js → chunk-2HJPUDPP.js} +762 -14
- package/dist/{chunk-M2564IGT.js → chunk-35TXJGDQ.js} +50 -71
- package/dist/chunk-5RMEQPPU.js +27 -0
- package/dist/{chunk-MZPWRWBL.js → chunk-64S3EP7Y.js} +171 -145
- package/dist/{chunk-JX5L253P.js → chunk-EETO4RJO.js} +4 -6
- package/dist/chunk-EHJWKKFL.js +94 -0
- package/dist/{chunk-CCB7ARZU.js → chunk-FBYONIJS.js} +6 -26
- package/dist/{chunk-MRXIE55Y.js → chunk-LJY3AK2P.js} +2 -2
- package/dist/{chunk-CAQ3QQFP.js → chunk-PE5PENCB.js} +48 -4
- package/dist/commands/diff.js +4 -5
- package/dist/commands/hukam.js +4 -5
- package/dist/commands/mcp.js +5 -4
- package/dist/commands/migrate/create.d.ts +3 -2
- package/dist/commands/migrate/create.js +12 -75
- package/dist/commands/migrate/run.js +3 -3
- package/dist/commands/restore.js +2 -3
- package/dist/commands/sync.js +4 -5
- package/dist/index.js +7 -6
- package/package.json +2 -2
- package/dist/chunk-GGZ7YWBZ.js +0 -761
package/dist/chunk-GGZ7YWBZ.js
DELETED
|
@@ -1,761 +0,0 @@
|
|
|
1
|
-
import {
|
|
2
|
-
parseStatements,
|
|
3
|
-
relationName,
|
|
4
|
-
rolesNamedBy,
|
|
5
|
-
runLikeApply,
|
|
6
|
-
sqlSkeleton
|
|
7
|
-
} from "./chunk-YUJ2MHLM.js";
|
|
8
|
-
import {
|
|
9
|
-
isCommentOnly,
|
|
10
|
-
splitSqlStatements
|
|
11
|
-
} from "./chunk-WK5YTINL.js";
|
|
12
|
-
import {
|
|
13
|
-
describeMissingPgDump,
|
|
14
|
-
getServerMajorVersion,
|
|
15
|
-
globToRegExp,
|
|
16
|
-
resolvePgDumpPath
|
|
17
|
-
} from "./chunk-Z2YUOA4W.js";
|
|
18
|
-
import {
|
|
19
|
-
pgQuery,
|
|
20
|
-
quoteIdent,
|
|
21
|
-
quoteLiteral,
|
|
22
|
-
quoteName
|
|
23
|
-
} from "./chunk-KT7NMELZ.js";
|
|
24
|
-
|
|
25
|
-
// src/prove.ts
|
|
26
|
-
import { randomBytes } from "crypto";
|
|
27
|
-
import { execFile, spawn as spawn2 } from "child_process";
|
|
28
|
-
import { promisify } from "util";
|
|
29
|
-
import { fingerprintSql, stateSql } from "@akal/pg-conformance";
|
|
30
|
-
|
|
31
|
-
// src/expression-forms.ts
|
|
32
|
-
var LITERAL = `'(?:[^']|'')*'(?:::[a-z_][\\w ]*(?:\\(\\d+(?:,\\s*\\d+)?\\))?)?`;
|
|
33
|
-
var CAST_ARRAY = new RegExp(`\\(ARRAY\\[(${LITERAL}(?:, ${LITERAL})*)\\]\\)::([a-z_][\\w ]*?(?:\\(\\d+(?:,\\s*\\d+)?\\))?)\\[\\]`, "g");
|
|
34
|
-
var ELEMENT = new RegExp(LITERAL, "g");
|
|
35
|
-
function canonicalArrays(text) {
|
|
36
|
-
return text.replace(CAST_ARRAY, (_match, elements, type) => `ARRAY[${(elements.match(ELEMENT) ?? []).map((e) => `(${e})::${type}`).join(", ")}]`);
|
|
37
|
-
}
|
|
38
|
-
|
|
39
|
-
// src/state-diff.ts
|
|
40
|
-
var canonical = (d) => typeof d === "string" ? canonicalArrays(d) : d;
|
|
41
|
-
var show = (v) => {
|
|
42
|
-
if (v === null || v === void 0) return "none";
|
|
43
|
-
if (typeof v === "boolean") return v ? "yes" : "no";
|
|
44
|
-
if (Array.isArray(v)) return v.length ? v.join(", ") : "none";
|
|
45
|
-
if (typeof v === "object") return JSON.stringify(v);
|
|
46
|
-
return String(v);
|
|
47
|
-
};
|
|
48
|
-
var qualify = (schema, name) => `${schema}.${name}`;
|
|
49
|
-
function compareField(out, subject, label, before, after) {
|
|
50
|
-
const a = show(before), b = show(after);
|
|
51
|
-
if (a !== b) out.push(`${subject}: ${label} ${a} \u2192 ${b}`);
|
|
52
|
-
}
|
|
53
|
-
function compareKeyed(out, kind, before, after, keyOf, compare, note = () => "") {
|
|
54
|
-
const a = new Map((before ?? []).map((x) => [keyOf(x), x]));
|
|
55
|
-
const b = new Map((after ?? []).map((x) => [keyOf(x), x]));
|
|
56
|
-
for (const [key, item] of a) {
|
|
57
|
-
if (!b.has(key)) out.push(`${kind} ${key}: missing`);
|
|
58
|
-
else compare(out, `${kind} ${key}`, item, b.get(key));
|
|
59
|
-
}
|
|
60
|
-
for (const [key, item] of b) {
|
|
61
|
-
if (!a.has(key)) out.push(`${kind} ${key}: unexpected${note(item)}`);
|
|
62
|
-
}
|
|
63
|
-
}
|
|
64
|
-
function compareColumn(out, subject, a, b) {
|
|
65
|
-
compareField(out, subject, "type", a.type, b.type);
|
|
66
|
-
compareField(out, subject, "not null", a.not_null, b.not_null);
|
|
67
|
-
compareField(out, subject, "default", a.default, b.default);
|
|
68
|
-
compareField(out, subject, "identity", a.identity, b.identity);
|
|
69
|
-
compareField(out, subject, "identity options", a.identity_options, b.identity_options);
|
|
70
|
-
compareField(out, subject, "generated", a.generated, b.generated);
|
|
71
|
-
compareField(out, subject, "storage", a.storage, b.storage);
|
|
72
|
-
compareField(out, subject, "compression", a.compression, b.compression);
|
|
73
|
-
compareField(out, subject, "collation", a.collation, b.collation);
|
|
74
|
-
compareField(out, subject, "comment", a.comment, b.comment);
|
|
75
|
-
}
|
|
76
|
-
function compareTable(out, subject, a, b) {
|
|
77
|
-
compareField(out, subject, "kind", a.kind, b.kind);
|
|
78
|
-
compareField(out, subject, "unlogged", a.unlogged, b.unlogged);
|
|
79
|
-
compareField(out, subject, "partition of", a.partition_of, b.partition_of);
|
|
80
|
-
compareField(out, subject, "partition bound", a.partition_bound, b.partition_bound);
|
|
81
|
-
compareField(out, subject, "partition by", a.partition_by, b.partition_by);
|
|
82
|
-
compareField(out, subject, "inherits", a.inherits, b.inherits);
|
|
83
|
-
compareField(out, subject, "options", a.options, b.options);
|
|
84
|
-
compareField(out, subject, "RLS enabled", a.rls_enabled, b.rls_enabled);
|
|
85
|
-
compareField(out, subject, "RLS forced", a.rls_forced, b.rls_forced);
|
|
86
|
-
compareField(out, subject, "comment", a.comment, b.comment);
|
|
87
|
-
const prefix = subject.replace(/^table /, "");
|
|
88
|
-
compareKeyed(
|
|
89
|
-
out,
|
|
90
|
-
"column",
|
|
91
|
-
a.columns,
|
|
92
|
-
b.columns,
|
|
93
|
-
(c) => `${prefix}.${c.name}`,
|
|
94
|
-
(o, s, x, y) => compareColumn(o, s, x, y)
|
|
95
|
-
);
|
|
96
|
-
compareKeyed(
|
|
97
|
-
out,
|
|
98
|
-
`constraint on ${prefix}`,
|
|
99
|
-
a.constraints,
|
|
100
|
-
b.constraints,
|
|
101
|
-
(c) => c.type === "not_null" ? c.definition : c.name,
|
|
102
|
-
(o, s, x, y) => {
|
|
103
|
-
compareField(o, s, "definition", canonical(x.definition), canonical(y.definition));
|
|
104
|
-
compareField(o, s, "validated", x.validated, y.validated);
|
|
105
|
-
compareField(o, s, "deferrable", x.deferrable, y.deferrable);
|
|
106
|
-
compareField(o, s, "deferred", x.deferred, y.deferred);
|
|
107
|
-
}
|
|
108
|
-
);
|
|
109
|
-
compareKeyed(
|
|
110
|
-
out,
|
|
111
|
-
`index on ${prefix}`,
|
|
112
|
-
a.indexes,
|
|
113
|
-
b.indexes,
|
|
114
|
-
(i) => i.name,
|
|
115
|
-
(o, s, x, y) => compareField(o, s, "definition", canonical(x.definition), canonical(y.definition))
|
|
116
|
-
);
|
|
117
|
-
compareKeyed(
|
|
118
|
-
out,
|
|
119
|
-
`policy on ${prefix}`,
|
|
120
|
-
a.policies,
|
|
121
|
-
b.policies,
|
|
122
|
-
(p) => p.name,
|
|
123
|
-
(o, s, x, y) => {
|
|
124
|
-
compareField(o, s, "command", x.command, y.command);
|
|
125
|
-
compareField(o, s, "permissive", x.permissive, y.permissive);
|
|
126
|
-
compareField(o, s, "roles", x.roles, y.roles);
|
|
127
|
-
compareField(o, s, "using", canonical(x.using), canonical(y.using));
|
|
128
|
-
compareField(o, s, "with check", canonical(x.with_check), canonical(y.with_check));
|
|
129
|
-
}
|
|
130
|
-
);
|
|
131
|
-
compareKeyed(
|
|
132
|
-
out,
|
|
133
|
-
`trigger on ${prefix}`,
|
|
134
|
-
a.triggers,
|
|
135
|
-
b.triggers,
|
|
136
|
-
(t) => t.name,
|
|
137
|
-
(o, s, x, y) => compareField(o, s, "definition", canonical(x.definition), canonical(y.definition))
|
|
138
|
-
);
|
|
139
|
-
}
|
|
140
|
-
function diffState(before, after) {
|
|
141
|
-
const out = [];
|
|
142
|
-
compareKeyed(
|
|
143
|
-
out,
|
|
144
|
-
"table",
|
|
145
|
-
before.tables,
|
|
146
|
-
after.tables,
|
|
147
|
-
(t) => qualify(t.schema, t.name),
|
|
148
|
-
(o, s, a, b) => compareTable(o, s, a, b)
|
|
149
|
-
);
|
|
150
|
-
compareKeyed(
|
|
151
|
-
out,
|
|
152
|
-
"view",
|
|
153
|
-
before.views,
|
|
154
|
-
after.views,
|
|
155
|
-
(v) => qualify(v.schema, v.name),
|
|
156
|
-
(o, s, a, b) => {
|
|
157
|
-
compareField(o, s, "materialized", a.materialized, b.materialized);
|
|
158
|
-
compareField(o, s, "definition", canonical(a.definition), canonical(b.definition));
|
|
159
|
-
compareField(o, s, "options", a.options, b.options);
|
|
160
|
-
}
|
|
161
|
-
);
|
|
162
|
-
compareKeyed(
|
|
163
|
-
out,
|
|
164
|
-
"sequence",
|
|
165
|
-
before.sequences,
|
|
166
|
-
after.sequences,
|
|
167
|
-
(q) => qualify(q.schema, q.name),
|
|
168
|
-
(o, s, a, b) => {
|
|
169
|
-
for (const k of ["type", "start", "increment", "min", "max", "cache", "cycle", "owned_by"]) {
|
|
170
|
-
compareField(o, s, k.replace("_", " "), a[k], b[k]);
|
|
171
|
-
}
|
|
172
|
-
},
|
|
173
|
-
// A serial or identity column's: it goes with its table.
|
|
174
|
-
(q) => q.owned_by ? ` (owned by ${q.owned_by})` : ""
|
|
175
|
-
);
|
|
176
|
-
compareKeyed(
|
|
177
|
-
out,
|
|
178
|
-
"routine",
|
|
179
|
-
before.routines,
|
|
180
|
-
after.routines,
|
|
181
|
-
(r) => `${qualify(r.schema, r.name)}(${r.arguments})`,
|
|
182
|
-
(o, s, a, b) => {
|
|
183
|
-
compareField(o, s, "kind", a.kind, b.kind);
|
|
184
|
-
compareField(o, s, "definition", canonical(a.definition), canonical(b.definition));
|
|
185
|
-
}
|
|
186
|
-
);
|
|
187
|
-
compareKeyed(
|
|
188
|
-
out,
|
|
189
|
-
"type",
|
|
190
|
-
before.types,
|
|
191
|
-
after.types,
|
|
192
|
-
(t) => qualify(t.schema, t.name),
|
|
193
|
-
(o, s, a, b) => {
|
|
194
|
-
compareField(o, s, "kind", a.kind, b.kind);
|
|
195
|
-
compareField(o, s, "labels", a.labels, b.labels);
|
|
196
|
-
compareField(o, s, "base type", a.base_type, b.base_type);
|
|
197
|
-
compareField(o, s, "not null", a.not_null, b.not_null);
|
|
198
|
-
compareField(o, s, "default", a.default, b.default);
|
|
199
|
-
compareField(o, s, "constraints", a.constraints, b.constraints);
|
|
200
|
-
compareField(o, s, "attributes", a.attributes, b.attributes);
|
|
201
|
-
}
|
|
202
|
-
);
|
|
203
|
-
compareKeyed(
|
|
204
|
-
out,
|
|
205
|
-
"extension",
|
|
206
|
-
before.extensions,
|
|
207
|
-
after.extensions,
|
|
208
|
-
(e) => e.name,
|
|
209
|
-
(o, s, a, b) => compareField(o, s, "version", a.version, b.version)
|
|
210
|
-
);
|
|
211
|
-
return out;
|
|
212
|
-
}
|
|
213
|
-
|
|
214
|
-
// src/prove.ts
|
|
215
|
-
import { join, dirname } from "path";
|
|
216
|
-
|
|
217
|
-
// src/prove-data.ts
|
|
218
|
-
import { spawn } from "child_process";
|
|
219
|
-
var DEFAULT_SAMPLE_ROWS = 1e3;
|
|
220
|
-
function sampleRows() {
|
|
221
|
-
const raw = process.env.SUPAFORGE_PROVE_ROWS;
|
|
222
|
-
const n = raw === void 0 ? DEFAULT_SAMPLE_ROWS : Number(raw);
|
|
223
|
-
return Number.isInteger(n) && n >= 0 ? n : DEFAULT_SAMPLE_ROWS;
|
|
224
|
-
}
|
|
225
|
-
var TABLES_SQL = `
|
|
226
|
-
SELECT n.nspname || '.' || c.relname AS name, quote_ident(n.nspname) || '.' || quote_ident(c.relname) AS ident,
|
|
227
|
-
(SELECT string_agg(quote_ident(a.attname), ', ' ORDER BY a.attnum) FROM pg_attribute a
|
|
228
|
-
WHERE a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped AND a.attgenerated = '') AS columns
|
|
229
|
-
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
230
|
-
WHERE c.relkind = 'r' AND NOT c.relispartition AND n.nspname = ANY($1::text[])
|
|
231
|
-
ORDER BY 1`;
|
|
232
|
-
async function sampleInto(psql, fromUrl, intoUrl, schemas, limit) {
|
|
233
|
-
const tables = await pgQuery(fromUrl, TABLES_SQL, [schemas]);
|
|
234
|
-
const sampled = [];
|
|
235
|
-
const unchecked = [];
|
|
236
|
-
for (const t of tables) {
|
|
237
|
-
if (!t.columns) continue;
|
|
238
|
-
try {
|
|
239
|
-
await pipeCopy(
|
|
240
|
-
psql,
|
|
241
|
-
fromUrl,
|
|
242
|
-
intoUrl,
|
|
243
|
-
`\\copy (SELECT ${t.columns} FROM ${t.ident} LIMIT ${limit}) TO STDOUT`,
|
|
244
|
-
`\\copy ${t.ident} (${t.columns}) FROM STDIN`
|
|
245
|
-
);
|
|
246
|
-
sampled.push(t.name);
|
|
247
|
-
} catch {
|
|
248
|
-
unchecked.push(t.name);
|
|
249
|
-
}
|
|
250
|
-
}
|
|
251
|
-
return { sampled, unchecked };
|
|
252
|
-
}
|
|
253
|
-
function pipeCopy(psql, fromUrl, intoUrl, out, into) {
|
|
254
|
-
return new Promise((resolve, reject) => {
|
|
255
|
-
const reader = spawn(psql, [fromUrl, "-X", "-q", "-v", "ON_ERROR_STOP=1", "-c", out], { stdio: ["ignore", "pipe", "pipe"] });
|
|
256
|
-
const writer = spawn(psql, [intoUrl, "-X", "-q", "-v", "ON_ERROR_STOP=1", "-f", "-"], { stdio: ["pipe", "pipe", "pipe"] });
|
|
257
|
-
let stderr = "";
|
|
258
|
-
reader.stderr.on("data", (d) => {
|
|
259
|
-
stderr += d.toString();
|
|
260
|
-
});
|
|
261
|
-
writer.stderr.on("data", (d) => {
|
|
262
|
-
stderr += d.toString();
|
|
263
|
-
});
|
|
264
|
-
reader.on("error", reject);
|
|
265
|
-
writer.on("error", reject);
|
|
266
|
-
writer.stdin.on("error", () => void 0);
|
|
267
|
-
writer.stdin.write(`\\set ON_ERROR_STOP 0
|
|
268
|
-
SET session_replication_role = replica;
|
|
269
|
-
\\set ON_ERROR_STOP 1
|
|
270
|
-
${into}
|
|
271
|
-
`);
|
|
272
|
-
reader.stdout.pipe(writer.stdin);
|
|
273
|
-
let done = 0;
|
|
274
|
-
let failed = false;
|
|
275
|
-
const finish = (code) => {
|
|
276
|
-
if (code !== 0) failed = true;
|
|
277
|
-
if (++done === 2) failed ? reject(new Error(stderr.trim() || "copy failed")) : resolve();
|
|
278
|
-
};
|
|
279
|
-
reader.on("close", finish);
|
|
280
|
-
writer.on("close", finish);
|
|
281
|
-
});
|
|
282
|
-
}
|
|
283
|
-
async function snapshotTables(dbUrl, schemas) {
|
|
284
|
-
const rows = await pgQuery(dbUrl, `
|
|
285
|
-
SELECT n.nspname || '.' || c.relname AS name, quote_ident(n.nspname) || '.' || quote_ident(c.relname) AS ident,
|
|
286
|
-
json_agg(json_build_array(a.attname, format_type(a.atttypid, a.atttypmod)) ORDER BY a.attnum) AS columns
|
|
287
|
-
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
288
|
-
JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped AND a.attgenerated = ''
|
|
289
|
-
WHERE c.relkind = 'r' AND NOT c.relispartition AND n.nspname = ANY($1::text[])
|
|
290
|
-
GROUP BY 1, 2 ORDER BY 1`, [schemas]);
|
|
291
|
-
const out = /* @__PURE__ */ new Map();
|
|
292
|
-
for (const t of rows) {
|
|
293
|
-
const hashes = t.columns.map(([col], i) => {
|
|
294
|
-
const value = `coalesce(md5(x.${quoteIdent(col)}::text), 'n')`;
|
|
295
|
-
return `coalesce(md5(string_agg(${value}, '' ORDER BY ${value})), '') AS h${i}`;
|
|
296
|
-
});
|
|
297
|
-
const [row] = await pgQuery(
|
|
298
|
-
dbUrl,
|
|
299
|
-
`SELECT count(*)::text AS rows, pg_relation_filenode(${quoteLiteral(t.ident)}::regclass)::text AS filenode${hashes.length ? ", " + hashes.join(", ") : ""}
|
|
300
|
-
FROM ${t.ident} x`
|
|
301
|
-
);
|
|
302
|
-
out.set(t.name, {
|
|
303
|
-
rows: Number(row.rows),
|
|
304
|
-
filenode: row.filenode,
|
|
305
|
-
columns: Object.fromEntries(t.columns.map(([col, type], i) => [col, { type, hash: row[`h${i}`] }]))
|
|
306
|
-
});
|
|
307
|
-
}
|
|
308
|
-
return out;
|
|
309
|
-
}
|
|
310
|
-
function emptiedTables(sql) {
|
|
311
|
-
const out = /* @__PURE__ */ new Set();
|
|
312
|
-
for (const s of parseStatements(sql) ?? []) {
|
|
313
|
-
if (s.kind === "DeleteStmt") out.add(relationName(s.node.relation));
|
|
314
|
-
if (s.kind === "TruncateStmt") for (const r of s.node.relations ?? []) out.add(relationName(r.RangeVar));
|
|
315
|
-
}
|
|
316
|
-
return out;
|
|
317
|
-
}
|
|
318
|
-
function compareTables(before, after, sampled, migrationSql) {
|
|
319
|
-
const emptied = emptiedTables(migrationSql);
|
|
320
|
-
const lost = [];
|
|
321
|
-
const rewritten = [];
|
|
322
|
-
for (const name of sampled) {
|
|
323
|
-
const b = before.get(name);
|
|
324
|
-
const a = after.get(name);
|
|
325
|
-
if (!b || !a) continue;
|
|
326
|
-
if (b.filenode !== a.filenode) rewritten.push(name);
|
|
327
|
-
if (emptied.has(name.slice(name.indexOf(".") + 1))) continue;
|
|
328
|
-
if (a.rows < b.rows) {
|
|
329
|
-
lost.push(`${name}: ${b.rows} row(s) before, ${a.rows} after`);
|
|
330
|
-
continue;
|
|
331
|
-
}
|
|
332
|
-
if (a.rows !== b.rows) continue;
|
|
333
|
-
const changed = Object.entries(b.columns).filter(([col, c]) => a.columns[col] && a.columns[col].type === c.type && a.columns[col].hash !== c.hash).map(([col]) => col);
|
|
334
|
-
if (changed.length > 0) {
|
|
335
|
-
lost.push(`${name}: values changed in ${changed.join(", ")}`);
|
|
336
|
-
}
|
|
337
|
-
}
|
|
338
|
-
return { lost, rewritten };
|
|
339
|
-
}
|
|
340
|
-
|
|
341
|
-
// src/prove.ts
|
|
342
|
-
var exec = promisify(execFile);
|
|
343
|
-
var TARGET_EXTENSIONS_SQL = `
|
|
344
|
-
SELECT e.extname AS name, n.nspname AS schema
|
|
345
|
-
FROM pg_extension e
|
|
346
|
-
JOIN pg_namespace n ON n.oid = e.extnamespace
|
|
347
|
-
WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
|
|
348
|
-
AND n.nspname NOT LIKE 'pg\\_%'
|
|
349
|
-
ORDER BY e.extname
|
|
350
|
-
`;
|
|
351
|
-
function withDatabase(dbUrl, database) {
|
|
352
|
-
const url = new URL(dbUrl);
|
|
353
|
-
url.pathname = `/${database}`;
|
|
354
|
-
return url.toString();
|
|
355
|
-
}
|
|
356
|
-
async function fingerprint(dbUrl, schemas) {
|
|
357
|
-
const rows = await pgQuery(dbUrl, fingerprintSql(schemas));
|
|
358
|
-
const value = rows[0]?.fingerprint;
|
|
359
|
-
if (value === void 0) {
|
|
360
|
-
throw new Error('fingerprint query returned no "fingerprint" column');
|
|
361
|
-
}
|
|
362
|
-
return value ?? "";
|
|
363
|
-
}
|
|
364
|
-
async function describeDifference(sourceUrl, cloneUrl, schemas, want, got) {
|
|
365
|
-
try {
|
|
366
|
-
const [before, after] = await Promise.all([
|
|
367
|
-
schemaState(sourceUrl, schemas),
|
|
368
|
-
schemaState(cloneUrl, schemas)
|
|
369
|
-
]);
|
|
370
|
-
const findings = diffState(before, after);
|
|
371
|
-
if (findings.length > 0) return findings;
|
|
372
|
-
} catch {
|
|
373
|
-
}
|
|
374
|
-
const wanted = new Set(want.split("\n").filter(Boolean));
|
|
375
|
-
const actual = new Set(got.split("\n").filter(Boolean));
|
|
376
|
-
return [
|
|
377
|
-
...[...wanted].filter((l) => !actual.has(l)).map((l) => `missing: ${l}`),
|
|
378
|
-
...[...actual].filter((l) => !wanted.has(l)).map((l) => `unexpected: ${l}`)
|
|
379
|
-
];
|
|
380
|
-
}
|
|
381
|
-
async function schemaState(dbUrl, schemas) {
|
|
382
|
-
const rows = await pgQuery(dbUrl, stateSql(schemas));
|
|
383
|
-
const value = rows[0]?.state;
|
|
384
|
-
if (!value) throw new Error('state query returned no "state" column');
|
|
385
|
-
return JSON.parse(value);
|
|
386
|
-
}
|
|
387
|
-
async function comparedSchemas(sourceUrl, targetUrl, ignore, query = pgQuery) {
|
|
388
|
-
const sql = `SELECT n.nspname AS name FROM pg_namespace n
|
|
389
|
-
WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
|
|
390
|
-
AND n.nspname NOT LIKE 'pg\\_toast%' AND n.nspname NOT LIKE 'pg\\_temp\\_%'
|
|
391
|
-
AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.classid = 'pg_namespace'::regclass
|
|
392
|
-
AND d.objid = n.oid AND d.deptype = 'e')`;
|
|
393
|
-
const ignored = ignore.map(globToRegExp);
|
|
394
|
-
const names = (await Promise.all([sourceUrl, targetUrl].map((url) => query(url, sql)))).flat().map((r) => String(r.name));
|
|
395
|
-
return [...new Set(names)].filter((n) => !ignored.some((g) => g.test(n))).sort();
|
|
396
|
-
}
|
|
397
|
-
async function proveConvergence(opts) {
|
|
398
|
-
const schemas = opts.schemas ?? ["public"];
|
|
399
|
-
const suffix = randomBytes(4).toString("hex");
|
|
400
|
-
const cloneName = `supaforge_prove_${suffix}`;
|
|
401
|
-
const adminUrl = withDatabase(opts.targetUrl, "postgres");
|
|
402
|
-
const cloneUrl = withDatabase(opts.targetUrl, cloneName);
|
|
403
|
-
let pgDump;
|
|
404
|
-
let psql;
|
|
405
|
-
let serverMajor;
|
|
406
|
-
let clientMajor;
|
|
407
|
-
let sourceMajor;
|
|
408
|
-
try {
|
|
409
|
-
serverMajor = await getServerMajorVersion(opts.targetUrl);
|
|
410
|
-
sourceMajor = await getServerMajorVersion(opts.sourceUrl).catch(() => serverMajor);
|
|
411
|
-
const resolved = await resolvePgDumpPath(Math.max(serverMajor, sourceMajor)) ?? await resolvePgDumpPath(serverMajor);
|
|
412
|
-
if (!resolved) {
|
|
413
|
-
return { converged: false, residual: [], cloneName, skipped: await describeMissingPgDump(serverMajor) };
|
|
414
|
-
}
|
|
415
|
-
pgDump = resolved.path;
|
|
416
|
-
clientMajor = resolved.major;
|
|
417
|
-
psql = psqlBeside(pgDump);
|
|
418
|
-
} catch (err) {
|
|
419
|
-
return {
|
|
420
|
-
converged: false,
|
|
421
|
-
residual: [],
|
|
422
|
-
cloneName,
|
|
423
|
-
skipped: `could not resolve pg_dump: ${err.message}`
|
|
424
|
-
};
|
|
425
|
-
}
|
|
426
|
-
const absent = await absentRoles(opts.targetUrl, opts.migrationSql);
|
|
427
|
-
if (absent.length > 0) {
|
|
428
|
-
return {
|
|
429
|
-
converged: false,
|
|
430
|
-
residual: [],
|
|
431
|
-
cloneName,
|
|
432
|
-
skipped: `the migration needs role(s) this server does not have yet (${absent.join(", ")}), and creating a role is server-wide, so it cannot be done in a throwaway database`
|
|
433
|
-
};
|
|
434
|
-
}
|
|
435
|
-
let created = false;
|
|
436
|
-
let sourceCopyCreated = false;
|
|
437
|
-
let roundTripName;
|
|
438
|
-
try {
|
|
439
|
-
try {
|
|
440
|
-
await pgQuery(adminUrl, `CREATE DATABASE ${quoteName(cloneName)}`);
|
|
441
|
-
created = true;
|
|
442
|
-
} catch (err) {
|
|
443
|
-
return {
|
|
444
|
-
converged: false,
|
|
445
|
-
residual: [],
|
|
446
|
-
cloneName,
|
|
447
|
-
skipped: `could not create a throwaway database: ${err.message}`
|
|
448
|
-
};
|
|
449
|
-
}
|
|
450
|
-
const tools = { pgDump, psql, clientMajor, serverMajor };
|
|
451
|
-
await copyStructure(opts.targetUrl, cloneUrl, schemas, tools, opts.sourceUrl);
|
|
452
|
-
const scoped = opts.checks !== void 0 && !opts.checks.includes("schema");
|
|
453
|
-
const before = scoped ? await schemaState(cloneUrl, schemas) : void 0;
|
|
454
|
-
const limit = sampleRows();
|
|
455
|
-
const sample = limit > 0 ? await sampleInto(psql, opts.targetUrl, cloneUrl, schemas, limit) : void 0;
|
|
456
|
-
const tablesBefore = sample ? await snapshotTables(cloneUrl, schemas) : void 0;
|
|
457
|
-
let notApplied;
|
|
458
|
-
if (opts.fixes) {
|
|
459
|
-
const replayed = await runLikeApply(cloneUrl, opts.fixes, sourceMajor);
|
|
460
|
-
const unmet = replayed.errors.filter((e) => / — not applied: /.test(e.error));
|
|
461
|
-
const failed = replayed.errors.filter((e) => !unmet.includes(e));
|
|
462
|
-
if (failed.length > 0) {
|
|
463
|
-
return {
|
|
464
|
-
converged: false,
|
|
465
|
-
cloneName,
|
|
466
|
-
residual: failed.map((e) => `fix ${e.issueId} failed: ${e.error}`)
|
|
467
|
-
};
|
|
468
|
-
}
|
|
469
|
-
const byId = new Map(opts.fixes.map((f) => [f.issueId, f.sql]));
|
|
470
|
-
notApplied = unmet.map((e) => ({ issueId: e.issueId, sql: byId.get(e.issueId) ?? "", reason: e.error }));
|
|
471
|
-
} else {
|
|
472
|
-
await runSql(psql, cloneUrl, opts.migrationSql);
|
|
473
|
-
}
|
|
474
|
-
let data;
|
|
475
|
-
if (sample && tablesBefore) {
|
|
476
|
-
data = { ...sample, ...compareTables(tablesBefore, await snapshotTables(cloneUrl, schemas), sample.sampled, opts.migrationSql) };
|
|
477
|
-
if (data.lost.length > 0) {
|
|
478
|
-
return { converged: false, cloneName, data, residual: data.lost.map((l) => `rows lost in ${l}`) };
|
|
479
|
-
}
|
|
480
|
-
}
|
|
481
|
-
const reported = (r) => {
|
|
482
|
-
const withData = data ? { ...r, data } : r;
|
|
483
|
-
return notApplied?.length ? { ...withData, notApplied } : withData;
|
|
484
|
-
};
|
|
485
|
-
const [want, got] = await Promise.all([
|
|
486
|
-
fingerprint(opts.sourceUrl, schemas),
|
|
487
|
-
fingerprint(cloneUrl, schemas)
|
|
488
|
-
]);
|
|
489
|
-
if (canonicalArrays(want) === canonicalArrays(got)) return reported({ converged: true, residual: [], cloneName });
|
|
490
|
-
roundTripName = `${cloneName}_src`;
|
|
491
|
-
const roundTripUrl = withDatabase(opts.targetUrl, roundTripName);
|
|
492
|
-
const roundTrip = await copyOfSource(adminUrl, opts.sourceUrl, roundTripUrl, roundTripName, schemas, tools);
|
|
493
|
-
if (roundTrip !== null) {
|
|
494
|
-
sourceCopyCreated = true;
|
|
495
|
-
if (roundTrip.ok) {
|
|
496
|
-
const wantRoundTripped = await fingerprint(roundTripUrl, schemas);
|
|
497
|
-
if (canonicalArrays(wantRoundTripped) === canonicalArrays(got)) return reported({ converged: true, residual: [], cloneName });
|
|
498
|
-
const residual2 = await describeDifference(roundTripUrl, cloneUrl, schemas, wantRoundTripped, got);
|
|
499
|
-
return reported(withinScope(residual2, before && diffState(await schemaState(roundTripUrl, schemas), before), opts.checks, cloneName));
|
|
500
|
-
}
|
|
501
|
-
}
|
|
502
|
-
if (sourceMajor !== serverMajor) {
|
|
503
|
-
return {
|
|
504
|
-
converged: false,
|
|
505
|
-
residual: [],
|
|
506
|
-
cloneName,
|
|
507
|
-
skipped: `no pg_dump ${sourceMajor} or later to copy the PostgreSQL ${sourceMajor} source onto the PostgreSQL ${serverMajor} target's server, which comparing across the two versions needs`
|
|
508
|
-
};
|
|
509
|
-
}
|
|
510
|
-
const residual = await describeDifference(opts.sourceUrl, cloneUrl, schemas, want, got);
|
|
511
|
-
return reported(withinScope(residual, before && diffState(await schemaState(opts.sourceUrl, schemas), before), opts.checks, cloneName));
|
|
512
|
-
} finally {
|
|
513
|
-
if (sourceCopyCreated && roundTripName) {
|
|
514
|
-
await dropDatabase(adminUrl, roundTripName);
|
|
515
|
-
}
|
|
516
|
-
if (created) {
|
|
517
|
-
await dropDatabase(adminUrl, cloneName);
|
|
518
|
-
}
|
|
519
|
-
}
|
|
520
|
-
}
|
|
521
|
-
async function copyStructure(fromUrl, intoUrl, schemas, tools, migratingFrom) {
|
|
522
|
-
await prepareClone(intoUrl, fromUrl, schemas);
|
|
523
|
-
const supporting = await supportingSchemas(fromUrl, schemas);
|
|
524
|
-
const present = new Set((await pgQuery(fromUrl, "SELECT nspname FROM pg_namespace")).map((r) => r.nspname));
|
|
525
|
-
if (migratingFrom) {
|
|
526
|
-
for (const name of await supportingSchemas(migratingFrom, schemas)) {
|
|
527
|
-
if (present.has(name) && !supporting.includes(name)) supporting.push(name);
|
|
528
|
-
}
|
|
529
|
-
}
|
|
530
|
-
const dumpArgs = [
|
|
531
|
-
fromUrl,
|
|
532
|
-
"--schema-only",
|
|
533
|
-
"--no-owner",
|
|
534
|
-
"--no-privileges",
|
|
535
|
-
...[...schemas.filter((s) => present.has(s)), ...supporting].map((s) => `--schema=${quoteName(s)}`)
|
|
536
|
-
];
|
|
537
|
-
const { stdout: structure } = await exec(tools.pgDump, dumpArgs, {
|
|
538
|
-
maxBuffer: 256 * 1024 * 1024,
|
|
539
|
-
timeout: 3e5
|
|
540
|
-
});
|
|
541
|
-
const { sql: replayable } = dropUnsupportedSetStatements(
|
|
542
|
-
tolerateExistingSchemas(structure),
|
|
543
|
-
await knownParameters(intoUrl)
|
|
544
|
-
);
|
|
545
|
-
try {
|
|
546
|
-
await runSql(tools.psql, intoUrl, replayable);
|
|
547
|
-
} catch (err) {
|
|
548
|
-
throw new Error(explainStructureFailure(err.message, tools.clientMajor, tools.serverMajor));
|
|
549
|
-
}
|
|
550
|
-
}
|
|
551
|
-
async function supportingSchemas(dbUrl, schemas, queryFn = pgQuery) {
|
|
552
|
-
const known = new Set(schemas);
|
|
553
|
-
const found = [];
|
|
554
|
-
for (let from = [...schemas]; from.length > 0; ) {
|
|
555
|
-
const rows = await queryFn(dbUrl, SUPPORTING_SCHEMAS_SQL(from));
|
|
556
|
-
from = rows.map((r) => r.schema).filter((s) => !known.has(s));
|
|
557
|
-
for (const schema of from) {
|
|
558
|
-
known.add(schema);
|
|
559
|
-
found.push(schema);
|
|
560
|
-
}
|
|
561
|
-
}
|
|
562
|
-
return found;
|
|
563
|
-
}
|
|
564
|
-
var NAMESPACE_OF = (cls, oid) => `CASE ${cls}
|
|
565
|
-
WHEN 'pg_class'::regclass THEN (SELECT relnamespace FROM pg_class WHERE oid = ${oid})
|
|
566
|
-
WHEN 'pg_proc'::regclass THEN (SELECT pronamespace FROM pg_proc WHERE oid = ${oid})
|
|
567
|
-
WHEN 'pg_type'::regclass THEN (SELECT typnamespace FROM pg_type WHERE oid = ${oid})
|
|
568
|
-
WHEN 'pg_constraint'::regclass THEN (SELECT connamespace FROM pg_constraint WHERE oid = ${oid})
|
|
569
|
-
WHEN 'pg_attrdef'::regclass THEN (SELECT x_c.relnamespace FROM pg_attrdef x_d JOIN pg_class x_c ON x_c.oid = x_d.adrelid WHERE x_d.oid = ${oid})
|
|
570
|
-
WHEN 'pg_policy'::regclass THEN (SELECT x_c.relnamespace FROM pg_policy x_p JOIN pg_class x_c ON x_c.oid = x_p.polrelid WHERE x_p.oid = ${oid})
|
|
571
|
-
WHEN 'pg_trigger'::regclass THEN (SELECT x_c.relnamespace FROM pg_trigger x_t JOIN pg_class x_c ON x_c.oid = x_t.tgrelid WHERE x_t.oid = ${oid})
|
|
572
|
-
WHEN 'pg_rewrite'::regclass THEN (SELECT x_c.relnamespace FROM pg_rewrite x_r JOIN pg_class x_c ON x_c.oid = x_r.ev_class WHERE x_r.oid = ${oid})
|
|
573
|
-
END`;
|
|
574
|
-
var SUPPORTING_SCHEMAS_SQL = (from) => `
|
|
575
|
-
SELECT DISTINCT rn.nspname AS schema
|
|
576
|
-
FROM pg_depend d
|
|
577
|
-
JOIN pg_namespace n ON n.oid = ${NAMESPACE_OF("d.classid", "d.objid")}
|
|
578
|
-
JOIN pg_namespace rn ON rn.oid = ${NAMESPACE_OF("d.refclassid", "d.refobjid")}
|
|
579
|
-
WHERE n.nspname IN (${from.map(quoteLiteral2).join(", ")})
|
|
580
|
-
AND rn.nspname <> n.nspname
|
|
581
|
-
AND rn.nspname NOT IN ('pg_catalog', 'information_schema')
|
|
582
|
-
AND rn.nspname NOT LIKE 'pg\\_%'
|
|
583
|
-
AND d.deptype IN ('n', 'a')
|
|
584
|
-
AND NOT EXISTS (SELECT 1 FROM pg_depend e
|
|
585
|
-
WHERE e.classid = d.refclassid AND e.objid = d.refobjid AND e.deptype = 'e')
|
|
586
|
-
ORDER BY 1`;
|
|
587
|
-
function quoteLiteral2(value) {
|
|
588
|
-
return `'${value.replace(/'/g, "''")}'`;
|
|
589
|
-
}
|
|
590
|
-
function tolerateExistingSchemas(sql) {
|
|
591
|
-
return sql.replace(/^CREATE SCHEMA (?!IF NOT EXISTS )/gm, "CREATE SCHEMA IF NOT EXISTS ");
|
|
592
|
-
}
|
|
593
|
-
async function copyOfSource(adminUrl, sourceUrl, intoUrl, name, schemas, tools) {
|
|
594
|
-
try {
|
|
595
|
-
await pgQuery(adminUrl, `CREATE DATABASE ${quoteName(name)}`);
|
|
596
|
-
} catch {
|
|
597
|
-
return null;
|
|
598
|
-
}
|
|
599
|
-
try {
|
|
600
|
-
await copyStructure(sourceUrl, intoUrl, schemas, tools);
|
|
601
|
-
return { ok: true };
|
|
602
|
-
} catch {
|
|
603
|
-
return { ok: false };
|
|
604
|
-
}
|
|
605
|
-
}
|
|
606
|
-
async function dropDatabase(adminUrl, name) {
|
|
607
|
-
await pgQuery(
|
|
608
|
-
adminUrl,
|
|
609
|
-
`SELECT pg_terminate_backend(pid) FROM pg_stat_activity
|
|
610
|
-
WHERE datname = '${name}' AND pid <> pg_backend_pid()`
|
|
611
|
-
).catch(() => void 0);
|
|
612
|
-
await pgQuery(adminUrl, `DROP DATABASE IF EXISTS ${quoteName(name)}`).catch(() => void 0);
|
|
613
|
-
}
|
|
614
|
-
function runSql(psqlPath, dbUrl, sql) {
|
|
615
|
-
const trimmed = sql.trim();
|
|
616
|
-
if (!trimmed) return Promise.resolve();
|
|
617
|
-
return new Promise((resolve, reject) => {
|
|
618
|
-
const child = spawn2(psqlPath, [dbUrl, "-v", "ON_ERROR_STOP=1", "-q", "-f", "-"], {
|
|
619
|
-
stdio: ["pipe", "pipe", "pipe"]
|
|
620
|
-
});
|
|
621
|
-
let stderr = "";
|
|
622
|
-
child.stderr.on("data", (d) => {
|
|
623
|
-
stderr += d.toString();
|
|
624
|
-
});
|
|
625
|
-
child.on("error", reject);
|
|
626
|
-
child.on("close", (code) => {
|
|
627
|
-
if (code === 0) resolve();
|
|
628
|
-
else reject(new Error(stderr.trim() || `psql exited ${code}`));
|
|
629
|
-
});
|
|
630
|
-
child.stdin.write(trimmed);
|
|
631
|
-
child.stdin.end();
|
|
632
|
-
});
|
|
633
|
-
}
|
|
634
|
-
function psqlBeside(pgDumpPath) {
|
|
635
|
-
return pgDumpPath === "pg_dump" ? "psql" : join(dirname(pgDumpPath), "psql");
|
|
636
|
-
}
|
|
637
|
-
var PREAMBLE_LINE = /^\s*(?:--|$|\\(?:un)?restrict\b|SET\s+[\w.]+\s*=|SELECT\s+pg_catalog\.set_config\s*\()/i;
|
|
638
|
-
var SET_STATEMENT = /^\s*SET\s+([\w.]+)\s*=/i;
|
|
639
|
-
function dropUnsupportedSetStatements(sql, knownParameters2) {
|
|
640
|
-
const lines = sql.split("\n");
|
|
641
|
-
const dropped = [];
|
|
642
|
-
const kept = [];
|
|
643
|
-
let inPreamble = true;
|
|
644
|
-
for (const line of lines) {
|
|
645
|
-
if (inPreamble && !PREAMBLE_LINE.test(line)) inPreamble = false;
|
|
646
|
-
if (inPreamble) {
|
|
647
|
-
const name = SET_STATEMENT.exec(line)?.[1];
|
|
648
|
-
if (name && !knownParameters2.has(name.toLowerCase())) {
|
|
649
|
-
dropped.push(name.toLowerCase());
|
|
650
|
-
continue;
|
|
651
|
-
}
|
|
652
|
-
}
|
|
653
|
-
kept.push(line);
|
|
654
|
-
}
|
|
655
|
-
return { sql: kept.join("\n"), dropped };
|
|
656
|
-
}
|
|
657
|
-
async function prepareClone(cloneUrl, targetUrl, schemas, queryFn = pgQuery) {
|
|
658
|
-
for (const schema of schemas) {
|
|
659
|
-
await queryFn(cloneUrl, `DROP SCHEMA IF EXISTS ${quoteName(schema)} CASCADE`);
|
|
660
|
-
}
|
|
661
|
-
const extensions = await queryFn(targetUrl, TARGET_EXTENSIONS_SQL);
|
|
662
|
-
for (const ext of extensions) {
|
|
663
|
-
await queryFn(cloneUrl, `CREATE SCHEMA IF NOT EXISTS ${quoteName(ext.schema)}`).catch(() => void 0);
|
|
664
|
-
await queryFn(
|
|
665
|
-
cloneUrl,
|
|
666
|
-
`CREATE EXTENSION IF NOT EXISTS ${quoteName(ext.name)} WITH SCHEMA ${quoteName(ext.schema)}`
|
|
667
|
-
).catch(() => void 0);
|
|
668
|
-
}
|
|
669
|
-
}
|
|
670
|
-
async function knownParameters(dbUrl) {
|
|
671
|
-
const rows = await pgQuery(dbUrl, "SELECT name FROM pg_settings");
|
|
672
|
-
return new Set(rows.map((r) => r.name.toLowerCase()));
|
|
673
|
-
}
|
|
674
|
-
function explainStructureFailure(message, clientMajor, serverMajor) {
|
|
675
|
-
const looksLikeVersionGap = /unrecognized configuration parameter|syntax error/i.test(message);
|
|
676
|
-
const versionGap = clientMajor > serverMajor && looksLikeVersionGap ? ` The local client is PostgreSQL ${clientMajor} and the target server is ${serverMajor}; pg_dump ${clientMajor} can emit SQL that a ${serverMajor} server rejects. Installing postgresql-client-${serverMajor} removes the gap.` : "";
|
|
677
|
-
return `could not replay the target's structure onto the clone: ${message}${versionGap}`;
|
|
678
|
-
}
|
|
679
|
-
var DROPPED_NAME = /\bDROP\s+(?:TABLE|VIEW|MATERIALIZED\s+VIEW|TYPE|DOMAIN|SEQUENCE|FUNCTION|PROCEDURE|INDEX|COLUMN|CONSTRAINT|POLICY|TRIGGER)\s+(?:IF\s+EXISTS\s+)?(?:(?:"[^"]+"|[\w$]+)\s*\.\s*)?("[^"]+"|[\w$]+)/gi;
|
|
680
|
-
function identParts(qualified) {
|
|
681
|
-
return [...qualified.matchAll(/"((?:[^"]|"")+)"|([^."]+)/g)].map((m) => (m[1]?.replace(/""/g, '"') ?? m[2]).toLowerCase());
|
|
682
|
-
}
|
|
683
|
-
var CREATED_NAME = /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:UNIQUE\s+)?(?:TABLE|VIEW|MATERIALIZED\s+VIEW|TYPE|DOMAIN|SEQUENCE|FUNCTION|PROCEDURE|INDEX|POLICY|TRIGGER|EXTENSION)\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(?:"[^"]+"|[\w$]+)\s*\.\s*)?("[^"]+"|[\w$]+)/gi;
|
|
684
|
-
function residualHeldBack(residual, heldBackSql) {
|
|
685
|
-
const dropped = /* @__PURE__ */ new Set();
|
|
686
|
-
for (const sql of heldBackSql) {
|
|
687
|
-
for (const m of sql.matchAll(DROPPED_NAME)) dropped.add(m[1].replace(/^"|"$/g, "").toLowerCase());
|
|
688
|
-
}
|
|
689
|
-
const created = [];
|
|
690
|
-
for (const sql of heldBackSql) {
|
|
691
|
-
for (const m of sql.matchAll(CREATED_NAME)) created.push(m[1].replace(/^"|"$/g, "").toLowerCase());
|
|
692
|
-
}
|
|
693
|
-
const heldBack = [];
|
|
694
|
-
const unexplained = [];
|
|
695
|
-
for (const line of residual) {
|
|
696
|
-
const [, subject, owner] = /^[a-z ]+?\s([^\s:]+(?:\s[^\s:]+)?):\s*unexpected(?: \(owned by (.+)\))?$/i.exec(line) ?? [];
|
|
697
|
-
const name = subject?.split(/[.\s]/).pop()?.replace(/^"|"$/g, "").toLowerCase();
|
|
698
|
-
const owners = owner ? identParts(owner) : [];
|
|
699
|
-
const missing = /^(.*):\s*missing$/i.exec(line)?.[1].toLowerCase();
|
|
700
|
-
if (name && dropped.has(name) || owners.some((o) => dropped.has(o))) heldBack.push(line);
|
|
701
|
-
else if (missing && created.some((n) => missing.endsWith(` ${n}`) || missing.endsWith(`.${n}`))) heldBack.push(line);
|
|
702
|
-
else unexplained.push(line);
|
|
703
|
-
}
|
|
704
|
-
return { heldBack, unexplained };
|
|
705
|
-
}
|
|
706
|
-
var PROVED_CHECKS = /* @__PURE__ */ new Set(["schema", "rls", "rls-coverage", "extensions", "webhooks"]);
|
|
707
|
-
var SERVER_WIDE = [
|
|
708
|
-
/^\s*(?:CREATE|ALTER|DROP)\s+(?:ROLE|USER|GROUP|DATABASE|TABLESPACE)\b/i,
|
|
709
|
-
/^\s*ALTER\s+SYSTEM\b/i,
|
|
710
|
-
// Role membership: a GRANT or REVOKE with no ON names roles, not objects.
|
|
711
|
-
/^\s*(?:GRANT|REVOKE)\b(?![\s\S]*\bON\b)/i
|
|
712
|
-
];
|
|
713
|
-
function proofScope(statements) {
|
|
714
|
-
const replay = [];
|
|
715
|
-
const unproved = [];
|
|
716
|
-
for (const stmt of statements) {
|
|
717
|
-
const serverWide = splitSqlStatements(stmt.sql).filter((s) => !isCommentOnly(s)).some((s) => SERVER_WIDE.some((re) => re.test(sqlSkeleton(s))));
|
|
718
|
-
if (PROVED_CHECKS.has(stmt.check) && !serverWide) replay.push(stmt);
|
|
719
|
-
else unproved.push(stmt);
|
|
720
|
-
}
|
|
721
|
-
return { replay, unproved };
|
|
722
|
-
}
|
|
723
|
-
async function absentRoles(dbUrl, sql) {
|
|
724
|
-
const named = [...new Set(splitSqlStatements(sql).flatMap((s) => rolesNamedBy(s)))];
|
|
725
|
-
if (named.length === 0) return [];
|
|
726
|
-
const rows = await pgQuery(dbUrl, "SELECT rolname FROM pg_roles WHERE rolname = ANY($1::text[])", [named]);
|
|
727
|
-
const present = new Set(rows.map((r) => r.rolname));
|
|
728
|
-
return named.filter((r) => !present.has(r));
|
|
729
|
-
}
|
|
730
|
-
function withinScope(residual, baseline, checks, cloneName) {
|
|
731
|
-
if (!baseline || !checks) return { converged: residual.length === 0, residual, cloneName };
|
|
732
|
-
const had = new Set(baseline);
|
|
733
|
-
const outOfScope = residual.filter((l) => had.has(l) && outsideTheRun(l, checks));
|
|
734
|
-
const remaining = residual.filter((l) => !outOfScope.includes(l));
|
|
735
|
-
return { converged: remaining.length === 0, residual: remaining, outOfScope, cloneName };
|
|
736
|
-
}
|
|
737
|
-
var GOVERNED = {
|
|
738
|
-
"rls": /^policy on |: RLS (?:enabled|forced) /,
|
|
739
|
-
"rls-coverage": /: RLS enabled /,
|
|
740
|
-
"extensions": /^extension /,
|
|
741
|
-
"webhooks": /^trigger on /
|
|
742
|
-
};
|
|
743
|
-
function outsideTheRun(line, checks) {
|
|
744
|
-
if (checks.includes("schema")) return false;
|
|
745
|
-
return !checks.some((c) => GOVERNED[c]?.test(line));
|
|
746
|
-
}
|
|
747
|
-
|
|
748
|
-
export {
|
|
749
|
-
withDatabase,
|
|
750
|
-
fingerprint,
|
|
751
|
-
comparedSchemas,
|
|
752
|
-
proveConvergence,
|
|
753
|
-
copyStructure,
|
|
754
|
-
dropDatabase,
|
|
755
|
-
psqlBeside,
|
|
756
|
-
dropUnsupportedSetStatements,
|
|
757
|
-
knownParameters,
|
|
758
|
-
residualHeldBack,
|
|
759
|
-
proofScope
|
|
760
|
-
};
|
|
761
|
-
//# sourceMappingURL=chunk-GGZ7YWBZ.js.map
|