@arkebcacy/beacon-cli-temp 0.1.6 → 0.1.7

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,6 +1,4 @@
 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';
@@ -8,154 +6,251 @@ 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>();
 
-	const ui = getUi();
+	// 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);
+		}
+	}
 
-	let data: unknown;
-	try {
-		data = await readYaml(path);
-	} catch {
-		ui.info(`Labels: no file at ${path}, skipping`);
-		return new MutableTransferResults();
+	// 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);
 	}
 
-	// Support both hierarchical and flat label structures
-	let flatLabels: Label[] = [];
-	if (isNormalizedLabels(data)) {
-		// Hierarchical structure - flatten it first
-		flatLabels = [...flatten(data.labels)];
-	} else if (isRecord(data) && Array.isArray(data.labels)) {
-		// Legacy flat array format
-		flatLabels = data.labels as Label[];
-	} else if (Array.isArray(data)) {
-		// Direct array format
-		flatLabels = data as Label[];
+	// 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');
+
+	const data = await loadLabelsData(path, ui);
+	if (!data) {
+		return new MutableTransferResults();
+	}
+
+	const flatLabels = extractFlatLabels(data);
 	ui.info(`Labels: read ${flatLabels.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 flatLabels) {
+	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;
-			// Normalize parent_uid: skip if null or undefined
-			if (key === 'parent_uid' && (obj[key] === null || obj[key] === undefined))
-				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: 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;
+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: 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 [];
 }
 
-async function createLabel(
-	ctx: Ctx,
-	localLabel: Record<string, unknown>,
-	results: MutableTransferResults,
-) {
-	const res = (await ctx.cs.client.POST('/v3/labels', {
-		body: { label: prepareLabel(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;
-		}
-		if (createdUid === null && typeof pd.uid === 'string') createdUid = pd.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);
 	}
-	results.created.add(createdUid ?? '<created>');
-}
 
-// Prepare label for API by removing parent_uid if null
-function prepareLabel(label: Record<string, unknown>): Record<string, unknown> {
-	const { parent_uid, ...rest } = label;
-	// Only include parent_uid if it's a non-null string
-	if (typeof parent_uid === 'string') {
-		return { ...rest, parent_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);
+		}
 	}
-	return rest;
+
+	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,
+	);
 
-	if (uid.length) {
-		await updateIfNecessary(ctx, uid, labelRaw, results);
+	// 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;
 	}
 
-	await createLabel(ctx, 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;
+	}
+
+	// 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,20 +1,27 @@
 import getAllLabels from '#cli/cs/labels/getAllLabels.js';
 import writeYaml from '#cli/fs/writeYaml.js';
 import organize from '#cli/dto/labels/organize.js';
-import schemaDirectory from '../content-types/schemaDirectory.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 organize them into a hierarchical structure
 	const flatLabels = await getAllLabels(ctx.cs.client);
 	const hierarchicalLabels = organize(flatLabels);
 
-	await writeYaml(`${directory}/labels.yaml`, { labels: hierarchicalLabels });
+	await writeYaml(labelsPath, { labels: hierarchicalLabels });
 
 	const result = new MutableTransferResults();
 	result.created.add('labels.yaml');