April: OpenAI integration, state inspector, simpler action results
Greetings everyone and welcome to our April release notes! As spring is in full swing, we're excited to share some exciting new features. The most significant update is the integration of OpenAI, providing you with access to the most advanced language models available to unlock a whole range of new use cases on Uify. In addition, we have released a bunch of impressive features that we can't wait to share with you. So sit back, relax, and let's explore them together!
- 🤖 OpenAI integration: You can now build custom prompting interfaces on top of any of the OpenAI models. This marks the 10th integration of the Uify platform!
- 🔬 State inspector: The left-hand panel of the app editor now provides a convenient overview of all actions, components, and state variables, incl. their exposed properties. This is very useful for testing and debugging while working on your applications.
- 📈 Data source explorer improvements: We've improved our recently launched data source explorer. These enhancements include cell range selection for effortless copying and pasting, better search functionality for schemas and tables, and overall performance improvements.
- 🧘♀️ Simpler action results: Previously, when retrieving records from a data source using a SQL SELECT query, the result was returned as an object with the array-fields HEADERS and RECORDS. Now, the result is returned as an array of objects, which is a more convenient structure for working with the retrieved records.
- 🤝 Multi-item operations in the action editor: It is now possible to select multiple actions or folders in the action editor and move or delete them all at once. Pushing a bunch of actions into a newly created folder is easier than ever!
Let’s break it down
Fair to say that the rise of large language models has revolutionized the world. With our latest OpenAI integration, you can now harness this groundbreaking technology to create LLM-powered apps within minutes! Our integration empowers you with fine-tuned control over all parameters of the APIs, unlocking endless possibilities. The potential for innovation is limitless, and we're already seeing some exciting Uify apps leveraging these capabilities. Stay tuned for more exciting updates as we further push the boundaries of what's possible with LLM-powered applications!
To work effectively with actions, components, and state variables in your apps, you need a solid understanding of their exposed properties and values. While our code editor offers a decent overview of available properties, you may sometimes be unaware of the underlying structures accessible through them.
Introducing our state inspector! With its release, the left-hand panel now presents a comprehensive list of all available entities in your app, allowing you to dive deep into the details and explore their exposed elements. This feature is invaluable during the app development and debugging process. To accommodate this new panel, we have relocated the component library to the right-hand side, alongside the properties panel for selected components. These two panels will alternate based on your component selection.
You will never be left wondering again what the result of a specific action currently holds 🙌:
Data source explorer improvements
We highly value the feedback we've received for our recently launched data source explorer, and we're excited to announce that we've taken decisive action to enhance your data exploration experience:
- Cell selection: Your data source tables now feel like spreadsheets! You may select individual cells, move/expand your selection by keyboard, or select a range of cells by click-dragging your mouse cursor. The selected cells can easily be copied and pasted to any external place, like a Google Sheet or a Notion base.
- Schema search: We've expanded the search capabilities within the data source explorer to offer more comprehensive results. Now, in addition to searching for data sources by name, you can also search within schema and table names. This enhanced search functionality ensures that all relevant matches are immediately visible, as the tree structure conveniently expands to display the search results.
- Supporting large schemas: We understand that some of your data sources can be extensive and intricate. We have implemented a range of improvements that ensure an enjoyable user experience, even when dealing with large data sources, comprising thousands of tables across hundreds of sources. With these enhancements, you can confidently navigate, explore, and interact with your data sources without any compromise on performance or usability 🚀.
Simpler action results
When fetching data from your sources, the resulting structure used to be an object with two static fields:
- HEADERS is an array of column/field names
- RECORDS is an array of records, while a single record is again an array of field values
While such a structure is very memory-efficient and fairly explicit, it is inconvenient to work with at times. Especially map/filter/reduce as well as looking up values for a specific column is trickier compared to working with objects.
Now, all actions pulling records from a data source return a plain array of objects. Don’t worry about your existing apps though! The changes have been introduced with backward compatibility, i.e. using the HEADERS and RECORDS fields still works. We encourage you to slowly migrate to the new structure though, as this workaround will be removed at some point in the future.
For a better illustration of these changes, here is a before/after example:
Multi-item operations in the action editor
You can now select multiple actions or folders by holding CMD (Mac) / CTRL (Win) and clicking on individual items, or by shift-clicking to select a range.
Move them in bulk with drag-and-drop or right-click to delete the entire selection. Of course, you will still get a warning in case any of the items is in use - safety first!
- “On delete” handler in table: Our TABLE component has received an update with the addition of a new event handler for deleting rows, complementing the existing action handlers for adding and editing rows. With this new feature, app users can now delete rows directly from the TABLE component via the right-click context menu, provided that the TABLE is configured accordingly.
- Action chaining: Powerful apps require powerful logic, which often includes executing a series of actions in sequence. This is now configurable without any code - simply navigate to the “Trigger” tab of your action, select another one as “On success” event, and it will be executed whenever your action succeeds.
- Uploading images: Our IMAGE component now allows app developers to upload and host images directly in Uify. The existing ability to embed images via public URL of course remains as well.
- Automatic table refresh: Row and multi-row actions of the TABLE component often lead to changes of data in the original source. To visualize these changes to the user, the affected TABLE component requires a refresh, usually done by calling the REFRESH() function. This is now configurable without code, by activating the “Refresh table afterwards” toggle of the action. This is equally possible for “On rows update” and “On row add” events.
- Disabling schemas: In some cases, you might not want data source schemas to be refetched, especially when API calls become costly. We have added the ability to explicitly disable schema fetching for a particular data source. When this toggle is active for the data source, the schema tree will never be fetched or visualized.
- Bug fixes & improvements: On top of all the features mentioned above, we applied 32 additional bug fixes and improvements 🚀.
This release is the beginning of incorporating the power of AI into our platform. We are convinced that this unlocks an entire new category of use cases, and you may expect a bunch of exciting new features and integrations in that direction shortly - stay tuned!
As always, please don't hesitate to contact us if you have any questions or feedback!