@arkebcacy/beacon-cli-temp 0.1.1

package/src/cs/entries/lib/isEmptyJsonRTEValue.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import isEmptyJsonRTEValue from './isEmptyJsonRTEValue.js';
+
+describe(isEmptyJsonRTEValue.name, () => {
+	const theories: readonly Theory[] = [
+		new Theory(true, 'is empty with no children', []),
+
+		new Theory(true, 'is empty with one empty child', [
+			{
+				attrs: {},
+				children: [{ text: '' }],
+				type: 'p',
+				uid: 'unique-id',
+			},
+		]),
+
+		new Theory(false, 'has multiple children', [
+			{
+				attrs: {},
+				children: [{ text: '' }],
+				type: 'p',
+				uid: 'unique-id',
+			},
+			{
+				attrs: {},
+				children: [{ text: '' }],
+				type: 'p',
+				uid: 'unique-id',
+			},
+		]),
+
+		new Theory(false, 'has multiple descendants', [
+			{
+				attrs: {},
+				children: [{ text: '' }, { text: 'extra' }],
+				type: 'p',
+				uid: 'unique-id',
+			},
+		]),
+
+		new Theory(false, 'has non-empty text in child', [
+			{
+				attrs: {},
+				children: [{ text: 'not empty' }],
+				type: 'p',
+				uid: 'unique-id',
+			},
+		]),
+
+		new Theory(false, 'has non-paragraph type', [
+			{
+				attrs: {},
+				children: [{ text: '' }],
+				type: 'div',
+				uid: 'unique-id',
+			},
+		]),
+	];
+
+	theories.forEach((theory) => {
+		it(`returns ${theory.expected} when the value ${theory.name}.`, () => {
+			// Arrange
+			const value = {
+				_version: 1,
+				attrs: {},
+				children: theory.content,
+				type: 'doc',
+				uid: '07cc2e39fcc94427ae255b8e5f32fce2',
+			};
+
+			const result = isEmptyJsonRTEValue(value);
+			expect(result).toBe(theory.expected);
+		});
+	});
+});
+
+class Theory {
+	public constructor(
+		public readonly expected: boolean,
+		public readonly name: string,
+		public readonly content: readonly Record<string, unknown>[],
+	) {}
+}

package/src/cs/entries/lib/isEmptyJsonRTEValue.ts

@@ -0,0 +1,56 @@
+import isRecord from '#cli/util/isRecord.js';
+import { isDeepStrictEqual } from 'node:util';
+
+export default function isEmptyJsonRTEValue(value: Record<string, unknown>) {
+	if (value.type !== 'doc') {
+		return false;
+	}
+
+	const { attrs, children } = value;
+
+	if (attrs && !isDeepStrictEqual(attrs, {})) {
+		return false;
+	}
+
+	if (!children) {
+		return true;
+	}
+
+	if (!Array.isArray(children)) {
+		return false;
+	}
+
+	return (
+		children.length === 0 ||
+		(children.length === 1 && isEmptyChild(children[0]))
+	);
+}
+
+function isEmptyChild(child: unknown): boolean {
+	if (child === undefined) {
+		return true;
+	}
+
+	if (!isRecord(child)) {
+		return false;
+	}
+
+	const { attrs, type, children } = child;
+
+	if (type !== 'p') {
+		return false;
+	}
+
+	if (attrs && !isDeepStrictEqual(attrs, {})) {
+		return false;
+	}
+
+	if (!children) {
+		return true;
+	}
+
+	return (
+		Array.isArray(children) &&
+		(children.length === 0 || isDeepStrictEqual(children, [{ text: '' }]))
+	);
+}

package/src/cs/entries/lib/parseImportResponse.ts

