I just put a small patch online: version 1.0.3.

I found a bug that occurred when NativeJS code called a global function. It concerned the management of variable scopes which was not respected. NativeJS tried to access variables out of scope and this caused a bug that prevents the execution of the code. This is now fixed. 

Hello everyone, 

I improved NativeJS to fix one bug with the date type return value. Now it works fine and you can get any date type like this:

#{:date return Date.now()}# 

return a Ninox date value : 22/11/2022 

var myDate := now()
"on "+ #{:date return myDate}# + " at " + #{:time return myDate}#

return a string with date + time : on 22/11/2022 at 21:09

NativeJS version 1.0.4

Please read this message about the Ninext shutdown : https://forum.ninox.com/t/m1h0b4d/ninext-important-information

Based onSotirios Zormpas' post https://forum.ninox.com/t/x2yp1qy?r=y4yp1a1, I created a global function that merges two PDF files into one. Many thanks to Sotirios for his excellent post — this is a perfect use case for NativeJS!

I updated the #Ninext 2-3 application with a page that demonstrates how to use this function. The updated application is available for download here: https://docs.ninext.fr/ninext-app-38

First, a simple case to merge two PDF files:

Button code: Merge PDF 1 and PDF 2

"Merge PDF 1 and PDF 2 into a single dataUrl";
var mergedPDF := mergeTwoPDFs(text(shareFile('PDF 1')), text(shareFile('PDF 2')));

"Import the merged PDF into the 'PDF 1 + 2' field";
'PDF 1 + 2' := importFile(this, mergedPDF, "File name.pdf")

Then a more complex yet common use case. It prints a first page using a print layout (here the customer description), then appends all invoices for that customer:

Button code: Print report

"Remove existing files before generating new ones";
removeFile('Customer report file');
removeFile('invoice file');

"Build the output filename from customer's first and last name";
var FileName := ---
{ 'Selected customer'.'First Name' } { 'Selected customer'.'Last Name' }.pdf
    ---;

"Generate and import the customer report as the initial PDF";
alert("Printing customer report");
'Customer report file' := importFile(this, printAndSaveRecord('Selected customer', "Kunde"), FileName);

"Loop through all invoices of the selected customer";
for invoice in 'Selected customer'.Invoices do
    "Generate and import the current invoice PDF";
    alert("Printing invoice No " + invoice.'Invoice No');
    'invoice file' := importFile(this, printAndSaveRecord(invoice, "Invoice"));

    "Merge the customer report with the current invoice and update the report file";
    'Customer report file' := importFile(this, mergeTwoPDFs(text(shareFile('Customer report file')), text(shareFile('invoice file'))), FileName);

    "Clean up the temporary invoice file";
    removeFile('invoice file')
end;

"Notify user that the process is complete";
alert("Report completed")

Finally, here is the global function itself:

Global function: mergeTwoPDFs

"----------------------------
mergeTwoPDFs - Merge two PDF files
Parameters:
  - url1 : URL or dataUrl of the first PDF (can be null or empty)
  - url2 : URL or dataUrl of the second PDF (can be null or empty)
Returns: dataUrl of the merged PDF (data:application/pdf;base64,...)
         or the valid URL if the other is null/empty
         or null if both are null/empty
-----------------------------";

function mergeTwoPDFs(url1 : text, url2 : text) do
    #{:text:callback
    (async () => {
        try {
            const DATA_URL_PREFIX = 'data:application/pdf;base64,';

            "--- Helper Functions ---";

            "Convert ArrayBuffer to base64 dataUrl";
            function bufferToDataUrl(buffer) {
                const uint8Array = new Uint8Array(buffer);
                let binary = '';
                for (let i = 0; i < uint8Array.length; i++) {
                    binary += String.fromCharCode(uint8Array[i]);
                }
                return DATA_URL_PREFIX + btoa(binary);
            }

            "Load PDF buffer from URL or dataUrl";
            async function loadPdfBuffer(url) {
                if (!url || !url.trim()) return null;

                if (url.startsWith(DATA_URL_PREFIX)) {
                    const binary = atob(url.replace(DATA_URL_PREFIX, ''));
                    const bytes = new Uint8Array(binary.length);
                    for (let i = 0; i < binary.length; i++) {
                        bytes[i] = binary.charCodeAt(i);
                    }
                    return bytes.buffer;
                }

                const res = await fetch(url);
                return res.ok ? await res.arrayBuffer() : null;
            }

            "Convert URL to dataUrl format";
            async function toDataUrl(url) {
                if (!url || !url.trim()) return null;
                if (url.startsWith(DATA_URL_PREFIX)) return url;

                const buffer = await loadPdfBuffer(url);
                return buffer ? bufferToDataUrl(buffer) : null;
            }

            "--- Main Logic ---";

            const hasUrl1 = url1 && url1.trim() !== '';
            const hasUrl2 = url2 && url2.trim() !== '';

            "Handle edge cases: none or single URL";
            if (!hasUrl1 && !hasUrl2) { callback(null); return; }
            if (!hasUrl1) { callback(await toDataUrl(url2)); return; }
            if (!hasUrl2) { callback(await toDataUrl(url1)); return; }

            "Load pdf-lib dynamically if needed";
            if (typeof PDFLib === 'undefined') {
                await new Promise((resolve, reject) => {
                    const script = document.createElement('script');
                    script.src = 'https://cdn.jsdelivr.net/npm/pdf-lib@1.17.1/dist/pdf-lib.min.js';
                    script.onload = resolve;
                    script.onerror = () => reject(new Error('Unable to load pdf-lib'));
                    document.head.appendChild(script);
                });
            }

            "Create merged PDF document";
            const pdfDoc = await PDFLib.PDFDocument.create();

            "Load and merge both PDFs";
            for (const url of [url1, url2]) {
                const buffer = await loadPdfBuffer(url);
                if (buffer) {
                    const pdf = await PDFLib.PDFDocument.load(buffer);
                    const pages = await pdfDoc.copyPages(pdf, pdf.getPageIndices());
                    pages.forEach(p => pdfDoc.addPage(p));
                }
            }

            "Return merged PDF as dataUrl";
            callback(bufferToDataUrl(await pdfDoc.save()));

        } catch (error) {
            callback(null, error.message);
        }
    })();
    }#
end;