@formo/cli 0.2.0 → 1.0.2

package/dist/lib/client.js

@@ -3,12 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EVENTS_BASE_URL = exports.DEFAULT_API_BASE_URL = void 0;
+exports.getApiBaseUrl = getApiBaseUrl;
+exports.getEventsBaseUrl = getEventsBaseUrl;
 exports.parseApiError = parseApiError;
+exports.createEventsClient = createEventsClient;
 exports.requireApiKey = requireApiKey;
 exports.createClient = createClient;
 const axios_1 = __importDefault(require("axios"));
 const config_1 = require("./config");
-const BASE_URL = 'https://api.formo.so';
+exports.DEFAULT_API_BASE_URL = 'https://api.formo.so';
+exports.DEFAULT_EVENTS_BASE_URL = 'https://events.formo.so';
+function getApiBaseUrl() {
+    return process.env.FORMO_API_BASE_URL ?? exports.DEFAULT_API_BASE_URL;
+}
+function getEventsBaseUrl() {
+    return process.env.FORMO_EVENTS_BASE_URL ?? exports.DEFAULT_EVENTS_BASE_URL;
+}
 /**
  * Translate an AxiosError into a thrown Error with the API's structured
  * `{ error: { code, message, doc_url, param, details } }` envelope decoded
@@ -25,6 +36,12 @@ function parseApiError(error) {
     parts.push(apiError?.code ? `[${apiError.code}] ${baseMessage}` : baseMessage);
     if (apiError?.param)
         parts.push(`Param: ${apiError.param}`);
+    if (apiError?.details && Object.keys(apiError.details).length > 0) {
+        const details = Object.entries(apiError.details)
+            .map(([key, value]) => `${key}: ${String(value)}`)
+            .join('; ');
+        parts.push(`Details: ${details}`);
+    }
     if (apiError?.doc_url)
         parts.push(`Docs:  ${apiError.doc_url}`);
     const message = parts.join('\n   ');
@@ -37,9 +54,9 @@ function parseApiError(error) {
         transportCode: error.code,
     });
 }
-function createClient() {
-    const apiKey = (0, config_1.getApiKey)();
-    const baseURL = BASE_URL;
+function createClient(options = {}) {
+    const apiKey = options.apiKey ?? (0, config_1.getApiKey)();
+    const baseURL = options.baseURL ?? getApiBaseUrl();
     const instance = axios_1.default.create({
         baseURL,
         timeout: 30000,
@@ -53,6 +70,12 @@ function createClient() {
     });
     return instance;
 }
+function createEventsClient(writeKey) {
+    if (!writeKey) {
+        throw new Error('No event write key configured. Pass --write-key or set FORMO_WRITE_KEY.');
+    }
+    return createClient({ baseURL: getEventsBaseUrl(), apiKey: writeKey });
+}
 function requireApiKey() {
     if (!(0, config_1.getApiKey)()) {
         throw new Error('No API key configured. Run `formo login <apiKey>` or set FORMO_API_KEY env var.');

package/dist/lib/config.js

@@ -24,10 +24,17 @@ function readConfig() {
 function saveConfig(updates) {
     const existing = readConfig();
     const merged = { ...existing, ...updates };
+    // The `mode` option on mkdir/writeFile is honored ONLY when the path is
+    // newly created. A pre-existing dir/file (older CLI version, dotfile-sync
+    // tool, another app under ~/.config) keeps its old, possibly
+    // group/world-readable perms — leaking the plaintext API key on a
+    // multi-user host. chmod unconditionally so 0o700/0o600 always holds.
     fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs_1.default.chmodSync(CONFIG_DIR, 0o700);
     fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), {
         mode: 0o600,
     });
+    fs_1.default.chmodSync(CONFIG_FILE, 0o600);
 }
 function clearConfig() {
     try {
@@ -35,6 +42,9 @@ function clearConfig() {
             fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify({}, null, 2), {
                 mode: 0o600,
             });
+            // Same create-only-mode caveat as saveConfig: enforce 0o600 on the
+            // already-existing file so the cleared config can't be left readable.
+            fs_1.default.chmodSync(CONFIG_FILE, 0o600);
         }
     }
     catch {

package/dist/lib/json.d.ts

@@ -0,0 +1,5 @@
+export declare function parseJson(raw: string, flagName: string): unknown;
+export declare function parseJsonObject(raw: string, flagName: string): Record<string, unknown>;
+export declare function parseJsonArray(raw: string, flagName: string): unknown[];
+export declare function parseJsonArrayOfObjects(raw: string, flagName: string): Record<string, unknown>[];
+export declare function parseStringArray(raw: string, flagName: string): string[];

package/dist/lib/json.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = parseJson;
+exports.parseJsonObject = parseJsonObject;
+exports.parseJsonArray = parseJsonArray;
+exports.parseJsonArrayOfObjects = parseJsonArrayOfObjects;
+exports.parseStringArray = parseStringArray;
+function parseJson(raw, flagName) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${flagName} must be valid JSON`);
+    }
+}
+function parseJsonObject(raw, flagName) {
+    const parsed = parseJson(raw, flagName);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${flagName} must be a valid JSON object`);
+    }
+    return parsed;
+}
+function parseJsonArray(raw, flagName) {
+    const parsed = parseJson(raw, flagName);
+    if (!Array.isArray(parsed)) {
+        throw new Error(`${flagName} must be a valid JSON array`);
+    }
+    return parsed;
+}
+function parseJsonArrayOfObjects(raw, flagName) {
+    const parsed = parseJsonArray(raw, flagName);
+    if (parsed.some((item) => !item || typeof item !== 'object' || Array.isArray(item))) {
+        throw new Error(`${flagName} must be a valid JSON array of objects`);
+    }
+    return parsed;
+}
+function parseStringArray(raw, flagName) {
+    const value = raw.trim();
+    if (value.startsWith('[')) {
+        const parsed = parseJsonArray(value, flagName);
+        if (parsed.some((item) => typeof item !== 'string')) {
+            throw new Error(`${flagName} must be a JSON array of strings`);
+        }
+        return parsed;
+    }
+    const parts = value
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        throw new Error(`${flagName} must contain at least one value`);
+    }
+    return parts;
+}

package/dist/lib/sql.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SQL helpers for the query command.
+ *
+ * The Formo query API wraps the SQL you submit so it can paginate the result
+ * set and force a machine-readable response:
+ *
+ *     SELECT * FROM (<your query>) LIMIT <n> FORMAT JSON
+ *
+ * ClickHouse does not allow a `FORMAT` clause inside a subquery, so if your
+ * query ends in its own `FORMAT` clause the wrapped statement becomes:
+ *
+ *     SELECT * FROM (SELECT ... FORMAT CSV) LIMIT 100 FORMAT JSON
+ *
+ * which ClickHouse rejects with a 400. A trailing `FORMAT` (or a trailing
+ * semicolon) can never take effect through this endpoint anyway — the outer
+ * `FORMAT JSON` always wins, and output shaping is the CLI's `--format` job —
+ * so we remove it before sending and let the server wrap a clean query.
+ */
+/**
+ * Strip a trailing, top-level `FORMAT <name>` clause and any trailing
+ * semicolons from a SQL statement.
+ *
+ * The scan is aware of string literals, quoted identifiers, and comments, so
+ * `FORMAT`-looking text inside them is never mistaken for a real clause. The
+ * match is anchored to the end of the statement, so a `FORMAT` nested inside
+ * parentheses (a subquery) or part of an identifier/function such as
+ * `formatDateTime(...)` — or a column aliased `format` — is left untouched.
+ *
+ * Returns the original input unchanged when there is nothing to strip.
+ */
+export declare function stripTrailingFormatClause(sql: string): string;

