@poe-platform/safe-fs 0.1.652 → 0.1.654

package/dist/safe-fs/fs/capabilities.js

@@ -116,7 +116,7 @@ export function quotaCapabilities(capabilities) {
     const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, !capabilities.readOnly);
     const streamingAppend = requireCapabilities(capabilities.append, !capabilities.readOnly);
     const { streamingWrite: ignoredWrite, streamingAppend: ignoredAppend, ...rest } = capabilities;
-    return Object.freeze({ ...rest, open: false, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+    return Object.freeze({ ...rest, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
         ...(streamingWrite === undefined ? {} : { streamingWrite }),
         ...(streamingAppend === undefined ? {} : { streamingAppend }),
     });

package/dist/safe-fs/fs/quota/index.d.ts

@@ -6,6 +6,7 @@ export interface FileSystemQuotaOptions {
 }
 export declare class FileSystemQuotaError extends Error {
     readonly maxBytes: number;
+    readonly code = "ENOSPC";
     constructor(maxBytes: number);
 }
 export declare function withFileSystemQuota(fs: FileSystem, options: FileSystemQuotaOptions): FileSystem;

package/dist/safe-fs/fs/quota/index.js

@@ -2,8 +2,10 @@ import { FsError } from "../../contracts/errors.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { openRetainedReadFile, openRetainedResizeFile, quotaCapabilities, retainedReadCapabilities, retainedResizeCapabilities } from "../capabilities.js";
 import { admitDirectoryEntries } from "../directory-admission.js";
+import { forwardFileDescriptor, openFileDescriptor } from "../descriptor.js";
 export class FileSystemQuotaError extends Error {
     maxBytes;
+    code = "ENOSPC";
     constructor(maxBytes) {
         super(`Filesystem quota exceeded (${maxBytes} bytes)`);
         this.maxBytes = maxBytes;
@@ -183,9 +185,87 @@ export function withFileSystemQuota(fs, options) {
             throw new FileSystemQuotaError(options.maxBytes);
     };
     const mutations = {
-        async open(path, openOptions) {
-            openOptions.signal?.throwIfAborted();
-            throw new FsError("ENOTSUP", { syscall: "open", path });
+        open(path, openOptions) {
+            return openFileDescriptor(path, openOptions, {
+                positionedRead: true, positionedWrite: true, truncate: true, synchronization: "storage",
+            }, admitted => mutate(async () => {
+                admitted.signal?.throwIfAborted();
+                const open = fs.open;
+                const capabilities = admitted.creation === "exclusive" ? fs.capabilities : await fs.capabilitiesFor?.(path, admitted) ?? fs.capabilities;
+                admitted.signal?.throwIfAborted();
+                if (!open || capabilities.open === false)
+                    throw new FsError("ENOTSUP", { syscall: "open", path });
+                admitted.signal?.throwIfAborted();
+                const descriptor = await open.call(fs, path, admitted);
+                try {
+                    admitted.signal?.throwIfAborted();
+                    const pinned = admitted.access === "read" ? undefined : { ...await descriptor.stat(admitted) };
+                    admitted.signal?.throwIfAborted();
+                    if (pinned && (pinned.type !== "file" || !completeIdentity(pinned))) {
+                        throw new FsError("ENOTSUP", { syscall: "open", path, message: "quota requires complete retained file identity" });
+                    }
+                    if (pinned && (!Number.isSafeInteger(pinned.size) || pinned.size < 0)) {
+                        throw new FsError("EIO", { syscall: "fstat", path, message: "invalid retained file size" });
+                    }
+                    const current = async (operationOptions) => {
+                        const stat = { ...await descriptor.stat(operationOptions) };
+                        operationOptions.signal?.throwIfAborted();
+                        if (!pinned || stat.type !== "file" || !completeIdentity(stat)
+                            || stat.identityScope !== pinned.identityScope || stat.dev !== pinned.dev || stat.ino !== pinned.ino
+                            || !Number.isSafeInteger(stat.size) || stat.size < 0) {
+                            throw new FsError("EIO", { syscall: "fstat", path, message: "invalid retained quota identity or size" });
+                        }
+                        return stat;
+                    };
+                    const admitSize = async (stat, nextBytes, operationOptions) => {
+                        if (!Number.isSafeInteger(nextBytes) || nextBytes < 0)
+                            throw new FsError("EFBIG", { syscall: "write", path });
+                        const projected = await usedBytes(fs, scanLimits, operationOptions, { path, stat, delta: nextBytes - stat.size, retained: true });
+                        operationOptions.signal?.throwIfAborted();
+                        if (projected > options.maxBytes)
+                            throw new FileSystemQuotaError(options.maxBytes);
+                    };
+                    const forwarded = forwardFileDescriptor(descriptor, (syscall, operationOptions, action) => syscall === "close" ? action() : mutate(async () => {
+                        operationOptions.signal?.throwIfAborted();
+                        return action();
+                    }));
+                    return {
+                        ...forwarded,
+                        write: (retained, buffer, position, operationOptions) => mutate(async () => {
+                            operationOptions.signal?.throwIfAborted();
+                            if (buffer.byteLength === 0)
+                                return retained.write(buffer, position, operationOptions);
+                            const stat = await current(operationOptions);
+                            let offset = position;
+                            if (offset === null) {
+                                if (admitted.append)
+                                    offset = stat.size;
+                                else {
+                                    if (forwarded.capabilities?.position !== true || !forwarded.getPosition) {
+                                        throw new FsError("ENOTSUP", { syscall: "getPosition", path });
+                                    }
+                                    offset = await retained.getPosition(operationOptions);
+                                    operationOptions.signal?.throwIfAborted();
+                                }
+                            }
+                            if (!Number.isSafeInteger(offset) || offset < 0)
+                                throw new FsError("EIO", { syscall: "getPosition", path });
+                            await admitSize(stat, Math.max(stat.size, offset + buffer.byteLength), operationOptions);
+                            return retained.write(buffer, position, operationOptions);
+                        }),
+                        truncate: (retained, length, operationOptions) => mutate(async () => {
+                            operationOptions.signal?.throwIfAborted();
+                            await admitSize(await current(operationOptions), length, operationOptions);
+                            await retained.truncate(length, operationOptions);
+                        }),
+                    };
+                }
+                catch (error) {
+                    await finishCleanup(() => descriptor.close(), true);
+                    admitted.signal?.throwIfAborted();
+                    throw error;
+                }
+            }));
         },
         openResizeFile(path, resizeOptions = {}) {
             return mutate(async () => {
@@ -320,14 +400,14 @@ export function withFileSystemQuota(fs, options) {
     // capabilities and methods without violating invariants on own properties.
     return new Proxy(Object.create(fs), {
         get(_target, property) {
-            if (property === "removeEntryConditional" || property === "unlink" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
+            if (property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
                 return undefined;
             if (property === "capabilities")
-                return quotaCapabilities(retainedResizeCapabilities(fs, retainedReadCapabilities(fs)));
+                return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }) });
             if (property === "capabilitiesFor")
                 return async (path, fsOptions) => {
                     const capabilities = await fs.capabilitiesFor?.(path, fsOptions) ?? fs.capabilities;
-                    return quotaCapabilities(retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)));
+                    return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)), ...(typeof fs.open === "function" ? {} : { open: false }) });
                 };
             if (property === "openReadFile")
                 return (path, fsOptions = {}) => openRetainedReadFile(fs, path, fsOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.652",
+  "version": "0.1.654",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",