Skip to main content

Um, yeah - it is. But first, a little of the backstory.

As is often the case just when you’ve thought you’ve seen it all, a client asks -

Is it possible to chain blocks and run them sequentially - as one completes, the next one starts?

No, right?

But then she tossed in another requirement -

The computational results from the first block must be available to the next block and sometimes to all subsequent blocks.

Oy! Nothing like a mind-bender for a Monday morning.

This business requirement is daunting – indeed, impossible given the nature of Script Blocks. I’m sure the Airtable folks have pondered this, but as it stands, it’s off the table for now, right? Indeed, Script Blocks are simply not capable … until and unless … you factor in the amazing power of that which Airtable is known and most famous for - simple data/content management with an intimate relationship with integrated script.

Often, it is the alchemy of data and code that spark the most remote possibilities into a new reality.

Simple Workflow Example - a Happiness Survey

Imagine a three-step process asking basic questions about your day. It’s a survey per-se and I’ve embodied the essence of it into a simple table shown below. Each step has a question and a column for answers. Lastly, there’s a final step - Happiness Assessment - that computes your relative happiness based on your answers

The following screenshot shows this three-step process but also displays a very important field showing Block Script in a long text field.

As I mentioned, each step is a question, and each question is presented abstractly in the script using the value in the first column (i.e., Process Step). The final stage in the process is based upon the answers at each step in the survey process.

BlockChaining

To do this elegantly and well, chaining together different script blocks is ideal.

Each script in each process is loaded and executed sequentially. A single “runner” Block orchestrates the execution of each data-based block and it manages the in-memory scope of the results from start to finish.

The final step includes the block shown below which displays the resulting happiness assessment. Note the reference to aRecords - this is the variable that contains all of the answers gathered from each of the chained blocks.

And the outcome in the block runner reveals this display when all four steps have completed.

Summary

Block chaining is possible. In and of itself, this is an important realization. While my example is super simple and somewhat lame, imagine the incredible solutions that could be built by chaining block scripts together in easily-managed table data.

  • The execution order of block segments could be altered by simply dragging table rows.
  • Imagine using this to administer dynamic tests where specific (named) users must be tracked.
  • Learning systems could be provided through Block Chaining.
  • Searching block script for key elements and debugging is made simple by Airtable search.
  • Building complex expert systems are more possible because blending data is virtually unlimited.
  • Block Chaining is somewhat ideal for creating code reuse.
  • Building code in Long Text fields is terrible (just sayin’… build them in a real block and test, then deploy as data objects).

As I mentioned, it is also possible to manage, share, and aggregate computational results that occur across multiple block segments.

Tell me - is Block Chaining a thing?

I’ll give it a shot then, when I’m not rolling the internet on my phone :winking_face:


I believe this is possible. Never checked into it, but I have often wondered if this approach wasn’t a pathway to extending the flight ceiling of Script Blocks by dynamically introducing code into a solution for which the code occupies no space (i.e., script memory per-se) in the lately-bound process. Note - you may have experienced a script block is unable to load more than about 2,000 lines of script and minifying seems to help.

My example makes it obvious that …

  1. Script fragments can exist in records/fields; a fragment is no different than a dynamic library
  2. Script in records/fields can be executed with eval()
  3. Return values from dynamically called script fragments can be persisted
  4. Processes that use multiple script fragments can be strung together and even reordered, filtered, and updated dynamically

It totally works!

Pasting the entire minified moment.js library into a script block is rejected for making the script too long. However, a long text field can hold the entire minified library:

And that library can be called into the Script block with eval(), as if you were importing it with import.

As you see from my screenshot above, you will clearly not have intellisense while editing, and any calls to the eval'd library will be flagged as errors, but once the library is eval'd its models can be used in the script.

Thank you for discovering this strategy, @Bill.French – this is going to make the Script block so much more flexible for junior scripters who prefer to lean on other people’s work :winking_face:


It totally works!

Pasting the entire minified moment.js library into a script block is rejected for making the script too long. However, a long text field can hold the entire minified library:

And that library can be called into the Script block with eval(), as if you were importing it with import.

As you see from my screenshot above, you will clearly not have intellisense while editing, and any calls to the eval'd library will be flagged as errors, but once the library is eval'd its models can be used in the script.

Thank you for discovering this strategy, @Bill.French – this is going to make the Script block so much more flexible for junior scripters who prefer to lean on other people’s work :winking_face:


You’re welcome!

Yep - perfect use case for this feature looking for a problem to solve. :winking_face:

This will probably not be a big issue as libraries – for the most part – are well-tested and few will have the desire to modify them. But, this doesn’t stop any of us from using this approach for creating and managing our own reusable libraries in this way.

Sidebar - if Airtable is able to create a JSON editor for long text fields, it can certainly create and install a code editor for javascript because - wait for it - json is javascript. :winking_face:

