@flowfuse/file-server 1.14.0

package/forge/routes/files.js

@@ -0,0 +1,130 @@
+/**
+ * File Storage API
+ *
+ * @namespace files
+ * @memberof forge.fileserver
+ */
+
+/** @typedef {import('fastify')} Fastify */
+/** @typedef {import('fastify').FastifyReply} FastifyReply */
+/** @typedef {import('fastify').FastifyRequest} FastifyRequest */
+
+module.exports = async function (app, opts, done) {
+    app.addContentTypeParser('application/octet-stream', { parseAs: 'buffer' }, function (request, payload, done) {
+        done(null, payload)
+    })
+
+    /**
+     * Create/Update a File
+     *
+     * @name /v1/files/:teamId/:projectId/*
+     * @static
+     * @memberof forge.fileserver.files
+     */
+    app.post('/:teamId/:projectId/*', {
+
+    }, async (request, reply) => {
+        const path = request.params['*']
+        let quota = -1
+        if (request.quota?.file) {
+            quota = request.quota.file
+        } else if (app.config.driver.quota) {
+            quota = app.config.driver.quota
+        }
+        let currentSize = -1
+        if (quota !== -1) {
+            currentSize = await request.vfs.quota()
+        }
+        try {
+            if (request.headers.ff_mode === 'append') {
+                if (currentSize !== -1) {
+                    const newSize = currentSize + request.body.length
+                    if (newSize < quota) {
+                        await request.vfs.append(path, request.body)
+                    } else {
+                        reply.code(413).send({ code: 'over_quota', error: 'Over Quota', limit: quota })
+                        return
+                    }
+                } else {
+                    await request.vfs.append(path, request.body)
+                }
+            } else if (request.headers.ff_mode === 'ensureDir') {
+                await request.vfs.ensureDir(path, request.body)
+            } else {
+                // should really check if file exists first and compute the delta
+                if (currentSize !== -1) {
+                    const newSize = currentSize + request.body.length
+                    if (newSize < quota) {
+                        await request.vfs.save(path, request.body)
+                    } else {
+                        reply.code(413).send({ code: 'over_quota', error: 'Over Quota', limit: quota })
+                        return
+                    }
+                } else {
+                    await request.vfs.save(path, request.body)
+                }
+            }
+            reply.code(200).send()
+        } catch (err) {
+            console.log(err)
+            reply.code(400).send(err)
+        }
+    })
+
+    // /**
+    //  * Stat a file
+    //  *
+    //  * @name /v1/files/:teamId/:projectId/*
+    //  * @static
+    //  * @memberof forge.fileserver.files
+    //  */
+    //  app.head('/:teamId/:projectId/*', async (request, reply) => {
+
+    //  })
+
+    /**
+     * Retrieve a file
+     *
+     * @name /v1/files/:teamId/:projectId/*
+     * @static
+     * @memberof forge.fileserver.files
+     */
+    app.get('/:teamId/:projectId/*', async (/** @type {FastifyRequest} */ request, /** @type {FastifyReply} */ reply) => {
+        const path = request.params['*']
+        try {
+            const file = await request.vfs.read(path)
+            if (file) {
+                reply.send(file)
+            } else {
+                reply.code(404).send()
+            }
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                reply.code(404).send(err)
+            } else if (err.code === 'ENOTDIR') {
+                reply.code(400).send(err)
+            } else {
+                reply.code(500).send(err)
+            }
+        }
+    })
+
+    /**
+     * Delete a file
+     *
+     * @name /v1/files/:teamId/:projectId/*
+     * @static
+     * @memberof forge.fileserver.files
+     */
+    app.delete('/:teamId/:projectId/*', async (request, reply) => {
+        const path = request.params['*']
+        try {
+            await request.vfs.delete(path)
+            reply.code(200).send()
+        } catch (err) {
+            reply.code(err.statusCode || 400).send(err)
+        }
+    })
+
+    done()
+}

package/forge/routes/index.js

@@ -0,0 +1,18 @@
+const fp = require('fastify-plugin')
+
+module.exports = fp(async function (app, opts, done) {
+    app.addHook('preHandler', app.checkAuth)
+    await app.register(require('./files'), { prefix: '/v1/files', logLevel: app.config.logging.http })
+    await app.register(require('./quota'), { prefix: '/v1/quota', logLevel: app.config.logging.http })
+    if (app.config.context?.type) {
+        await app.register(require('./context'), { prefix: '/v1/context', logLevel: app.config.logging.http })
+    }
+    app.decorate('getPaginationOptions', (request, defaults) => {
+        const result = { ...defaults, ...request.query }
+        if (result.query) {
+            result.query = result.query.trim()
+        }
+        return result
+    })
+    done()
+})

