@depup/contentful 11.10.7-depup.0

package/dist/esm/paged-sync.js

@@ -0,0 +1,118 @@
+import resolveResponse from 'contentful-resolve-response';
+import { freezeSys, toPlainObject, createRequestConfig } from 'contentful-sdk-core';
+import mixinStringifySafe from './mixins/stringify-safe.js';
+
+/**
+ * Retrieves all the available pages for a sync operation
+ */
+async function pagedSync(http, query, options) {
+    if (!query || (!query.initial && !query.nextSyncToken && !query.nextPageToken)) {
+        throw new Error('Please provide one of `initial`, `nextSyncToken` or `nextPageToken` parameters for syncing');
+    }
+    if (query['content_type'] && !query.type) {
+        query.type = 'Entry';
+    }
+    else if (query['content_type'] && query.type && query.type !== 'Entry') {
+        throw new Error('When using the `content_type` filter your `type` parameter cannot be different from `Entry`.');
+    }
+    const defaultOptions = {
+        withoutLinkResolution: false,
+        withoutUnresolvableLinks: false,
+        paginate: true,
+    };
+    const { withoutLinkResolution, withoutUnresolvableLinks, paginate } = Object.assign(Object.assign({}, defaultOptions), options);
+    const response = await getSyncPage(http, [], query, { paginate });
+    // clones response.items used in includes because we don't want these to be mutated
+    if (!withoutLinkResolution) {
+        response.items = resolveResponse(response, {
+            removeUnresolved: withoutUnresolvableLinks,
+            itemEntryPoints: ['fields'],
+        });
+    }
+    // maps response items again after getters are attached
+    const mappedResponseItems = mapResponseItems(response.items);
+    if (response.nextSyncToken) {
+        mappedResponseItems.nextSyncToken = response.nextSyncToken;
+    }
+    if (response.nextPageToken) {
+        mappedResponseItems.nextPageToken = response.nextPageToken;
+    }
+    return freezeSys(mixinStringifySafe(toPlainObject(mappedResponseItems)));
+}
+/**
+ * @private
+ * @param items
+ * @returns Entities mapped to an object for each entity type
+ */
+function mapResponseItems(items) {
+    const reducer = (type) => {
+        return (accumulated, item) => {
+            if (item.sys.type === type) {
+                accumulated.push(toPlainObject(item));
+            }
+            return accumulated;
+        };
+    };
+    return {
+        entries: items.reduce(reducer('Entry'), []),
+        assets: items.reduce(reducer('Asset'), []),
+        deletedEntries: items.reduce(reducer('DeletedEntry'), []),
+        deletedAssets: items.reduce(reducer('DeletedAsset'), []),
+    };
+}
+function createRequestQuery(originalQuery) {
+    if (originalQuery.nextPageToken) {
+        return { sync_token: originalQuery.nextPageToken };
+    }
+    if (originalQuery.nextSyncToken) {
+        return { sync_token: originalQuery.nextSyncToken };
+    }
+    if (originalQuery.sync_token) {
+        return { sync_token: originalQuery.sync_token };
+    }
+    return originalQuery;
+}
+/**
+ * If the response contains a nextPageUrl, extracts the sync token to get the
+ * next page and calls itself again with that token.
+ * Otherwise, if the response contains a nextSyncUrl, extracts the sync token
+ * and returns it.
+ * On each call of this function, any retrieved items are collected in the
+ * supplied items array, which gets returned in the end.
+ */
+async function getSyncPage(http, items, query, { paginate }) {
+    const requestQuery = createRequestQuery(query);
+    const response = await http.get('sync', createRequestConfig({ query: requestQuery }));
+    const data = response.data || {};
+    items = items.concat(data.items || []);
+    if (data.nextPageUrl) {
+        if (paginate) {
+            delete requestQuery.initial;
+            requestQuery.sync_token = getToken(data.nextPageUrl);
+            return getSyncPage(http, items, requestQuery, { paginate });
+        }
+        return {
+            items,
+            nextPageToken: getToken(data.nextPageUrl),
+        };
+    }
+    else if (data.nextSyncUrl) {
+        return {
+            items,
+            nextSyncToken: getToken(data.nextSyncUrl),
+        };
+    }
+    else {
+        return { items: [] };
+    }
+}
+/**
+ * Extracts token out of an url
+ * @private
+ */
+function getToken(url) {
+    const urlParts = url.split('?');
+    return urlParts.length > 0 ? urlParts[1].replace('sync_token=', '') : '';
+}
+
+export { pagedSync as default };

package/dist/esm/utils/normalize-cursor-pagination-parameters.js

@@ -0,0 +1,9 @@
+import { __rest } from 'tslib';
+
+function normalizeCursorPaginationParameters(query) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { cursor, pagePrev, pageNext, skip } = query, rest = __rest(query, ["cursor", "pagePrev", "pageNext", "skip"]);
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, rest), { cursor: true }), (!!pagePrev && { pagePrev })), (!!pageNext && { pageNext }));
+}
+
+export { normalizeCursorPaginationParameters };

package/dist/esm/utils/normalize-cursor-pagination-response.js

@@ -0,0 +1,23 @@
+function extractQueryParam(key, url) {
+    const queryString = url === null || url === void 0 ? void 0 : url.split('?')[1];
+    if (!queryString) {
+        return;
+    }
+    return new URLSearchParams(queryString).get(key);
+}
+const Pages = {
+    prev: 'pagePrev',
+    next: 'pageNext',
+};
+function normalizeCursorPaginationResponse(response) {
+    const pages = {};
+    for (const [responseKey, queryKey] of Object.entries(Pages)) {
+        const cursorToken = extractQueryParam(queryKey, response.pages[responseKey]);
+        if (cursorToken) {
+            pages[responseKey] = cursorToken;
+        }
+    }
+    return Object.assign(Object.assign({}, response), { pages });
+}
+
+export { normalizeCursorPaginationResponse };

package/dist/esm/utils/normalize-search-parameters.js

@@ -0,0 +1,18 @@
+function normalizeSearchParameters(query) {
+    const convertedQuery = {};
+    let hasConverted = false;
+    for (const key in query) {
+        // We allow multiple values to be passed as arrays
+        // which have to be converted to comma-separated strings before being sent to the API
+        if (Array.isArray(query[key])) {
+            convertedQuery[key] = query[key].join(',');
+            hasConverted = true;
+        }
+    }
+    if (hasConverted) {
+        return Object.assign(Object.assign({}, query), convertedQuery);
+    }
+    return query;
+}
+
+export { normalizeSearchParameters as default };

package/dist/esm/utils/normalize-select.js

@@ -0,0 +1,25 @@
+import getQuerySelectionSet from './query-selection-set.js';
+
+/*
+ * sdk relies heavily on sys metadata
+ * so we cannot omit the sys property on sdk level entirely
+ * and we have to ensure that at least `id` and `type` are present
+ * */
+function normalizeSelect(query) {
+    if (!query.select) {
+        return query;
+    }
+    const selectedSet = getQuerySelectionSet(query);
+    // If we already select all of `sys` we can just return
+    // since we're anyway fetching everything that is needed
+    if (selectedSet.has('sys')) {
+        return query;
+    }
+    // We don't select `sys` so we need to ensure the minimum set
+    selectedSet.add('sys.id');
+    selectedSet.add('sys.type');
+    // Reassign the normalized sys properties
+    return Object.assign(Object.assign({}, query), { select: [...selectedSet].join(',') });
+}
+
+export { normalizeSelect as default };

package/dist/esm/utils/query-selection-set.js

@@ -0,0 +1,14 @@
+function getQuerySelectionSet(query) {
+    if (!query.select) {
+        return new Set();
+    }
+    // The selection of fields for the query is limited
+    // Get the different parts that are listed for selection
+    const allSelects = Array.isArray(query.select)
+        ? query.select
+        : query.select.split(',').map((q) => q.trim());
+    // Move the parts into a set for easy access and deduplication
+    return new Set(allSelects);
+}
+
+export { getQuerySelectionSet as default };

package/dist/esm/utils/resolve-circular.js

@@ -0,0 +1,15 @@
+import resolveResponse from 'contentful-resolve-response';
+import mixinStringifySafe from '../mixins/stringify-safe.js';
+
+function resolveCircular(data, { resolveLinks, removeUnresolved }) {
+    const wrappedData = mixinStringifySafe(data);
+    if (resolveLinks) {
+        wrappedData.items = resolveResponse(wrappedData, {
+            removeUnresolved,
+            itemEntryPoints: ['fields'],
+        });
+    }
+    return wrappedData;
+}
+
+export { resolveCircular as default };

package/dist/esm/utils/timeline-preview-helpers.js

@@ -0,0 +1,33 @@
+import { checkEnableTimelinePreviewIsAllowed } from './validate-params.js';
+import { ValidationError } from './validation-error.js';
+
+function isValidRelease(release) {
+    return !!(release && typeof release === 'object' && typeof release.lte === 'string');
+}
+function isValidTimestamp(timestamp) {
+    return !!(timestamp &&
+        typeof timestamp === 'object' &&
+        (typeof timestamp.lte === 'string' || timestamp.lte instanceof Date));
+}
+const isValidTimelinePreviewConfig = (timelinePreview) => {
+    if (typeof timelinePreview !== 'object' ||
+        timelinePreview === null ||
+        Array.isArray(timelinePreview)) {
+        throw new ValidationError('timelinePreview', `The 'timelinePreview' parameter must be an object.`);
+    }
+    const hasRelease = isValidRelease(timelinePreview.release);
+    const hasTimestamp = isValidTimestamp(timelinePreview.timestamp);
+    if (!hasRelease && !hasTimestamp) {
+        throw new ValidationError('timelinePreview', `The 'timelinePreview' object must have at least one of 'release' or 'timestamp' with a valid 'lte' property.`);
+    }
+    return hasRelease || hasTimestamp;
+};
+const getTimelinePreviewParams = (params) => {
+    var _a, _b;
+    const host = params === null || params === void 0 ? void 0 : params.host;
+    const timelinePreview = (_a = params === null || params === void 0 ? void 0 : params.timelinePreview) !== null && _a !== void 0 ? _a : (_b = params === null || params === void 0 ? void 0 : params.alphaFeatures) === null || _b === void 0 ? void 0 : _b.timelinePreview;
+    const enabled = checkEnableTimelinePreviewIsAllowed(host, timelinePreview);
+    return { enabled, timelinePreview };
+};
+
+export { getTimelinePreviewParams, isValidTimelinePreviewConfig };

package/dist/esm/utils/validate-params.js

