[FREE] Json Array decoder for you CRUD's

SupaJson: The last JsonArray decoder you'll need.

  • I call it that way, because y use a lot Supabase DB
  • And by Jesus Christ I'm tired of racking my brain and getting lost in the blocks of code decoding the Json's I receive in response. (Json to list, then a Dict, then look up, Key path, it's there or not, and bla bla bla).
  • So I decided to create this extension to make life easier for all of us who work doing many database CRUD's and complex projects.

Let's start:

  • It is a non-visible extension that is made up of 3 components: Headers List<>, Rows List<List>, Columns List<List>
Components

SupaJson Blocks

It is made especially for those cases where you work with tables (Columns and Rows and Headers).

Example Table

  • Headers: List the headers of your Json Array, ex: {id, name, age, country, photo} in a clean way, so you can use it on any component on the go.

  • Rows: A List that's return your Json Array by Rows, ex:[{1, jonathan, 38, Argentina, Jony.jpg}, {2, Andres, 39, Chile, Andres.jpg}]

  • Columns: A List that's return your Json Array by Columns, ex: [{1,2},{Jonathan, Andres}, {38, 39}, {Argentina, Chile},{Jony.jpg, Andres.jpg}]

Use case:

Using the example table above, i made a CRUD through a remote procedure call (RPC) to my table (interfaz_principal) in Supabase.

  1. Set the web component to make the RPC
Web component RPC = tester_b

  1. My procedure is heeding the call on server side (supabase)
tester_b procedure in supabase

  1. When web component got text i use SupaJson to decode
Web Component Got Text

  • In this example, i use a Spinner to get the headers of my table from the JsonArray
Look how it's seen on the screen

:melting_face:

No format, look up, etc. just ready to use :smiling_face_with_three_hearts:

  • Then (see web component got text screenshot), i use Columns on Label1 (Row: 4, Column: 2) [See example table] to get nombre.

  • Then (see web component got text screenshot), i use Rows on Label2 (Column: 4, Row: 2) [See example table] to get nombre.

  • Label3 get length of the list in Columns component (ALT+0160 = Space).

  • Label4 get length of the list in Rows component (ALT+0160 = Space).

  • Label5 show how looks like Columns decoded.

Look how it's seen on the screen

FAQ:

Is tested?
  • Yes, in Android 8, 9, 10 : Motorola G7 (8, 9, 10), G7 Power (8, 9, 10) and Huawei Redmi Note 4 (8).
  • Please test and feedback.
Why do i need this Json Array Decoder?
  • Easy to use.
  • Iterate in any kind of loop.
  • Populate any component.
  • I made it with :heart:
How free is the extension?
  • Totally free!
  • I don't need a god or law to do what is right.
  • So it can be used under any reason, excuse, context, etc.
  • If you are from the AppInventor TEAM and want the source code to review and add it to any updates, feel free to request it.
Why do you use an RPC and not a Get?
  • A Supabase-Appinventor full course is soon to come, but now I'm very busy with a project.
  • But long story short; I can tell you that it is about "security" and "maintenance" or "updates" about your API calls and the structure of your DB and App.

In app inventor you must provide your public key and url to be able to connect to an API

When you make a GET request, you must provide the fields (headers), table name, data type, schema, etc.

And if you do not have the RLS (Row Level Security) set, as well as the User Roles, etc. Also that you provide the URL, API Key (public or not).

It's a recipe for disaster, especially when it comes to IOT applications (Webcams, smart devices sending and receiving data, etc.).

You will laugh, but there are many Appinventor applications that go into production, and through RPC you can manage security from the server, without having to expose your DB schema, tables and fields that are in them. As you see in my example, I only make a POST with the values ​​y and x, There is no table name, no schema, etc. On the server side I simply set that if y != x or y is Null, then return values, to avoid a 400 error (Bad request), which can provide certain information to an attacker.

On the maintenance and updating side, I usually make my applications (UI part) dynamically, using dynamic components, utils components, etc.

So my applications (from the splash to icons, buttons, colors, fonts, images, etc.) start with a logic that starts making calls to the database to create the components dynamically (even forms), load their configurations and formats, allowing to have different settings for each device, and different UI versions, etc.

That way I don't need to recompile a version of my App (unless it's absolutely necessary), and I manage everything from the backend, through tables, triggers, procedures, etc.