@@ -0,0 +1,32 @@
+import ContentstackError from '#cli/cs/api/ContentstackError.js';
+import isRecord from '#cli/util/isRecord.js';
+import { isEntry } from '../Types.js';
+
+export default function parseImportResponse(
+	response: {
+		data?: unknown;
+		error?: unknown;
+		response: Response;
+	},
+	context: string,
+) {
+	ContentstackError.throwIfError(response.error, context);
+
+	if (!response.response.ok) {
+		throw new Error(context);
+	}
+
+	const { data } = response;
+
+	if (!isRecord(data)) {
+		throw new TypeError(context);
+	}
+
+	const { entry: importedEntry } = data;
+
+	if (!isEntry(importedEntry)) {
+		throw new Error(context);
+	}
+
+	return importedEntry;
+}

package/src/cs/entries/lib/removeEmptyJsonRTEs.ts

@@ -0,0 +1,33 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import EntryWalker from '#cli/cs/entryWalker/EntryWalker.js';
+import type { Schema, SchemaField } from '#cli/cs/Types.js';
+import isJsonRteField from '#cli/dto/entry/lib/isJsonRteField.js';
+import isRecord from '#cli/util/isRecord.js';
+import type { Entry, ReferencePath } from '../Types.js';
+import isEmptyJsonRTEValue from './isEmptyJsonRTEValue.js';
+
+export default function removeEmptyJsonRTEs(
+	globalFieldsByUid: ReadonlyMap<Schema['uid'], Schema>,
+	contentType: ContentType,
+	x: Entry,
+) {
+	const context: ReferencePath = `${contentType.uid}/${x.title}`;
+	const walker = new EntryWalker(globalFieldsByUid, context, remove);
+	return walker.process(contentType.schema, x);
+}
+
+function remove(field: SchemaField, value: unknown) {
+	if (!isJsonRteField(field)) {
+		return value;
+	}
+
+	if (!isRecord(value)) {
+		return value;
+	}
+
+	if (isEmptyJsonRTEValue(value)) {
+		return;
+	}
+
+	return value;
+}

package/src/cs/entries/parseReferencePath.ts

@@ -0,0 +1,15 @@
+import type { ContentType } from '../content-types/Types.js';
+import type { Entry, ReferencePath } from './Types.js';
+
+export default function parseReferencePath(path: ReferencePath): {
+	readonly contentTypeUid: ContentType['uid'];
+	readonly title: Entry['title'];
+} {
+	const [contentTypeUid, ...titleSegments] = path.split('/');
+
+	if (typeof contentTypeUid !== 'string') {
+		throw new Error(`Invalid reference path: ${path}`);
+	}
+
+	return { contentTypeUid, title: titleSegments.join('/') };
+}

package/src/cs/entryWalker/EntryWalker.ts

