@zenfs/core 0.9.6 → 0.10.0

package/dist/backends/port/rpc.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { TransferListItem } from 'worker_threads';
+import { type PortFS } from './fs.js';
+type _MessageEvent<T = any> = T | {
+    data: T;
+};
+export interface Port {
+    postMessage(value: unknown, transferList?: ReadonlyArray<TransferListItem>): void;
+    on?(event: 'message', listener: (value: unknown) => void): this;
+    off?(event: 'message', listener: (value: unknown) => void): this;
+    addEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
+    removeEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
+}
+export interface Options {
+    /**
+     * The target port that you want to connect to, or the current port if in a port context.
+     */
+    port: Port;
+    /**
+     * How long to wait for a request to complete
+     */
+    timeout?: number;
+}
+/**
+ * An RPC message
+ */
+export interface Message<TScope extends string = string, TMethod extends string = string> {
+    _zenfs: true;
+    scope: TScope;
+    id: string;
+    method: TMethod;
+    stack: string;
+}
+export interface Request<TScope extends string = string, TMethod extends string = string, TArgs extends unknown[] = unknown[]> extends Message<TScope, TMethod> {
+    args: TArgs;
+}
+export interface Response<TScope extends string = string, TMethod extends string = string, TValue = unknown> extends Message<TScope, TMethod> {
+    error: boolean;
+    value: Awaited<TValue> extends File ? FileData : Awaited<TValue>;
+}
+export interface FileData {
+    fd: number;
+    path: string;
+    position: number;
+}
+export { FileData as File };
+export declare function isMessage(arg: unknown): arg is Message<string, string>;
+type _Executor = Parameters<ConstructorParameters<typeof Promise<any>>[0]>;
+export interface Executor {
+    resolve: _Executor[0];
+    reject: _Executor[1];
+    fs?: PortFS;
+}
+export declare function request<const TRequest extends Request, TValue>(request: Omit<TRequest, 'id' | 'stack' | '_zenfs'>, { port, timeout, fs }?: Partial<Options> & {
+    fs?: PortFS;
+}): Promise<TValue>;
+export declare function handleResponse<const TResponse extends Response>(response: TResponse): void;
+export declare function attach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
+export declare function detach<T extends Message>(port: Port, handler: (message: T) => unknown): void;

package/dist/backends/port/rpc.js

@@ -0,0 +1,71 @@
+import { ErrnoError, Errno } from '../../error.js';
+import { PortFile } from './fs.js';
+function isFileData(value) {
+    return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
+}
+// general types
+export function isMessage(arg) {
+    return typeof arg == 'object' && arg != null && '_zenfs' in arg && !!arg._zenfs;
+}
+const executors = new Map();
+export function request(request, { port, timeout = 1000, fs } = {}) {
+    const stack = new Error().stack.slice('Error:'.length);
+    if (!port) {
+        throw ErrnoError.With('EINVAL');
+    }
+    return new Promise((resolve, reject) => {
+        const id = Math.random().toString(16).slice(10);
+        executors.set(id, { resolve, reject, fs });
+        port.postMessage({ ...request, _zenfs: true, id, stack });
+        setTimeout(() => {
+            const error = new ErrnoError(Errno.EIO, 'RPC Failed');
+            error.stack += stack;
+            reject(error);
+        }, timeout);
+    });
+}
+export function handleResponse(response) {
+    if (!isMessage(response)) {
+        return;
+    }
+    const { id, value, error, stack } = response;
+    if (!executors.has(id)) {
+        const error = new ErrnoError(Errno.EIO, 'Invalid RPC id:' + id);
+        error.stack += stack;
+        throw error;
+    }
+    const { resolve, reject, fs } = executors.get(id);
+    if (error) {
+        const e = ErrnoError.fromJSON(value);
+        e.stack += stack;
+        reject(e);
+        executors.delete(id);
+        return;
+    }
+    if (isFileData(value)) {
+        const { fd, path, position } = value;
+        const file = new PortFile(fs, fd, path, position);
+        resolve(file);
+        executors.delete(id);
+        return;
+    }
+    resolve(value);
+    executors.delete(id);
+    return;
+}
+export function attach(port, handler) {
+    if (!port) {
+        throw ErrnoError.With('EINVAL');
+    }
+    port['on' in port ? 'on' : 'addEventListener']('message', (message) => {
+        handler('data' in message ? message.data : message);
+    });
+}
+export function detach(port, handler) {
+    if (!port) {
+        throw ErrnoError.With('EINVAL');
+    }
+    port['off' in port ? 'off' : 'removeEventListener']('message', (message) => {
+        handler('data' in message ? message.data : message);
+    });
+}

package/dist/backends/port/store.d.ts