So, in summary:

  • It allows you to apply security, configuration, update and maintenance logic without having to touch the application.
  • You don't need to do too much data processing on the device, since Postgres has many tools that allow you to operate on any type of data (text string, numbers, geo data, etc., even embedding vectors).
  • In my example, the table has a field called "visible" and it is a boolean (true/false)
    If I change my 'tester_b' procedure and add that it only sends those rows where the "visible" field is 'true', that field will not be rendered in the UI.
Example code of modified 'tester_b' procedure
CREATE OR REPLACE FUNCTION tester_b(y TEXT) 
RETURNS TABLE (id BIGINT, nombre TEXT, icono TEXT, visible BOOLEAN, descripcion TEXT) 
AS $$
BEGIN
    IF y IS NULL OR y != 'x' THEN
        RETURN QUERY  
        SELECT 
            0::bigint AS id,
            'No Papá!!' AS nombre,
            'Acá va un icono' AS icono,
            false AS visible,
            'Te lo describo así nomás' AS descripcion
        LIMIT 1;
    ELSE
        RETURN QUERY 
        SELECT * 
        FROM public.interfaz_principal
        WHERE visible = TRUE;
    END IF;
END;
$$ LANGUAGE plpgsql;
  • That's it with the explanation (for now). If you have any specific questions, don't hesitate to send a PM, so the thread doesn't get filled with things that aren't related to the extension.

Download Link:

  • For now it will be on my GoogleDrive, until it passes the tests.

SupaJson V 1.0

  • Please don't forget to test it and give feedback With: With the phone brand and Android version
  • Thanx!
  • Waiting for the Supabase course.
0 voters
1 Like

Is this just for data stored on Supabase? If so, the topic title should reflect that, and that a Supabase account is required and in use (the nice people at Supabase "shut down" free accounts if not touched for a week...)

2 Likes
  • No no, any table, any crud, etc. i just use Supabase as example.
  • Works at Json Array level, not trough connection.
1 Like

In this part it is clear that its use is for those who work with the mentioned format, well covers, pocketbase, baserow, GSheet among others xD!

1 Like

Please provide an example of some json "that works" in this extension, that is the only thing you do not show, the raw responseContent coming back from supabase (why a table is output as json and not csv I do not know...)

1 Like
  • No and yes :rofl:
This is a typical Json Aarray
[
    {
        "id": 1,
        "name": "Alice",
        "position": "Developer",
        "department": "Engineering"
    },
    {
        "id": 2,
        "name": "Bob",
        "position": "Manager",
        "department": "Sales"
    },
    {
        "id": 3,
        "name": "Charlie",
        "position": "Analyst",
        "department": "Marketing"
    }
]
This is a Nested Json Array
{
  "employees": [
    {
      "id": 1,
      "name": "Alice Johnson",
      "position": "Software Engineer",
      "department": "Engineering",
      "contact": {
        "email": "alice.johnson@example.com",
        "phone": "+1-555-1234"
      },
      "projects": [
        {
          "projectId": "P001",
          "projectName": "Project Alpha",
          "startDate": "2024-01-15",
          "status": "Ongoing"
        },
        {
          "projectId": "P002",
          "projectName": "Project Beta",
          "startDate": "2024-03-01",
          "status": "Planning"
        }
      ]
    },
    {
      "id": 2,
      "name": "Bob Smith",
      "position": "Marketing Manager",
      "department": "Marketing",
      "contact": {
        "email": "bob.smith@example.com",
        "phone": "+1-555-5678"
      },
      "projects": [
        {
          "projectId": "P003",
          "projectName": "Marketing Campaign 2024",
          "startDate": "2024-02-01",
          "status": "Ongoing"
        }
      ]
    }
  ]
}

it can be returned by a sql or nosql database (graph, sql, postgre, documents collections, etc), like supabase, pocketbase, baserow, GSheet & Firebase queryes.

  • Yes, you are correct.

  • But I thought it was understood.

  • This has more to do with the current (globally accepted) standards on data.
1. Hierarchical and Complex Data Structures

JSON:

  • Nested and Hierarchical Data: JSON supports nested structures, allowing you to represent hierarchical and complex data. This is particularly useful for data with relationships, such as objects within objects or arrays of objects.
  • Example: In JSON, you can represent a user profile that includes nested objects for contact information and arrays for lists of projects, each with its own set of details.

CSV:

  • Flat Data Structure: CSV is inherently flat and tabular. It is designed to handle simple rows and columns, making it less suitable for representing nested or hierarchical data.
  • Limitations: CSV does not natively support complex structures or relationships, which limits its ability to represent data that requires multiple levels of detail.
2. Data Representation and Readability

