@budibase/server 1.3.15-alpha.3 → 1.3.17

package/src/api/controllers/plugin/index.ts

@@ -1,206 +0,0 @@
-import { ObjectStoreBuckets } from "../../../constants"
-import { loadJSFile } from "../../../utilities/fileSystem"
-import { npmUpload, urlUpload, githubUpload, fileUpload } from "./uploaders"
-import { getGlobalDB } from "@budibase/backend-core/tenancy"
-import { validate } from "@budibase/backend-core/plugins"
-import { generatePluginID, getPluginParams } from "../../../db/utils"
-import {
-  uploadDirectory,
-  deleteFolder,
-} from "@budibase/backend-core/objectStore"
-import { PluginType, FileType, PluginSource } from "@budibase/types"
-import env from "../../../environment"
-import { ClientAppSocket } from "../../../websocket"
-
-export async function getPlugins(type?: PluginType) {
-  const db = getGlobalDB()
-  const response = await db.allDocs(
-    getPluginParams(null, {
-      include_docs: true,
-    })
-  )
-  const plugins = response.rows.map((row: any) => row.doc)
-  if (type) {
-    return plugins.filter((plugin: any) => plugin.schema?.type === type)
-  } else {
-    return plugins
-  }
-}
-
-export async function upload(ctx: any) {
-  const plugins: FileType[] =
-    ctx.request.files.file.length > 1
-      ? Array.from(ctx.request.files.file)
-      : [ctx.request.files.file]
-  try {
-    let docs = []
-    // can do single or multiple plugins
-    for (let plugin of plugins) {
-      const doc = await processPlugin(plugin, PluginSource.FILE)
-      docs.push(doc)
-    }
-    ctx.body = {
-      message: "Plugin(s) uploaded successfully",
-      plugins: docs,
-    }
-  } catch (err: any) {
-    const errMsg = err?.message ? err?.message : err
-
-    ctx.throw(400, `Failed to import plugin: ${errMsg}`)
-  }
-}
-
-export async function create(ctx: any) {
-  const { source, url, headers, githubToken } = ctx.request.body
-
-  if (!env.SELF_HOSTED) {
-    ctx.throw(400, "Plugins not supported outside of self-host.")
-  }
-
-  try {
-    let metadata
-    let directory
-    // Generating random name as a backup and needed for url
-    let name = "PLUGIN_" + Math.floor(100000 + Math.random() * 900000)
-
-    switch (source) {
-      case PluginSource.NPM:
-        const { metadata: metadataNpm, directory: directoryNpm } =
-          await npmUpload(url, name)
-        metadata = metadataNpm
-        directory = directoryNpm
-        break
-      case PluginSource.GITHUB:
-        const { metadata: metadataGithub, directory: directoryGithub } =
-          await githubUpload(url, name, githubToken)
-        metadata = metadataGithub
-        directory = directoryGithub
-        break
-      case PluginSource.URL:
-        const headersObj = headers || {}
-        const { metadata: metadataUrl, directory: directoryUrl } =
-          await urlUpload(url, name, headersObj)
-        metadata = metadataUrl
-        directory = directoryUrl
-        break
-    }
-
-    validate(metadata?.schema)
-
-    const doc = await storePlugin(metadata, directory, source)
-
-    ctx.body = {
-      message: "Plugin uploaded successfully",
-      plugins: [doc],
-    }
-  } catch (err: any) {
-    const errMsg = err?.message ? err?.message : err
-
-    ctx.throw(400, `Failed to import plugin: ${errMsg}`)
-  }
-  ctx.status = 200
-}
-
-export async function fetch(ctx: any) {
-  ctx.body = await getPlugins()
-}
-
-export async function destroy(ctx: any) {
-  const db = getGlobalDB()
-  const { pluginId } = ctx.params
-
-  try {
-    const plugin = await db.get(pluginId)
-    const bucketPath = `${plugin.name}/`
-    await deleteFolder(ObjectStoreBuckets.PLUGINS, bucketPath)
-
-    await db.remove(pluginId, plugin._rev)
-  } catch (err: any) {
-    const errMsg = err?.message ? err?.message : err
-
-    ctx.throw(400, `Failed to delete plugin: ${errMsg}`)
-  }
-
-  ctx.message = `Plugin ${ctx.params.pluginId} deleted.`
-  ctx.status = 200
-}
-
-export async function storePlugin(
-  metadata: any,
-  directory: any,
-  source?: string
-) {
-  const db = getGlobalDB()
-  const version = metadata.package.version,
-    name = metadata.package.name,
-    description = metadata.package.description,
-    hash = metadata.schema.hash
-
-  // first open the tarball into tmp directory
-  const bucketPath = `${name}/`
-  const files = await uploadDirectory(
-    ObjectStoreBuckets.PLUGINS,
-    directory,
-    bucketPath
-  )
-  const jsFile = files.find((file: any) => file.name.endsWith(".js"))
-  if (!jsFile) {
-    throw new Error(`Plugin missing .js file.`)
-  }
-  // validate the JS for a datasource
-  if (metadata.schema.type === PluginType.DATASOURCE) {
-    const js = loadJSFile(directory, jsFile.name)
-    // TODO: this isn't safe - but we need full node environment
-    // in future we should do this in a thread for safety
-    try {
-      eval(js)
-    } catch (err: any) {
-      const message = err?.message ? err.message : JSON.stringify(err)
-      throw new Error(`JS invalid: ${message}`)
-    }
-  }
-  const jsFileName = jsFile.name
-  const pluginId = generatePluginID(name)
-
-  // overwrite existing docs entirely if they exist
-  let rev
-  try {
-    const existing = await db.get(pluginId)
-    rev = existing._rev
-  } catch (err) {
-    rev = undefined
-  }
-  let doc = {
-    _id: pluginId,
-    _rev: rev,
-    ...metadata,
-    name,
-    version,
-    hash,
-    description,
-    jsUrl: `${bucketPath}${jsFileName}`,
-  }
-
-  if (source) {
-    doc = {
-      ...doc,
-      source,
-    }
-  }
-
-  const response = await db.put(doc)
-  ClientAppSocket.emit("plugin-update", { name, hash })
-  return {
-    ...doc,
-    _rev: response.rev,
-  }
-}
-
-export async function processPlugin(plugin: FileType, source?: string) {
-  if (!env.SELF_HOSTED) {
-    throw new Error("Plugins not supported outside of self-host.")
-  }
-
-  const { metadata, directory } = await fileUpload(plugin)
-  return await storePlugin(metadata, directory, source)
-}

