2341807152

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/jungvonmatt/contentful-ssg/commit/<a class=hub.com/jungvonmatt/contentful-ssg/commit/670bc7623ec97f8f080d51bc261b9af50fc73e33">670bc7623<a href="https://github.com/jungvonmatt/contentful-ssg/commit/670bc7623ec97f8f080d51bc261b9af50fc73e33">">Merge </a><a class="double-link" href="https://github.com/jungvonmatt/contentful-ssg/commit/<a class="double-link" href="https://github.com/jungvonmatt/contentful-ssg/commit/1bbf6d178cb6395eff0bd803d01be65c5acc9229">1bbf6d178</a>">1bbf6d178</a><a href="https://github.com/jungvonmatt/contentful-ssg/commit/670bc7623ec97f8f080d51bc261b9af50fc73e33"> into 07c6810f5">07c6810f5</a>

Pull Request Pull Request #44: Feature/sync api

Run Details

277 of 370 branches covered (74.86%)

Branch coverage included in aggregate %.

153 of 153 new or added lines in 6 files covered. (100.0%)

796 of 877 relevant lines covered (90.76%)

62.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.68

/packages/contentful-ssg/src/lib/contentful.ts

/* eslint-disable @typescript-eslint/naming-convention */
import { existsSync } from 'fs';
import { hostname } from 'os';
import { v4 as uuidv4 } from 'uuid';
import { readFile, unlink, writeFile } from 'fs/promises';
import type { ClientAPI as ContentfulManagementApi } from 'contentful-management';
import type {
  Space,
  ApiKey,
  QueryOptions,
  CollectionProp,
  CreateWebhooksProps,
} from 'contentful-management/types';
import type {
  CreateClientParams,
  ContentfulClientApi,
  EntryFields,
  SyncCollection,
} from 'contentful';
import type {
  ContentfulConfig,
  FieldSettings,
  Node,
  Entry,
  Asset,
  ContentType,
  Locale,
  PagedGetOptions,
  SyncOptions,
} from '../types.js';
import contentful from 'contentful';
import contentfulManagement from 'contentful-management';

let client: ContentfulClientApi;
let managementClient: ContentfulManagementApi;

export const FIELD_TYPE_SYMBOL = 'Symbol';
export const FIELD_TYPE_TEXT = 'Text';
export const FIELD_TYPE_RICHTEXT = 'RichText';
export const FIELD_TYPE_NUMBER = 'Number';
export const FIELD_TYPE_INTEGER = 'Integer';
export const FIELD_TYPE_DATE = 'Date';
export const FIELD_TYPE_LOCATION = 'Location';
export const FIELD_TYPE_ARRAY = 'Array';
export const FIELD_TYPE_BOOLEAN = 'Boolean';
export const FIELD_TYPE_LINK = 'Link';
export const FIELD_TYPE_OBJECT = 'Object';
export const LINK_TYPE_ASSET = 'Asset';
export const LINK_TYPE_ENTRY = 'Entry';

export const MAX_ALLOWED_LIMIT = 1000;

export const SYNC_TOKEN_FILENAME = '.contentful_sync.lock';

/**
 * Get contentType id from entry
 * @param {Object} node Contentful entry
 * @returns {String}
 */
export const getContentTypeId = <T extends Node | EntryFields.Link<unknown>>(node: T): string =>
  node?.sys?.contentType?.sys?.id ?? 'unknown';

/**
 * Get environment id id from entry
 * @param {Object} node Contentful entry
 * @returns {String}
 */
export const getEnvironmentId = <T extends Node>(node: T): string =>
  node?.sys?.environment?.sys?.id ?? 'unknown';

/**
 * Get content id id from entry
 * @param {Object} node Contentful entry
 * @returns {String}
 */
export const getContentId = <T extends Node | ContentType | EntryFields.Link<unknown>>(
  node: T
): string => node?.sys?.id ?? 'unknown';

/**
 * Get contentful client api
 * @param {Object} options
 * @returns {*}
 */
const getClient = (options: ContentfulConfig): ContentfulClientApi => {
  const { accessToken, previewAccessToken, spaceId, environmentId, preview } = options || {};

  if (client) {
    return client;
  }

  if (accessToken) {
    const params: CreateClientParams = {
      space: spaceId,
      host: preview ? 'preview.contentful.com' : 'cdn.contentful.com',
      accessToken: preview ? previewAccessToken : accessToken,
      environment: environmentId,
    };
    return contentful.createClient(params);
  }

  throw new Error('You need to login first. Run npx contentful login');
};

/**
 * Get contentful management client api
 * @param {Object} options
 * @returns {*}
 */
const getManagementClient = (options: ContentfulConfig): ContentfulManagementApi => {
  const { managementToken } = options || {};

  if (managementClient) {
    return managementClient;
  }

  if (managementToken) {
    return contentfulManagement.createClient({
      accessToken: managementToken,
    });
  }

  throw new Error('You need to login first. Run npx contentful login');
};

/**
 * Get Contentful spaces
 * @param {Options} options
 * @returns {Array<Object>}
 */
export const getSpaces = async (options: ContentfulConfig): Promise<Space[]> => {
  const client = getManagementClient(options);

  const { items: spaces } = await client.getSpaces();

  return spaces;
};

/**
 * Get Contentful space
 * @param {Options} options
 * @returns {Object}
 */
export const getSpace = async (options: ContentfulConfig) => {
  const { spaceId } = options || {};
  const client = getManagementClient(options);
  return client.getSpace(spaceId);
};

/**
 * Get Contentful environments
 * @param {Options} options
 * @returns {Array<Object>}
 */
export const getEnvironments = async (options: ContentfulConfig) => {
  const space = await getSpace(options);
  const { items: environments } = await space.getEnvironments();

  return environments;
};

/**
 * Get Contentful environment
 * @param {Options} options
 * @returns {Object}
 */
export const getEnvironment = async (options: ContentfulConfig) => {
  const { environmentId, spaceId } = options || {};
  const space = await getSpace(options);

  const { items: environments } = await space.getEnvironments();

  const environmentIds = (environments || []).map((env) => env.sys.id);

  if (environmentId && environmentIds.includes(environmentId)) {
    return space.getEnvironment(environmentId);
  }

  if (environmentId && !environmentIds.includes(environmentId)) {
    throw new Error(`Environment "${environmentId}" is not available in space ${spaceId}"`);
  }

  throw new Error('Missing required parameter: environmentId');
};

/**
 * Fetch api key from contentful
 * @param {Object} options
 * @returns {String} accessToken
 */
export const getApiKey = async (options: ContentfulConfig) => {
  const space = await getSpace(options);

  const { items: apiKeys = [] } = (await space.getApiKeys()) || {};
  const [apiKey] = apiKeys;
  const { accessToken } = apiKey || {};

  return accessToken;
};

/**
 * Fetch preview api key from contentful
 * @param {Object} options
 * @returns {String} previewAccessToken
 */
export const getPreviewApiKey = async (options: ContentfulConfig) => {
  const space = await getSpace(options);

  const { items: previewApiKeys = [] } = await space.getPreviewApiKeys();
  const [previewApiKey] = previewApiKeys;
  const { accessToken: previewAccessToken } = previewApiKey as ApiKey;

  return previewAccessToken;
};

export const getWebhooks = async (options: ContentfulConfig) => {
  const space = await getSpace(options);
  const { items: webhooks = [] } = await space.getWebhooks();

  return webhooks;
};

export const addWebhook = async (
  options: ContentfulConfig,
  id: string,
  data: CreateWebhooksProps
) => {
  const space = await getSpace(options);
  return space.createWebhookWithId(id, data);
};

export const deleteWebhook = async (options: ContentfulConfig, id: string) => {
  const space = await getSpace(options);
  const webhook = await space.getWebhook(id);

  return webhook.delete();
};

export const addWatchWebhook = async (options: ContentfulConfig, url: string) => {
  let topics = [
    'ContentType.publish',
    'ContentType.unpublish',
    'ContentType.delete',
    'Entry.archive',
    'Entry.unarchive',
    'Entry.publish',
    'Entry.unpublish',
    'Entry.delete',
    'Asset.archive',
    'Asset.unarchive',
    'Asset.publish',
    'Asset.unpublish',
    'Asset.delete',
  ];

  if (options.preview) {
    topics = [
      ...topics,
      'ContentType.save',
      'Entry.save',
      'Entry.auto_save',
      'Asset.save',
      'Asset.auto_save',
    ];
  }

  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
  const uuid = uuidv4() as string;

  return addWebhook(options, uuid, {
    name: `contentful-ssg (${hostname()})`,
    url,
    httpBasicUsername: null,
    topics,
    filters: [
      {
        equals: [
          {
            doc: 'sys.environment.sys.id',
          },
          options.environmentId,
        ],
      },
    ],
    transformation: {
      includeContentLength: true,
    },

    headers: [],
  });
};

/**
 * Gets all the existing entities based on pagination parameters.
 * The first call will have no aggregated response. Subsequent calls will
 * concatenate the new responses to the original one.
 * Methods:
 * - getContentTypes
 * - getEntries
 * - getAssets
 */
const pagedGet = async <T>(
  apiClient,
  { method, skip = 0, aggregatedResponse = null, query = null }: PagedGetOptions<T>
): Promise<CollectionProp<T>> => {
  const fullQuery: QueryOptions = {
    skip,
    limit: MAX_ALLOWED_LIMIT,
    order: 'sys.createdAt,sys.id',
    locale: '*',
    include: 0,
    ...(query || {}),
  };

  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
  const response = (await apiClient[method](fullQuery)) as CollectionProp<T>;

  if (aggregatedResponse) {
    aggregatedResponse.items = aggregatedResponse.items.concat(response.items);
  } else {
    aggregatedResponse = response;
  }

  if (skip + MAX_ALLOWED_LIMIT <= response.total) {
    return pagedGet(apiClient, {
      method,
      skip: skip + MAX_ALLOWED_LIMIT,
      aggregatedResponse,
      query,
    });
  }

  return aggregatedResponse;
};

/**
 * Synchronizes either all the content or only new content since last sync
 * @param apiClient Contentful API client
 * @returns Promise for the collection resulting of a sync operation
 */
const sync = async (apiClient): Promise<SyncCollection> => {
  const options: SyncOptions = { initial: true };
  if (existsSync(SYNC_TOKEN_FILENAME)) {
    options.nextSyncToken = await readFile(SYNC_TOKEN_FILENAME, 'utf8');
    delete options.initial;
  }

  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
  const response: SyncCollection = (await apiClient.sync(options)) as SyncCollection;
  if (response.nextSyncToken) {
    await writeFile(SYNC_TOKEN_FILENAME, response.nextSyncToken);
  }

  return response;
};

export const isSyncRequest = () => existsSync(SYNC_TOKEN_FILENAME);

export const resetSync = async () => {
  if (isSyncRequest()) {
    return unlink(SYNC_TOKEN_FILENAME);
  }

  return true;
};

/**
 * Gets all the existing entities based on pagination parameters.
 * The first call will have no aggregated response. Subsequent calls will
 * concatenate the new responses to the original one.
 * Methods:
 * - getContentTypes
 * - getEntries
 * - getAssets
 * - getLocales
 */
export const getContent = async (options: ContentfulConfig) => {
  const apiClient = getClient(options);

  const { items: locales } = await pagedGet<Locale>(apiClient, {
    method: 'getLocales',
  });

  const { items: contentTypes } = await pagedGet<ContentType>(apiClient, {
    method: 'getContentTypes',
  });

  // Use the sync api if watch mode is enabled
  if (options.sync) {
    const { entries, assets, deletedEntries, deletedAssets } = await sync(apiClient);
    return { entries, assets, deletedEntries, deletedAssets, contentTypes, locales };
  }

  const { items: entries } = await pagedGet<Entry>(apiClient, {
    method: 'getEntries',
  });
  const { items: assets } = await pagedGet<Asset>(apiClient, {
    method: 'getAssets',
  });

  return { entries, assets, contentTypes, locales };
};

