@budibase/server 0.0.32 → 0.0.999-alpha.30

package/scripts/docs/toSwagger.js

@@ -0,0 +1,320 @@
+let _ = require("lodash")
+let { pathToRegexp } = require("path-to-regexp")
+
+/********************************************************
+ * Based on: https://github.com/fsbahman/apidoc-swagger *
+ ********************************************************/
+
+let swagger = {
+  swagger: "2.0",
+  info: {},
+  paths: {},
+  definitions: {},
+}
+
+function toSwagger(apidocJson, projectJson) {
+  swagger.info = addInfo(projectJson)
+  swagger.paths = extractPaths(apidocJson)
+  return swagger
+}
+
+let tagsRegex = /(<([^>]+)>)/gi
+// Removes <p> </p> tags from text
+function removeTags(text) {
+  return text ? text.replace(tagsRegex, "") : text
+}
+
+function addInfo(projectJson) {
+  let info = {}
+  info["title"] = projectJson.title || projectJson.name
+  info["version"] = projectJson.version
+  info["description"] = projectJson.description
+  return info
+}
+
+/**
+ * Extracts paths provided in json format
+ * post, patch, put request parameters are extracted in body
+ * get and delete are extracted to path parameters
+ * @param apidocJson
+ * @returns {{}}
+ */
+function extractPaths(apidocJson) {
+  let apiPaths = groupByUrl(apidocJson)
+  let paths = {}
+  for (let i = 0; i < apiPaths.length; i++) {
+    let verbs = apiPaths[i].verbs
+    let url = verbs[0].url
+    let pattern = pathToRegexp(url, null)
+    let matches = pattern.exec(url)
+
+    // Surrounds URL parameters with curly brackets -> :email with {email}
+    let pathKeys = []
+    for (let j = 1; j < matches.length; j++) {
+      let key = matches[j].slice(1)
+      url = url.replace(matches[j], "{" + key + "}")
+      pathKeys.push(key)
+    }
+
+    for (let j = 0; j < verbs.length; j++) {
+      let verb = verbs[j]
+      let type = verb.type
+
+      let obj = (paths[url] = paths[url] || {})
+
+      if (type === "post" || type === "patch" || type === "put") {
+        _.extend(
+          obj,
+          createPostPushPutOutput(verb, swagger.definitions, pathKeys)
+        )
+      } else {
+        _.extend(obj, createGetDeleteOutput(verb, swagger.definitions))
+      }
+    }
+  }
+  return paths
+}
+
+function createPostPushPutOutput(verbs, definitions, pathKeys) {
+  let pathItemObject = {}
+  let verbDefinitionResult = createVerbDefinitions(verbs, definitions)
+
+  let params = []
+  let pathParams = createPathParameters(verbs, pathKeys)
+  pathParams = _.filter(pathParams, function (param) {
+    let hasKey = pathKeys.indexOf(param.name) !== -1
+    return !(param.in === "path" && !hasKey)
+  })
+
+  params = params.concat(pathParams)
+  let required =
+    verbs.parameter &&
+    verbs.parameter.fields &&
+    verbs.parameter.fields.Parameter &&
+    verbs.parameter.fields.Parameter.length > 0
+
+  params.push({
+    in: "body",
+    name: "body",
+    description: removeTags(verbs.description),
+    required: required,
+    schema: {
+      $ref: "#/definitions/" + verbDefinitionResult.topLevelParametersRef,
+    },
+  })
+
+  pathItemObject[verbs.type] = {
+    tags: [verbs.group],
+    summary: removeTags(verbs.description),
+    consumes: ["application/json"],
+    produces: ["application/json"],
+    parameters: params,
+  }
+
+  if (verbDefinitionResult.topLevelSuccessRef) {
+    pathItemObject[verbs.type].responses = {
+      200: {
+        description: "successful operation",
+        schema: {
+          type: verbDefinitionResult.topLevelSuccessRefType,
+          items: {
+            $ref: "#/definitions/" + verbDefinitionResult.topLevelSuccessRef,
+          },
+        },
+      },
+    }
+  }
+
+  return pathItemObject
+}
+
+function createVerbDefinitions(verbs, definitions) {
+  let result = {
+    topLevelParametersRef: null,
+    topLevelSuccessRef: null,
+    topLevelSuccessRefType: null,
+  }
+  let defaultObjectName = verbs.name
+
+  let fieldArrayResult = {}
+  if (verbs && verbs.parameter && verbs.parameter.fields) {
+    fieldArrayResult = createFieldArrayDefinitions(
+      verbs.parameter.fields.Parameter,
+      definitions,
+      verbs.name,
+      defaultObjectName
+    )
+    result.topLevelParametersRef = fieldArrayResult.topLevelRef
+  }
+
+  if (verbs && verbs.success && verbs.success.fields) {
+    fieldArrayResult = createFieldArrayDefinitions(
+      verbs.success.fields["Success 200"],
+      definitions,
+      verbs.name,
+      defaultObjectName
+    )
+    result.topLevelSuccessRef = fieldArrayResult.topLevelRef
+    result.topLevelSuccessRefType = fieldArrayResult.topLevelRefType
+  }
+
+  return result
+}
+
+function createFieldArrayDefinitions(
+  fieldArray,
+  definitions,
+  topLevelRef,
+  defaultObjectName
+) {
+  let result = {
+    topLevelRef: topLevelRef,
+    topLevelRefType: null,
+  }
+
+  if (!fieldArray) {
+    return result
+  }
+
+  for (let i = 0; i < fieldArray.length; i++) {
+    let parameter = fieldArray[i]
+
+    let nestedName = createNestedName(parameter.field)
+    let objectName = nestedName.objectName
+    if (!objectName) {
+      objectName = defaultObjectName
+    }
+    let type = parameter.type
+    if (i === 0) {
+      result.topLevelRefType = type
+      if (parameter.type === "Object") {
+        objectName = nestedName.propertyName
+        nestedName.propertyName = null
+      } else if (parameter.type === "Array") {
+        objectName = nestedName.propertyName
+        nestedName.propertyName = null
+        result.topLevelRefType = "array"
+      }
+      result.topLevelRef = objectName
+    }
+
+    definitions[objectName] = definitions[objectName] || {
+      properties: {},
+      required: [],
+    }
+
+    if (nestedName.propertyName) {
+      let prop = {
+        type: (parameter.type || "").toLowerCase(),
+        description: removeTags(parameter.description),
+      }
+      if (parameter.type === "Object") {
+        prop.$ref = "#/definitions/" + parameter.field
+      }
+
+      let typeIndex = type.indexOf("[]")
+      if (typeIndex !== -1 && typeIndex === type.length - 2) {
+        prop.type = "array"
+        prop.items = {
+          type: type.slice(0, type.length - 2),
+        }
+      }
+
+      definitions[objectName]["properties"][nestedName.propertyName] = prop
+      if (!parameter.optional) {
+        let arr = definitions[objectName]["required"]
+        if (arr.indexOf(nestedName.propertyName) === -1) {
+          arr.push(nestedName.propertyName)
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+function createNestedName(field) {
+  let propertyName = field
+  let objectName
+  let propertyNames = field.split(".")
+  if (propertyNames && propertyNames.length > 1) {
+    propertyName = propertyNames[propertyNames.length - 1]
+    propertyNames.pop()
+    objectName = propertyNames.join(".")
+  }
+
+  return {
+    propertyName: propertyName,
+    objectName: objectName,
+  }
+}
+
+/**
+ * Generate get, delete method output
+ * @param verbs
+ * @param definitions
+ * @returns {{}}
+ */
+function createGetDeleteOutput(verbs, definitions) {
+  let pathItemObject = {}
+  verbs.type = verbs.type === "del" ? "delete" : verbs.type
+
+  let verbDefinitionResult = createVerbDefinitions(verbs, definitions)
+  pathItemObject[verbs.type] = {
+    tags: [verbs.group],
+    summary: removeTags(verbs.description),
+    consumes: ["application/json"],
+    produces: ["application/json"],
+    parameters: createPathParameters(verbs),
+  }
+  if (verbDefinitionResult.topLevelSuccessRef) {
+    pathItemObject[verbs.type].responses = {
+      200: {
+        description: "successful operation",
+        schema: {
+          type: verbDefinitionResult.topLevelSuccessRefType,
+          items: {
+            $ref: "#/definitions/" + verbDefinitionResult.topLevelSuccessRef,
+          },
+        },
+      },
+    }
+  }
+  return pathItemObject
+}
+
+/**
+ * Iterate through all method parameters and create array of parameter objects which are stored as path parameters
+ * @param verbs
+ * @returns {Array}
+ */
+function createPathParameters(verbs) {
+  let pathItemObject = []
+  if (verbs.parameter && verbs.parameter.fields.Parameter) {
+    for (let i = 0; i < verbs.parameter.fields.Parameter.length; i++) {
+      let param = verbs.parameter.fields.Parameter[i]
+      let field = param.field
+      let type = param.type
+      pathItemObject.push({
+        name: field,
+        in: type === "file" ? "formData" : "path",
+        required: !param.optional,
+        type: param.type.toLowerCase(),
+        description: removeTags(param.description),
+      })
+    }
+  }
+  return pathItemObject
+}
+
+function groupByUrl(apidocJson) {
+  return _.chain(apidocJson)
+    .groupBy("url")
+    .toPairs()
+    .map(function (element) {
+      return _.zipObject(["url", "verbs"], element)
+    })
+    .value()
+}
+
+module.exports = toSwagger

package/scripts/exportAppTemplate.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+const yargs = require("yargs")
+const fs = require("fs")
+const { join } = require("path")
+require("../src/db").init()
+const { db: dbCore } = require("@budibase/backend-core")
+// load environment
+const env = require("../src/environment")
+const {
+  USER_METDATA_PREFIX,
+  LINK_USER_METADATA_PREFIX,
+} = require("../src/db/utils")
+
+// Script to export a chosen budibase app into a package
+// Usage: ./scripts/exportAppTemplate.js export --name=Funky --appId=appId
+
+yargs
+  .command(
+    "export",
+    "Export an existing budibase application to the .budibase/templates directory",
+    {
+      name: {
+        description: "The name of the newly exported template",
+        alias: "n",
+        type: "string",
+      },
+      appId: {
+        description: "The appId of the application you want to export",
+        alias: "app",
+        type: "string",
+      },
+    },
+    async args => {
+      if (!env.isDev()) {
+        throw "Only works in dev"
+      }
+      const name = args.name,
+        appId = args.appId
+      console.log("Exporting app..")
+      if (name == null || appId == null) {
+        console.error(
+          "Unable to export without a name and app ID being specified, check help for more info."
+        )
+        return
+      }
+      const exportPath = join(process.cwd(), name, "db")
+      fs.ensureDirSync(exportPath)
+      const writeStream = fs.createWriteStream(join(exportPath, "dump.text"))
+      // perform couch dump
+
+      await dbCore.doWithDB(appId, async db => {
+        return db.dump(writeStream, {
+          filter: doc =>
+            !(
+              doc._id.includes(USER_METDATA_PREFIX) ||
+              doc.includes(LINK_USER_METADATA_PREFIX)
+            ),
+        })
+      })
+      console.log(`Template ${name} exported to ${exportPath}`)
+    }
+  )
+  .help()
+  .alias("help", "h").argv

package/scripts/integrations/customer-categories/docker-compose.yml

@@ -0,0 +1,28 @@
+version: "3.8"
+services:
+  db:
+    container_name: postgres
+    image: postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: root
+      POSTGRES_PASSWORD: root
+      POSTGRES_DB: main
+    ports:
+      - "5432:5432"
+    volumes:
+      #- pg_data:/var/lib/postgresql/data/
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
+
+  pgadmin:
+    container_name: pgadmin-pg
+    image: dpage/pgadmin4
+    restart: unless-stopped
+    environment:
+      PGADMIN_DEFAULT_EMAIL: root@root.com
+      PGADMIN_DEFAULT_PASSWORD: root
+    ports:
+      - "5050:80"
+
+#volumes:
+#  pg_data:

package/scripts/integrations/customer-categories/init.sql

@@ -0,0 +1,41 @@
+SELECT 'CREATE DATABASE main'
+WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = 'main')\gexec
+
+CREATE TABLE categories
+(
+    name text COLLATE pg_catalog."default",
+    id integer NOT NULL GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 2147483647 CACHE 1 ),
+    CONSTRAINT categories_pkey PRIMARY KEY (id)
+);
+
+CREATE TABLE customers
+(
+    id integer NOT NULL GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 2147483647 CACHE 1 ),
+    name text COLLATE pg_catalog."default",
+    email text COLLATE pg_catalog."default",
+    age integer,
+    "dateOfBirth" date,
+    CONSTRAINT customers_pkey PRIMARY KEY (id)
+);
+
+CREATE TABLE customer_category
+(
+    customer_id integer,
+    category_id integer,
+    notes text COLLATE pg_catalog."default",
+    id integer NOT NULL GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 2147483647 CACHE 1 ),
+    CONSTRAINT "Category" FOREIGN KEY (category_id)
+        REFERENCES public.categories (id) MATCH SIMPLE
+        ON UPDATE NO ACTION
+        ON DELETE NO ACTION
+        NOT VALID,
+    CONSTRAINT "Customer" FOREIGN KEY (customer_id)
+        REFERENCES public.customers (id) MATCH SIMPLE
+        ON UPDATE NO ACTION
+        ON DELETE NO ACTION
+        NOT VALID
+);
+
+
+INSERT INTO customers (name, email, age) VALUES ('Mike', 'mike@mike.com', 30);
+INSERT INTO categories (name) VALUES ('Books');

package/scripts/integrations/customer-categories/reset.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+docker-compose down
+docker volume prune -f

package/scripts/integrations/mssql/data/Dockerfile

@@ -0,0 +1,9 @@
+FROM mcr.microsoft.com/mssql/server:2017-latest
+
+ENV ACCEPT_EULA=Y
+ENV SA_PASSWORD=Passw0rd
+
+COPY ./data /
+
+ENTRYPOINT [ "/bin/bash", "entrypoint.sh" ]
+CMD [ "/opt/mssql/bin/sqlservr" ]

package/scripts/integrations/mssql/data/entrypoint.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+if [ "$1" = '/opt/mssql/bin/sqlservr' ]; then
+  # If this is the container's first run, initialize the application database
+  if [ ! -f /tmp/app-initialized ]; then
+    # Initialize the application database asynchronously in a background process. This allows a) the SQL Server process to be the main process in the container, which allows graceful shutdown and other goodies, and b) us to only start the SQL Server process once, as opposed to starting, stopping, then starting it again.
+    function initialize_app_database() {
+      # Wait a bit for SQL Server to start. SQL Server's process doesn't provide a clever way to check if it's up or not, and it needs to be up before we can import the application database
+      sleep 30s
+
+      echo "RUNNING BUDIBASE SETUP"
+
+      cat setup.sql
+      #run the setup script to create the DB and the schema in the DB
+      /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P Passw0rd -i setup.sql
+
+      # Note that the container has been initialized so future starts won't wipe changes to the data
+      touch /tmp/app-initialized
+    }
+    initialize_app_database &
+  fi
+fi
+
+exec "$@"

package/scripts/integrations/mssql/data/setup.sql

@@ -0,0 +1,80 @@
+USE master;
+
+IF NOT EXISTS(SELECT 1 FROM sys.schemas WHERE name = 'Chains')
+BEGIN
+    EXEC sys.sp_executesql N'CREATE SCHEMA Chains;'
+END
+
+IF OBJECT_ID ('dbo.products', 'U') IS NOT NULL  
+  DROP TABLE products;  
+GO  
+CREATE TABLE products 
+(  
+  id int IDENTITY(1,1),  
+  name varchar (20) NOT NULL,  
+  description varchar(30),
+  CONSTRAINT pk_products PRIMARY KEY NONCLUSTERED (id)
+);
+
+IF OBJECT_ID ('dbo.tasks', 'U') IS NOT NULL
+  DROP TABLE tasks;
+GO
+CREATE TABLE tasks
+(
+  taskid int IDENTITY(1,1),
+  taskname varchar (20) NOT NULL,
+  productid int,
+  CONSTRAINT pk_tasks PRIMARY KEY NONCLUSTERED (taskid),
+  CONSTRAINT fk_products FOREIGN KEY (productid) REFERENCES products (id),
+);
+
+IF OBJECT_ID ('dbo.people', 'U') IS NOT NULL
+  DROP TABLE people;
+GO
+CREATE TABLE people
+(
+  name varchar(30) NOT NULL,
+  age int default 20 NOT NULL,
+  CONSTRAINT pk_people PRIMARY KEY NONCLUSTERED (name, age)
+);
+  
+INSERT products
+  (name, description)  
+VALUES  
+  ('Bananas', 'Fruit thing'),
+  ('Meat', 'Animal thing');
+  
+INSERT tasks
+  (taskname, productid)
+VALUES
+  ('Processing', 1);
+
+INSERT INTO people (name, age)
+VALUES ('Bob', 30),
+  ('Bert', 10),
+  ('Jack', 12),
+  ('Mike', 31),
+  ('Dave', 44),
+  ('Jim', 43),
+  ('Kerry', 32),
+  ('Julie', 12),
+  ('Kim', 55),
+  ('Andy', 33),
+  ('John', 22),
+  ('Ruth', 66),
+  ('Robert', 88),
+  ('Bobert', 99),
+  ('Jan', 22),
+  ('Megan', 11);
+
+
+IF OBJECT_ID ('Chains.sizes', 'U') IS NOT NULL
+  DROP TABLE Chains.sizes;
+GO
+CREATE TABLE Chains.sizes
+(
+  sizeid int IDENTITY(1, 1),
+  name varchar(30),
+  CONSTRAINT pk_size PRIMARY KEY NONCLUSTERED (sizeid)
+);
+

package/scripts/integrations/mssql/docker-compose.yaml

@@ -0,0 +1,12 @@
+version: "3.8"
+services:
+  # password: Passw0rd
+  # user: sa
+  # database: master
+  mssql:
+    image: bb/mssql
+    build:
+      context: .
+      dockerfile: data/Dockerfile
+    ports:
+      - "1433:1433"

package/scripts/integrations/mssql/reset.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+docker-compose down
+docker volume prune -f

package/scripts/integrations/mysql/docker-compose.yaml

@@ -0,0 +1,21 @@
+# Use root/example as user/password credentials
+version: '3.1'
+
+services:
+
+  db:
+    image: mysql
+    restart: always
+    command: --init-file /data/application/init.sql --default-authentication-plugin=mysql_native_password
+    volumes:
+      - ./init.sql:/data/application/init.sql
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+    ports:
+      - 3306:3306
+
+  adminer:
+    image: adminer
+    restart: always
+    ports:
+      - 8080:8080

package/scripts/integrations/mysql/init.sql

@@ -0,0 +1,32 @@
+CREATE DATABASE IF NOT EXISTS main;
+USE main;
+CREATE TABLE Persons (
+    PersonID int NOT NULL AUTO_INCREMENT,
+    CreatedAt datetime,
+    Age float DEFAULT 20 NOT NULL,
+    LastName varchar(255),
+    FirstName varchar(255),
+    Address varchar(255),
+    City varchar(255),
+    PRIMARY KEY (PersonID)
+);
+CREATE TABLE Tasks (
+    TaskID int NOT NULL AUTO_INCREMENT,
+    PersonID INT,
+    TaskName varchar(255),
+    CreatedAt DATE,
+    PRIMARY KEY (TaskID),
+    CONSTRAINT fkPersons
+        FOREIGN KEY(PersonID)
+	    REFERENCES Persons(PersonID)
+);
+CREATE TABLE Products (
+    id serial primary key,
+    name text,
+    updated time
+);
+INSERT INTO Persons (FirstName, LastName, Age, Address, City, CreatedAt) VALUES ('Mike', 'Hughes', 28.2, '123 Fake Street', 'Belfast', '2021-01-19 03:14:07');
+INSERT INTO Persons (FirstName, LastName, Age, Address, City, CreatedAt) VALUES ('Dave', 'Johnson', 29, '124 Fake Street', 'Belfast', '2022-04-01 00:11:11');
+INSERT INTO Tasks (PersonID, TaskName, CreatedAt) VALUES (1, 'assembling', '2020-01-01');
+INSERT INTO Tasks (PersonID, TaskName, CreatedAt) VALUES (2, 'processing', '2019-12-31');
+INSERT INTO Products (name, updated) VALUES ('Meat', '11:00:22'), ('Fruit', '10:00:00');

package/scripts/integrations/mysql/reset.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+docker-compose down
+docker volume prune -f

package/scripts/integrations/oracle/docker-compose.yml

@@ -0,0 +1,19 @@
+# For more information see:
+# https://container-registry.oracle.com/
+# - Database > Express
+version: "3.8"
+services:
+  db:
+    restart: unless-stopped
+    platform: linux/x86_64
+    image: container-registry.oracle.com/database/express:18.4.0-xe
+    environment:
+      ORACLE_PWD: oracle
+    ports:
+      - 1521:1521
+      - 5500:5500
+    volumes:
+      - oracle_data:/opt/oracle/oradata
+
+volumes:
+ oracle_data: