@budibase/server 1.0.79 → 1.0.80-alpha.2

package/specs/parameters.js

@@ -0,0 +1,59 @@
+exports.tableId = {
+  in: "path",
+  name: "tableId",
+  required: true,
+  description: "The ID of the table which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}
+
+exports.rowId = {
+  in: "path",
+  name: "rowId",
+  required: true,
+  description: "The ID of the row which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}
+
+exports.appId = {
+  in: "header",
+  name: "x-budibase-app-id",
+  required: true,
+  description: "The ID of the app which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}
+
+exports.appIdUrl = {
+  in: "path",
+  name: "appId",
+  required: true,
+  description: "The ID of the app which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}
+
+exports.queryId = {
+  in: "path",
+  name: "queryId",
+  required: true,
+  description: "The ID of the query which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}
+
+exports.userId = {
+  in: "path",
+  name: "userId",
+  required: true,
+  description: "The ID of the user which this request is targeting.",
+  schema: {
+    type: "string",
+  },
+}

package/specs/resources/application.js

@@ -0,0 +1,101 @@
+const userResource = require("./user")
+const { object } = require("./utils")
+const Resource = require("./utils/Resource")
+
+const application = {
+  _id: "app_metadata",
+  appId: "app_dev_957b12f943d348faa61db7e18e088d0f",
+  version: "1.0.58-alpha.0",
+  name: "App name",
+  url: "/app-url",
+  tenantId: "default",
+  updatedAt: "2022-02-22T13:00:54.035Z",
+  createdAt: "2022-02-11T18:02:26.961Z",
+  status: "development",
+  lockedBy: userResource.getExamples().user.value.user,
+}
+
+const base = {
+  name: {
+    description: "The name of the app.",
+    type: "string",
+  },
+  url: {
+    description:
+      "The URL by which the app is accessed, this must be URL encoded.",
+    type: "string",
+  },
+}
+
+const applicationSchema = object(base, { required: ["name", "url"] })
+
+const applicationOutputSchema = object(
+  {
+    ...base,
+    _id: {
+      description: "The ID of the app.",
+      type: "string",
+    },
+    status: {
+      description:
+        "The status of the app, stating it if is the development or published version.",
+      type: "string",
+      enum: ["development", "published"],
+    },
+    createdAt: {
+      description:
+        "States when the app was created, will be constant. Stored in ISO format.",
+      type: "string",
+    },
+    updatedAt: {
+      description:
+        "States the last time the app was updated - stored in ISO format.",
+      type: "string",
+    },
+    version: {
+      description:
+        "States the version of the Budibase client this app is currently based on.",
+      type: "string",
+    },
+    tenantId: {
+      description:
+        "In a multi-tenant environment this will state the tenant this app is within.",
+      type: "string",
+    },
+    lockedBy: {
+      description: "The user this app is currently being built by.",
+      type: "object",
+    },
+  },
+  {
+    required: [
+      "_id",
+      "name",
+      "url",
+      "status",
+      "createdAt",
+      "updatedAt",
+      "version",
+    ],
+  }
+)
+
+module.exports = new Resource()
+  .setExamples({
+    application: {
+      value: {
+        data: application,
+      },
+    },
+    applications: {
+      value: {
+        data: [application],
+      },
+    },
+  })
+  .setSchemas({
+    application: applicationSchema,
+    applicationOutput: object({
+      data: applicationOutputSchema,
+    }),
+  })

package/specs/resources/index.js

@@ -0,0 +1,24 @@
+const application = require("./application")
+const row = require("./row")
+const table = require("./table")
+const query = require("./query")
+const user = require("./user")
+const misc = require("./misc")
+
+exports.examples = {
+  ...application.getExamples(),
+  ...row.getExamples(),
+  ...table.getExamples(),
+  ...query.getExamples(),
+  ...user.getExamples(),
+  ...misc.getExamples(),
+}
+
+exports.schemas = {
+  ...application.getSchemas(),
+  ...row.getSchemas(),
+  ...table.getSchemas(),
+  ...query.getSchemas(),
+  ...user.getSchemas(),
+  ...misc.getSchemas(),
+}

package/specs/resources/misc.js

@@ -0,0 +1,12 @@
+const { object } = require("./utils")
+const Resource = require("./utils/Resource")
+
+module.exports = new Resource().setSchemas({
+  nameSearch: object({
+    name: {
+      type: "string",
+      description:
+        "The name to be used when searching - this will be used in a case insensitive starts with match.",
+    },
+  }),
+})

package/specs/resources/query.js

@@ -0,0 +1,189 @@
+const Resource = require("./utils/Resource")
+const { object } = require("./utils")
+const { BaseQueryVerbs } = require("../../src/constants")
+
+const query = {
+  _id: "query_datasource_plus_4d8be0c506b9465daf4bf84d890fdab6_454854487c574d45bc4029b1e153219e",
+  datasourceId: "datasource_plus_4d8be0c506b9465daf4bf84d890fdab6",
+  parameters: [],
+  fields: {
+    sql: "select * from persons",
+  },
+  queryVerb: "read",
+  name: "Help",
+  schema: {
+    personid: {
+      name: "personid",
+      type: "string",
+    },
+    lastname: {
+      name: "lastname",
+      type: "string",
+    },
+    firstname: {
+      name: "firstname",
+      type: "string",
+    },
+    address: {
+      name: "address",
+      type: "string",
+    },
+    city: {
+      name: "city",
+      type: "string",
+    },
+  },
+  transformer: "return data",
+  readable: true,
+}
+
+const restResponse = {
+  value: {
+    data: [
+      {
+        value: "<html lang='en-GB'></html>",
+      },
+    ],
+    pagination: {
+      cursor: "2",
+    },
+    raw: "<html lang='en-GB'></html>",
+    headers: {
+      "content-type": "text/html; charset=ISO-8859-1",
+    },
+  },
+}
+
+const sqlResponse = {
+  value: {
+    data: [
+      {
+        personid: 1,
+        lastname: "Hughes",
+        firstname: "Mike",
+        address: "123 Fake Street",
+        city: "Belfast",
+      },
+      {
+        personid: 2,
+        lastname: "Smith",
+        firstname: "John",
+        address: "64 Updown Road",
+        city: "Dublin",
+      },
+    ],
+  },
+}
+
+const querySchema = object(
+  {
+    _id: {
+      description: "The ID of the query.",
+      type: "string",
+    },
+    datasourceId: {
+      description: "The ID of the data source the query belongs to.",
+      type: "string",
+    },
+    parameters: {
+      description: "The bindings which are required to perform this query.",
+      type: "array",
+      items: {
+        type: "string",
+      },
+    },
+    fields: {
+      description:
+        "The fields that are used to perform this query, e.g. the sql statement",
+      type: "object",
+    },
+    queryVerb: {
+      description: "The verb that describes this query.",
+      enum: Object.values(BaseQueryVerbs),
+    },
+    name: {
+      description: "The name of the query.",
+      type: "string",
+    },
+    schema: {
+      description:
+        "The schema of the data returned when the query is executed.",
+      type: "object",
+    },
+    transformer: {
+      description:
+        "The JavaScript transformer function, applied after the query responds with data.",
+      type: "string",
+    },
+    readable: {
+      description: "Whether the query has readable data.",
+      type: "boolean",
+    },
+  },
+  { required: ["name", "schema", "_id"] }
+)
+
+const executeQuerySchema = {
+  description:
+    "The query body must contain the required parameters for the query, this depends on query type, setup and bindings.",
+  type: "object",
+  additionalProperties: {
+    description:
+      "Key value properties of any type, depending on the query output schema.",
+  },
+}
+
+const executeQueryOutputSchema = object(
+  {
+    data: {
+      description: "The data response from the query.",
+      type: "array",
+      items: {
+        type: "object",
+      },
+    },
+    extra: {
+      description:
+        "Extra information that is not part of the main data, e.g. headers.",
+      type: "object",
+      properties: {
+        headers: {
+          description:
+            "If carrying out a REST request, this will contain the response headers.",
+          type: "object",
+        },
+        raw: {
+          description: "The raw query response, as a string.",
+          type: "string",
+        },
+      },
+    },
+    pagination: {
+      description:
+        "If pagination is supported, this will contain the bookmark/anchor information for it.",
+      type: "object",
+    },
+  },
+  { required: ["data"] }
+)
+
+module.exports = new Resource()
+  .setExamples({
+    query: {
+      value: {
+        data: query,
+      },
+    },
+    queries: {
+      value: {
+        data: [query],
+      },
+    },
+    restResponse,
+    sqlResponse,
+  })
+  .setSchemas({
+    executeQuery: executeQuerySchema,
+    executeQueryOutput: executeQueryOutputSchema,
+    query: querySchema,
+  })

package/specs/resources/row.js

@@ -0,0 +1,125 @@
+const { object } = require("./utils")
+const Resource = require("./utils/Resource")
+
+const baseRow = {
+  _id: "ro_ta_5b1649e42a5b41dea4ef7742a36a7a70_e6dc7e38cf1343b2b56760265201cda4",
+  type: "row",
+  tableId: "ta_5b1649e42a5b41dea4ef7742a36a7a70",
+  name: "Mike",
+  age: 30,
+}
+
+const inputRow = {
+  ...baseRow,
+  relationship: ["ro_ta_..."],
+}
+
+const row = {
+  ...baseRow,
+  relationship: [
+    {
+      primaryDisplay: "Joe",
+      _id: "ro_ta_...",
+    },
+  ],
+}
+
+const enrichedRow = {
+  _id: "ro_ta_5b1649e42a5b41dea4ef7742a36a7a70_e6dc7e38cf1343b2b56760265201cda4",
+  name: "eg",
+  tableId: "ta_5b1649e42a5b41dea4ef7742a36a7a70",
+  type: "row",
+  relationship: [
+    {
+      _id: "ro_ta_users_us_8f3d717147d74d759d8cef5b6712062f",
+      name: "Joe",
+      tableId: "ta_users",
+      internal: [
+        {
+          _id: "ro_ta_5b1649e42a5b41dea4ef7742a36a7a70_e6dc7e38cf1343b2b56760265201cda4",
+          primaryDisplay: "eg",
+        },
+      ],
+    },
+  ],
+}
+
+const rowSchema = {
+  description: "The row to be created/updated, based on the table schema.",
+  type: "object",
+  additionalProperties: {
+    description:
+      "Key value properties of any type, depending on the table schema.",
+  },
+}
+
+const rowOutputSchema = {
+  ...rowSchema,
+  properties: {
+    ...rowSchema.properties,
+    _id: {
+      description: "The ID of the row.",
+      type: "string",
+    },
+    tableId: {
+      description: "The ID of the table this row comes from.",
+      type: "string",
+    },
+  },
+  required: ["tableId", "_id"],
+}
+
+const searchOutputSchema = {
+  type: "object",
+  required: ["data"],
+  properties: {
+    data: {
+      description:
+        "An array of rows, these will each contain an _id field which can be used to update or delete them.",
+      type: "array",
+      items: {
+        type: "object",
+      },
+    },
+    bookmark: {
+      description: "If pagination in use, this should be provided.",
+      oneOf: [{ type: "string" }, { type: "integer" }],
+    },
+    hasNextPage: {
+      description:
+        "If pagination in use, this will determine if there is another page to fetch.",
+      type: "boolean",
+    },
+  },
+}
+
+module.exports = new Resource()
+  .setExamples({
+    inputRow: {
+      value: inputRow,
+    },
+    row: {
+      value: {
+        data: row,
+      },
+    },
+    enrichedRow: {
+      value: {
+        data: enrichedRow,
+      },
+    },
+    rows: {
+      value: {
+        data: [row],
+        hasNextPage: true,
+        bookmark: 10,
+      },
+    },
+  })
+  .setSchemas({
+    row: rowSchema,
+    searchOutput: searchOutputSchema,
+    rowOutput: object({
+      data: rowOutputSchema,
+    }),
+  })

package/specs/resources/table.js

@@ -0,0 +1,191 @@
+const {
+  FieldTypes,
+  RelationshipTypes,
+  FormulaTypes,
+} = require("../../src/constants")
+const { object } = require("./utils")
+const Resource = require("./utils/Resource")
+
+const table = {
+  _id: "ta_5b1649e42a5b41dea4ef7742a36a7a70",
+  name: "People",
+  schema: {
+    name: {
+      type: "string",
+      name: "name",
+    },
+    age: {
+      type: "number",
+      name: "age",
+    },
+    relationship: {
+      type: "link",
+      name: "relationship",
+      tableId: "ta_...",
+      fieldName: "relatedColumn",
+      relationshipType: "many-to-many",
+    },
+  },
+}
+
+const baseColumnDef = {
+  type: {
+    type: "string",
+    enum: Object.values(FieldTypes),
+    description:
+      "Defines the type of the column, most explain themselves, a link column is a relationship.",
+  },
+  constraints: {
+    type: "object",
+    description:
+      "A constraint can be applied to the column which will be validated against when a row is saved.",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["string", "number", "object", "boolean"],
+      },
+      presence: {
+        type: "boolean",
+        description: "Defines whether the column is required or not.",
+      },
+    },
+  },
+  name: {
+    type: "string",
+    description: "The name of the column.",
+  },
+  autocolumn: {
+    type: "boolean",
+    description: "Defines whether the column is automatically generated.",
+  },
+}
+
+const tableSchema = {
+  description: "The table to be created/updated.",
+  type: "object",
+  required: ["name", "schema"],
+  properties: {
+    name: {
+      description: "The name of the table.",
+      type: "string",
+    },
+    primaryDisplay: {
+      type: "string",
+      description:
+        "The name of the column which should be used in relationship tags when relating to this table.",
+    },
+    schema: {
+      type: "object",
+      additionalProperties: {
+        oneOf: [
+          // relationship
+          {
+            type: "object",
+            properties: {
+              ...baseColumnDef,
+              type: {
+                type: "string",
+                enum: [FieldTypes.LINK],
+                description: "A relationship column.",
+              },
+              fieldName: {
+                type: "string",
+                description:
+                  "The name of the column which a relationship column is related to in another table.",
+              },
+              tableId: {
+                type: "string",
+                description:
+                  "The ID of the table which a relationship column is related to.",
+              },
+              relationshipType: {
+                type: "string",
+                enum: Object.values(RelationshipTypes),
+                description:
+                  "Defines the type of relationship that this column will be used for.",
+              },
+              through: {
+                type: "string",
+                description:
+                  "When using a SQL table that contains many to many relationships this defines the table the relationships are linked through.",
+              },
+              foreignKey: {
+                type: "string",
+                description:
+                  "When using a SQL table that contains a one to many relationship this defines the foreign key.",
+              },
+              throughFrom: {
+                type: "string",
+                description:
+                  "When using a SQL table that utilises a through table, this defines the primary key in the through table for this table.",
+              },
+              throughTo: {
+                type: "string",
+                description:
+                  "When using a SQL table that utilises a through table, this defines the primary key in the through table for the related table.",
+              },
+            },
+          },
+          {
+            type: "object",
+            properties: {
+              ...baseColumnDef,
+              type: {
+                type: "string",
+                enum: [FieldTypes.FORMULA],
+                description: "A formula column.",
+              },
+              formula: {
+                type: "string",
+                description:
+                  "Defines a Handlebars or JavaScript formula to use, note that Javascript formulas are expected to be provided in the base64 format.",
+              },
+              formulaType: {
+                type: "string",
+                enum: Object.values(FormulaTypes),
+                description:
+                  "Defines whether this is a static or dynamic formula.",
+              },
+            },
+          },
+          {
+            type: "object",
+            properties: baseColumnDef,
+          },
+        ],
+      },
+    },
+  },
+}
+
+const tableOutputSchema = {
+  ...tableSchema,
+  properties: {
+    ...tableSchema.properties,
+    _id: {
+      description: "The ID of the table.",
+      type: "string",
+    },
+  },
+  required: [...tableSchema.required, "_id"],
+}
+
+module.exports = new Resource()
+  .setExamples({
+    table: {
+      value: {
+        data: table,
+      },
+    },
+    tables: {
+      value: {
+        data: [table],
+      },
+    },
+  })
+  .setSchemas({
+    table: tableSchema,
+    tableOutput: object({
+      data: tableOutputSchema,
+    }),
+  })