package/dist/lib/sql.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * SQL helpers for the query command.
+ *
+ * The Formo query API wraps the SQL you submit so it can paginate the result
+ * set and force a machine-readable response:
+ *
+ *     SELECT * FROM (<your query>) LIMIT <n> FORMAT JSON
+ *
+ * ClickHouse does not allow a `FORMAT` clause inside a subquery, so if your
+ * query ends in its own `FORMAT` clause the wrapped statement becomes:
+ *
+ *     SELECT * FROM (SELECT ... FORMAT CSV) LIMIT 100 FORMAT JSON
+ *
+ * which ClickHouse rejects with a 400. A trailing `FORMAT` (or a trailing
+ * semicolon) can never take effect through this endpoint anyway — the outer
+ * `FORMAT JSON` always wins, and output shaping is the CLI's `--format` job —
+ * so we remove it before sending and let the server wrap a clean query.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripTrailingFormatClause = stripTrailingFormatClause;
+/**
+ * Strip a trailing, top-level `FORMAT <name>` clause and any trailing
+ * semicolons from a SQL statement.
+ *
+ * The scan is aware of string literals, quoted identifiers, and comments, so
+ * `FORMAT`-looking text inside them is never mistaken for a real clause. The
+ * match is anchored to the end of the statement, so a `FORMAT` nested inside
+ * parentheses (a subquery) or part of an identifier/function such as
+ * `formatDateTime(...)` — or a column aliased `format` — is left untouched.
+ *
+ * Returns the original input unchanged when there is nothing to strip.
+ */
+function stripTrailingFormatClause(sql) {
+    if (!sql)
+        return sql;
+    const masked = maskLiterals(sql);
+    // A genuine trailing FORMAT clause: the keyword `format` preceded by a word
+    // boundary (so `formatDateTime` or a column aliased `format` is safe),
+    // followed by exactly one identifier (the format name) and nothing else.
+    const formatClause = /(^|[^A-Za-z0-9_])format\s+[A-Za-z_][A-Za-z0-9_]*\s*$/i;
+    let end = sql.length;
+    let didStrip = false;
+    // Peel top-level semicolons and a trailing FORMAT clause repeatedly so any
+    // ordering collapses to the bare query, e.g. `... FORMAT CSV;`,
+    // `...; FORMAT CSV`, or `... FORMAT CSV ;`. Trailing whitespace and comments
+    // are only ever skipped to *look* past them — never removed on their own.
+    for (;;) {
+        let e = end;
+        while (e > 0 && /\s/.test(masked[e - 1]))
+            e--;
+        if (e === 0)
+            break;
+        if (masked[e - 1] === ';') {
+            end = e - 1;
+            didStrip = true;
+            continue;
+        }
+        const match = formatClause.exec(masked.slice(0, e));
+        if (match) {
+            // Cut at the `format` keyword, after the leading word-boundary char.
+            end = match.index + match[1].length;
+            didStrip = true;
+            continue;
+        }
+        break;
+    }
+    if (!didStrip)
+        return sql;
+    // Tidy the real whitespace now left dangling where the clause used to be.
+    // Comments are not whitespace, so any genuine comment is preserved.
+    const stripped = sql.slice(0, end).replace(/\s+$/, '');
+    // Never manufacture an empty query from non-empty input (degenerate inputs
+    // such as a bare `FORMAT JSON`): let the original surface its own error.
+    return stripped === '' ? sql : stripped;
+}
+/**
+ * Return a copy of `sql` with the *contents* of string literals, quoted
+ * identifiers, and comments replaced by spaces, preserving the original length
+ * so indices stay aligned with the source. Quote delimiters are kept; comments
+ * are blanked entirely. This lets the clause scanner reason about real SQL code
+ * without tripping over keywords that merely appear inside literals or comments.
+ */
+function maskLiterals(sql) {
+    const out = [];
+    const n = sql.length;
+    let i = 0;
+    while (i < n) {
+        const c = sql[i];
+        const next = i + 1 < n ? sql[i + 1] : '';
+        // Line comment: -- ... or # ... to end of line. ClickHouse accepts `#`
+        // and `#!` line comments for MySQL compatibility.
+        if ((c === '-' && next === '-') || c === '#') {
+            while (i < n && sql[i] !== '\n') {
+                out.push(' ');
+                i++;
+            }
+            continue;
+        }
+        // Block comment: /* ... */
+        if (c === '/' && next === '*') {
+            out.push(' ', ' ');
+            i += 2;
+            while (i < n && !(sql[i] === '*' && sql[i + 1] === '/')) {
+                out.push(' ');
+                i++;
+            }
+            if (i < n) {
+                out.push(' ', ' ');
+                i += 2;
+            }
+            continue;
+        }
+        // String literal or quoted identifier: '...', "...", `...`
+        if (c === "'" || c === '"' || c === '`') {
+            const quote = c;
+            out.push(quote);
+            i++;
+            while (i < n) {
+                const d = sql[i];
+                // Backslash escapes are honored inside single-quoted strings.
+                if (d === '\\' && quote === "'") {
+                    out.push(' ');
+                    i++;
+                    if (i < n) {
+                        out.push(' ');
+                        i++;
+                    }
+                    continue;
+                }
+                if (d === quote) {
+                    // A doubled delimiter is an escaped quote, not the terminator.
+                    if (i + 1 < n && sql[i + 1] === quote) {
+                        out.push(' ', ' ');
+                        i += 2;
+                        continue;
+                    }
+                    out.push(quote);
+                    i++;
+                    break;
+                }
+                out.push(' ');
+                i++;
+            }
+            continue;
+        }
+        out.push(c);
+        i++;
+    }
+    return out.join('');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formo/cli",
-  "version": "0.2.0",
-  "packageManager": "pnpm@10.28.2",
+  "version": "1.0.2",
+  "packageManager": "pnpm@11.1.2",
   "description": "Formo API CLI — query profiles and analytics data",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     "test:watch": "mocha --watch"
   },
   "dependencies": {
-    "axios": "^1.7.0",
+    "axios": "^1.15.2",
     "incur": "^0.3.4"
   },
   "overrides": {