@arkebcacy/beacon-cli-temp 0.1.5 → 0.1.7

package/src/schema/entries/toContentstack.ts

@@ -3,6 +3,7 @@ import deleteEntry from '#cli/cs/entries/delete.js';
 import getEntryLocales from '#cli/cs/entries/getEntryLocales.js';
 import importEntry from '#cli/cs/entries/import.js';
 import type { Entry } from '#cli/cs/entries/Types.js';
+import { ensureLocaleExists } from '#cli/cs/locales/ensureLocaleExists.js';
 import BeaconReplacer from '#cli/dto/entry/BeaconReplacer.js';
 import type ProgressBar from '#cli/ui/progress/ProgressBar.js';
 import type Ctx from '../ctx/Ctx.js';
@@ -45,7 +46,45 @@ export default async function toContentstack(
 		update,
 	});
 
-	for (const title of result.unmodified) {
+	// Process unmodified entries to ensure all locale versions are synced
+	await processUnmodifiedEntries(
+		result.unmodified,
+		ctx,
+		contentType,
+		csEntriesByTitle,
+		fsEntriesByTitle,
+		transformer,
+		filenamesByTitle,
+	);
+
+	return result;
+}
+
+function shouldSyncLocales(
+	fsLocaleVersions: Awaited<ReturnType<typeof loadFsLocaleVersions>>,
+	csLocaleSet: Set<string>,
+): boolean {
+	// Check if we have new locale versions that don't exist in Contentstack
+	const fsLocaleSet = new Set(
+		fsLocaleVersions.map((lv) => (lv.locale === 'default' ? null : lv.locale)),
+	);
+	return Array.from(fsLocaleSet).some(
+		(locale) => locale !== null && !csLocaleSet.has(locale),
+	);
+}
+
+async function processUnmodifiedEntries(
+	unmodified: Iterable<string>,
+	ctx: Ctx,
+	contentType: ContentType,
+	csEntriesByTitle: ReadonlyMap<string, Entry>,
+	fsEntriesByTitle: ReadonlyMap<string, Entry>,
+	transformer: BeaconReplacer,
+	filenamesByTitle: ReadonlyMap<Entry['uid'], string>,
+) {
+	const ui = getUi();
+
+	for (const title of unmodified) {
 		const cs = csEntriesByTitle.get(title);
 		const fs = fsEntriesByTitle.get(title);
 
@@ -60,11 +99,33 @@ export default async function toContentstack(
 			throw new Error(`No matching entry found for ${title}.`);
 		}
 
+		// Load all locale versions from filesystem
+		const fsLocaleVersions = await loadFsLocaleVersions(
+			fs,
+			contentType.uid,
+			filenamesByTitle,
+		);
+
+		const csLocaleSet = await getExistingLocales(ctx, contentType, cs.uid);
+
+		// Only push if there are new locale versions to sync
+		if (!shouldSyncLocales(fsLocaleVersions, csLocaleSet)) {
+			continue;
+		}
+
+		// Push all locale versions (including new locales like zh-cn)
+		await updateAllLocales(
+			ctx,
+			transformer,
+			contentType,
+			fsLocaleVersions,
+			cs.uid,
+			csLocaleSet,
+		);
+
 		const entry = { ...fs, uid: cs.uid };
 		ctx.references.recordEntryForReferences(contentType.uid, entry);
 	}
-
-	return result;
 }
 
 function buildUpdateFn(
@@ -141,6 +202,13 @@ async function updateAllLocales(
 	entryUid: string,
 	csLocaleSet: Set<string>,
 ) {
+	// Ensure all required locales exist in the target stack before pushing entries
+	const localeEnsurePromises = fsLocaleVersions
+		.filter((lv) => lv.locale !== 'default')
+		.map(async (lv) => ensureLocaleExists(ctx.cs.client, lv.locale));
+
+	await Promise.all(localeEnsurePromises);
+
 	// Import all locale versions in parallel for better performance
 	const importPromises = fsLocaleVersions.map(async (localeVersion) => {
 		const transformed = transformer.process(localeVersion.entry);
@@ -148,9 +216,10 @@ async function updateAllLocales(
 		// Pass undefined for 'default' locale (single-locale backward compat)
 		const locale =
 			localeVersion.locale === 'default' ? undefined : localeVersion.locale;
-		const overwrite = locale
-			? csLocaleSet.has(localeVersion.locale)
-			: csLocaleSet.size > 0;
+
+		// Always use overwrite=true for locale-specific versions since the entry exists.
+		// For 'default' locale (single-locale backward compat), only overwrite if entry has locales.
+		const overwrite = locale ? true : csLocaleSet.size > 0;
 
 		return importEntry(
 			ctx.cs.client,

package/src/schema/entries/toFilesystem.ts

@@ -80,28 +80,24 @@ function createWriteFn(
 		}
 
 		// If only one locale, save without locale suffix for backward compatibility.
-		// When multiple locales exist prefer writing a single base file when an
-		// English locale is present (fixtures expect base filenames like
-		// `Autumn Feast and Social.yaml`). Only use locale suffix when no
-		// English locale is available.
-		const hasEnglish = locales.some((l) => /^en(?:[-_]|$)/iu.test(l.code));
-		const useLocaleSuffix = locales.length > 1 && !hasEnglish;
-
-		// Log locale details for debugging why specific locales (e.g. Chinese)
-		// may not be written to the filesystem.
-		// Debug logging removed to avoid unsafe-call lint errors.
+		// When multiple locales exist, write English as base file and other locales
+		// with locale suffixes (e.g., Entry.yaml for English, Entry.zh-chs.yaml for Chinese)
 
 		// Write all locale versions in parallel for better performance
-		const writePromises = locales.map(async (locale) =>
-			writeLocaleVersion(
+		const writePromises = locales.map(async (locale) => {
+			const isEnglish = /^en(?:[-_]|$)/iu.test(locale.code);
+			// Use locale suffix for non-English locales when multiple locales exist
+			const useLocaleSuffix = locales.length > 1 && !isEnglish;
+
+			return writeLocaleVersion(
 				ctx,
 				contentType,
 				entry,
 				locale.code,
 				getBasePath,
 				useLocaleSuffix,
-			),
-		);
+			);
+		});
 
 		await Promise.all(writePromises);
 	};
@@ -122,8 +118,27 @@ async function writeLocaleVersion(
 		localeCode,
 	);
 
+	// Skip writing this locale version if it's a fallback (locale doesn't match requested)
+	// This happens when Contentstack returns the default locale content because
+	// no localized version exists for the requested locale
+	if (
+		useLocaleSuffix &&
+		exported.locale &&
+		typeof exported.locale === 'string' &&
+		exported.locale !== localeCode
+	) {
+		// This is a fallback locale, skip writing it
+		return;
+	}
+
 	const { uid, ...transformed } = transformEntry(ctx, contentType, exported);
 
+	// Preserve the actual locale code from the source stack
+	// This ensures we maintain the exact language-region configuration
+	if ('locale' in transformed) {
+		transformed.locale = localeCode;
+	}
+
 	const basePath = getBasePath(entry);
 	const filePath = useLocaleSuffix
 		? basePath.replace(/\.yaml$/u, `.${localeCode}.yaml`)

package/src/schema/labels/lib/labelHelpers.ts

@@ -0,0 +1,36 @@
+import isRecord from '#cli/util/isRecord.js';
+
+export function canonicalize(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		const result: unknown[] = [];
+		for (const item of value) {
+			result.push(canonicalize(item));
+		}
+		return result;
+	}
+	if (isRecord(value)) {
+		const obj: Record<string, unknown> = value;
+		const out: Record<string, unknown> = {};
+		const objKeys: string[] = Object.keys(obj);
+		objKeys.sort();
+		for (const key of objKeys) {
+			if (key === 'uid' || key === 'created_at' || key === 'updated_at')
+				continue;
+			// Normalize parent: skip if empty array
+			const val: unknown = obj[key];
+			if (key === 'parent' && Array.isArray(val) && val.length === 0) continue;
+			const canonicalizedVal: unknown = canonicalize(val);
+			out[key] = canonicalizedVal;
+		}
+		return out;
+	}
+	return value;
+}
+
+export function prepareLabel(
+	label: Record<string, unknown>,
+): Record<string, unknown> {
+	// Labels are sent to the API with all fields intact
+	// The API expects the parent field as an array
+	return label;
+}

package/src/schema/labels/lib/labelOperations.ts

@@ -0,0 +1,74 @@
+import ContentstackError from '#cli/cs/api/ContentstackError.js';
+import isRecord from '#cli/util/isRecord.js';
+import type Ctx from '../../ctx/Ctx.js';
+import type { MutableTransferResults } from '../../xfer/TransferResults.js';
+import type Label from '#cli/cs/labels/Label.js';
+import { canonicalize, prepareLabel } from './labelHelpers.js';
+
+export async function updateIfNecessary(
+	ctx: Ctx,
+	uid: string,
+	localLabel: Record<string, unknown>,
+	remoteLabel: Label | undefined,
+	results: MutableTransferResults,
+) {
+	if (!remoteLabel) {
+		// If we don't have remote data, err on the side of updating
+		const res = (await ctx.cs.client.PUT('/v3/labels/{label_uid}', {
+			body: { label: prepareLabel(localLabel) },
+			params: { path: { label_uid: uid } },
+		})) as unknown;
+		const putError = (res as { error?: unknown } | undefined)?.error;
+		ContentstackError.throwIfError(putError, `Failed to update label: ${uid}`);
+		results.updated.add(uid);
+		return;
+	}
+
+	let shouldUpdate = true;
+	try {
+		shouldUpdate =
+			JSON.stringify(canonicalize(localLabel)) !==
+			JSON.stringify(canonicalize(remoteLabel));
+	} catch {
+		shouldUpdate = true;
+	}
+
+	if (!shouldUpdate) return;
+
+	const res = (await ctx.cs.client.PUT('/v3/labels/{label_uid}', {
+		body: { label: prepareLabel(localLabel) },
+		params: { path: { label_uid: uid } },
+	})) as unknown;
+	const putError = (res as { error?: unknown } | undefined)?.error;
+	ContentstackError.throwIfError(putError, `Failed to update label: ${uid}`);
+	results.updated.add(uid);
+}
+
+export async function createLabel(
+	ctx: Ctx,
+	localLabel: Record<string, unknown>,
+	results: MutableTransferResults,
+): Promise<string | null> {
+	const res = (await ctx.cs.client.POST('/v3/labels', {
+		body: { label: prepareLabel(localLabel) },
+	})) as unknown;
+
+	const postError = (res as { error?: unknown } | undefined)?.error;
+	const labelName = typeof localLabel.name === 'string' ? localLabel.name : '';
+	ContentstackError.throwIfError(
+		postError,
+		`Failed to create label: ${labelName}`,
+	);
+	const postData = (res as { data?: unknown } | undefined)?.data;
+	let createdUid: string | null = null;
+	if (isRecord(postData)) {
+		const pd = postData;
+		if (isRecord(pd.label)) {
+			const labelObj = pd.label;
+			if (typeof labelObj.uid === 'string') createdUid = labelObj.uid;
+		}
+		if (createdUid === null && typeof pd.uid === 'string') createdUid = pd.uid;
+	}
+	results.created.add(createdUid ?? '<created>');
+	return createdUid;
+}

package/src/schema/labels/toContentstack.ts

@@ -1,139 +1,256 @@
 import readYaml from '#cli/fs/readYaml.js';
-import schemaDirectory from '../content-types/schemaDirectory.js';
-import ContentstackError from '#cli/cs/api/ContentstackError.js';
 import type Ctx from '../ctx/Ctx.js';
 import { MutableTransferResults } from '../xfer/TransferResults.js';
 import getUi from '../lib/SchemaUi.js';
 import isRecord from '#cli/util/isRecord.js';
+import flatten from '#cli/dto/labels/flatten.js';
+import { isNormalizedLabels } from '#cli/dto/labels/NormalizedLabels.js';
+import type Label from '#cli/cs/labels/Label.js';
+import getAllLabels from '#cli/cs/labels/getAllLabels.js';
+import { createLabel, updateIfNecessary } from './lib/labelOperations.js';
+import { resolve } from 'node:path';
 
-export default async function toContentstack(ctx: Ctx) {
-	const directory = schemaDirectory();
-	const path = `${directory}/labels.yaml`;
+/**
+ * Sort labels to ensure parents are processed before children.
+ * Labels without parents come first, then labels are sorted by dependency depth.
+ */
+function sortLabelsByDependency(labels: Label[]): Label[] {
+	const labelsByUid = new Map<string, Label>();
+	const sorted: Label[] = [];
+	const processed = new Set<string>();
+
+	// Build a map for quick lookup
+	for (const label of labels) {
+		if (isRecord(label) && typeof label.uid === 'string') {
+			labelsByUid.set(label.uid, label as Label);
+		}
+	}
 
+	// Recursive function to add a label and its dependencies
+	function addLabel(label: Label) {
+		const uid = typeof label.uid === 'string' ? label.uid : '';
+		if (!uid || processed.has(uid)) return;
+
+		// First, process parent if it exists in our label set
+		const parentArray = label.parent;
+		if (Array.isArray(parentArray) && parentArray.length > 0) {
+			// Use destructuring to satisfy eslint prefer-destructuring rule
+			const [parentValue] = parentArray as unknown as readonly [
+				string,
+				...string[],
+			];
+			if (labelsByUid.has(parentValue) && !processed.has(parentValue)) {
+				const parentLabel = labelsByUid.get(parentValue);
+				if (parentLabel) addLabel(parentLabel);
+			}
+		}
+
+		// Now add this label
+		sorted.push(label);
+		processed.add(uid);
+	}
+
+	// Process all labels
+	for (const label of labels) {
+		if (isRecord(label)) {
+			addLabel(label as Label);
+		}
+	}
+
+	return sorted;
+}
+
+export default async function toContentstack(ctx: Ctx) {
 	const ui = getUi();
+	const path = resolve(ui.options.schema.schemaPath, 'labels.yaml');
 
-	let data: unknown;
-	try {
-		data = await readYaml(path);
-	} catch {
-		ui.info(`Labels: no file at ${path}, skipping`);
+	const data = await loadLabelsData(path, ui);
+	if (!data) {
 		return new MutableTransferResults();
 	}
 
-	const labels =
-		isRecord(data) && Array.isArray(data.labels)
-			? data.labels
-			: Array.isArray(data)
-				? (data as unknown[])
-				: [];
+	const flatLabels = extractFlatLabels(data);
+	ui.info(`Labels: read ${flatLabels.length} label(s) from ${path}`);
 
-	ui.info(`Labels: read ${labels.length} label(s) from ${path}`);
+	const {
+		localUidToName,
+		nameToRemoteUid,
+		remoteLabelsByName,
+		remoteLabelsByUid,
+	} = await prepareLabelMappings(ctx, flatLabels);
 
+	const sortedLabels = sortLabelsByDependency(flatLabels);
 	const results = new MutableTransferResults();
 
-	for (const labelRaw of labels) {
+	for (const labelRaw of sortedLabels) {
 		if (!isRecord(labelRaw)) continue;
-		// keep per-label logic in helper to reduce complexity of this function
 
-		await handleLabel(ctx, labelRaw, results);
+		await handleLabel(
+			ctx,
+			labelRaw,
+			remoteLabelsByUid,
+			remoteLabelsByName,
+			nameToRemoteUid,
+			localUidToName,
+			results,
+		);
 	}
 
 	return results;
 }
 
-function canonicalize(value: unknown): unknown {
-	if (Array.isArray(value)) return value.map(canonicalize);
-	if (isRecord(value)) {
-		const obj = value;
-		const out: Record<string, unknown> = {};
-		for (const key of Object.keys(obj).sort()) {
-			if (key === 'uid' || key === 'created_at' || key === 'updated_at')
-				continue;
-			out[key] = canonicalize(obj[key]);
-		}
-		return out;
+async function loadLabelsData(
+	path: string,
+	ui: ReturnType<typeof getUi>,
+): Promise<unknown> {
+	try {
+		return await readYaml(path);
+	} catch {
+		ui.info(`Labels: no file at ${path}, skipping`);
+		return undefined;
 	}
-	return value;
 }
 
-async function updateIfNecessary(
-	ctx: Ctx,
-	uid: string,
-	localLabel: Record<string, unknown>,
-	results: MutableTransferResults,
-) {
-	const remoteRes = (await ctx.cs.client.GET('/v3/labels/{label_uid}', {
-		params: { path: { label_uid: uid } },
-	})) as unknown;
-	const remoteData = (remoteRes as { data?: unknown } | undefined)?.data;
-
-	if (!isRecord(remoteData) || !isRecord(remoteData.label)) {
-		// If we can't parse remote data, err on the side of updating
-		const res = (await ctx.cs.client.PUT('/v3/labels/{label_uid}', {
-			body: { label: localLabel },
-			params: { path: { label_uid: uid } },
-		})) as unknown;
-		const putError = (res as { error?: unknown } | undefined)?.error;
-		ContentstackError.throwIfError(putError, `Failed to update label: ${uid}`);
-		results.updated.add(uid);
-		return;
+function extractFlatLabels(data: unknown): Label[] {
+	if (isNormalizedLabels(data)) {
+		interface LabelWithChildren {
+			children?: unknown;
+		}
+		const hasChildren = (data.labels as unknown as LabelWithChildren[]).some(
+			(l) => 'children' in l && l.children !== undefined,
+		);
+
+		if (hasChildren) {
+			return [...flatten(data.labels)];
+		}
+		return [...data.labels] as unknown as Label[];
 	}
 
-	const remoteLabel = remoteData.label;
-	let shouldUpdate = true;
-	try {
-		shouldUpdate =
-			JSON.stringify(canonicalize(localLabel)) !==
-			JSON.stringify(canonicalize(remoteLabel));
-	} catch {
-		shouldUpdate = true;
+	if (isRecord(data) && Array.isArray(data.labels)) {
+		return data.labels as Label[];
 	}
 
-	if (!shouldUpdate) return;
+	if (Array.isArray(data)) {
+		return data as Label[];
+	}
 
-	const res = (await ctx.cs.client.PUT('/v3/labels/{label_uid}', {
-		body: { label: localLabel },
-		params: { path: { label_uid: uid } },
-	})) as unknown;
-	const putError = (res as { error?: unknown } | undefined)?.error;
-	ContentstackError.throwIfError(putError, `Failed to update label: ${uid}`);
-	results.updated.add(uid);
+	return [];
 }
 
-async function createLabel(
-	ctx: Ctx,
-	localLabel: Record<string, unknown>,
-	results: MutableTransferResults,
-) {
-	const res = (await ctx.cs.client.POST('/v3/labels', {
-		body: { label: localLabel },
-	})) as unknown;
-	const postError = (res as { error?: unknown } | undefined)?.error;
-	ContentstackError.throwIfError(postError, `Failed to create label`);
-	const postData = (res as { data?: unknown } | undefined)?.data;
-	let createdUid: string | null = null;
-	if (isRecord(postData)) {
-		const pd = postData;
-		if (isRecord(pd.label)) {
-			const labelObj = pd.label;
-			if (typeof labelObj.uid === 'string') createdUid = labelObj.uid;
+async function prepareLabelMappings(ctx: Ctx, flatLabels: Label[]) {
+	const remoteLabels = await getAllLabels(ctx.cs.client);
+	const remoteLabelsByUid = new Map<string, Label>();
+	const remoteLabelsByName = new Map<string, Label>();
+
+	for (const label of remoteLabels) {
+		remoteLabelsByUid.set(label.uid, label);
+		remoteLabelsByName.set(label.name, label);
+	}
+
+	const nameToRemoteUid = new Map<string, string>();
+	for (const [name, label] of remoteLabelsByName) {
+		nameToRemoteUid.set(name, label.uid);
+	}
+
+	const localUidToName = new Map<string, string>();
+	for (const label of flatLabels) {
+		if (
+			isRecord(label) &&
+			typeof label.uid === 'string' &&
+			typeof label.name === 'string'
+		) {
+			localUidToName.set(label.uid, label.name);
 		}
-		if (createdUid === null && typeof pd.uid === 'string') createdUid = pd.uid;
 	}
-	results.created.add(createdUid ?? '<created>');
+
+	return {
+		localUidToName,
+		nameToRemoteUid,
+		remoteLabelsByName,
+		remoteLabelsByUid,
+	};
 }
 
 async function handleLabel(
 	ctx: Ctx,
 	labelRaw: Record<string, unknown>,
+	remoteLabelsByUid: Map<string, Label>,
+	remoteLabelsByName: Map<string, Label>,
+	nameToRemoteUid: Map<string, string>,
+	localUidToName: Map<string, string>,
 	results: MutableTransferResults,
 ) {
 	const uid = typeof labelRaw.uid === 'string' ? labelRaw.uid : '';
+	const name = typeof labelRaw.name === 'string' ? labelRaw.name : '';
+
+	const preparedLabel = translateParentReference(
+		labelRaw,
+		localUidToName,
+		nameToRemoteUid,
+	);
+
+	// First try to find by UID (exact match from same stack)
+	if (uid.length > 0 && remoteLabelsByUid.has(uid)) {
+		const remoteLabel = remoteLabelsByUid.get(uid);
+		await updateIfNecessary(ctx, uid, preparedLabel, remoteLabel, results);
+		return;
+	}
 
-	if (uid.length) {
-		await updateIfNecessary(ctx, uid, labelRaw, results);
+	// Then try to find by name (for cross-stack scenarios)
+	if (name.length > 0 && remoteLabelsByName.has(name)) {
+		const remoteLabel = remoteLabelsByName.get(name);
+		if (!remoteLabel) {
+			return;
+		}
+		await updateIfNecessary(
+			ctx,
+			remoteLabel.uid,
+			preparedLabel,
+			remoteLabel,
+			results,
+		);
+		nameToRemoteUid.set(name, remoteLabel.uid);
 		return;
 	}
 
-	await createLabel(ctx, labelRaw, results);
+	// Label doesn't exist remotely, create it
+	const createdUid = await createLabel(ctx, preparedLabel, results);
+
+	if (createdUid && name) {
+		nameToRemoteUid.set(name, createdUid);
+	}
+}
+
+function translateParentReference(
+	labelRaw: Record<string, unknown>,
+	localUidToName: Map<string, string>,
+	nameToRemoteUid: Map<string, string>,
+): Record<string, unknown> {
+	const parentField = labelRaw.parent;
+	if (!Array.isArray(parentField) || parentField.length === 0) {
+		return { ...labelRaw };
+	}
+
+	// TypeScript knows parentField is an array, but we need to type it properly
+	const [firstElement] = parentField as unknown[];
+	if (typeof firstElement !== 'string') {
+		return { ...labelRaw };
+	}
+	const firstParent: string = firstElement;
+
+	const parentName = localUidToName.get(firstParent);
+
+	if (!parentName || !nameToRemoteUid.has(parentName)) {
+		return { ...labelRaw };
+	}
+
+	const remoteParentUid = nameToRemoteUid.get(parentName);
+	if (!remoteParentUid) {
+		return { ...labelRaw };
+	}
+
+	return {
+		...labelRaw,
+		parent: [remoteParentUid],
+	};
 }

package/src/schema/labels/toFilesystem.ts

@@ -1,24 +1,30 @@
 import getAllLabels from '#cli/cs/labels/getAllLabels.js';
 import writeYaml from '#cli/fs/writeYaml.js';
-import schemaDirectory from '../content-types/schemaDirectory.js';
+import organize from '#cli/dto/labels/organize.js';
 import { MutableTransferResults } from '../xfer/TransferResults.js';
 import createProgressBar from '../lib/createProgressBar.js';
 import type Ctx from '../ctx/Ctx.js';
+import getUi from '../lib/SchemaUi.js';
+import { resolve } from 'node:path';
 
 export default async function toFilesystem(ctx: Ctx) {
-	const directory = schemaDirectory();
+	const ui = getUi();
+	const {
+		options: {
+			schema: { schemaPath },
+		},
+	} = ui;
+	const labelsPath = resolve(schemaPath, 'labels.yaml');
 	const bar = createProgressBar('Labels', 1, 0);
 
-	// Fetch labels and write them directly. processPlan shortcuts when the
-	// merge plan is empty, so for a single-file resource we write and return
-	// a simple TransferResults object.
-	const labels = await getAllLabels(ctx.cs.client);
-	await writeYaml(`${directory}/labels.yaml`, { labels });
+	// Fetch labels and organize them into a hierarchical structure
+	const flatLabels = await getAllLabels(ctx.cs.client);
+	const hierarchicalLabels = organize(flatLabels);
+
+	await writeYaml(labelsPath, { labels: hierarchicalLabels });
 
 	const result = new MutableTransferResults();
 	result.created.add('labels.yaml');
 	bar.increment();
 	return result;
 }
-
-//# sourceMappingURL=toFilesystem.js.map