@akal/supaforge 0.0.0-stage → 0.0.31
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 +134 -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-4OU7KO5Y.js +13 -0
- package/dist/chunk-4OU7KO5Y.js.map +1 -0
- package/dist/chunk-5QQBTLWO.js +642 -0
- package/dist/chunk-5QQBTLWO.js.map +1 -0
- package/dist/chunk-5Z3SAIQS.js +2807 -0
- package/dist/chunk-5Z3SAIQS.js.map +1 -0
- package/dist/chunk-6WAMNZLO.js +336 -0
- package/dist/chunk-6WAMNZLO.js.map +1 -0
- package/dist/chunk-BHYLBKYD.js +156 -0
- package/dist/chunk-BHYLBKYD.js.map +1 -0
- package/dist/chunk-BLKJWDTL.js +153 -0
- package/dist/chunk-BLKJWDTL.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-H5MJ5DFX.js +16 -0
- package/dist/chunk-H5MJ5DFX.js.map +1 -0
- package/dist/chunk-KIFJGON5.js +248 -0
- package/dist/chunk-KIFJGON5.js.map +1 -0
- package/dist/chunk-LQXF65MC.js +240 -0
- package/dist/chunk-LQXF65MC.js.map +1 -0
- package/dist/chunk-NXRSAVRU.js +478 -0
- package/dist/chunk-NXRSAVRU.js.map +1 -0
- package/dist/chunk-PARSNTBD.js +837 -0
- package/dist/chunk-PARSNTBD.js.map +1 -0
- package/dist/chunk-RRMI5CZD.js +376 -0
- package/dist/chunk-RRMI5CZD.js.map +1 -0
- package/dist/chunk-SF3YA42C.js +506 -0
- package/dist/chunk-SF3YA42C.js.map +1 -0
- package/dist/chunk-TQJSQLWA.js +574 -0
- package/dist/chunk-TQJSQLWA.js.map +1 -0
- package/dist/chunk-VMTBLHN2.js +122 -0
- package/dist/chunk-VMTBLHN2.js.map +1 -0
- package/dist/chunk-VOXZWQ3N.js +948 -0
- package/dist/chunk-VOXZWQ3N.js.map +1 -0
- package/dist/chunk-X6V2GGDZ.js +333 -0
- package/dist/chunk-X6V2GGDZ.js.map +1 -0
- package/dist/chunk-XMYMIURR.js +552 -0
- package/dist/chunk-XMYMIURR.js.map +1 -0
- package/dist/chunk-YVDSR4GM.js +1264 -0
- package/dist/chunk-YVDSR4GM.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 +65 -0
- package/dist/commands/diff.js +24 -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 +29 -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 +44 -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 +128 -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 +19 -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 +268 -0
- package/dist/commands/restore.js.map +1 -0
- package/dist/commands/snapshot.d.ts +33 -0
- package/dist/commands/snapshot.js +251 -0
- package/dist/commands/snapshot.js.map +1 -0
- package/dist/commands/sync.d.ts +16 -0
- package/dist/commands/sync.js +39 -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 +493 -0
- package/dist/index.js +147 -0
- package/dist/index.js.map +1 -0
- package/package.json +74 -4
|
@@ -0,0 +1,837 @@
|
|
|
1
|
+
import {
|
|
2
|
+
loadMigrations
|
|
3
|
+
} from "./chunk-KIFJGON5.js";
|
|
4
|
+
import {
|
|
5
|
+
ensureMigrationsTable,
|
|
6
|
+
getAppliedVersions
|
|
7
|
+
} from "./chunk-VMTBLHN2.js";
|
|
8
|
+
import {
|
|
9
|
+
dropUnsupportedSetStatements,
|
|
10
|
+
knownParameters
|
|
11
|
+
} from "./chunk-TQJSQLWA.js";
|
|
12
|
+
import {
|
|
13
|
+
ABSENT_ON_TARGET,
|
|
14
|
+
EXTENSION_UNAVAILABLE
|
|
15
|
+
} from "./chunk-H5MJ5DFX.js";
|
|
16
|
+
import {
|
|
17
|
+
rolesNamedBy,
|
|
18
|
+
sqlSkeleton,
|
|
19
|
+
statementSubject
|
|
20
|
+
} from "./chunk-RRMI5CZD.js";
|
|
21
|
+
import {
|
|
22
|
+
isCommentOnly,
|
|
23
|
+
isPsqlMetaCommand,
|
|
24
|
+
splitSqlStatements,
|
|
25
|
+
stripPsqlMetaCommands
|
|
26
|
+
} from "./chunk-G2DIPIYU.js";
|
|
27
|
+
import {
|
|
28
|
+
loadSnapshot
|
|
29
|
+
} from "./chunk-YVDSR4GM.js";
|
|
30
|
+
import {
|
|
31
|
+
errMsg,
|
|
32
|
+
pgClientConfig,
|
|
33
|
+
pgQuery,
|
|
34
|
+
quoteIdent,
|
|
35
|
+
quoteLiteral,
|
|
36
|
+
quoteName
|
|
37
|
+
} from "./chunk-X6V2GGDZ.js";
|
|
38
|
+
import {
|
|
39
|
+
DEFAULT_IGNORE_SCHEMAS,
|
|
40
|
+
MIGRATIONS_TABLE,
|
|
41
|
+
SUPABASE_PLATFORM_SCHEMAS
|
|
42
|
+
} from "./chunk-6WAMNZLO.js";
|
|
43
|
+
|
|
44
|
+
// src/restore.ts
|
|
45
|
+
import { readFile as readFile2, access } from "fs/promises";
|
|
46
|
+
import { constants } from "fs";
|
|
47
|
+
import { join as join2 } from "path";
|
|
48
|
+
import pg from "pg";
|
|
49
|
+
|
|
50
|
+
// src/restore-data.ts
|
|
51
|
+
import { readdir, readFile } from "fs/promises";
|
|
52
|
+
import { join } from "path";
|
|
53
|
+
async function dataTablesIn(dataDir) {
|
|
54
|
+
try {
|
|
55
|
+
return (await readdir(dataDir)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length)).sort();
|
|
56
|
+
} catch {
|
|
57
|
+
return [];
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
async function dataTablesInOrder(client, dataDir) {
|
|
61
|
+
return inDependencyOrder(client, await dataTablesIn(dataDir));
|
|
62
|
+
}
|
|
63
|
+
async function restoreTableRows(client, dataDir, table) {
|
|
64
|
+
const rows = await readFile(join(dataDir, `${table}.json`), "utf-8");
|
|
65
|
+
const inserted = await insertRows(client, quoteIdent(table), rows);
|
|
66
|
+
await resetSequences(client, quoteIdent(table));
|
|
67
|
+
return inserted;
|
|
68
|
+
}
|
|
69
|
+
async function restoreBuckets(client, file) {
|
|
70
|
+
const { rows: [present] } = await client.query(`SELECT to_regclass('storage.buckets') IS NOT NULL AS ok`);
|
|
71
|
+
if (!present?.ok) return void 0;
|
|
72
|
+
return insertRows(client, "storage.buckets", await readFile(file, "utf-8"));
|
|
73
|
+
}
|
|
74
|
+
async function insertRows(client, table, rows) {
|
|
75
|
+
const asText = rows.trimStart().startsWith("{");
|
|
76
|
+
const elements = asText ? `json_array_elements($1::json -> 'rows')` : `json_array_elements($1::json)`;
|
|
77
|
+
const { rows: keys } = await client.query(
|
|
78
|
+
`SELECT DISTINCT json_object_keys(e) AS key FROM ${elements} e`,
|
|
79
|
+
[rows]
|
|
80
|
+
);
|
|
81
|
+
if (keys.length === 0) return 0;
|
|
82
|
+
const { rows: columns } = await client.query(
|
|
83
|
+
`SELECT attname AS name, attidentity AS identity, attgenerated AS generated, format_type(atttypid, atttypmod) AS type
|
|
84
|
+
FROM pg_attribute WHERE attrelid = $1::regclass AND attnum > 0 AND NOT attisdropped ORDER BY attnum`,
|
|
85
|
+
[table]
|
|
86
|
+
);
|
|
87
|
+
const captured = new Set(keys.map((k) => k.key));
|
|
88
|
+
const usable = columns.filter((c) => c.generated === "" && captured.has(c.name));
|
|
89
|
+
const list = usable.map((c) => quoteName(c.name)).join(", ");
|
|
90
|
+
const overriding = usable.some((c) => c.identity === "a") ? " OVERRIDING SYSTEM VALUE" : "";
|
|
91
|
+
const select = asText ? `SELECT ${usable.map((c) => `(e ->> ${quoteLiteral(c.name)})::${c.type}`).join(", ")} FROM ${elements} e` : `SELECT ${list} FROM json_populate_recordset(NULL::${table}, $1::json)`;
|
|
92
|
+
const { rowCount } = await client.query(
|
|
93
|
+
`INSERT INTO ${table} (${list})${overriding} ${select} ON CONFLICT DO NOTHING`,
|
|
94
|
+
[rows]
|
|
95
|
+
);
|
|
96
|
+
return rowCount ?? 0;
|
|
97
|
+
}
|
|
98
|
+
async function resetSequences(client, table) {
|
|
99
|
+
const { rows } = await client.query(
|
|
100
|
+
`SELECT pg_get_serial_sequence($1, attname) AS seq, attname AS col
|
|
101
|
+
FROM pg_attribute WHERE attrelid = $1::regclass AND attnum > 0 AND NOT attisdropped
|
|
102
|
+
AND pg_get_serial_sequence($1, attname) IS NOT NULL`,
|
|
103
|
+
[table]
|
|
104
|
+
);
|
|
105
|
+
for (const { seq, col } of rows) {
|
|
106
|
+
await client.query(
|
|
107
|
+
`SELECT setval($1, coalesce((SELECT max(${quoteName(col)}) FROM ${table}), 1),
|
|
108
|
+
(SELECT max(${quoteName(col)}) FROM ${table}) IS NOT NULL)`,
|
|
109
|
+
[seq]
|
|
110
|
+
);
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
async function inDependencyOrder(client, tables) {
|
|
114
|
+
const { rows: oids } = await client.query(
|
|
115
|
+
`SELECT t AS name, to_regclass(q)::oid::text AS oid FROM unnest($1::text[], $2::text[]) AS u(t, q)`,
|
|
116
|
+
[tables, tables.map(quoteIdent)]
|
|
117
|
+
);
|
|
118
|
+
const byOid = new Map(oids.filter((r) => r.oid).map((r) => [r.oid, r.name]));
|
|
119
|
+
const { rows: keys } = await client.query(
|
|
120
|
+
`SELECT conrelid::text AS child, confrelid::text AS parent FROM pg_constraint
|
|
121
|
+
WHERE contype = 'f' AND conrelid::text = ANY($1) AND confrelid::text = ANY($1) AND conrelid <> confrelid`,
|
|
122
|
+
[[...byOid.keys()]]
|
|
123
|
+
);
|
|
124
|
+
const parents = new Map(tables.map((t) => [t, /* @__PURE__ */ new Set()]));
|
|
125
|
+
for (const { child, parent } of keys) parents.get(byOid.get(child))?.add(byOid.get(parent));
|
|
126
|
+
const ordered = [];
|
|
127
|
+
const placed = /* @__PURE__ */ new Set();
|
|
128
|
+
while (ordered.length < tables.length) {
|
|
129
|
+
const ready = tables.filter((t) => !placed.has(t) && [...parents.get(t)].every((p) => placed.has(p)));
|
|
130
|
+
for (const t of ready.length > 0 ? ready : tables.filter((t2) => !placed.has(t2))) {
|
|
131
|
+
ordered.push(t);
|
|
132
|
+
placed.add(t);
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
return ordered;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
// src/restore-replace.ts
|
|
139
|
+
var NEVER_CLEARED = new Set(SUPABASE_PLATFORM_SCHEMAS);
|
|
140
|
+
function replaceableSchemas(snapshotSchemas) {
|
|
141
|
+
return snapshotSchemas.filter((s) => !NEVER_CLEARED.has(s) && !s.startsWith("pg_"));
|
|
142
|
+
}
|
|
143
|
+
async function findExternalDependents(client, schemas) {
|
|
144
|
+
if (schemas.length === 0) return { recreate: [], blockers: [] };
|
|
145
|
+
const { rows: [{ search_path: previous }] } = await client.query(
|
|
146
|
+
"SHOW search_path"
|
|
147
|
+
);
|
|
148
|
+
await client.query(`SELECT set_config('search_path', '', false)`);
|
|
149
|
+
try {
|
|
150
|
+
const { rows } = await client.query(EXTERNAL_DEPENDENTS_SQL, [schemas]);
|
|
151
|
+
const recreate = [];
|
|
152
|
+
const blockers = [];
|
|
153
|
+
const seen = /* @__PURE__ */ new Set();
|
|
154
|
+
for (const row of rows) {
|
|
155
|
+
if (seen.has(row.identity)) continue;
|
|
156
|
+
seen.add(row.identity);
|
|
157
|
+
if (row.kind === "trigger" && row.trigger_ddl) {
|
|
158
|
+
recreate.push({
|
|
159
|
+
kind: "trigger",
|
|
160
|
+
schema: row.table_schema,
|
|
161
|
+
table: row.table_name,
|
|
162
|
+
name: row.object_name,
|
|
163
|
+
ddl: `${row.trigger_ddl};`
|
|
164
|
+
});
|
|
165
|
+
} else if (row.kind === "policy" && row.policy_ddl) {
|
|
166
|
+
recreate.push({
|
|
167
|
+
kind: "policy",
|
|
168
|
+
schema: row.table_schema,
|
|
169
|
+
table: row.table_name,
|
|
170
|
+
name: row.object_name,
|
|
171
|
+
ddl: `${row.policy_ddl};`
|
|
172
|
+
});
|
|
173
|
+
} else {
|
|
174
|
+
blockers.push(`${row.kind} ${row.identity}`);
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
return { recreate, blockers };
|
|
178
|
+
} finally {
|
|
179
|
+
await client.query(`SELECT set_config('search_path', $1, false)`, [previous]);
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
var EXTERNAL_DEPENDENTS_SQL = `
|
|
183
|
+
-- What clearing drops: everything in the schemas except extension members,
|
|
184
|
+
-- which dropSchemaContents leaves in place. Counting those would refuse a
|
|
185
|
+
-- --force over, say, an auth default calling public.uuid_generate_v4()
|
|
186
|
+
-- from an extension installed in public, which is never dropped.
|
|
187
|
+
WITH members AS (
|
|
188
|
+
SELECT objid FROM pg_depend WHERE deptype = 'e'
|
|
189
|
+
),
|
|
190
|
+
inside AS (
|
|
191
|
+
SELECT c.oid, 'pg_class'::regclass AS classid
|
|
192
|
+
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
193
|
+
WHERE n.nspname = ANY($1) AND c.oid NOT IN (SELECT objid FROM members)
|
|
194
|
+
UNION ALL
|
|
195
|
+
SELECT p.oid, 'pg_proc'::regclass
|
|
196
|
+
FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
|
|
197
|
+
WHERE n.nspname = ANY($1) AND p.oid NOT IN (SELECT objid FROM members)
|
|
198
|
+
UNION ALL
|
|
199
|
+
SELECT t.oid, 'pg_type'::regclass
|
|
200
|
+
FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace
|
|
201
|
+
WHERE n.nspname = ANY($1) AND t.oid NOT IN (SELECT objid FROM members)
|
|
202
|
+
),
|
|
203
|
+
dependents AS (
|
|
204
|
+
SELECT DISTINCT d.classid, d.objid, d.objsubid
|
|
205
|
+
FROM pg_depend d
|
|
206
|
+
JOIN inside i ON i.oid = d.refobjid AND i.classid = d.refclassid
|
|
207
|
+
WHERE d.deptype = 'n'
|
|
208
|
+
)
|
|
209
|
+
SELECT o.type AS kind, o.identity, o.schema,
|
|
210
|
+
CASE WHEN dep.classid = 'pg_trigger'::regclass
|
|
211
|
+
THEN pg_get_triggerdef(dep.objid) END AS trigger_ddl,
|
|
212
|
+
CASE WHEN dep.classid = 'pg_policy'::regclass THEN (
|
|
213
|
+
SELECT format('CREATE POLICY %I ON %I.%I AS %s FOR %s TO %s%s%s',
|
|
214
|
+
p.polname, pn.nspname, pc.relname,
|
|
215
|
+
CASE WHEN p.polpermissive THEN 'PERMISSIVE' ELSE 'RESTRICTIVE' END,
|
|
216
|
+
CASE p.polcmd WHEN 'r' THEN 'SELECT' WHEN 'a' THEN 'INSERT'
|
|
217
|
+
WHEN 'w' THEN 'UPDATE' WHEN 'd' THEN 'DELETE' ELSE 'ALL' END,
|
|
218
|
+
CASE WHEN p.polroles = '{0}' THEN 'PUBLIC'
|
|
219
|
+
ELSE (SELECT string_agg(quote_ident(r.rolname), ', ' ORDER BY r.rolname)
|
|
220
|
+
FROM pg_roles r WHERE r.oid = ANY (p.polroles)) END,
|
|
221
|
+
CASE WHEN p.polqual IS NOT NULL
|
|
222
|
+
THEN ' USING (' || pg_get_expr(p.polqual, p.polrelid) || ')' ELSE '' END,
|
|
223
|
+
CASE WHEN p.polwithcheck IS NOT NULL
|
|
224
|
+
THEN ' WITH CHECK (' || pg_get_expr(p.polwithcheck, p.polrelid) || ')' ELSE '' END)
|
|
225
|
+
FROM pg_policy p
|
|
226
|
+
JOIN pg_class pc ON pc.oid = p.polrelid
|
|
227
|
+
JOIN pg_namespace pn ON pn.oid = pc.relnamespace
|
|
228
|
+
WHERE p.oid = dep.objid) END AS policy_ddl,
|
|
229
|
+
COALESCE(tn.nspname, pn.nspname) AS table_schema,
|
|
230
|
+
COALESCE(tc.relname, pc.relname) AS table_name,
|
|
231
|
+
COALESCE(t.tgname, p.polname) AS object_name
|
|
232
|
+
FROM dependents dep
|
|
233
|
+
CROSS JOIN LATERAL pg_identify_object(dep.classid, dep.objid, dep.objsubid) o
|
|
234
|
+
LEFT JOIN pg_trigger t ON dep.classid = 'pg_trigger'::regclass AND t.oid = dep.objid
|
|
235
|
+
LEFT JOIN pg_class tc ON tc.oid = t.tgrelid
|
|
236
|
+
LEFT JOIN pg_namespace tn ON tn.oid = tc.relnamespace
|
|
237
|
+
LEFT JOIN pg_policy p ON dep.classid = 'pg_policy'::regclass AND p.oid = dep.objid
|
|
238
|
+
LEFT JOIN pg_class pc ON pc.oid = p.polrelid
|
|
239
|
+
LEFT JOIN pg_namespace pn ON pn.oid = pc.relnamespace
|
|
240
|
+
-- The schema an object lives in. pg_identify_object reports none for a
|
|
241
|
+
-- trigger, policy, rule or column default, which belong to their
|
|
242
|
+
-- relation's schema: read as "no schema", every view, default, policy and
|
|
243
|
+
-- trigger inside the cleared schemas looked like an outside dependent \u2014
|
|
244
|
+
-- refusing a --force over any table with a serial column, and putting
|
|
245
|
+
-- back policies the snapshot had removed.
|
|
246
|
+
CROSS JOIN LATERAL (
|
|
247
|
+
SELECT COALESCE(
|
|
248
|
+
tn.nspname,
|
|
249
|
+
pn.nspname,
|
|
250
|
+
(SELECT n.nspname FROM pg_attrdef ad JOIN pg_class c ON c.oid = ad.adrelid
|
|
251
|
+
JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
252
|
+
WHERE dep.classid = 'pg_attrdef'::regclass AND ad.oid = dep.objid),
|
|
253
|
+
(SELECT n.nspname FROM pg_rewrite r JOIN pg_class c ON c.oid = r.ev_class
|
|
254
|
+
JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
255
|
+
WHERE dep.classid = 'pg_rewrite'::regclass AND r.oid = dep.objid),
|
|
256
|
+
(SELECT n.nspname FROM pg_constraint k
|
|
257
|
+
LEFT JOIN pg_class c ON c.oid = k.conrelid
|
|
258
|
+
LEFT JOIN pg_type ty ON ty.oid = k.contypid
|
|
259
|
+
JOIN pg_namespace n ON n.oid = COALESCE(c.relnamespace, ty.typnamespace)
|
|
260
|
+
WHERE dep.classid = 'pg_constraint'::regclass AND k.oid = dep.objid),
|
|
261
|
+
o.schema
|
|
262
|
+
) AS schema
|
|
263
|
+
) owner
|
|
264
|
+
WHERE owner.schema IS NULL OR NOT (owner.schema = ANY($1))
|
|
265
|
+
ORDER BY o.type, o.identity
|
|
266
|
+
`;
|
|
267
|
+
async function dropSchemaContents(client, schemas) {
|
|
268
|
+
if (schemas.length === 0) return 0;
|
|
269
|
+
const { rows } = await client.query(DROP_CONTENTS_SQL, [schemas]);
|
|
270
|
+
for (const { statement } of rows) {
|
|
271
|
+
await client.query(statement);
|
|
272
|
+
}
|
|
273
|
+
return rows.length;
|
|
274
|
+
}
|
|
275
|
+
var DROP_CONTENTS_SQL = `
|
|
276
|
+
WITH members AS (
|
|
277
|
+
SELECT objid FROM pg_depend WHERE deptype = 'e'
|
|
278
|
+
)
|
|
279
|
+
SELECT statement FROM (
|
|
280
|
+
SELECT 1 AS phase, format('DROP %s IF EXISTS %I.%I CASCADE',
|
|
281
|
+
CASE c.relkind WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'MATERIALIZED VIEW'
|
|
282
|
+
WHEN 'f' THEN 'FOREIGN TABLE' WHEN 'S' THEN 'SEQUENCE'
|
|
283
|
+
ELSE 'TABLE' END,
|
|
284
|
+
n.nspname, c.relname) AS statement,
|
|
285
|
+
n.nspname || '.' || c.relname AS sort_key
|
|
286
|
+
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
287
|
+
WHERE n.nspname = ANY($1)
|
|
288
|
+
AND c.relkind IN ('r', 'p', 'v', 'm', 'f', 'S')
|
|
289
|
+
AND c.oid NOT IN (SELECT objid FROM members)
|
|
290
|
+
UNION ALL
|
|
291
|
+
SELECT 2, format('DROP %s IF EXISTS %s CASCADE',
|
|
292
|
+
CASE p.prokind WHEN 'a' THEN 'AGGREGATE' WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END,
|
|
293
|
+
p.oid::regprocedure::text),
|
|
294
|
+
p.oid::regprocedure::text
|
|
295
|
+
FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
|
|
296
|
+
WHERE n.nspname = ANY($1)
|
|
297
|
+
AND p.oid NOT IN (SELECT objid FROM members)
|
|
298
|
+
UNION ALL
|
|
299
|
+
SELECT 3, format('DROP %s IF EXISTS %I.%I CASCADE',
|
|
300
|
+
CASE t.typtype WHEN 'd' THEN 'DOMAIN' ELSE 'TYPE' END, n.nspname, t.typname),
|
|
301
|
+
n.nspname || '.' || t.typname
|
|
302
|
+
FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace
|
|
303
|
+
WHERE n.nspname = ANY($1)
|
|
304
|
+
AND t.typtype IN ('e', 'd', 'r', 'm', 'c')
|
|
305
|
+
AND (t.typtype <> 'c' OR (SELECT relkind FROM pg_class WHERE oid = t.typrelid) = 'c')
|
|
306
|
+
AND t.oid NOT IN (SELECT objid FROM members)
|
|
307
|
+
) s
|
|
308
|
+
ORDER BY phase, sort_key
|
|
309
|
+
`;
|
|
310
|
+
async function recreateExternalDependents(client, dependents) {
|
|
311
|
+
const recreated = [];
|
|
312
|
+
for (const dep of dependents) {
|
|
313
|
+
const exists = dep.kind === "trigger" ? `SELECT 1 FROM pg_trigger t JOIN pg_class c ON c.oid = t.tgrelid
|
|
314
|
+
JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
315
|
+
WHERE n.nspname = $1 AND c.relname = $2 AND t.tgname = $3` : `SELECT 1 FROM pg_policies WHERE schemaname = $1 AND tablename = $2 AND policyname = $3`;
|
|
316
|
+
const { rows } = await client.query(exists, [dep.schema, dep.table, dep.name]);
|
|
317
|
+
if (rows.length > 0) continue;
|
|
318
|
+
await client.query(dep.ddl);
|
|
319
|
+
recreated.push(dep);
|
|
320
|
+
}
|
|
321
|
+
return recreated;
|
|
322
|
+
}
|
|
323
|
+
async function resetRelationGrants(client, schemas) {
|
|
324
|
+
if (schemas.length === 0) return 0;
|
|
325
|
+
const { rows } = await client.query(`
|
|
326
|
+
SELECT format('REVOKE ALL ON %s FROM %s', c.oid::regclass,
|
|
327
|
+
string_agg(DISTINCT CASE WHEN a.grantee = 0 THEN 'PUBLIC'
|
|
328
|
+
ELSE quote_ident(pg_get_userbyid(a.grantee)) END, ', ')) AS statement
|
|
329
|
+
FROM pg_class c
|
|
330
|
+
JOIN pg_namespace n ON n.oid = c.relnamespace
|
|
331
|
+
CROSS JOIN LATERAL aclexplode(c.relacl) a
|
|
332
|
+
WHERE n.nspname = ANY($1)
|
|
333
|
+
AND c.relkind IN ('r', 'p', 'v', 'f')
|
|
334
|
+
AND a.grantee <> c.relowner
|
|
335
|
+
GROUP BY c.oid
|
|
336
|
+
`, [schemas]);
|
|
337
|
+
for (const { statement } of rows) await client.query(statement);
|
|
338
|
+
return rows.length;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
// src/restore.ts
|
|
342
|
+
async function getPublicTables(targetUrl) {
|
|
343
|
+
const ignoreList = DEFAULT_IGNORE_SCHEMAS.map((s) => `'${s}'`).join(", ");
|
|
344
|
+
const client = new pg.Client(pgClientConfig(targetUrl));
|
|
345
|
+
await client.connect();
|
|
346
|
+
try {
|
|
347
|
+
const { rows } = await client.query(
|
|
348
|
+
`SELECT tablename FROM pg_tables
|
|
349
|
+
WHERE schemaname = 'public'
|
|
350
|
+
AND schemaname NOT IN (${ignoreList})
|
|
351
|
+
ORDER BY tablename`
|
|
352
|
+
);
|
|
353
|
+
return rows.map((r) => r.tablename);
|
|
354
|
+
} finally {
|
|
355
|
+
await client.end();
|
|
356
|
+
}
|
|
357
|
+
}
|
|
358
|
+
async function restoreFromSnapshot(options) {
|
|
359
|
+
if (!options.snapshotDir) throw new Error("snapshotDir is required for snapshot restore");
|
|
360
|
+
const result = { applied: [], skipped: [], errors: [], mode: "snapshot" };
|
|
361
|
+
const manifest = await loadSnapshot(options.snapshotDir);
|
|
362
|
+
const sqlOrder = RESTORE_SQL_ORDER;
|
|
363
|
+
const client = new pg.Client(pgClientConfig(options.targetUrl));
|
|
364
|
+
await client.connect();
|
|
365
|
+
const transactional = !options.noTransaction;
|
|
366
|
+
if (transactional) await client.query("BEGIN");
|
|
367
|
+
const missing = /* @__PURE__ */ new Set();
|
|
368
|
+
const createdBySchemaLayer = /* @__PURE__ */ new Set();
|
|
369
|
+
let external = [];
|
|
370
|
+
const { rows: [{ search_path: sessionSearchPath }] } = await client.query("SHOW search_path");
|
|
371
|
+
try {
|
|
372
|
+
if (options.replace) {
|
|
373
|
+
const schemas = replaceableSchemas(await schemasInSnapshot(options.snapshotDir));
|
|
374
|
+
const dependents = await findExternalDependents(client, schemas);
|
|
375
|
+
if (dependents.blockers.length > 0) {
|
|
376
|
+
result.errors.push({
|
|
377
|
+
type: "sql",
|
|
378
|
+
label: "Restore --force",
|
|
379
|
+
error: `clearing ${schemas.join(", ")} would also drop objects outside them that this restore cannot put back: ${dependents.blockers.join("; ")}. Nothing was changed. Remove or move those first, or restore into an empty database.`
|
|
380
|
+
});
|
|
381
|
+
throw new RestoreAborted();
|
|
382
|
+
}
|
|
383
|
+
external = dependents.recreate;
|
|
384
|
+
const dropped = await dropSchemaContents(client, schemas);
|
|
385
|
+
result.applied.push({
|
|
386
|
+
type: "sql",
|
|
387
|
+
label: `Cleared ${dropped} object(s) from ${schemas.join(", ")} (--force)`
|
|
388
|
+
});
|
|
389
|
+
}
|
|
390
|
+
for (const layer of sqlOrder) {
|
|
391
|
+
const file = layerRestoreFile(layer);
|
|
392
|
+
const info = manifest.layers[layer === "storage-policies" ? "storage" : layer];
|
|
393
|
+
if (!info?.captured) {
|
|
394
|
+
result.skipped.push({ type: "sql", label: `Layer: ${layer}`, reason: "Not captured in snapshot" });
|
|
395
|
+
continue;
|
|
396
|
+
}
|
|
397
|
+
if (layer === "schema" && !await isReadable(join2(options.snapshotDir, file))) {
|
|
398
|
+
result.skipped.push({
|
|
399
|
+
type: "sql",
|
|
400
|
+
label: `Layer: ${layer}`,
|
|
401
|
+
reason: info.sqlSkipReason ?? "this snapshot has no schema.sql \u2014 it predates one being written, so the schema cannot be replayed. Use `supaforge clone`, or `restore --from-migrations`."
|
|
402
|
+
});
|
|
403
|
+
continue;
|
|
404
|
+
}
|
|
405
|
+
try {
|
|
406
|
+
const raw = await readFile2(join2(options.snapshotDir, file), "utf-8");
|
|
407
|
+
const content = layer === "schema" ? await replayableSchemaSql(raw, options.targetUrl) : raw;
|
|
408
|
+
let statements = extractExecutableStatements(content);
|
|
409
|
+
if (layer === "roles") {
|
|
410
|
+
const reset = await resetRelationGrants(
|
|
411
|
+
client,
|
|
412
|
+
replaceableSchemas(await schemasInSnapshot(options.snapshotDir))
|
|
413
|
+
);
|
|
414
|
+
if (reset > 0) {
|
|
415
|
+
result.applied.push({ type: "sql", label: `Reset grants on ${reset} relation(s) before replaying the captured ones` });
|
|
416
|
+
}
|
|
417
|
+
}
|
|
418
|
+
statements = statements.filter((sql) => {
|
|
419
|
+
const owner = platformOwnedObject(sql);
|
|
420
|
+
if (owner === void 0) return true;
|
|
421
|
+
result.skipped.push({
|
|
422
|
+
type: "sql",
|
|
423
|
+
label: summarizeStatement(sql),
|
|
424
|
+
reason: `${owner} is managed by the platform and cannot be recreated here`
|
|
425
|
+
});
|
|
426
|
+
return false;
|
|
427
|
+
});
|
|
428
|
+
if (layer === "webhooks") {
|
|
429
|
+
statements = statements.filter((sql) => {
|
|
430
|
+
if (!createdBySchemaLayer.has(webhookTriggerKey(sql) ?? "")) return true;
|
|
431
|
+
result.skipped.push({
|
|
432
|
+
type: "sql",
|
|
433
|
+
label: summarizeStatement(sql),
|
|
434
|
+
reason: "already created by the schema layer"
|
|
435
|
+
});
|
|
436
|
+
return false;
|
|
437
|
+
});
|
|
438
|
+
}
|
|
439
|
+
if (layer === "schema") {
|
|
440
|
+
for (const sql of statements) {
|
|
441
|
+
const key = webhookTriggerKey(sql);
|
|
442
|
+
if (key) createdBySchemaLayer.add(key);
|
|
443
|
+
}
|
|
444
|
+
}
|
|
445
|
+
for (const sql of statements) {
|
|
446
|
+
await applyStatement(client, sql, transactional, result, missing);
|
|
447
|
+
}
|
|
448
|
+
} catch (err) {
|
|
449
|
+
if (err instanceof RestoreAborted) throw err;
|
|
450
|
+
result.skipped.push({ type: "sql", label: `Layer: ${layer}`, reason: "File not readable" });
|
|
451
|
+
}
|
|
452
|
+
await client.query(`SELECT set_config('search_path', $1, false)`, [sessionSearchPath]);
|
|
453
|
+
}
|
|
454
|
+
await restoreRows(client, options.snapshotDir, manifest, result, transactional);
|
|
455
|
+
for (const dep of await recreateExternalDependents(client, external)) {
|
|
456
|
+
result.applied.push({
|
|
457
|
+
type: "sql",
|
|
458
|
+
label: `Recreated ${dep.kind} ${dep.name} on ${dep.schema}.${dep.table} (outside the snapshot, dropped by --force)`
|
|
459
|
+
});
|
|
460
|
+
}
|
|
461
|
+
if (transactional) {
|
|
462
|
+
if (result.errors.length > 0) {
|
|
463
|
+
await client.query("ROLLBACK");
|
|
464
|
+
result.rolledBack = result.applied;
|
|
465
|
+
result.applied = [];
|
|
466
|
+
delete result.incomplete;
|
|
467
|
+
} else {
|
|
468
|
+
await client.query("COMMIT");
|
|
469
|
+
}
|
|
470
|
+
}
|
|
471
|
+
} catch (err) {
|
|
472
|
+
if (transactional) {
|
|
473
|
+
await client.query("ROLLBACK").catch(() => void 0);
|
|
474
|
+
result.rolledBack = result.applied;
|
|
475
|
+
result.applied = [];
|
|
476
|
+
delete result.incomplete;
|
|
477
|
+
}
|
|
478
|
+
if (!(err instanceof RestoreAborted)) {
|
|
479
|
+
result.errors.push({ type: "sql", label: "Restore", error: errMsg(err) });
|
|
480
|
+
}
|
|
481
|
+
} finally {
|
|
482
|
+
await client.end();
|
|
483
|
+
}
|
|
484
|
+
for (const note of MANUAL_LAYERS) {
|
|
485
|
+
if (manifest.layers[note.layer]?.captured) {
|
|
486
|
+
result.skipped.push({ type: note.type, label: note.label, reason: note.reason });
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
return result;
|
|
490
|
+
}
|
|
491
|
+
async function restoreRows(client, snapshotDir, manifest, result, transactional) {
|
|
492
|
+
const attempt = async (label, run) => {
|
|
493
|
+
if (transactional) await client.query("SAVEPOINT sf_restore_rows");
|
|
494
|
+
try {
|
|
495
|
+
const done = await run();
|
|
496
|
+
if (done) result.applied.push({ type: "sql", label: `${label}: ${done}` });
|
|
497
|
+
} catch (err) {
|
|
498
|
+
if (transactional) await client.query("ROLLBACK TO SAVEPOINT sf_restore_rows");
|
|
499
|
+
result.errors.push({ type: "sql", label, error: errMsg(err) });
|
|
500
|
+
if (transactional) throw new RestoreAborted();
|
|
501
|
+
}
|
|
502
|
+
};
|
|
503
|
+
if (manifest.layers.data?.captured) {
|
|
504
|
+
const dataDir = join2(snapshotDir, "data");
|
|
505
|
+
for (const table of await dataTablesInOrder(client, dataDir)) {
|
|
506
|
+
await attempt(`Data: ${table}`, async () => `${await restoreTableRows(client, dataDir, table)} row(s)`);
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
const buckets = join2(snapshotDir, "storage-buckets.json");
|
|
510
|
+
if (manifest.layers.storage?.captured && await isReadable(buckets)) {
|
|
511
|
+
await attempt("Storage buckets", async () => {
|
|
512
|
+
const created = await restoreBuckets(client, buckets);
|
|
513
|
+
if (created === void 0) {
|
|
514
|
+
result.skipped.push({ type: "api", label: "Storage buckets", reason: "this target has no storage schema to hold them" });
|
|
515
|
+
return void 0;
|
|
516
|
+
}
|
|
517
|
+
return `${created} created; objects are never transferred`;
|
|
518
|
+
});
|
|
519
|
+
}
|
|
520
|
+
}
|
|
521
|
+
var MANUAL_LAYERS = [
|
|
522
|
+
{
|
|
523
|
+
layer: "auth",
|
|
524
|
+
type: "api",
|
|
525
|
+
label: "Auth config",
|
|
526
|
+
reason: "Requires --project-ref and --api-key to restore via Management API"
|
|
527
|
+
},
|
|
528
|
+
{
|
|
529
|
+
layer: "edge-functions",
|
|
530
|
+
type: "api",
|
|
531
|
+
label: "Edge Functions",
|
|
532
|
+
reason: 'Deploy via "supabase functions deploy" from your local functions directory'
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
layer: "vault",
|
|
536
|
+
type: "sql",
|
|
537
|
+
label: "Vault secrets",
|
|
538
|
+
reason: "vault.sql lists the secret names only \u2014 a value cannot be read out of Vault, so each must be recreated by hand with vault.create_secret"
|
|
539
|
+
}
|
|
540
|
+
];
|
|
541
|
+
async function restoreFromMigrations(options) {
|
|
542
|
+
const cwd = options.cwd ?? process.cwd();
|
|
543
|
+
const result = { applied: [], skipped: [], errors: [], mode: "migrations" };
|
|
544
|
+
const queryFn = options.queryFn ?? pgQuery;
|
|
545
|
+
const migrations = await loadMigrations(cwd);
|
|
546
|
+
if (migrations.length === 0) {
|
|
547
|
+
result.skipped.push({ type: "sql", label: "No migrations", reason: "No migration files found in .supaforge/migrations/" });
|
|
548
|
+
return result;
|
|
549
|
+
}
|
|
550
|
+
let filtered = migrations;
|
|
551
|
+
if (options.fromVersion) {
|
|
552
|
+
filtered = filtered.filter((m) => m.version >= options.fromVersion);
|
|
553
|
+
}
|
|
554
|
+
if (options.toVersion) {
|
|
555
|
+
filtered = filtered.filter((m) => m.version <= options.toVersion);
|
|
556
|
+
}
|
|
557
|
+
const client = new pg.Client(pgClientConfig(options.targetUrl));
|
|
558
|
+
await client.connect();
|
|
559
|
+
try {
|
|
560
|
+
await ensureMigrationsTable(options.targetUrl, queryFn);
|
|
561
|
+
const legacy = await findLegacyTrackingTable(client);
|
|
562
|
+
if (legacy) {
|
|
563
|
+
result.skipped.push({
|
|
564
|
+
type: "sql",
|
|
565
|
+
label: "public._supaforge_migrations",
|
|
566
|
+
reason: "left over from an earlier version and reachable with the anon key \u2014 tracking has moved to supabase_migrations.schema_migrations. Drop it: DROP TABLE public._supaforge_migrations;"
|
|
567
|
+
});
|
|
568
|
+
}
|
|
569
|
+
const applied = await getAppliedVersions(options.targetUrl, queryFn);
|
|
570
|
+
for (const migration of filtered) {
|
|
571
|
+
if (applied.has(migration.version)) {
|
|
572
|
+
result.skipped.push({ type: "sql", label: `v${migration.version}`, reason: "Already applied" });
|
|
573
|
+
continue;
|
|
574
|
+
}
|
|
575
|
+
let ran = 0;
|
|
576
|
+
for (const sql of migration.up.sql) {
|
|
577
|
+
if (isCommentOnly(sql)) continue;
|
|
578
|
+
try {
|
|
579
|
+
await client.query(sql);
|
|
580
|
+
ran++;
|
|
581
|
+
result.applied.push({ type: "sql", label: summarizeStatement(sql) });
|
|
582
|
+
} catch (err) {
|
|
583
|
+
result.errors.push({
|
|
584
|
+
type: "sql",
|
|
585
|
+
label: summarizeStatement(sql),
|
|
586
|
+
error: errMsg(err)
|
|
587
|
+
});
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
if (ran === 0) {
|
|
591
|
+
result.skipped.push({
|
|
592
|
+
type: "sql",
|
|
593
|
+
label: `v${migration.version}`,
|
|
594
|
+
reason: "carries no SQL to apply, so it was not recorded as applied. Snapshot-derived migrations hold no schema DDL \u2014 use `supaforge clone`, or restore from a snapshot, to build structure."
|
|
595
|
+
});
|
|
596
|
+
continue;
|
|
597
|
+
}
|
|
598
|
+
await queryFn(
|
|
599
|
+
options.targetUrl,
|
|
600
|
+
`INSERT INTO ${MIGRATIONS_TABLE} (version, name, statements)
|
|
601
|
+
VALUES ($1, $2, '{}')
|
|
602
|
+
ON CONFLICT (version) DO NOTHING`,
|
|
603
|
+
[migration.version, migration.description]
|
|
604
|
+
);
|
|
605
|
+
}
|
|
606
|
+
} finally {
|
|
607
|
+
await client.end();
|
|
608
|
+
}
|
|
609
|
+
return result;
|
|
610
|
+
}
|
|
611
|
+
async function previewSnapshotRestore(snapshotDir) {
|
|
612
|
+
const manifest = await loadSnapshot(snapshotDir);
|
|
613
|
+
const preview = [];
|
|
614
|
+
const sqlOrder = RESTORE_SQL_ORDER;
|
|
615
|
+
for (const layer of sqlOrder) {
|
|
616
|
+
const file = layerRestoreFile(layer);
|
|
617
|
+
const info = manifest.layers[layer === "storage-policies" ? "storage" : layer];
|
|
618
|
+
if (!info?.captured) continue;
|
|
619
|
+
try {
|
|
620
|
+
const content = await readFile2(join2(snapshotDir, file), "utf-8");
|
|
621
|
+
const statements = extractExecutableStatements(content);
|
|
622
|
+
if (statements.length > 0) {
|
|
623
|
+
preview.push({ layer, statements });
|
|
624
|
+
}
|
|
625
|
+
} catch {
|
|
626
|
+
}
|
|
627
|
+
}
|
|
628
|
+
return preview;
|
|
629
|
+
}
|
|
630
|
+
async function previewMigrationRestore(cwd = process.cwd(), toVersion, fromVersion) {
|
|
631
|
+
let migrations = await loadMigrations(cwd);
|
|
632
|
+
if (fromVersion) migrations = migrations.filter((m) => m.version >= fromVersion);
|
|
633
|
+
if (toVersion) migrations = migrations.filter((m) => m.version <= toVersion);
|
|
634
|
+
return migrations;
|
|
635
|
+
}
|
|
636
|
+
async function isReadable(path) {
|
|
637
|
+
try {
|
|
638
|
+
await access(path, constants.R_OK);
|
|
639
|
+
return true;
|
|
640
|
+
} catch {
|
|
641
|
+
return false;
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
async function replayableSchemaSql(sql, targetUrl) {
|
|
645
|
+
try {
|
|
646
|
+
return dropUnsupportedSetStatements(sql, await knownParameters(targetUrl)).sql;
|
|
647
|
+
} catch {
|
|
648
|
+
return sql;
|
|
649
|
+
}
|
|
650
|
+
}
|
|
651
|
+
var RESTORE_SQL_ORDER = [
|
|
652
|
+
"extensions",
|
|
653
|
+
"schema",
|
|
654
|
+
"rls",
|
|
655
|
+
"cron",
|
|
656
|
+
"webhooks",
|
|
657
|
+
"storage-policies",
|
|
658
|
+
"realtime",
|
|
659
|
+
"roles"
|
|
660
|
+
];
|
|
661
|
+
function layerRestoreFile(layer) {
|
|
662
|
+
switch (layer) {
|
|
663
|
+
case "extensions":
|
|
664
|
+
return "extensions.sql";
|
|
665
|
+
case "schema":
|
|
666
|
+
return "schema.sql";
|
|
667
|
+
case "rls":
|
|
668
|
+
return "rls.sql";
|
|
669
|
+
case "cron":
|
|
670
|
+
return "cron.sql";
|
|
671
|
+
case "webhooks":
|
|
672
|
+
return "webhooks.sql";
|
|
673
|
+
case "storage-policies":
|
|
674
|
+
return "storage-policies.sql";
|
|
675
|
+
default:
|
|
676
|
+
return `${layer}.sql`;
|
|
677
|
+
}
|
|
678
|
+
}
|
|
679
|
+
var LEADING_NOISE = /^(?:[ \t]*(?:--[^\n]*)?\n)*[ \t]*/;
|
|
680
|
+
var OPENS_CREATE_SCHEMA = /^CREATE\s+SCHEMA\s+(?!IF\s+NOT\s+EXISTS\b)/i;
|
|
681
|
+
function makeCreateSchemaConditional(statement) {
|
|
682
|
+
const lead = LEADING_NOISE.exec(statement)?.[0] ?? "";
|
|
683
|
+
const body = statement.slice(lead.length);
|
|
684
|
+
if (!OPENS_CREATE_SCHEMA.test(body)) return statement;
|
|
685
|
+
return lead + body.replace(/^CREATE\s+SCHEMA\s+/i, "CREATE SCHEMA IF NOT EXISTS ");
|
|
686
|
+
}
|
|
687
|
+
function extractExecutableStatements(content) {
|
|
688
|
+
if (!content) return [];
|
|
689
|
+
const sql = stripPsqlMetaCommands(content);
|
|
690
|
+
return splitSqlStatements(sql).filter((s) => !isCommentOnly(s)).filter((s) => !isPsqlMetaCommand(s)).map(makeCreateSchemaConditional).map((s) => s.endsWith(";") ? s : `${s};`);
|
|
691
|
+
}
|
|
692
|
+
function summarizeStatement(sql) {
|
|
693
|
+
const first = sql.split("\n").map((l) => l.trim()).find((l) => l.length > 0 && !l.startsWith("--")) ?? sql.trim();
|
|
694
|
+
return first.length > 80 ? `${first.slice(0, 77)}...` : first;
|
|
695
|
+
}
|
|
696
|
+
async function findLegacyTrackingTable(client) {
|
|
697
|
+
try {
|
|
698
|
+
const { rows } = await client.query(
|
|
699
|
+
`SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = '_supaforge_migrations'`
|
|
700
|
+
);
|
|
701
|
+
return rows.length > 0;
|
|
702
|
+
} catch {
|
|
703
|
+
return false;
|
|
704
|
+
}
|
|
705
|
+
}
|
|
706
|
+
async function schemasInSnapshot(snapshotDir) {
|
|
707
|
+
try {
|
|
708
|
+
const sql = await readFile2(join2(snapshotDir, "schema.sql"), "utf-8");
|
|
709
|
+
const found = /* @__PURE__ */ new Set();
|
|
710
|
+
for (const match of sql.matchAll(/^\s*CREATE SCHEMA (?:IF NOT EXISTS )?("[^"]+"|[A-Za-z_][\w$]*)/gim)) {
|
|
711
|
+
found.add(match[1].replace(/"/g, ""));
|
|
712
|
+
}
|
|
713
|
+
found.add("public");
|
|
714
|
+
return [...found];
|
|
715
|
+
} catch {
|
|
716
|
+
return ["public"];
|
|
717
|
+
}
|
|
718
|
+
}
|
|
719
|
+
var PLATFORM_OWNED_SCHEMAS = ["pgbouncer", "cron", "pgsodium", "vault", "_realtime", "supabase_functions"];
|
|
720
|
+
function platformOwnedObject(sql) {
|
|
721
|
+
const subject = statementSubject(sql);
|
|
722
|
+
if (!subject?.schema) return void 0;
|
|
723
|
+
return PLATFORM_OWNED_SCHEMAS.includes(subject.schema) ? subject.schema : void 0;
|
|
724
|
+
}
|
|
725
|
+
var SUPABASE_ONLY_SCHEMAS = [
|
|
726
|
+
.../* @__PURE__ */ new Set([...SUPABASE_PLATFORM_SCHEMAS, ...PLATFORM_OWNED_SCHEMAS])
|
|
727
|
+
].filter((s) => s !== "pg_catalog" && s !== "information_schema");
|
|
728
|
+
function mentionedPlatformSchema(sql, targetSchemas) {
|
|
729
|
+
const skeleton = sqlSkeleton(sql);
|
|
730
|
+
return SUPABASE_ONLY_SCHEMAS.find((schema) => !targetSchemas.has(schema) && new RegExp(String.raw`(?:"${schema}"|\b${schema})\s*\.`, "i").test(skeleton));
|
|
731
|
+
}
|
|
732
|
+
var ATTACHMENT = new RegExp(String.raw`^\s*(?:` + String.raw`GRANT|REVOKE|COMMENT\s+ON|SELECT|ALTER\s+PUBLICATION|ALTER\s+DEFAULT\s+PRIVILEGES|` + String.raw`ALTER\s+POLICY|ALTER\s+TABLE\s+(?:ONLY\s+)?\S+\s+ADD\s+CONSTRAINT\b[\s\S]*\bFOREIGN\s+KEY|` + String.raw`CREATE\s+(?:OR\s+REPLACE\s+)?(?:POLICY|(?:CONSTRAINT\s+)?TRIGGER|VIEW|MATERIALIZED\s+VIEW|RULE)` + String.raw`)\b`, "i");
|
|
733
|
+
function tolerableFailure(sql, err, targetSchemas, missing = /* @__PURE__ */ new Set()) {
|
|
734
|
+
const code = err?.code;
|
|
735
|
+
if (!code) return void 0;
|
|
736
|
+
const skeleton = sqlSkeleton(sql);
|
|
737
|
+
if (/^\s*CREATE\s+EXTENSION\b/i.test(skeleton)) {
|
|
738
|
+
return EXTENSION_UNAVAILABLE.has(code) ? `extension not available on this server: ${errMsg(err)}` : void 0;
|
|
739
|
+
}
|
|
740
|
+
if (/^\s*GRANT\s+MAINTAIN\b/i.test(skeleton) && /unrecognized privilege type/i.test(errMsg(err))) {
|
|
741
|
+
return "MAINTAIN is a PostgreSQL 17 privilege this server does not have";
|
|
742
|
+
}
|
|
743
|
+
if (!ABSENT_ON_TARGET.has(code)) return void 0;
|
|
744
|
+
const schema = mentionedPlatformSchema(sql, targetSchemas);
|
|
745
|
+
if (schema && (ATTACHMENT.test(skeleton) || ROUTINE.test(skeleton))) {
|
|
746
|
+
return `depends on ${schema}, which this target does not have (${errMsg(err)})`;
|
|
747
|
+
}
|
|
748
|
+
if (missing.size > 0) {
|
|
749
|
+
const message = errMsg(err);
|
|
750
|
+
const named = [...missing].filter((what) => {
|
|
751
|
+
const name = /^the (.+) (?:extension|schema)$/.exec(what)?.[1];
|
|
752
|
+
return name !== void 0 && new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(message);
|
|
753
|
+
});
|
|
754
|
+
return `${message}, as this target lacks ${(named.length > 0 ? named : [...missing]).join(", ")}`;
|
|
755
|
+
}
|
|
756
|
+
return void 0;
|
|
757
|
+
}
|
|
758
|
+
var ROUTINE = /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:FUNCTION|PROCEDURE)\b/i;
|
|
759
|
+
async function applyStatement(client, sql, transactional, result, missing) {
|
|
760
|
+
if (transactional) await client.query("SAVEPOINT sf_restore_statement");
|
|
761
|
+
try {
|
|
762
|
+
const needed = extensionTargetSchema(sql);
|
|
763
|
+
if (needed) await client.query(`CREATE SCHEMA IF NOT EXISTS ${quoteName(needed)}`);
|
|
764
|
+
for (const role of rolesNamedBy(sql)) await client.query(createRoleIfMissing(role));
|
|
765
|
+
await client.query(conditionalPublicationMembership(sql));
|
|
766
|
+
if (transactional) await client.query("RELEASE SAVEPOINT sf_restore_statement");
|
|
767
|
+
result.applied.push({ type: "sql", label: summarizeStatement(sql) });
|
|
768
|
+
} catch (err) {
|
|
769
|
+
if (transactional) await client.query("ROLLBACK TO SAVEPOINT sf_restore_statement");
|
|
770
|
+
const { rows } = await client.query("SELECT nspname FROM pg_namespace");
|
|
771
|
+
const targetSchemas = new Set(rows.map((r) => r.nspname));
|
|
772
|
+
const tolerated = tolerableFailure(sql, err, targetSchemas, missing);
|
|
773
|
+
if (tolerated) {
|
|
774
|
+
result.skipped.push({ type: "sql", label: summarizeStatement(sql), reason: tolerated });
|
|
775
|
+
const extension = /^\s*CREATE\s+EXTENSION\s+(?:IF\s+NOT\s+EXISTS\s+)?("[^"]+"|[\w$-]+)/i.exec(sqlSkeleton(sql));
|
|
776
|
+
const schema = mentionedPlatformSchema(sql, targetSchemas);
|
|
777
|
+
if (extension) missing.add(`the ${extension[1].replace(/"/g, "")} extension`);
|
|
778
|
+
else if (schema && tolerated.startsWith("depends on")) missing.add(`the ${schema} schema`);
|
|
779
|
+
else result.incomplete = true;
|
|
780
|
+
return;
|
|
781
|
+
}
|
|
782
|
+
result.errors.push({ type: "sql", label: summarizeStatement(sql), error: errMsg(err) });
|
|
783
|
+
if (transactional) throw new RestoreAborted();
|
|
784
|
+
}
|
|
785
|
+
}
|
|
786
|
+
function webhookTriggerKey(sql) {
|
|
787
|
+
const match = /CREATE\s+TRIGGER\s+("[^"]+"|[\w$]+)[\s\S]*?\bON\s+((?:"[^"]+"|[\w$]+)(?:\s*\.\s*(?:"[^"]+"|[\w$]+))?)/i.exec(sqlSkeleton(sql));
|
|
788
|
+
if (!match) return null;
|
|
789
|
+
const bare = (s) => s.replace(/"/g, "").trim();
|
|
790
|
+
return `${bare(match[2])}.${bare(match[1])}`.toLowerCase();
|
|
791
|
+
}
|
|
792
|
+
function isSystemSchema(schema) {
|
|
793
|
+
return schema === "pg_catalog" || schema === "information_schema" || schema.startsWith("pg_");
|
|
794
|
+
}
|
|
795
|
+
function extensionTargetSchema(sql) {
|
|
796
|
+
const match = /CREATE\s+EXTENSION\b[\s\S]*?\bWITH\s+SCHEMA\s+("[^"]+"|[\w$]+)/i.exec(sqlSkeleton(sql));
|
|
797
|
+
if (!match) return void 0;
|
|
798
|
+
const schema = match[1].replace(/"/g, "");
|
|
799
|
+
return isSystemSchema(schema) ? void 0 : schema;
|
|
800
|
+
}
|
|
801
|
+
function createRoleIfMissing(role) {
|
|
802
|
+
return `DO $$ BEGIN
|
|
803
|
+
IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = ${quoteLiteral(role)}) THEN
|
|
804
|
+
CREATE ROLE ${quoteName(role)} NOLOGIN;
|
|
805
|
+
END IF;
|
|
806
|
+
END $$;`;
|
|
807
|
+
}
|
|
808
|
+
function conditionalPublicationMembership(sql) {
|
|
809
|
+
const match = /^\s*ALTER\s+PUBLICATION\s+("[^"]+"|[\w$]+)\s+ADD\s+TABLE\s+(?:ONLY\s+)?([^;]+?)\s*;?\s*$/i.exec(sql);
|
|
810
|
+
if (!match) return sql;
|
|
811
|
+
const [, publication, table] = match;
|
|
812
|
+
const parts = table.split(".").map((p) => p.replace(/"/g, "").trim());
|
|
813
|
+
if (parts.length !== 2) return sql;
|
|
814
|
+
const [schema, name] = parts;
|
|
815
|
+
return `DO $$ BEGIN
|
|
816
|
+
IF NOT EXISTS (
|
|
817
|
+
SELECT 1 FROM pg_publication_tables
|
|
818
|
+
WHERE pubname = ${quoteLiteral(publication.replace(/"/g, ""))}
|
|
819
|
+
AND schemaname = ${quoteLiteral(schema)}
|
|
820
|
+
AND tablename = ${quoteLiteral(name)}
|
|
821
|
+
) THEN
|
|
822
|
+
EXECUTE ${quoteLiteral(`ALTER PUBLICATION ${quoteIdent(publication.replace(/"/g, ""))} ADD TABLE ${quoteName(schema)}.${quoteName(name)}`)};
|
|
823
|
+
END IF;
|
|
824
|
+
END $$;`;
|
|
825
|
+
}
|
|
826
|
+
var RestoreAborted = class extends Error {
|
|
827
|
+
};
|
|
828
|
+
|
|
829
|
+
export {
|
|
830
|
+
getPublicTables,
|
|
831
|
+
restoreFromSnapshot,
|
|
832
|
+
restoreFromMigrations,
|
|
833
|
+
previewSnapshotRestore,
|
|
834
|
+
previewMigrationRestore,
|
|
835
|
+
summarizeStatement
|
|
836
|
+
};
|
|
837
|
+
//# sourceMappingURL=chunk-PARSNTBD.js.map
|