@bareblends/vsf-prismic/server/index.js

Prismic CMS integration with Vue Storefront

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var core = require('@vue-storefront/core');
var Prismic = require('@prismicio/client');
var tslib = require('tslib');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var Prismic__default = /*#__PURE__*/_interopDefaultLegacy(Prismic);

var transformQuery = function (query) {
    var predict = function (method, args) {
        var _a;
        return (_a = Prismic__default['default'].Predicates)[method].apply(_a, args);
    };
    var queryContainer = Array.isArray(query) ? query : [query];
    var queries = queryContainer.map(function (q) { return Object.keys(q).map(function (key) {
        var current = q[key];
        if (!Prismic__default['default'].Predicates[key]) {
            return undefined;
        }
        var fragment = current.fragment, after = current.after, before = current.before, day = current.day, documentId = current.documentId, hour = current.hour, latitude = current.latitude, longitude = current.longitude, maxResults = current.maxResults, month = current.month, radius = current.radius, value = current.value, values = current.values, year = current.year;
        switch (true) {
            case values !== undefined:
                return predict(key, [fragment, values]);
            case value !== undefined:
                return predict(key, [fragment, value]);
            case documentId !== undefined && maxResults !== undefined:
                return predict(key, [documentId, maxResults]);
            case before !== undefined && after !== undefined:
                return predict(key, [fragment, before, after]);
            case before !== undefined:
                return predict(key, [fragment, before]);
            case after !== undefined:
                return predict(key, [fragment, after]);
            case latitude !== undefined && longitude !== undefined && radius !== undefined:
                return predict(key, [fragment, latitude, longitude, radius]);
            case year !== undefined:
                return predict(key, [fragment, year]);
            case month !== undefined:
                return predict(key, [fragment, month]);
            case day !== undefined:
                return predict(key, [fragment, day]);
            case hour !== undefined:
                return predict(key, [fragment, hour]);
            default:
                return predict(key, [fragment]);
        }
    }); });
    var flatArray = [].concat.apply([], queries.filter(function (queryElement) { return queryElement !== undefined; }));
    return flatArray.length === 1 ? flatArray[0] : flatArray;
};

var getContent = function (_a, _b) {
    var client = _a.client, config = _a.config;
    var query = _b.query, queryOptions = _b.queryOptions;
    return tslib.__awaiter(void 0, void 0, void 0, function () {
        var apiOptions, endpoint, api, response, _c, results, metadata, error_1;
        return tslib.__generator(this, function (_d) {
            switch (_d.label) {
                case 0:
                    apiOptions = config.apiOptions, endpoint = config.endpoint;
                    return [4 /*yield*/, client.getApi(endpoint, apiOptions)];
                case 1:
                    api = _d.sent();
                    response = null;
                    _d.label = 2;
                case 2:
                    _d.trys.push([2, 4, , 5]);
                    return [4 /*yield*/, api.query(transformQuery(query), queryOptions)];
                case 3:
                    _c = _d.sent(), results = _c.results, metadata = tslib.__rest(_c, ["results"]);
                    response = { results: results, metadata: metadata };
                    return [3 /*break*/, 5];
                case 4:
                    error_1 = _d.sent();
                    core.Logger.error('Can\'t get data from Prismic.', error_1);
                    return [3 /*break*/, 5];
                case 5: return [2 /*return*/, response];
            }
        });
    });
};

var setup = function (_a) {
    var apiOptions = _a.apiOptions, endpoint = _a.endpoint;
    return {
        client: Prismic__default['default'].client(endpoint, apiOptions),
        config: {
            apiOptions: apiOptions,
            endpoint: endpoint
        }
    };
};
var createApiClient = core.apiClientFactory({
    onCreate: setup,
    api: {
        getContent: getContent
    }
}).createApiClient;

exports.createApiClient = createApiClient;
//# sourceMappingURL=index.js.map