ketting/dist/client.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fetcher_1 = require("./http/fetcher");
const resource_1 = require("./resource");
const state_1 = require("./state");
const util_1 = require("./http/util");
const uri_1 = require("./util/uri");
const cache_1 = require("./cache");
const LinkHeader = require("http-link-header");
class Client {
    constructor(bookmarkUri) {
        /**
         * Supported content types
         *
         * Each content-type has a 'factory' that turns a HTTP response
         * into a State object.
         *
         * The last value in the array is the 'q=' value, used in Accept
         * headers. Higher means higher priority.
         */
        this.contentTypeMap = {
            'application/prs.hal-forms+json': [state_1.halStateFactory, '1.0'],
            'application/hal+json': [state_1.halStateFactory, '0.9'],
            'application/vnd.api+json': [state_1.jsonApiStateFactory, '0.8'],
            'application/vnd.siren+json': [state_1.sirenStateFactory, '0.8'],
            'application/vnd.collection+json': [state_1.cjStateFactory, '0.8'],
            'application/json': [state_1.halStateFactory, '0.7'],
            'text/html': [state_1.htmlStateFactory, '0.6'],
        };
        this.acceptHeader = (request, next) => {
            if (!request.headers.has('Accept')) {
                const acceptHeader = Object.entries(this.contentTypeMap).map(([contentType, [stateFactory, q]]) => contentType + ';q=' + q).join(', ');
                request.headers.set('Accept', acceptHeader);
            }
            return next(request);
        };
        this.cacheExpireHandler = async (request, next) => {
            /**
             * Prevent a 'stale' event from being emitted, but only for the main
             * uri
             */
            let noStaleEvent = false;
            if (request.headers.has('X-KETTING-NO-STALE')) {
                noStaleEvent = true;
                request.headers.delete('X-KETTING-NO-STALE');
            }
            const response = await next(request);
            if (util_1.isSafeMethod(request.method)) {
                return response;
            }
            if (!response.ok) {
                // There was an error, no cache changes
                return response;
            }
            // We just processed an unsafe method, lets notify all subsystems.
            const expireUris = [];
            if (!noStaleEvent && request.method !== 'DELETE') {
                // Sorry for the double negative
                expireUris.push(request.url);
            }
            // If the response had a Link: rel=invalidate header, we want to
            // expire those too.
            if (response.headers.has('Link')) {
                for (const httpLink of LinkHeader.parse(response.headers.get('Link')).rel('invalidates')) {
                    const uri = uri_1.resolve(request.url, httpLink.uri);
                    expireUris.push(uri);
                }
            }
            // Location headers should also expire
            if (response.headers.has('Location')) {
                expireUris.push(uri_1.resolve(request.url, response.headers.get('Location')));
            }
            // Content-Location headers should also expire
            if (response.headers.has('Content-Location')) {
                expireUris.push(uri_1.resolve(request.url, response.headers.get('Content-Location')));
            }
            for (const uri of expireUris) {
                this.cache.delete(request.url);
                const resource = this.resources.get(uri);
                if (resource) {
                    // We have a resource for this object, notify it as well.
                    resource.emit('stale');
                }
            }
            if (request.method === 'DELETE') {
                this.cache.delete(request.url);
                const resource = this.resources.get(request.url);
                if (resource) {
                    resource.emit('delete');
                }
            }
            return response;
        };
        this.bookmarkUri = bookmarkUri;
        this.fetcher = new fetcher_1.Fetcher();
        this.fetcher.use(this.cacheExpireHandler);
        this.fetcher.use(this.acceptHeader);
        this.cache = new cache_1.ForeverCache();
        this.resources = new Map();
    }
    /**
     * Follows a relationship, based on its reltype. For example, this might be
     * 'alternate', 'item', 'edit' or a custom url-based one.
     *
     * This function can also follow templated uris. You can specify uri
     * variables in the optional variables argument.
     */
    follow(rel, variables) {
        return this.go().follow(rel, variables);
    }
    /**
     * Returns a resource by its uri.
     *
     * This function doesn't do any HTTP requests. The uri is optional. If it's
     * not specified, it will return the bookmark resource.
     *
     * If a relative uri is passed, it will be resolved based on the bookmark
     * uri.
     *
     * @example
     * const res = ketting.go('https://example.org/);
     * @example
     * const res = ketting.go<Author>('/users/1');
     * @example
     * const res = ketting.go(); // bookmark
     */
    go(uri) {
        let absoluteUri;
        if (uri !== undefined) {
            absoluteUri = uri_1.resolve(this.bookmarkUri, uri);
        }
        else {
            absoluteUri = this.bookmarkUri;
        }
        if (!this.resources.has(absoluteUri)) {
            const resource = new resource_1.default(this, absoluteUri);
            this.resources.set(absoluteUri, resource);
            return resource;
        }
        return this.resources.get(absoluteUri);
    }
    /**
     * Adds a fetch middleware, which will be executed for
     * each fetch() call.
     *
     * If 'origin' is specified, fetch middlewares can be executed
     * only if the host/origin matches.
     */
    use(middleware, origin = '*') {
        this.fetcher.use(middleware, origin);
    }
    /**
     * Clears the entire state cache
     */
    clearCache() {
        this.cache.clear();
    }
    /**
     * Transforms a fetch Response to a State object.
     */
    async getStateForResponse(uri, response) {
        const contentType = util_1.parseContentType(response.headers.get('Content-Type'));
        let state;
        if (!contentType) {
            return state_1.binaryStateFactory(uri, response);
        }
        if (contentType in this.contentTypeMap) {
            state = await this.contentTypeMap[contentType][0](uri, response);
        }
        else if (contentType.startsWith('text/')) {
            // Default to TextState for any format starting with text/
            state = await state_1.textStateFactory(uri, response);
        }
        else if (contentType.match(/^application\/[A-Za-z-.]+\+json/)) {
            // Default to HalState for any format containing a pattern like application/*+json
            state = await state_1.halStateFactory(uri, response);
        }
        else {
            state = await state_1.binaryStateFactory(uri, response);
        }
        state.client = this;
        return state;
    }
    /**
     * Caches a State object
     *
     * This function will also emit 'update' events to resources, and store all
     * embedded states.
     */
    cacheState(state) {
        this.cache.store(state);
        const resource = this.resources.get(state.uri);
        if (resource) {
            // We have a resource for this object, notify it as well.
            resource.emit('update', state);
        }
        for (const embeddedState of state.getEmbedded()) {
            // Recursion. MADNESS
            this.cacheState(embeddedState);
        }
    }
}
exports.default = Client;
//# sourceMappingURL=client.js.map