Hi, Is it possible to create custom asynchronous functions in suitescript (ie not just using the built in supported promise functions)? I’m trying to run a big search in the background while doing other stuff and then when the search.run().each() has finished doing what I want it to do, I’ll handle the results. I have a scheduled script like the one below, and I would be expecting the order of the logs to be: 1. “Start of runSearch” 2. “Meanwhile” 3. “Finishing runSearch” 4. “myResults” But instead, “Meanwhile” doesn’t log until runSearch() has finished (which I know, because in my actual script I’m also logging the time elapsed), and “Finishing runSearch” and “myResults” don’t log at all. So I’m having a few problems, one being that the promise doesn’t seem to work since it’s not logging everything, another being that the async execute function seems to wait until the promise function has finished even though I’m not using the await keyword when I call it, and the last one being that for some reason the “myResults” line doesn’t even log at all. Any thoughts?

async function execute(scriptContext) {
    let transactionSearch = search.load('searchinternalid')
    let pendingPromise = runSearch(transactionSearch);
    log.debug('execute', 'Meanwhile');
    let myResults = await pendingPromise;
    log.debug('execute', 'myResults: ' + JSON.stringify(myResults))

}

function runSearch(transactionSearch) {
    log.debug('runSearch', 'Start of runSearch');
    let searchResults = [];
    return new Promise(resolve => {
        transactionSearch.run().each(result => {
            searchResults.push(result.id);
            return true;
        });
        log.debug('runSearch', 'Finishing runSearch');
        resolve(searchResults);
    })
}

the point of asynchronous functions is to do something else while waiting for the results from some other process

I know I’m not handling errors here, this was a very basic example for when I’m not even getting an error-free scenario to work. I realize I am probably building the logic incorrectly, but I thought I was triggering the runSearch so it could do its thing in the background and wouldn’t check for its status until the await pendingPromise line

your description of meanwhile is normal, its how Promises work, your code doesnt do anything asynchronus, its immediately resolves

the Promise you wrote is trying to wait on itself

This is where I probably don’t fully understand how promises work. I’ve been spending quite some time reading up on them but I’m clearly still missing the basic understanding haha

same answer, asynchronous code allows your code to do something else while waiting for the result of something else

I will definitely add the try/catch to log the errors then, thank you for catching that (😉). Is there a way to make the runSearch() function asynchronous? I thought creating a promise that doesn’t resolve until it’s done with the processing meant waiting for something

your promise runs a search and tries (and probably fails) to build an array of ids

I appreciate your help a lot, thank you. I don’t want to take up too much of your time, so can I just ask if there are any changes you would suggest I make to be able to process the search results in the background while doing other stuff?

Should I use that to process the results in my runSearch function?

yes

I tried changing to that, which inside the runSearch function it seemed to work, because I added a line of logging before the return Promise line and that line was logged immediately, before the results were processed. But the “meanwhile” in the main function still wasn’t logged until after the runSearch was finished. So it seems like the specific ResultSet.each.promise part of runSearch() runs asynchronously, but the entire runSearch() as such doesn’t, so the main script won’t continue until it’s done. Which I guess makes sense, but is there a way to make the runSearch run asynchronously?

what did your attempt look like

I cleaned up the actual code some and ran it again and I may have misspoke, but it’s still leaving me confused. It looks like this

async function execute(scriptContext) {
    startTime = Date.now();
    log.debug('execute', getElapsedTime() + ': START execute');

    let transactionSearch = search.create({
        type: search.Type.TRANSACTION,
        columns: ['tranid', 'entity', 'trandate', 'item', 'type']
    });
    let promise;
    try {
        promise = runSearch(transactionSearch);
    } catch (e) {
        log.error('execute', getElapsedTime() + ': catch 1 error: ' + JSON.stringify(e))
    }

    log.debug('test', getElapsedTime() + ': meanwhile.....');

    let results;
    try {
        results = await promise;
        log.debug('test', getElapsedTime() + ': results: ' + results.length);
    } catch (e) {
        log.error('execute', getElapsedTime() + ': catch 2 error: ' + JSON.stringify(e))
    }
}

function getElapsedTime() {
    return Date.now() - startTime
}