@@ -0,0 +1,65 @@
+import { isValidTimelinePreviewConfig } from './timeline-preview-helpers.js';
+import { ValidationError } from './validation-error.js';
+
+function checkLocaleParamIsAll(query) {
+    if (query.locale === '*') {
+        throw new ValidationError('locale', `The use of locale='*' is no longer supported.To fetch an entry in all existing locales,
+      use client.withAllLocales instead of the locale='*' parameter.`);
+    }
+}
+function checkLocaleParamExists(query) {
+    if (query.locale) {
+        throw new ValidationError('locale', 'The `locale` parameter is not allowed');
+    }
+}
+function validateLocaleParam(query, isWithAllLocalesClient) {
+    if (isWithAllLocalesClient) {
+        checkLocaleParamExists(query);
+    }
+    else {
+        checkLocaleParamIsAll(query);
+    }
+    return;
+}
+function validateResolveLinksParam(query) {
+    if ('resolveLinks' in query) {
+        throw new ValidationError('resolveLinks', `The use of the 'resolveLinks' parameter is no longer supported. By default, links are resolved.
+      If you do not want to resolve links, use client.withoutLinkResolution.`);
+    }
+    return;
+}
+function validateRemoveUnresolvedParam(query) {
+    if ('removeUnresolved' in query) {
+        throw new ValidationError('removeUnresolved', `The use of the 'removeUnresolved' parameter is no longer supported. By default, unresolved links are kept as link objects.
+      If you do not want to include unresolved links, use client.withoutUnresolvableLinks.`);
+    }
+    return;
+}
+function checkIncludeContentSourceMapsParamIsAllowed(host, includeContentSourceMaps) {
+    if (includeContentSourceMaps === undefined) {
+        return false;
+    }
+    if (typeof includeContentSourceMaps !== 'boolean') {
+        throw new ValidationError('includeContentSourceMaps', `The 'includeContentSourceMaps' parameter must be a boolean.`);
+    }
+    const includeContentSourceMapsIsAllowed = typeof host === 'string' && host.startsWith('preview');
+    if (includeContentSourceMaps && !includeContentSourceMapsIsAllowed) {
+        throw new ValidationError('includeContentSourceMaps', `The 'includeContentSourceMaps' parameter can only be used with the CPA. Please set host to 'preview.contentful.com' or 'preview.eu.contentful.com' to include Content Source Maps.
+      `);
+    }
+    return includeContentSourceMaps;
+}
+function checkEnableTimelinePreviewIsAllowed(host, timelinePreview) {
+    if (timelinePreview === undefined) {
+        return false;
+    }
+    const isValidConfig = isValidTimelinePreviewConfig(timelinePreview);
+    const isValidHost = typeof host === 'string' && host.startsWith('preview');
+    if (isValidConfig && !isValidHost) {
+        throw new ValidationError('timelinePreview', `The 'timelinePreview' parameter can only be used with the CPA. Please set host to 'preview.contentful.com' or 'preview.eu.contentful.com' to enable Timeline Preview.
+      `);
+    }
+    return true;
+}
+
+export { checkEnableTimelinePreviewIsAllowed, checkIncludeContentSourceMapsParamIsAllowed, validateLocaleParam, validateRemoveUnresolvedParam, validateResolveLinksParam };

package/dist/esm/utils/validate-search-parameters.js

@@ -0,0 +1,11 @@
+function validateSearchParameters(query) {
+    for (const key in query) {
+        const value = query[key];
+        // We don’t allow any objects as values for query parameters
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            throw new Error(`Objects are not supported as value for the "${key}" query parameter.`);
+        }
+    }
+}
+
+export { validateSearchParameters as default };

package/dist/esm/utils/validate-timestamp.js

@@ -0,0 +1,16 @@
+import { ValidationError } from './validation-error.js';
+
+function validateTimestamp(name, timestamp, options) {
+    options = options || {};
+    if (typeof timestamp !== 'number') {
+        throw new ValidationError(name, `only numeric values are allowed for timestamps, provided type was "${typeof timestamp}"`);
+    }
+    if (options.maximum && timestamp > options.maximum) {
+        throw new ValidationError(name, `value (${timestamp}) cannot be further in the future than expected maximum (${options.maximum})`);
+    }
+    if (options.now && timestamp < options.now) {
+        throw new ValidationError(name, `value (${timestamp}) cannot be in the past, current time was ${options.now}`);
+    }
+}
+
+export { validateTimestamp as default };

package/dist/esm/utils/validation-error.js

@@ -0,0 +1,8 @@
+class ValidationError extends Error {
+    constructor(name, message) {
+        super(`Invalid "${name}" provided, ` + message);
+        this.name = 'ValidationError';
+    }
+}
+
+export { ValidationError };