@getxflow/cli 1.8.0 → 1.9.0

package/dist/args.js

@@ -21,6 +21,7 @@ exports.BOOLEAN_FLAGS = new Set([
     'dry-run',
     'allow-destructive',
     'allow-removals',
+    'overwrite',
 ]);
 function parseArgs(argv) {
     const words = [];

package/dist/bin.js

@@ -183,11 +183,19 @@ async function run(args) {
                 await (0, logs_1.dbLogs)(args);
                 return;
             }
+            if (second === 'branch' || second === 'branches') {
+                await (0, db_1.dbBranch)({ ...args, words: args.words.slice(2) });
+                return;
+            }
+            if (second === 'restore') {
+                await (0, db_1.dbRestore)(args);
+                return;
+            }
             if (second === undefined || second === 'status') {
                 await (0, db_1.dbStatus)({ ...args, words: args.words.slice(2) });
                 return;
             }
-            throw new errors_1.CliError(`Unknown command: db ${second}`, 'Available: status, list, schema, query, exec and migrate');
+            throw new errors_1.CliError(`Unknown command: db ${second}`, 'Available: status, list, schema, query, exec, migrate, branch and restore');
         case 'storage':
             if (second === 'push') {
                 await (0, storage_1.storagePush)(rest);

package/dist/commands/db.js

@@ -7,6 +7,8 @@ exports.dbQuery = dbQuery;
 exports.dbExec = dbExec;
 exports.dbMigrate = dbMigrate;
 exports.migrateBeforeDeploy = migrateBeforeDeploy;
+exports.dbBranch = dbBranch;
+exports.dbRestore = dbRestore;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const api_1 = require("../api");
@@ -14,6 +16,7 @@ const args_1 = require("../args");
 const config_1 = require("../config");
 const errors_1 = require("../errors");
 const session_1 = require("../session");
+const moment_1 = require("../moment");
 const text_file_1 = require("../text-file");
 const ui_1 = require("../ui");
 const sources_1 = require("./sources");
@@ -171,7 +174,7 @@ async function dbQuery(args) {
     const { projectId, client } = await (0, session_1.projectTarget)(args);
     const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/db/query`, {
         method: 'POST',
-        body: { sql },
+        body: { sql, branch: (0, args_1.flagString)(args, 'branch') },
         timeoutMs: 60_000,
     });
     // The whole values, machine-readable, and the only thing printed: --json silences
@@ -217,7 +220,7 @@ async function dbExec(args) {
     const { projectId, client } = await (0, session_1.projectTarget)(args);
     const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/db/exec`, {
         method: 'POST',
-        body: { sql, allow_destructive: (0, args_1.flagBool)(args, 'allow-destructive') },
+        body: { sql, allow_destructive: (0, args_1.flagBool)(args, 'allow-destructive'), branch: (0, args_1.flagString)(args, 'branch') },
         timeoutMs: 120_000,
     });
     if ((0, args_1.flagBool)(args, 'json')) {
@@ -251,11 +254,13 @@ async function dbMigrate(args) {
     const client = await (0, session_1.connectProject)(config.projectId, root, config);
     const migrations = requireMigrations(root);
     const dryRun = (0, args_1.flagBool)(args, 'dry-run');
+    const branch = (0, args_1.flagString)(args, 'branch');
     // Migrations live in the revisions of the project root: without this a project
     // without functions would lose them from its history, and a clone would miss them.
-    if (!dryRun)
+    // A try on a branch is not history yet.
+    if (!dryRun && !branch)
         await (0, sources_1.pushSources)({ kind: 'project', root, projectId: config.projectId }, client, { force: false });
-    await migrate(client, config.projectId, migrations, dryRun, (0, args_1.flagBool)(args, 'allow-destructive'));
+    await migrate(client, config.projectId, migrations, dryRun, (0, args_1.flagBool)(args, 'allow-destructive'), branch);
 }
 /** The functions deploy runs this first: new code must not meet an old schema. */
 async function migrateBeforeDeploy(client, root, projectId) {
@@ -271,14 +276,16 @@ async function migrateBeforeDeploy(client, root, projectId) {
         throw e;
     }
 }
-async function migrate(client, projectId, migrations, dryRun, allowDestructive) {
-    (0, ui_1.step)(dryRun ? `Checking the migrations (${migrations.length} in the directory)` : `Applying the migrations (${migrations.length} in the directory)`);
+async function migrate(client, projectId, migrations, dryRun, allowDestructive, branch) {
+    const where = branch ? ` to branch ${branch}` : '';
+    (0, ui_1.step)(dryRun ? `Checking the migrations${where} (${migrations.length} in the directory)` : `Applying the migrations${where} (${migrations.length} in the directory)`);
     const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/db/migrate`, {
         method: 'POST',
         body: {
             migrations,
             dry_run: dryRun,
             allow_destructive: allowDestructive,
+            branch,
         },
         timeoutMs: 300_000,
     });
@@ -314,3 +321,77 @@ async function migrate(client, projectId, migrations, dryRun, allowDestructive)
             : 'The database is unchanged: the migration rolled back as a whole');
     }
 }
+/** Branches of the project database: list, create, delete. */
+async function dbBranch(args) {
+    const [sub, name] = args.words;
+    const { projectId, client } = await (0, session_1.projectTarget)(args);
+    const path = `/api/v1/projects/${projectId}/db/branches`;
+    if (sub === undefined || sub === 'list') {
+        const data = await (0, api_1.apiJson)(client, path);
+        if ((0, args_1.flagBool)(args, 'json')) {
+            (0, ui_1.out)(JSON.stringify(data.branches, null, 2));
+            return;
+        }
+        if (data.branches.length === 0) {
+            (0, ui_1.note)('No branches');
+            (0, ui_1.note)((0, ui_1.dim)('  A copy to try things on: xflow db branch create <name> [--at 2h]'));
+            return;
+        }
+        (0, ui_1.table)(data.branches.map((b) => [b.name, b.at ? `as of ${new Date(b.at).toLocaleString()}` : 'as made', (0, ui_1.formatAge)(b.created_at)]));
+        return;
+    }
+    if (!name)
+        throw new errors_1.CliError(`xflow db branch ${sub} needs a name`, `For example: xflow db branch ${sub} fix-orders`);
+    if (sub === 'create') {
+        const at = (0, args_1.flagString)(args, 'at');
+        const data = await (0, api_1.apiJson)(client, path, {
+            method: 'POST',
+            body: { name, at: at ? (0, moment_1.parseMoment)(at) : undefined },
+            timeoutMs: 180_000,
+        });
+        if ((0, args_1.flagBool)(args, 'json')) {
+            (0, ui_1.out)(JSON.stringify(data.branch, null, 2));
+            return;
+        }
+        (0, ui_1.ok)(`Branch ${name}: the project database ${data.branch.at ? `as of ${new Date(data.branch.at).toLocaleString()}` : 'as it is now'}`);
+        (0, ui_1.note)((0, ui_1.dim)(`  Work in it: xflow db query --branch ${name} '...', db exec and db migrate take --branch too`));
+        (0, ui_1.note)((0, ui_1.dim)(`  Rows back into the project database: xflow db restore --from ${name} --table <table>`));
+        return;
+    }
+    if (sub === 'delete' || sub === 'rm') {
+        await (0, api_1.apiJson)(client, `${path}/${encodeURIComponent(name)}`, { method: 'DELETE' });
+        (0, ui_1.ok)(`Branch ${name} deleted; the project database is unchanged`);
+        return;
+    }
+    throw new errors_1.CliError(`Unknown command: db branch ${sub}`, 'Available: list, create and delete');
+}
+/** Rows of a table from a branch back into the project database, by primary key. */
+async function dbRestore(args) {
+    const from = (0, args_1.flagString)(args, 'from');
+    const tableName = (0, args_1.flagString)(args, 'table');
+    if (!from || !tableName) {
+        throw new errors_1.CliError('Name the branch and the table', "For example: xflow db restore --from before-import --table orders --where 'id in (7, 9)'");
+    }
+    const overwrite = (0, args_1.flagBool)(args, 'overwrite');
+    const { projectId, client } = await (0, session_1.projectTarget)(args);
+    const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/db/restore`, {
+        method: 'POST',
+        body: { branch: from, table: tableName, where: (0, args_1.flagString)(args, 'where'), overwrite },
+        timeoutMs: 120_000,
+    });
+    if ((0, args_1.flagBool)(args, 'json')) {
+        (0, ui_1.out)(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (data.read === 0) {
+        (0, ui_1.note)(`No rows of ${tableName} in branch ${from} match`);
+        return;
+    }
+    (0, ui_1.ok)(`${data.restored} of ${data.read} rows of ${tableName} from branch ${from} ${overwrite ? 'written' : 'put back'}`);
+    for (const dump of data.dumps ?? []) {
+        (0, ui_1.note)((0, ui_1.dim)(`  Copy of ${dump.table} before the change: ${dump.rows} rows, kept for ${data.dump_retention_days} days`));
+    }
+    if (!overwrite && data.restored < data.read) {
+        (0, ui_1.note)((0, ui_1.dim)(`  The other ${data.read - data.restored} are in the database already and kept as they are: --overwrite replaces them`));
+    }
+}

package/dist/flags.js

@@ -78,10 +78,13 @@ exports.KNOWN = {
     'db status': ['project'],
     'db list': [],
     'db schema': ['project'],
-    'db query': ['json', 'project'],
-    'db exec': ['allow-destructive', 'json', 'project'],
+    'db query': ['json', 'project', 'branch'],
+    'db exec': ['allow-destructive', 'json', 'project', 'branch'],
     'db logs': ['limit', 'project', 'cursor'],
-    'db migrate': ['dry-run', 'allow-destructive'],
+    'db migrate': ['dry-run', 'allow-destructive', 'branch'],
+    'db branch': ['at', 'json', 'project'],
+    'db branches': ['at', 'json', 'project'],
+    'db restore': ['from', 'table', 'where', 'overwrite', 'json', 'project'],
     storage: ['json', 'project'],
     'storage ls': ['json', 'project'],
     'storage list': ['json', 'project'],