package/src/api/controllers/plugin/npm.ts

@@ -1,56 +0,0 @@
-import {
-  getPluginMetadata,
-  findFileRec,
-  extractTarball,
-  deleteFolderFileSystem,
-} from "../../../utilities/fileSystem"
-import fetch from "node-fetch"
-import { join } from "path"
-import { downloadUnzipTarball } from "./utils"
-
-export async function npmUpload(url: string, name: string, headers = {}) {
-  let npmTarballUrl = url
-  let pluginName = name
-
-  if (
-    !npmTarballUrl.includes("https://www.npmjs.com") &&
-    !npmTarballUrl.includes("https://registry.npmjs.org")
-  ) {
-    throw new Error("The plugin origin must be from NPM")
-  }
-
-  if (!npmTarballUrl.includes(".tgz")) {
-    const npmPackageURl = url.replace(
-      "https://www.npmjs.com/package/",
-      "https://registry.npmjs.org/"
-    )
-    const response = await fetch(npmPackageURl)
-    if (response.status !== 200) {
-      throw new Error("NPM Package not found")
-    }
-
-    let npmDetails = await response.json()
-    pluginName = npmDetails.name
-    const npmVersion = npmDetails["dist-tags"].latest
-    npmTarballUrl = npmDetails?.versions?.[npmVersion]?.dist?.tarball
-
-    if (!npmTarballUrl) {
-      throw new Error("NPM tarball url not found")
-    }
-  }
-
-  const path = await downloadUnzipTarball(npmTarballUrl, pluginName, headers)
-  const tarballPluginFile = findFileRec(path, ".tar.gz")
-  if (!tarballPluginFile) {
-    throw new Error("Tarball plugin file not found")
-  }
-
-  try {
-    await extractTarball(tarballPluginFile, path)
-    deleteFolderFileSystem(join(path, "package"))
-  } catch (err: any) {
-    throw new Error(err)
-  }
-
-  return await getPluginMetadata(path)
-}

