n8n-nodes-apexapi 0.1.2 → 0.1.4

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

@@ -117,12 +117,23 @@ class ApexApi {
                     type: 'options',
                     displayOptions: { show: { resource: ['image'] } },
                     options: [
-                        { name: 'Square — 1:1 (1024×1024)', value: '1024x1024' },
-                        { name: 'Landscape — 16:9 (1344×768)', value: '1344x768' },
-                        { name: 'Portrait — 9:16 (768×1344)', value: '768x1344' },
+                        { name: 'Square 1:1 — 1024×1024', value: '1024x1024' },
+                        { name: 'Square 1:1 — 1080×1080', value: '1080x1080' },
+                        { name: 'Portrait 9:16 — 1080×1920', value: '1080x1920' },
+                        { name: 'Landscape 16:9 — 1920×1080', value: '1920x1080' },
+                        { name: 'Custom (WIDTHxHEIGHT)…', value: 'custom' },
                     ],
                     default: '1024x1024',
-                    description: 'Output resolution / aspect ratio. Note: some models only support specific sizes.',
+                    description: 'Output size / aspect ratio. Works on every model — the API adapts it per provider (exact pixels for fal/flux, nearest aspect ratio for Imagen/Gemini/GPT-Image).',
+                },
+                {
+                    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',
@@ -227,15 +238,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: this.getNodeParameter('imageSize', i, '1024x1024'),
+                        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-apexapi",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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"
   }
 }