@zenfs/core 0.1.0 → 0.2.0

package/dist/filesystem.js

@@ -1,36 +1,19 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 // disable no-unused-vars since BaseFileSystem uses them a lot
-var _a;
 import { ApiError, ErrorCode } from './ApiError.js';
-import { FileFlag, ActionType } from './file.js';
-import * as path from './emulation/path.js';
-import { encode } from './utils.js';
 /**
- * Structure for a filesystem. **All** ZenFS FileSystems must implement
- * this.
+ * Structure for a filesystem. All ZenFS FileSystems must implement this.
  *
- * ### Argument Assumptions
+ * This class includes some default implementations
  *
- * You can assume the following about arguments passed to each API method:
+ * Assume the following about arguments passed to each API method:
  *
- * - Every path is an absolute path. `.`, `..`, and other items
- *   are resolved into an absolute form.
- * - All arguments are present. Any optional arguments at the Node API level
- *   have been passed in with their default values.
+ * - Every path is an absolute path. `.`, `..`, and other items are resolved into an absolute form.
+ * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export class FileSystem {
-    constructor(options) {
-        // unused
-    }
-}
-/**
- * Basic filesystem class. Most filesystems should extend this class, as it
- * provides default implementations for a handful of methods.
- */
-export class BaseFileSystem extends FileSystem {
-    constructor(options) {
-        super();
-        this._ready = Promise.resolve(this);
+    static get Name() {
+        return this.name;
     }
     get metadata() {
         return {
@@ -38,418 +21,111 @@ export class BaseFileSystem extends FileSystem {
             readonly: false,
             synchronous: false,
             supportsProperties: false,
-            supportsLinks: false,
             totalSpace: 0,
             freeSpace: 0,
         };
     }
-    whenReady() {
-        return this._ready;
-    }
-    /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
-     * @param flag The flag to use when opening the file.
-     */
-    async openFile(p, flag, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+    constructor(options) {
+        // unused
     }
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Test whether or not the given path exists by checking with the file system.
      */
-    async createFile(p, flag, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async open(p, flag, mode, cred) {
+    async exists(path, cred) {
         try {
-            const stats = await this.stat(p, cred);
-            switch (flag.pathExistsAction()) {
-                case ActionType.THROW_EXCEPTION:
-                    throw ApiError.EEXIST(p);
-                case ActionType.TRUNCATE_FILE:
-                    // NOTE: In a previous implementation, we deleted the file and
-                    // re-created it. However, this created a race condition if another
-                    // asynchronous request was trying to read the file, as the file
-                    // would not exist for a small period of time.
-                    const fd = await this.openFile(p, flag, cred);
-                    if (!fd)
-                        throw new Error('BFS has reached an impossible code path; please file a bug.');
-                    await fd.truncate(0);
-                    await fd.sync();
-                    return fd;
-                case ActionType.NOP:
-                    return this.openFile(p, flag, cred);
-                default:
-                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-            }
-            // File exists.
+            await this.stat(path, cred);
+            return true;
         }
         catch (e) {
-            // File does not exist.
-            switch (flag.pathNotExistsAction()) {
-                case ActionType.CREATE_FILE:
-                    // Ensure parent exists.
-                    const parentStats = await this.stat(path.dirname(p), cred);
-                    if (parentStats && !parentStats.isDirectory()) {
-                        throw ApiError.ENOTDIR(path.dirname(p));
-                    }
-                    return this.createFile(p, flag, mode, cred);
-                case ActionType.THROW_EXCEPTION:
-                    throw ApiError.ENOENT(p);
-                default:
-                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-            }
+            return false;
         }
     }
-    async access(p, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    accessSync(p, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async rename(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    renameSync(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async stat(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    statSync(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
-     * @param flag The flag to use when opening the file.
-     * @return A File object corresponding to the opened file.
-     */
-    openFileSync(p, flag, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Test whether or not the given path exists by checking with the file system.
      */
-    createFileSync(p, flag, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    openSync(p, flag, mode, cred) {
-        // Check if the path exists, and is a file.
-        let stats;
-        try {
-            stats = this.statSync(p, cred);
-        }
-        catch (e) {
-            // File does not exist.
-            switch (flag.pathNotExistsAction()) {
-                case ActionType.CREATE_FILE:
-                    // Ensure parent exists.
-                    const parentStats = this.statSync(path.dirname(p), cred);
-                    if (!parentStats.isDirectory()) {
-                        throw ApiError.ENOTDIR(path.dirname(p));
-                    }
-                    return this.createFileSync(p, flag, mode, cred);
-                case ActionType.THROW_EXCEPTION:
-                    throw ApiError.ENOENT(p);
-                default:
-                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-            }
-        }
-        if (!stats.hasAccess(mode, cred)) {
-            throw ApiError.EACCES(p);
-        }
-        // File exists.
-        switch (flag.pathExistsAction()) {
-            case ActionType.THROW_EXCEPTION:
-                throw ApiError.EEXIST(p);
-            case ActionType.TRUNCATE_FILE:
-                // Delete file.
-                this.unlinkSync(p, cred);
-                // Create file. Use the same mode as the old file.
-                // Node itself modifies the ctime when this occurs, so this action
-                // will preserve that behavior if the underlying file system
-                // supports those properties.
-                return this.createFileSync(p, flag, stats.mode, cred);
-            case ActionType.NOP:
-                return this.openFileSync(p, flag, cred);
-            default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-        }
-    }
-    async unlink(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    unlinkSync(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async rmdir(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    rmdirSync(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async mkdir(p, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    mkdirSync(p, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async readdir(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    readdirSync(p, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async exists(p, cred) {
+    existsSync(path, cred) {
         try {
-            await this.stat(p, cred);
+            this.statSync(path, cred);
             return true;
         }
         catch (e) {
             return false;
         }
     }
-    existsSync(p, cred) {
-        try {
-            this.statSync(p, cred);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
+}
+/**
+ * Implements the asynchronous API in terms of the synchronous API.
+ */
+export class SyncFileSystem extends FileSystem {
+    get metadata() {
+        return { ...super.metadata, synchronous: true };
     }
-    async realpath(p, cred) {
-        if (this.metadata.supportsLinks) {
-            // The path could contain symlinks. Split up the path,
-            // resolve any symlinks, return the resolved string.
-            const splitPath = p.split(path.sep);
-            // TODO: Simpler to just pass through file, find sep and such.
-            for (let i = 0; i < splitPath.length; i++) {
-                const addPaths = splitPath.slice(0, i + 1);
-                splitPath[i] = path.join(...addPaths);
-            }
-            return splitPath.join(path.sep);
-        }
-        else {
-            // No symlinks. We just need to verify that it exists.
-            if (!(await this.exists(p, cred))) {
-                throw ApiError.ENOENT(p);
-            }
-            return p;
-        }
+    async ready() {
+        return this;
     }
-    realpathSync(p, cred) {
-        if (this.metadata.supportsLinks) {
-            // The path could contain symlinks. Split up the path,
-            // resolve any symlinks, return the resolved string.
-            const splitPath = p.split(path.sep);
-            // TODO: Simpler to just pass through file, find sep and such.
-            for (let i = 0; i < splitPath.length; i++) {
-                const addPaths = splitPath.slice(0, i + 1);
-                splitPath[i] = path.join(...addPaths);
-            }
-            return splitPath.join(path.sep);
-        }
-        else {
-            // No symlinks. We just need to verify that it exists.
-            if (this.existsSync(p, cred)) {
-                return p;
-            }
-            else {
-                throw ApiError.ENOENT(p);
-            }
-        }
+    async rename(oldPath, newPath, cred) {
+        return this.renameSync(oldPath, newPath, cred);
     }
-    async truncate(p, len, cred) {
-        const fd = await this.open(p, FileFlag.getFileFlag('r+'), 0o644, cred);
-        try {
-            await fd.truncate(len);
-        }
-        finally {
-            await fd.close();
-        }
+    async stat(path, cred) {
+        return this.statSync(path, cred);
     }
-    truncateSync(p, len, cred) {
-        const fd = this.openSync(p, FileFlag.getFileFlag('r+'), 0o644, cred);
-        // Need to safely close FD, regardless of whether or not truncate succeeds.
-        try {
-            fd.truncateSync(len);
-        }
-        finally {
-            fd.closeSync();
-        }
+    async createFile(path, flag, mode, cred) {
+        return this.createFileSync(path, flag, mode, cred);
     }
-    async readFile(fname, flag, cred) {
-        // Get file.
-        const fd = await this.open(fname, flag, 0o644, cred);
-        try {
-            const stat = await fd.stat();
-            // Allocate buffer.
-            const buf = new Uint8Array(stat.size);
-            await fd.read(buf, 0, stat.size, 0);
-            await fd.close();
-            return buf;
-        }
-        finally {
-            await fd.close();
-        }
+    async openFile(path, flag, cred) {
+        return this.openFileSync(path, flag, cred);
     }
-    readFileSync(fname, flag, cred) {
-        // Get file.
-        const fd = this.openSync(fname, flag, 0o644, cred);
-        try {
-            const stat = fd.statSync();
-            // Allocate buffer.
-            const buf = new Uint8Array(stat.size);
-            fd.readSync(buf, 0, stat.size, 0);
-            fd.closeSync();
-            return buf;
-        }
-        finally {
-            fd.closeSync();
-        }
+    async unlink(path, cred) {
+        return this.unlinkSync(path, cred);
     }
-    async writeFile(fname, data, flag, mode, cred) {
-        // Get file.
-        const fd = await this.open(fname, flag, mode, cred);
-        try {
-            if (typeof data === 'string') {
-                data = encode(data);
-            }
-            // Write into file.
-            await fd.write(data, 0, data.length, 0);
-        }
-        finally {
-            await fd.close();
-        }
+    async rmdir(path, cred) {
+        return this.rmdirSync(path, cred);
     }
-    writeFileSync(fname, data, flag, mode, cred) {
-        // Get file.
-        const fd = this.openSync(fname, flag, mode, cred);
-        try {
-            if (typeof data === 'string') {
-                data = encode(data);
-            }
-            // Write into file.
-            fd.writeSync(data, 0, data.length, 0);
-        }
-        finally {
-            fd.closeSync();
-        }
+    async mkdir(path, mode, cred) {
+        return this.mkdirSync(path, mode, cred);
     }
-    async appendFile(fname, data, flag, mode, cred) {
-        const fd = await this.open(fname, flag, mode, cred);
-        try {
-            if (typeof data === 'string') {
-                data = encode(data);
-            }
-            await fd.write(data, 0, data.length, null);
-        }
-        finally {
-            await fd.close();
-        }
+    async readdir(path, cred) {
+        return this.readdirSync(path, cred);
     }
-    appendFileSync(fname, data, flag, mode, cred) {
-        const fd = this.openSync(fname, flag, mode, cred);
-        try {
-            if (typeof data === 'string') {
-                data = encode(data);
-            }
-            fd.writeSync(data, 0, data.length, null);
-        }
-        finally {
-            fd.closeSync();
-        }
+    async link(srcpath, dstpath, cred) {
+        return this.linkSync(srcpath, dstpath, cred);
     }
-    async chmod(p, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+    async sync(path, data, stats) {
+        return this.syncSync(path, data, stats);
     }
-    chmodSync(p, mode, cred) {
+}
+export class AsyncFileSystem extends FileSystem {
+    renameSync(oldPath, newPath, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    async chown(p, new_uid, new_gid, cred) {
+    statSync(path, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    chownSync(p, new_uid, new_gid, cred) {
+    createFileSync(path, flag, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    async utimes(p, atime, mtime, cred) {
+    openSync(path, flags, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    utimesSync(p, atime, mtime, cred) {
+    openFileSync(path, flag, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    async link(srcpath, dstpath, cred) {
+    unlinkSync(path, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    linkSync(srcpath, dstpath, cred) {
+    rmdirSync(path, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    async symlink(srcpath, dstpath, type, cred) {
+    mkdirSync(path, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    symlinkSync(srcpath, dstpath, type, cred) {
+    readdirSync(path, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    async readlink(p, cred) {
+    linkSync(srcpath, dstpath, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    readlinkSync(p, cred) {
+    syncSync(path, data, stats) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
 }
-_a = BaseFileSystem;
-BaseFileSystem.Name = _a.name;
-/**
- * Implements the asynchronous API in terms of the synchronous API.
- */
-export class SynchronousFileSystem extends BaseFileSystem {
-    get metadata() {
-        return { ...super.metadata, synchronous: true };
-    }
-    async access(p, mode, cred) {
-        return this.accessSync(p, mode, cred);
-    }
-    async rename(oldPath, newPath, cred) {
-        return this.renameSync(oldPath, newPath, cred);
-    }
-    async stat(p, cred) {
-        return this.statSync(p, cred);
-    }
-    async open(p, flags, mode, cred) {
-        return this.openSync(p, flags, mode, cred);
-    }
-    async unlink(p, cred) {
-        return this.unlinkSync(p, cred);
-    }
-    async rmdir(p, cred) {
-        return this.rmdirSync(p, cred);
-    }
-    async mkdir(p, mode, cred) {
-        return this.mkdirSync(p, mode, cred);
-    }
-    async readdir(p, cred) {
-        return this.readdirSync(p, cred);
-    }
-    async chmod(p, mode, cred) {
-        return this.chmodSync(p, mode, cred);
-    }
-    async chown(p, new_uid, new_gid, cred) {
-        return this.chownSync(p, new_uid, new_gid, cred);
-    }
-    async utimes(p, atime, mtime, cred) {
-        return this.utimesSync(p, atime, mtime, cred);
-    }
-    async link(srcpath, dstpath, cred) {
-        return this.linkSync(srcpath, dstpath, cred);
-    }
-    async symlink(srcpath, dstpath, type, cred) {
-        return this.symlinkSync(srcpath, dstpath, type, cred);
-    }
-    async readlink(p, cred) {
-        return this.readlinkSync(p, cred);
-    }
-}

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 /**
  * ZenFS's main module. This is exposed in the browser via the ZenFS global.
  */
-import fs from './emulation/fs.js';
-import { FileSystem, type NoArgCallback, type TwoArgCallback } from './filesystem.js';
+import * as fs from './emulation/index.js';
+import { FileSystem } from './filesystem.js';
 import { backends } from './backends/index.js';
+import { type Backend, type BackendConfig } from './backends/backend.js';
 /**
  * Initializes ZenFS with the given file systems.
  */
@@ -14,55 +15,17 @@ export declare function initialize(mounts: {
  * Defines a mapping of mount points to their configurations
  */
 export interface ConfigMapping {
-    [mountPoint: string]: FileSystem | FileSystemConfiguration | keyof typeof backends;
+    [mountPoint: string]: FileSystem | BackendConfig | keyof typeof backends | Backend;
 }
 /**
  * A configuration for ZenFS
  */
-export type Configuration = FileSystem | FileSystemConfiguration | ConfigMapping;
+export type Configuration = FileSystem | BackendConfig | ConfigMapping;
 /**
- * Creates a file system with the given configuration, and initializes ZenFS with it.
- * See the FileSystemConfiguration type for more info on the configuration object.
+ * Creates filesystems with the given configuration, and initializes ZenFS with it.
+ * See the Configuration type for more info on the configuration object.
  */
 export declare function configure(config: Configuration): Promise<void>;
-export declare function configure(config: Configuration, cb: NoArgCallback): void;
-/**
- * Asynchronously creates a file system with the given configuration, and initializes ZenFS with it.
- * See the FileSystemConfiguration type for more info on the configuration object.
- * Note: unlike configure, the .then is provided with the file system
- */
-/**
- * Specifies a file system backend type and its options.
- *
- * Individual options can recursively contain FileSystemConfiguration objects for
- * option values that require file systems.
- *
- * For example, to mirror Dropbox to Storage with AsyncMirror, use the following
- * object:
- *
- * ```javascript
- * var config = {
- *   fs: "AsyncMirror",
- *   options: {
- *     sync: {fs: "Storage"},
- *     async: {fs: "Dropbox", options: {client: anAuthenticatedDropboxSDKClient }}
- *   }
- * };
- * ```
- *
- * The option object for each file system corresponds to that file system's option object passed to its `Create()` method.
- */
-export interface FileSystemConfiguration {
-    fs: string;
-    options?: object;
-}
-/**
- * Retrieve a file system with the given configuration. Will return a promise if invoked without a callback
- * @param config A FileSystemConfiguration object. See FileSystemConfiguration for details.
- * @param cb Called when the file system is constructed, or when an error occurs.
- */
-export declare function getFileSystem(config: FileSystemConfiguration): Promise<FileSystem>;
-export declare function getFileSystem(config: FileSystemConfiguration, cb: TwoArgCallback<FileSystem>): void;
 export * from './backends/index.js';
 export * from './backends/AsyncStore.js';
 export * from './backends/SyncStore.js';

package/dist/index.js

@@ -1,11 +1,11 @@
 /**
  * ZenFS's main module. This is exposed in the browser via the ZenFS global.
  */
-import fs from './emulation/fs.js';
+import * as fs from './emulation/index.js';
 import { FileSystem } from './filesystem.js';
 import { backends } from './backends/index.js';
-import { ErrorCode, ApiError } from './ApiError.js';
 import { Cred } from './cred.js';
+import { isBackend, resolveBackendConfig } from './backends/backend.js';
 import { setCred } from './emulation/shared.js';
 /**
  * Initializes ZenFS with the given file systems.
@@ -14,8 +14,12 @@ export function initialize(mounts, uid = 0, gid = 0) {
     setCred(new Cred(uid, gid, uid, gid, uid, gid));
     return fs.initialize(mounts);
 }
-async function _configure(config) {
-    if ('fs' in config || config instanceof FileSystem) {
+/**
+ * Creates filesystems with the given configuration, and initializes ZenFS with it.
+ * See the Configuration type for more info on the configuration object.
+ */
+export async function configure(config) {
+    if ('backend' in config || config instanceof FileSystem) {
         // single FS
         config = { '/': config };
     }
@@ -28,57 +32,14 @@ async function _configure(config) {
             continue;
         }
         if (typeof value == 'string') {
-            value = { fs: value };
+            value = { backend: backends[value] };
         }
-        config[point] = await getFileSystem(value);
-    }
-    return initialize(config);
-}
-export function configure(config, cb) {
-    // Promise version
-    if (typeof cb != 'function') {
-        return _configure(config);
-    }
-    // Callback version
-    _configure(config)
-        .then(() => cb())
-        .catch(err => cb(err));
-    return;
-}
-async function _getFileSystem({ fs: fsName, options = {} }) {
-    if (!fsName) {
-        throw new ApiError(ErrorCode.EPERM, 'Missing "fs" property on configuration object.');
-    }
-    if (typeof options !== 'object' || options === null) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid "options" property on configuration object.');
-    }
-    const props = Object.keys(options).filter(k => k != 'fs');
-    for (const prop of props) {
-        const opt = options[prop];
-        if (opt === null || typeof opt !== 'object' || !('fs' in opt)) {
-            continue;
+        if (isBackend(value)) {
+            value = { backend: value };
         }
-        const fs = await _getFileSystem(opt);
-        options[prop] = fs;
-    }
-    const fsc = backends[fsName];
-    if (!fsc) {
-        throw new ApiError(ErrorCode.EPERM, `File system ${fsName} is not available in ZenFS.`);
-    }
-    else {
-        return fsc.Create(options);
+        config[point] = await resolveBackendConfig(value);
     }
-}
-export function getFileSystem(config, cb) {
-    // Promise version
-    if (typeof cb != 'function') {
-        return _getFileSystem(config);
-    }
-    // Callback version
-    _getFileSystem(config)
-        .then(fs => cb(null, fs))
-        .catch(err => cb(err));
-    return;
+    return initialize(config);
 }
 export * from './backends/index.js';
 export * from './backends/AsyncStore.js';