@@ -0,0 +1,30 @@
+import { type AsyncStore, type AsyncTransaction } from '../AsyncStore.js';
+import type { SyncStore } from '../SyncStore.js';
+import type { Backend } from '../backend.js';
+import * as RPC from './rpc.js';
+import type { ExtractProperties } from 'utilium';
+export declare class PortStore implements AsyncStore {
+    readonly options: RPC.Options;
+    readonly name: string;
+    readonly port: RPC.Port;
+    constructor(options: RPC.Options, name?: string);
+    clear(): Promise<void>;
+    beginTransaction(): PortTransaction;
+}
+type TxMethods = ExtractProperties<AsyncTransaction, (...args: any[]) => Promise<any>>;
+type TxMethod = keyof TxMethods;
+export declare class PortTransaction implements AsyncTransaction {
+    readonly store: PortStore;
+    readonly id: number | Promise<number>;
+    constructor(store: PortStore, id: number | Promise<number>);
+    rpc<const T extends TxMethod>(method: T, ...args: Parameters<TxMethods[T]>): Promise<Awaited<ReturnType<TxMethods[T]>>>;
+    get(key: bigint): Promise<Uint8Array>;
+    put(key: bigint, data: Uint8Array, overwrite: boolean): Promise<boolean>;
+    remove(key: bigint): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}
+export declare function attachStore(port: RPC.Port, store: SyncStore | AsyncStore): void;
+export declare function detachStore(port: RPC.Port, store: SyncStore | AsyncStore): void;
+export declare const PortStoreBackend: Backend;
+export {};

package/dist/backends/port/store.js

@@ -0,0 +1,142 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ErrnoError, Errno } from '../../error.js';
+import { AsyncStoreFS } from '../AsyncStore.js';
+import * as RPC from './rpc.js';
+export class PortStore {
+    constructor(options, name = 'port') {
+        this.options = options;
+        this.name = name;
+        this.port = options.port;
+        RPC.attach(this.port, RPC.handleResponse);
+    }
+    clear() {
+        return RPC.request({
+            scope: 'store',
+            method: 'clear',
+            args: [],
+        }, this.options);
+    }
+    beginTransaction() {
+        const id = RPC.request({
+            scope: 'store',
+            method: 'beginTransaction',
+            args: [],
+        }, this.options);
+        return new PortTransaction(this, id);
+    }
+}
+export class PortTransaction {
+    constructor(store, id) {
+        this.store = store;
+        this.id = id;
+    }
+    async rpc(method, ...args) {
+        return RPC.request({
+            scope: 'transaction',
+            tx: await this.id,
+            method,
+            args,
+        }, this.store.options);
+    }
+    get(key) {
+        return this.rpc('get', key);
+    }
+    async put(key, data, overwrite) {
+        return await this.rpc('put', key, data, overwrite);
+    }
+    async remove(key) {
+        return await this.rpc('remove', key);
+    }
+    async commit() {
+        return await this.rpc('commit');
+    }
+    async abort() {
+        return await this.rpc('abort');
+    }
+}
+let nextTx = 0;
+const transactions = new Map();
+async function handleRequest(port, store, request) {
+    if (!RPC.isMessage(request)) {
+        return;
+    }
+    const { method, args, id, scope, stack } = request;
+    let value, error = false;
+    try {
+        switch (scope) {
+            case 'store':
+                // @ts-expect-error 2556
+                value = await store[method](...args);
+                if (method == 'beginTransaction') {
+                    transactions.set(++nextTx, value);
+                    value = nextTx;
+                }
+                break;
+            case 'transaction':
+                const { tx } = request;
+                if (!transactions.has(tx)) {
+                    throw new ErrnoError(Errno.EBADF);
+                }
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore 2556
+                value = await transactions.get(tx)[method](...args);
+                if (method == 'close') {
+                    transactions.delete(tx);
+                }
+                break;
+            default:
+                return;
+        }
+    }
+    catch (e) {
+        value = e;
+        error = true;
+    }
+    port.postMessage({
+        _zenfs: true,
+        scope,
+        id,
+        error,
+        method,
+        stack,
+        value: value instanceof ErrnoError ? value.toJSON() : value,
+    });
+}
+export function attachStore(port, store) {
+    RPC.attach(port, (request) => handleRequest(port, store, request));
+}
+export function detachStore(port, store) {
+    RPC.detach(port, (request) => handleRequest(port, store, request));
+}
+export const PortStoreBackend = {
+    name: 'PortStore',
+    options: {
+        port: {
+            type: 'object',
+            description: 'The target port that you want to connect to',
+            validator(port) {
+                // Check for a `postMessage` function.
+                if (typeof port?.postMessage != 'function') {
+                    throw new ErrnoError(Errno.EINVAL, 'option must be a port.');
+                }
+            },
+        },
+    },
+    async isAvailable() {
+        if ('WorkerGlobalScope' in globalThis && globalThis instanceof globalThis.WorkerGlobalScope) {
+            // Web Worker
+            return true;
+        }
+        try {
+            const worker_threads = await import('node:worker_threads');
+            // NodeJS worker
+            return 'Worker' in worker_threads;
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    create(options) {
+        return new AsyncStoreFS({ ...options, store: new PortStore(options, options?.name) });
+    },
+};