package/forge/routes/quota.js

@@ -0,0 +1,9 @@
+module.exports = async function (app, opts, done) {
+    app.get('/:teamId/:projectId', async (request, reply) => {
+        reply.send({
+            used: await request.vfs.quota(request.params.teamId, request.params.projectId)
+        })
+    })
+
+    done()
+}

package/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+'use strict'
+
+const semver = require('semver')
+const flowForgeFileServer = require('./forge/fileServer')
+const YAML = require('yaml')
+
+const app = (async function () {
+    if (!semver.satisfies(process.version, '>=16.0.0')) {
+        console.error(`FlowForge File Server requires at least NodeJS v16, ${process.version} found`)
+        process.exit(1)
+    }
+
+    try {
+        const options = {}
+        // The tests for `nr-persistent-context` run a local copy of the file-server
+        // and pass in the full config via this env var
+        if (process.env.FF_FS_TEST_CONFIG) {
+            try {
+                options.config = YAML.parse(process.env.FF_FS_TEST_CONFIG)
+            } catch (err) {
+                console.error('Failed to parse FF_FS_TEST_CONFIG:', err)
+                process.exitCode = 1
+                return
+            }
+        }
+
+        const server = await flowForgeFileServer(options)
+        let stopping = false
+        async function exitWhenStopped () {
+            if (!stopping) {
+                stopping = true
+                server.log.info('Stopping FlowForge File Server')
+                await server.close()
+                server.log.info('FlowForge File Server stopped')
+                process.exit(0)
+            }
+        }
+
+        process.on('SIGINT', exitWhenStopped)
+        process.on('SIGTERM', exitWhenStopped)
+        process.on('SIGHUP', exitWhenStopped)
+        process.on('SIGUSR2', exitWhenStopped) // for nodemon restart
+        process.on('SIGBREAK', exitWhenStopped)
+        process.on('message', function (m) { // for PM2 under window with --shutdown-with-message
+            if (m === 'shutdown') { exitWhenStopped() }
+        })
+
+        // Start the server
+        server.listen({ port: server.config.port, host: server.config.host }, function (err, address) {
+            if (err) {
+                console.error(err)
+                process.exit(1)
+            }
+        })
+        return server
+    } catch (err) {
+        console.error(err)
+        process.exitCode = 1
+    }
+})()
+
+module.exports = app

package/package.json

@@ -0,0 +1,63 @@
+{
+    "name": "@flowfuse/file-server",
+    "version": "1.14.0",
+    "description": "A basic Object Storage backend",
+    "main": "index.js",
+    "scripts": {
+        "start": "node index.js",
+        "serve": "cross-env NODE_ENV=development nodemon -w forge index.js",
+        "lint": "eslint -c .eslintrc \"forge/**/*.js\" \"test/**/*.js\" index.js",
+        "lint:fix": "eslint -c .eslintrc \"forge/**/*.js\" \"test/**/*.js\" index.js --fix",
+        "test": "mocha test/unit/**/*_spec.js --timeout 5000",
+        "test:nopg": "cross-env TEST_POSTGRES=false mocha test/unit/**/*_spec.js --timeout 5000"
+    },
+    "bin": {
+        "ff-file-storage": "./index.js"
+    },
+    "keywords": [
+        "flowfuse",
+        "object-store"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/FlowFuse/file-server.git"
+    },
+    "author": {
+        "name": "FlowFuse Inc."
+    },
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/FlowFuse/file-server/issues"
+    },
+    "homepage": "https://github.com/FlowFuse/file-server#readme",
+    "dependencies": {
+        "@aws-sdk/client-s3": "^3.388.0",
+        "@fastify/helmet": "^11.0.0",
+        "@node-red/util": "^3.1.0",
+        "fastify": "^4.21.0",
+        "fastify-metrics": "^10.3.0",
+        "fastify-plugin": "^4.5.1",
+        "got": "^11.8.6",
+        "pg": "^8.11.2",
+        "pino": "^8.15.1",
+        "pino-pretty": "^10.2.0",
+        "semver": "^7.5.4",
+        "sequelize": "^6.33.0",
+        "sqlite3": "^5.1.6",
+        "yaml": "^2.1.3"
+    },
+    "devDependencies": {
+        "cross-env": "^7.0.3",
+        "eslint": "^8.47.0",
+        "eslint-config-standard": "^17.1.0",
+        "eslint-plugin-no-only-tests": "^3.1.0",
+        "eslint-plugin-promise": "^6.1.1",
+        "mocha": "^10.1.0",
+        "mocha-cli": "^1.0.1",
+        "nodemon": "^3.0.1",
+        "should": "^13.2.3"
+    },
+    "engines": {
+        "node": ">=16.x"
+    }
+}