@norbix.ai/cli 0.3.0 → 1.0.0

package/README.md

@@ -125,6 +125,29 @@ pipe into `jq`:
 norbix db find orders --json | jq '.list.items[] | ._id'
 ```
 
+## Errors
+
+A failed call prints one line: the error code, the message, and the HTTP
+status.
+
+```sh
+$ norbix files info nbin_1 a/b.txt
+ ›   Error: CM-ERRORS-FILES-016: File not found: "a/b.txt" does not exist in
+ ›   Local (nbin_1). (HTTP 404)
+```
+
+The code and the message are the gateway's own — they come out of
+`responseStatus.errors[]`, where the gateway puts them. Before this, every
+failure read "Request failed with status 404" with no code.
+
+Exit codes do not change: `1` for a failed call, `2` for a check that ran and
+came back negative (`norbix files integrations test`).
+
+**A refusal the gateway answers with HTTP 200** and
+`responseStatus.isSuccess = false` now exits non-zero as well, wherever it did
+not before — `norbix files publish` / `unpublish` were the two commands that
+used to treat it as a success.
+
 ## Development
 
 ```sh

package/dist/base.js

@@ -157,12 +157,23 @@ export class BaseCommand extends Command {
             this.log(typeof data === 'string' ? data : JSON.stringify(data, null, 2));
         }
     }
+    /**
+     * One line for a failed call: `<errorCode>: <message> (HTTP <status>)`.
+     *
+     * The code comes first because it is the part a reader can search for and a
+     * script can match on. It is the gateway's own code — the SDK reads it out
+     * of `responseStatus.errors[]`, where the gateway puts it (10b-files slice
+     * ERRORS, issue #66). The exit codes do not change.
+     */
     async catch(error) {
         if (error instanceof NorbixError) {
-            const status = error.status;
-            const suffix = status ? ` (HTTP ${status})` : '';
+            const { code, status } = error;
+            const prefix = code ? `${code}: ` : '';
+            // The SDK's last-resort message already ends in "(HTTP <status>)" —
+            // do not say it twice.
+            const suffix = status && !error.message.includes(`(HTTP ${status})`) ? ` (HTTP ${status})` : '';
             const hint = status === 401 ? '\nYour session may have expired. Run `norbix login` again.' : '';
-            return this.error(`${error.message}${suffix}${hint}`);
+            return this.error(`${prefix}${error.message}${suffix}${hint}`);
         }
         return super.catch(error);
     }

package/dist/lib/filesIntegrationTest.js

@@ -1,4 +1,4 @@
-import { NorbixAuthError, NorbixError, NorbixValidationError } from '@norbix.ai/ts';
+import { gatewayError } from './gatewayError.js';
 /** The API version the SDK talks by default. Kept in one place. */
 const API_VERSION = 'v2';
 export async function callTestFilesIntegration(ctx, filesIntegrationId) {
@@ -32,23 +32,9 @@ export async function callTestFilesIntegration(ctx, filesIntegrationId) {
         }
     }
     if (!response.ok)
-        throw errorFrom(response.status, raw, url);
+        throw gatewayError(response.status, raw, url);
     return (raw && typeof raw === 'object' ? raw : {});
 }
-/** Same mapping as the SDK transport: 401/403 → auth, 400 → validation, else NorbixError. */
-function errorFrom(status, raw, url) {
-    const body = raw && typeof raw === 'object' ? raw : undefined;
-    const payload = body?.responseStatus ?? body;
-    const message = payload?.message ??
-        body?.responseStatus?.errors?.find((e) => e.message)?.message ??
-        `Request failed with status ${status}`;
-    const opts = { code: payload?.errorCode, message, raw, status, url };
-    if (status === 401 || status === 403)
-        return new NorbixAuthError(opts);
-    if (status === 400)
-        return new NorbixValidationError(opts);
-    return new NorbixError(opts);
-}
 /** `Failed` / `NotTested` / `NOT_TESTED` → `FAILED` / `NOT_TESTED`. */
 export function normaliseResult(result) {
     if (!result)

package/dist/lib/gatewayError.js

@@ -0,0 +1,58 @@
+import { NorbixAuthError, NorbixError, NorbixValidationError } from '@norbix.ai/ts';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** The `responseStatus` block of a body, whatever the casing of the key. */
+function responseStatusOf(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    for (const key of Object.keys(raw)) {
+        if (key.toLowerCase() === 'responsestatus') {
+            const value = raw[key];
+            return isRecord(value) ? value : undefined;
+        }
+    }
+    return undefined;
+}
+function text(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function itemsOf(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => isRecord(entry)).map((entry) => entry);
+}
+/**
+ * True when the gateway said the call failed inside the body.
+ *
+ * A business refusal — an unknown id, a rule that says no — comes back as HTTP
+ * 200 with `responseStatus.isSuccess = false` (10b-files, issue #67).
+ */
+export function saysItFailed(raw) {
+    const status = responseStatusOf(raw);
+    return isRecord(status) && status.isSuccess === false;
+}
+/** The message and the error code a gateway answer carries. */
+export function readGatewayError(raw, status) {
+    const responseStatus = responseStatusOf(raw);
+    // `source` is responseStatus when the body has one, the body itself when it
+    // has none — so the top-level fields are read only in the second case.
+    const source = responseStatus ?? (isRecord(raw) ? raw : undefined);
+    const errors = itemsOf(source?.errors);
+    const first = errors.find((e) => e.message !== undefined || e.errorCode !== undefined);
+    return {
+        code: first?.errorCode ?? text(source?.errorCode),
+        errors,
+        message: first?.message ?? text(source?.message) ?? `Request failed (HTTP ${status})`,
+    };
+}
+/** Build the right NorbixError for a status and an already-parsed body. */
+export function gatewayError(status, raw, url) {
+    const { code, message } = readGatewayError(raw, status);
+    const opts = { code, message, raw, status, url };
+    if (status === 401 || status === 403)
+        return new NorbixAuthError(opts);
+    if (status === 400)
+        return new NorbixValidationError(opts);
+    return new NorbixError(opts);
+}

package/dist/lib/publicFiles.js

@@ -1,4 +1,4 @@
-import { NorbixError } from '@norbix.ai/ts';
+import { gatewayError, saysItFailed } from './gatewayError.js';
 const ROUTES = {
     makeFilePrivate: 'files/item/private',
     makeFilePublic: 'files/item/public',
@@ -27,23 +27,23 @@ export async function callPublicFiles(ctx, operation, body) {
     const url = `${base}/${HUB_VERSION}/${ROUTES[operation]}`;
     const response = await fetch(url, { body: JSON.stringify(body), headers, method: 'POST' });
     const text = await response.text();
-    let payload = {};
+    let raw;
     if (text) {
         try {
-            payload = JSON.parse(text);
+            raw = JSON.parse(text);
         }
         catch {
-            payload = {};
+            raw = text;
         }
     }
-    if (!response.ok) {
-        throw new NorbixError({
-            code: payload.status,
-            message: payload.message ?? text ?? 'Request failed',
-            status: response.status,
-        });
-    }
-    return payload;
+    if (!response.ok)
+        throw gatewayError(response.status, raw, url);
+    // A 2xx does not mean the call worked: the gateway answers a business
+    // refusal with HTTP 200 and responseStatus.isSuccess = false, and the
+    // command must exit non-zero for it (10b-files, issue #67).
+    if (saysItFailed(raw))
+        throw gatewayError(response.status, raw, url);
+    return (raw && typeof raw === 'object' ? raw : {});
 }
 /**
  * The address anyone can open. The gateway builds the same one and puts it on