@helia/verified-fetch 0.0.0-8a5bc6f

package/dist/src/utils/parse-resource.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedUrlStringResults } from './parse-url-string.js';
+import type { Resource } from '../index.js';
+import type { IPNS, IPNSRoutingEvents, ResolveDnsLinkProgressEvents, ResolveProgressEvents } from '@helia/ipns';
+import type { ComponentLogger } from '@libp2p/interface';
+import type { ProgressOptions } from 'progress-events';
+export interface ParseResourceComponents {
+    ipns: IPNS;
+    logger: ComponentLogger;
+}
+export interface ParseResourceOptions extends ProgressOptions<ResolveProgressEvents | IPNSRoutingEvents | ResolveDnsLinkProgressEvents> {
+}
+/**
+ * Handles the different use cases for the `resource` argument.
+ * The resource can represent an IPFS path, IPNS path, or CID.
+ * If the resource represents an IPNS path, we need to resolve it to a CID.
+ */
+export declare function parseResource(resource: Resource, { ipns, logger }: ParseResourceComponents, options?: ParseResourceOptions): Promise<ParsedUrlStringResults>;
+//# sourceMappingURL=parse-resource.d.ts.map

package/dist/src/utils/parse-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-resource.d.ts","sourceRoot":"","sources":["../../../src/utils/parse-resource.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAC/G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,eAAe,CAAC,qBAAqB,GAAG,iBAAiB,GAAG,4BAA4B,CAAC;CAEtI;AACD;;;;GAIG;AACH,wBAAsB,aAAa,CAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,uBAAuB,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAkBnK"}

package/dist/src/utils/parse-resource.js

