@cooperco/cooper-component-library 0.1.127 → 0.1.128

package/dist/cms/0095-tabmodule-inline-body-copy.cjs

@@ -0,0 +1,566 @@
+/**
+ * Inline tabModule.bodyCopy: replace the Entry Link to the bodyCopy content
+ * type with a RichText field directly on tabModule.
+ *
+ * Pattern mirrors 0054 (create → transformEntries → deleteField) and 0044
+ * (makeRequest to resolve linked entry data). changeFieldId renames the temp
+ * RichText field back to `bodyCopy` after the Link field is removed.
+ *
+ * Source RichText validations match 0047-create-body-copy.cjs so existing
+ * documents (including highlightedText embeds) remain valid.
+ *
+ * Content-type cleanup (delete leftover bodyCopy entries + content type) is
+ * intentionally in 0096 — makeRequest at migration start only works after this
+ * migration has already dropped the Link field (see 0090 → 0091 split).
+ *
+ * Sandbox note: some tabModules retain Link fields pointing at Body Copy
+ * entries that no longer exist (orphaned references). Missing links are
+ * skipped with a log so the migration can finish; those tabs end up with an
+ * empty inline bodyCopy and need content re-authored if still used.
+ *
+ * down() reverses the data migration: for each tabModule it recreates a
+ * bodyCopy entry from the inline RichText, publishes it, and restores the
+ * Link field. Requires 0096 down to have recreated the bodyCopy content type.
+ */
+
+const BODY_COPY_RICH_TEXT_VALIDATIONS = [
+	{
+		enabledMarks: ['bold', 'italic', 'underline'],
+		message: 'Only bold, italic, and underline marks are allowed',
+	},
+	{
+		enabledNodeTypes: [
+			'ordered-list',
+			'unordered-list',
+			'hr',
+			'hyperlink',
+			'embedded-entry-inline',
+		],
+	},
+	{
+		nodes: {
+			'embedded-entry-inline': [
+				{
+					linkContentType: ['highlightedText'],
+					message: 'You can only embedd Higlighted Text.',
+				},
+			],
+		},
+	},
+]
+
+/**
+ * contentful-sdk-core's errorHandler builds errors as:
+ *   error.name = data.sys.id          // e.g. "NotFound"
+ *   error.message = JSON.stringify({ status, statusText, message, details, request, requestId })
+ * so status/sys are NOT top-level properties — they live in the JSON message
+ * (and name). Plain Axios / CMA shapes may still expose status/sys/response.
+ *
+ * @param {unknown} error
+ * @returns {Record<string, unknown>}
+ */
+const summarizeErrorShape = (error) => {
+	if (!error || typeof error !== 'object') {
+		return { typeof: typeof error, value: String(error) }
+	}
+
+	const err = /** @type {Record<string, unknown>} */ (error)
+	let parsedMessage = null
+	if (typeof err.message === 'string') {
+		try {
+			parsedMessage = JSON.parse(err.message)
+		} catch {
+			parsedMessage = null
+		}
+	}
+
+	return {
+		name: err.name,
+		status: err.status,
+		statusCode: err.statusCode,
+		sys: err.sys,
+		responseStatus:
+			err.response && typeof err.response === 'object'
+				? /** @type {Record<string, unknown>} */ (err.response).status
+				: undefined,
+		responseSys:
+			err.response && typeof err.response === 'object'
+				? /** @type {Record<string, unknown>} */ (
+						/** @type {Record<string, unknown>} */ (err.response).data || {}
+					).sys
+				: undefined,
+		messagePreview:
+			typeof err.message === 'string' ? err.message.slice(0, 500) : err.message,
+		parsedMessageStatus:
+			parsedMessage && typeof parsedMessage === 'object'
+				? /** @type {Record<string, unknown>} */ (parsedMessage).status
+				: undefined,
+		parsedMessageSys:
+			parsedMessage && typeof parsedMessage === 'object'
+				? /** @type {Record<string, unknown>} */ (parsedMessage).sys
+				: undefined,
+		keys: Object.keys(err),
+	}
+}
+
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+const isNotFoundError = (error) => {
+	if (!error || typeof error !== 'object') {
+		return false
+	}
+
+	const err = /** @type {Record<string, unknown>} */ (error)
+
+	// contentful-sdk-core: error.name = data.sys.id ("NotFound")
+	if (err.name === 'NotFound') {
+		return true
+	}
+
+	if (err.status === 404 || err.statusCode === 404) {
+		return true
+	}
+
+	if (
+		err.response &&
+		typeof err.response === 'object' &&
+		/** @type {Record<string, unknown>} */ (err.response).status === 404
+	) {
+		return true
+	}
+
+	const topSys = err.sys
+	if (
+		topSys &&
+		typeof topSys === 'object' &&
+		/** @type {Record<string, unknown>} */ (topSys).id === 'NotFound'
+	) {
+		return true
+	}
+
+	if (err.response && typeof err.response === 'object') {
+		const data = /** @type {Record<string, unknown>} */ (err.response).data
+		if (
+			data &&
+			typeof data === 'object' &&
+			/** @type {Record<string, unknown>} */ (data).sys &&
+			typeof /** @type {Record<string, unknown>} */ (data).sys === 'object' &&
+			/** @type {Record<string, unknown>} */ (
+				/** @type {Record<string, unknown>} */ (data).sys
+			).id === 'NotFound'
+		) {
+			return true
+		}
+	}
+
+	// contentful-sdk-core packs status into error.message JSON
+	if (typeof err.message === 'string') {
+		try {
+			const parsed = JSON.parse(err.message)
+			if (parsed && typeof parsed === 'object') {
+				if (parsed.status === 404) {
+					return true
+				}
+				if (parsed.sys && parsed.sys.id === 'NotFound') {
+					return true
+				}
+			}
+		} catch {
+			// message is not JSON — ignore
+		}
+		if (/\bNotFound\b/.test(err.message) && /\b404\b/.test(err.message)) {
+			return true
+		}
+	}
+
+	return false
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+const isEntryLink = (value) =>
+	!!value &&
+	typeof value === 'object' &&
+	/** @type {Record<string, unknown>} */ (value).sys &&
+	typeof /** @type {Record<string, unknown>} */ (value).sys === 'object' &&
+	/** @type {Record<string, unknown>} */ (
+		/** @type {Record<string, unknown>} */ (value).sys
+	).type === 'Link' &&
+	!!/** @type {Record<string, unknown>} */ (
+		/** @type {Record<string, unknown>} */ (value).sys
+	).id
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+const isRichTextDocument = (value) =>
+	!!value &&
+	typeof value === 'object' &&
+	/** @type {Record<string, unknown>} */ (value).nodeType === 'document'
+
+/**
+ * @param {Function} makeRequest
+ * @param {string} entryId
+ * @returns {Promise<Record<string, unknown>|null>}
+ */
+const fetchEntry = async (makeRequest, entryId) => {
+	try {
+		return await makeRequest({
+			method: 'GET',
+			url: `/entries/${entryId}`,
+		})
+	} catch (error) {
+		process.stdout.write(
+			`[0095] makeRequest error fetching entry ${entryId}: ` +
+				`${JSON.stringify(summarizeErrorShape(error))}\n`
+		)
+		if (isNotFoundError(error)) {
+			return null
+		}
+		throw error
+	}
+}
+
+/**
+ * @param {Function} makeRequest
+ * @param {Record<string, unknown>} entry
+ * @returns {Promise<Record<string, unknown>>}
+ */
+const publishEntry = async (makeRequest, entry) => {
+	const entryId = /** @type {Record<string, unknown>} */ (entry.sys).id
+	const version = /** @type {Record<string, unknown>} */ (entry.sys).version
+	return await makeRequest({
+		method: 'PUT',
+		url: `/entries/${entryId}/published`,
+		headers: {
+			'X-Contentful-Version': String(version),
+		},
+	})
+}
+
+/**
+ * Create or update a bodyCopy entry for one tabModule locale, then publish.
+ * One bodyCopy entry is reused across locales for the same tabModule (cached).
+ *
+ * @param {object} params
+ * @param {Function} params.makeRequest
+ * @param {Map<string, string>} params.bodyCopyIdByTabId
+ * @param {string} params.tabModuleId
+ * @param {string} params.currentLocale
+ * @param {unknown} params.richText
+ * @param {string} params.entryName
+ * @param {string|undefined} params.existingBodyCopyId
+ * @returns {Promise<string|null>} bodyCopy entry id, or null if skipped
+ */
+const upsertBodyCopyEntry = async ({
+	makeRequest,
+	bodyCopyIdByTabId,
+	tabModuleId,
+	currentLocale,
+	richText,
+	entryName,
+	existingBodyCopyId,
+}) => {
+	const cachedId = bodyCopyIdByTabId.get(tabModuleId)
+	const targetId = existingBodyCopyId || cachedId
+
+	if (targetId) {
+		const existing = await fetchEntry(makeRequest, targetId)
+		if (existing) {
+			const fields = {
+				...(existing.fields || {}),
+				entryName: {
+					...((existing.fields && existing.fields.entryName) || {}),
+					[currentLocale]: entryName,
+				},
+				bodyCopy: {
+					...((existing.fields && existing.fields.bodyCopy) || {}),
+					[currentLocale]: richText,
+				},
+			}
+
+			const updated = await makeRequest({
+				method: 'PUT',
+				url: `/entries/${targetId}`,
+				headers: {
+					'X-Contentful-Content-Type': 'bodyCopy',
+					'X-Contentful-Version': String(existing.sys.version),
+				},
+				data: { fields },
+			})
+
+			await publishEntry(makeRequest, updated)
+			bodyCopyIdByTabId.set(tabModuleId, targetId)
+			process.stdout.write(
+				`[0095 down] Updated bodyCopy ${targetId} for tabModule ${tabModuleId} ` +
+					`(locale ${currentLocale})\n`
+			)
+			return targetId
+		}
+
+		process.stdout.write(
+			`[0095 down] Existing bodyCopy ${targetId} missing; creating a new entry ` +
+				`for tabModule ${tabModuleId} (locale ${currentLocale})\n`
+		)
+	}
+
+	const created = await makeRequest({
+		method: 'POST',
+		url: `/entries`,
+		headers: {
+			'X-Contentful-Content-Type': 'bodyCopy',
+		},
+		data: {
+			fields: {
+				entryName: {
+					[currentLocale]: entryName,
+				},
+				bodyCopy: {
+					[currentLocale]: richText,
+				},
+			},
+		},
+	})
+
+	const published = await publishEntry(makeRequest, created)
+	const newId = published.sys.id
+	bodyCopyIdByTabId.set(tabModuleId, newId)
+	process.stdout.write(
+		`[0095 down] Created bodyCopy ${newId} for tabModule ${tabModuleId} ` +
+			`(locale ${currentLocale})\n`
+	)
+	return newId
+}
+
+module.exports = {
+	// @ts-check
+	/** @type { import('contentful-migration').MigrationFunction } */
+	up: function (migration, { makeRequest }) {
+		const tabModule = migration.editContentType('tabModule')
+		/** @type {Set<string>} */
+		const skippedBodyCopyIds = new Set()
+
+		// 1. Temp RichText field (bodyCopy is still the Link field).
+		tabModule
+			.createField('bodyCopyRichText')
+			.name('Body Copy')
+			.type('RichText')
+			.required(false)
+			.validations(BODY_COPY_RICH_TEXT_VALIDATIONS)
+
+		// Keep editor order consistent with the old reference field (before cta).
+		tabModule.moveField('bodyCopyRichText').beforeField('cta')
+
+		// 2. Copy RichText from each linked bodyCopy entry into the temp field.
+		migration.transformEntries({
+			contentType: 'tabModule',
+			from: ['bodyCopy'],
+			to: ['bodyCopyRichText'],
+			transformEntryForLocale: async (fromFields, currentLocale, { id }) => {
+				const link = fromFields.bodyCopy?.[currentLocale]
+				if (!link?.sys?.id) {
+					return
+				}
+
+				const linkedBodyCopyId = link.sys.id
+				let linkedEntry
+				try {
+					linkedEntry = await makeRequest({
+						method: 'GET',
+						url: `/entries/${linkedBodyCopyId}`,
+					})
+				} catch (error) {
+					process.stdout.write(
+						`[0095] makeRequest error for bodyCopy ${linkedBodyCopyId} ` +
+							`(tabModule ${id}, locale ${currentLocale}): ` +
+							`${JSON.stringify(summarizeErrorShape(error))}\n`
+					)
+
+					if (isNotFoundError(error)) {
+						skippedBodyCopyIds.add(linkedBodyCopyId)
+						process.stdout.write(
+							`[0095] Skipping missing bodyCopy entry ${linkedBodyCopyId} ` +
+								`(referenced by tabModule ${id}, locale ${currentLocale})\n`
+						)
+						return
+					}
+					throw error
+				}
+
+				const richText =
+					linkedEntry.fields?.bodyCopy?.[currentLocale] ??
+					linkedEntry.fields?.bodyCopy?.['en-US']
+
+				if (!richText) {
+					process.stdout.write(
+						`[0095] Skipping bodyCopy entry ${linkedBodyCopyId} with empty RichText ` +
+							`(referenced by tabModule ${id}, locale ${currentLocale})\n`
+					)
+					return
+				}
+
+				return {
+					bodyCopyRichText: richText,
+				}
+			},
+		})
+
+		// 3. Drop the old Entry Link field.
+		tabModule.deleteField('bodyCopy')
+
+		// 4. Rename temp RichText → bodyCopy (preserves migrated values).
+		tabModule.changeFieldId('bodyCopyRichText', 'bodyCopy')
+	},
+
+	/** @type { import('contentful-migration').MigrationFunction } */
+	down: async function (migration, { makeRequest }) {
+		// Idempotent: if bodyCopy is already a Link, a prior down completed.
+		const contentType = await makeRequest({
+			method: 'GET',
+			url: '/content_types/tabModule',
+		})
+		const bodyCopyField = (contentType.fields || []).find(
+			(field) => field.id === 'bodyCopy'
+		)
+		if (bodyCopyField?.type === 'Link') {
+			process.stdout.write(
+				'[0095 down] tabModule.bodyCopy is already a Link; skipping rollback\n'
+			)
+			return
+		}
+		if (bodyCopyField?.type !== 'RichText') {
+			process.stdout.write(
+				`[0095 down] Unexpected tabModule.bodyCopy type ` +
+					`"${bodyCopyField?.type ?? 'missing'}"; skipping rollback\n`
+			)
+			return
+		}
+
+		const tabModule = migration.editContentType('tabModule')
+		/** @type {Map<string, string>} */
+		const bodyCopyIdByTabId = new Map()
+
+		// Temp Link field while bodyCopy is still the inline RichText.
+		tabModule
+			.createField('bodyCopyLink')
+			.name('Body Copy')
+			.type('Link')
+			.linkType('Entry')
+			.required(false)
+			.validations([{ linkContentType: ['bodyCopy'] }])
+
+		tabModule.moveField('bodyCopyLink').beforeField('cta')
+
+		migration.transformEntries({
+			contentType: 'tabModule',
+			from: ['bodyCopy', 'bodyCopyLink', 'entryName', 'title'],
+			to: ['bodyCopyLink'],
+			transformEntryForLocale: async (fromFields, currentLocale, { id }) => {
+				const existingLink = fromFields.bodyCopyLink?.[currentLocale]
+				const inlineBodyCopy = fromFields.bodyCopy?.[currentLocale]
+
+				// Already restored to a Link for this locale — reuse / refresh.
+				if (isEntryLink(existingLink)) {
+					const existingId = existingLink.sys.id
+					if (isRichTextDocument(inlineBodyCopy)) {
+						const entryName =
+							fromFields.entryName?.[currentLocale] ||
+							fromFields.title?.[currentLocale] ||
+							`Tab Module ${id}`
+						await upsertBodyCopyEntry({
+							makeRequest,
+							bodyCopyIdByTabId,
+							tabModuleId: id,
+							currentLocale,
+							richText: inlineBodyCopy,
+							entryName,
+							existingBodyCopyId: existingId,
+						})
+					} else {
+						bodyCopyIdByTabId.set(id, existingId)
+						process.stdout.write(
+							`[0095 down] Reusing existing bodyCopyLink ${existingId} ` +
+								`for tabModule ${id} (locale ${currentLocale})\n`
+						)
+					}
+					return {
+						bodyCopyLink: {
+							sys: {
+								type: 'Link',
+								linkType: 'Entry',
+								id: existingId,
+							},
+						},
+					}
+				}
+
+				// No inline RichText for this locale — nothing to restore.
+				if (!isRichTextDocument(inlineBodyCopy)) {
+					if (bodyCopyIdByTabId.has(id)) {
+						return {
+							bodyCopyLink: {
+								sys: {
+									type: 'Link',
+									linkType: 'Entry',
+									id: bodyCopyIdByTabId.get(id),
+								},
+							},
+						}
+					}
+					process.stdout.write(
+						`[0095 down] Skipping tabModule ${id} locale ${currentLocale}: ` +
+							`no inline RichText bodyCopy to restore\n`
+					)
+					return
+				}
+
+				const entryName =
+					fromFields.entryName?.[currentLocale] ||
+					fromFields.title?.[currentLocale] ||
+					`Tab Module ${id}`
+
+				let bodyCopyId
+				try {
+					bodyCopyId = await upsertBodyCopyEntry({
+						makeRequest,
+						bodyCopyIdByTabId,
+						tabModuleId: id,
+						currentLocale,
+						richText: inlineBodyCopy,
+						entryName,
+						existingBodyCopyId: bodyCopyIdByTabId.get(id),
+					})
+				} catch (error) {
+					process.stdout.write(
+						`[0095 down] Failed restoring bodyCopy for tabModule ${id} ` +
+							`(locale ${currentLocale}): ` +
+							`${JSON.stringify(summarizeErrorShape(error))}\n`
+					)
+					throw error
+				}
+
+				if (!bodyCopyId) {
+					return
+				}
+
+				return {
+					bodyCopyLink: {
+						sys: {
+							type: 'Link',
+							linkType: 'Entry',
+							id: bodyCopyId,
+						},
+					},
+				}
+			},
+		})
+
+		tabModule.deleteField('bodyCopy')
+		tabModule.changeFieldId('bodyCopyLink', 'bodyCopy')
+	},
+}

package/dist/cms/0096-delete-body-copy-content-type.cjs

@@ -0,0 +1,151 @@
+const addEntryNameField = require('../helpers/addEntryNameField.cjs')
+
+/**
+ * Delete the obsolete bodyCopy content type after 0095 inlined its RichText
+ * onto tabModule.
+ *
+ * Only tabModule referenced bodyCopy (0048-create-tab-module.cjs). After 0095
+ * removed that Link field, nothing else links to it — safe to wipe entries and
+ * delete the content type.
+ *
+ * Entry deletion uses makeRequest at migration start (execution of 0096), which
+ * is valid here because 0095 has already been applied to the environment.
+ */
+
+const BODY_COPY_RICH_TEXT_VALIDATIONS = [
+	{
+		enabledMarks: ['bold', 'italic', 'underline'],
+		message: 'Only bold, italic, and underline marks are allowed',
+	},
+	{
+		enabledNodeTypes: [
+			'ordered-list',
+			'unordered-list',
+			'hr',
+			'hyperlink',
+			'embedded-entry-inline',
+		],
+	},
+	{
+		nodes: {
+			'embedded-entry-inline': [
+				{
+					linkContentType: ['highlightedText'],
+					message: 'You can only embedd Higlighted Text.',
+				},
+			],
+		},
+	},
+]
+
+/**
+ * Unpublish (if needed) and delete a single entry via the CMA.
+ * Ignores 404 so retries / races are safe.
+ *
+ * @param {Function} makeRequest
+ * @param {string} entryId
+ */
+async function deleteEntry(makeRequest, entryId) {
+	let entry
+	try {
+		entry = await makeRequest({
+			method: 'GET',
+			url: `/entries/${entryId}`,
+		})
+	} catch (error) {
+		if (error?.status === 404 || error?.response?.status === 404) {
+			return
+		}
+		throw error
+	}
+
+	if (entry.sys.publishedVersion) {
+		try {
+			await makeRequest({
+				method: 'DELETE',
+				url: `/entries/${entryId}/published`,
+				headers: {
+					'X-Contentful-Version': String(entry.sys.version),
+				},
+			})
+			entry = await makeRequest({
+				method: 'GET',
+				url: `/entries/${entryId}`,
+			})
+		} catch (error) {
+			if (error?.status !== 404 && error?.response?.status !== 404) {
+				throw error
+			}
+			return
+		}
+	}
+
+	try {
+		await makeRequest({
+			method: 'DELETE',
+			url: `/entries/${entryId}`,
+			headers: {
+				'X-Contentful-Version': String(entry.sys.version),
+			},
+		})
+	} catch (error) {
+		if (error?.status !== 404 && error?.response?.status !== 404) {
+			throw error
+		}
+	}
+}
+
+/**
+ * Delete every entry of the given content type (paginated).
+ *
+ * @param {Function} makeRequest
+ * @param {string} contentTypeId
+ */
+async function deleteAllEntriesOfContentType(makeRequest, contentTypeId) {
+	const limit = 100
+
+	// Re-query from skip 0 after each page of deletes — indexes shift as
+	// entries drop, so a single ascending skip walk would miss rows.
+	for (;;) {
+		const page = await makeRequest({
+			method: 'GET',
+			url: `/entries?content_type=${contentTypeId}&limit=${limit}&skip=0&sys.archivedAt[exists]=false`,
+		})
+
+		const items = page.items ?? []
+		if (items.length === 0) {
+			break
+		}
+
+		for (const item of items) {
+			await deleteEntry(makeRequest, item.sys.id)
+		}
+	}
+}
+
+module.exports = {
+	// @ts-check
+	/** @type { import('contentful-migration').MigrationFunction } */
+	up: async function (migration, { makeRequest }) {
+		await deleteAllEntriesOfContentType(makeRequest, 'bodyCopy')
+		migration.deleteContentType('bodyCopy')
+	},
+
+	/** @type { import('contentful-migration').MigrationFunction } */
+	down: function (migration) {
+		const bodyCopy = migration.createContentType('bodyCopy', {
+			name: 'Body Copy',
+			displayField: 'entryName',
+			description: 'Manage the body copy module',
+		})
+
+		addEntryNameField(bodyCopy)
+
+		bodyCopy
+			.createField('bodyCopy')
+			.name('Body Copy')
+			.type('RichText')
+			.required(true)
+			.validations(BODY_COPY_RICH_TEXT_VALIDATIONS)
+	},
+}