package/src/api/controllers/plugin/uploaders.ts

@@ -1,4 +0,0 @@
-export { fileUpload } from "./file"
-export { githubUpload } from "./github"
-export { npmUpload } from "./npm"
-export { urlUpload } from "./url"

package/src/api/controllers/plugin/url.ts

@@ -1,12 +0,0 @@
-import { downloadUnzipTarball } from "./utils"
-import { getPluginMetadata } from "../../../utilities/fileSystem"
-
-export async function urlUpload(url: string, name = "", headers = {}) {
-  if (!url.includes(".tar.gz")) {
-    throw new Error("Plugin must be compressed into a gzipped tarball.")
-  }
-
-  const path = await downloadUnzipTarball(url, name, headers)
-
-  return await getPluginMetadata(path)
-}

package/src/api/controllers/plugin/utils.ts

@@ -1,19 +0,0 @@
-import {
-  createTempFolder,
-  downloadTarballDirect,
-} from "../../../utilities/fileSystem"
-
-export async function downloadUnzipTarball(
-  url: string,
-  name: string,
-  headers = {}
-) {
-  try {
-    const path = createTempFolder(name)
-    await downloadTarballDirect(url, path, headers)
-
-    return path
-  } catch (e: any) {
-    throw new Error(e.message)
-  }
-}

package/src/api/routes/plugin.ts

@@ -1,14 +0,0 @@
-import Router from "@koa/router"
-import * as controller from "../controllers/plugin"
-import authorized from "../../middleware/authorized"
-import { BUILDER } from "@budibase/backend-core/permissions"
-
-const router = new Router()
-
-router
-  .post("/api/plugin/upload", authorized(BUILDER), controller.upload)
-  .post("/api/plugin", authorized(BUILDER), controller.create)
-  .get("/api/plugin", authorized(BUILDER), controller.fetch)
-  .delete("/api/plugin/:pluginId", authorized(BUILDER), controller.destroy)
-
-export default router

package/src/watch.ts

@@ -1,38 +0,0 @@
-import path from "path"
-import * as env from "./environment"
-import chokidar from "chokidar"
-import fs from "fs"
-import { tenancy } from "@budibase/backend-core"
-import { DEFAULT_TENANT_ID } from "@budibase/backend-core/constants"
-import { processPlugin } from "./api/controllers/plugin"
-
-export function watch() {
-  const watchPath = path.join(env.PLUGINS_DIR, "./**/*.tar.gz")
-  chokidar
-    .watch(watchPath, {
-      ignored: "**/node_modules",
-      awaitWriteFinish: {
-        pollInterval: 100,
-        stabilityThreshold: 250,
-      },
-      usePolling: true,
-      interval: 250,
-    })
-    .on("all", async (event: string, path: string) => {
-      // Sanity checks
-      if (!path?.endsWith(".tar.gz") || !fs.existsSync(path)) {
-        return
-      }
-      await tenancy.doInTenant(DEFAULT_TENANT_ID, async () => {
-        try {
-          const split = path.split("/")
-          const name = split[split.length - 1]
-          console.log("Importing plugin:", path)
-          await processPlugin({ name, path })
-        } catch (err: any) {
-          const message = err?.message ? err?.message : err
-          console.error("Failed to import plugin:", message)
-        }
-      })
-    })
-}

package/src/websocket.ts

@@ -1,26 +0,0 @@
-import { Server } from "socket.io"
-import http from "http"
-
-class Websocket {
-  socketServer: Server
-
-  constructor(server: http.Server, path: string) {
-    this.socketServer = new Server(server, {
-      path,
-    })
-  }
-
-  // Emit an event to all sockets
-  emit(event: string, payload: any) {
-    this.socketServer.sockets.emit(event, payload)
-  }
-}
-
-// Likely to be more socket instances in future
-let ClientAppSocket: Websocket
-
-export const initialise = (server: http.Server) => {
-  ClientAppSocket = new Websocket(server, "/socket/client")
-}
-
-export { ClientAppSocket }