@getxflow/cli 1.0.9 → 1.1.1

package/dist/commands/db.js

@@ -6,6 +6,7 @@ exports.dbSchema = dbSchema;
 exports.dbQuery = dbQuery;
 exports.dbMove = dbMove;
 exports.dbMigrate = dbMigrate;
+exports.migrateBeforeDeploy = migrateBeforeDeploy;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const api_1 = require("../api");
@@ -244,7 +245,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, limit: (0, args_1.flagNumber)(args, 'limit') },
+        body: { sql },
         timeoutMs: 60_000,
     });
     // The whole values, machine-readable, and the only thing printed: --json silences
@@ -272,11 +273,10 @@ async function dbQuery(args) {
     }
     if (data.truncated) {
         // No exact total here: the platform stops reading at limit + 1 rows, so all
-        // it knows is that more exist. The "raise --limit" advice shows only while
-        // the flag still has room below the ceiling.
+        // it knows is that more exist.
         const room = data.limit !== undefined && data.limit_max !== undefined && data.limit < data.limit_max;
         (0, ui_1.note)((0, ui_1.dim)(room
-            ? `  Shown the first ${data.rows.length} rows, more exist: raise --limit (up to ${data.limit_max}), or narrow the query`
+            ? `  Shown the first ${data.rows.length} rows, more exist: end the query with a larger limit (up to ${data.limit_max}), or narrow it`
             : `  Shown the first ${data.rows.length} rows, more exist: narrow the query, with a where clause or an offset`));
     }
 }
@@ -345,13 +345,30 @@ async function dbMigrate(args) {
     // without functions would lose them from its history, and a clone would miss them.
     if (!dryRun)
         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'));
+}
+/** The functions deploy runs this first: new code must not meet an old schema. */
+async function migrateBeforeDeploy(client, root, projectId) {
+    const migrations = readMigrations(root);
+    if (migrations.length === 0)
+        return;
+    try {
+        await migrate(client, projectId, migrations, false, false);
+    }
+    catch (e) {
+        (0, ui_1.warn)('The functions were not deployed: the migrations stopped first');
+        (0, ui_1.note)((0, ui_1.dim)('  Once xflow db migrate goes through, deploy again'));
+        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)`);
-    const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/db/migrate`, {
+    const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/db/migrate`, {
         method: 'POST',
         body: {
             migrations,
             dry_run: dryRun,
-            allow_destructive: (0, args_1.flagBool)(args, 'allow-destructive'),
+            allow_destructive: allowDestructive,
         },
         timeoutMs: 300_000,
     });

package/dist/commands/deploy.js

@@ -14,6 +14,7 @@ const prompt_1 = require("../prompt");
 const session_1 = require("../session");
 const tree_1 = require("../tree");
 const ui_1 = require("../ui");
+const db_1 = require("./db");
 const sources_1 = require("./sources");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** Slightly longer than the platform's own build timeout. */
@@ -166,7 +167,7 @@ async function warnUndeployedRoot(client, projectRoot, projectId) {
         const relation = server ? (0, tree_1.syncState)(tree.hash, server.tree_hash, (0, config_1.readState)(projectRoot).treeHash) : 'local-changes';
         if (relation !== 'matches') {
             (0, ui_1.warn)('The project root holds changes nobody deployed (functions, migrations or callers)');
-            (0, ui_1.note)((0, ui_1.dim)('  If this app needs them: xflow db migrate and xflow deploy functions first'));
+            (0, ui_1.note)((0, ui_1.dim)('  If this app needs them: xflow deploy functions first, it applies the migrations too'));
         }
     }
     catch {
@@ -199,6 +200,8 @@ async function deployTarget(target, args, comment, revision) {
                 : { kind: 'project', root: target.root, projectId: target.projectId };
             revision = (await (0, sources_1.pushSources)(stream, client, { force: (0, args_1.flagBool)(args, 'force') })).revision;
         }
+        if (target.kind === 'project')
+            await (0, db_1.migrateBeforeDeploy)(client, target.root, target.projectId);
     }
     (0, ui_1.step)(target.kind === 'app' ? `Building the app from revision ${revision}` : `Deploying the functions from revision ${revision}`);
     const started = await startBuild(client, base, revision, (0, args_1.flagBool)(args, 'allow-removals'), comment);

package/dist/commands/functions.js

@@ -24,7 +24,7 @@ async function functionsList(args) {
         fn.last_called_at ? `called ${(0, ui_1.formatAge)(fn.last_called_at)}` : 'never called',
         fn.last_error_at ? `failed ${(0, ui_1.formatAge)(fn.last_error_at)}` : '',
     ]));
-    (0, ui_1.note)((0, ui_1.dim)('  callers: the app folders and page names allowed to call it (functions in the root xflow.json)'));
+    (0, ui_1.note)((0, ui_1.dim)('  callers: the app folders allowed to call it (functions in the root xflow.json)'));
     (0, ui_1.note)((0, ui_1.dim)('  open: a caller is public, so anyone on the internet can call it; no callers: a workflow'));
     (0, ui_1.note)((0, ui_1.dim)(`  Webhooks and other functions call ${functions[0].url.replace(/\/[^/]+$/, '/<name>')} with a key`));
 }

package/dist/commands/pages.js

@@ -99,7 +99,6 @@ async function pagesCreate(args) {
     (0, ui_1.ok)(`Page "${result.page.title}" is live: ${result.file_count} file(s), ${(0, ui_1.formatBytes)(result.size_bytes)}`);
     (0, ui_1.out)(result.page.url);
     (0, ui_1.note)((0, ui_1.dim)(`  Anyone with the address sees it within seconds. The next version: xflow pages deploy ${result.page.slug} <path>`));
-    (0, ui_1.note)((0, ui_1.dim)(`  A backend for it: name "${result.page.slug}" in functions.<name>.callers of a project, xflow deploy functions, then fetch /_fn/<name>`));
 }
 function contentTypeOf(upload) {
     return upload.kind === 'zip' ? 'application/zip' : 'text/html';

package/dist/flags.js

@@ -80,7 +80,7 @@ exports.KNOWN = {
     'db status': ['project'],
     'db list': [],
     'db schema': ['project'],
-    'db query': ['limit', 'json', 'project'],
+    'db query': ['json', 'project'],
     'db migrate': ['dry-run', 'allow-destructive'],
     'db move': ['to', 'confirm', 'project'],
     storage: ['json', 'project'],

package/dist/help.js

@@ -301,11 +301,10 @@ build it and upload what the build writes. Dot entries are skipped. At most 5 MB
 unpacked and 1000 files.
 
 The page is public, so a file holding a secret key is refused whole: every visitor would read
-it. A page that needs a backend (a form, a lookup) calls ${(0, ui_1.bold)('/_fn/<name>')} on its own address,
-and only a function whose callers in the root xflow.json of its project name the page answers:
-add the page name there and run ${(0, ui_1.bold)('xflow deploy functions')}. The page has to exist first.
-Such a function is open to the whole internet. Search engines are asked not to index pages,
-so do not promise SEO.
+it. A page has no backend: a form or a lookup belongs in an app with access "anyone". The one
+key a page may hold is a function key, and it opens that function to every visitor: an HTML
+form can post to its webhook address with ${(0, ui_1.bold)('?key=')}, while fetch cannot read the answer
+(no CORS). Search engines are asked not to index pages, so do not promise SEO.
 
 ${(0, ui_1.bold)('Deleting is final.')} The address goes empty and every version of the page is gone: there
 is no undo and no copy on the platform side. The name stays reserved for the organization, so
@@ -343,8 +342,8 @@ will work.`,
   xflow db status                  what is applied, what is waiting, the server
   xflow db list                    databases of the projects, the servers of the organization
   xflow db schema [table]          tables of the project, or the columns of one
-  xflow db query 'select ...'      read data (--limit N: 50 by default, 300 at most;
-                                   --json prints the values whole)
+  xflow db query 'select ...'      read data (rows: the query's own limit, 50 without
+                                   one, 300 at most; --json prints the values whole)
   xflow db query <file>.sql        the same, the query read from a file
   xflow db migrate                 store the project root, then apply migrations/*.sql
   xflow db move --to <server> --confirm <project name>
@@ -618,14 +617,14 @@ of the project runs the new code the moment it finishes; there is no publish ste
 
 Who may call a function is its callers, in the root xflow.json:
 
-  { "projectId": "…", "functions": { "book-slot": { "callers": ["zapis", "clinic-landing"] } } }
+  { "projectId": "…", "functions": { "book-slot": { "callers": ["zapis"] } } }
 
-A caller is an app folder of this project (apps/zapis is "zapis") or the name of a page of
-the organization. A function nobody lists has no callers: a workflow, woken by a schedule,
-by a service holding a key a person issued, or by ${(0, ui_1.bold)('invoke')}. ${(0, ui_1.bold)('open')} in the list means a
-caller is public (a page, or an app anyone with the link opens), so anyone on the internet
-can call it. The address in the note under the table is for webhooks and other functions,
-with a key; apps and pages call ${(0, ui_1.bold)('/_fn/<name>')} on their own address.
+A caller is an app folder of this project (apps/zapis is "zapis"); pages are static and call
+nothing. A function nobody lists has no callers: a workflow, woken by a schedule, by a service
+holding a key a person issued, or by ${(0, ui_1.bold)('invoke')}. ${(0, ui_1.bold)('open')} in the list means a caller is an app
+anyone with the link opens, so anyone on the internet can call it. The address in the note
+under the table is for webhooks and other functions, with a key; apps call ${(0, ui_1.bold)('/_fn/<name>')} on
+their own address.
 
 ${(0, ui_1.bold)('invoke')} calls it as the person who owns the key: the platform checks the role, gives
 the function a one-minute ticket and calls it itself, so the function sees
@@ -718,8 +717,8 @@ git's job.
   --force            overwrite the folder completely`,
     deploy: `${(0, ui_1.bold)('xflow deploy')}: deploy the functions or build an app, then publish
 
-  xflow deploy functions -m "…"       send the project root, check it, ship the functions
-                                      and their callers
+  xflow deploy functions -m "…"       send the project root, check it, apply the new
+                                      migrations, ship the functions and their callers
   xflow deploy apps/<folder> -m "…"   send one app and build it; inside its folder a plain
                                       xflow deploy does the same
   xflow publish [build]               point the app address at the newest build, or a named one
@@ -760,11 +759,13 @@ keys in the code, alert instead of a dialog) is printed as a list and nothing st
 merely unfinished (the template page title, no icon) goes through and prints a line
 ${(0, ui_1.bold)('Unfinished:')}. Fix it before telling the person the app is done.
 
-${(0, ui_1.bold)('deploy functions')} bundles everything in ${(0, ui_1.bold)('functions/<name>/index.ts')}. A function whose
+${(0, ui_1.bold)('deploy functions')} first applies the new migrations of ${(0, ui_1.bold)('migrations/')}: if one fails or
+would destroy data, nothing ships, and ${(0, ui_1.bold)('xflow db migrate')} is where that gets settled. Then it
+bundles everything in ${(0, ui_1.bold)('functions/<name>/index.ts')}. A function whose
 code and variables did not change is left alone, and one that fails to ship fails the whole
 deploy. It then records the callers and prints which functions are open to the whole
-internet now. A change that touches data and screens goes in this order: the migration,
-the functions, then every app that shows it; an app deploy warns when the root holds
+internet now. A change that touches data and screens goes in this order: the functions
+(with the migration), then every app that shows it; an app deploy warns when the root holds
 changes nobody deployed.
 
 A function gone from the sources would be deleted from the cloud along with its keys and
@@ -774,9 +775,6 @@ to agree. If the sources hold no functions at all while the cloud holds several,
 is deleted and nothing is asked: that looks like a directory which never made it (a
 ${(0, ui_1.bold)('functions/')} line in .xflowignore) rather than a decision.
 
-The database is not part of this: migrations change data in ways nothing can undo, so
-they stay their own command (${(0, ui_1.bold)('xflow db migrate')}).
-
 A build of an app is not shown to visitors until ${(0, ui_1.bold)('xflow publish')}: publishing points the
 app address at a build and takes a second, and an older kept build is the rollback. Only
 the app moves: the functions and the database are one per project and stay as they are.

package/dist/template.js

@@ -13,7 +13,7 @@ const README = `# %NAME%
 A project on XFlow: one database, cloud functions and the apps that use them.
 
 \`\`\`
-xflow.json          projectId, and which apps and pages may call each function
+xflow.json          projectId, and which apps may call each function
 package.json        dependencies of the functions
 functions/<name>/   cloud functions, shared by every app
 migrations/         the database of the project

package/dist/version.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_API_URL = exports.CLI_VERSION = void 0;
 /** Keep in sync with cli/package.json. */
-exports.CLI_VERSION = '1.0.9';
+exports.CLI_VERSION = '1.1.1';
 /** Overridden by XFLOW_API_URL or the `api` field in xflow.json. */
 exports.DEFAULT_API_URL = 'https://app.getxflow.com';

package/package.json

@@ -1,24 +1,24 @@
-{
-  "name": "@getxflow/cli",
-  "version": "1.0.9",
-  "description": "CLI for the XFlow platform: projects with apps, functions and a database; source sync, deployment and publishing",
-  "license": "UNLICENSED",
-  "engines": {
-    "node": ">=20"
-  },
-  "bin": {
-    "xflow": "dist/bin.js"
-  },
-  "files": [
-    "dist",
-    "skills"
-  ],
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@getxflow/cli",
+  "version": "1.1.1",
+  "description": "CLI for the XFlow platform: projects with apps, functions and a database; source sync, deployment and publishing",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "xflow": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}