@zenfs/core 0.1.0 → 0.2.0

package/dist/backends/SyncStore.d.ts

@@ -1,15 +1,16 @@
 import { Cred } from '../cred.js';
 import { FileFlag, PreloadFile } from '../file.js';
-import { SynchronousFileSystem } from '../filesystem.js';
-import { Stats } from '../stats.js';
+import { SyncFileSystem, type FileSystemMetadata } from '../filesystem.js';
+import { type Ino, Inode } from '../inode.js';
+import { Stats, FileType } from '../stats.js';
 /**
  * Represents a *synchronous* key-value store.
  */
-export interface SyncKeyValueStore {
+export interface SyncStore {
     /**
      * The name of the key-value store.
      */
-    name(): string;
+    name: string;
     /**
      * Empties the key-value store completely.
      */
@@ -17,43 +18,43 @@ export interface SyncKeyValueStore {
     /**
      * Begins a new read-only transaction.
      */
-    beginTransaction(type: 'readonly'): SyncKeyValueROTransaction;
+    beginTransaction(type: 'readonly'): SyncROTransaction;
     /**
      * Begins a new read-write transaction.
      */
-    beginTransaction(type: 'readwrite'): SyncKeyValueRWTransaction;
-    beginTransaction(type: string): SyncKeyValueROTransaction;
+    beginTransaction(type: 'readwrite'): SyncRWTransaction;
+    beginTransaction(type: string): SyncROTransaction;
 }
 /**
  * A read-only transaction for a synchronous key value store.
  */
-export interface SyncKeyValueROTransaction {
+export interface SyncROTransaction {
     /**
      * Retrieves the data at the given key. Throws an ApiError if an error occurs
      * or if the key does not exist.
-     * @param key The key to look under for data.
+     * @param ino The key to look under for data.
      * @return The data stored under the key, or undefined if not present.
      */
-    get(key: string): Uint8Array | undefined;
+    get(ino: Ino): Uint8Array | undefined;
 }
 /**
  * A read-write transaction for a synchronous key value store.
  */
-export interface SyncKeyValueRWTransaction extends SyncKeyValueROTransaction {
+export interface SyncRWTransaction extends SyncROTransaction {
     /**
      * Adds the data to the store under the given key.
-     * @param key The key to add the data under.
+     * @param ino The key to add the data under.
      * @param data The data to add to the store.
      * @param overwrite If 'true', overwrite any existing data. If 'false',
      *   avoids storing the data if the key exists.
      * @return True if storage succeeded, false otherwise.
      */
-    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
+    put(ino: Ino, data: Uint8Array, overwrite: boolean): boolean;
     /**
      * Deletes the data at the given key.
-     * @param key The key to delete from the store.
+     * @param ino The key to delete from the store.
      */
-    del(key: string): void;
+    remove(ino: Ino): void;
     /**
      * Commits the transaction.
      */
@@ -68,66 +69,54 @@ export interface SyncKeyValueRWTransaction extends SyncKeyValueROTransaction {
  * support for transactions and such.
  */
 export interface SimpleSyncStore {
-    get(key: string): Uint8Array | undefined;
-    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
-    del(key: string): void;
+    get(ino: Ino): Uint8Array | undefined;
+    put(ino: Ino, data: Uint8Array, overwrite: boolean): boolean;
+    remove(ino: Ino): void;
 }
 /**
  * A simple RW transaction for simple synchronous key-value stores.
  */
-export declare class SimpleSyncRWTransaction implements SyncKeyValueRWTransaction {
-    private store;
+export declare class SimpleSyncRWTransaction implements SyncRWTransaction {
+    protected store: SimpleSyncStore;
     /**
      * Stores data in the keys we modify prior to modifying them.
      * Allows us to roll back commits.
      */
-    private originalData;
+    protected originalData: Map<Ino, Uint8Array>;
     /**
      * List of keys modified in this transaction, if any.
      */
-    private modifiedKeys;
+    protected modifiedKeys: Set<Ino>;
     constructor(store: SimpleSyncStore);
-    get(key: string): Uint8Array | undefined;
-    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
-    del(key: string): void;
+    get(ino: Ino): Uint8Array | undefined;
+    put(ino: Ino, data: Uint8Array, overwrite: boolean): boolean;
+    remove(ino: Ino): void;
     commit(): void;
     abort(): void;
-    private _has;
     /**
      * Stashes given key value pair into `originalData` if it doesn't already
      * exist. Allows us to stash values the program is requesting anyway to
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    private stashOldValue;
+    protected stashOldValue(ino: Ino, value: Uint8Array | undefined): void;
     /**
      * Marks the given key as modified, and stashes its value if it has not been
      * stashed already.
      */
-    private markModified;
+    protected markModified(ino: Ino): void;
 }
-export interface SyncKeyValueFileSystemOptions {
+export interface SyncFileSystemOptions {
     /**
      * The actual key-value store to read from/write to.
      */
-    store: SyncKeyValueStore;
-    /**
-     * Should the file system support properties (mtime/atime/ctime/chmod/etc)?
-     * Enabling this slightly increases the storage space per file, and adds
-     * atime updates every time a file is accessed, mtime updates every time
-     * a file is modified, and permission checks on every operation.
-     *
-     * Defaults to *false*.
-     */
-    supportProps?: boolean;
-    /**
-     * Should the file system support links?
-     */
-    supportLinks?: boolean;
+    store: SyncStore;
 }
-export declare class SyncKeyValueFile extends PreloadFile<SyncKeyValueFileSystem> {
-    constructor(_fs: SyncKeyValueFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+export declare class SyncStoreFile extends PreloadFile<SyncStoreFileSystem> {
+    constructor(_fs: SyncStoreFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+    sync(): Promise<void>;
     syncSync(): void;
+    close(): Promise<void>;
     closeSync(): void;
 }
 /**
@@ -139,35 +128,28 @@ export declare class SyncKeyValueFile extends PreloadFile<SyncKeyValueFileSystem
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  */
-export declare class SyncKeyValueFileSystem extends SynchronousFileSystem {
-    static isAvailable(): boolean;
-    private store;
-    constructor(options: SyncKeyValueFileSystemOptions);
-    getName(): string;
-    isReadOnly(): boolean;
-    supportsSymlinks(): boolean;
-    supportsProps(): boolean;
-    supportsSynch(): boolean;
+export declare class SyncStoreFileSystem extends SyncFileSystem {
+    protected store: SyncStore;
+    constructor(options: SyncFileSystemOptions);
+    get metadata(): FileSystemMetadata;
     /**
      * Delete all contents stored in the file system.
      */
     empty(): void;
-    accessSync(p: string, mode: number, cred: Cred): void;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(p: string, cred: Cred): Stats;
-    createFileSync(p: string, flag: FileFlag, mode: number, cred: Cred): SyncKeyValueFile;
-    openFileSync(p: string, flag: FileFlag, cred: Cred): SyncKeyValueFile;
+    createFileSync(p: string, flag: FileFlag, mode: number, cred: Cred): SyncStoreFile;
+    openFileSync(p: string, flag: FileFlag, cred: Cred): SyncStoreFile;
     unlinkSync(p: string, cred: Cred): void;
     rmdirSync(p: string, cred: Cred): void;
     mkdirSync(p: string, mode: number, cred: Cred): void;
     readdirSync(p: string, cred: Cred): string[];
-    chmodSync(p: string, mode: number, cred: Cred): void;
-    chownSync(p: string, new_uid: number, new_gid: number, cred: Cred): void;
-    _syncSync(p: string, data: Uint8Array, stats: Stats): void;
+    syncSync(p: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    linkSync(existing: string, newpath: string, cred: Cred): void;
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
-    private makeRootDirectory;
+    protected makeRootDirectory(): void;
     /**
      * Helper function for findINode.
      * @param parent The parent directory of the file we are attempting to find.
@@ -175,35 +157,35 @@ export declare class SyncKeyValueFileSystem extends SynchronousFileSystem {
      *   the parent.
      * @return string The ID of the file's inode in the file system.
      */
-    private _findINode;
+    protected _findINode(tx: SyncROTransaction, parent: string, filename: string, visited?: Set<string>): Ino;
     /**
      * Finds the Inode of the given path.
      * @param p The path to look up.
      * @return The Inode of the path p.
      * @todo memoize/cache
      */
-    private findINode;
+    protected findINode(tx: SyncROTransaction, p: string): Inode;
     /**
      * Given the ID of a node, retrieves the corresponding Inode.
      * @param tx The transaction to use.
      * @param p The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    private getINode;
+    protected getINode(tx: SyncROTransaction, id: Ino, p?: string): Inode;
     /**
-     * Given the Inode of a directory, retrieves the corresponding directory
-     * listing.
+     * Given the Inode of a directory, retrieves the corresponding directory listing.
      */
-    private getDirListing;
+    protected getDirListing(tx: SyncROTransaction, inode: Inode, p?: string): {
+        [fileName: string]: Ino;
+    };
     /**
      * Creates a new node under a random ID. Retries 5 times before giving up in
      * the exceedingly unlikely chance that we try to reuse a random GUID.
      * @return The GUID that the data was stored under.
      */
-    private addNewNode;
+    protected addNewNode(tx: SyncRWTransaction, data: Uint8Array): Ino;
     /**
-     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with
-     * the given mode.
+     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with the given mode.
      * Note: This will commit the transaction.
      * @param p The path to the new file.
      * @param type The type of the new file.
@@ -211,12 +193,12 @@ export declare class SyncKeyValueFileSystem extends SynchronousFileSystem {
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    private commitNewFile;
+    protected commitNewFile(p: string, type: FileType, mode: number, cred: Cred, data?: Uint8Array): Inode;
     /**
      * Remove all traces of the given path from the file system.
      * @param p The path to remove from the file system.
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    private removeEntry;
+    protected removeEntry(p: string, isDir: boolean, cred: Cred): void;
 }