JSON:

  • Self-Describing: JSON includes field names within the data itself, making it self-describing. This means that the structure of the data (e.g., keys and their associated values) is explicit and easy to understand.
  • Human-Readable: JSON’s structured format with clear key-value pairs and nested objects makes it easy to read and interpret, especially for developers and those familiar with JSON syntax.

CSV:

  • No Metadata: CSV files do not include metadata about the data. Field names are typically represented in the first row, and the data does not include information about types or structure beyond simple delimiters.
  • Potential for Ambiguity: Without metadata, interpreting the meaning of the data can sometimes be ambiguous, particularly if field names are not included or if the structure is not uniform.
3. Integration with Modern Technologies

JSON:

  • Web APIs: JSON is the standard format for data interchange in web APIs, particularly in RESTful APIs. It is widely used in web and mobile applications due to its ease of integration with JavaScript and many programming languages.
  • Programming Languages: Most modern programming languages have built-in support for parsing and generating JSON. This makes JSON a natural choice for data exchange in applications.

CSV:

  • Legacy Format: CSV is often used for data import/export in spreadsheets and legacy systems. While it is supported by many tools, it is not as commonly used for web APIs or complex data interchange in modern applications.
  • Limited Language Support: While many programming languages support CSV parsing, it is often less integrated and more cumbersome to handle compared to JSON.
4. Flexibility and Adaptability

JSON:

  • Dynamic Schema: JSON allows for a dynamic schema where objects can vary in structure. This flexibility is useful for scenarios where the data schema may evolve or differ between records.
  • Rich Data Types: JSON supports various data types, including strings, numbers, booleans, arrays, and nested objects, providing a rich representation of data.

CSV:

  • Static Schema: CSV files typically require a consistent schema where each row has the same columns. This can be restrictive when dealing with data that varies in structure.
  • Basic Data Types: CSV is limited to basic data types and does not handle nested or complex types, making it less flexible for modern data needs.
5. Error Handling and Validation

JSON:

  • Validation Tools: JSON data can be validated against schemas (e.g., JSON Schema) to ensure it meets specific requirements. This facilitates error checking and ensures data integrity.
  • Error Messages: JSON parsers often provide meaningful error messages if the data is malformed, making it easier to diagnose and fix issues.

CSV:

  • Limited Validation: CSV lacks built-in validation and error handling. Data errors or inconsistencies may not be easily detected or reported, making it prone to issues during data processing.
  • Error-Prone Parsing: Parsing CSV can be error-prone due to issues like delimiters within fields, inconsistent quoting, or missing values.
6. Data Interchange and Storage

JSON:

  • API and Data Storage: JSON is widely used for storing and exchanging data in NoSQL databases (e.g., MongoDB) and is a common format for configuration files (e.g., package.json in Node.js).
  • Serialization: JSON’s structured format makes it suitable for serializing complex objects and storing them in a structured manner.

CSV:

  • Simple Data Export: CSV is often used for exporting data to spreadsheets or for simple data interchange between applications. It is well-suited for scenarios where the data is tabular and does not require complex relationships.
JSON vs CSV Summary

JSON is more accepted than CSV in modern contexts due to its support for hierarchical data, self-describing nature, integration with web technologies, flexibility, and rich data types. While CSV remains useful for flat tabular data and certain legacy applications, JSON’s advantages make it the preferred choice for complex data interchange and storage in contemporary software development.

That's why In our connected world, where we rely on the internet, big data, mobile apps, IoT devices and cloud services, JSON has become the go-to format for data (Added to dockerization and kubernets).

All platforms have a CLI to connect with their API, in each programming language and/or framework, and all of them have the Json format as standard.

It's all about standards

  • Explanations/Answers; help clarify the issues, shed light on darkness and not stigmatize ignorance about something.

  • But please feel free to test the extension in real production environments (large and diverse data sets). Even with the simple Nested Json Array that I gave as an example.

as well as:

  1. Using traditional methods to iterate and populate components, using for, for each, etc. methods.
  2. Count the number of steps and components you had to use to achieve it.
  3. Look at your canvas and tell me where you got lost. :joy:
  4. Then use my extension and draw your own conclusions.
  5. You'll see that with 2 simple for methods, you went through the entire Json and extracted everything you needed.

P/D: You will see the big difference, when you face the Nested Json Arrays.

  • (I will do) the "full" course on complex dynamic applications using the (Sync/Async) procedural approach with supabase.

Thanks guys, your criticism and advice do not fall on deaf ears.