@@ -0,0 +1,86 @@
+import type { Entry, ReferencePath } from '../entries/Types.js';
+import type { Schema, SchemaField, SchemaFields } from '../Types.js';
+import field from './lib/field.js';
+import globalField from './lib/globalField.js';
+import globalFields from './lib/globalFields.js';
+import group from './lib/group.js';
+import groups from './lib/groups.js';
+import modularBlock from './lib/modularBlock.js';
+import modularBlocks from './lib/modularBlocks.js';
+import node from './lib/node.js';
+import referenceBlock from './lib/referenceBlock.js';
+import resolveBlockTypes from './lib/resolveBlockTypes.js';
+import schemaBlock from './lib/schemaBlock.js';
+
+type CallbackFn = (field: SchemaField, value: unknown) => unknown;
+
+export default class EntryWalker {
+	protected readonly field: typeof field;
+	protected readonly globalField: typeof globalField;
+	protected readonly globalFields: typeof globalFields;
+	protected readonly group: typeof group;
+	protected readonly groups: typeof groups;
+	protected readonly modularBlock: typeof modularBlock;
+	protected readonly modularBlocks: typeof modularBlocks;
+	protected readonly node: typeof node;
+	protected readonly referenceBlock: typeof referenceBlock;
+	protected readonly resolveBlockTypes: typeof resolveBlockTypes;
+	protected readonly schemaBlock: typeof schemaBlock;
+
+	public constructor(
+		protected readonly globalFieldsByUid: ReadonlyMap<Schema['uid'], Schema>,
+		protected readonly context: ReferencePath,
+		protected readonly callback: CallbackFn,
+	) {
+		this.field = field.bind(this);
+		this.globalField = globalField.bind(this);
+		this.globalFields = globalFields.bind(this);
+		this.group = group.bind(this);
+		this.groups = groups.bind(this);
+		this.modularBlock = modularBlock.bind(this);
+		this.modularBlocks = modularBlocks.bind(this);
+		this.node = node.bind(this);
+		this.referenceBlock = referenceBlock.bind(this);
+		this.resolveBlockTypes = resolveBlockTypes.bind(this);
+		this.schemaBlock = schemaBlock.bind(this);
+	}
+
+	public process(schema: SchemaFields, entryNode: Entry): Entry {
+		const metaProperties = new Map<string, unknown>();
+		const entryProperties = new Map<string, unknown>();
+
+		for (const [key, value] of Object.entries(entryNode)) {
+			if (keysToRemove.has(key)) {
+				continue;
+			}
+
+			if (metaKeys.has(key)) {
+				metaProperties.set(key, value);
+			} else {
+				entryProperties.set(key, value);
+			}
+		}
+
+		const result = this.node(schema, Object.fromEntries(entryProperties));
+
+		return {
+			title: entryNode.title,
+			uid: entryNode.uid,
+			...result,
+			...Object.fromEntries(metaProperties),
+		};
+	}
+}
+
+const metaKeys = new Set<string>(['locale', 'tags']);
+
+const keysToRemove = new Set<string>([
+	'_in_progress',
+	'_version',
+	'ACL',
+	'created_at',
+	'created_by',
+	'uid',
+	'updated_at',
+	'updated_by',
+]);

package/src/cs/entryWalker/lib/field.ts

@@ -0,0 +1,31 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function field(
+	this: EntryWalker,
+	schema: SchemaField,
+	value: unknown,
+) {
+	const mutated = this.callback(schema, value);
+	if (mutated === undefined) {
+		return;
+	}
+
+	switch (schema.data_type) {
+		case 'blocks':
+			return this.modularBlocks(schema, mutated);
+
+		case 'global_field':
+			return schema.multiple === true
+				? this.globalFields(schema, mutated)
+				: this.globalField(schema, mutated);
+
+		case 'group':
+			return schema.multiple === true
+				? this.groups(schema, mutated)
+				: this.group(schema, mutated);
+
+		default:
+			return mutated;
+	}
+}

package/src/cs/entryWalker/lib/globalField.ts

