n8n-nodes-apexapi 0.1.1 → 0.1.3

package/dist/nodes/ApexApi/ApexApi.node.js

@@ -111,6 +111,34 @@ class ApexApi {
                     default: '',
                     required: true,
                 },
+                {
+                    displayName: 'Size',
+                    name: 'imageSize',
+                    type: 'options',
+                    displayOptions: { show: { resource: ['image'] } },
+                    options: [
+                        { name: 'Square 1:1 — 1024×1024', value: '1024x1024' },
+                        { name: 'Square 1:1 — 1080×1080 (Instagram post)', value: '1080x1080' },
+                        { name: 'Portrait 9:16 — 1080×1920 (Story / Reel / TikTok)', value: '1080x1920' },
+                        { name: 'Landscape 16:9 — 1920×1080 (YouTube / X)', value: '1920x1080' },
+                        { name: 'Landscape 1.91:1 — 1200×630 (Facebook / link share)', value: '1200x630' },
+                        { name: 'Portrait 4:5 — 1080×1350 (Instagram portrait)', value: '1080x1350' },
+                        { name: 'Portrait 2:3 — 1024×1536', value: '1024x1536' },
+                        { name: 'Landscape 3:2 — 1536×1024', value: '1536x1024' },
+                        { name: 'Custom (WIDTHxHEIGHT)…', value: 'custom' },
+                    ],
+                    default: '1024x1024',
+                    description: 'Output resolution / aspect ratio. Note: some models only support specific sizes. Max 4096 per side.',
+                },
+                {
+                    displayName: 'Custom Size',
+                    name: 'customSize',
+                    type: 'string',
+                    placeholder: '1024x1024',
+                    displayOptions: { show: { resource: ['image'], imageSize: ['custom'] } },
+                    default: '1024x1024',
+                    description: 'Width×height in pixels, e.g. 1024x1024. Each side 1–4096.',
+                },
                 {
                     displayName: 'Options',
                     name: 'options',
@@ -118,10 +146,7 @@ class ApexApi {
                     placeholder: 'Add Option',
                     displayOptions: { show: { resource: ['image'] } },
                     default: {},
-                    options: [
-                        { displayName: 'Size', name: 'size', type: 'string', default: '1024x1024' },
-                        { displayName: 'Number of Images', name: 'n', type: 'number', default: 1 },
-                    ],
+                    options: [{ displayName: 'Number of Images', name: 'n', type: 'number', default: 1 }],
                 },
                 // ---- Video ----
                 {
@@ -182,7 +207,7 @@ class ApexApi {
         this.methods = {
             loadOptions: {
                 async getChatModels() {
-                    return (0, loadOptions_1.loadModels)(this, 'text');
+                    return (0, loadOptions_1.loadModels)(this, 'chat');
                 },
                 async getImageModels() {
                     return (0, loadOptions_1.loadModels)(this, 'image');
@@ -217,15 +242,33 @@ class ApexApi {
                 }
                 else if (resource === 'image') {
                     const options = this.getNodeParameter('options', i, {});
+                    const sizeChoice = this.getNodeParameter('imageSize', i, '1024x1024');
+                    const size = sizeChoice === 'custom'
+                        ? this.getNodeParameter('customSize', i, '1024x1024')
+                        : sizeChoice;
                     const body = (0, image_1.buildImageBody)({
                         model: this.getNodeParameter('model', i),
                         prompt: this.getNodeParameter('prompt', i),
-                        size: options.size,
+                        size,
                         n: options.n,
                     });
                     const resp = await (0, transport_1.apexApiRequest)(ctx, 'POST', '/images/generations', body);
                     const parsed = (0, image_1.parseImageResponse)(resp);
                     json = { urls: parsed.urls, response: parsed.raw };
+                    // Some providers (Vertex/Imagen) return inline base64 instead of a hosted
+                    // link. Emit those as n8n binary so the next node can post/upload them
+                    // directly — hosted-URL providers (fal/kie) just come through in `urls`.
+                    const b64Images = parsed.images.filter((im) => im.base64);
+                    if (b64Images.length > 0) {
+                        const binary = {};
+                        for (let k = 0; k < b64Images.length; k++) {
+                            const im = b64Images[k];
+                            const ext = (im.mimeType ?? 'image/png').split('/')[1] ?? 'png';
+                            binary[k === 0 ? 'data' : `data${k}`] = await this.helpers.prepareBinaryData(Buffer.from(im.base64, 'base64'), `image_${k}.${ext}`, im.mimeType);
+                        }
+                        returnData.push({ json, binary, pairedItem: { item: i } });
+                        continue;
+                    }
                 }
                 else {
                     // video

package/dist/shared/image.js

@@ -10,11 +10,29 @@ function buildImageBody(params) {
         body.n = params.n;
     return body;
 }
+const DATA_URL_RE = /^data:([^;,]+);base64,(.+)$/;
+/**
+ * Normalise the `/v1/images/generations` response. Providers return images two
+ * ways: a hosted URL (fal/kie) or inline base64 (Vertex/Imagen `data:` URLs, or
+ * `b64_json`). `urls` holds only real links; `images` holds every image with the
+ * base64 decoded out of `data:` URLs so the node can emit it as n8n binary.
+ */
 function parseImageResponse(resp) {
     const r = resp;
     const data = Array.isArray(r?.data) ? r.data : [];
-    const urls = data
-        .map((d) => d?.url)
-        .filter((u) => typeof u === 'string');
-    return { urls, raw: resp };
+    const images = [];
+    for (const d of data) {
+        if (typeof d?.url === 'string') {
+            const m = d.url.match(DATA_URL_RE);
+            if (m)
+                images.push({ base64: m[2], mimeType: m[1] });
+            else
+                images.push({ url: d.url });
+        }
+        else if (typeof d?.b64_json === 'string') {
+            images.push({ base64: d.b64_json, mimeType: 'image/png' });
+        }
+    }
+    const urls = images.map((i) => i.url).filter((u) => typeof u === 'string');
+    return { urls, images, raw: resp };
 }

package/dist/shared/loadOptions.js

@@ -1,10 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadModels = loadModels;
-const transport_1 = require("./transport");
+const constants_1 = require("./constants");
 const models_1 = require("./models");
+/**
+ * Load the model dropdown options for a resource. The `/v1/models` endpoint is
+ * PUBLIC, so this uses the unauthenticated request helper and works even before
+ * a credential is attached — that avoids n8n's "error fetching options" when the
+ * key hasn't been entered yet. The base URL comes from the credential when
+ * present, otherwise the default.
+ */
 async function loadModels(ctx, modelType) {
-    const resp = await (0, transport_1.apexApiRequest)(ctx, 'GET', '/models');
+    let baseUrl = constants_1.DEFAULT_BASE_URL;
+    try {
+        const creds = await ctx.getCredentials(constants_1.CREDENTIAL_NAME);
+        if (creds && creds.baseUrl)
+            baseUrl = String(creds.baseUrl);
+    }
+    catch {
+        // No credential attached yet — /models is public, so fall back to the
+        // default base URL and load the list anyway.
+    }
+    baseUrl = baseUrl.replace(/\/+$/, '');
+    const http = ctx.helpers.httpRequest;
+    if (!http)
+        return [];
+    const resp = (await http({ method: 'GET', url: `${baseUrl}/models`, json: true }));
     const data = Array.isArray(resp?.data) ? resp.data : [];
     return (0, models_1.mapModelsToOptions)(data, modelType);
 }

package/dist/shared/models.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapModelsToOptions = mapModelsToOptions;
 /**
  * Map the `/v1/models` `data` array to n8n dropdown options. When `modelType`
- * is given, keep only models of that type (text/image/video); if that leaves
- * nothing, fall back to all models rather than showing an empty dropdown.
+ * is given, keep only models of that type (chat/image/video — matching the live
+ * /v1/models `type` field); if that leaves nothing, fall back to all models
+ * rather than showing an empty dropdown.
  */
 function mapModelsToOptions(models, modelType) {
     const filtered = modelType ? models.filter((m) => m.type === modelType) : models;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-apexapi",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "n8n community node for ApexApi — call 14 AI providers (OpenAI, Anthropic, Google, Mistral, and more) through one OpenAI-compatible API.",
   "keywords": [
     "n8n-community-node-package",
@@ -46,6 +46,7 @@
   "devDependencies": {
     "n8n-workflow": "^1.82.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "@types/node": "^22.0.0"
   }
 }