@akal/supaforge 0.0.0-stage → 0.0.32
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 +350 -2
- package/bin/dev.js +10 -0
- package/bin/run.js +18 -0
- package/dist/base-command.d.ts +135 -0
- package/dist/base-command.js +9 -0
- package/dist/base-command.js.map +1 -0
- package/dist/branch-C4ndfoj5.d.ts +58 -0
- package/dist/chunk-2SELREHW.js +156 -0
- package/dist/chunk-2SELREHW.js.map +1 -0
- package/dist/chunk-3HGAV5CC.js +2073 -0
- package/dist/chunk-3HGAV5CC.js.map +1 -0
- package/dist/chunk-4IVN7QVY.js +632 -0
- package/dist/chunk-4IVN7QVY.js.map +1 -0
- package/dist/chunk-6LJERPUN.js +499 -0
- package/dist/chunk-6LJERPUN.js.map +1 -0
- package/dist/chunk-6Q7MHFBM.js +13 -0
- package/dist/chunk-6Q7MHFBM.js.map +1 -0
- package/dist/chunk-6WAMNZLO.js +336 -0
- package/dist/chunk-6WAMNZLO.js.map +1 -0
- package/dist/chunk-7NAZGZPV.js +868 -0
- package/dist/chunk-7NAZGZPV.js.map +1 -0
- package/dist/chunk-BLKJWDTL.js +153 -0
- package/dist/chunk-BLKJWDTL.js.map +1 -0
- package/dist/chunk-BUOWHE36.js +1311 -0
- package/dist/chunk-BUOWHE36.js.map +1 -0
- package/dist/chunk-DMIWAJRB.js +602 -0
- package/dist/chunk-DMIWAJRB.js.map +1 -0
- package/dist/chunk-DQQ5E563.js +64 -0
- package/dist/chunk-DQQ5E563.js.map +1 -0
- package/dist/chunk-G2DIPIYU.js +94 -0
- package/dist/chunk-G2DIPIYU.js.map +1 -0
- package/dist/chunk-GEHPTPNZ.js +240 -0
- package/dist/chunk-GEHPTPNZ.js.map +1 -0
- package/dist/chunk-GZREXCQZ.js +207 -0
- package/dist/chunk-GZREXCQZ.js.map +1 -0
- package/dist/chunk-MIRLB5JM.js +1292 -0
- package/dist/chunk-MIRLB5JM.js.map +1 -0
- package/dist/chunk-NTUASFQ3.js +248 -0
- package/dist/chunk-NTUASFQ3.js.map +1 -0
- package/dist/chunk-ORQJVE57.js +642 -0
- package/dist/chunk-ORQJVE57.js.map +1 -0
- package/dist/chunk-SC2XHGIS.js +122 -0
- package/dist/chunk-SC2XHGIS.js.map +1 -0
- package/dist/chunk-SQPCWGQO.js +657 -0
- package/dist/chunk-SQPCWGQO.js.map +1 -0
- package/dist/chunk-UWAVXC57.js +916 -0
- package/dist/chunk-UWAVXC57.js.map +1 -0
- package/dist/commands/clone.d.ts +66 -0
- package/dist/commands/clone.js +416 -0
- package/dist/commands/clone.js.map +1 -0
- package/dist/commands/diff.d.ts +81 -0
- package/dist/commands/diff.js +23 -0
- package/dist/commands/diff.js.map +1 -0
- package/dist/commands/help.d.ts +32 -0
- package/dist/commands/help.js +36 -0
- package/dist/commands/help.js.map +1 -0
- package/dist/commands/hukam.d.ts +13 -0
- package/dist/commands/hukam.js +28 -0
- package/dist/commands/hukam.js.map +1 -0
- package/dist/commands/init.d.ts +47 -0
- package/dist/commands/init.js +388 -0
- package/dist/commands/init.js.map +1 -0
- package/dist/commands/mcp.d.ts +13 -0
- package/dist/commands/mcp.js +43 -0
- package/dist/commands/mcp.js.map +1 -0
- package/dist/commands/migrate/baseline.d.ts +24 -0
- package/dist/commands/migrate/baseline.js +69 -0
- package/dist/commands/migrate/baseline.js.map +1 -0
- package/dist/commands/migrate/create.d.ts +36 -0
- package/dist/commands/migrate/create.js +127 -0
- package/dist/commands/migrate/create.js.map +1 -0
- package/dist/commands/migrate/list.d.ts +23 -0
- package/dist/commands/migrate/list.js +110 -0
- package/dist/commands/migrate/list.js.map +1 -0
- package/dist/commands/migrate/run.d.ts +61 -0
- package/dist/commands/migrate/run.js +18 -0
- package/dist/commands/migrate/run.js.map +1 -0
- package/dist/commands/report.d.ts +27 -0
- package/dist/commands/report.js +210 -0
- package/dist/commands/report.js.map +1 -0
- package/dist/commands/restore.d.ts +26 -0
- package/dist/commands/restore.js +266 -0
- package/dist/commands/restore.js.map +1 -0
- package/dist/commands/snapshot.d.ts +33 -0
- package/dist/commands/snapshot.js +249 -0
- package/dist/commands/snapshot.js.map +1 -0
- package/dist/commands/sync.d.ts +16 -0
- package/dist/commands/sync.js +38 -0
- package/dist/commands/sync.js.map +1 -0
- package/dist/config-CTbeRlJk.d.ts +134 -0
- package/dist/help.d.ts +28 -0
- package/dist/help.js +64 -0
- package/dist/help.js.map +1 -0
- package/dist/index.d.ts +498 -0
- package/dist/index.js +147 -0
- package/dist/index.js.map +1 -0
- package/package.json +74 -4
|
@@ -0,0 +1,1311 @@
|
|
|
1
|
+
import {
|
|
2
|
+
splitSqlStatements
|
|
3
|
+
} from "./chunk-G2DIPIYU.js";
|
|
4
|
+
import {
|
|
5
|
+
escapeRegex
|
|
6
|
+
} from "./chunk-DQQ5E563.js";
|
|
7
|
+
import {
|
|
8
|
+
DiagnosticError,
|
|
9
|
+
errMsg,
|
|
10
|
+
friendlyDbError
|
|
11
|
+
} from "./chunk-SQPCWGQO.js";
|
|
12
|
+
import {
|
|
13
|
+
DBDIFF_EXEC_TIMEOUT_MS,
|
|
14
|
+
DBDIFF_MAX_BUFFER,
|
|
15
|
+
schemaDiffIgnores
|
|
16
|
+
} from "./chunk-6WAMNZLO.js";
|
|
17
|
+
|
|
18
|
+
// src/dbdiff.ts
|
|
19
|
+
import { execFile } from "child_process";
|
|
20
|
+
import { createRequire } from "module";
|
|
21
|
+
import { readFile, unlink, access } from "fs/promises";
|
|
22
|
+
import { tmpdir } from "os";
|
|
23
|
+
import { join } from "path";
|
|
24
|
+
import { promisify } from "util";
|
|
25
|
+
|
|
26
|
+
// src/sql-ast.ts
|
|
27
|
+
import { loadModule, parseSync } from "libpg-query";
|
|
28
|
+
await loadModule();
|
|
29
|
+
function parseStatements(sql) {
|
|
30
|
+
try {
|
|
31
|
+
const tree = parseSync(sql);
|
|
32
|
+
return (tree.stmts ?? []).map(({ stmt }) => {
|
|
33
|
+
const kind = Object.keys(stmt)[0];
|
|
34
|
+
return { kind, node: stmt[kind] };
|
|
35
|
+
});
|
|
36
|
+
} catch {
|
|
37
|
+
return void 0;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
function names(list) {
|
|
41
|
+
return (list ?? []).map((item) => item.String?.sval ?? "").filter(Boolean);
|
|
42
|
+
}
|
|
43
|
+
function relationName(rangeVar) {
|
|
44
|
+
return rangeVar?.relname ?? "";
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
// src/sql-deps.ts
|
|
48
|
+
var PHASE = {
|
|
49
|
+
/** Triggers, policies, views, indexes — dropped before what they depend on. */
|
|
50
|
+
DROP_DEPENDANT: 10,
|
|
51
|
+
/** A schema, before anything is made in it. */
|
|
52
|
+
CREATE_SCHEMA: 15,
|
|
53
|
+
/**
|
|
54
|
+
* An extension, before the types and tables that may use it — an exclusion
|
|
55
|
+
* constraint's btree_gist operator class. Read as OTHER it came after the
|
|
56
|
+
* table, which failed (`no default operator class for access method gist`).
|
|
57
|
+
*/
|
|
58
|
+
CREATE_EXTENSION: 20,
|
|
59
|
+
/** Types, domains, sequences: no dependencies of their own. */
|
|
60
|
+
CREATE_BASE: 30,
|
|
61
|
+
CREATE_TABLE: 40,
|
|
62
|
+
/** Columns and constraints, needing every table to exist first. */
|
|
63
|
+
ALTER_TABLE: 50,
|
|
64
|
+
/** Before the triggers that execute them and the views that call them. */
|
|
65
|
+
CREATE_ROUTINE: 60,
|
|
66
|
+
CREATE_INDEX: 70,
|
|
67
|
+
CREATE_VIEW: 80,
|
|
68
|
+
/** Anything unrecognised — grants, comments, ownership. */
|
|
69
|
+
OTHER: 85,
|
|
70
|
+
/** Triggers and policies: the last things to be created. */
|
|
71
|
+
CREATE_DEPENDANT: 90,
|
|
72
|
+
/**
|
|
73
|
+
* Comments, once what they name exists: a policy or trigger is created at
|
|
74
|
+
* CREATE_DEPENDANT, and a COMMENT ON it read as OTHER ran before it.
|
|
75
|
+
*/
|
|
76
|
+
COMMENT: 95,
|
|
77
|
+
/** Row changes, once the structure holding them is in place. */
|
|
78
|
+
DATA: 100,
|
|
79
|
+
DROP_TABLE: 110,
|
|
80
|
+
/**
|
|
81
|
+
* Routines, dropped once nothing calls them: the triggers, views and
|
|
82
|
+
* policies come off first, and so do the column defaults, CHECK constraints,
|
|
83
|
+
* expression indexes and tables — all of which can call one, and were still
|
|
84
|
+
* in place when routines were dropped at the start (`cannot drop function
|
|
85
|
+
* ... because other objects depend on it`). Before the types a routine's
|
|
86
|
+
* signature can use.
|
|
87
|
+
*/
|
|
88
|
+
DROP_ROUTINE: 115,
|
|
89
|
+
DROP_BASE: 120,
|
|
90
|
+
/** Once nothing that used it is left. */
|
|
91
|
+
DROP_EXTENSION: 125
|
|
92
|
+
};
|
|
93
|
+
var DROP_PHASES = /* @__PURE__ */ new Set([
|
|
94
|
+
PHASE.DROP_DEPENDANT,
|
|
95
|
+
PHASE.DROP_TABLE,
|
|
96
|
+
PHASE.DROP_ROUTINE,
|
|
97
|
+
PHASE.DROP_BASE,
|
|
98
|
+
PHASE.DROP_EXTENSION
|
|
99
|
+
]);
|
|
100
|
+
var PHASE_RULES = [
|
|
101
|
+
// A column type change grouped with the dependants dbdiff drops and
|
|
102
|
+
// recreates around it (see groupColumnTypeChanges) runs as the column change
|
|
103
|
+
// it is — before a foreign key that needs the new type, for one — not as the
|
|
104
|
+
// view or policy it happens to recreate.
|
|
105
|
+
[/^\s*DROP\s+(?:POLICY|TRIGGER|(?:MATERIALIZED\s+)?VIEW)\b[\s\S]*\bALTER\s+TABLE\s+\S+\s+ALTER\s+COLUMN\s+\S+\s+(?:SET\s+DATA\s+)?TYPE\b/i, PHASE.ALTER_TABLE],
|
|
106
|
+
[/\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\b/i, PHASE.CREATE_DEPENDANT],
|
|
107
|
+
[/\bCREATE\s+POLICY\b/i, PHASE.CREATE_DEPENDANT],
|
|
108
|
+
[/\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\b/i, PHASE.CREATE_VIEW],
|
|
109
|
+
[/\bCREATE\s+(?:UNIQUE\s+)?INDEX\b/i, PHASE.CREATE_INDEX],
|
|
110
|
+
[/\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:FUNCTION|PROCEDURE)\b/i, PHASE.CREATE_ROUTINE],
|
|
111
|
+
[/^\s*COMMENT\s+ON\b/i, PHASE.COMMENT],
|
|
112
|
+
[/^\s*CREATE\s+SCHEMA\b/i, PHASE.CREATE_SCHEMA],
|
|
113
|
+
[/^\s*CREATE\s+EXTENSION\b/i, PHASE.CREATE_EXTENSION],
|
|
114
|
+
[/^\s*DROP\s+EXTENSION\b/i, PHASE.DROP_EXTENSION],
|
|
115
|
+
[/\bCREATE\s+(?:TYPE|DOMAIN|SEQUENCE)\b/i, PHASE.CREATE_BASE],
|
|
116
|
+
[/\bCREATE\s+TABLE\b/i, PHASE.CREATE_TABLE],
|
|
117
|
+
[/^\s*ALTER\s+TABLE\b/i, PHASE.ALTER_TABLE],
|
|
118
|
+
[/^\s*DROP\s+(?:TRIGGER|POLICY|INDEX)\b/i, PHASE.DROP_DEPENDANT],
|
|
119
|
+
[/^\s*DROP\s+(?:MATERIALIZED\s+)?VIEW\b/i, PHASE.DROP_DEPENDANT],
|
|
120
|
+
[/^\s*DROP\s+(?:FUNCTION|PROCEDURE)\b/i, PHASE.DROP_ROUTINE],
|
|
121
|
+
[/^\s*DROP\s+TABLE\b/i, PHASE.DROP_TABLE],
|
|
122
|
+
[/^\s*DROP\s+(?:TYPE|DOMAIN|SEQUENCE)\b/i, PHASE.DROP_BASE],
|
|
123
|
+
[/^\s*(?:INSERT|UPDATE|DELETE)\b/i, PHASE.DATA]
|
|
124
|
+
];
|
|
125
|
+
function statementPhase(sql) {
|
|
126
|
+
const skeleton = sqlSkeleton(sql);
|
|
127
|
+
for (const [pattern, phase] of PHASE_RULES) {
|
|
128
|
+
if (pattern.test(skeleton)) return phase;
|
|
129
|
+
}
|
|
130
|
+
return PHASE.OTHER;
|
|
131
|
+
}
|
|
132
|
+
var DOLLAR_BODY = /\$([A-Za-z0-9_]*)\$[\s\S]*?\$\1\$/g;
|
|
133
|
+
var STRING_LITERAL = /'[^']*(?:''[^']*)*'/g;
|
|
134
|
+
var LINE_COMMENT = /--[^\n]*/g;
|
|
135
|
+
var BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
|
|
136
|
+
function sqlSkeleton(sql) {
|
|
137
|
+
return sql.replace(DOLLAR_BODY, " ").replace(STRING_LITERAL, " '' ").replace(LINE_COMMENT, " ").replace(BLOCK_COMMENT, " ");
|
|
138
|
+
}
|
|
139
|
+
var NAME_PART = String.raw`"(?:[^"]|"")+"|[\w$]+`;
|
|
140
|
+
var IDENT = String.raw`(?:${NAME_PART})(?:\s*\.\s*(?:${NAME_PART}))?`;
|
|
141
|
+
function bareName(identifier) {
|
|
142
|
+
const parts = identifier.match(new RegExp(NAME_PART, "g")) ?? [identifier];
|
|
143
|
+
return unquote(parts[parts.length - 1]).toLowerCase();
|
|
144
|
+
}
|
|
145
|
+
var unquote = (part) => {
|
|
146
|
+
const p = part.trim();
|
|
147
|
+
return p.startsWith('"') ? p.slice(1, -1).replace(/""/g, '"') : p;
|
|
148
|
+
};
|
|
149
|
+
var objectKey = (schema, table, name) => `${(schema || "public").toLowerCase()}.${(table ?? "").toLowerCase()}.${(name ?? "").toLowerCase()}`;
|
|
150
|
+
function schemaQualified(identifier) {
|
|
151
|
+
const parts = identifier.match(new RegExp(NAME_PART, "g")) ?? [identifier];
|
|
152
|
+
const fold = (part) => unquote(part).toLowerCase();
|
|
153
|
+
return `${parts.length > 1 ? fold(parts[0]) : "public"}.${fold(parts[parts.length - 1])}`;
|
|
154
|
+
}
|
|
155
|
+
var CREATES = new RegExp(
|
|
156
|
+
String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:UNIQUE\s+|MATERIALIZED\s+|TEMP(?:ORARY)?\s+|CONSTRAINT\s+){0,2}` + String.raw`(?:TABLE|VIEW|FUNCTION|PROCEDURE|TYPE|DOMAIN|SEQUENCE|INDEX|TRIGGER|POLICY)\s+` + String.raw`(?:IF\s+NOT\s+EXISTS\s+)?(${IDENT})`,
|
|
157
|
+
"gi"
|
|
158
|
+
);
|
|
159
|
+
function providedNames(sql) {
|
|
160
|
+
const names2 = /* @__PURE__ */ new Set();
|
|
161
|
+
for (const match of sqlSkeleton(sql).matchAll(CREATES)) {
|
|
162
|
+
names2.add(bareName(match[1]));
|
|
163
|
+
}
|
|
164
|
+
return [...names2];
|
|
165
|
+
}
|
|
166
|
+
function isDropOnly(sql, provides) {
|
|
167
|
+
return provides.length === 0 && /^\s*DROP\b/i.test(sql);
|
|
168
|
+
}
|
|
169
|
+
var BODY_TABLE_REF = new RegExp(String.raw`\b(?:FROM|JOIN|INTO|UPDATE|REFERENCES)\s+(?:ONLY\s+)?(${IDENT})`, "gi");
|
|
170
|
+
var ON_TABLE_REF = new RegExp(String.raw`\bON\s+(?:ONLY\s+)?(${IDENT})\s*(?:USING\b|FOR\b|AS\b|TO\b|\(|;|$)`, "gi");
|
|
171
|
+
var TARGET_TABLE_REF = new RegExp(
|
|
172
|
+
String.raw`^\s*(?:ALTER|DROP)\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(${IDENT})`,
|
|
173
|
+
"gi"
|
|
174
|
+
);
|
|
175
|
+
var NOT_A_TABLE = /* @__PURE__ */ new Set([
|
|
176
|
+
"on",
|
|
177
|
+
"of",
|
|
178
|
+
"from",
|
|
179
|
+
"join",
|
|
180
|
+
"into",
|
|
181
|
+
"select",
|
|
182
|
+
"lateral",
|
|
183
|
+
"only",
|
|
184
|
+
"conflict",
|
|
185
|
+
"delete",
|
|
186
|
+
"update",
|
|
187
|
+
"insert",
|
|
188
|
+
"constraint",
|
|
189
|
+
"each",
|
|
190
|
+
"row",
|
|
191
|
+
"statement",
|
|
192
|
+
"values"
|
|
193
|
+
]);
|
|
194
|
+
function createdPolicies(sql) {
|
|
195
|
+
const tree = parseStatements(sql);
|
|
196
|
+
if (tree) {
|
|
197
|
+
return tree.filter((s) => s.kind === "CreatePolicyStmt").map(({ node }) => objectKey(node.table?.schemaname, node.table?.relname, node.policy_name));
|
|
198
|
+
}
|
|
199
|
+
const out = [];
|
|
200
|
+
const re = new RegExp(String.raw`CREATE\s+POLICY\s+(${NAME_PART})\s+ON\s+(${IDENT})`, "gi");
|
|
201
|
+
for (const m of sqlSkeleton(sql).matchAll(re)) {
|
|
202
|
+
out.push(`${schemaQualified(m[2])}.${bareName(m[1])}`);
|
|
203
|
+
}
|
|
204
|
+
return out;
|
|
205
|
+
}
|
|
206
|
+
function droppedPolicies(sql) {
|
|
207
|
+
const tree = parseStatements(sql);
|
|
208
|
+
if (tree) {
|
|
209
|
+
return tree.filter((s) => s.kind === "DropStmt" && s.node.removeType === "OBJECT_POLICY").flatMap(({ node }) => node.objects.map((o) => (o.List?.items ?? []).map((i) => i.String?.sval)).map((parts) => objectKey(parts.at(-3), parts.at(-2), parts.at(-1))));
|
|
210
|
+
}
|
|
211
|
+
const out = [];
|
|
212
|
+
const re = new RegExp(String.raw`DROP\s+POLICY\s+(?:IF\s+EXISTS\s+)?(${NAME_PART})\s+ON\s+(${IDENT})`, "gi");
|
|
213
|
+
for (const m of sqlSkeleton(sql).matchAll(re)) {
|
|
214
|
+
out.push(`${schemaQualified(m[2])}.${bareName(m[1])}`);
|
|
215
|
+
}
|
|
216
|
+
return out;
|
|
217
|
+
}
|
|
218
|
+
function policiesRemoved(sql) {
|
|
219
|
+
const recreated = new Set(createdPolicies(sql));
|
|
220
|
+
return droppedPolicies(sql).filter((key) => !recreated.has(key));
|
|
221
|
+
}
|
|
222
|
+
function createsOnlyPolicies(sql) {
|
|
223
|
+
if (createdPolicies(sql).length === 0) return false;
|
|
224
|
+
const withoutPolicies = sqlSkeleton(sql).replace(/CREATE\s+POLICY[\s\S]*?(?=;|$)/gi, "").replace(/DROP\s+POLICY[\s\S]*?(?=;|$)/gi, "");
|
|
225
|
+
return !/[A-Za-z]/.test(withoutPolicies);
|
|
226
|
+
}
|
|
227
|
+
function createdTriggers(sql) {
|
|
228
|
+
const tree = parseStatements(sql);
|
|
229
|
+
if (tree) {
|
|
230
|
+
return tree.filter((s) => s.kind === "CreateTrigStmt").map(({ node }) => `${(node.relation?.relname ?? "").toLowerCase()}.${String(node.trigname).toLowerCase()}`);
|
|
231
|
+
}
|
|
232
|
+
const out = [];
|
|
233
|
+
const re = new RegExp(String.raw`CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+(${NAME_PART})[\s\S]*?\sON\s+(${IDENT})`, "gi");
|
|
234
|
+
for (const m of sqlSkeleton(sql).matchAll(re)) {
|
|
235
|
+
out.push(`${bareName(m[2])}.${bareName(m[1])}`);
|
|
236
|
+
}
|
|
237
|
+
return out;
|
|
238
|
+
}
|
|
239
|
+
function createsOnlyTriggers(sql) {
|
|
240
|
+
if (createdTriggers(sql).length === 0) return false;
|
|
241
|
+
const withoutTriggers = sqlSkeleton(sql).replace(/CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER[\s\S]*?(?=;|$)/gi, "").replace(/DROP\s+TRIGGER[\s\S]*?(?=;|$)/gi, "");
|
|
242
|
+
return !/[A-Za-z]/.test(withoutTriggers);
|
|
243
|
+
}
|
|
244
|
+
function referencedTables(sql) {
|
|
245
|
+
const names2 = /* @__PURE__ */ new Set();
|
|
246
|
+
for (const pattern of [BODY_TABLE_REF, ON_TABLE_REF, TARGET_TABLE_REF]) {
|
|
247
|
+
for (const match of sql.matchAll(pattern)) {
|
|
248
|
+
const name = bareName(match[1]);
|
|
249
|
+
if (!NOT_A_TABLE.has(name)) names2.add(name);
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
return [...names2];
|
|
253
|
+
}
|
|
254
|
+
function identifierMatcher(name) {
|
|
255
|
+
return new RegExp(String.raw`(?<![\w$])"?${escapeRegex(name)}"?(?![\w$])`, "i");
|
|
256
|
+
}
|
|
257
|
+
function linkDependencies(nodes, texts, provides) {
|
|
258
|
+
const droppers = texts.map((sql, i) => isDropOnly(sql, provides[i]));
|
|
259
|
+
const uses = texts.map(withoutDropStatements);
|
|
260
|
+
for (let provider = 0; provider < nodes.length; provider++) {
|
|
261
|
+
for (const name of provides[provider]) {
|
|
262
|
+
const matcher = identifierMatcher(name);
|
|
263
|
+
for (let consumer = 0; consumer < nodes.length; consumer++) {
|
|
264
|
+
if (consumer === provider || droppers[consumer]) continue;
|
|
265
|
+
if (provides[consumer].includes(name)) continue;
|
|
266
|
+
if (matcher.test(uses[consumer])) nodes[consumer].after.add(provider);
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
function withoutDropStatements(sql) {
|
|
272
|
+
if (!/\bDROP\b/i.test(sql)) return sql;
|
|
273
|
+
return splitSqlStatements(sql).filter((s) => !/^\s*DROP\b/i.test(sqlSkeleton(s))).join("\n");
|
|
274
|
+
}
|
|
275
|
+
function nextReady(remaining, nodes, done) {
|
|
276
|
+
const ready = remaining.filter((i) => isSatisfied(nodes[i].after, done));
|
|
277
|
+
const first = (from, key) => from.reduce((best, i) => best === void 0 || key(nodes[i]) < key(nodes[best]) ? i : best, void 0);
|
|
278
|
+
const head = first(ready.filter((i) => nodes[i].rank !== void 0), (n) => n.rank);
|
|
279
|
+
const free = first(ready.filter((i) => nodes[i].rank === void 0), (n) => n.phase);
|
|
280
|
+
if (head === void 0 || free === void 0) return head ?? free ?? remaining[0];
|
|
281
|
+
const sequence = Math.min(...remaining.filter((i) => nodes[i].rank !== void 0 && !DROP_PHASES.has(nodes[i].phase)).map((i) => nodes[i].phase));
|
|
282
|
+
return nodes[free].phase < sequence ? free : head;
|
|
283
|
+
}
|
|
284
|
+
function isSatisfied(after, done) {
|
|
285
|
+
for (const dep of after) {
|
|
286
|
+
if (!done.has(dep)) return false;
|
|
287
|
+
}
|
|
288
|
+
return true;
|
|
289
|
+
}
|
|
290
|
+
function orderStatements(items, sqlOf, rankOf = () => void 0) {
|
|
291
|
+
if (items.length < 2) return [...items];
|
|
292
|
+
const texts = items.map(sqlOf);
|
|
293
|
+
const provides = texts.map(providedNames);
|
|
294
|
+
const nodes = texts.map((sql, i) => ({ phase: statementPhase(sql), rank: rankOf(items[i]), after: /* @__PURE__ */ new Set() }));
|
|
295
|
+
linkDependencies(nodes, texts, provides);
|
|
296
|
+
const done = /* @__PURE__ */ new Set();
|
|
297
|
+
let remaining = texts.map((_, i) => i);
|
|
298
|
+
const ordered = [];
|
|
299
|
+
while (remaining.length > 0) {
|
|
300
|
+
const next = nextReady(remaining, nodes, done);
|
|
301
|
+
ordered.push(items[next]);
|
|
302
|
+
done.add(next);
|
|
303
|
+
remaining = remaining.filter((i) => i !== next);
|
|
304
|
+
}
|
|
305
|
+
return ordered;
|
|
306
|
+
}
|
|
307
|
+
function splitQualified(identifier) {
|
|
308
|
+
const parts = identifier.match(/"[^"]+"|[\w$]+/g) ?? [];
|
|
309
|
+
const clean = parts.map((p) => p.replace(/^"|"$/g, ""));
|
|
310
|
+
if (clean.length >= 2) return { schema: clean[clean.length - 2], name: clean[clean.length - 1] };
|
|
311
|
+
return { schema: null, name: clean[0] ?? "" };
|
|
312
|
+
}
|
|
313
|
+
var IDENT3 = String.raw`(?:"[^"]+"|[\w$]+)(?:\s*\.\s*(?:"[^"]+"|[\w$]+)){0,2}`;
|
|
314
|
+
var OBJECT_KIND = String.raw`(?:TABLE|VIEW|MATERIALIZED\s+VIEW|FOREIGN\s+TABLE|FUNCTION|PROCEDURE|ROUTINE|AGGREGATE|SEQUENCE|TYPE|DOMAIN|INDEX|SCHEMA)`;
|
|
315
|
+
var SUBJECT_RULES = [
|
|
316
|
+
// CREATE/DROP/ALTER TRIGGER|POLICY name ... ON <table>
|
|
317
|
+
[new RegExp(String.raw`^\s*(?:CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?|DROP\s+|ALTER\s+)(?:TRIGGER|POLICY)\s+(?:IF\s+EXISTS\s+)?(?:"[^"]+"|[\w$]+)[\s\S]*?\bON\s+(?:ONLY\s+)?(${IDENT})`, "i"), "object"],
|
|
318
|
+
// CREATE RULE name AS ON <event> TO <table>
|
|
319
|
+
[new RegExp(String.raw`^\s*CREATE\s+(?:OR\s+REPLACE\s+)?RULE\s+(?:"[^"]+"|[\w$]+)\s+AS\s+ON\s+\w+\s+TO\s+(${IDENT})`, "i"), "object"],
|
|
320
|
+
// CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] [name] ON [ONLY] <table>
|
|
321
|
+
[new RegExp(String.raw`^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\b[\s\S]*?\bON\s+(?:ONLY\s+)?(${IDENT})`, "i"), "object"],
|
|
322
|
+
// COMMENT ON TRIGGER|POLICY|RULE|CONSTRAINT name ON <table>
|
|
323
|
+
[new RegExp(String.raw`^\s*COMMENT\s+ON\s+(?:TRIGGER|POLICY|RULE|CONSTRAINT)\s+(?:"[^"]+"|[\w$]+)\s+ON\s+(?:DOMAIN\s+)?(${IDENT})`, "i"), "object"],
|
|
324
|
+
[new RegExp(String.raw`^\s*COMMENT\s+ON\s+COLUMN\s+(${IDENT3})`, "i"), "column"],
|
|
325
|
+
[new RegExp(String.raw`^\s*COMMENT\s+ON\s+SCHEMA\s+((?:"[^"]+"|[\w$]+))`, "i"), "schema"],
|
|
326
|
+
[new RegExp(String.raw`^\s*COMMENT\s+ON\s+${OBJECT_KIND}\s+(${IDENT})`, "i"), "object"],
|
|
327
|
+
// GRANT/REVOKE ... ON SCHEMA <schema> | ON ALL <kind> IN SCHEMA <schema> | ON [kind] <name>
|
|
328
|
+
[new RegExp(String.raw`^\s*(?:GRANT|REVOKE)\b[\s\S]*?\bON\s+SCHEMA\s+((?:"[^"]+"|[\w$]+))`, "i"), "schema"],
|
|
329
|
+
[new RegExp(String.raw`^\s*(?:GRANT|REVOKE)\b[\s\S]*?\bON\s+ALL\s+\w+\s+IN\s+SCHEMA\s+((?:"[^"]+"|[\w$]+))`, "i"), "schema"],
|
|
330
|
+
[new RegExp(String.raw`^\s*(?:GRANT|REVOKE)\b[\s\S]*?\bON\s+(?:${OBJECT_KIND}\s+)?(${IDENT})`, "i"), "object"],
|
|
331
|
+
// ALTER DEFAULT PRIVILEGES ... IN SCHEMA <schema>
|
|
332
|
+
[new RegExp(String.raw`^\s*ALTER\s+DEFAULT\s+PRIVILEGES\b[\s\S]*?\bIN\s+SCHEMA\s+((?:"[^"]+"|[\w$]+))`, "i"), "schema"],
|
|
333
|
+
// CREATE|ALTER|DROP SCHEMA <schema>
|
|
334
|
+
[new RegExp(String.raw`^\s*(?:CREATE|ALTER|DROP)\s+SCHEMA\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?((?:"[^"]+"|[\w$]+))`, "i"), "schema"],
|
|
335
|
+
// CREATE [OR REPLACE] [modifiers] <kind> [IF NOT EXISTS] <name>
|
|
336
|
+
[new RegExp(String.raw`^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY|UNLOGGED|RECURSIVE)\s+)*${OBJECT_KIND}\s+(?:IF\s+NOT\s+EXISTS\s+)?(${IDENT})`, "i"), "object"],
|
|
337
|
+
// ALTER|DROP <kind> [IF EXISTS] [ONLY] <name>
|
|
338
|
+
[new RegExp(String.raw`^\s*(?:ALTER|DROP)\s+${OBJECT_KIND}\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(${IDENT})`, "i"), "object"]
|
|
339
|
+
];
|
|
340
|
+
function statementSubject(sql) {
|
|
341
|
+
const skeleton = sqlSkeleton(sql);
|
|
342
|
+
for (const [rule, captures] of SUBJECT_RULES) {
|
|
343
|
+
const match = rule.exec(skeleton);
|
|
344
|
+
if (!match) continue;
|
|
345
|
+
const parts = (match[1].match(/"[^"]+"|[\w$]+/g) ?? []).map((p) => p.replace(/^"|"$/g, ""));
|
|
346
|
+
if (captures === "schema") return { schema: parts[0], name: parts[0] };
|
|
347
|
+
if (captures === "column") {
|
|
348
|
+
return parts.length >= 3 ? { schema: parts[parts.length - 3], name: parts[parts.length - 2] } : { schema: null, name: parts[0] ?? "" };
|
|
349
|
+
}
|
|
350
|
+
return splitQualified(match[1]);
|
|
351
|
+
}
|
|
352
|
+
return void 0;
|
|
353
|
+
}
|
|
354
|
+
function policyOnlyKeys(sql) {
|
|
355
|
+
if (!sql) return null;
|
|
356
|
+
const statements = splitSqlStatements(sql).filter((s) => sqlSkeleton(s).trim() !== "");
|
|
357
|
+
if (statements.length === 0) return null;
|
|
358
|
+
if (!statements.every((s) => /^\s*(?:CREATE|DROP)\s+POLICY\b/i.test(sqlSkeleton(s)))) return null;
|
|
359
|
+
return [.../* @__PURE__ */ new Set([...createdPolicies(sql), ...droppedPolicies(sql)])];
|
|
360
|
+
}
|
|
361
|
+
function rolesOf({ kind, node }) {
|
|
362
|
+
const specs = kind === "GrantStmt" && node.is_grant ? node.grantees ?? [] : kind === "GrantRoleStmt" && node.is_grant ? node.grantee_roles ?? [] : kind === "CreatePolicyStmt" || kind === "AlterPolicyStmt" ? node.roles ?? [] : [];
|
|
363
|
+
return specs.map((spec) => spec.RoleSpec).filter((role) => role?.roletype === "ROLESPEC_CSTRING" && typeof role.rolename === "string").map((role) => role.rolename).filter((name) => !name.startsWith("pg_"));
|
|
364
|
+
}
|
|
365
|
+
var ROLE_KEYWORDS = /* @__PURE__ */ new Set(["public", "current_user", "current_role", "session_user"]);
|
|
366
|
+
function rolesNamedBy(sql) {
|
|
367
|
+
const statements = parseStatements(sql);
|
|
368
|
+
if (statements) return [...new Set(statements.flatMap(rolesOf))];
|
|
369
|
+
const skeleton = sqlSkeleton(sql);
|
|
370
|
+
const list = /^\s*GRANT\b[\s\S]*?\bTO\s+([\s\S]*?)(?=\s+WITH\b|\s+GRANTED\s+BY\b|\s*;|\s*$)/i.exec(skeleton) ?? /^\s*(?:CREATE|ALTER)\s+POLICY\b(?![\s\S]*\bRENAME\s+TO\b)[\s\S]*?\bTO\s+([\s\S]*?)(?=\s+USING\b|\s+WITH\s+CHECK\b|\s*;|\s*$)/i.exec(skeleton);
|
|
371
|
+
if (!list) return [];
|
|
372
|
+
const roles = (list[1].match(/"(?:[^"]|"")+"|[\w$]+/g) ?? []).map((r) => r.startsWith('"') ? r.slice(1, -1).replace(/""/g, '"') : r.toLowerCase()).filter((r) => !ROLE_KEYWORDS.has(r.toLowerCase()) && !r.startsWith("pg_"));
|
|
373
|
+
return [...new Set(roles)];
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
// src/dbdiff-units.ts
|
|
377
|
+
var BEGIN = /^-- dbdiff:unit (\S+)(?: (.*))?$/;
|
|
378
|
+
var END = "-- dbdiff:end";
|
|
379
|
+
function parseUnits(section) {
|
|
380
|
+
if (!section.includes("-- dbdiff:unit ")) return void 0;
|
|
381
|
+
const units = [];
|
|
382
|
+
let open;
|
|
383
|
+
for (const line of section.split("\n")) {
|
|
384
|
+
const begin = BEGIN.exec(line.trimEnd());
|
|
385
|
+
if (begin) {
|
|
386
|
+
open = { kind: begin[1], object: (begin[2] ?? "").trim(), lines: [] };
|
|
387
|
+
} else if (line.trimEnd() === END && open) {
|
|
388
|
+
units.push({ kind: open.kind, object: open.object, sql: open.lines.join("\n").trim() });
|
|
389
|
+
open = void 0;
|
|
390
|
+
} else if (open) {
|
|
391
|
+
open.lines.push(line);
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
return units.filter((u) => u.sql !== "");
|
|
395
|
+
}
|
|
396
|
+
function unitKey(unit) {
|
|
397
|
+
return `${unit.kind} ${unit.object}`;
|
|
398
|
+
}
|
|
399
|
+
function pairUnits(up, down) {
|
|
400
|
+
const unclaimed = /* @__PURE__ */ new Map();
|
|
401
|
+
for (const unit of down) {
|
|
402
|
+
const key = unitKey(unit);
|
|
403
|
+
unclaimed.set(key, [...unclaimed.get(key) ?? [], unit]);
|
|
404
|
+
}
|
|
405
|
+
return up.map((unit) => ({ up: unit, down: unclaimed.get(unitKey(unit))?.shift() }));
|
|
406
|
+
}
|
|
407
|
+
var REPLACING_KINDS = {
|
|
408
|
+
AlterRoutine: "routine",
|
|
409
|
+
AlterEnum: "type",
|
|
410
|
+
AlterCompositeType: "type",
|
|
411
|
+
AlterDomain: "type",
|
|
412
|
+
AlterPolicy: "policy",
|
|
413
|
+
AlterTrigger: "trigger",
|
|
414
|
+
AlterView: "view",
|
|
415
|
+
AlterMatView: "view"
|
|
416
|
+
};
|
|
417
|
+
|
|
418
|
+
// src/dbdiff.ts
|
|
419
|
+
var execFileAsync = promisify(execFile);
|
|
420
|
+
function dbdiffNotInstalled(code, stderr) {
|
|
421
|
+
if (code === "ENOENT") return true;
|
|
422
|
+
return /ERR_MODULE_NOT_FOUND|could not determine executable|npm (?:ERR!|error) (?:code E404|404)|\bE404\b|command not found|: not found\s*$/m.test(stderr);
|
|
423
|
+
}
|
|
424
|
+
function resolveDbDiffBin() {
|
|
425
|
+
const override = process.env.SUPAFORGE_DBDIFF_BIN?.trim();
|
|
426
|
+
if (override) return { command: override, prefixArgs: [] };
|
|
427
|
+
try {
|
|
428
|
+
const require2 = createRequire(import.meta.url);
|
|
429
|
+
const binPath = require2.resolve("@dbdiff/cli/bin/dbdiff.js");
|
|
430
|
+
return { command: process.execPath, prefixArgs: [binPath] };
|
|
431
|
+
} catch {
|
|
432
|
+
return { command: "npx", prefixArgs: ["@dbdiff/cli"] };
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
function resolveDbDiffTimeoutMs(configuredSeconds) {
|
|
436
|
+
const raw = process.env.SUPAFORGE_DBDIFF_TIMEOUT;
|
|
437
|
+
if (raw) {
|
|
438
|
+
const secs = Number(raw);
|
|
439
|
+
if (Number.isFinite(secs) && secs > 0) return Math.round(secs * 1e3);
|
|
440
|
+
}
|
|
441
|
+
if (Number.isFinite(configuredSeconds) && configuredSeconds > 0) {
|
|
442
|
+
return Math.round(configuredSeconds * 1e3);
|
|
443
|
+
}
|
|
444
|
+
return DBDIFF_EXEC_TIMEOUT_MS;
|
|
445
|
+
}
|
|
446
|
+
var DBDIFF_TABLE_LINE = /calculating schema diff for table [`"']?([\w.$]+)/i;
|
|
447
|
+
function parseDbDiffProgress(line) {
|
|
448
|
+
return DBDIFF_TABLE_LINE.exec(line)?.[1] ?? null;
|
|
449
|
+
}
|
|
450
|
+
function resolveDbDiffMemoryLimit() {
|
|
451
|
+
const raw = process.env.SUPAFORGE_DBDIFF_MEMORY?.trim();
|
|
452
|
+
if (!raw) return void 0;
|
|
453
|
+
return /^-?\d+[KMG]?$/i.test(raw) ? raw : void 0;
|
|
454
|
+
}
|
|
455
|
+
var DBDIFF_NOISE_LINE = /^\s*[ℹ✔✓⚠⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/u;
|
|
456
|
+
function stripDbDiffNoise(text) {
|
|
457
|
+
return text.split("\n").filter((line) => line.trim() !== "" && !DBDIFF_NOISE_LINE.test(line)).join("\n").trim();
|
|
458
|
+
}
|
|
459
|
+
function buildDbDiffArgs(options, outputFile) {
|
|
460
|
+
const args = [
|
|
461
|
+
"diff",
|
|
462
|
+
`--server1-url=${options.sourceUrl}`,
|
|
463
|
+
`--server2-url=${options.targetUrl}`,
|
|
464
|
+
`--type=${options.type}`,
|
|
465
|
+
// Was hardcoded to 'both', silently ignoring options.include. Every caller
|
|
466
|
+
// passes 'both' (sqlToIssues pairs each UP statement with its DOWN
|
|
467
|
+
// counterpart, so it needs both directions), but the option was part of the
|
|
468
|
+
// public interface and did nothing.
|
|
469
|
+
`--include=${options.include}`,
|
|
470
|
+
"--nocomments",
|
|
471
|
+
// @dbdiff/cli >= 3.0.0-rc.3 refuses to emit a migration containing
|
|
472
|
+
// DROP TABLE or DROP COLUMN unless this is passed, exiting non-zero and
|
|
473
|
+
// writing no output file. SupaForge is a *detection* tool: an extra table
|
|
474
|
+
// or column on the target is the single most common form of drift, and it
|
|
475
|
+
// has to be reported rather than turned into a hard failure. The safety
|
|
476
|
+
// gate belongs at apply time instead — see isDestructiveSql()/promote(),
|
|
477
|
+
// which skip these statements unless the user opts in explicitly.
|
|
478
|
+
"--allow-destructive",
|
|
479
|
+
`--output=${outputFile}`
|
|
480
|
+
];
|
|
481
|
+
if (options.type === "schema" && options.units !== false) {
|
|
482
|
+
args.push("--units");
|
|
483
|
+
}
|
|
484
|
+
const memoryLimit = resolveDbDiffMemoryLimit();
|
|
485
|
+
if (memoryLimit) {
|
|
486
|
+
args.push(`--memory-limit=${memoryLimit}`);
|
|
487
|
+
}
|
|
488
|
+
if (options.type === "schema" && options.ignoreSchemas) {
|
|
489
|
+
args.push(`--ignore-schemas=${schemaDiffIgnores(options.ignoreSchemas).join(",")}`);
|
|
490
|
+
}
|
|
491
|
+
const ignore = options.ignoreTables ?? [];
|
|
492
|
+
if (options.tables?.length) {
|
|
493
|
+
args.push(`--tables=${options.tables.join(",")}`);
|
|
494
|
+
}
|
|
495
|
+
if (ignore.length) {
|
|
496
|
+
args.push(`--ignore-tables=${ignore.join(",")}`);
|
|
497
|
+
}
|
|
498
|
+
return args;
|
|
499
|
+
}
|
|
500
|
+
function attachProgress(running, onProgress) {
|
|
501
|
+
if (!onProgress) return;
|
|
502
|
+
try {
|
|
503
|
+
const stdout = running.child?.stdout;
|
|
504
|
+
if (!stdout) return;
|
|
505
|
+
let buffer = "";
|
|
506
|
+
let tablesSeen = 0;
|
|
507
|
+
stdout.on("data", (chunk) => {
|
|
508
|
+
try {
|
|
509
|
+
buffer += String(chunk);
|
|
510
|
+
const lines = buffer.split("\n");
|
|
511
|
+
buffer = lines.pop() ?? "";
|
|
512
|
+
for (const line of lines) {
|
|
513
|
+
const table = parseDbDiffProgress(line);
|
|
514
|
+
if (table) {
|
|
515
|
+
tablesSeen++;
|
|
516
|
+
onProgress({ table, tablesSeen });
|
|
517
|
+
}
|
|
518
|
+
}
|
|
519
|
+
} catch {
|
|
520
|
+
}
|
|
521
|
+
});
|
|
522
|
+
stdout.on("error", () => {
|
|
523
|
+
});
|
|
524
|
+
} catch {
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
async function runDbDiff(options) {
|
|
528
|
+
const { command, prefixArgs } = resolveDbDiffBin();
|
|
529
|
+
const outputFile = join(tmpdir(), `supaforge-dbdiff-${Date.now()}-${Math.random().toString(36).slice(2)}.sql`);
|
|
530
|
+
const args = [...prefixArgs, ...buildDbDiffArgs(options, outputFile)];
|
|
531
|
+
const timeoutMs = resolveDbDiffTimeoutMs(options.timeoutSeconds);
|
|
532
|
+
try {
|
|
533
|
+
const running = execFileAsync(command, args, {
|
|
534
|
+
timeout: timeoutMs,
|
|
535
|
+
maxBuffer: DBDIFF_MAX_BUFFER
|
|
536
|
+
});
|
|
537
|
+
attachProgress(running, options.onProgress);
|
|
538
|
+
await running;
|
|
539
|
+
const fileExists = await access(outputFile).then(() => true, () => false);
|
|
540
|
+
if (!fileExists) {
|
|
541
|
+
return { up: "", down: "" };
|
|
542
|
+
}
|
|
543
|
+
const output = await readFile(outputFile, "utf8");
|
|
544
|
+
return parseDbDiffOutput(output);
|
|
545
|
+
} catch (err) {
|
|
546
|
+
const errObj = err ?? {};
|
|
547
|
+
const message = errMsg(err);
|
|
548
|
+
const stderr = String(errObj.stderr ?? "").trim();
|
|
549
|
+
const stdout = String(errObj.stdout ?? "").trim();
|
|
550
|
+
const combined = `${message} ${stderr}`;
|
|
551
|
+
if (options.units !== false && /"--units" option does not exist/.test(`${combined} ${stdout}`)) {
|
|
552
|
+
return runDbDiff({ ...options, units: false });
|
|
553
|
+
}
|
|
554
|
+
if (dbdiffNotInstalled(errObj.code, stderr)) {
|
|
555
|
+
throw new DiagnosticError(
|
|
556
|
+
"@dbdiff/cli is not installed. Install it with: npm install @dbdiff/cli"
|
|
557
|
+
);
|
|
558
|
+
}
|
|
559
|
+
const fileExists = await access(outputFile).then(() => true, () => false);
|
|
560
|
+
if (fileExists) {
|
|
561
|
+
const output = await readFile(outputFile, "utf8");
|
|
562
|
+
const parsed = parseDbDiffOutput(output);
|
|
563
|
+
if (parsed.up || parsed.down) return parsed;
|
|
564
|
+
}
|
|
565
|
+
const timedOut = errObj.killed === true || errObj.signal === "SIGTERM" || errObj.code === "ETIMEDOUT" || /ETIMEDOUT|timed out/i.test(combined);
|
|
566
|
+
if (timedOut) {
|
|
567
|
+
const secs = Math.round(timeoutMs / 1e3);
|
|
568
|
+
throw new DiagnosticError(
|
|
569
|
+
`Schema diff timed out after ${secs}s \u2014 the schema is very large or the database connection is slow.
|
|
570
|
+
Remediations:
|
|
571
|
+
\u2022 Raise the limit: set SUPAFORGE_DBDIFF_TIMEOUT=600 (seconds) and re-run.
|
|
572
|
+
\u2022 Narrow the scan: diff one layer at a time with --check=schema.
|
|
573
|
+
\u2022 Exclude large internal schemas via "ignoreSchemas" in supaforge.config.json.`
|
|
574
|
+
);
|
|
575
|
+
}
|
|
576
|
+
const realError = stderr || stripDbDiffNoise(stdout);
|
|
577
|
+
const cleanMessage = realError ? realError : message.replace(/^Command failed:[^\n]*/m, "").trim() || "dbdiff failed with no error output";
|
|
578
|
+
throw new Error(friendlyDbError(cleanMessage, options.sourceUrl));
|
|
579
|
+
} finally {
|
|
580
|
+
await unlink(outputFile).catch(() => {
|
|
581
|
+
});
|
|
582
|
+
}
|
|
583
|
+
}
|
|
584
|
+
var UP_MARKER = "-- ==================== UP ====================";
|
|
585
|
+
var DOWN_MARKER = "-- ==================== DOWN ====================";
|
|
586
|
+
var CREATE_FUNCTION = "create-function";
|
|
587
|
+
var DROP_FUNCTION = "drop-function";
|
|
588
|
+
var DROP_TYPES = ["drop", "drop-view", DROP_FUNCTION, "drop-trigger", "drop-type", "drop-sequence"];
|
|
589
|
+
function isDestructiveSql(sql) {
|
|
590
|
+
return destructiveReason(sql) !== void 0;
|
|
591
|
+
}
|
|
592
|
+
function destructiveReason(sql, recreatedElsewhere = /* @__PURE__ */ new Set()) {
|
|
593
|
+
const statements = parseStatements(sql);
|
|
594
|
+
return statements ? destructiveInTree(statements, recreatedElsewhere) : destructiveInText(sql, recreatedElsewhere);
|
|
595
|
+
}
|
|
596
|
+
function destructiveInTree(statements, recreatedElsewhere) {
|
|
597
|
+
const dropped = (type) => statements.some((s) => s.kind === "DropStmt" && s.node.removeType === type);
|
|
598
|
+
if (dropped("OBJECT_SCHEMA")) return "drops a schema and everything in it";
|
|
599
|
+
if (dropped("OBJECT_TABLE")) return "drops a table and its rows";
|
|
600
|
+
if (statements.some((s) => s.kind === "TruncateStmt")) return "deletes every row in a table";
|
|
601
|
+
if (columnsDroppedForGoodInTree(statements).length > 0) return "drops a column and its values";
|
|
602
|
+
if (statements.some((s) => s.kind === "DeleteStmt")) return "deletes rows";
|
|
603
|
+
if (statements.some((s) => s.kind === "DropRoleStmt")) return "drops a role, and every login and grant it holds";
|
|
604
|
+
const key = (schema, table, policy) => `${(schema || "public").toLowerCase()}.${table.toLowerCase()}.${policy.toLowerCase()}`;
|
|
605
|
+
const created = new Set(statements.filter((s) => s.kind === "CreatePolicyStmt").map((s) => key(s.node.table?.schemaname, relationName(s.node.table), s.node.policy_name)));
|
|
606
|
+
const policies = statements.filter((s) => s.kind === "DropStmt" && s.node.removeType === "OBJECT_POLICY").flatMap((s) => s.node.objects.map((o) => names(o.List?.items))).map((parts) => key(parts.at(-3), parts.at(-2) ?? "", parts.at(-1) ?? "")).filter((k) => !created.has(k) && !recreatedElsewhere.has(k));
|
|
607
|
+
if (policies.length > 0) {
|
|
608
|
+
return policies.length === 1 ? `removes the policy ${policies[0]}, which may widen access` : `removes ${policies.length} policies, which may widen access`;
|
|
609
|
+
}
|
|
610
|
+
return void 0;
|
|
611
|
+
}
|
|
612
|
+
function columnsDroppedForGoodInTree(statements) {
|
|
613
|
+
const commands = statements.filter((s) => s.kind === "AlterTableStmt").flatMap((s) => s.node.cmds.map((c) => ({ table: relationName(s.node.relation), cmd: c.AlterTableCmd })));
|
|
614
|
+
return commands.flatMap(({ table, cmd }, i) => {
|
|
615
|
+
if (cmd?.subtype !== "AT_DropColumn") return [];
|
|
616
|
+
const readded = commands.slice(i + 1).some((later) => later.table === table && later.cmd?.subtype === "AT_AddColumn" && later.cmd.def?.ColumnDef?.colname === cmd.name);
|
|
617
|
+
return readded ? [] : [cmd.name];
|
|
618
|
+
});
|
|
619
|
+
}
|
|
620
|
+
function destructiveInText(sql, recreatedElsewhere) {
|
|
621
|
+
const skeleton = sqlSkeleton(sql).toUpperCase();
|
|
622
|
+
if (/\bDROP\s+SCHEMA\b/.test(skeleton)) return "drops a schema and everything in it";
|
|
623
|
+
if (/\bDROP\s+TABLE\b/.test(skeleton)) return "drops a table and its rows";
|
|
624
|
+
if (/(?:^|;)\s*TRUNCATE\b/.test(skeleton)) return "deletes every row in a table";
|
|
625
|
+
if (columnsDroppedForGood(skeleton).length > 0) return "drops a column and its values";
|
|
626
|
+
if (/\bDELETE\s+FROM\b/.test(skeleton)) return "deletes rows";
|
|
627
|
+
if (/(?:^|;)\s*DROP\s+(?:ROLE|USER|GROUP)\b/.test(skeleton)) return "drops a role, and every login and grant it holds";
|
|
628
|
+
const policies = policiesRemoved(sql).filter((key) => !recreatedElsewhere.has(key));
|
|
629
|
+
if (policies.length > 0) {
|
|
630
|
+
return policies.length === 1 ? `removes the policy ${policies[0]}, which may widen access` : `removes ${policies.length} policies, which may widen access`;
|
|
631
|
+
}
|
|
632
|
+
return void 0;
|
|
633
|
+
}
|
|
634
|
+
function columnsDroppedForGood(skeleton) {
|
|
635
|
+
const ident = String.raw`("(?:[^"]|"")+"|[\w$]+)`;
|
|
636
|
+
const dropped = [...skeleton.matchAll(new RegExp(String.raw`\bDROP\s+COLUMN\s+(?:IF\s+EXISTS\s+)?` + ident, "g"))];
|
|
637
|
+
return dropped.filter((m) => !new RegExp(String.raw`\bADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?` + escapeRegex(m[1]) + String.raw`(?![\w$"])`).test(skeleton.slice((m.index ?? 0) + m[0].length))).map((m) => m[1]);
|
|
638
|
+
}
|
|
639
|
+
function parseDbDiffOutput(output) {
|
|
640
|
+
const upIdx = output.indexOf(UP_MARKER);
|
|
641
|
+
const downIdx = output.indexOf(DOWN_MARKER);
|
|
642
|
+
if (upIdx === -1 && downIdx === -1) {
|
|
643
|
+
return { up: output.trim(), down: "" };
|
|
644
|
+
}
|
|
645
|
+
let up = "";
|
|
646
|
+
let down = "";
|
|
647
|
+
if (upIdx !== -1) {
|
|
648
|
+
const upStart = upIdx + UP_MARKER.length;
|
|
649
|
+
const upEnd = downIdx !== -1 ? downIdx : output.length;
|
|
650
|
+
up = output.slice(upStart, upEnd).trim();
|
|
651
|
+
}
|
|
652
|
+
if (downIdx !== -1) {
|
|
653
|
+
const downStart = downIdx + DOWN_MARKER.length;
|
|
654
|
+
down = output.slice(downStart).trim();
|
|
655
|
+
}
|
|
656
|
+
return { up, down };
|
|
657
|
+
}
|
|
658
|
+
function sqlToIssues(result, check, ignoreSchemas, ignoredSchemaTables) {
|
|
659
|
+
const issues = unfoldedIssues(result, check, ignoreSchemas, ignoredSchemaTables);
|
|
660
|
+
return check === "schema" ? foldCommentsIntoCreates(issues) : issues;
|
|
661
|
+
}
|
|
662
|
+
var COMMENT_TITLE = /^(?:Comment changed|Comment missing): (?:schema (.+)|(.+) \(([a-z ]+)\))$/;
|
|
663
|
+
var CREATE_TITLE = /^(Schema|Table|View|Function|Procedure|Type|Domain|Sequence|Index|Policy|Trigger|Extension) (?:missing|modified): (.+)$/;
|
|
664
|
+
var ON_A_TABLE = /* @__PURE__ */ new Set(["column", "constraint", "trigger", "policy", "rule"]);
|
|
665
|
+
function foldCommentsIntoCreates(issues) {
|
|
666
|
+
const creates = /* @__PURE__ */ new Map();
|
|
667
|
+
const routines = /* @__PURE__ */ new Map();
|
|
668
|
+
for (const issue of issues) {
|
|
669
|
+
const m = CREATE_TITLE.exec(issue.title);
|
|
670
|
+
if (!m) continue;
|
|
671
|
+
creates.set(`${m[1] === "Schema" ? "schema" : "object"}:${m[2]}`, issue);
|
|
672
|
+
if (m[1] === "Function" || m[1] === "Procedure") {
|
|
673
|
+
const base = routineBaseName(m[2]);
|
|
674
|
+
routines.set(base, [...routines.get(base) ?? [], issue]);
|
|
675
|
+
}
|
|
676
|
+
}
|
|
677
|
+
return issues.filter((issue) => {
|
|
678
|
+
const up = issue.sql?.up;
|
|
679
|
+
if (!up) return true;
|
|
680
|
+
const owner = commentOwner(issue, up, creates, routines) ?? rlsFlagsOwner(issue, up, creates);
|
|
681
|
+
if (!owner?.sql) return true;
|
|
682
|
+
owner.sql = { ...owner.sql, up: `${owner.sql.up.trimEnd()}
|
|
683
|
+
${up.trim()}` };
|
|
684
|
+
return false;
|
|
685
|
+
});
|
|
686
|
+
}
|
|
687
|
+
function commentOwner(issue, up, creates, routines) {
|
|
688
|
+
const m = COMMENT_TITLE.exec(issue.title);
|
|
689
|
+
if (!m || splitStatements(up).length !== 1) return void 0;
|
|
690
|
+
const [, schema, name, kind] = m;
|
|
691
|
+
const candidates = schema !== void 0 ? [`schema:${schema}`] : [`object:${name}`, ...ON_A_TABLE.has(kind) ? [`object:${name.slice(0, name.lastIndexOf("."))}`] : []];
|
|
692
|
+
const exact = candidates.map((c) => creates.get(c)).find(Boolean);
|
|
693
|
+
if (exact || kind !== "function" && kind !== "procedure") return exact;
|
|
694
|
+
const sameName = routines.get(routineBaseName(name)) ?? [];
|
|
695
|
+
return sameName.length === 1 ? sameName[0] : void 0;
|
|
696
|
+
}
|
|
697
|
+
var routineBaseName = (name) => name.includes("(") ? name.slice(0, name.indexOf("(")) : name;
|
|
698
|
+
var RLS_FLAG = /^\s*ALTER\s+TABLE\s+(?:ONLY\s+)?\S+\s+(?:ENABLE|DISABLE|(?:NO\s+)?FORCE)\s+ROW\s+LEVEL\s+SECURITY\s*;?\s*$/i;
|
|
699
|
+
function rlsFlagsOwner(issue, up, creates) {
|
|
700
|
+
const m = /^Table altered: (.+)$/.exec(issue.title);
|
|
701
|
+
if (!m || !splitStatements(up).every((sql) => RLS_FLAG.test(sql))) return void 0;
|
|
702
|
+
return creates.get(`object:${m[1]}`);
|
|
703
|
+
}
|
|
704
|
+
function unfoldedIssues(result, check, ignoreSchemas, ignoredSchemaTables) {
|
|
705
|
+
if (!result.up && !result.down) return [];
|
|
706
|
+
const upUnits = parseUnits(result.up);
|
|
707
|
+
if (upUnits) {
|
|
708
|
+
return issuesFromUnits(upUnits, parseUnits(result.down) ?? [], check, ignoreSchemas, ignoredSchemaTables);
|
|
709
|
+
}
|
|
710
|
+
let upStatements = splitStatements(result.up);
|
|
711
|
+
let downStatements = splitStatements(result.down);
|
|
712
|
+
if (ignoreSchemas?.length && check === "schema") {
|
|
713
|
+
const keep = filterCrossSchemaFks(upStatements, downStatements, ignoreSchemas, ignoredSchemaTables);
|
|
714
|
+
upStatements = upStatements.filter((_, i) => keep[i]);
|
|
715
|
+
downStatements = downStatements.filter((_, i) => keep[i]);
|
|
716
|
+
}
|
|
717
|
+
if (upStatements.length === 0) return [];
|
|
718
|
+
upStatements = groupColumnTypeChanges(upStatements);
|
|
719
|
+
downStatements = groupColumnTypeChanges(downStatements);
|
|
720
|
+
const merged = mergeReplacements(upStatements, downStatements);
|
|
721
|
+
return merged.map(({ up: upSql, down: downSql, modified }, i) => {
|
|
722
|
+
const lead = columnTypeChangeOf(upSql) ?? upSql;
|
|
723
|
+
const type = classifyStatement(lead);
|
|
724
|
+
if (modified) {
|
|
725
|
+
const report = REPLACEABLE_REPORT[modified.kind];
|
|
726
|
+
return {
|
|
727
|
+
id: `${check}-alter-${report.idPart}-${i + 1}`,
|
|
728
|
+
check,
|
|
729
|
+
severity: "warning",
|
|
730
|
+
title: `${report.label}: ${qualifySchemaName(modified.name)}`,
|
|
731
|
+
description: `${report.what} differs between source and target.`,
|
|
732
|
+
sql: { up: upSql, down: downSql }
|
|
733
|
+
};
|
|
734
|
+
}
|
|
735
|
+
return {
|
|
736
|
+
id: `${check}-${type}-${i + 1}`,
|
|
737
|
+
check,
|
|
738
|
+
severity: DROP_TYPES.includes(type) ? "critical" : "warning",
|
|
739
|
+
// The DOWN counterpart is passed so a title can recover a schema the UP
|
|
740
|
+
// statement does not carry — see routineLabel (issue #47).
|
|
741
|
+
title: summariseStatement(lead, check, downSql),
|
|
742
|
+
description: `${check === "schema" ? "Schema" : "Data"} difference detected by @dbdiff/cli.`,
|
|
743
|
+
sql: { up: upSql, down: downSql }
|
|
744
|
+
};
|
|
745
|
+
});
|
|
746
|
+
}
|
|
747
|
+
function issuesFromUnits(upUnits, downUnits, check, ignoreSchemas, ignoredSchemaTables) {
|
|
748
|
+
const pairs = pairUnits(upUnits, downUnits).filter(({ up, down }) => !(ignoreSchemas?.length && isCrossSchemaFkUnit(up, down, ignoreSchemas, ignoredSchemaTables)));
|
|
749
|
+
return pairs.map(({ up, down }, i) => {
|
|
750
|
+
const upSql = up.sql;
|
|
751
|
+
const downSql = down?.sql ?? "";
|
|
752
|
+
const statements = splitStatements(upSql);
|
|
753
|
+
const replaced = replacedObject(up, statements);
|
|
754
|
+
const manualOnly = manualEnumChange(up);
|
|
755
|
+
const manual = manualOnly ? { manualOnly } : {};
|
|
756
|
+
if (replaced) {
|
|
757
|
+
const report = REPLACEABLE_REPORT[replaced.kind];
|
|
758
|
+
return {
|
|
759
|
+
id: `${check}-alter-${report.idPart}-${i + 1}`,
|
|
760
|
+
check,
|
|
761
|
+
severity: "warning",
|
|
762
|
+
title: `${report.label}: ${qualifySchemaName(replaced.name)}`,
|
|
763
|
+
description: `${report.what} differs between source and target.`,
|
|
764
|
+
sql: { up: upSql, down: downSql },
|
|
765
|
+
...manual
|
|
766
|
+
};
|
|
767
|
+
}
|
|
768
|
+
const lead = leadStatement(up, statements);
|
|
769
|
+
const type = classifyStatement(lead);
|
|
770
|
+
return {
|
|
771
|
+
id: `${check}-${type}-${i + 1}`,
|
|
772
|
+
check,
|
|
773
|
+
severity: DROP_TYPES.includes(type) ? "critical" : "warning",
|
|
774
|
+
title: summariseStatement(lead, check, downSql),
|
|
775
|
+
description: `${check === "schema" ? "Schema" : "Data"} difference detected by @dbdiff/cli.`,
|
|
776
|
+
sql: { up: upSql, down: downSql },
|
|
777
|
+
...manual
|
|
778
|
+
};
|
|
779
|
+
});
|
|
780
|
+
}
|
|
781
|
+
function manualEnumChange(unit) {
|
|
782
|
+
if (unit.kind !== "AlterEnum" || !/^--.*\benum labels\b/im.test(unit.sql)) return void 0;
|
|
783
|
+
const blockers = [...unit.sql.matchAll(/^--\s{3}(.+)$/gm)].map((m) => m[1].trim());
|
|
784
|
+
return "removing or reordering these enum labels needs the type replaced" + (blockers.length > 0 ? `, and these use it in ways that cannot be moved automatically: ${blockers.join(", ")}` : "") + ". Migrate them first, then re-run, or apply the change by hand.";
|
|
785
|
+
}
|
|
786
|
+
function isCrossSchemaFkUnit(up, down, schemas, ignoredSchemaTables) {
|
|
787
|
+
if (!/Constraint$/.test(up.kind)) return false;
|
|
788
|
+
return [up.sql, down?.sql ?? ""].some((sql) => /\bFOREIGN\s+KEY\b/i.test(sql) && (hasCrossSchemaRef(sql, schemas, ignoredSchemaTables) || hasBrokenRef(sql)));
|
|
789
|
+
}
|
|
790
|
+
function replacedObject(unit, statements) {
|
|
791
|
+
const kind = REPLACING_KINDS[unit.kind];
|
|
792
|
+
const drop = statements.find((sql) => replaceablePart(sql)?.drop);
|
|
793
|
+
if (!kind || !drop) return void 0;
|
|
794
|
+
if (kind === "type") return { kind, name: unit.object };
|
|
795
|
+
const create = [...statements].reverse().find((sql) => replaceablePart(sql)?.drop === false) ?? drop;
|
|
796
|
+
return {
|
|
797
|
+
kind,
|
|
798
|
+
name: kind === "routine" ? extractRoutineName(create) + extractRoutineArgs(drop) : REPLACEABLE_NAME[kind](create)
|
|
799
|
+
};
|
|
800
|
+
}
|
|
801
|
+
function leadStatement(unit, statements) {
|
|
802
|
+
if (unit.kind.startsWith("AlterTable")) {
|
|
803
|
+
const alter = statements.find((sql) => /^\s*ALTER\s+TABLE\b/i.test(sql));
|
|
804
|
+
if (alter) return alter;
|
|
805
|
+
}
|
|
806
|
+
return statements[0] ?? unit.sql;
|
|
807
|
+
}
|
|
808
|
+
var ALTER_COLUMN_TYPE = /^\s*ALTER\s+TABLE\s+(?:ONLY\s+)?((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)\s+ALTER\s+COLUMN\s+("[^"]+"|[\w$]+)\s+(?:SET\s+DATA\s+)?TYPE\b/i;
|
|
809
|
+
function columnTypeChangeOf(sql) {
|
|
810
|
+
if (!/^\s*DROP\s+/i.test(sql)) return void 0;
|
|
811
|
+
return splitStatements(sql).find((s) => ALTER_COLUMN_TYPE.test(s));
|
|
812
|
+
}
|
|
813
|
+
function plainName(identifier) {
|
|
814
|
+
return identifier.replace(/"/g, "").replace(/^public\./i, "").trim();
|
|
815
|
+
}
|
|
816
|
+
function groupColumnTypeChanges(statements) {
|
|
817
|
+
const out = [];
|
|
818
|
+
let i = 0;
|
|
819
|
+
while (i < statements.length) {
|
|
820
|
+
const alter = ALTER_COLUMN_TYPE.exec(statements[i]);
|
|
821
|
+
if (!alter) {
|
|
822
|
+
out.push(statements[i]);
|
|
823
|
+
i++;
|
|
824
|
+
continue;
|
|
825
|
+
}
|
|
826
|
+
const [, table, column] = alter;
|
|
827
|
+
const views = /* @__PURE__ */ new Set();
|
|
828
|
+
const attached = /* @__PURE__ */ new Set();
|
|
829
|
+
const drops = [];
|
|
830
|
+
let start = out.length;
|
|
831
|
+
while (start > 0) {
|
|
832
|
+
const drop = /^\s*DROP\s+(?:(MATERIALIZED\s+VIEW|VIEW)|(POLICY|TRIGGER))\s+IF\s+EXISTS\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)(?:\s+ON\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?))?\s*;?\s*$/i.exec(out[start - 1]);
|
|
833
|
+
if (!drop) break;
|
|
834
|
+
if (drop[1]) {
|
|
835
|
+
views.add(plainName(drop[3]));
|
|
836
|
+
drops.unshift({ index: start - 1, view: plainName(drop[3]) });
|
|
837
|
+
} else {
|
|
838
|
+
const key = `${plainName(drop[3])}@${plainName(drop[4] ?? "")}`;
|
|
839
|
+
attached.add(key);
|
|
840
|
+
drops.unshift({ index: start - 1, attached: key, table: plainName(drop[4] ?? "") });
|
|
841
|
+
}
|
|
842
|
+
start--;
|
|
843
|
+
}
|
|
844
|
+
if (drops.length === 0) {
|
|
845
|
+
out.push(statements[i]);
|
|
846
|
+
i++;
|
|
847
|
+
continue;
|
|
848
|
+
}
|
|
849
|
+
const onView = (name) => views.has(plainName(name));
|
|
850
|
+
const recreated = /* @__PURE__ */ new Set();
|
|
851
|
+
const belongs = (sql) => {
|
|
852
|
+
const sameColumn = ALTER_COLUMN_TYPE.exec(sql) ?? /^\s*ALTER\s+TABLE\s+(?:ONLY\s+)?((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)\s+ALTER\s+COLUMN\s+("[^"]+"|[\w$]+)\s+(?:SET|DROP)\b/i.exec(sql);
|
|
853
|
+
if (sameColumn) return plainName(sameColumn[1]) === plainName(table) && plainName(sameColumn[2]) === plainName(column);
|
|
854
|
+
let m = /^\s*CREATE\s+(?:MATERIALIZED\s+)?VIEW\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)/i.exec(sql);
|
|
855
|
+
if (m) return onView(m[1]);
|
|
856
|
+
m = /^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\b[\s\S]*?\bON\s+(?:ONLY\s+)?((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)/i.exec(sql);
|
|
857
|
+
if (m) return onView(m[1]);
|
|
858
|
+
m = /^\s*(?:GRANT|REVOKE)\b[\s\S]*?\bON\s+(?:TABLE\s+)?((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)\s+(?:TO|FROM)\b/i.exec(sql);
|
|
859
|
+
if (m) return onView(m[1]);
|
|
860
|
+
m = /^\s*COMMENT\s+ON\s+(?:MATERIALIZED\s+VIEW|VIEW)\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)/i.exec(sql);
|
|
861
|
+
if (m) return onView(m[1]);
|
|
862
|
+
m = /^\s*COMMENT\s+ON\s+COLUMN\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)\.(?:"[^"]+"|[\w$]+)\s+IS\b/i.exec(sql);
|
|
863
|
+
if (m) return onView(m[1]);
|
|
864
|
+
m = /^\s*CREATE\s+(?:POLICY|(?:CONSTRAINT\s+)?TRIGGER)\s+("[^"]+"|[\w$]+)[\s\S]*?\bON\s+((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)/i.exec(sql);
|
|
865
|
+
if (m) {
|
|
866
|
+
const key = `${plainName(m[1])}@${plainName(m[2])}`;
|
|
867
|
+
if (attached.has(key)) {
|
|
868
|
+
recreated.add(key);
|
|
869
|
+
return true;
|
|
870
|
+
}
|
|
871
|
+
return onView(m[2]);
|
|
872
|
+
}
|
|
873
|
+
return false;
|
|
874
|
+
};
|
|
875
|
+
let end = i + 1;
|
|
876
|
+
while (end < statements.length && belongs(statements[end])) end++;
|
|
877
|
+
const foreign = (d) => d.attached !== void 0 && d.table !== plainName(table) && !recreated.has(d.attached);
|
|
878
|
+
while (drops.length > 0 && foreign(drops[0])) {
|
|
879
|
+
drops.shift();
|
|
880
|
+
start++;
|
|
881
|
+
}
|
|
882
|
+
if (drops.length === 0) {
|
|
883
|
+
out.push(statements[i]);
|
|
884
|
+
i++;
|
|
885
|
+
continue;
|
|
886
|
+
}
|
|
887
|
+
const group = [...out.splice(start), ...statements.slice(i, end)];
|
|
888
|
+
out.push(group.join("\n"));
|
|
889
|
+
i = end;
|
|
890
|
+
}
|
|
891
|
+
return out;
|
|
892
|
+
}
|
|
893
|
+
var REPLACEABLE_NAME = {
|
|
894
|
+
routine: extractRoutineName,
|
|
895
|
+
type: (sql) => extractQualifiedName(sql, /\b(?:TYPE|DOMAIN)\s+(?:IF\s+EXISTS\s+)?/i),
|
|
896
|
+
sequence: (sql) => extractQualifiedName(sql, /\bSEQUENCE\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?/i),
|
|
897
|
+
// `table.policy`: a policy name is unique only per table.
|
|
898
|
+
policy: (sql) => policyLabel(sql),
|
|
899
|
+
// `schema.table.trigger`, for the same reason.
|
|
900
|
+
trigger: (sql) => triggerLabel(sql),
|
|
901
|
+
view: (sql) => extractQualifiedName(sql, AFTER.view)
|
|
902
|
+
};
|
|
903
|
+
var REPLACEABLE_REPORT = {
|
|
904
|
+
routine: { idPart: "function", label: "Function modified", what: "Function body" },
|
|
905
|
+
type: { idPart: "type", label: "Type modified", what: "Type definition" },
|
|
906
|
+
sequence: { idPart: "sequence", label: "Sequence modified", what: "Sequence definition" },
|
|
907
|
+
policy: { idPart: "policy", label: "Policy modified", what: "Policy definition" },
|
|
908
|
+
trigger: { idPart: "trigger", label: "Trigger modified", what: "Trigger definition" },
|
|
909
|
+
view: { idPart: "view", label: "View modified", what: "View definition" }
|
|
910
|
+
};
|
|
911
|
+
function replaceablePart(sql) {
|
|
912
|
+
if (/^\s*DROP\s+POLICY\b/i.test(sql)) return { kind: "policy", drop: true };
|
|
913
|
+
if (/^\s*CREATE\s+POLICY\b/i.test(sql)) return { kind: "policy", drop: false };
|
|
914
|
+
if (/^\s*DROP\s+TRIGGER\b/i.test(sql)) return { kind: "trigger", drop: true };
|
|
915
|
+
if (/^\s*DROP\s+(?:MATERIALIZED\s+)?VIEW\b/i.test(sql)) return { kind: "view", drop: true };
|
|
916
|
+
if (/^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\b/i.test(sql)) return { kind: "view", drop: false };
|
|
917
|
+
if (/^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\b/i.test(sql)) return { kind: "trigger", drop: false };
|
|
918
|
+
switch (classifyStatement(sql)) {
|
|
919
|
+
case CREATE_FUNCTION:
|
|
920
|
+
return { kind: "routine", drop: false };
|
|
921
|
+
case DROP_FUNCTION:
|
|
922
|
+
return { kind: "routine", drop: true };
|
|
923
|
+
case "create-type":
|
|
924
|
+
return { kind: "type", drop: false };
|
|
925
|
+
case "drop-type":
|
|
926
|
+
return { kind: "type", drop: true };
|
|
927
|
+
case "create-sequence":
|
|
928
|
+
return { kind: "sequence", drop: false };
|
|
929
|
+
case "drop-sequence":
|
|
930
|
+
return { kind: "sequence", drop: true };
|
|
931
|
+
default:
|
|
932
|
+
return void 0;
|
|
933
|
+
}
|
|
934
|
+
}
|
|
935
|
+
function replacementKey(kind, sql) {
|
|
936
|
+
const name = REPLACEABLE_NAME[kind](sql);
|
|
937
|
+
if (kind === "policy") return `policy:${name.replace(/"/g, "").toLowerCase()}`;
|
|
938
|
+
if (kind === "trigger") return `trigger:${name.split(".").slice(-2).join(".").toLowerCase()}`;
|
|
939
|
+
return `${kind}:${name.slice(name.lastIndexOf(".") + 1).toLowerCase()}`;
|
|
940
|
+
}
|
|
941
|
+
function mergeReplacements(upStatements, downStatements) {
|
|
942
|
+
const unclaimedCreates = /* @__PURE__ */ new Map();
|
|
943
|
+
const dropCounts = /* @__PURE__ */ new Map();
|
|
944
|
+
upStatements.forEach((sql, i) => {
|
|
945
|
+
const part = replaceablePart(sql);
|
|
946
|
+
if (!part) return;
|
|
947
|
+
const key = replacementKey(part.kind, sql);
|
|
948
|
+
if (part.drop) {
|
|
949
|
+
dropCounts.set(key, (dropCounts.get(key) ?? 0) + 1);
|
|
950
|
+
} else {
|
|
951
|
+
unclaimedCreates.set(key, [...unclaimedCreates.get(key) ?? [], i]);
|
|
952
|
+
}
|
|
953
|
+
});
|
|
954
|
+
const absorbed = /* @__PURE__ */ new Set();
|
|
955
|
+
const out = [];
|
|
956
|
+
upStatements.forEach((upSql, i) => {
|
|
957
|
+
if (absorbed.has(i)) return;
|
|
958
|
+
const down = downStatements[i] ?? "";
|
|
959
|
+
const part = replaceablePart(upSql);
|
|
960
|
+
if (!part?.drop) {
|
|
961
|
+
out.push({ up: upSql, down });
|
|
962
|
+
return;
|
|
963
|
+
}
|
|
964
|
+
const key = replacementKey(part.kind, upSql);
|
|
965
|
+
const unambiguous = dropCounts.get(key) === 1 && unclaimedCreates.get(key)?.length === 1;
|
|
966
|
+
const createIdx = claimCreateFor(unclaimedCreates, key, i, unambiguous);
|
|
967
|
+
if (createIdx === void 0) {
|
|
968
|
+
out.push({ up: upSql, down });
|
|
969
|
+
return;
|
|
970
|
+
}
|
|
971
|
+
const createSql = upStatements[createIdx];
|
|
972
|
+
absorbed.add(createIdx);
|
|
973
|
+
out.push({
|
|
974
|
+
// Drop first, create second, in one statement. Kept together rather than
|
|
975
|
+
// ordered apart because `orderStatements` sends drops to the last phase
|
|
976
|
+
// and creates to an early one, which put the CREATE before the DROP it
|
|
977
|
+
// was replacing — `type "order_state" already exists`, and the whole
|
|
978
|
+
// apply rolled back (issue #81). Phasing reads the CREATE in a merged
|
|
979
|
+
// pair, so the pair runs where the object it leaves behind belongs.
|
|
980
|
+
up: `${upSql}
|
|
981
|
+
${createSql}`,
|
|
982
|
+
down: [down, downStatements[createIdx] ?? ""].filter(Boolean).join("\n"),
|
|
983
|
+
modified: {
|
|
984
|
+
kind: part.kind,
|
|
985
|
+
// A routine's name is qualified by its argument types, since overloads
|
|
986
|
+
// share a name; nothing else can be overloaded.
|
|
987
|
+
name: part.kind === "routine" ? extractRoutineName(createSql) + extractRoutineArgs(upSql) : REPLACEABLE_NAME[part.kind](createSql)
|
|
988
|
+
}
|
|
989
|
+
});
|
|
990
|
+
});
|
|
991
|
+
return out;
|
|
992
|
+
}
|
|
993
|
+
function claimCreateFor(unclaimed, key, dropIdx, unambiguous) {
|
|
994
|
+
const queue = unclaimed.get(key);
|
|
995
|
+
if (!queue) return void 0;
|
|
996
|
+
const at = queue.findIndex((idx) => unambiguous ? idx > dropIdx : idx === dropIdx + 1);
|
|
997
|
+
if (at === -1) return void 0;
|
|
998
|
+
return queue.splice(at, 1)[0];
|
|
999
|
+
}
|
|
1000
|
+
function filterCrossSchemaFks(upStmts, downStmts, schemas, ignoredSchemaTables) {
|
|
1001
|
+
const keep = new Array(upStmts.length).fill(true);
|
|
1002
|
+
const crossSchemaConstraints = /* @__PURE__ */ new Set();
|
|
1003
|
+
for (let i = 0; i < upStmts.length; i++) {
|
|
1004
|
+
const upper = upStmts[i].toUpperCase();
|
|
1005
|
+
if (!upper.includes("ADD CONSTRAINT") || !upper.includes("FOREIGN KEY")) continue;
|
|
1006
|
+
const isCrossSchema = hasCrossSchemaRef(upStmts[i], schemas, ignoredSchemaTables) || downStmts[i] != null && hasBrokenRef(downStmts[i]);
|
|
1007
|
+
if (isCrossSchema) {
|
|
1008
|
+
keep[i] = false;
|
|
1009
|
+
const name = upStmts[i].match(/CONSTRAINT\s+"([^"]+)"/i)?.[1];
|
|
1010
|
+
if (name) crossSchemaConstraints.add(name);
|
|
1011
|
+
}
|
|
1012
|
+
}
|
|
1013
|
+
for (let i = 0; i < upStmts.length; i++) {
|
|
1014
|
+
if (!keep[i]) continue;
|
|
1015
|
+
const upper = upStmts[i].toUpperCase();
|
|
1016
|
+
if (!upper.includes("DROP CONSTRAINT")) continue;
|
|
1017
|
+
const name = upStmts[i].match(/DROP\s+CONSTRAINT\s+"([^"]+)"/i)?.[1];
|
|
1018
|
+
if (name && crossSchemaConstraints.has(name)) {
|
|
1019
|
+
keep[i] = false;
|
|
1020
|
+
}
|
|
1021
|
+
}
|
|
1022
|
+
return keep;
|
|
1023
|
+
}
|
|
1024
|
+
function hasCrossSchemaRef(sql, schemas, ignoredSchemaTables) {
|
|
1025
|
+
const refsMatch = sql.match(/REFERENCES\s+"([^"]*)"(?:\s*\.\s*"([^"]*)")?\s*\(\s*"([^"]*)"\s*\)/i);
|
|
1026
|
+
if (!refsMatch) return false;
|
|
1027
|
+
const [, first, second] = refsMatch;
|
|
1028
|
+
if (first === "") return true;
|
|
1029
|
+
if (second !== void 0) {
|
|
1030
|
+
if (!schemas.some((s) => s.toLowerCase() === first.toLowerCase())) return false;
|
|
1031
|
+
return !ignoredSchemaTables?.has(`${first}.${second}`.toLowerCase());
|
|
1032
|
+
}
|
|
1033
|
+
return ignoredSchemaTables ? ignoredSchemaTables.has(first.toLowerCase()) : false;
|
|
1034
|
+
}
|
|
1035
|
+
function hasBrokenRef(sql) {
|
|
1036
|
+
return /REFERENCES\s+""\s*\(\s*""\s*\)/i.test(sql);
|
|
1037
|
+
}
|
|
1038
|
+
function splitStatements(sql) {
|
|
1039
|
+
if (!sql) return [];
|
|
1040
|
+
const statements = [];
|
|
1041
|
+
let buf = "";
|
|
1042
|
+
let i = 0;
|
|
1043
|
+
while (i < sql.length) {
|
|
1044
|
+
if (sql[i] === "$") {
|
|
1045
|
+
const tagMatch = sql.slice(i + 1).match(/^([A-Za-z0-9_]*)\$/);
|
|
1046
|
+
if (tagMatch) {
|
|
1047
|
+
const tag = `$${tagMatch[1]}$`;
|
|
1048
|
+
const closeIdx = sql.indexOf(tag, i + tag.length);
|
|
1049
|
+
if (closeIdx !== -1) {
|
|
1050
|
+
buf += sql.slice(i, closeIdx + tag.length);
|
|
1051
|
+
i = closeIdx + tag.length;
|
|
1052
|
+
continue;
|
|
1053
|
+
}
|
|
1054
|
+
}
|
|
1055
|
+
}
|
|
1056
|
+
if (sql[i] === ";") {
|
|
1057
|
+
buf += ";";
|
|
1058
|
+
i++;
|
|
1059
|
+
let j = i;
|
|
1060
|
+
while (j < sql.length && (sql[j] === " " || sql[j] === " " || sql[j] === "\r")) j++;
|
|
1061
|
+
if (j >= sql.length || sql[j] === "\n") {
|
|
1062
|
+
const stmt = withoutLeadingComments(buf);
|
|
1063
|
+
if (stmt.length > 0) {
|
|
1064
|
+
statements.push(stmt);
|
|
1065
|
+
}
|
|
1066
|
+
buf = "";
|
|
1067
|
+
i = j < sql.length ? j + 1 : j;
|
|
1068
|
+
}
|
|
1069
|
+
continue;
|
|
1070
|
+
}
|
|
1071
|
+
buf += sql[i];
|
|
1072
|
+
i++;
|
|
1073
|
+
}
|
|
1074
|
+
const last = withoutLeadingComments(buf);
|
|
1075
|
+
if (last.length > 0) {
|
|
1076
|
+
statements.push(last.endsWith(";") ? last : `${last};`);
|
|
1077
|
+
}
|
|
1078
|
+
return statements;
|
|
1079
|
+
}
|
|
1080
|
+
function withoutLeadingComments(chunk) {
|
|
1081
|
+
return chunk.trim().replace(/^(?:--[^\n]*(?:\n|$)\s*)+/, "").trim();
|
|
1082
|
+
}
|
|
1083
|
+
function classifyStatement(sql) {
|
|
1084
|
+
const upper = sql.toUpperCase().trimStart();
|
|
1085
|
+
if (upper.startsWith("CREATE VIEW") || upper.startsWith("CREATE OR REPLACE VIEW")) return "create-view";
|
|
1086
|
+
if (upper.startsWith("ALTER VIEW")) return "alter-view";
|
|
1087
|
+
if (upper.startsWith("DROP VIEW")) return "drop-view";
|
|
1088
|
+
if (upper.startsWith("CREATE FUNCTION") || upper.startsWith("CREATE OR REPLACE FUNCTION")) return CREATE_FUNCTION;
|
|
1089
|
+
if (upper.startsWith("ALTER FUNCTION")) return "alter-function";
|
|
1090
|
+
if (upper.startsWith("DROP FUNCTION")) return DROP_FUNCTION;
|
|
1091
|
+
if (upper.startsWith("CREATE PROCEDURE") || upper.startsWith("CREATE OR REPLACE PROCEDURE")) return CREATE_FUNCTION;
|
|
1092
|
+
if (upper.startsWith("DROP PROCEDURE")) return DROP_FUNCTION;
|
|
1093
|
+
if (upper.startsWith("CREATE TRIGGER") || upper.startsWith("CREATE OR REPLACE TRIGGER")) return "create-trigger";
|
|
1094
|
+
if (upper.startsWith("ALTER TRIGGER")) return "alter-trigger";
|
|
1095
|
+
if (upper.startsWith("DROP TRIGGER")) return "drop-trigger";
|
|
1096
|
+
if (upper.startsWith("CREATE TYPE")) return "create-type";
|
|
1097
|
+
if (upper.startsWith("ALTER TYPE")) return "alter-type";
|
|
1098
|
+
if (upper.startsWith("DROP TYPE")) return "drop-type";
|
|
1099
|
+
if (upper.startsWith("CREATE DOMAIN")) return "create-type";
|
|
1100
|
+
if (upper.startsWith("ALTER DOMAIN")) return "alter-type";
|
|
1101
|
+
if (upper.startsWith("DROP DOMAIN")) return "drop-type";
|
|
1102
|
+
if (upper.startsWith("ALTER TABLE")) return "alter";
|
|
1103
|
+
if (upper.startsWith("CREATE TABLE")) return "create-table";
|
|
1104
|
+
if (upper.startsWith("DROP TABLE")) return "drop";
|
|
1105
|
+
if (upper.startsWith("CREATE INDEX") || upper.startsWith("CREATE UNIQUE INDEX")) return "create-index";
|
|
1106
|
+
if (upper.startsWith("DROP INDEX")) return "drop";
|
|
1107
|
+
if (upper.startsWith("CREATE SEQUENCE")) return "create-sequence";
|
|
1108
|
+
if (upper.startsWith("ALTER SEQUENCE")) return "alter-sequence";
|
|
1109
|
+
if (upper.startsWith("DROP SEQUENCE")) return "drop-sequence";
|
|
1110
|
+
if (upper.startsWith("INSERT")) return "insert";
|
|
1111
|
+
if (upper.startsWith("UPDATE")) return "update";
|
|
1112
|
+
if (upper.startsWith("DELETE")) return "delete";
|
|
1113
|
+
return "change";
|
|
1114
|
+
}
|
|
1115
|
+
var AFTER = {
|
|
1116
|
+
view: /\bVIEW\s+(?:IF\s+EXISTS\s+)?/i,
|
|
1117
|
+
trigger: /\bTRIGGER\s+(?:IF\s+EXISTS\s+)?/i,
|
|
1118
|
+
type: /\bTYPE\s+(?:IF\s+EXISTS\s+)?/i,
|
|
1119
|
+
domain: /\bDOMAIN\s+(?:IF\s+EXISTS\s+)?/i,
|
|
1120
|
+
sequence: /\bSEQUENCE\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?/i,
|
|
1121
|
+
table: /\bTABLE\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(?:ONLY\s+)?/i,
|
|
1122
|
+
index: /\bINDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+(?:NOT\s+)?EXISTS\s+)?/i,
|
|
1123
|
+
policy: /\bPOLICY\s+(?:IF\s+EXISTS\s+)?/i,
|
|
1124
|
+
on: /\bON\s+(?:ONLY\s+)?/i
|
|
1125
|
+
};
|
|
1126
|
+
var named = (head) => (sql) => extractQualifiedName(sql, head);
|
|
1127
|
+
function policyLabel(sql) {
|
|
1128
|
+
const policy = extractQualifiedName(sql, AFTER.policy);
|
|
1129
|
+
const table = extractQualifiedName(sql, AFTER.on);
|
|
1130
|
+
if (policy === UNKNOWN_NAME) return UNKNOWN_NAME;
|
|
1131
|
+
if (table === UNKNOWN_NAME) return policy;
|
|
1132
|
+
return `${qualifySchemaName(table)}.${policy}`;
|
|
1133
|
+
}
|
|
1134
|
+
function triggerLabel(sql, downSql) {
|
|
1135
|
+
const trigger = extractQualifiedName(sql, AFTER.trigger);
|
|
1136
|
+
let table = extractQualifiedName(sql, AFTER.on);
|
|
1137
|
+
if (trigger === UNKNOWN_NAME) return UNKNOWN_NAME;
|
|
1138
|
+
if (table === UNKNOWN_NAME) return trigger;
|
|
1139
|
+
if (!table.includes(".") && downSql) {
|
|
1140
|
+
const counterpart = extractQualifiedName(downSql, AFTER.on);
|
|
1141
|
+
if (counterpart.includes(".") && unqualify(counterpart) === table.toLowerCase()) table = counterpart;
|
|
1142
|
+
}
|
|
1143
|
+
return `${qualifySchemaName(table)}.${trigger}`;
|
|
1144
|
+
}
|
|
1145
|
+
var DBDIFF_SCHEMA = "public";
|
|
1146
|
+
function qualifySchemaName(name) {
|
|
1147
|
+
if (name === UNKNOWN_NAME) return name;
|
|
1148
|
+
const paren = name.indexOf("(");
|
|
1149
|
+
const head = paren === -1 ? name : name.slice(0, paren);
|
|
1150
|
+
if (head.includes(".")) return name;
|
|
1151
|
+
return `${DBDIFF_SCHEMA}.${name}`;
|
|
1152
|
+
}
|
|
1153
|
+
function indexLabel(sql) {
|
|
1154
|
+
const name = extractQualifiedName(sql, AFTER.index);
|
|
1155
|
+
if (name === UNKNOWN_NAME || name.includes(".")) return name;
|
|
1156
|
+
const table = extractQualifiedName(sql, AFTER.on);
|
|
1157
|
+
const dot = table.lastIndexOf(".");
|
|
1158
|
+
return dot === -1 ? name : `${table.slice(0, dot)}.${name}`;
|
|
1159
|
+
}
|
|
1160
|
+
var SCHEMA_RULES = [
|
|
1161
|
+
{ match: /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\b/i, label: "View missing", name: named(AFTER.view) },
|
|
1162
|
+
{ match: /^\s*ALTER\s+(?:MATERIALIZED\s+)?VIEW\b/i, label: "View altered", name: named(AFTER.view) },
|
|
1163
|
+
{ match: /^\s*DROP\s+(?:MATERIALIZED\s+)?VIEW\b/i, label: "Extra view", name: named(AFTER.view) },
|
|
1164
|
+
{ match: /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\b/i, label: "Function missing", name: routineLabel },
|
|
1165
|
+
{ match: /^\s*ALTER\s+FUNCTION\b/i, label: "Function altered", name: routineLabel },
|
|
1166
|
+
{ match: /^\s*DROP\s+FUNCTION\b/i, label: "Extra function", name: routineLabel },
|
|
1167
|
+
{ match: /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\b/i, label: "Procedure missing", name: routineLabel },
|
|
1168
|
+
{ match: /^\s*DROP\s+PROCEDURE\b/i, label: "Extra procedure", name: routineLabel },
|
|
1169
|
+
{ match: /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\b/i, label: "Trigger missing", name: triggerLabel },
|
|
1170
|
+
{ match: /^\s*ALTER\s+TRIGGER\b/i, label: "Trigger altered", name: triggerLabel },
|
|
1171
|
+
{ match: /^\s*DROP\s+TRIGGER\b/i, label: "Extra trigger", name: triggerLabel },
|
|
1172
|
+
{ match: /^\s*CREATE\s+TYPE\b/i, label: "Type missing", name: named(AFTER.type) },
|
|
1173
|
+
{ match: /^\s*ALTER\s+TYPE\b/i, label: "Type altered", name: named(AFTER.type) },
|
|
1174
|
+
{ match: /^\s*DROP\s+TYPE\b/i, label: "Extra type", name: named(AFTER.type) },
|
|
1175
|
+
{ match: /^\s*CREATE\s+DOMAIN\b/i, label: "Domain missing", name: named(AFTER.domain) },
|
|
1176
|
+
{ match: /^\s*ALTER\s+DOMAIN\b/i, label: "Domain altered", name: named(AFTER.domain) },
|
|
1177
|
+
{ match: /^\s*DROP\s+DOMAIN\b/i, label: "Extra domain", name: named(AFTER.domain) },
|
|
1178
|
+
{ match: /^\s*ALTER\s+TABLE\b/i, label: "Table altered", name: named(AFTER.table) },
|
|
1179
|
+
{ match: /^\s*CREATE\s+TABLE\b/i, label: "Table missing", name: named(AFTER.table) },
|
|
1180
|
+
{ match: /^\s*DROP\s+TABLE\b/i, label: "Extra table", name: named(AFTER.table) },
|
|
1181
|
+
{ match: /^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\b/i, label: "Index missing", name: indexLabel },
|
|
1182
|
+
{ match: /^\s*DROP\s+INDEX\b/i, label: "Extra index", name: named(AFTER.index) },
|
|
1183
|
+
// Policies. Without these, dbdiff's own CREATE/DROP POLICY statements fell
|
|
1184
|
+
// through to the catch-all and were titled "Schema change: unknown" — the
|
|
1185
|
+
// one finding in a report that named no object at all (issue #97). Keyed
|
|
1186
|
+
// `table.policy`, which is how a policy is identified and how the RLS check
|
|
1187
|
+
// names the same one.
|
|
1188
|
+
{ match: /^\s*CREATE\s+POLICY\b/i, label: "Policy missing", name: policyLabel },
|
|
1189
|
+
{ match: /^\s*ALTER\s+POLICY\b/i, label: "Policy altered", name: policyLabel },
|
|
1190
|
+
{ match: /^\s*DROP\s+POLICY\b/i, label: "Extra policy", name: policyLabel },
|
|
1191
|
+
// Comments (rc.21) and extensions (rc.22), named like everything else, and
|
|
1192
|
+
// a comment by the object it is on and that object's kind.
|
|
1193
|
+
{ match: /^\s*COMMENT\s+ON\b/i, label: "Comment changed", name: commentLabel },
|
|
1194
|
+
{ match: /^\s*CREATE\s+EXTENSION\b/i, label: "Extension missing", name: extensionLabel },
|
|
1195
|
+
{ match: /^\s*DROP\s+EXTENSION\b/i, label: "Extra extension", name: extensionLabel },
|
|
1196
|
+
{ match: /^\s*CREATE\s+SEQUENCE\b/i, label: "Sequence missing", name: named(AFTER.sequence) },
|
|
1197
|
+
{ match: /^\s*ALTER\s+SEQUENCE\b/i, label: "Sequence altered", name: named(AFTER.sequence) },
|
|
1198
|
+
{ match: /^\s*DROP\s+SEQUENCE\b/i, label: "Extra sequence", name: named(AFTER.sequence) }
|
|
1199
|
+
];
|
|
1200
|
+
var unquoted = (part) => part.replace(/^"|"$/g, "").replace(/""/g, '"');
|
|
1201
|
+
function commentLabel(sql) {
|
|
1202
|
+
const m = /^\s*COMMENT\s+ON\s+(MATERIALIZED\s+VIEW|FOREIGN\s+TABLE|[A-Z]+)\s+([\s\S]*?)\s+IS\s/i.exec(sql);
|
|
1203
|
+
if (!m) return UNKNOWN_NAME;
|
|
1204
|
+
const kind = m[1].toLowerCase().replace(/\s+/g, " ");
|
|
1205
|
+
const on = /^("(?:[^"]|"")+"|\S+)\s+ON\s+(?:DOMAIN\s+)?([\s\S]+)$/i.exec(m[2].trim());
|
|
1206
|
+
const object = on ? `${on[2].trim()}.${on[1]}` : m[2].trim();
|
|
1207
|
+
const name = object.split(/\.(?=(?:[^"]*"[^"]*")*[^"]*$)/).map(unquoted).join(".");
|
|
1208
|
+
return `${name} (${kind})`;
|
|
1209
|
+
}
|
|
1210
|
+
function extensionLabel(sql) {
|
|
1211
|
+
const name = /\bEXTENSION\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?("[^"]+"|[\w$-]+)/i.exec(sql)?.[1];
|
|
1212
|
+
const schema = /\bSCHEMA\s+("[^"]+"|[\w$]+)/i.exec(sql)?.[1];
|
|
1213
|
+
if (!name) return UNKNOWN_NAME;
|
|
1214
|
+
return schema ? `${unquoted(schema)}.${unquoted(name)}` : unquoted(name);
|
|
1215
|
+
}
|
|
1216
|
+
function schemaTitle(sql, downSql) {
|
|
1217
|
+
const m = /^\s*(CREATE|DROP|COMMENT\s+ON)\s+SCHEMA\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?("[^"]+"|[\w$]+)/i.exec(sql);
|
|
1218
|
+
if (!m) return void 0;
|
|
1219
|
+
const label = { CREATE: "Schema missing", DROP: "Extra schema" }[m[1].toUpperCase()];
|
|
1220
|
+
return label ? `${label}: ${unquoted(m[2])}` : `${commentChange(sql, downSql)}: schema ${unquoted(m[2])}`;
|
|
1221
|
+
}
|
|
1222
|
+
var CLEARS_COMMENT = /\bIS\s+NULL\s*;?\s*$/i;
|
|
1223
|
+
function commentChange(sql, downSql) {
|
|
1224
|
+
if (CLEARS_COMMENT.test(sql)) return "Extra comment";
|
|
1225
|
+
if (downSql && CLEARS_COMMENT.test(downSql)) return "Comment missing";
|
|
1226
|
+
return "Comment changed";
|
|
1227
|
+
}
|
|
1228
|
+
function summariseDataStatement(sql) {
|
|
1229
|
+
const table = extractQualifiedName(sql, /\b(?:INTO|FROM|UPDATE)\s+(?:ONLY\s+)?/i);
|
|
1230
|
+
const upper = sql.toUpperCase().trimStart();
|
|
1231
|
+
if (upper.startsWith("INSERT")) return `Missing row in ${table}`;
|
|
1232
|
+
if (upper.startsWith("DELETE")) return `Extra row in ${table}`;
|
|
1233
|
+
if (upper.startsWith("UPDATE")) return `Modified row in ${table}`;
|
|
1234
|
+
return `Data change in ${table}`;
|
|
1235
|
+
}
|
|
1236
|
+
function summariseStatement(sql, check, downSql) {
|
|
1237
|
+
if (check === "data") return summariseDataStatement(sql);
|
|
1238
|
+
const schema = schemaTitle(sql, downSql);
|
|
1239
|
+
if (schema) return schema;
|
|
1240
|
+
for (const rule of SCHEMA_RULES) {
|
|
1241
|
+
if (rule.match.test(sql)) {
|
|
1242
|
+
const label = rule.name === commentLabel ? commentChange(sql, downSql) : rule.label;
|
|
1243
|
+
return `${label}: ${qualifySchemaName(rule.name(sql, downSql))}`;
|
|
1244
|
+
}
|
|
1245
|
+
}
|
|
1246
|
+
return `Schema change: ${qualifySchemaName(
|
|
1247
|
+
extractQualifiedName(sql, /\b(?:TABLE|INTO|FROM|UPDATE)\s+(?:ONLY\s+)?/i)
|
|
1248
|
+
)}`;
|
|
1249
|
+
}
|
|
1250
|
+
function routineLabel(sql, downSql) {
|
|
1251
|
+
const name = extractRoutineName(sql);
|
|
1252
|
+
const args = extractRoutineArgs(sql);
|
|
1253
|
+
if (!downSql || name === UNKNOWN_NAME || name.includes(".")) return name + args;
|
|
1254
|
+
const counterpart = extractRoutineName(downSql);
|
|
1255
|
+
const sameRoutine = unqualify(counterpart) === unqualify(name);
|
|
1256
|
+
return (counterpart.includes(".") && sameRoutine ? counterpart : name) + args;
|
|
1257
|
+
}
|
|
1258
|
+
function unqualify(name) {
|
|
1259
|
+
return name.slice(name.lastIndexOf(".") + 1).toLowerCase();
|
|
1260
|
+
}
|
|
1261
|
+
function extractRoutineName(sql) {
|
|
1262
|
+
return extractQualifiedName(sql, /\b(?:FUNCTION|PROCEDURE)\s+(?:IF\s+EXISTS\s+)?/i);
|
|
1263
|
+
}
|
|
1264
|
+
var UNKNOWN_NAME = "unknown";
|
|
1265
|
+
function extractQualifiedName(sql, head) {
|
|
1266
|
+
const found = head.exec(sql);
|
|
1267
|
+
if (!found) return UNKNOWN_NAME;
|
|
1268
|
+
let rest = sql.slice(found.index + found[0].length);
|
|
1269
|
+
const parts = [];
|
|
1270
|
+
for (let depth = 0; depth < 2; depth++) {
|
|
1271
|
+
const ident = /^(?:"((?:[^"]|"")*)"|([\w$]+))/.exec(rest);
|
|
1272
|
+
if (!ident) break;
|
|
1273
|
+
parts.push(ident[1] !== void 0 ? ident[1].replace(/""/g, '"') : ident[2]);
|
|
1274
|
+
rest = rest.slice(ident[0].length);
|
|
1275
|
+
const dot = /^\s*\.\s*/.exec(rest);
|
|
1276
|
+
if (!dot) break;
|
|
1277
|
+
rest = rest.slice(dot[0].length);
|
|
1278
|
+
}
|
|
1279
|
+
return parts.length > 0 ? parts.join(".") : UNKNOWN_NAME;
|
|
1280
|
+
}
|
|
1281
|
+
function extractRoutineArgs(sql) {
|
|
1282
|
+
const open = sql.indexOf("(");
|
|
1283
|
+
if (open === -1) return "";
|
|
1284
|
+
let depth = 0;
|
|
1285
|
+
for (let i = open; i < sql.length; i++) {
|
|
1286
|
+
if (sql[i] === "(") depth++;
|
|
1287
|
+
else if (sql[i] === ")" && --depth === 0) return sql.slice(open, i + 1);
|
|
1288
|
+
}
|
|
1289
|
+
return "";
|
|
1290
|
+
}
|
|
1291
|
+
|
|
1292
|
+
export {
|
|
1293
|
+
parseStatements,
|
|
1294
|
+
sqlSkeleton,
|
|
1295
|
+
bareName,
|
|
1296
|
+
createdPolicies,
|
|
1297
|
+
createsOnlyPolicies,
|
|
1298
|
+
createdTriggers,
|
|
1299
|
+
createsOnlyTriggers,
|
|
1300
|
+
referencedTables,
|
|
1301
|
+
identifierMatcher,
|
|
1302
|
+
orderStatements,
|
|
1303
|
+
statementSubject,
|
|
1304
|
+
policyOnlyKeys,
|
|
1305
|
+
rolesNamedBy,
|
|
1306
|
+
runDbDiff,
|
|
1307
|
+
isDestructiveSql,
|
|
1308
|
+
destructiveReason,
|
|
1309
|
+
sqlToIssues
|
|
1310
|
+
};
|
|
1311
|
+
//# sourceMappingURL=chunk-BUOWHE36.js.map
|