@@ -0,0 +1,24 @@
+import { CID } from 'multiformats/cid';
+import { parseUrlString } from './parse-url-string.js';
+/**
+ * Handles the different use cases for the `resource` argument.
+ * The resource can represent an IPFS path, IPNS path, or CID.
+ * If the resource represents an IPNS path, we need to resolve it to a CID.
+ */
+export async function parseResource(resource, { ipns, logger }, options) {
+    if (typeof resource === 'string') {
+        return parseUrlString({ urlString: resource, ipns, logger }, { onProgress: options?.onProgress });
+    }
+    const cid = CID.asCID(resource);
+    if (cid != null) {
+        // an actual CID
+        return {
+            cid,
+            protocol: 'ipfs',
+            path: '',
+            query: {}
+        };
+    }
+    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${resource}`);
+}
+//# sourceMappingURL=parse-resource.js.map

package/dist/src/utils/parse-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-resource.js","sourceRoot":"","sources":["../../../src/utils/parse-resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAetD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAE,QAAkB,EAAE,EAAE,IAAI,EAAE,MAAM,EAA2B,EAAE,OAA8B;IAChI,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,cAAc,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAA;IACnG,CAAC;IAED,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAE/B,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,gBAAgB;QAChB,OAAO;YACL,GAAG;YACH,QAAQ,EAAE,MAAM;YAChB,IAAI,EAAE,EAAE;YACR,KAAK,EAAE,EAAE;SACV,CAAA;IACH,CAAC;IAED,MAAM,IAAI,SAAS,CAAC,yDAAyD,QAAQ,EAAE,CAAC,CAAA;AAC1F,CAAC"}

package/dist/src/utils/parse-url-string.d.ts

@@ -0,0 +1,26 @@
+import { CID } from 'multiformats/cid';
+import type { IPNS, IPNSRoutingEvents, ResolveDnsLinkProgressEvents, ResolveProgressEvents } from '@helia/ipns';
+import type { ComponentLogger } from '@libp2p/interface';
+import type { ProgressOptions } from 'progress-events';
+export interface ParseUrlStringInput {
+    urlString: string;
+    ipns: IPNS;
+    logger: ComponentLogger;
+}
+export interface ParseUrlStringOptions extends ProgressOptions<ResolveProgressEvents | IPNSRoutingEvents | ResolveDnsLinkProgressEvents> {
+}
+export interface ParsedUrlStringResults {
+    protocol: string;
+    path: string;
+    cid: CID;
+    query: Record<string, string>;
+}
+/**
+ * A function that parses ipfs:// and ipns:// URLs, returning an object with easily recognizable properties.
+ *
+ * After determining the protocol successfully, we process the cidOrPeerIdOrDnsLink:
+ * * If it's ipfs, it parses the CID or throws an Aggregate error
+ * * If it's ipns, it attempts to resolve the PeerId and then the DNSLink. If both fail, an Aggregate error is thrown.
+ */
+export declare function parseUrlString({ urlString, ipns, logger }: ParseUrlStringInput, options?: ParseUrlStringOptions): Promise<ParsedUrlStringResults>;
+//# sourceMappingURL=parse-url-string.d.ts.map

package/dist/src/utils/parse-url-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-url-string.d.ts","sourceRoot":"","sources":["../../../src/utils/parse-url-string.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAEtC,OAAO,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,qBAAqB,EAAiB,MAAM,aAAa,CAAA;AAC9H,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAItD,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,eAAe,CAAA;CACxB;AACD,MAAM,WAAW,qBAAsB,SAAQ,eAAe,CAAC,qBAAqB,GAAG,iBAAiB,GAAG,4BAA4B,CAAC;CAEvI;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;IACR,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AAID;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAwGxJ"}

package/dist/src/utils/parse-url-string.js

@@ -0,0 +1,109 @@
+import { peerIdFromString } from '@libp2p/peer-id';
+import { CID } from 'multiformats/cid';
+import { TLRU } from './tlru.js';
+const ipnsCache = new TLRU(1000);
+const URL_REGEX = /^(?<protocol>ip[fn]s):\/\/(?<cidOrPeerIdOrDnsLink>[^/$?]+)\/?(?<path>[^$?]*)\??(?<queryString>.*)$/;
+/**
+ * A function that parses ipfs:// and ipns:// URLs, returning an object with easily recognizable properties.
+ *
+ * After determining the protocol successfully, we process the cidOrPeerIdOrDnsLink:
+ * * If it's ipfs, it parses the CID or throws an Aggregate error
+ * * If it's ipns, it attempts to resolve the PeerId and then the DNSLink. If both fail, an Aggregate error is thrown.
+ */
+export async function parseUrlString({ urlString, ipns, logger }, options) {
+    const log = logger.forComponent('helia:verified-fetch:parse-url-string');
+    const match = urlString.match(URL_REGEX);
+    if (match == null || match.groups == null) {
+        throw new TypeError(`Invalid URL: ${urlString}, please use ipfs:// or ipns:// URLs only.`);
+    }
+    const { protocol, cidOrPeerIdOrDnsLink, path: urlPath, queryString } = match.groups;
+    let cid;
+    let resolvedPath;
+    const errors = [];
+    if (protocol === 'ipfs') {
+        try {
+            cid = CID.parse(cidOrPeerIdOrDnsLink);
+        }
+        catch (err) {
+            log.error(err);
+            errors.push(new TypeError('Invalid CID for ipfs://<cid> URL'));
+        }
+    }
+    else {
+        let resolveResult = ipnsCache.get(cidOrPeerIdOrDnsLink);
+        if (resolveResult != null) {
+            cid = resolveResult.cid;
+            resolvedPath = resolveResult.path;
+            log.trace('resolved %s to %c from cache', cidOrPeerIdOrDnsLink, cid);
+        }
+        else {
+            // protocol is ipns
+            log.trace('Attempting to resolve PeerId for %s', cidOrPeerIdOrDnsLink);
+            let peerId = null;
+            try {
+                peerId = peerIdFromString(cidOrPeerIdOrDnsLink);
+                resolveResult = await ipns.resolve(peerId, { onProgress: options?.onProgress });
+                cid = resolveResult?.cid;
+                resolvedPath = resolveResult?.path;
+                log.trace('resolved %s to %c', cidOrPeerIdOrDnsLink, cid);
+                ipnsCache.set(cidOrPeerIdOrDnsLink, resolveResult, 60 * 1000 * 2);
+            }
+            catch (err) {
+                if (peerId == null) {
+                    log.error('Could not parse PeerId string "%s"', cidOrPeerIdOrDnsLink, err);
+                    errors.push(new TypeError(`Could not parse PeerId in ipns url "${cidOrPeerIdOrDnsLink}", ${err.message}`));
+                }
+                else {
+                    log.error('Could not resolve PeerId %c', peerId, err);
+                    errors.push(new TypeError(`Could not resolve PeerId "${cidOrPeerIdOrDnsLink}", ${err.message}`));
+                }
+            }
+            if (cid == null) {
+                log.trace('Attempting to resolve DNSLink for %s', cidOrPeerIdOrDnsLink);
+                try {
+                    resolveResult = await ipns.resolveDns(cidOrPeerIdOrDnsLink, { onProgress: options?.onProgress });
+                    cid = resolveResult?.cid;
+                    resolvedPath = resolveResult?.path;
+                    log.trace('resolved %s to %c', cidOrPeerIdOrDnsLink, cid);
+                    ipnsCache.set(cidOrPeerIdOrDnsLink, resolveResult, 60 * 1000 * 2);
+                }
+                catch (err) {
+                    log.error('Could not resolve DnsLink for "%s"', cidOrPeerIdOrDnsLink, err);
+                    errors.push(err);
+                }
+            }
+        }
+    }
+    if (cid == null) {
+        throw new AggregateError(errors, `Invalid resource. Cannot determine CID from URL "${urlString}"`);
+    }
+    // parse query string
+    const query = {};
+    if (queryString != null && queryString.length > 0) {
+        const queryParts = queryString.split('&');
+        for (const part of queryParts) {
+            const [key, value] = part.split('=');
+            query[key] = decodeURIComponent(value);
+        }
+    }
+    /**
+     * join the path from resolve result & given path.
+     * e.g. /ipns/<peerId>/ that is resolved to /ipfs/<cid>/<path1>, when requested as /ipns/<peerId>/<path2>, should be
+     * resolved to /ipfs/<cid>/<path1>/<path2>
+     */
+    const pathParts = [];
+    if (urlPath.length > 0) {
+        pathParts.push(urlPath);
+    }
+    if (resolvedPath != null && resolvedPath.length > 0) {
+        pathParts.push(resolvedPath);
+    }
+    const path = pathParts.join('/');
+    return {
+        protocol,
+        cid,
+        path,
+        query
+    };
+}
+//# sourceMappingURL=parse-url-string.js.map

