@botpress/api 0.18.0 → 0.18.1

package/src/gen/state.ts

@@ -6744,12 +6744,726 @@ export const state = {
         },
       },
     },
+    listTables: {
+      name: "listTables",
+      path: "/v1/tables",
+      description: "Retrieves a list of all tables associated with your bot.",
+      method: "get",
+      parameters: {
+        tags: {
+          in: "query",
+          type: "object",
+          schema: {
+            type: "object",
+            additionalProperties: {
+              type: "string",
+            },
+          },
+          description:
+            "Optional filters to narrow down the list by tags associated with tables.",
+        },
+      },
+      section: "tables",
+      response: {
+        description: "Returns a list of tables.",
+        schema: {
+          type: "object",
+          properties: {
+            tables: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Table",
+              },
+            },
+          },
+          required: ["tables"],
+          title: "listTablesResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    getTable: {
+      name: "getTable",
+      path: "/v1/tables/{table}",
+      description:
+        "Retrieves detailed information about a specific table, identified by its name or unique identifier.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      method: "get",
+      section: "tables",
+      response: {
+        description:
+          "Details of the requested table, including row count and indexing status.",
+        schema: {
+          type: "object",
+          properties: {
+            table: {
+              $ref: "#/components/schemas/Table",
+            },
+            rows: {
+              type: "number",
+              description: "The total number of rows present in the table.",
+            },
+            indexingCount: {
+              type: "number",
+              description:
+                "The number of rows pending indexing, relevant for search functionalities.",
+            },
+          },
+          required: ["table", "rows", "indexingCount"],
+          title: "getTableResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    createTable: {
+      name: "createTable",
+      path: "/v1/tables",
+      description:
+        "Initiates the creation of a new table based on the provided schema, excluding system-managed fields like IDs and timestamps.",
+      method: "post",
+      requestBody: {
+        description: "Schema defining the structure of the new table",
+        schema: {
+          type: "object",
+          properties: {
+            name: {
+              description:
+                "Required. This name is used to identify your table.",
+              type: "string",
+              minLength: 1,
+            },
+            factor: {
+              default: 1,
+              type: "number",
+              minimum: 1,
+              maximum: 30,
+              description:
+                "The 'factor' multiplies the row's data storage limit by 4KB and its quota count, but can only be set at table creation and not modified later. For instance, a factor of 2 increases storage to 8KB but counts as 2 rows in your quota. The default factor is 1.",
+            },
+            schema: {
+              type: "object",
+              additionalProperties: true,
+              description:
+                "Provide an object or a JSON schema to define the columns of the table. A maximum of 20 keys in the object/schema is allowed.",
+            },
+            tags: {
+              type: "object",
+              additionalProperties: {
+                type: "string",
+              },
+              description:
+                "Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.",
+            },
+          },
+          required: ["name", "schema"],
+          title: "createTableBody",
+          additionalProperties: false,
+        },
+      },
+      section: "tables",
+      response: {
+        description: "The created table object.",
+        schema: {
+          type: "object",
+          properties: {
+            table: {
+              $ref: "#/components/schemas/Table",
+            },
+          },
+          required: ["table"],
+          title: "createTableResponse",
+          additionalProperties: false,
+        },
+      },
+      parameters: {},
+    },
+    updateTable: {
+      name: "updateTable",
+      path: "/v1/tables/{table}",
+      description: "Updates the schema or the name of an existing table.",
+      method: "put",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description: "The updated schema/name of the table.",
+        schema: {
+          type: "object",
+          properties: {
+            name: {
+              description:
+                "Required. This name is used to identify your table.",
+              type: "string",
+              minLength: 1,
+            },
+            schema: {
+              type: "object",
+              additionalProperties: true,
+              description:
+                "Provide an object or a JSON schema to define the columns of the table. A maximum of 20 keys in the object/schema is allowed.",
+            },
+            tags: {
+              type: "object",
+              additionalProperties: {
+                type: "string",
+              },
+              description:
+                "Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.",
+            },
+          },
+          title: "updateTableBody",
+          additionalProperties: false,
+        },
+      },
+      section: "tables",
+      response: {
+        description: "The updated table",
+        schema: {
+          type: "object",
+          properties: {
+            table: {
+              $ref: "#/components/schemas/Table",
+            },
+          },
+          required: ["table"],
+          title: "updateTableResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    renameTableColumn: {
+      name: "renameTableColumn",
+      path: "/v1/tables/{table}/column",
+      description:
+        "Renames an existing column within a table to better reflect its content or usage. The operation targets a specific table and requires the current and new column names.",
+      method: "put",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description:
+          "Details of the column to be renamed, including its current name and the desired new name.",
+        schema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "The existing name of the column.",
+            },
+            newName: {
+              description: "The new name to assign to the column.",
+              type: "string",
+              minLength: 1,
+              maxLength: 30,
+            },
+          },
+          required: ["name", "newName"],
+          title: "renameTableColumnBody",
+          additionalProperties: false,
+        },
+      },
+      section: "tables",
+      response: {
+        description:
+          "Confirmation of the column rename operation, including the updated table schema.",
+        schema: {
+          type: "object",
+          properties: {
+            table: {
+              $ref: "#/components/schemas/Table",
+            },
+          },
+          required: ["table"],
+          title: "renameTableColumnResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    deleteTable: {
+      name: "deleteTable",
+      path: "/v1/tables/{table}",
+      description:
+        "Permanently deletes a table and all its associated data from the system. Use with caution, as this action cannot be undone.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      method: "delete",
+      section: "tables",
+      response: {
+        description: "Confirmation that the table has been deleted.",
+        schema: {
+          type: "object",
+          title: "deleteTableResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    getTableRow: {
+      name: "getTableRow",
+      path: "/v1/tables/{table}/row",
+      description:
+        "Fetches a specific row from a table using the row's unique identifier.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+        id: {
+          type: "object",
+          description: "Identifier of the row within the table.",
+          in: "query",
+          required: true,
+          schema: {
+            type: "integer",
+          },
+        },
+      },
+      method: "get",
+      section: "tables",
+      response: {
+        description: "The requested row object.",
+        schema: {
+          type: "object",
+          properties: {
+            row: {
+              $ref: "#/components/schemas/Row",
+            },
+          },
+          required: ["row"],
+          title: "getTableRowResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    findTableRows: {
+      name: "findTableRows",
+      path: "/v1/tables/{table}/rows/find",
+      description:
+        "Enables the search and filtering of rows within a table based on specific criteria. This operation supports complex queries for advanced data manipulation and retrieval.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description:
+          "The search criteria and filters to apply when searching for rows. This includes conditions, search terms, and pagination options.",
+        schema: {
+          type: "object",
+          properties: {
+            limit: {
+              default: 100,
+              type: "integer",
+              minimum: 1,
+              maximum: 1000,
+              description:
+                "Limit for pagination, specifying the maximum number of rows to return.",
+            },
+            offset: {
+              default: 0,
+              type: "integer",
+              minimum: 0,
+              description:
+                "Offset for pagination, specifying where to start returning rows from.",
+            },
+            filter: {
+              type: "object",
+              additionalProperties: true,
+              description:
+                'Provide a mongodb-like filter to apply to the query. Example: \\{ "name": \\{ "$eq": "John" \\} \\}',
+            },
+            group: {
+              type: "object",
+              additionalProperties: true,
+              description:
+                'Group the rows by a specific column and apply aggregations to them. Allowed values: key, avg, max, min, sum, count. Example: \\{ "someId": "key", "orders": ["sum", "avg"] \\}',
+            },
+            search: {
+              type: "string",
+              maxLength: 1024,
+              description:
+                "Search term to apply to the row search. When using this parameter, some rows which doesn't match the search term will be returned, use the similarity field to know how much the row matches the search term. ",
+            },
+            orderBy: {
+              default: "id",
+              type: "string",
+              description:
+                "Specifies the column by which to order the results. By default it is ordered by id. Build-in columns: id, createdAt, updatedAt",
+            },
+            orderDirection: {
+              default: "asc",
+              type: "string",
+              enum: ["asc", "desc"],
+              description:
+                "Specifies the direction of sorting, either ascending or descending.",
+            },
+          },
+          title: "findTableRowsBody",
+          additionalProperties: false,
+        },
+      },
+      method: "post",
+      section: "tables",
+      response: {
+        description:
+          "A collection of rows that match the search criteria, along with metadata such as total count and pagination details.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Row",
+              },
+            },
+            count: {
+              type: "integer",
+              description:
+                "The total number of rows matching the search criteria, regardless of pagination.",
+            },
+            offset: {
+              type: "integer",
+            },
+            limit: {
+              type: "integer",
+            },
+          },
+          required: ["rows", "count", "offset", "limit"],
+          title: "findTableRowsResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    createTableRows: {
+      name: "createTableRows",
+      path: "/v1/tables/{table}/rows",
+      description: "Inserts one or multiple new rows into the specified table.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description:
+          "A batch of new rows to insert into the table. Each row must adhere to the table’s schema. A maximum of 1000 rows can be inserted in a single request.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {},
+                additionalProperties: true,
+              },
+              minItems: 1,
+              maxItems: 1000,
+            },
+          },
+          required: ["rows"],
+          title: "createTableRowsBody",
+          additionalProperties: false,
+        },
+      },
+      method: "post",
+      section: "tables",
+      response: {
+        description:
+          "A summary of the insertion operation, including any warnings or errors encountered, and the inserted row data.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Row",
+              },
+            },
+            warnings: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Alerts for minor issues that don't block the operation but suggest possible improvements.",
+            },
+            errors: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Critical issues in specific elements that prevent their successful processing, allowing partial operation success.",
+            },
+          },
+          required: ["rows"],
+          title: "createTableRowsResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    deleteTableRows: {
+      name: "deleteTableRows",
+      path: "/v1/tables/{table}/rows/delete",
+      description:
+        "Allows selective deletion of rows or complete clearance of a table.",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description: "Identifiers of the rows to be deleted.",
+        schema: {
+          type: "object",
+          properties: {
+            ids: {
+              type: "array",
+              items: {
+                type: "number",
+              },
+              maxItems: 1000,
+            },
+            filter: {
+              type: "object",
+              additionalProperties: true,
+              description:
+                'Filter to apply when deleting rows. Example: \\{ "name": \\{ "$eq": "John" \\} \\}',
+            },
+            deleteAllRows: {
+              type: "boolean",
+              description:
+                "Flag to delete all rows. Use with caution as this action is irreversible.",
+            },
+          },
+          title: "deleteTableRowsBody",
+          additionalProperties: false,
+        },
+      },
+      method: "post",
+      section: "tables",
+      response: {
+        description: "Confirms the number of rows successfully deleted.",
+        schema: {
+          type: "object",
+          properties: {
+            deletedRows: {
+              type: "number",
+            },
+          },
+          required: ["deletedRows"],
+          title: "deleteTableRowsResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    updateTableRows: {
+      name: "updateTableRows",
+      path: "/v1/tables/{table}/rows",
+      description:
+        "Updates specified rows in a table, allowing partial success with detailed feedback on errors.",
+      method: "put",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description:
+          "Data for rows to update, including IDs. Errors affect only specific rows, not the entire batch.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "number",
+                  },
+                },
+                required: ["id"],
+                additionalProperties: true,
+              },
+              minItems: 1,
+              maxItems: 1000,
+              description: "Rows with updated data, identified by ID.",
+            },
+          },
+          required: ["rows"],
+          title: "updateTableRowsBody",
+          additionalProperties: false,
+        },
+      },
+      section: "tables",
+      response: {
+        description:
+          "Returns updated rows, including warnings for minor issues and errors for failed updates.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Row",
+              },
+            },
+            warnings: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Alerts for minor issues that don't block the operation but suggest possible improvements.",
+            },
+            errors: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Critical issues in specific elements that prevent their successful processing, allowing partial operation success.",
+            },
+          },
+          required: ["rows"],
+          title: "updateTableRowsResponse",
+          additionalProperties: false,
+        },
+      },
+    },
+    upsertTableRows: {
+      name: "upsertTableRows",
+      path: "/v1/tables/{table}/rows/upsert",
+      description:
+        "Inserts or updates rows based on a key. If a row exists, it is updated; otherwise, a new row is created.",
+      method: "post",
+      parameters: {
+        table: {
+          type: "string",
+          description:
+            "The table's name or unique identifier for targeting specific table operations.",
+          in: "path",
+        },
+      },
+      requestBody: {
+        description:
+          "Rows for insertion or update, with a key column to determine action. Supports partial successes.",
+        schema: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "number",
+                  },
+                },
+                additionalProperties: true,
+              },
+              minItems: 1,
+              maxItems: 1000,
+            },
+            keyColumn: {
+              default: "id",
+              type: "string",
+              minLength: 1,
+              maxLength: 30,
+              description:
+                'Determines if a row is inserted or updated. Defaults to "id".',
+            },
+          },
+          required: ["rows"],
+          title: "upsertTableRowsBody",
+          additionalProperties: false,
+        },
+      },
+      section: "tables",
+      response: {
+        description:
+          "Summary of insertions and updates, including any warnings or errors.",
+        schema: {
+          type: "object",
+          properties: {
+            inserted: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Row",
+              },
+            },
+            updated: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Row",
+              },
+            },
+            warnings: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Alerts for minor issues that don't block the operation but suggest possible improvements.",
+            },
+            errors: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+              description:
+                "Critical issues in specific elements that prevent their successful processing, allowing partial operation success.",
+            },
+          },
+          required: ["inserted", "updated"],
+          title: "upsertTableRowsResponse",
+          additionalProperties: false,
+        },
+      },
+    },
   },
   metadata: {
     title: "Botpress API",
     description: "API for Botpress Cloud",
     server: "https://api.botpress.cloud",
-    version: "0.18.0",
+    version: "0.18.1",
     prefix: "v1",
   },
   errors: [
@@ -6820,7 +7534,13 @@ export const state = {
       status: 409,
       type: "RelationConflict",
       description:
-        "The resource is not related with another resource. This is usually caused when providing two resources that aren't linked together.",
+        "The resource is related with a different resource that the one referenced in the request. This is usually caused when providing two resource identifiers that aren't linked together.",
+    },
+    {
+      status: 409,
+      type: "ReferenceConstraint",
+      description:
+        "The resource cannot be deleted because it's referenced by another resource",
     },
     {
       status: 400,
@@ -6908,6 +7628,14 @@ export const state = {
       changeAISpendQuotaBody: true,
       introspectBody: true,
       createFileBody: true,
+      createTableBody: true,
+      updateTableBody: true,
+      renameTableColumnBody: true,
+      findTableRowsBody: true,
+      createTableRowsBody: true,
+      deleteTableRowsBody: true,
+      updateTableRowsBody: true,
+      upsertTableRowsBody: true,
     },
     responses: {
       createConversationResponse: true,
@@ -7006,6 +7734,18 @@ export const state = {
       downloadFileResponse: true,
       deleteFileResponse: true,
       listFilesResponse: true,
+      listTablesResponse: true,
+      getTableResponse: true,
+      createTableResponse: true,
+      updateTableResponse: true,
+      renameTableColumnResponse: true,
+      deleteTableResponse: true,
+      getTableRowResponse: true,
+      findTableRowsResponse: true,
+      createTableRowsResponse: true,
+      deleteTableRowsResponse: true,
+      updateTableRowsResponse: true,
+      upsertTableRowsResponse: true,
     },
     schemas: {
       Bot: true,
@@ -8723,8 +9463,9 @@ export const state = {
             description: "Unique identifier for the table",
           },
           name: {
-            type: "string",
             description: "Required. This name is used to identify your table.",
+            type: "string",
+            minLength: 1,
           },
           factor: {
             default: 1,
@@ -9121,9 +9862,23 @@ export const state = {
     },
     {
       title: "Tables",
-      description: "Operations related to table management.",
+      description:
+        "Manage and interact with table structures, including creation, updates, and querying of tables and their rows.",
       name: "tables",
-      operations: [],
+      operations: [
+        "listTables",
+        "getTable",
+        "createTable",
+        "updateTable",
+        "renameTableColumn",
+        "deleteTable",
+        "getTableRow",
+        "findTableRows",
+        "createTableRows",
+        "deleteTableRows",
+        "updateTableRows",
+        "upsertTableRows",
+      ],
       schema: "Table",
     },
   ],