@@ -0,0 +1,41 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function globalField(
+	this: EntryWalker,
+	field: SchemaField,
+	value: unknown,
+) {
+	if (!isRecord(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains an unexpected global field`;
+		const msg2 = 'data structure:';
+		getUi().warn(msg1, msg2, value);
+		return value;
+	}
+
+	const { reference_to: referenceTo } = field;
+
+	if (typeof referenceTo !== 'string') {
+		const y = createStylus('yellowBright');
+		const msg = y`Entry ${this.context} references invalid global field:`;
+		getUi().warn(msg, field);
+		return value;
+	}
+
+	const match = this.globalFieldsByUid.get(referenceTo);
+
+	if (!match) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} references a global field named`;
+		const msg2 = y`${referenceTo}, which does not exist.`;
+		getUi().warn(msg1, msg2);
+		return value;
+	}
+
+	const { schema } = match;
+	return this.node(schema, value);
+}

package/src/cs/entryWalker/lib/globalFields.ts

@@ -0,0 +1,78 @@
+import type { Schema, SchemaField } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function globalFields(
+	this: EntryWalker,
+	field: SchemaField,
+	value: unknown,
+) {
+	const { reference_to: referenceTo } = field;
+
+	if (typeof referenceTo !== 'string') {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains an unexpected global`;
+		const msg2 = 'field reference. Expected to find the global field UID,';
+		const msg3 = y`but found: ${typeof referenceTo}.`;
+		getUi().warn(msg1, msg2, msg3);
+		return value;
+	}
+
+	const globalField = this.globalFieldsByUid.get(referenceTo);
+
+	if (!globalField) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} references a global field named`;
+		const msg2 = y`${referenceTo}, which does not exist.`;
+		getUi().warn(msg1, msg2);
+		return value;
+	}
+
+	if (!Array.isArray(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains a reference to`;
+		const msg2 = y`global field ${globalField.uid}. Expected the value`;
+		const msg3 = y`to be an array of groups, but found: ${typeof value}.`;
+		getUi().warn(msg1, msg2, msg3);
+		return value;
+	}
+
+	return value.map(processGlobalField.bind(this, globalField)).filter(Boolean);
+}
+
+function processGlobalField(
+	this: EntryWalker,
+	globalField: Schema,
+	value: unknown,
+	idx: number,
+) {
+	if (!isRecord(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} references global field`;
+		const msg2 = y`${globalField.uid}, which contains an unexpected data`;
+		const msg3 = y`structure at index ${idx.toLocaleString()}:`;
+		getUi().warn(msg1, msg2, msg3, value);
+		return value;
+	}
+
+	const processed = this.node(globalField.schema, value);
+	if (processed === undefined) {
+		return;
+	}
+
+	if (!isRecord(processed)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} references global field`;
+		const msg2 = y`${globalField.uid} that supports multiple values.`;
+		const msg3 = y`The value at index ${idx.toLocaleString()} was mutated`;
+		const msg4 = 'while normalizing the data structure, but the mutation';
+		const msg5 = 'resulted in an invalid global field value:';
+		getUi().warn(msg1, msg2, msg3, msg4, msg5, processed);
+		return value;
+	}
+
+	delete processed._metadata;
+	return processed;
+}

package/src/cs/entryWalker/lib/group.ts

@@ -0,0 +1,56 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import { isSchemaFields } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function group(
+	this: EntryWalker,
+	field: SchemaField,
+	value: unknown,
+) {
+	if (!isRecord(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains a group field (${field.uid})`;
+		const msg2 = 'with an unexpected data structure:';
+		getUi().warn(msg1, msg2, value);
+		return value;
+	}
+
+	if (!('schema' in field)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains a group field (${field.uid})`;
+		const msg2 = 'without a schema definition:';
+		getUi().warn(msg1, msg2, field);
+		return value;
+	}
+
+	const { schema } = field;
+
+	if (!isSchemaFields(schema)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains a group field (${field.uid})`;
+		const msg2 = 'with an invalid schema definition:';
+		getUi().warn(msg1, msg2, schema);
+		return value;
+	}
+
+	const processed = this.node(schema, value);
+
+	if (processed === undefined) {
+		return;
+	}
+
+	if (!isRecord(processed)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains a group field (${field.uid})`;
+		const msg2 = 'that was mutated during normalization, but the mutation';
+		const msg3 = 'resulted in an unexpected data structure:';
+		getUi().warn(msg1, msg2, msg3, processed);
+		return value;
+	}
+
+	delete processed._metadata;
+	return processed;
+}

package/src/cs/entryWalker/lib/groups.ts

@@ -0,0 +1,20 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function groups(
+	this: EntryWalker,
+	field: SchemaField,
+	value: unknown,
+) {
+	if (!Array.isArray(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.context} contains an group[multiple=true]`;
+		const msg2 = y`field named ${field.uid}, whose value is not an array:`;
+		getUi().warn(msg1, msg2, value);
+		return value;
+	}
+
+	return value.map(this.group.bind(this, field));
+}

package/src/cs/entryWalker/lib/modularBlock.ts

@@ -0,0 +1,101 @@
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type { Item } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function modularBlock(
+	this: EntryWalker,
+	blockTypes: ReadonlyMap<string, Item>,
+	block: unknown,
+	idx: number,
+) {
+	if (!isRecord(block)) {
+		getUi().warn(...unexpectedDataStructure(this.context, idx), block);
+		return block;
+	}
+
+	const [[blockType, blockValue] = []] = Object.entries(block);
+	if (!blockType) {
+		getUi().warn(...missingBlockType(this.context, idx), block);
+		return block;
+	}
+
+	const matchingBlockType = blockTypes.get(blockType);
+	if (!matchingBlockType) {
+		getUi().warn(...unknownBlockType(this.context, blockType, idx));
+		return block;
+	}
+
+	if (!isRecord(blockValue)) {
+		getUi().warn(
+			...unexpectedBlockType(this.context, blockType, idx),
+			blockValue,
+		);
+
+		return;
+	}
+
+	const result =
+		this.schemaBlock(matchingBlockType, blockValue) ??
+		this.referenceBlock(matchingBlockType, blockValue);
+
+	if (result) {
+		const { _metadata, ...rest } = result;
+		return { [blockType]: rest };
+	}
+
+	getUi().warn(...invalidBlockType(this.context, blockType, idx));
+	return block;
+}
+
+function unexpectedDataStructure(context: ReferencePath, idx: number) {
+	const y = createStylus('yellowBright');
+	const msg1 = y`Entry ${context} contains an unexpected modular block`;
+	const msg2 = y`data structure at index ${idx.toLocaleString()}:`;
+	return [msg1, msg2];
+}
+
+function missingBlockType(context: ReferencePath, idx: number) {
+	const y = createStylus('yellowBright');
+	const msg1 = y`Entry ${context} contains an invalid`;
+	const msg2 = y`modular block at index ${idx.toLocaleString()}:`;
+	return [msg1, msg2];
+}
+
+function unknownBlockType(
+	context: ReferencePath,
+	blockType: string,
+	idx: number,
+) {
+	const y = createStylus('yellowBright');
+	const msg1 = y`Entry ${context} references an unknown`;
+	const msg2 = y`modular block type (${blockType})`;
+	const msg3 = y`at index ${idx.toLocaleString()}.`;
+	return [msg1, msg2, msg3];
+}
+
+function unexpectedBlockType(
+	context: ReferencePath,
+	blockType: string,
+	idx: number,
+) {
+	const y = createStylus('yellowBright');
+	const msg1 = y`Entry ${context} references modular block type`;
+	const msg2 = y`${blockType} with an unexpected data structure`;
+	const msg3 = y`at index ${idx.toLocaleString()}:`;
+	return [msg1, msg2, msg3];
+}
+
+function invalidBlockType(
+	context: ReferencePath,
+	blockType: string,
+	idx: number,
+) {
+	const y = createStylus('yellowBright');
+	const msg1 = y`Entry ${context} references modular block type`;
+	const msg2 = y`${blockType} with an invalid schema at index`;
+	const msg3 = y`${idx.toLocaleString()}.`;
+	return [msg1, msg2, msg3];
+}

package/src/cs/entryWalker/lib/modularBlocks.ts

@@ -0,0 +1,27 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import type EntryWalker from '../EntryWalker.js';
+
+export default function modularBlocks(
+	this: EntryWalker,
+	field: SchemaField,
+	value: unknown,
+) {
+	const blockTypes = this.resolveBlockTypes(field);
+	if (!blockTypes) {
+		// resolveBlockTypes has multiple reasons for possible failure and is
+		// responsible for its own logging.
+		return value;
+	}
+
+	if (!Array.isArray(value)) {
+		const y = createStylus('yellowBright');
+		const msg1 = y`Expected modular blocks in entry ${this.context}`;
+		const msg2 = y`to be an array, but found [${typeof value}]:`;
+		getUi().warn(msg1, msg2, value);
+		return value;
+	}
+
+	return value.map(this.modularBlock.bind(this, blockTypes));
+}