@zenfs/core 0.0.1

package/dist/emulation/promises.js

@@ -0,0 +1,521 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ApiError, ErrorCode } from '../ApiError';
+import * as constants from './constants';
+export { constants };
+import { FileFlag } from '../file';
+import { normalizePath, normalizeMode, getFdForFile, normalizeOptions, fd2file, fdMap, normalizeTime, cred, nop, resolveFS, fixError, mounts } from './shared';
+/**
+ * Utility for FS ops. It handles
+ * - path normalization (for the first parameter to the FS op)
+ * - path translation for errors
+ * - FS/mount point resolution
+ *
+ * It can't be used for functions which may operate on multiple mounted FSs or paths (e.g. `rename`)
+ * @param name the function name
+ * @param resolveSymlinks whether to resolve symlinks
+ * @param args the rest of the parameters are passed to the FS function. Note that the first parameter is required to be a path
+ * @returns
+ */
+function doOp(...[name, resolveSymlinks, path, ...args]) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = normalizePath(path);
+        const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && (yield exists(path)) ? yield realpath(path) : path);
+        try {
+            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
+            return fs[name](resolvedPath, ...args);
+        }
+        catch (e) {
+            throw fixError(e, { [resolvedPath]: path });
+        }
+    });
+}
+// fs.promises
+/**
+ * Renames a file
+ * @param oldPath
+ * @param newPath
+ */
+export function rename(oldPath, newPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        oldPath = normalizePath(oldPath);
+        newPath = normalizePath(newPath);
+        const _old = resolveFS(oldPath);
+        const _new = resolveFS(newPath);
+        const paths = { [_old.path]: oldPath, [_new.path]: newPath };
+        try {
+            if (_old === _new) {
+                return _old.fs.rename(_old.path, _new.path, cred);
+            }
+            const data = yield readFile(oldPath);
+            yield writeFile(newPath, data);
+            yield unlink(oldPath);
+        }
+        catch (e) {
+            throw fixError(e, paths);
+        }
+    });
+}
+/**
+ * Test whether or not the given path exists by checking with the file system.
+ * @param path
+ */
+export function exists(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = normalizePath(path);
+        try {
+            const { fs, path: resolvedPath } = resolveFS(path);
+            return fs.exists(resolvedPath, cred);
+        }
+        catch (e) {
+            if (e.errno == ErrorCode.ENOENT) {
+                return false;
+            }
+            throw e;
+        }
+    });
+}
+/**
+ * `stat`.
+ * @param path
+ * @returns Stats
+ */
+export function stat(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('stat', true, path, cred);
+    });
+}
+/**
+ * `lstat`.
+ * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
+ * then the link itself is stat-ed, not the file that it refers to.
+ * @param path
+ * @return [ZenFS.node.fs.Stats]
+ */
+export function lstat(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('stat', false, path, cred);
+    });
+}
+// FILE-ONLY METHODS
+/**
+ * `truncate`.
+ * @param path
+ * @param len
+ */
+export function truncate(path, len = 0) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (len < 0) {
+            throw new ApiError(ErrorCode.EINVAL);
+        }
+        return doOp('truncate', true, path, len, cred);
+    });
+}
+/**
+ * `unlink`.
+ * @param path
+ */
+export function unlink(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('unlink', false, path, cred);
+    });
+}
+/**
+ * file open.
+ * @see http://www.manpagez.com/man/2/open/
+ * @param path
+ * @param flags
+ * @param mode defaults to `0644`
+ */
+export function open(path, flag, mode = 0o644) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = yield doOp('open', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
+        return getFdForFile(file);
+    });
+}
+export function readFile(filename, arg2 = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = normalizeOptions(arg2, null, 'r', null);
+        const flag = FileFlag.getFileFlag(options.flag);
+        if (!flag.isReadable()) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
+        }
+        return doOp('readFile', true, filename, options.encoding, flag, cred);
+    });
+}
+export function writeFile(filename, data, arg3) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = normalizeOptions(arg3, 'utf8', 'w', 0o644);
+        const flag = FileFlag.getFileFlag(options.flag);
+        if (!flag.isWriteable()) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
+        }
+        return doOp('writeFile', true, filename, data, options.encoding, flag, options.mode, cred);
+    });
+}
+export function appendFile(filename, data, arg3) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
+        const flag = FileFlag.getFileFlag(options.flag);
+        if (!flag.isAppendable()) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        }
+        return doOp('appendFile', true, filename, data, options.encoding, flag, options.mode, cred);
+    });
+}
+// FILE DESCRIPTOR METHODS
+/**
+ * `fstat`.
+ * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
+ * specified by the file descriptor `fd`.
+ * @param fd
+ * @return [ZenFS.node.fs.Stats]
+ */
+export function fstat(fd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fd2file(fd).stat();
+    });
+}
+/**
+ * close.
+ * @param fd
+ */
+export function close(fd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fd2file(fd).close();
+        fdMap.delete(fd);
+        return;
+    });
+}
+/**
+ * ftruncate.
+ * @param fd
+ * @param len
+ */
+export function ftruncate(fd, len = 0) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = fd2file(fd);
+        if (len < 0) {
+            throw new ApiError(ErrorCode.EINVAL);
+        }
+        return file.truncate(len);
+    });
+}
+/**
+ * fsync.
+ * @param fd
+ */
+export function fsync(fd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fd2file(fd).sync();
+    });
+}
+/**
+ * fdatasync.
+ * @param fd
+ */
+export function fdatasync(fd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fd2file(fd).datasync();
+    });
+}
+export function write(fd, arg2, arg3, arg4, arg5) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let buffer, offset = 0, length, position;
+        if (typeof arg2 === 'string') {
+            // Signature 1: (fd, string, [position?, [encoding?]])
+            position = typeof arg3 === 'number' ? arg3 : null;
+            const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
+            offset = 0;
+            buffer = Buffer.from(arg2, encoding);
+            length = buffer.length;
+        }
+        else {
+            // Signature 2: (fd, buffer, offset, length, position?)
+            buffer = arg2;
+            offset = arg3;
+            length = arg4;
+            position = typeof arg5 === 'number' ? arg5 : null;
+        }
+        const file = fd2file(fd);
+        if (position === undefined || position === null) {
+            position = file.getPos();
+        }
+        return file.write(buffer, offset, length, position);
+    });
+}
+/**
+ * Read data from the file specified by `fd`.
+ * @param fd
+ * @param buffer The buffer that the data will be
+ *   written to.
+ * @param offset The offset within the buffer where writing will
+ *   start.
+ * @param length An integer specifying the number of bytes to read.
+ * @param position An integer specifying where to begin reading from
+ *   in the file. If position is null, data will be read from the current file
+ *   position.
+ */
+export function read(fd, buffer, offset, length, position) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = fd2file(fd);
+        if (isNaN(+position)) {
+            position = file.getPos();
+        }
+        return file.read(buffer, offset, length, position);
+    });
+}
+/**
+ * `fchown`.
+ * @param fd
+ * @param uid
+ * @param gid
+ */
+export function fchown(fd, uid, gid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fd2file(fd).chown(uid, gid);
+    });
+}
+/**
+ * `fchmod`.
+ * @param fd
+ * @param mode
+ */
+export function fchmod(fd, mode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const numMode = typeof mode === 'string' ? parseInt(mode, 8) : mode;
+        return fd2file(fd).chmod(numMode);
+    });
+}
+/**
+ * Change the file timestamps of a file referenced by the supplied file
+ * descriptor.
+ * @param fd
+ * @param atime
+ * @param mtime
+ */
+export function futimes(fd, atime, mtime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fd2file(fd).utimes(normalizeTime(atime), normalizeTime(mtime));
+    });
+}
+// DIRECTORY-ONLY METHODS
+/**
+ * `rmdir`.
+ * @param path
+ */
+export function rmdir(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('rmdir', true, path, cred);
+    });
+}
+/**
+ * `mkdir`.
+ * @param path
+ * @param mode defaults to `0777`
+ */
+export function mkdir(path, mode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('mkdir', true, path, normalizeMode(mode, 0o777), cred);
+    });
+}
+/**
+ * `readdir`. Reads the contents of a directory.
+ * @param path
+ * @return [String[]]
+ */
+export function readdir(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = normalizePath(path);
+        const entries = yield doOp('readdir', true, path, cred);
+        const points = [...mounts.keys()];
+        for (const point of points) {
+            if (point.startsWith(path)) {
+                const entry = point.slice(path.length);
+                if (entry.includes('/') || entry.length == 0) {
+                    // ignore FSs mounted in subdirectories and any FS mounted to `path`.
+                    continue;
+                }
+                entries.push(entry);
+            }
+        }
+        return entries;
+    });
+}
+// SYMLINK METHODS
+/**
+ * `link`.
+ * @param srcpath
+ * @param dstpath
+ */
+export function link(srcpath, dstpath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        dstpath = normalizePath(dstpath);
+        return doOp('link', false, srcpath, dstpath, cred);
+    });
+}
+/**
+ * `symlink`.
+ * @param srcpath
+ * @param dstpath
+ * @param type can be either `'dir'` or `'file'` (default is `'file'`)
+ */
+export function symlink(srcpath, dstpath, type = 'file') {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!['file', 'dir', 'junction'].includes(type)) {
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
+        }
+        dstpath = normalizePath(dstpath);
+        return doOp('symlink', false, srcpath, dstpath, type, cred);
+    });
+}
+/**
+ * readlink.
+ * @param path
+ * @return [String]
+ */
+export function readlink(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('readlink', false, path, cred);
+    });
+}
+// PROPERTY OPERATIONS
+/**
+ * `chown`.
+ * @param path
+ * @param uid
+ * @param gid
+ */
+export function chown(path, uid, gid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('chown', true, path, uid, gid, cred);
+    });
+}
+/**
+ * `lchown`.
+ * @param path
+ * @param uid
+ * @param gid
+ */
+export function lchown(path, uid, gid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('chown', false, path, uid, gid, cred);
+    });
+}
+/**
+ * `chmod`.
+ * @param path
+ * @param mode
+ */
+export function chmod(path, mode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const numMode = normalizeMode(mode, -1);
+        if (numMode < 0) {
+            throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+        }
+        return doOp('chmod', true, path, numMode, cred);
+    });
+}
+/**
+ * `lchmod`.
+ * @param path
+ * @param mode
+ */
+export function lchmod(path, mode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const numMode = normalizeMode(mode, -1);
+        if (numMode < 1) {
+            throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+        }
+        return doOp('chmod', false, normalizePath(path), numMode, cred);
+    });
+}
+/**
+ * Change file timestamps of the file referenced by the supplied path.
+ * @param path
+ * @param atime
+ * @param mtime
+ */
+export function utimes(path, atime, mtime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('utimes', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    });
+}
+/**
+ * Change file timestamps of the file referenced by the supplied path.
+ * @param path
+ * @param atime
+ * @param mtime
+ */
+export function lutimes(path, atime, mtime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('utimes', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    });
+}
+/**
+ * `realpath`.
+ * @param path
+ * @param cache An object literal of mapped paths that can be used to
+ *   force a specific path resolution or avoid additional `fs.stat` calls for
+ *   known real paths.
+ * @return [String]
+ */
+export function realpath(path, cache = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = normalizePath(path);
+        const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
+        try {
+            const stats = yield fs.stat(resolvedPath, cred);
+            if (!stats.isSymbolicLink()) {
+                return path;
+            }
+            const dst = mountPoint + normalizePath(yield fs.readlink(resolvedPath, cred));
+            return realpath(dst);
+        }
+        catch (e) {
+            throw fixError(e, { [resolvedPath]: path });
+        }
+    });
+}
+export function watchFile(filename, arg2, listener = nop) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    });
+}
+export function unwatchFile(filename, listener = nop) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    });
+}
+export function watch(filename, arg2, listener = nop) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    });
+}
+/**
+ * `access`.
+ * @param path
+ * @param mode
+ */
+export function access(path, mode = 0o600) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return doOp('access', true, path, mode, cred);
+    });
+}
+export function createReadStream(path, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    });
+}
+export function createWriteStream(path, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    });
+}

package/dist/emulation/shared.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { Cred } from '../cred';
+import { FileSystem } from '../filesystem';
+import { File } from '../file';
+import { BackendConstructor } from '../backends/backend';
+/**
+ * converts Date or number to a fractional UNIX timestamp
+ * Grabbed from NodeJS sources (lib/fs.js)
+ */
+export declare function _toUnixTimestamp(time: Date | number): number;
+export declare function normalizeMode(mode: unknown, def: number): number;
+export declare function normalizeTime(time: number | Date): Date;
+export declare function normalizePath(p: string): string;
+export declare function normalizeOptions(options: any, defEnc: string | null, defFlag: string, defMode: number | null): {
+    encoding: BufferEncoding;
+    flag: string;
+    mode: number;
+};
+export declare function nop(): void;
+export declare let cred: Cred;
+export declare function setCred(val: Cred): void;
+export declare const fdMap: Map<number, File>;
+export declare function getFdForFile(file: File): number;
+export declare function fd2file(fd: number): File;
+export interface MountMapping {
+    [point: string]: InstanceType<BackendConstructor>;
+}
+export declare const mounts: Map<string, FileSystem>;
+/**
+ * Gets the file system mounted at `mountPoint`
+ */
+export declare function getMount(mountPoint: string): FileSystem;
+/**
+ * Gets an object of mount points (keys) and filesystems (values)
+ */
+export declare function getMounts(): MountMapping;
+/**
+ * Mounts the file system at the given mount point.
+ */
+export declare function mount(mountPoint: string, fs: FileSystem): void;
+/**
+ * Unmounts the file system at the given mount point.
+ */
+export declare function umount(mountPoint: string): void;
+/**
+ * Gets the internal FileSystem for the path, then returns it along with the path relative to the FS' root
+ */
+export declare function resolveFS(path: string): {
+    fs: FileSystem;
+    path: string;
+    mountPoint: string;
+};
+/**
+ * Reverse maps the paths in text from the mounted FileSystem to the global path
+ */
+export declare function fixPaths(text: string, paths: {
+    [from: string]: string;
+}): string;
+export declare function fixError<E extends Error>(e: E, paths: {
+    [from: string]: string;
+}): E;
+export declare function initialize(mountMapping: MountMapping): void;