package/dist/src/utils/parse-url-string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-url-string.js","sourceRoot":"","sources":["../../../src/utils/parse-url-string.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/tlru.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Time Aware Least Recent Used Cache
+ *
+ * @see https://arxiv.org/pdf/1801.00390
+ */
+export declare class TLRU<T> {
+    private readonly lru;
+    constructor(maxSize: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttl: number): void;
+    has(key: string): boolean;
+    remove(key: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=tlru.d.ts.map

package/dist/src/utils/tlru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tlru.d.ts","sourceRoot":"","sources":["../../../src/utils/tlru.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qBAAa,IAAI,CAAC,CAAC;IACjB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA4B;gBAEnC,OAAO,EAAE,MAAM;IAI5B,GAAG,CAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAgBhC,GAAG,CAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAI9C,GAAG,CAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAU1B,MAAM,CAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAI1B,KAAK,IAAK,IAAI;CAGf"}

package/dist/src/utils/tlru.js

@@ -0,0 +1,40 @@
+import hashlru from 'hashlru';
+/**
+ * Time Aware Least Recent Used Cache
+ *
+ * @see https://arxiv.org/pdf/1801.00390
+ */
+export class TLRU {
+    lru;
+    constructor(maxSize) {
+        this.lru = hashlru(maxSize);
+    }
+    get(key) {
+        const value = this.lru.get(key);
+        if (value != null) {
+            if (value.expire != null && value.expire < Date.now()) {
+                this.lru.remove(key);
+                return undefined;
+            }
+            return value.value;
+        }
+        return undefined;
+    }
+    set(key, value, ttl) {
+        this.lru.set(key, { value, expire: Date.now() + ttl });
+    }
+    has(key) {
+        const value = this.get(key);
+        if (value != null) {
+            return true;
+        }
+        return false;
+    }
+    remove(key) {
+        this.lru.remove(key);
+    }
+    clear() {
+        this.lru.clear();
+    }
+}
+//# sourceMappingURL=tlru.js.map

package/dist/src/utils/tlru.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tlru.js","sourceRoot":"","sources":["../../../src/utils/tlru.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B;;;;GAIG;AACH,MAAM,OAAO,IAAI;IACE,GAAG,CAA4B;IAEhD,YAAa,OAAe;QAC1B,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC7B,CAAC;IAED,GAAG,CAAE,GAAW;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAE/B,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;gBACtD,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAEpB,OAAO,SAAS,CAAA;YAClB,CAAC;YAED,OAAO,KAAK,CAAC,KAAK,CAAA;QACpB,CAAC;QAED,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,GAAG,CAAE,GAAW,EAAE,KAAQ,EAAE,GAAW;QACrC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC,CAAA;IACxD,CAAC;IAED,GAAG,CAAE,GAAW;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAE3B,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,CAAE,GAAW;QACjB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAA;IAClB,CAAC;CACF"}

package/dist/src/utils/walk-path.d.ts

@@ -0,0 +1,13 @@
+import { type ExporterOptions, type ReadableStorage, type UnixFSEntry } from 'ipfs-unixfs-exporter';
+import type { CID } from 'multiformats/cid';
+export interface PathWalkerOptions extends ExporterOptions {
+}
+export interface PathWalkerResponse {
+    ipfsRoots: CID[];
+    terminalElement: UnixFSEntry;
+}
+export interface PathWalkerFn {
+    (blockstore: ReadableStorage, path: string, options?: PathWalkerOptions): Promise<PathWalkerResponse>;
+}
+export declare function walkPath(blockstore: ReadableStorage, path: string, options?: PathWalkerOptions): Promise<PathWalkerResponse>;
+//# sourceMappingURL=walk-path.d.ts.map

package/dist/src/utils/walk-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk-path.d.ts","sourceRoot":"","sources":["../../../src/utils/walk-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAC7H,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAE3C,MAAM,WAAW,iBAAkB,SAAQ,eAAe;CAEzD;AACD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,GAAG,EAAE,CAAA;IAChB,eAAe,EAAE,WAAW,CAAA;CAE7B;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;CACtG;AAED,wBAAsB,QAAQ,CAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAiBnI"}

package/dist/src/utils/walk-path.js

@@ -0,0 +1,17 @@
+import { walkPath as exporterWalk } from 'ipfs-unixfs-exporter';
+export async function walkPath(blockstore, path, options) {
+    const ipfsRoots = [];
+    let terminalElement;
+    for await (const entry of exporterWalk(path, blockstore, options)) {
+        ipfsRoots.push(entry.cid);
+        terminalElement = entry;
+    }
+    if (terminalElement == null) {
+        throw new Error('No terminal element found');
+    }
+    return {
+        ipfsRoots,
+        terminalElement
+    };
+}
+//# sourceMappingURL=walk-path.js.map

package/dist/src/utils/walk-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk-path.js","sourceRoot":"","sources":["../../../src/utils/walk-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,YAAY,EAAgE,MAAM,sBAAsB,CAAA;AAgB7H,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAE,UAA2B,EAAE,IAAY,EAAE,OAA2B;IACpG,MAAM,SAAS,GAAU,EAAE,CAAA;IAC3B,IAAI,eAAwC,CAAA;IAE5C,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC;QAClE,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACzB,eAAe,GAAG,KAAK,CAAA;IACzB,CAAC;IAED,IAAI,eAAe,IAAI,IAAI,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC9C,CAAC;IAED,OAAO;QACL,SAAS;QACT,eAAe;KAChB,CAAA;AACH,CAAC"}

package/dist/src/verified-fetch.d.ts

@@ -0,0 +1,64 @@
+import { type DAGCBOR } from '@helia/dag-cbor';
+import { type DAGJSON } from '@helia/dag-json';
+import { type IPNS } from '@helia/ipns';
+import { type JSON } from '@helia/json';
+import { type UnixFS as HeliaUnixFs } from '@helia/unixfs';
+import { type PathWalkerFn } from './utils/walk-path.js';
+import type { Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js';
+import type { Helia } from '@helia/interface';
+interface VerifiedFetchComponents {
+    helia: Helia;
+    ipns?: IPNS;
+    unixfs?: HeliaUnixFs;
+    dagJson?: DAGJSON;
+    json?: JSON;
+    dagCbor?: DAGCBOR;
+    pathWalker?: PathWalkerFn;
+}
+/**
+ * Potential future options for the VerifiedFetch constructor.
+ */
+interface VerifiedFetchInit {
+}
+export declare class VerifiedFetch {
+    private readonly helia;
+    private readonly ipns;
+    private readonly unixfs;
+    private readonly dagJson;
+    private readonly dagCbor;
+    private readonly json;
+    private readonly pathWalker;
+    private readonly log;
+    constructor({ helia, ipns, unixfs, dagJson, json, dagCbor, pathWalker }: VerifiedFetchComponents, init?: VerifiedFetchInit);
+    private handleIPNSRecord;
+    private handleIPLDCar;
+    private handleDagJson;
+    private handleJson;
+    private handleDagCbor;
+    private handleDagPb;
+    private handleRaw;
+    /**
+     * Determines the format requested by the client, defaults to `null` if no format is requested.
+     *
+     * @see https://specs.ipfs.tech/http-gateways/path-gateway/#format-request-query-parameter
+     * @default 'raw'
+     */
+    private getFormat;
+    /**
+     * Map of format to specific handlers for that format.
+     * These format handlers should adjust the response headers as specified in https://specs.ipfs.tech/http-gateways/path-gateway/#response-headers
+     */
+    private readonly formatHandlers;
+    private readonly codecHandlers;
+    fetch(resource: Resource, opts?: VerifiedFetchOptions): Promise<Response>;
+    /**
+     * Start the Helia instance
+     */
+    start(): Promise<void>;
+    /**
+     * Shut down the Helia instance
+     */
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=verified-fetch.d.ts.map

package/dist/src/verified-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verified-fetch.d.ts","sourceRoot":"","sources":["../../src/verified-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACvE,OAAO,EAA2B,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACvE,OAAO,EAAqB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAA;AAE1D,OAAO,EAAqB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,EAAyB,KAAK,MAAM,IAAI,WAAW,EAAoB,MAAM,eAAe,CAAA;AASnG,OAAO,EAAY,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAa,QAAQ,EAAE,iBAAiB,IAAI,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAChG,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAK7C,UAAU,uBAAuB;IAC/B,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;GAEG;AAEH,UAAU,iBAAiB;CAE1B;AA4BD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAO;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAc;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;gBAEf,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,uBAAuB,EAAE,IAAI,CAAC,EAAE,iBAAiB;YAkB7G,gBAAgB;YAOhB,aAAa;YAMb,aAAa;YAab,UAAU;YAaV,aAAa;YAab,WAAW;YA6CX,SAAS;IAUvB;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAyBjB;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAS9B;IAED,OAAO,CAAC,QAAQ,CAAC,aAAa,CAM7B;IAEK,KAAK,CAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuDhF;;OAEG;IACG,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;IAI7B;;OAEG;IACG,IAAI,IAAK,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/src/verified-fetch.js

@@ -0,0 +1,261 @@
+import { dagCbor as heliaDagCbor } from '@helia/dag-cbor';
+import { dagJson as heliaDagJson } from '@helia/dag-json';
+import { ipns as heliaIpns } from '@helia/ipns';
+import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers';
+import { json as heliaJson } from '@helia/json';
+import { unixfs as heliaUnixFs } from '@helia/unixfs';
+import { code as dagCborCode } from '@ipld/dag-cbor';
+import { code as dagJsonCode } from '@ipld/dag-json';
+import { code as dagPbCode } from '@ipld/dag-pb';
+import { code as jsonCode } from 'multiformats/codecs/json';
+import { decode, code as rawCode } from 'multiformats/codecs/raw';
+import { CustomProgressEvent } from 'progress-events';
+import { getStreamAndContentType } from './utils/get-stream-and-content-type.js';
+import { parseResource } from './utils/parse-resource.js';
+import { walkPath } from './utils/walk-path.js';
+function convertOptions(options) {
+    if (options == null) {
+        return undefined;
+    }
+    let signal;
+    if (options?.signal === null) {
+        signal = undefined;
+    }
+    return {
+        ...options,
+        signal
+    };
+}
+export class VerifiedFetch {
+    helia;
+    ipns;
+    unixfs;
+    dagJson;
+    dagCbor;
+    json;
+    pathWalker;
+    log;
+    constructor({ helia, ipns, unixfs, dagJson, json, dagCbor, pathWalker }, init) {
+        this.helia = helia;
+        this.log = helia.logger.forComponent('helia:verified-fetch');
+        this.ipns = ipns ?? heliaIpns(helia, {
+            resolvers: [
+                dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query'),
+                dnsJsonOverHttps('https://dns.google/resolve')
+            ]
+        });
+        this.unixfs = unixfs ?? heliaUnixFs(helia);
+        this.dagJson = dagJson ?? heliaDagJson(helia);
+        this.json = json ?? heliaJson(helia);
+        this.dagCbor = dagCbor ?? heliaDagCbor(helia);
+        this.pathWalker = pathWalker ?? walkPath;
+        this.log.trace('created VerifiedFetch instance');
+    }
+    // handle vnd.ipfs.ipns-record
+    async handleIPNSRecord({ cid, path, options }) {
+        const response = new Response('vnd.ipfs.ipns-record support is not implemented', { status: 501 });
+        response.headers.set('X-Content-Type-Options', 'nosniff'); // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
+        return response;
+    }
+    // handle vnd.ipld.car
+    async handleIPLDCar({ cid, path, options }) {
+        const response = new Response('vnd.ipld.car support is not implemented', { status: 501 });
+        response.headers.set('X-Content-Type-Options', 'nosniff'); // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
+        return response;
+    }
+    async handleDagJson({ cid, path, options }) {
+        this.log.trace('fetching %c/%s', cid, path);
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: cid.toString(), path }));
+        const result = await this.dagJson.get(cid, {
+            signal: options?.signal,
+            onProgress: options?.onProgress
+        });
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: cid.toString(), path }));
+        const response = new Response(JSON.stringify(result), { status: 200 });
+        response.headers.set('content-type', 'application/json');
+        return response;
+    }
+    async handleJson({ cid, path, options }) {
+        this.log.trace('fetching %c/%s', cid, path);
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: cid.toString(), path }));
+        const result = await this.json.get(cid, {
+            signal: options?.signal,
+            onProgress: options?.onProgress
+        });
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: cid.toString(), path }));
+        const response = new Response(JSON.stringify(result), { status: 200 });
+        response.headers.set('content-type', 'application/json');
+        return response;
+    }
+    async handleDagCbor({ cid, path, options }) {
+        this.log.trace('fetching %c/%s', cid, path);
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: cid.toString(), path }));
+        const result = await this.dagCbor.get(cid, {
+            signal: options?.signal,
+            onProgress: options?.onProgress
+        });
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: cid.toString(), path }));
+        const response = new Response(JSON.stringify(result), { status: 200 });
+        response.headers.set('content-type', 'application/json');
+        return response;
+    }
+    async handleDagPb({ cid, path, options, terminalElement }) {
+        this.log.trace('fetching %c/%s', cid, path);
+        let resolvedCID = terminalElement?.cid ?? cid;
+        let stat;
+        if (terminalElement?.type === 'directory') {
+            const dirCid = terminalElement.cid;
+            const rootFilePath = 'index.html';
+            try {
+                this.log.trace('found directory at %c/%s, looking for index.html', cid, path);
+                options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: dirCid.toString(), path: rootFilePath }));
+                stat = await this.unixfs.stat(dirCid, {
+                    path: rootFilePath,
+                    signal: options?.signal,
+                    onProgress: options?.onProgress
+                });
+                this.log.trace('found root file at %c/%s with cid %c', dirCid, rootFilePath, stat.cid);
+                path = rootFilePath;
+                resolvedCID = stat.cid;
+                // terminalElement = stat
+            }
+            catch (err) {
+                this.log('error loading path %c/%s', dirCid, rootFilePath, err);
+                return new Response('Unable to find index.html for directory at given path. Support for directories with implicit root is not implemented', { status: 501 });
+            }
+            finally {
+                options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: dirCid.toString(), path: rootFilePath }));
+            }
+        }
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: resolvedCID.toString(), path: '' }));
+        const asyncIter = this.unixfs.cat(resolvedCID, {
+            signal: options?.signal,
+            onProgress: options?.onProgress
+        });
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: resolvedCID.toString(), path: '' }));
+        this.log('got async iterator for %c/%s', cid, path);
+        const { contentType, stream } = await getStreamAndContentType(asyncIter, path ?? '', this.helia.logger, {
+            onProgress: options?.onProgress
+        });
+        const response = new Response(stream, { status: 200 });
+        response.headers.set('content-type', contentType);
+        return response;
+    }
+    async handleRaw({ cid, path, options }) {
+        this.log.trace('fetching %c/%s', cid, path);
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:start', { cid: cid.toString(), path }));
+        const result = await this.helia.blockstore.get(cid);
+        options?.onProgress?.(new CustomProgressEvent('verified-fetch:request:end', { cid: cid.toString(), path }));
+        const response = new Response(decode(result), { status: 200 });
+        response.headers.set('content-type', 'application/octet-stream');
+        return response;
+    }
+    /**
+     * Determines the format requested by the client, defaults to `null` if no format is requested.
+     *
+     * @see https://specs.ipfs.tech/http-gateways/path-gateway/#format-request-query-parameter
+     * @default 'raw'
+     */
+    getFormat({ headerFormat, queryFormat }) {
+        const formatMap = {
+            'vnd.ipld.raw': 'raw',
+            'vnd.ipld.car': 'car',
+            'application/x-tar': 'tar',
+            'application/vnd.ipld.dag-json': 'dag-json',
+            'application/vnd.ipld.dag-cbor': 'dag-cbor',
+            'application/json': 'json',
+            'application/cbor': 'cbor',
+            'vnd.ipfs.ipns-record': 'ipns-record'
+        };
+        if (headerFormat != null) {
+            for (const format in formatMap) {
+                if (headerFormat.includes(format)) {
+                    return formatMap[format];
+                }
+            }
+        }
+        else if (queryFormat != null) {
+            return queryFormat;
+        }
+        return null;
+    }
+    /**
+     * Map of format to specific handlers for that format.
+     * These format handlers should adjust the response headers as specified in https://specs.ipfs.tech/http-gateways/path-gateway/#response-headers
+     */
+    formatHandlers = {
+        raw: async () => new Response('application/vnd.ipld.raw support is not implemented', { status: 501 }),
+        car: this.handleIPLDCar,
+        'ipns-record': this.handleIPNSRecord,
+        tar: async () => new Response('application/x-tar support is not implemented', { status: 501 }),
+        'dag-json': async () => new Response('application/vnd.ipld.dag-json support is not implemented', { status: 501 }),
+        'dag-cbor': async () => new Response('application/vnd.ipld.dag-cbor support is not implemented', { status: 501 }),
+        json: async () => new Response('application/json support is not implemented', { status: 501 }),
+        cbor: async () => new Response('application/cbor support is not implemented', { status: 501 })
+    };
+    codecHandlers = {
+        [dagJsonCode]: this.handleDagJson,
+        [dagPbCode]: this.handleDagPb,
+        [jsonCode]: this.handleJson,
+        [dagCborCode]: this.handleDagCbor,
+        [rawCode]: this.handleRaw
+    };
+    async fetch(resource, opts) {
+        const options = convertOptions(opts);
+        const { path, query, ...rest } = await parseResource(resource, { ipns: this.ipns, logger: this.helia.logger }, options);
+        const cid = rest.cid;
+        let response;
+        const format = this.getFormat({ headerFormat: new Headers(options?.headers).get('accept'), queryFormat: query.format ?? null });
+        if (format != null) {
+            // TODO: These should be handled last when they're returning something other than 501
+            const formatHandler = this.formatHandlers[format];
+            if (formatHandler != null) {
+                response = await formatHandler.call(this, { cid, path, options });
+                if (response.status === 501) {
+                    return response;
+                }
+            }
+        }
+        let terminalElement;
+        let ipfsRoots;
+        try {
+            const pathDetails = await this.pathWalker(this.helia.blockstore, `${cid.toString()}/${path}`, options);
+            ipfsRoots = pathDetails.ipfsRoots;
+            terminalElement = pathDetails.terminalElement;
+        }
+        catch (err) {
+            this.log.error('Error walking path %s', path, err);
+            // return new Response(`Error walking path: ${(err as Error).message}`, { status: 500 })
+        }
+        if (response == null) {
+            const codecHandler = this.codecHandlers[cid.code];
+            if (codecHandler != null) {
+                response = await codecHandler.call(this, { cid, path, options, terminalElement });
+            }
+            else {
+                return new Response(`Support for codec with code ${cid.code} is not yet implemented. Please open an issue at https://github.com/ipfs/helia/issues/new`, { status: 501 });
+            }
+        }
+        response.headers.set('etag', cid.toString()); // https://specs.ipfs.tech/http-gateways/path-gateway/#etag-response-header
+        response.headers.set('cache-cotrol', 'public, max-age=29030400, immutable');
+        response.headers.set('X-Ipfs-Path', resource.toString()); // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-path-response-header
+        if (ipfsRoots != null) {
+            response.headers.set('X-Ipfs-Roots', ipfsRoots.map(cid => cid.toV1().toString()).join(',')); // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-roots-response-header
+        }
+        // response.headers.set('Content-Disposition', `TODO`) // https://specs.ipfs.tech/http-gateways/path-gateway/#content-disposition-response-header
+        return response;
+    }
+    /**
+     * Start the Helia instance
+     */
+    async start() {
+        await this.helia.start();
+    }
+    /**
+     * Shut down the Helia instance
+     */
+    async stop() {
+        await this.helia.stop();
+    }
+}
+//# sourceMappingURL=verified-fetch.js.map