1 Like
  • No, they don't "Shut Down" free accounts, just "Pause Projects" ak: "DatabaBase project"

  • They don't charge for API calls or transactions (like firebase), they only charge for DB space (+ 500Mb Db) and up to 10,000 authenticated users.

  • Believe me, 500 Mb for a DB & 10k of authenticated users is a lot.

What I did (since it is open source), I downloaded the CLI, and I connected directly to the cloud database, Then (through functions and triggers), when the database is reaching its limit, I download all the information that is not ultra necessary to a GDrive as CSV.

In this way I free up the space in the cloud, so that users can continue using the platform, until the mvp (minimum viable product) reaches its time limit, and things have to be done differently.

Thank you for the example json. I just wanted to see if it was me...

Results for the first json, I get output for Columns and Headers, but not for rows:

image

Results for the second json, I get no results for any of the three extension blocks:

image

I also get no results using the json from the AI2 Help page for dictionaries:

{
  "people": [{
    "first_name": "Tim",
    "last_name": "Beaver"
  },{
    "first_name": "John",
    "last_name": "Smith"
  },{
    "first_name": "Jane",
    "last_name": "Doe"
  }]
}

[edit] note: json corrected by removing a comma, this now validates in json lint

image

Hence my confusion...:upside_down_face:

1 Like

Nice explanations of JSON and CSV.

FAQ-worthy

1 Like

This is possibly why. When I copy one of the examples from dictionary help page, they always result in an invalid determination when using this on line checker.

1 Like

That comma after "Smith" is the killer.

The MIT documentarian must be warned

@Susan_Lane ?

1 Like

Yes. :grinning:

2 Likes

Even when the json is corrected and validated it still does not return anything with the extension blocks. I edited the above.

and again...

Not to be defeated:

works fine with dictionary blocks

1 Like

I don't think I'm tracking.

This is a 3rd-party JSON extension or ours? Is the example with the extra comma after "Smith" from our documentation?

1 Like

Third party

Yes

https://ai2-appinventor-mit-edu.ezproxy.canberra.edu.au/reference/blocks/dictionaries.html#list-by-walking-key-path

1 Like

Eeeek. Yes, that definitely needs to be fixed. I'll see if I can find that docco.

ETA: OK, there's a pull request up to fix this. It's nice to have something simple to fix.

3 Likes

Yes! Because I say in my first post:

[{Json Arrays}] and Nested ones, are decoded as list<list> (List of List) to use with iterators, loops (for, each, etc)

If you see your Json Is not an valid array one [brackets are missing] all over the file.

