semantic-network/lib/sync/pooledResource.js

A utility library for manipulating a list of links that form a semantic interface to a network of resources.

import { __awaiter } from "tslib";
import { LinkUtil } from 'semantic-link';
import anylogger from 'anylogger';
import { LinkRelation } from '../linkRelation';
import { PooledResourceUtil } from './pooledResourceUtil';
const log = anylogger('PooledResource');
const noopUndefined = () => __awaiter(void 0, void 0, void 0, function* () { return undefined; });
export class PooledResource {
    constructor(resource) {
        /**
         * Default resolves returns a noop undefined
         */
        this.defaultPooledResolver = () => noopUndefined;
        if (!resource) {
            log.error('empty resource for pooled resources');
        }
        log.debug('pooled resource on %s', LinkUtil.getUri(resource, LinkRelation.Self));
        this.contextResource = resource;
        log.debug('make resolvers on pooled resource');
        this.resolvers = this.makeResolvers();
    }
    get resourceResolver() {
        return this.pooledResource.bind(this);
    }
    /**
     *
     * @param rel known link relation of the resource resolved on the pooled resource context
     * @param options
     */
    resolve(rel, options) {
        // initialise on entry as resolver is not scoped on inner function
        const { pooledResolver } = Object.assign({}, options);
        log.debug('pooled resource resolve on \'%s\': start', rel);
        return (document, options) => __awaiter(this, void 0, void 0, function* () {
            log.debug('resolve pooled %s %s', rel, LinkUtil.getUri(document, LinkRelation.Self));
            if (this.contextResource) {
                const resource = yield PooledResourceUtil.sync(this.contextResource, document, Object.assign(Object.assign({}, options), { rel }));
                /*
                 * process nested sync
                 */
                if (resource) {
                    log.debug('pooled resource nested sync: %s', LinkUtil.getUri(resource, LinkRelation.Self));
                    pooledResolver === null || pooledResolver === void 0 ? void 0 : pooledResolver(resource, document, options);
                }
                else {
                    log.debug('pooled resource nested sync not found');
                }
                log.debug('pooled resource resolve on \'%s\': end', rel);
                return resource;
            }
            else {
                log.warn('context resource not found');
            }
        });
    }
    /**
     * Access back to the keyed resolver
     */
    pooledResource(type) {
        if (this.resolvers[type]) {
            log.debug('resolving resource pool type: %s', type);
            return this.resolvers[type];
        }
        else {
            log.debug('resolving resource pool type not found: %s', type);
            return noopUndefined;
        }
    }
}
//# sourceMappingURL=pooledResource.js.map