Sidebar.2 - BTW, this happened when I envisioned a way to manage code as if it were data and what better example for doing so with the advantageous relationship that Script Blocks share with data tables?

Sidebar.3 - feel free to write the Show & Tell with a title that’s more aligned with what you are showing here; “BlockChaining” doesn’t really express what you’re accomplishing with libraries.

Sidebar.4 - no developer (me included) should ever be given credit for using eval() in creative or potentially dangerous ways. LOL


No one truly understands how eval() really works. :winking_face: Perhaps this will help.

This is the magic of eval(); it makes it possible to construct code in a very late binding process purely as a string and then execute that code AFTER the string has been fully constructed.


Many thanks @Bill.French !
It seems already to me to be the right link but I would ingest and process it during free hours !

Bill had already suggested this in this thread or elsewhere and there you tried, and succeeded! Bravo and thank you very much!
It’s time for me to go on vacation (soon) to try to give something to the Community in return, but for the moment, in javascript, I’m learning to play the Who and the Rolling Stones as perfectly as possible : I’m not composing anything original yet. But it will come !
oLπ


Your English is almost as good as some English people I’ve met and certainly better than some Americans. :slightly_smiling_face: And despite my last name, you do not want to hear a single utterance in French from me.

One of the design goals of this “sample/example” script was to determine how late script could be bound in a Script Block. That was my only objective in building this - I wanted to see and understand at an architectural level how abstract code could be made to run in a script block or even a custom block.

And, of course, the answer is that it may be bound extremely late - script “injection” into a running framework is entirely within the scope of apps built in Script Block and it demonstrates “just-in-time” application behaviours.

Using this approach, very large script “libraries” (perhaps not built in Airtable but certainly) managed in Airtable could be deployed to avoid the Script Block size ceiling. It also means that new scripts and script versions could be deployed without users copying and pasting into each their own blocks.

A secondary design goal was to see how well the vast benefits of tables could be used to create a smart system, or at least some simple wizards and surveys that compile answers.


Hi @Bill.French,

Subject to cross-checking with some of you, this ceiling is at 49999 characters including space :slightly_smiling_face:

Best,

olπ


You’re welcome!

Yep - perfect use case for this feature looking for a problem to solve. :winking_face:

This will probably not be a big issue as libraries – for the most part – are well-tested and few will have the desire to modify them. But, this doesn’t stop any of us from using this approach for creating and managing our own reusable libraries in this way.

Sidebar - if Airtable is able to create a JSON editor for long text fields, it can certainly create and install a code editor for javascript because - wait for it - json is javascript. :winking_face:

Sidebar.2 - BTW, this happened when I envisioned a way to manage code as if it were data and what better example for doing so with the advantageous relationship that Script Blocks share with data tables?

Sidebar.3 - feel free to write the Show & Tell with a title that’s more aligned with what you are showing here; “BlockChaining” doesn’t really express what you’re accomplishing with libraries.

Sidebar.4 - no developer (me included) should ever be given credit for using eval() in creative or potentially dangerous ways. LOL


Did anyone write this show and tell article? I would love to dive deeper into the inclusion of libraries into JS. This entire article is an incredible example of your superhero status Bill!


Did anyone write this show and tell article? I would love to dive deeper into the inclusion of libraries into JS. This entire article is an incredible example of your superhero status Bill!


Not that I’m aware of one. And unfortunately, that approach won’t work in automation scripts as eval() apparently isn’t supported in that scripting feature as pointed out recently by @kuovonne.

To be clear, I’m not sure its wise for anyone to follow me off the cliff in a Thelma & Louise journey to use tables as script libraries despite the fact that @Jeremy_Oglesby found the concept somewhat compelling in a script block context.

And to ensure there’s no misunderstanding about my original intent - this approach was created to achieve one thing - to provide dynamically changing script logic while the script was running. This objective is a close cousin of the late-binding of libraries.

Setting aside library inclusion, Airtable should make it possible (in all script environments) to manage code in much the way all JavaScript developers do this - by establishing a model for reusable chunks.

I really appreciate the kind comments, but I must warn you - it didn’t end well for Thelma & Louise. There’s a fine line between superheros and super-nut-jobs.


Bill just needs to find his Ted to go on his Thelma & Louise adventure :slightly_smiling_face:

We developed an alternative approach we use at Openside/On2Air that allows for reusable snippets/libraries and better overall management of your scripts.

Check out the product here: https://on2air.com/on2air-scripts

Here is a video review of how it works:


Bill just needs to find his Ted to go on his Thelma & Louise adventure :slightly_smiling_face:

We developed an alternative approach we use at Openside/On2Air that allows for reusable snippets/libraries and better overall management of your scripts.

Check out the product here: https://on2air.com/on2air-scripts

Here is a video review of how it works:


Hello Openside,your solution is really well designed, I think, but after paying for my Airtable-Pro-Plan, I had a careful compromise to make between several Third-Part-Solutions that offer different additional tools to Airtable without being able to pay them all for my current low to minimal traffic.
I wish you all the best for your offer of excellent Add-Ons for airtable.
oLπ


Not that I’m aware of one. And unfortunately, that approach won’t work in automation scripts as eval() apparently isn’t supported in that scripting feature as pointed out recently by @kuovonne.

To be clear, I’m not sure its wise for anyone to follow me off the cliff in a Thelma & Louise journey to use tables as script libraries despite the fact that @Jeremy_Oglesby found the concept somewhat compelling in a script block context.

And to ensure there’s no misunderstanding about my original intent - this approach was created to achieve one thing - to provide dynamically changing script logic while the script was running. This objective is a close cousin of the late-binding of libraries.

Setting aside library inclusion, Airtable should make it possible (in all script environments) to manage code in much the way all JavaScript developers do this - by establishing a model for reusable chunks.

I really appreciate the kind comments, but I must warn you - it didn’t end well for Thelma & Louise. There’s a fine line between superheros and super-nut-jobs.


Airtable is not only a very important business tool that must be based on reliable, stable, consistent techniques and must meet the selection criteria of market decision-makers, as @Bill.French teaches us in some of its writings.
It’s also a dream tool that I’ve been waiting for a long time when I found it in a corner of the WEB for a “small lab” that started with Z80s and that today enjoys “As A Service”, “Serverless”, “Micro-Applications”, “Micro-Front-Ends” so don’t hesitate to play Thelma & Louise again from time to time: there is a Audience that loves to follow you on these roads too!

oLπ


Airtable is not only a very important business tool that must be based on reliable, stable, consistent techniques and must meet the selection criteria of market decision-makers, as @Bill.French teaches us in some of its writings.
It’s also a dream tool that I’ve been waiting for a long time when I found it in a corner of the WEB for a “small lab” that started with Z80s and that today enjoys “As A Service”, “Serverless”, “Micro-Applications”, “Micro-Front-Ends” so don’t hesitate to play Thelma & Louise again from time to time: there is a Audience that loves to follow you on these roads too!

oLπ


So I am looking at this solution for Airtable automation since it would mean you could store global functions in a separate table and reference them across your automations.

However, inside Automations I am getting the error “ReferenceError: eval is not defined” despite ‘eval’ showing up as a usable function in the tooltip.

Any ideas? Any workarounds here?


There are a few small differences between running a script from scripting app with a button and running a script as an automation. The inability to use eval in an automation is one of them. Some other differences include using setTimeout and how fetch works.


There are a few small differences between running a script from scripting app with a button and running a script as an automation. The inability to use eval in an automation is one of them. Some other differences include using setTimeout and how fetch works.


Hmm is there a workaround? It’d be great to put global functions into a table that can be referenced directly as code.


A CDN + JSON.parse()? But building anything on this sort of functionality seems… unwise.


A CDN + JSON.parse()? But building anything on this sort of functionality seems… unwise.


JSON.parse() won’t return an executable function. You could store the code as a string in the JSON, but then you would still need eval to convert the string into an executable function.


JSON.parse() won’t return an executable function. You could store the code as a string in the JSON, but then you would still need eval to convert the string into an executable function.


Ah, I learn something new every day, cheers.


I just got Pro and… it’s so powerful, should have gotten it sooner!

I think this is totally possible with Automations / Webhooks — on each Webhook, the last action you run is a script that could fetch another webhook in another base/table… debugging this thing sounds like a nightmare though.

Basically:

  1. Incoming trigger (e.g. a form is filled)
  2. Automate based on trigger — run a script that calls a webhook
  3. Webhook triggers actions in another base/table (e.g. create a row), and a script that fetches more webhooks
  4. Rinse and repeat until done

This could be done with Airtable’s webhooks, but Airtable’s automation webhooks come with their own set of limitations. Even the webhooks API has significant limitations, such as a limit of 10 webhooks per base.

Even though Make is a low-code environment (instead of a scripting environment), this is one of the Top 20 Reasons why I encourage Airtable users to take a look at Make for their automations.

Not only does Make have more advanced webhooks than Airtable with no limitations (along with custom webhook responses and even mailhooks), but blockchaining is possible with Make and reusable “code” is possible in Make.

Make allows you to copy and paste modules from one scenario to another, Make allows you to export and import blueprints for backups or portability to other accounts, and best of all, you can use Make’s own internal meta modules to daisychain scenarios together with custom variables. There are 44 meta modules that let you control Make, including running other scenarios with dynamic variables.

There is a small learning curve with Make, which is why I created this basic navigation video to help. I also provide the links to a few other Make training resources. For example, to instantly trigger your Make scenarios from Airtable, check out this thread.