Your Json structure
{
  "1": {
    "pet": "dog",
    "name": "Patch",
    "gender": "Male"
  },
  "2": {
    "pet": "cat",
    "name": "Spike",
    "gender": "Male"
  },
  "3": {
    "pet": "bird",
    "name": "Tweety",
    "gender": "Female"
  },
  "4": {
    "pet": "rabbit",
    "name": "Thumper",
    "gender": "Male"
  },
  "5": {
    "pet": "hamster",
    "name": "Squeaky",
    "gender": "Female"
  },
  "6": {
    "pet": "fish",
    "name": "Goldie",
    "gender": "Female"
  },
  "7": {
    "pet": "turtle",
    "name": "Shelly",
    "gender": "Male"
  },
  "8": {
    "pet": "ferret",
    "name": "Fuzzy",
    "gender": "Female"
  },
  "9": {
    "pet": "guinea pig",
    "name": "Cuddles",
    "gender": "Male"
  },
  "10": {
    "pet": "parrot",
    "name": "Polly",
    "gender": "Female"
  },
  "11": {
    "pet": "dog",
    "name": "Rex",
    "gender": "Male"
  },
  "12": {
    "pet": "cat",
    "name": "Whiskers",
    "gender": "Female"
  },
  "13": {
    "pet": "rabbit",
    "name": "Flopsy",
    "gender": "Female"
  },
  "14": {
    "pet": "hamster",
    "name": "Nibbles",
    "gender": "Male"
  },
  "15": {
    "pet": "fish",
    "name": "Bubbles",
    "gender": "Male"
  },
  "16": {
    "pet": "turtle",
    "name": "Speedy",
    "gender": "Female"
  },
  "17": {
    "pet": "ferret",
    "name": "Slinky",
    "gender": "Male"
  },
  "18": {
    "pet": "guinea pig",
    "name": "Pipsqueak",
    "gender": "Female"
  },
  "19": {
    "pet": "parrot",
    "name": "Coco",
    "gender": "Male"
  },
  "20": {
    "pet": "dog",
    "name": "Buddy",
    "gender": "Male"
  }
}
This is a valid Json Array
[
{
  "1": {
    "pet": "dog",
    "name": "Patch",
    "gender": "Male"
  },
  "2": {
    "pet": "cat",
    "name": "Spike",
    "gender": "Male"
  },
  "3": {
    "pet": "bird",
    "name": "Tweety",
    "gender": "Female"
  },
  "4": {
    "pet": "rabbit",
    "name": "Thumper",
    "gender": "Male"
  },
  "5": {
    "pet": "hamster",
    "name": "Squeaky",
    "gender": "Female"
  },
  "6": {
    "pet": "fish",
    "name": "Goldie",
    "gender": "Female"
  },
  "7": {
    "pet": "turtle",
    "name": "Shelly",
    "gender": "Male"
  },
  "8": {
    "pet": "ferret",
    "name": "Fuzzy",
    "gender": "Female"
  },
  "9": {
    "pet": "guinea pig",
    "name": "Cuddles",
    "gender": "Male"
  },
  "10": {
    "pet": "parrot",
    "name": "Polly",
    "gender": "Female"
  },
  "11": {
    "pet": "dog",
    "name": "Rex",
    "gender": "Male"
  },
  "12": {
    "pet": "cat",
    "name": "Whiskers",
    "gender": "Female"
  },
  "13": {
    "pet": "rabbit",
    "name": "Flopsy",
    "gender": "Female"
  },
  "14": {
    "pet": "hamster",
    "name": "Nibbles",
    "gender": "Male"
  },
  "15": {
    "pet": "fish",
    "name": "Bubbles",
    "gender": "Male"
  },
  "16": {
    "pet": "turtle",
    "name": "Speedy",
    "gender": "Female"
  },
  "17": {
    "pet": "ferret",
    "name": "Slinky",
    "gender": "Male"
  },
  "18": {
    "pet": "guinea pig",
    "name": "Pipsqueak",
    "gender": "Female"
  },
  "19": {
    "pet": "parrot",
    "name": "Coco",
    "gender": "Male"
  },
  "20": {
    "pet": "dog",
    "name": "Buddy",
    "gender": "Male"
  }
}
]
This is a perfect valid Nested Json Array
[
  {
    "1": [
      { "pet": "dog" },
      { "name": "Patch" },
      { "gender": "Male" }
    ]
  },
  {
    "2": [
      { "pet": "cat" },
      { "name": "Spike" },
      { "gender": "Male" }
    ]
  },
  {
    "3": [
      { "pet": "bird" },
      { "name": "Tweety" },
      { "gender": "Female" }
    ]
  },
  {
    "4": [
      { "pet": "rabbit" },
      { "name": "Thumper" },
      { "gender": "Male" }
    ]
  },
  {
    "5": [
      { "pet": "hamster" },
      { "name": "Squeaky" },
      { "gender": "Female" }
    ]
  },
  {
    "6": [
      { "pet": "fish" },
      { "name": "Goldie" },
      { "gender": "Female" }
    ]
  },
  {
    "7": [
      { "pet": "turtle" },
      { "name": "Shelly" },
      { "gender": "Male" }
    ]
  },
  {
    "8": [
      { "pet": "ferret" },
      { "name": "Fuzzy" },
      { "gender": "Female" }
    ]
  },
  {
    "9": [
      { "pet": "guinea pig" },
      { "name": "Cuddles" },
      { "gender": "Male" }
    ]
  },
  {
    "10": [
      { "pet": "parrot" },
      { "name": "Polly" },
      { "gender": "Female" }
    ]
  },
  {
    "11": [
      { "pet": "dog" },
      { "name": "Rex" },
      { "gender": "Male" }
    ]
  },
  {
    "12": [
      { "pet": "cat" },
      { "name": "Whiskers" },
      { "gender": "Female" }
    ]
  },
  {
    "13": [
      { "pet": "rabbit" },
      { "name": "Flopsy" },
      { "gender": "Female" }
    ]
  },
  {
    "14": [
      { "pet": "hamster" },
      { "name": "Nibbles" },
      { "gender": "Male" }
    ]
  },
  {
    "15": [
      { "pet": "fish" },
      { "name": "Bubbles" },
      { "gender": "Male" }
    ]
  },
  {
    "16": [
      { "pet": "turtle" },
      { "name": "Speedy" },
      { "gender": "Female" }
    ]
  },
  {
    "17": [
      { "pet": "ferret" },
      { "name": "Slinky" },
      { "gender": "Male" }
    ]
  },
  {
    "18": [
      { "pet": "guinea pig" },
      { "name": "Pipsqueak" },
      { "gender": "Female" }
    ]
  },
  {
    "19": [
      { "pet": "parrot" },
      { "name": "Coco" },
      { "gender": "Male" }
    ]
  },
  {
    "20": [
      { "pet": "dog" },
      { "name": "Buddy" },
      { "gender": "Male" }
    ]
  }]
  • In this last JSON:

    • It is an arrangement of objects.
    • Each object has a numeric key that corresponds to a unique index.
    • The value of each key is an array of objects, where each object represents a key-value pair.