export const getEntriesLinkedToEntry = async (options: ContentfulConfig, id: string) => {
  const apiClient = getClient(options);

  const { items: entries } = await pagedGet<Entry>(apiClient, {
    method: 'getEntries',
    query: { links_to_entry: id },
  });

  return entries;
};

export const getEntriesLinkedToAsset = async (options: ContentfulConfig, id: string) => {
  const apiClient = getClient(options);

  const { items: entries } = await pagedGet<Entry>(apiClient, {
    method: 'getEntries',
    query: { links_to_asset: id },
  });

  return entries;
};

/**
 * Check if the passed object looks lika a regular contentful entity (entry or asset)
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isContentfulObject = (obj) =>
  Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).includes('sys');

/**
 * Check if the passed object is a contentful link object
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isLink = (obj) => isContentfulObject(obj) && obj.sys.type === FIELD_TYPE_LINK;

/**
 * Check if the passed object is a contentful asset link object
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isAssetLink = (obj) => isLink(obj) && obj.sys.linkType === LINK_TYPE_ASSET;

/**
 * Check if the passed object is a contentful entry link object
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isEntryLink = (obj) => isContentfulObject(obj) && obj.sys.linkType === LINK_TYPE_ENTRY;

/**
 * Check if the passed object is a contentful asset object
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isAsset = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ASSET;

/**
 * Check if the passed object is a contentful entry object
 * @param {Object} entity Contentful entity
 * @returns {Boolean}
 */
export const isEntry = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ENTRY;

/**
 * Convert contenttype list to a map
 * @param {Array} entity Contentful entity
 * @returns {Object} e.g. {'contenttype-id': { 'field-1-id': { required: ..., type: ..., ...}}}
 */
export const getFieldSettings = (contentTypes: ContentType[]): FieldSettings =>
  contentTypes.reduce((res, contentType) => {
    const id = getContentId(contentType);
    const fields = contentType.fields.reduce(
      (fields, field) => ({ ...fields, [field.id]: field }),
      {}
    );
    return { ...res, [id]: fields };
  }, {});

/**
 * Convert entries/assets array to map
 * @param {Array} nodes Nodes array (entries/assets)
 */
export const convertToMap = <T extends Node>(nodes: T[] = []) =>
  new Map(nodes.map((node) => [getContentId(node), node]));

