@sasjs/api 0.0.0-stage → 0.2.0

package/build/cjs/corpus/drive.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIVE_CORPUS = void 0;
+const success = { status: 'success' };
+/**
+ * Bytes without an encoding API: the package builds with `lib: ES2020` and no
+ * ambient types, so a `TextEncoder` reference would compile here and fail in a
+ * host that does not have one. An explicit byte array is both.
+ */
+const bytes = (...values) => Uint8Array.from(values);
+exports.DRIVE_CORPUS = [
+    {
+        id: 'create-file',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'creates a file the drive did not have',
+        request: {
+            query: { _filePath: '/data/users.csv' },
+            file: { name: 'users.csv', contents: 'id,name\n1,Ann\n' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-file-at-form-path',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'takes the destination from the form field when the query has none',
+        request: {
+            file: { name: 'x.csv', contents: 'x' },
+            body: { filePath: '/data/from-form.csv' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-file-over-existing',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a create over a file that exists, as 409',
+        seed: { '/data/exists.csv': 'a' },
+        request: {
+            query: { _filePath: '/data/exists.csv' },
+            file: { name: 'x', contents: 'b' }
+        },
+        expect: { status: 409, error: 'File already exists.' }
+    },
+    {
+        id: 'create-file-blocked-extension',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a refused extension before touching the drive',
+        request: {
+            query: { _filePath: '/data/run.sh' },
+            file: { name: 'run.sh', contents: 'x' }
+        },
+        expect: { status: 400, error: 'Invalid file extension' }
+    },
+    {
+        id: 'create-file-outside-drive',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a path that climbs out of the drive',
+        request: {
+            query: { _filePath: '/../escape.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 400, error: "Can't put file outside drive." }
+    },
+    {
+        id: 'create-file-without-payload',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'answers for a missing file with the server wording',
+        request: { query: { _filePath: '/data/x.csv' } },
+        expect: { status: 400, error: '"file" is not present.' }
+    },
+    {
+        id: 'create-file-without-destination',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'answers for a missing destination with the validation wording',
+        request: { file: { name: 'x', contents: 'x' } },
+        expect: { status: 400, error: '"_filePath" is required' }
+    },
+    {
+        id: 'replace-file',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'replaces the contents of a file that exists',
+        seed: { '/data/keep.csv': 'old' },
+        request: {
+            query: { _filePath: '/data/keep.csv' },
+            file: { name: 'keep.csv', contents: 'new' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'replace-file-missing',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'refuses a replace of a file that is not there, as 404',
+        request: {
+            query: { _filePath: '/data/missing.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'replace-file-outside-drive',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'refuses a replace of a path that climbs out of the drive',
+        request: {
+            query: { _filePath: '/../escape.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 400, error: "Can't modify file outside drive." }
+    },
+    {
+        id: 'read-file',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'answers with the file contents',
+        seed: { '/data/keep.csv': 'a,b\n1,2\n' },
+        request: { query: { _filePath: '/data/keep.csv' } },
+        expect: { status: 200, contents: 'a,b\n1,2\n' }
+    },
+    {
+        id: 'read-file-missing',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'refuses a read of a file that is not there',
+        request: { query: { _filePath: '/data/missing.csv' } },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'read-file-outside-drive',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'refuses a read of a path that climbs out of the drive',
+        request: { query: { _filePath: '/../escape.csv' } },
+        expect: { status: 400, error: "Can't get file outside drive." }
+    },
+    {
+        id: 'delete-file',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'deletes a file that exists',
+        seed: { '/data/keep.csv': 'a' },
+        request: { query: { _filePath: '/data/keep.csv' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'delete-file-missing',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'refuses a delete of a file that is not there',
+        request: { query: { _filePath: '/data/missing.csv' } },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'delete-file-outside-drive',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'refuses a delete of a path that climbs out of the drive',
+        request: { query: { _filePath: '/../escape.csv' } },
+        expect: { status: 400, error: "Can't delete file outside drive." }
+    },
+    {
+        id: 'list-folder',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'lists the files and folders of a folder',
+        seed: { '/data/a.csv': 'a', '/data/reports/b.csv': 'b' },
+        request: { query: { _folderPath: '/data' } },
+        expect: { status: 200, body: { files: ['a.csv'], folders: ['reports'] } }
+    },
+    {
+        id: 'list-folder-missing',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'refuses a listing of a folder that is not there',
+        request: { query: { _folderPath: '/nope' } },
+        expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+        id: 'list-folder-outside-drive',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'refuses a listing of a path that climbs out of the drive',
+        request: { query: { _folderPath: '/../escape' } },
+        expect: { status: 400, error: "Can't get folder outside drive." }
+    },
+    {
+        id: 'delete-folder-without-path',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'answers for a missing folder path, because the table marks it required',
+        request: {},
+        expect: { status: 400, error: '"_folderPath" is required' }
+    },
+    {
+        id: 'create-folder-without-path',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'answers for a missing folder path in the body',
+        request: { body: {} },
+        expect: { status: 400, error: '"folderPath" is required' }
+    },
+    {
+        id: 'create-folder',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'creates a folder',
+        request: { body: { folderPath: '/data/reports' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-folder-existing',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'refuses a folder that already exists, as 409',
+        seed: { '/data/reports/a.csv': 'a' },
+        request: { body: { folderPath: '/data/reports' } },
+        expect: { status: 409, error: 'Folder already exists.' }
+    },
+    {
+        id: 'delete-folder',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'deletes a folder with everything under it',
+        seed: { '/data/reports/a.csv': 'a', '/data/reports/nested/b.csv': 'b' },
+        request: { query: { _folderPath: '/data/reports' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'delete-folder-missing',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'refuses a delete of a folder that is not there',
+        request: { query: { _folderPath: '/nope' } },
+        expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+        id: 'rename-file',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'moves a file to a new path',
+        seed: { '/data/old.csv': 'r' },
+        request: { body: { oldPath: '/data/old.csv', newPath: '/data/new.csv' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'rename-onto-existing',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a move onto something that exists',
+        seed: { '/data/a.csv': 'a', '/data/b.csv': 'b' },
+        request: { body: { oldPath: '/data/a.csv', newPath: '/data/b.csv' } },
+        expect: { status: 409, error: 'File with new name already exists.' }
+    },
+    {
+        id: 'rename-missing',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a move of something that is not there',
+        request: { body: { oldPath: '/data/nope.csv', newPath: '/data/x.csv' } },
+        expect: { status: 404, error: 'No file/folder found for provided path.' }
+    },
+    {
+        id: 'rename-folder-into-itself',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a folder moved inside itself, which the server loses at the filesystem',
+        seed: { '/data/reports/a.csv': 'a' },
+        request: {
+            body: { oldPath: '/data/reports', newPath: '/data/reports/nested' }
+        },
+        expect: {
+            status: 400,
+            error: "New path can't be inside the folder being moved."
+        }
+    },
+    {
+        id: 'tree',
+        route: 'GET /SASjsApi/drive/filetree',
+        description: 'answers with the drive tree',
+        seed: { '/data/a.csv': 'a' },
+        request: { query: { _folderPath: '/data' } },
+        expect: {
+            status: 200,
+            body: {
+                status: 'success',
+                tree: {
+                    name: 'data',
+                    relativePath: '/data',
+                    isFolder: true,
+                    children: [
+                        {
+                            name: 'a.csv',
+                            relativePath: '/data/a.csv',
+                            isFolder: false,
+                            children: []
+                        }
+                    ]
+                }
+            }
+        }
+    },
+    {
+        id: 'bytes-round-trip',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'keeps a byte file as bytes',
+        seed: { '/data/pack.zip': bytes(80, 75, 3, 4) },
+        request: { query: { _filePath: '/data/pack.zip' } },
+        expect: { status: 200, contents: bytes(80, 75, 3, 4) }
+    }
+];

package/build/cjs/corpus/runner.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCase = exports.servicesFor = void 0;
+const dispatch_js_1 = require("../host/dispatch.js");
+const service_js_1 = require("../drive/service.js");
+const memory_store_js_1 = require("../drive/memory-store.js");
+const types_js_1 = require("../types.js");
+/** Services over a fresh store, seeded with the case's files. */
+const servicesFor = (testCase) => ({
+    drive: (0, service_js_1.createDriveService)(new memory_store_js_1.MemoryDriveStore(testCase.seed || {}))
+});
+exports.servicesFor = servicesFor;
+/**
+ * Runs a corpus case against the drive the case seeds itself, or against
+ * services a caller supplies - that is how a host (or a failing store) is put
+ * behind the same cases.
+ */
+const runCase = async (testCase, services = (0, exports.servicesFor)(testCase)) => {
+    try {
+        const response = await (0, dispatch_js_1.dispatch)(services, testCase.route, testCase.request);
+        return {
+            status: response.status,
+            body: response.body,
+            contents: response.contents
+        };
+    }
+    catch (error) {
+        // only a refusal the API decided on becomes a status; anything else is a
+        // broken host, and reporting it as a 500 would hide it from the suite
+        if ((0, types_js_1.isApiError)(error))
+            return { status: error.status, error: error.message };
+        throw error;
+    }
+};
+exports.runCase = runCase;

package/build/cjs/drive/memory-store.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDriveStore = void 0;
+const types_js_1 = require("../types.js");
+const paths_js_1 = require("./paths.js");
+class MemoryDriveStore {
+    constructor(seed = {}) {
+        this.files = new Map();
+        this.folders = new Set(['/']);
+        for (const [path, contents] of Object.entries(seed)) {
+            this.putSync(path, contents);
+        }
+    }
+    /** Everything on the drive, for a snapshot or an assertion. */
+    dump() {
+        const out = {};
+        for (const [path, contents] of this.files)
+            out[path] = contents;
+        return out;
+    }
+    putSync(path, contents) {
+        this.mkdirpSync((0, paths_js_1.dirname)(path));
+        this.files.set(path, typeof contents === 'string' ? contents : contents.slice());
+    }
+    mkdirpSync(path) {
+        const parts = path.split('/').filter(Boolean);
+        let acc = '';
+        for (const part of parts) {
+            acc += '/' + part;
+            this.folders.add(acc);
+        }
+    }
+    children(path) {
+        const prefix = path === '/' ? '/' : path + '/';
+        const files = [];
+        const folders = [];
+        for (const candidate of this.files.keys()) {
+            if (!candidate.startsWith(prefix))
+                continue;
+            const rest = candidate.slice(prefix.length);
+            if (rest && !rest.includes('/'))
+                files.push(rest);
+        }
+        for (const candidate of this.folders) {
+            if (!candidate.startsWith(prefix))
+                continue;
+            const rest = candidate.slice(prefix.length);
+            if (rest && !rest.includes('/'))
+                folders.push(rest);
+        }
+        return { files: files.sort(), folders: folders.sort() };
+    }
+    async read(path) {
+        const contents = this.files.get(path);
+        if (contents === undefined)
+            throw new types_js_1.ApiError(404, `File doesn't exist.`);
+        return contents;
+    }
+    async write(path, contents) {
+        this.putSync(path, contents);
+    }
+    async exists(path) {
+        return this.files.has(path) || this.folders.has(path);
+    }
+    async stat(path) {
+        if (this.folders.has(path) && !this.files.has(path))
+            return { directory: true, size: 0 };
+        const contents = this.files.get(path);
+        if (contents === undefined)
+            throw new types_js_1.ApiError(404, `File doesn't exist.`);
+        return {
+            directory: false,
+            size: typeof contents === 'string' ? contents.length : contents.length
+        };
+    }
+    async list(path) {
+        return this.children(path);
+    }
+    async mkdirp(path) {
+        this.mkdirpSync(path);
+    }
+    async remove(path) {
+        if (this.files.delete(path))
+            return;
+        const prefix = path === '/' ? '/' : path + '/';
+        for (const candidate of [...this.files.keys()]) {
+            if (candidate.startsWith(prefix))
+                this.files.delete(candidate);
+        }
+        for (const candidate of [...this.folders]) {
+            if (candidate === path || candidate.startsWith(prefix))
+                this.folders.delete(candidate);
+        }
+    }
+    async move(from, to) {
+        const contents = this.files.get(from);
+        if (contents !== undefined) {
+            const copy = typeof contents === 'string' ? contents : contents.slice();
+            this.files.delete(from);
+            this.mkdirpSync((0, paths_js_1.dirname)(to));
+            this.files.set(to, copy);
+            return;
+        }
+        // a folder: every entry under it moves by prefix, then the folder records
+        const prefix = from + '/';
+        const moves = [];
+        for (const [candidate, value] of this.files) {
+            if (candidate.startsWith(prefix))
+                moves.push([candidate, to + candidate.slice(from.length), value]);
+        }
+        for (const [source] of moves)
+            this.files.delete(source);
+        for (const [, destination, value] of moves) {
+            this.mkdirpSync((0, paths_js_1.dirname)(destination));
+            this.files.set(destination, value);
+        }
+        for (const candidate of [...this.folders]) {
+            if (candidate === from || candidate.startsWith(prefix)) {
+                this.folders.delete(candidate);
+                this.folders.add(to + candidate.slice(from.length));
+            }
+        }
+        this.mkdirpSync(to);
+    }
+}
+exports.MemoryDriveStore = MemoryDriveStore;

package/build/cjs/drive/paths.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Drive path rules, in one place.
+ *
+ * These are the server's rules, not an invention of this package:
+ * `resolveWithinDrive` in sasjs/server resolves a caller-supplied path against
+ * the drive root and refuses anything that leaves it, and `filePathSchema`
+ * refuses a handful of extensions before a path reaches the drive at all.
+ * Because both hosts now import this file, the rule can only be changed in one
+ * place - which is the point of the package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFilePath = exports.isRoot = exports.basename = exports.dirname = exports.normaliseDrivePath = exports.hasBlockedExtension = void 0;
+/**
+ * Extensions a drive request may not name, on any route (the server's
+ * `blockFileRegex`). Nothing is executable on a browser host, but a client that
+ * would be refused by a server should hear the same answer from the mock.
+ */
+const BLOCKED_EXTENSION = /\.(exe|sh|htaccess)$/i;
+/** True when the last segment of the path carries a refused extension. */
+const hasBlockedExtension = (path) => BLOCKED_EXTENSION.test(path);
+exports.hasBlockedExtension = hasBlockedExtension;
+/**
+ * A caller-supplied path as a drive-relative path, or `null` when it would land
+ * outside the drive.
+ *
+ * The rules, each of which a test pins:
+ *
+ *   - a leading slash means "under the drive root", never filesystem-absolute -
+ *     so `/Public/app/x` and `Public/app/x` are the same destination;
+ *   - a backslash is a separator, because a Windows client sends them;
+ *   - `.` is ignored and `..` pops a segment, so traversal is resolved rather
+ *     than string-matched;
+ *   - a `..` that would pop past the root returns null instead of clamping,
+ *     because a path that escapes is refused, not rewritten;
+ *   - a name that merely starts with dots (`..foo`) is a name, not a traversal.
+ *
+ * The return value starts with '/' (the root is '/'), has no trailing slash.
+ */
+const normaliseDrivePath = (input) => {
+    const given = typeof input === 'string' ? input : '';
+    const segments = [];
+    for (const segment of given.replace(/\\/g, '/').split('/')) {
+        if (!segment || segment === '.')
+            continue;
+        if (segment === '..') {
+            if (!segments.length)
+                return null;
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return '/' + segments.join('/');
+};
+exports.normaliseDrivePath = normaliseDrivePath;
+/** The folder a file path sits in ('/' for a path at the root). */
+const dirname = (path) => {
+    const cut = path.lastIndexOf('/');
+    return cut <= 0 ? '/' : path.slice(0, cut);
+};
+exports.dirname = dirname;
+/** The last segment of a path. */
+const basename = (path) => path.slice(path.lastIndexOf('/') + 1);
+exports.basename = basename;
+/** The drive root itself, which no write may name. */
+const isRoot = (path) => path === '/';
+exports.isRoot = isRoot;
+/**
+ * The path a file request names, with the blocked-extension rule applied.
+ * Returns the reason rather than a status, so the caller chooses the wording:
+ * a traversal and an extension are both 400s, with different messages.
+ */
+const checkFilePath = (input) => {
+    const path = (0, exports.normaliseDrivePath)(input);
+    if (path === null)
+        return { reason: 'outside' };
+    if ((0, exports.hasBlockedExtension)(path))
+        return { reason: 'extension' };
+    return { path };
+};
+exports.checkFilePath = checkFilePath;

package/build/cjs/drive/service.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDriveService = void 0;
+const types_js_1 = require("../types.js");
+const paths_js_1 = require("./paths.js");
+/** A path a file operation may act on, or the refusal the operation answers. */
+const filePath = (input, outside) => {
+    const checked = (0, paths_js_1.checkFilePath)(input);
+    if ('reason' in checked) {
+        throw checked.reason === 'extension'
+            ? new types_js_1.ApiError(400, 'Invalid file extension')
+            : new types_js_1.ApiError(400, outside);
+    }
+    if ((0, paths_js_1.isRoot)(checked.path))
+        throw new types_js_1.ApiError(400, outside);
+    return checked.path;
+};
+/** A folder path, which may be the drive root but never an extension check. */
+const folderPath = (input, outside) => {
+    const path = (0, paths_js_1.normaliseDrivePath)(input);
+    if (path === null)
+        throw new types_js_1.ApiError(400, outside);
+    return path;
+};
+const createDriveService = (store) => {
+    const treeOf = async (path) => {
+        const listing = await store.list(path);
+        const children = [];
+        for (const folder of listing.folders) {
+            children.push(await treeOf(path === '/' ? '/' + folder : path + '/' + folder));
+        }
+        for (const file of listing.files) {
+            children.push({
+                name: file,
+                relativePath: path === '/' ? '/' + file : path + '/' + file,
+                isFolder: false,
+                children: []
+            });
+        }
+        return {
+            name: path === '/' ? 'files' : (0, paths_js_1.basename)(path),
+            relativePath: path,
+            isFolder: true,
+            children
+        };
+    };
+    return {
+        async list(given) {
+            // an empty path is the root, which is what the server's GET /folder does
+            // with no `_folderPath`
+            const path = folderPath(given === undefined ? '' : given, "Can't get folder outside drive.");
+            if (!(await store.exists(path)))
+                throw new types_js_1.ApiError(404, `Folder doesn't exist.`);
+            const stat = await store.stat(path);
+            if (!stat.directory)
+                throw new types_js_1.ApiError(400, 'Not a Folder.');
+            const listing = await store.list(path);
+            return {
+                files: [...listing.files].sort(),
+                folders: [...listing.folders].sort()
+            };
+        },
+        async read(given) {
+            const path = filePath(given, "Can't get file outside drive.");
+            if (!(await store.exists(path)))
+                throw new types_js_1.ApiError(404, `File doesn't exist.`);
+            const contents = await store.read(path);
+            return { contents, binary: typeof contents !== 'string' };
+        },
+        async save(given, contents) {
+            const path = filePath(given, "Can't put file outside drive.");
+            if (await store.exists(path))
+                throw new types_js_1.ApiError(409, 'File already exists.');
+            await store.mkdirp((0, paths_js_1.dirname)(path));
+            await store.write(path, contents);
+            return { status: 'success' };
+        },
+        async update(given, contents) {
+            const path = filePath(given, "Can't modify file outside drive.");
+            if (!(await store.exists(path)))
+                throw new types_js_1.ApiError(404, `File doesn't exist.`);
+            await store.write(path, contents);
+            return { status: 'success' };
+        },
+        async remove(given) {
+            const path = filePath(given, "Can't delete file outside drive.");
+            if (!(await store.exists(path)))
+                throw new types_js_1.ApiError(404, `File doesn't exist.`);
+            await store.remove(path);
+            return { status: 'success' };
+        },
+        async mkdir(given) {
+            const path = folderPath(given, "Can't put folder outside drive.");
+            if ((0, paths_js_1.isRoot)(path))
+                throw new types_js_1.ApiError(400, "Can't put folder outside drive.");
+            if (await store.exists(path))
+                throw new types_js_1.ApiError(409, 'Folder already exists.');
+            await store.mkdirp(path);
+            return { status: 'success' };
+        },
+        async rmdir(given) {
+            const path = folderPath(given, "Can't delete folder outside drive.");
+            // the root is the whole drive: refused here as well as at validation,
+            // because a caller reaching this function directly has no validation
+            if ((0, paths_js_1.isRoot)(path))
+                throw new types_js_1.ApiError(400, "Can't delete folder outside drive.");
+            if (!(await store.exists(path)) || !(await store.stat(path)).directory)
+                throw new types_js_1.ApiError(404, `Folder doesn't exist.`);
+            await store.remove(path);
+            return { status: 'success' };
+        },
+        async rename(oldPath, newPath) {
+            const from = folderPath(oldPath, "Old path can't be outside of drive.");
+            const to = folderPath(newPath, "New path can't be outside of drive.");
+            if ((0, paths_js_1.isRoot)(from) || (0, paths_js_1.isRoot)(to))
+                throw new types_js_1.ApiError(400, "New path can't be outside of drive.");
+            if (await store.exists(from)) {
+                const stat = await store.stat(from);
+                // a folder moved inside itself would be an infinite copy, and the
+                // server loses this at the filesystem with an opaque error
+                if (stat.directory && (to === from || to.startsWith(from + '/')))
+                    throw new types_js_1.ApiError(400, "New path can't be inside the folder being moved.");
+                if (await store.exists(to))
+                    throw new types_js_1.ApiError(409, stat.directory
+                        ? 'Folder with new name already exists.'
+                        : 'File with new name already exists.');
+                await store.move(from, to);
+                return { status: 'success' };
+            }
+            throw new types_js_1.ApiError(404, 'No file/folder found for provided path.');
+        },
+        async tree(given) {
+            const path = folderPath(given === undefined ? '' : given, "Can't get folder outside drive.");
+            if (!(await store.exists(path)))
+                throw new types_js_1.ApiError(404, `Folder doesn't exist.`);
+            const stat = await store.stat(path);
+            if (!stat.directory)
+                throw new types_js_1.ApiError(400, 'Not a Folder.');
+            return { status: 'success', tree: await treeOf(path) };
+        }
+    };
+};
+exports.createDriveService = createDriveService;