So the the Json that you presented, can be defined by structure:

Type of Structure

1. Dictionary (or Map):

  • The primary structure is a dictionary, also known as a map or hash in some programming languages. In this case, the keys are numbers in string format (like "1", "2", etc.), and the values associated with these keys are objects containing attributes related to each entry (i.e., pet, name, gender).

2. Collection of Objects:

  • It is a collection of objects where each object represents an entry with specific details about a pet, identified by a unique numeric key.

Structure Details

  • Key: At the top level, each key is a string representing a unique numeric identifier for each object (e.g., "1", "2", etc.).
  • Value: Each value associated with a key is an object containing three properties:
    • pet: The type of pet (e.g., "dog", "cat", "bird", etc.).
    • name: The name of the pet (e.g., "Patch", "Spike", "Tweety", etc.).
    • gender: The gender of the pet (e.g., "Male" or "Female").

Example of Interpretation

In a programming context, you might consider this structure as:

  • Dictionary of Identifiers: A dictionary where each numeric identifier (as a key) maps to an object that contains information about a pet.
  • List of Indexed Items: Although the format is a dictionary with numeric keys, conceptually you might think of it as a list of indexed items if the numeric keys were sequential.

Summary

Your JSON is primarily a collection of objects indexed by numeric keys, and in terms of data structures, it functions as a dictionary or map where each entry contains structured information about a pet.

Explanation: a long story short about Nested Json Array Syntax Structure
[
  {
    "20": [
      { "pet": "dog" },
      { "name": "Buddy" },
      { "gender": "Male" }
    ]
  }
]

Explanation

  1. Top-Level Array:
  • The outermost structure is an array ([]), which can hold multiple items. Each item within this array is an object.
  1. Object with Numeric Key:
  • Inside the array, there's an object with a numeric key "20". This key can be any string, but it represents a unique identifier for the object within the array.
  1. Nested Array:
  • The value associated with the key "20" is an array ([]). This array contains multiple objects, each representing a key-value pair where the key is one of the attributes ("pet", "name", "gender") and the value is the corresponding value.

Validity and Use Case

  • Valid JSON: Yes, this is a valid JSON structure. It conforms to JSON syntax rules.
  • Use Case: This structure might be useful in scenarios where you need to store data in a highly structured way, with each item indexed by a unique identifier and each item containing an array of key-value pairs. However, this format is less common than using a dictionary with direct key-value pairs.

Now:

  1. With the last Json (perfect valid...) iterate using Dictionary or traditional methods
  2. Do the same but with my extension.
  3. See the diference.
  4. Remember that each platform (DB) and API, has its own way of structuring data and returning it, so you must always make sure what type of structure you are going to handle (dictionaries, tabular, table, csv, collections, documents, etc.).
  • In the relational case (like postgre, sql, etc). everything comes in the form of nested arrays, even some documents or collections in firebase, can bring up to 32 collections one inside the other. :smiling_face_with_tear:

  • If this resolved your question, do not hesitate to mark as "solved", so I can earn a badge as a good boy scout :rofl:

PD: I'm sorry for the delay in the response, but it takes time to format the post. And for those who are interested, if you put 3 of these # + a space (At the beginning of a line), your words will look like this

Your words

I love that one! :joy: :joy: :joy:

  • You can use any information from this post that you need for documentation.
  • And if you are interested in the code to add it as an option in a future update, I have no problem.

Extension needs to generate an error message / (event block) if the supplied string is not a valid json array (perhaps showing the only accepted structure, or a link to this). Simple minded developers, like me, would need that.

1 Like

A hack to convert your valid json to a JSON ARRAY :wink:

You could also change the outside curly brackets to square brackets using text manipulation blocks.

or just use dictionary blocks...

2 Likes