@poe-platform/safe-fs 0.1.0

package/dist/safe-fs/fs/s3/transport.js

@@ -0,0 +1,28 @@
+export function createS3Transport(client, capabilities = {}) {
+    const transport = {
+        capabilities: Object.freeze({ ...capabilities }),
+        ...(client.getObjectStream ? { getObjectStream: (input, options) => client.getObjectStream(input, options) } : {}),
+        ...(client.putObjectStream ? { putObjectStream: (input, options) => client.putObjectStream(input, options) } : {}),
+        headObject: (input, options) => client.headObject(input, options),
+        getObject: (input, options) => client.getObject(input, options),
+        putObject: (input, options) => client.putObject(input, options),
+        deleteObject: (input, options) => client.deleteObject(input, options),
+        copyObject: (input, options) => client.copyObject(input, options),
+        listObjectsV2: (input, options) => client.listObjectsV2(input, options),
+    };
+    return transport;
+}
+export class S3ServiceError extends Error {
+    code;
+    $metadata;
+    constructor(code, status, message = code) {
+        super(message);
+        this.name = code;
+        this.code = code;
+        this.$metadata = { httpStatusCode: status };
+    }
+}
+export function encodeCopySource(bucket, key) {
+    return [bucket, ...key.split("/")].map((part) => encodeURIComponent(part)
+        .replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}

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

@@ -0,0 +1,2 @@
+export { WebDavFileSystem } from "./webdav.js";
+export type { WebDavFileSystemOptions, WebDavFetch, WebDavAtomicEmptyDirectoryBinding, WebDavAtomicEmptyDirectoryRequest, WebDavAtomicEmptyDirectoryResult, } from "./webdav.js";

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

@@ -0,0 +1 @@
+export { WebDavFileSystem } from "./webdav.js";

package/dist/safe-fs/fs/webdav/resource-id.d.ts

@@ -0,0 +1,18 @@
+import type { FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
+import type { EntryAuthority, EntryView } from "../mount/comparison.js";
+export interface OwnedWebDavEntry {
+    readonly storage: object;
+    readonly resource: object;
+}
+export interface OwnedWebDavResource extends OwnedWebDavEntry {
+    readonly identifier: string;
+}
+export declare function registerOwnedResourceResponse(response: Response, entries: ReadonlyMap<string, OwnedWebDavResource>): void;
+export declare function recordOwnedResourceStat(response: Response, filesystem: FileSystem, path: string, stat: FileStat): void;
+export declare function getOwnedWebDavEntry(view: EntryView): OwnedWebDavEntry | undefined;
+export declare function ownedResponseIdentifier(response: Response, path: string): string | undefined;
+type ResourceQuery = (path: string, options: FsOptions) => Promise<string | undefined>;
+export declare function registerResourceQuery(filesystem: FileSystem, query: ResourceQuery, baseComparison: NonNullable<FileSystem["compareEntry"]>, callback?: NonNullable<FileSystem["compareEntry"]>): void;
+export declare function resourceIdentifier(value: string): string;
+export declare const compareWebDavResources: EntryAuthority;
+export {};

package/dist/safe-fs/fs/webdav/resource-id.js

@@ -0,0 +1,109 @@
+import { FsError } from "../../contracts/errors.js";
+import { assertCallbackAuthorityAllowed } from "../mount/comparison.js";
+const responses = new WeakMap();
+const observations = new WeakMap();
+export function registerOwnedResourceResponse(response, entries) {
+    if (responses.has(response))
+        throw new TypeError("resource response already registered");
+    responses.set(response, new Map(entries));
+}
+export function recordOwnedResourceStat(response, filesystem, path, stat) {
+    const entry = responses.get(response)?.get(path);
+    if (entry)
+        observations.set(stat, { filesystem, path, entry });
+}
+export function getOwnedWebDavEntry(view) {
+    const observation = observations.get(view.stat);
+    return observation?.filesystem === view.filesystem && observation.path === view.path
+        ? observation.entry : undefined;
+}
+export function ownedResponseIdentifier(response, path) {
+    return responses.get(response)?.get(path)?.identifier;
+}
+const queries = new WeakMap();
+const comparisons = new WeakMap();
+const callbacks = new WeakMap();
+export function registerResourceQuery(filesystem, query, baseComparison, callback) {
+    comparisons.set(filesystem, baseComparison);
+    if (callback)
+        callbacks.set(filesystem, callback);
+    queries.set(filesystem, async (path, options) => {
+        options.signal?.throwIfAborted();
+        const identifier = await query(path, options);
+        options.signal?.throwIfAborted();
+        return identifier;
+    });
+}
+export function resourceIdentifier(value) {
+    if (!/^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"{}|\\^`]+$/.test(value) || /%(?![0-9A-Fa-f]{2})/.test(value)
+        || /[^\x21-\x7e]/.test(value))
+        throw new Error("invalid DAV:resource-id URI");
+    new URL(value);
+    if (/^urn:uuid:/i.test(value)) {
+        if (!/^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+            throw new Error("invalid DAV:resource-id UUID");
+        }
+        return value.toLowerCase();
+    }
+    return value;
+}
+export const compareWebDavResources = async (own, peer, options) => {
+    options.signal?.throwIfAborted();
+    let explicit = false;
+    let answer = "unknown";
+    const visited = new Set();
+    for (const [left, right] of [[own, peer], [peer, own]]) {
+        const baseComparison = comparisons.get(left.filesystem);
+        if (!baseComparison)
+            continue;
+        const method = left.filesystem.compareEntry;
+        const comparison = method === baseComparison ? callbacks.get(left.filesystem) : method;
+        if (method === baseComparison && !comparison)
+            continue;
+        explicit = true;
+        if (!comparison || visited.has(left.filesystem))
+            continue;
+        visited.add(left.filesystem);
+        options.signal?.throwIfAborted();
+        assertCallbackAuthorityAllowed();
+        const result = await comparison.call(left.filesystem, left.path, right.filesystem, right.path, options);
+        options.signal?.throwIfAborted();
+        if (result !== "same" && result !== "distinct" && result !== "unknown") {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit WebDAV comparison" });
+        }
+        if (result === "unknown")
+            continue;
+        if (answer !== "unknown" && answer !== result) {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit WebDAV comparisons" });
+        }
+        answer = result;
+    }
+    const builtin = await compareProtocolEntries(own, peer, options);
+    if (builtin === "same" && answer === "distinct") {
+        throw new FsError("EIO", { path: own.path, dest: peer.path, message: "explicit WebDAV comparison contradicts built-in identity" });
+    }
+    if (builtin === "same")
+        return "same";
+    return explicit ? answer : builtin;
+};
+async function compareProtocolEntries(own, peer, options) {
+    const left = getOwnedWebDavEntry(own);
+    const right = getOwnedWebDavEntry(peer);
+    const ownQuery = queries.get(own.filesystem);
+    const peerQuery = queries.get(peer.filesystem);
+    if (!ownQuery || !peerQuery)
+        return "unknown";
+    options.signal?.throwIfAborted();
+    const ownId = await ownQuery(own.path, options);
+    options.signal?.throwIfAborted();
+    const peerId = await peerQuery(peer.path, options);
+    options.signal?.throwIfAborted();
+    if (ownId === undefined || peerId === undefined)
+        return "unknown";
+    if (left && right) {
+        const same = left.storage === right.storage && left.resource === right.resource;
+        if (same !== (ownId === peerId))
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting owned and protocol WebDAV identities" });
+    }
+    return ownId === peerId ? "same" : "distinct";
+}

package/dist/safe-fs/fs/webdav/webdav.d.ts

@@ -0,0 +1,101 @@
+import type { PlatformComparisonCallback } from "#safe-fs-platform";
+import type { ByteSource } from "../../contracts/io.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
+export interface WebDavAtomicEmptyDirectoryRequest {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly signal?: AbortSignal;
+}
+export interface WebDavAtomicEmptyDirectoryResult {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly outcome: "removed";
+}
+export interface WebDavAtomicEmptyDirectoryBinding {
+    readonly namespaceUrl: string;
+    readonly removeEmptyDirectory: (request: WebDavAtomicEmptyDirectoryRequest) => Promise<WebDavAtomicEmptyDirectoryResult>;
+}
+export interface WebDavFileSystemOptions {
+    readonly baseUrl: string;
+    readonly fetch: WebDavFetch;
+    readonly requestStreamSupport?: "native" | boolean;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly maxResponseBytes?: number;
+    readonly maxXmlBytes?: number;
+    readonly maxEntries?: number;
+    readonly timeoutMs?: number;
+    readonly overwritePolicy?: "lock" | "etag";
+    readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
+    readonly compareEntry?: PlatformComparisonCallback<(this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>>;
+}
+export declare class WebDavFileSystem implements FileSystem {
+    readonly capabilities: Readonly<{
+        symlinks: false;
+        hardlinks: false;
+        permissions: false;
+        timestamps: true;
+        atomicRename: false;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly base;
+    private readonly baseSegments;
+    private readonly transport;
+    private readonly requestStreamSupport;
+    private readonly headers;
+    private readonly maxResponseBytes;
+    private readonly maxXmlBytes;
+    private readonly maxEntries;
+    private readonly timeoutMs;
+    private readonly overwritePolicy;
+    private readonly configuredComparison;
+    private readonly atomicEmptyDirectory;
+    private readonly etags;
+    constructor(options: WebDavFileSystemOptions);
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    private resourceId;
+    private url;
+    private hrefPath;
+    private httpError;
+    private request;
+    private requestStream;
+    private bytes;
+    private bodyChunks;
+    private xml;
+    private multistatus;
+    private lockFailure;
+    private entryStat;
+    private entries;
+    private mutation;
+    private unsupported;
+    private maybeStat;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    readStream(path: string, options?: ReadStreamOptions): AsyncGenerator<Uint8Array>;
+    private prepareWrite;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    private atomicRmdir;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    private guardTransferIdentity;
+    private transfer;
+    private withDestinationLock;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, _options?: FsOptions): Promise<string>;
+    symlink(_target: string, path: string, _options?: FsOptions): Promise<void>;
+    link(_source: string, path: string, _options?: FsOptions): Promise<void>;
+    chmod(path: string, _mode: number, _options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, _length?: number, _options?: FsOptions): Promise<void>;
+}