1	/* eslint-disable @typescript-eslint/naming-convention */
2	import { existsSync } from 'fs';	10✔
3	import { hostname } from 'os';	10✔
4	import { v4 as uuidv4 } from 'uuid';	10✔
5	import { readFile, unlink, writeFile } from 'fs/promises';	10✔
6	import type { ClientAPI as ContentfulManagementApi } from 'contentful-management';
7	import type {
8	Space,
9	ApiKey,
10	QueryOptions,
11	CollectionProp,
12	CreateWebhooksProps,
13	} from 'contentful-management/types';
14	import type {
15	CreateClientParams,
16	ContentfulClientApi,
17	EntryFields,
18	SyncCollection,
19	} from 'contentful';
20	import type {
21	ContentfulConfig,
22	FieldSettings,
23	Node,
24	Entry,
25	Asset,
26	ContentType,
27	Locale,
28	PagedGetOptions,
29	SyncOptions,
30	} from '../types.js';
31	import contentful from 'contentful';	10✔
32	import contentfulManagement from 'contentful-management';	10✔
33
34	let client: ContentfulClientApi;
35	let managementClient: ContentfulManagementApi;
36
37	export const FIELD_TYPE_SYMBOL = 'Symbol';	10✔
38	export const FIELD_TYPE_TEXT = 'Text';	10✔
39	export const FIELD_TYPE_RICHTEXT = 'RichText';	10✔
40	export const FIELD_TYPE_NUMBER = 'Number';	10✔
41	export const FIELD_TYPE_INTEGER = 'Integer';	10✔
42	export const FIELD_TYPE_DATE = 'Date';	10✔
43	export const FIELD_TYPE_LOCATION = 'Location';	10✔
44	export const FIELD_TYPE_ARRAY = 'Array';	10✔
45	export const FIELD_TYPE_BOOLEAN = 'Boolean';	10✔
46	export const FIELD_TYPE_LINK = 'Link';	10✔
47	export const FIELD_TYPE_OBJECT = 'Object';	10✔
48	export const LINK_TYPE_ASSET = 'Asset';	10✔
49	export const LINK_TYPE_ENTRY = 'Entry';	10✔
50
51	export const MAX_ALLOWED_LIMIT = 1000;	10✔
52
53	export const SYNC_TOKEN_FILENAME = '.contentful_sync.lock';	10✔
54
55	/**
56	* Get contentType id from entry
57	* @param {Object} node Contentful entry
58	* @returns {String}
59	*/
60	export const getContentTypeId = <T extends Node \| EntryFields.Link<unknown>>(node: T): string =>	10✔
61	node?.sys?.contentType?.sys?.id ?? 'unknown';	404✔
62
63	/**
64	* Get environment id id from entry
65	* @param {Object} node Contentful entry
66	* @returns {String}
67	*/
68	export const getEnvironmentId = <T extends Node>(node: T): string =>	10✔
69	node?.sys?.environment?.sys?.id ?? 'unknown';	3✔
70
71	/**
72	* Get content id id from entry
73	* @param {Object} node Contentful entry
74	* @returns {String}
75	*/
76	export const getContentId = <T extends Node \| ContentType \| EntryFields.Link<unknown>>(	10✔
77	node: T
78	): string => node?.sys?.id ?? 'unknown';	625✔
79
80	/**
81	* Get contentful client api
82	* @param {Object} options
83	* @returns {*}
84	*/
85	const getClient = (options: ContentfulConfig): ContentfulClientApi => {	10✔
86	const { accessToken, previewAccessToken, spaceId, environmentId, preview } = options \|\| {};	4!
87
88	if (client) {	4!
89	return client;	×
90	}
91
92	if (accessToken) {	4✔
93	const params: CreateClientParams = {	3✔
94	space: spaceId,
95	host: preview ? 'preview.contentful.com' : 'cdn.contentful.com',	3!
96	accessToken: preview ? previewAccessToken : accessToken,	3!
97	environment: environmentId,
98	};
99	return contentful.createClient(params);	3✔
100	}
101
102	throw new Error('You need to login first. Run npx contentful login');	1✔
103	};
104
105	/**
106	* Get contentful management client api
107	* @param {Object} options
108	* @returns {*}
109	*/
110	const getManagementClient = (options: ContentfulConfig): ContentfulManagementApi => {	10✔
111	const { managementToken } = options \|\| {};	14!
112
113	if (managementClient) {	14!
114	return managementClient;	×
115	}
116
117	if (managementToken) {	14✔
118	return contentfulManagement.createClient({	13✔
119	accessToken: managementToken,
120	});
121	}
122
123	throw new Error('You need to login first. Run npx contentful login');	1✔
124	};
125
126	/**
127	* Get Contentful spaces
128	* @param {Options} options
129	* @returns {Array<Object>}
130	*/
131	export const getSpaces = async (options: ContentfulConfig): Promise<Space[]> => {	10✔
132	const client = getManagementClient(options);	2✔
133
134	const { items: spaces } = await client.getSpaces();	1✔
135
136	return spaces;	1✔
137	};
138
139	/**
140	* Get Contentful space
141	* @param {Options} options
142	* @returns {Object}
143	*/
144	export const getSpace = async (options: ContentfulConfig) => {	10✔
145	const { spaceId } = options \|\| {};	12!
146	const client = getManagementClient(options);	12✔
147	return client.getSpace(spaceId);	12✔
148	};
149
150	/**
151	* Get Contentful environments
152	* @param {Options} options
153	* @returns {Array<Object>}
154	*/
155	export const getEnvironments = async (options: ContentfulConfig) => {	10✔
156	const space = await getSpace(options);	1✔
157	const { items: environments } = await space.getEnvironments();	1✔
158
159	return environments;	1✔
160	};
161
162	/**
163	* Get Contentful environment
164	* @param {Options} options
165	* @returns {Object}
166	*/
167	export const getEnvironment = async (options: ContentfulConfig) => {	10✔
168	const { environmentId, spaceId } = options \|\| {};	3!
169	const space = await getSpace(options);	3✔
170
171	const { items: environments } = await space.getEnvironments();	3✔
172
173	const environmentIds = (environments \|\| []).map((env) => env.sys.id);	3!
174
175	if (environmentId && environmentIds.includes(environmentId)) {	3✔
176	return space.getEnvironment(environmentId);	1✔
177	}
178
179	if (environmentId && !environmentIds.includes(environmentId)) {	2✔
180	throw new Error(`Environment "${environmentId}" is not available in space ${spaceId}"`);	1✔
181	}
182
183	throw new Error('Missing required parameter: environmentId');	1✔
184	};
185
186	/**
187	* Fetch api key from contentful
188	* @param {Object} options
189	* @returns {String} accessToken
190	*/
191	export const getApiKey = async (options: ContentfulConfig) => {	10✔
192	const space = await getSpace(options);	1✔
193
194	const { items: apiKeys = [] } = (await space.getApiKeys()) \|\| {};	1!
195	const [apiKey] = apiKeys;	1✔
196	const { accessToken } = apiKey \|\| {};	1!
197
198	return accessToken;	1✔
199	};
200
201	/**
202	* Fetch preview api key from contentful
203	* @param {Object} options
204	* @returns {String} previewAccessToken
205	*/
206	export const getPreviewApiKey = async (options: ContentfulConfig) => {	10✔
207	const space = await getSpace(options);	1✔
208
209	const { items: previewApiKeys = [] } = await space.getPreviewApiKeys();	1!
210	const [previewApiKey] = previewApiKeys;	1✔
211	const { accessToken: previewAccessToken } = previewApiKey as ApiKey;	1✔
212
213	return previewAccessToken;	1✔
214	};
215
216	export const getWebhooks = async (options: ContentfulConfig) => {	10✔
217	const space = await getSpace(options);	1✔
218	const { items: webhooks = [] } = await space.getWebhooks();	1!
219
220	return webhooks;	1✔
221	};
222
223	export const addWebhook = async (	10✔
224	options: ContentfulConfig,
225	id: string,
226	data: CreateWebhooksProps
227	) => {
228	const space = await getSpace(options);	3✔
229	return space.createWebhookWithId(id, data);	3✔
230	};
231
232	export const deleteWebhook = async (options: ContentfulConfig, id: string) => {	10✔
233	const space = await getSpace(options);	1✔
234	const webhook = await space.getWebhook(id);	1✔
235
236	return webhook.delete();	1✔
237	};
238
239	export const addWatchWebhook = async (options: ContentfulConfig, url: string) => {	10✔
240	let topics = [	2✔
241	'ContentType.publish',
242	'ContentType.unpublish',
243	'ContentType.delete',
244	'Entry.archive',
245	'Entry.unarchive',
246	'Entry.publish',
247	'Entry.unpublish',
248	'Entry.delete',
249	'Asset.archive',
250	'Asset.unarchive',
251	'Asset.publish',
252	'Asset.unpublish',
253	'Asset.delete',
254	];
255
256	if (options.preview) {	2✔
257	topics = [	1✔
258	...topics,
259	'ContentType.save',
260	'Entry.save',
261	'Entry.auto_save',
262	'Asset.save',
263	'Asset.auto_save',
264	];
265	}
266
267	// eslint-disable-next-line @typescript-eslint/no-unsafe-call
268	const uuid = uuidv4() as string;	2✔
269
270	return addWebhook(options, uuid, {	2✔
271	name: `contentful-ssg (${hostname()})`,
272	url,
273	httpBasicUsername: null,
274	topics,
275	filters: [
276	{
277	equals: [
278	{
279	doc: 'sys.environment.sys.id',
280	},
281	options.environmentId,
282	],
283	},
284	],
285	transformation: {
286	includeContentLength: true,
287	},
288
289	headers: [],
290	});
291	};
292
293	/**
294	* Gets all the existing entities based on pagination parameters.
295	* The first call will have no aggregated response. Subsequent calls will
296	* concatenate the new responses to the original one.
297	* Methods:
298	* - getContentTypes
299	* - getEntries
300	* - getAssets
301	*/
302	const pagedGet = async <T>(	10✔
303	apiClient,
304	{ method, skip = 0, aggregatedResponse = null, query = null }: PagedGetOptions<T>	24✔
305	): Promise<CollectionProp<T>> => {
306	const fullQuery: QueryOptions = {	10✔
307	skip,
308	limit: MAX_ALLOWED_LIMIT,
309	order: 'sys.createdAt,sys.id',
310	locale: '*',
311	include: 0,
312	...(query \|\| {}),	20✔
313	};
314
315	// eslint-disable-next-line @typescript-eslint/no-unsafe-call
316	const response = (await apiClient[method](fullQuery)) as CollectionProp<T>;	10✔
317
318	if (aggregatedResponse) {	10✔
319	aggregatedResponse.items = aggregatedResponse.items.concat(response.items);	2✔
320	} else {
321	aggregatedResponse = response;	8✔
322	}
323
324	if (skip + MAX_ALLOWED_LIMIT <= response.total) {	10✔
325	return pagedGet(apiClient, {	2✔
326	method,
327	skip: skip + MAX_ALLOWED_LIMIT,
328	aggregatedResponse,
329	query,
330	});
331	}
332
333	return aggregatedResponse;	8✔
334	};
335
336	/**
337	* Synchronizes either all the content or only new content since last sync
338	* @param apiClient Contentful API client
339	* @returns Promise for the collection resulting of a sync operation
340	*/
341	const sync = async (apiClient): Promise<SyncCollection> => {	10✔
342	const options: SyncOptions = { initial: true };	2✔
343	if (existsSync(SYNC_TOKEN_FILENAME)) {	2✔
344	options.nextSyncToken = await readFile(SYNC_TOKEN_FILENAME, 'utf8');	1✔
345	delete options.initial;	1✔
346	}
347
348	// eslint-disable-next-line @typescript-eslint/no-unsafe-call
349	const response: SyncCollection = (await apiClient.sync(options)) as SyncCollection;	2✔
350	if (response.nextSyncToken) {	2✔
351	await writeFile(SYNC_TOKEN_FILENAME, response.nextSyncToken);	2✔
352	}
353
354	return response;	2✔
355	};
356
357	export const isSyncRequest = () => existsSync(SYNC_TOKEN_FILENAME);	10✔
358
359	export const resetSync = async () => {	10✔
360	if (isSyncRequest()) {	1✔
361	return unlink(SYNC_TOKEN_FILENAME);	1✔
362	}
363
364	return true;	×
365	};
366
367	/**
368	* Gets all the existing entities based on pagination parameters.
369	* The first call will have no aggregated response. Subsequent calls will
370	* concatenate the new responses to the original one.
371	* Methods:
372	* - getContentTypes
373	* - getEntries
374	* - getAssets
375	* - getLocales
376	*/
377	export const getContent = async (options: ContentfulConfig) => {	10✔
378	const apiClient = getClient(options);	4✔
379
380	const { items: locales } = await pagedGet<Locale>(apiClient, {	3✔
381	method: 'getLocales',
382	});
383
384	const { items: contentTypes } = await pagedGet<ContentType>(apiClient, {	3✔
385	method: 'getContentTypes',
386	});
387
388	// Use the sync api if watch mode is enabled
389	if (options.sync) {	3✔
390	const { entries, assets, deletedEntries, deletedAssets } = await sync(apiClient);	2✔
391	return { entries, assets, deletedEntries, deletedAssets, contentTypes, locales };	2✔
392	}
393
394	const { items: entries } = await pagedGet<Entry>(apiClient, {	1✔
395	method: 'getEntries',
396	});
397	const { items: assets } = await pagedGet<Asset>(apiClient, {	1✔
398	method: 'getAssets',
399	});
400
401	return { entries, assets, contentTypes, locales };	1✔
402	};
403
404	export const getEntriesLinkedToEntry = async (options: ContentfulConfig, id: string) => {	10✔
405	const apiClient = getClient(options);	×
406
407	const { items: entries } = await pagedGet<Entry>(apiClient, {	×
408	method: 'getEntries',
409	query: { links_to_entry: id },
410	});
411
412	return entries;	×
413	};
414
415	export const getEntriesLinkedToAsset = async (options: ContentfulConfig, id: string) => {	10✔
416	const apiClient = getClient(options);	×
417
418	const { items: entries } = await pagedGet<Entry>(apiClient, {	×
419	method: 'getEntries',
420	query: { links_to_asset: id },
421	});
422
423	return entries;	×
424	};
425
426	/**
427	* Check if the passed object looks lika a regular contentful entity (entry or asset)
428	* @param {Object} entity Contentful entity
429	* @returns {Boolean}
430	*/
431	export const isContentfulObject = (obj) =>	10✔
432	Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).includes('sys');	399✔
433
434	/**
435	* Check if the passed object is a contentful link object
436	* @param {Object} entity Contentful entity
437	* @returns {Boolean}
438	*/
439	export const isLink = (obj) => isContentfulObject(obj) && obj.sys.type === FIELD_TYPE_LINK;	190✔
440
441	/**
442	* Check if the passed object is a contentful asset link object
443	* @param {Object} entity Contentful entity
444	* @returns {Boolean}
445	*/
446	export const isAssetLink = (obj) => isLink(obj) && obj.sys.linkType === LINK_TYPE_ASSET;	182✔
447
448	/**
449	* Check if the passed object is a contentful entry link object
450	* @param {Object} entity Contentful entity
451	* @returns {Boolean}
452	*/
453	export const isEntryLink = (obj) => isContentfulObject(obj) && obj.sys.linkType === LINK_TYPE_ENTRY;	88✔
454
455	/**
456	* Check if the passed object is a contentful asset object
457	* @param {Object} entity Contentful entity
458	* @returns {Boolean}
459	*/
460	export const isAsset = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ASSET;	88✔
461
462	/**
463	* Check if the passed object is a contentful entry object
464	* @param {Object} entity Contentful entity
465	* @returns {Boolean}
466	*/
467	export const isEntry = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ENTRY;	29✔
468
469	/**
470	* Convert contenttype list to a map
471	* @param {Array} entity Contentful entity
472	* @returns {Object} e.g. {'contenttype-id': { 'field-1-id': { required: ..., type: ..., ...}}}
473	*/
474	export const getFieldSettings = (contentTypes: ContentType[]): FieldSettings =>	10✔
475	contentTypes.reduce((res, contentType) => {	24✔
476	const id = getContentId(contentType);	24✔
477	const fields = contentType.fields.reduce(	24✔
478	(fields, field) => ({ ...fields, [field.id]: field }),	360✔
479	{}
480	);
481	return { ...res, [id]: fields };	24✔
482	}, {});
483
484	/**
485	* Convert entries/assets array to map
486	* @param {Array} nodes Nodes array (entries/assets)
487	*/
488	export const convertToMap = <T extends Node>(nodes: T[] = []) =>	10!
489	new Map(nodes.map((node) => [getContentId(node), node]));	119✔

jungvonmatt / contentful-ssg / 2341807152

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous