@getxflow/cli 0.6.5 → 0.6.6

package/dist/api.js

@@ -98,26 +98,50 @@ async function send(client, path, options = {}) {
     assertProtocol(response);
     return response;
 }
-async function readError(response) {
+/**
+ * The body is not an answer of the API: every one of those is JSON with content.
+ * A page in its place, or nothing at all, means the request never reached a
+ * route, so we say that instead of quoting what came back.
+ *
+ * Markup never goes into the hint. The reader is an agent, and 200 characters of
+ * HTML read like a bug in its own code rather than like a platform that has not
+ * deployed this endpoint yet. An empty body is worse still: it used to leave no
+ * hint at all.
+ *
+ * Plain text is kept: some proxies say something useful in one line.
+ */
+function notAnAnswer(status, apiUrl, body) {
+    const text = body.trim();
+    if (text.length > 0 && !text.startsWith('<')) {
+        return new ApiError(`Request rejected (${status})`, 'unknown', status, text.slice(0, 200));
+    }
+    // 404 is a missing route, 405 a route without this method. Both mean the same
+    // thing to the caller: this platform does not serve the endpoint yet.
+    if (status === 404 || status === 405) {
+        return new ApiError(`The platform does not serve that endpoint (${status})`, 'not_deployed', status, `This CLI is ${version_1.CLI_VERSION} and ${apiUrl} is older than it. Wait for the platform to deploy, or check XFLOW_API_URL`);
+    }
+    return new ApiError(`The platform is not answering (${status})`, 'unavailable', status, `Something on the way to ${apiUrl} answered with a page instead of an answer. Retry in a minute`);
+}
+async function readError(response, client) {
     const text = await response.text().catch(() => '');
     try {
         const parsed = JSON.parse(text);
         return new ApiError(parsed.error || `Request rejected (${response.status})`, parsed.code || 'unknown', response.status, parsed.hint, parsed.issues, parsed.limit, parsed.removing);
     }
     catch {
-        return new ApiError(`Request rejected (${response.status})`, 'unknown', response.status, text.slice(0, 200) || undefined);
+        return notAnAnswer(response.status, client.apiUrl, text);
     }
 }
 async function apiJson(client, path, options = {}) {
     const response = await send(client, path, options);
     if (!response.ok)
-        throw await readError(response);
+        throw await readError(response, client);
     return (await response.json());
 }
 async function apiBinary(client, path) {
     const response = await send(client, path, { timeoutMs: TRANSFER_TIMEOUT_MS });
     if (!response.ok)
-        throw await readError(response);
+        throw await readError(response, client);
     return Buffer.from(await response.arrayBuffer());
 }
 async function apiUpload(client, path, body, headers = {}) {

package/dist/bin.js

@@ -107,11 +107,19 @@ async function run(args) {
             }
             throw new errors_1.CliError(`Unknown command: env ${second}`, 'Available: list, check, set and rm');
         case 'connections':
+            if (second === 'link') {
+                await (0, connections_1.connectionsLink)(rest);
+                return;
+            }
+            if (second === 'unlink') {
+                await (0, connections_1.connectionsUnlink)(rest);
+                return;
+            }
             if (second === undefined || second === 'list') {
                 await (0, connections_1.connectionsList)();
                 return;
             }
-            throw new errors_1.CliError(`Unknown command: connections ${second}`, 'Available: list');
+            throw new errors_1.CliError(`Unknown command: connections ${second}`, 'Available: list, link and unlink');
         case 'schedules':
             if (second === 'set') {
                 await (0, schedules_1.schedulesSet)(rest);

package/dist/commands/connections.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectionsList = connectionsList;
+exports.connectionsLink = connectionsLink;
+exports.connectionsUnlink = connectionsUnlink;
 const api_1 = require("../api");
+const args_1 = require("../args");
 const config_1 = require("../config");
+const errors_1 = require("../errors");
 const session_1 = require("../session");
 const ui_1 = require("../ui");
+const env_1 = require("./env");
 // An expiring token is renewed by any build, a revoked one is not renewed by
 // anything until a human reconnects the account. Telling them apart saves a
 // pointless rebuild, so every case gets its own line.
@@ -26,10 +31,35 @@ function state(row) {
             return 'linked';
     }
 }
+function endpoint(projectId) {
+    return `/api/v1/projects/${projectId}/connections`;
+}
+/**
+ * Which connection the argument means. Identifiers are what the platform knows,
+ * names are what the list shows and what a human said out loud; both are
+ * accepted, so nobody has to copy a UUID from somewhere the command never
+ * printed it. Names repeat across accounts of the same service, so an ambiguous
+ * one is refused with the identifiers rather than resolved by luck.
+ */
+function resolve(connections, target) {
+    const byId = connections.find((row) => row.id === target);
+    if (byId)
+        return byId;
+    const wanted = target.toLowerCase();
+    const named = connections.filter((row) => row.label.toLowerCase() === wanted);
+    if (named.length === 1)
+        return named[0];
+    if (named.length > 1) {
+        (0, ui_1.fail)(`The organization has ${named.length} connections named ${target}:`);
+        (0, ui_1.table)(named.map((row) => [row.id, row.connector_name ?? row.connector_key ?? '-']));
+        throw new errors_1.CliError('The name is ambiguous', 'Repeat with one of the identifiers above');
+    }
+    throw new errors_1.CliError(`No connection ${target}`, 'What this project can use: xflow connections');
+}
 async function connectionsList() {
     const { config } = (0, config_1.requireProject)();
     const client = (0, session_1.connect)(config);
-    const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/connections`);
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
     if (data.connections.length === 0) {
         (0, ui_1.note)('No connections you can use in this organization');
         (0, ui_1.note)((0, ui_1.dim)('  Somebody connects an account first: platform settings, Connectors'));
@@ -47,6 +77,63 @@ async function connectionsList() {
         (0, ui_1.note)((0, ui_1.dim)('  A change reaches a function on its next deploy: xflow deploy'));
     }
     if (data.connections.some((row) => !row.alias)) {
-        (0, ui_1.note)((0, ui_1.dim)('  To link one: project settings, Connectors. Needs the developer role on the project'));
+        (0, ui_1.note)((0, ui_1.dim)('  To link one: xflow connections link <name> --as ALIAS'));
+    }
+}
+async function connectionsLink(args) {
+    const target = args.words[1];
+    if (!target) {
+        throw new errors_1.CliError('A connection is required', 'Its name is the first column of xflow connections');
+    }
+    // The alias is asked for, never guessed: it becomes the prefix of the
+    // variables, it ends up in the code of the functions, and renaming it later
+    // means editing that code.
+    const alias = (0, args_1.flagString)(args, 'as');
+    if (!alias) {
+        throw new errors_1.CliError('An alias is required', 'For example: xflow connections link "Яндекс Метрика" --as YANDEX_METRIKA');
+    }
+    const { config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
+    const connectionId = resolve(data.connections, target).id;
+    const result = await (0, api_1.apiJson)(client, endpoint(config.projectId), { method: 'POST', body: { connection_id: connectionId, alias } });
+    (0, ui_1.ok)(`${(0, ui_1.bold)(result.label)} linked as ${result.alias}`);
+    if (result.env.length > 0)
+        (0, ui_1.note)((0, ui_1.dim)(`  The functions will get: ${result.env.join(', ')}`));
+    (0, ui_1.note)((0, ui_1.dim)('  The values arrive on the next deploy: xflow deploy'));
+}
+async function connectionsUnlink(args) {
+    const target = args.words[1];
+    if (!target) {
+        throw new errors_1.CliError('A connection is required', 'For example: xflow connections unlink YANDEX_METRIKA');
+    }
+    const { root, config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    // The alias is what the code of the functions knows, and it wins: it is the
+    // most precise of the three, since it names the link and not just the account.
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
+    const byAlias = data.connections.find((item) => item.alias !== null && item.alias === target.toUpperCase());
+    const row = byAlias ?? resolve(data.connections, target);
+    if (!row.alias) {
+        (0, ui_1.note)(`${row.label} is not linked to this project`);
+        return;
+    }
+    // The platform does not see the sources, so this check lives here. Without it
+    // the unlink is silent and the breakage shows up one deploy later.
+    const needed = (0, env_1.referencedByFunctions)(root).needed;
+    const inUse = row.env
+        .map((name) => ({ name, users: needed.get(name) ?? [] }))
+        .filter((entry) => entry.users.length > 0);
+    if (inUse.length > 0 && !(0, args_1.flagBool)(args, 'force')) {
+        (0, ui_1.fail)(`The functions of this project read the variables of ${row.alias}:`);
+        (0, ui_1.table)(inUse.map((entry) => [entry.name, entry.users.join(', ')]));
+        throw new errors_1.CliError('They would lose these variables on the next deploy', 'Repeat with --force if that is intended');
+    }
+    const result = await (0, api_1.apiJson)(client, `${endpoint(config.projectId)}?connection_id=${encodeURIComponent(row.id)}`, { method: 'DELETE' });
+    if (!result.removed) {
+        (0, ui_1.note)(`${row.label} is not linked to this project`);
+        return;
     }
+    (0, ui_1.ok)(`${(0, ui_1.bold)(row.label)} unlinked, ${result.alias} is gone`);
+    (0, ui_1.note)((0, ui_1.dim)('  Functions already deployed keep the values until their next deploy'));
 }

package/dist/commands/env.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.referencedByFunctions = referencedByFunctions;
 exports.envList = envList;
 exports.envCheck = envCheck;
 exports.envSet = envSet;