function runSearch(search) {
    log.debug('test', getElapsedTime() + ': starting to run search')
    let searchResults = [];
    return new Promise(resolve => {
        let counter = 0;
        search.run().each.promise(result => {
            counter++;
            let lineObj = {
                internalid: result.id,
                tranid: result.getValue('tranid'),
                trandate: result.getValue('trandate')
            }
            searchResults.push(lineObj);
            if (searchResults.length === 999) log.debug('test', getElapsedTime() + ': 999 results')
            return true;
        });
        log.debug('test', getElapsedTime() + ': finishing run search');
        resolve(searchResults);
    });
}

this try catch is useless

try {
        promise = runSearch(transactionSearch);
    } catch (e) {
        log.error('execute', getElapsedTime() + ': catch 1 error: ' + JSON.stringify(e))
    }

I feel like there’s one big puzzle piece I’m missing to fully understand the concept 😅 If I use “await”, doesn’t that tell the script to pause until the promise has been resolved? While what I want to do is for the script to not wait right away, I want it to start the “runSearch” function on the line “promise = runSearch(transactionSearch)“, but then I want it to immediately move onto the “log.debug(‘test’, getElapsedTime() + ’: meanwhile.....’);” line. Then, on the “results = await promise”, I want to wait until the search results have been processed, which I’m trying to flag with the “resolve(searchResults)” in the runSearch() function

its somewhat hidden when you use async and await

I’m not a trained programmer by any means, I’m self-taught and I’ve learned what I needed to do my job, so that’s why I’m lacking an understanding of certain areas and promises seems to be one of them, where my reading up on it hasn’t really helped

but the point of the Promise is that you return that Promise and attach functions to it to define what you do after that Promise resolves

I did notice that too haha, but how do I make sure the promise doesn’t resolve until the search is done?

you havent gotten very far on learning Promises if you dont know when to use the then method

Haha no, you’re right, I’ve never used them before and all the examples I’ve come across have looked similar to this one, which doesn’t include any then methods. But I’ll try to find better resources where I can learn about them from scratch

its basically hidden when you use async and await, but there is an implicit then on the pending Promise that encapsulates all the code that is awaiting that promise

I have a hard time understanding promises as well. 🙂 Basically, is there any way of running multiple query.runSuiteQL().asMappedResults() in parallel in a suitelet(serverside). Or does that function contain cpu blocking code that prevents it? All my attempts of running two queries at once using promises and async/await still takes timeToRunOneQuery*2 I have a frontend that needs a lot of data and thought it would be good to fetch multiple pages of 5000 rows in parallel in the backend suitelet. But as I can't get that to work, I'll let the frontend make parallel calls to the suitelet to see if that works.

@Watz you havent shared your code, but if

query.runSuiteQL().asMappedResults()

is representative of your attempts, then you are making the same mistake as @Madelene Sköld

Yeah, I probably am. I tried to wrap

query.runSuiteQL().asMappedResults()

in a promise. But as you say, only the api's that have a promise version actually works to run asynchronously. And runSuiteQL doesn't.

same mistake as the original, your code is mostly synchronous

haha

step through your code using the debugger

Ok, running it through the debugger shows that everything is synchronous. But why? I've read examples where you can do Promise.all([]) on returned promise.

none of the methods you use return promises or are asnychronous

I thought await Promise.all([]) was the waiting bit

it wouldnt actually wait for anything, both of the Promises you passed it are already fulfilled

hm, but disregard the bit where the function execSuiteQLAsync is incorrect and replace that with a bunch of search.lookupFields.promise(options). Would those still not be executed as fast as the slowest one?

depends on how many you mean by a bunch

4?

your browser still will only make so many requests at the same time

Ah, but in server-script?

and netsuite has a finite number of database connections it will use for you

But the logic in the code is then sound?

not really, you made the same mistakes as madellene

😂

your try catch in the Promise is wrong

Could you give a small sample on how it should look?

you will not get a useful education on how to use Promises from netsuite's documentation

Just for a simple lookupFields

ill consider it when i see you share something that convinces me you know how to use Promises

Ok, let me get back on that! 😁 The frontend path that I took instead seems to be working very nicely with 15 fetch's running in semi-parallel (limited by broweser)

@Watz how did you make the 7 asynchronous calls, did you use Promise.all for that?

(I found out it was only 6 asynchronous calls, limited by the browser) Yes I did use Promise.all(), all of this is running in the client and is independent of Suitescript/Netsuite. The only connection is that it calls a Suitelet. Here is the jist of it, edited out some irrelevant parts of it.

I’m sorry, I didn’t see this reply at all. Thank you so much, I’ll take a look and see if I can draw inspiration from it that I can apply on my project! 😄