@norbix.ai/cli 0.3.0 → 1.1.0

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

package/dist/lib/push.js

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+import { Flags } from '@oclif/core';
+import { readJsonInput } from './json.js';
+/**
+ * Read a JSON object from a flag: inline JSON, `-` for stdin, or `@path` for a
+ * file. Used by the push commands whose body is too rich for flags alone
+ * (template translations, provider credentials, campaign audiences).
+ */
+export async function readJsonObject(value, flagName) {
+    const raw = value.startsWith('@') ? readFileSync(value.slice(1), 'utf8') : value;
+    const parsed = JSON.parse(await readJsonInput(raw, flagName));
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`--${flagName} must be a JSON object`);
+    }
+    return parsed;
+}
+/** Turn repeated `--token key=value` flags into token mappings with the Custom resolver. */
+export function parseTokens(values) {
+    if (!values?.length)
+        return undefined;
+    return values.map((pair) => {
+        const at = pair.indexOf('=');
+        if (at < 1)
+            throw new Error(`--token must look like key=value, got "${pair}"`);
+        return { key: pair.slice(0, at), value: pair.slice(at + 1), resolver: 'Custom' };
+    });
+}
+/**
+ * Build the template body. Either --translations (a JSON array, @file or -)
+ * for several languages, or --title + --body for one language.
+ */
+export async function templateBody(flags) {
+    let translations;
+    if (flags.translations) {
+        const raw = flags.translations.startsWith('@') ? readFileSync(flags.translations.slice(1), 'utf8') : flags.translations;
+        translations = JSON.parse(await readJsonInput(raw, 'translations'));
+        if (!Array.isArray(translations))
+            throw new Error('--translations must be a JSON array');
+    }
+    else {
+        if (!flags.title || !flags.body) {
+            throw new Error('Pass --title and --body, or --translations for several languages.');
+        }
+        translations = [{ language: flags.language, content: { title: flags.title, body: flags.body } }];
+    }
+    return {
+        templateName: flags.name,
+        description: flags.description,
+        communicationChannel: flags.channel,
+        tags: flags.tag,
+        translations,
+    };
+}
+export const templateFlags = {
+    name: Flags.string({ required: true, description: 'Template name' }),
+    description: Flags.string({ description: 'What the template is for' }),
+    channel: Flags.string({
+        description: 'Communication channel',
+        options: ['Transactional', 'Marketing', 'System'],
+        default: 'Transactional',
+    }),
+    tag: Flags.string({ description: 'Tag (repeat for several)', multiple: true }),
+    language: Flags.string({ description: 'Language of --title / --body', default: 'en' }),
+    title: Flags.string({ description: 'Push title (Razor allowed)' }),
+    body: Flags.string({ description: 'Push body (Razor allowed)' }),
+    translations: Flags.string({
+        description: 'All languages as a JSON array of {language, content: {title, body}} — inline, @file or -',
+        exclusive: ['title', 'body'],
+    }),
+};