@arkebcacy/beacon-cli-temp 0.1.5 → 0.1.6

package/package.json

@@ -50,5 +50,5 @@
     "prepack": "node ./build/prepack.js"
   },
   "type": "module",
-  "version": "0.1.5"
+  "version": "0.1.6"
 }

package/src/cs/labels/Label.ts

@@ -0,0 +1,16 @@
+import type OmitIndex from '../../util/OmitIndex.js';
+import type { Item } from '../Types.js';
+import { isItem } from '../Types.js';
+
+export default interface Label extends OmitIndex<Item> {
+	readonly name: string;
+	readonly parent_uid: string | null;
+}
+
+export function isLabel(o: unknown): o is Label {
+	return (
+		isItem(o) &&
+		typeof o.name === 'string' &&
+		(o.parent_uid === null || typeof o.parent_uid === 'string')
+	);
+}

package/src/cs/labels/getAllLabels.ts

@@ -1,18 +1,43 @@
 import ContentstackError from '../api/ContentstackError.js';
 import type Client from '../api/Client.js';
 import isRecord from '#cli/util/isRecord.js';
+import type Label from './Label.js';
+import { isLabel } from './Label.js';
 
-export default async function getAllLabels(client: Client): Promise<unknown[]> {
+export default async function getAllLabels(client: Client): Promise<Label[]> {
 	const res = (await client.GET('/v3/labels')) as unknown;
 	const data = (res as { data?: unknown } | undefined)?.data;
 	const error = (res as { error?: unknown } | undefined)?.error;
 	const msg = `Failed to fetch labels`;
 	ContentstackError.throwIfError(error, msg);
+
+	let rawLabels: unknown[] = [];
 	if (isRecord(data) && Array.isArray(data.labels)) {
-		return data.labels as unknown[];
+		rawLabels = data.labels;
+	} else if (Array.isArray(data)) {
+		rawLabels = data;
 	}
-	if (Array.isArray(data)) {
-		return data as unknown[];
+
+	// Transform raw labels to ensure they have parent_uid (null if not present)
+	const labels: Label[] = [];
+	for (const raw of rawLabels) {
+		if (
+			isRecord(raw) &&
+			typeof raw.uid === 'string' &&
+			typeof raw.name === 'string'
+		) {
+			// Preserve all fields from the remote label
+			const label: Label = {
+				...raw,
+				name: raw.name,
+				parent_uid: typeof raw.parent_uid === 'string' ? raw.parent_uid : null,
+				uid: raw.uid,
+			};
+			if (isLabel(label)) {
+				labels.push(label);
+			}
+		}
 	}
-	return [];
+
+	return labels;
 }

package/src/dto/labels/NormalizedLabels.ts

@@ -0,0 +1,47 @@
+import isRecord from '#cli/util/isRecord.js';
+import type Label from '#cli/cs/labels/Label.js';
+import { isItem } from '#cli/cs/Types.js';
+
+export default interface NormalizedLabels {
+	readonly labels: readonly LabelTreeNode[];
+}
+
+export interface LabelTreeNode {
+	// Allow any additional fields from the label
+	readonly [key: string]: unknown;
+	readonly uid: Label['uid'];
+	readonly name: Label['name'];
+	readonly children?: readonly LabelTreeNode[];
+}
+
+export function key() {
+	return 'labels';
+}
+
+export function isNormalizedLabels(
+	value: unknown,
+): value is NormalizedLabels & Record<string, unknown> {
+	if (!isRecord(value)) {
+		return false;
+	}
+
+	return Array.isArray(value.labels) && value.labels.every(isLabelTreeNode);
+}
+
+function isLabelTreeNode(value: unknown): value is LabelTreeNode {
+	if (!isItem(value)) {
+		return false;
+	}
+
+	if (typeof value.name !== 'string') {
+		return false;
+	}
+
+	if (!('children' in value)) {
+		return true;
+	}
+
+	const { children } = value;
+
+	return Array.isArray(children) && children.every(isLabelTreeNode);
+}

package/src/dto/labels/flatten.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import flatten from './flatten.js';
+import type { LabelTreeNode } from './NormalizedLabels.js';
+
+describe('flatten', () => {
+	it('flattens a simple hierarchy', () => {
+		const tree: LabelTreeNode[] = [
+			{
+				children: [
+					{ name: 'Child 1', uid: 'child1' },
+					{ name: 'Child 2', uid: 'child2' },
+				],
+				name: 'Parent',
+				uid: 'parent',
+			},
+		];
+
+		const result = flatten(tree);
+
+		expect(result).toEqual([
+			{ name: 'Parent', parent_uid: null, uid: 'parent' },
+			{ name: 'Child 1', parent_uid: 'parent', uid: 'child1' },
+			{ name: 'Child 2', parent_uid: 'parent', uid: 'child2' },
+		]);
+	});
+
+	it('flattens nested hierarchy', () => {
+		const tree: LabelTreeNode[] = [
+			{
+				children: [
+					{ name: 'Calculator', uid: 'calculator' },
+					{ name: 'Data', uid: 'data' },
+					{ name: 'Page', uid: 'page' },
+				],
+				name: 'Component',
+				uid: 'component',
+			},
+		];
+
+		const result = flatten(tree);
+
+		expect(result).toEqual([
+			{ name: 'Component', parent_uid: null, uid: 'component' },
+			{ name: 'Calculator', parent_uid: 'component', uid: 'calculator' },
+			{ name: 'Data', parent_uid: 'component', uid: 'data' },
+			{ name: 'Page', parent_uid: 'component', uid: 'page' },
+		]);
+	});
+
+	it('handles deeply nested hierarchy', () => {
+		const tree: LabelTreeNode[] = [
+			{
+				children: [
+					{
+						children: [
+							{
+								children: [{ name: 'Level 3', uid: 'level3' }],
+								name: 'Level 2',
+								uid: 'level2',
+							},
+						],
+						name: 'Level 1',
+						uid: 'level1',
+					},
+				],
+				name: 'Root',
+				uid: 'root',
+			},
+		];
+
+		const result = flatten(tree);
+
+		expect(result).toEqual([
+			{ name: 'Root', parent_uid: null, uid: 'root' },
+			{ name: 'Level 1', parent_uid: 'root', uid: 'level1' },
+			{ name: 'Level 2', parent_uid: 'level1', uid: 'level2' },
+			{ name: 'Level 3', parent_uid: 'level2', uid: 'level3' },
+		]);
+	});
+
+	it('handles multiple top-level labels', () => {
+		const tree: LabelTreeNode[] = [
+			{ name: 'Label 1', uid: 'label1' },
+			{
+				children: [{ name: 'Child', uid: 'child' }],
+				name: 'Label 2',
+				uid: 'label2',
+			},
+		];
+
+		const result = flatten(tree);
+
+		expect(result).toEqual([
+			{ name: 'Label 1', parent_uid: null, uid: 'label1' },
+			{ name: 'Label 2', parent_uid: null, uid: 'label2' },
+			{ name: 'Child', parent_uid: 'label2', uid: 'child' },
+		]);
+	});
+
+	it('handles empty array', () => {
+		const result = flatten([]);
+		expect(result).toEqual([]);
+	});
+
+	it('handles labels without children', () => {
+		const tree: LabelTreeNode[] = [
+			{ name: 'Label 1', uid: 'label1' },
+			{ name: 'Label 2', uid: 'label2' },
+		];
+
+		const result = flatten(tree);
+
+		expect(result).toEqual([
+			{ name: 'Label 1', parent_uid: null, uid: 'label1' },
+			{ name: 'Label 2', parent_uid: null, uid: 'label2' },
+		]);
+	});
+});

package/src/dto/labels/flatten.ts

@@ -0,0 +1,27 @@
+import type Label from '#cli/cs/labels/Label.js';
+import type { LabelTreeNode } from './NormalizedLabels.js';
+
+export default function flatten(
+	labels: readonly LabelTreeNode[],
+): readonly Label[] {
+	const result: Label[] = [];
+
+	function traverse(nodes: readonly LabelTreeNode[], parentUid: string | null) {
+		for (const node of nodes) {
+			const { children, ...label } = node;
+
+			result.push({
+				...label,
+				parent_uid: parentUid,
+			} as Label);
+
+			if (children) {
+				traverse(children, node.uid);
+			}
+		}
+	}
+
+	traverse(labels, null);
+
+	return result;
+}

package/src/dto/labels/organize.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'vitest';
+import organize from './organize.js';
+import type Label from '#cli/cs/labels/Label.js';
+
+describe('organize', () => {
+	it('organizes flat labels into hierarchy', () => {
+		const labels: Label[] = [
+			{ name: 'Parent', parent_uid: null, uid: 'parent' },
+			{ name: 'Child 1', parent_uid: 'parent', uid: 'child1' },
+			{ name: 'Child 2', parent_uid: 'parent', uid: 'child2' },
+		];
+
+		const result = organize(labels);
+
+		expect(result).toEqual([
+			{
+				children: [
+					{ name: 'Child 1', uid: 'child1' },
+					{ name: 'Child 2', uid: 'child2' },
+				],
+				name: 'Parent',
+				uid: 'parent',
+			},
+		]);
+	});
+
+	it('organizes component label structure from screenshot', () => {
+		const labels: Label[] = [
+			{ name: 'Component', parent_uid: null, uid: 'component' },
+			{ name: 'Calculator', parent_uid: 'component', uid: 'calculator' },
+			{ name: 'Data', parent_uid: 'component', uid: 'data' },
+			{ name: 'Page', parent_uid: 'component', uid: 'page' },
+		];
+
+		const result = organize(labels);
+
+		expect(result).toEqual([
+			{
+				children: [
+					{ name: 'Calculator', uid: 'calculator' },
+					{ name: 'Data', uid: 'data' },
+					{ name: 'Page', uid: 'page' },
+				],
+				name: 'Component',
+				uid: 'component',
+			},
+		]);
+	});
+
+	it('handles deeply nested labels', () => {
+		const labels: Label[] = [
+			{ name: 'Root', parent_uid: null, uid: 'root' },
+			{ name: 'Level 1', parent_uid: 'root', uid: 'level1' },
+			{ name: 'Level 2', parent_uid: 'level1', uid: 'level2' },
+			{ name: 'Level 3', parent_uid: 'level2', uid: 'level3' },
+		];
+
+		const result = organize(labels);
+
+		expect(result).toEqual([
+			{
+				children: [
+					{
+						children: [
+							{
+								children: [{ name: 'Level 3', uid: 'level3' }],
+								name: 'Level 2',
+								uid: 'level2',
+							},
+						],
+						name: 'Level 1',
+						uid: 'level1',
+					},
+				],
+				name: 'Root',
+				uid: 'root',
+			},
+		]);
+	});
+
+	it('handles multiple top-level labels', () => {
+		const labels: Label[] = [
+			{ name: 'Label 1', parent_uid: null, uid: 'label1' },
+			{ name: 'Label 2', parent_uid: null, uid: 'label2' },
+			{ name: 'Child', parent_uid: 'label2', uid: 'child' },
+		];
+
+		const result = organize(labels);
+
+		expect(result).toEqual([
+			{ name: 'Label 1', uid: 'label1' },
+			{
+				children: [{ name: 'Child', uid: 'child' }],
+				name: 'Label 2',
+				uid: 'label2',
+			},
+		]);
+	});
+
+	it('handles empty array', () => {
+		const result = organize([]);
+		expect(result).toEqual([]);
+	});
+
+	it('throws error for orphaned label', () => {
+		const labels: Label[] = [
+			{ name: 'Child', parent_uid: 'nonexistent', uid: 'child' },
+		];
+
+		expect(() => organize(labels)).toThrow(
+			'Orphaned label child with parent nonexistent',
+		);
+	});
+
+	it('preserves order of siblings', () => {
+		const labels: Label[] = [
+			{ name: 'Parent', parent_uid: null, uid: 'parent' },
+			{ name: 'Child 3', parent_uid: 'parent', uid: 'child3' },
+			{ name: 'Child 1', parent_uid: 'parent', uid: 'child1' },
+			{ name: 'Child 2', parent_uid: 'parent', uid: 'child2' },
+		];
+
+		const result = organize(labels);
+
+		expect(result[0]?.children).toEqual([
+			{ name: 'Child 3', uid: 'child3' },
+			{ name: 'Child 1', uid: 'child1' },
+			{ name: 'Child 2', uid: 'child2' },
+		]);
+	});
+});

package/src/dto/labels/organize.ts

@@ -0,0 +1,57 @@
+import type Label from '#cli/cs/labels/Label.js';
+import type { LabelTreeNode } from './NormalizedLabels.js';
+
+// Labels have a tree structure defined by uid/parent_uid.
+//
+// The API returns a flat array that includes uid/parent_uid, but
+// leaves it up to the client to reconstruct the tree.
+//
+// We organize labels into a tree structure for serialization.
+//
+// The sort order amongst siblings is maintained equal to the order
+// as it appears in the array.
+export default function organize(
+	labels: readonly Label[],
+): readonly LabelTreeNode[] {
+	const byUid = new Map<string, MutableNode>();
+	const topLevel: MutableNode[] = [];
+
+	for (const label of labels) {
+		const { parent_uid, ...labelWithoutParent } = label;
+		// Preserve all fields except parent_uid (which is represented by the tree structure)
+		byUid.set(label.uid, {
+			...labelWithoutParent,
+			name: label.name,
+			uid: label.uid,
+		});
+	}
+
+	for (const { uid, parent_uid } of labels) {
+		const label = byUid.get(uid);
+		if (!label) {
+			throw new Error(`Label ${uid} not found`);
+		}
+
+		if (!parent_uid) {
+			topLevel.push(label);
+			continue;
+		}
+
+		const parent = byUid.get(parent_uid);
+		if (!parent) {
+			const msg = `Orphaned label ${uid} with parent ${parent_uid}`;
+			throw new Error(msg);
+		}
+
+		(parent.children ??= []).push(label);
+	}
+
+	return topLevel;
+}
+
+interface MutableNode {
+	[key: string]: unknown;
+	readonly uid: string;
+	readonly name: string;
+	children?: MutableNode[];
+}

package/src/schema/labels/toContentstack.ts

@@ -5,6 +5,9 @@ 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';
 
 export default async function toContentstack(ctx: Ctx) {
 	const directory = schemaDirectory();
@@ -20,18 +23,24 @@ export default async function toContentstack(ctx: Ctx) {
 		return new MutableTransferResults();
 	}
 
-	const labels =
-		isRecord(data) && Array.isArray(data.labels)
-			? data.labels
-			: Array.isArray(data)
-				? (data as unknown[])
-				: [];
+	// 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[];
+	}
 
-	ui.info(`Labels: read ${labels.length} label(s) from ${path}`);
+	ui.info(`Labels: read ${flatLabels.length} label(s) from ${path}`);
 
 	const results = new MutableTransferResults();
 
-	for (const labelRaw of labels) {
+	for (const labelRaw of flatLabels) {
 		if (!isRecord(labelRaw)) continue;
 		// keep per-label logic in helper to reduce complexity of this function
 
@@ -49,6 +58,9 @@ function canonicalize(value: unknown): 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;
@@ -70,7 +82,7 @@ async function updateIfNecessary(
 	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 },
+			body: { label: prepareLabel(localLabel) },
 			params: { path: { label_uid: uid } },
 		})) as unknown;
 		const putError = (res as { error?: unknown } | undefined)?.error;
@@ -92,7 +104,7 @@ async function updateIfNecessary(
 	if (!shouldUpdate) return;
 
 	const res = (await ctx.cs.client.PUT('/v3/labels/{label_uid}', {
-		body: { label: localLabel },
+		body: { label: prepareLabel(localLabel) },
 		params: { path: { label_uid: uid } },
 	})) as unknown;
 	const putError = (res as { error?: unknown } | undefined)?.error;
@@ -106,7 +118,7 @@ async function createLabel(
 	results: MutableTransferResults,
 ) {
 	const res = (await ctx.cs.client.POST('/v3/labels', {
-		body: { label: localLabel },
+		body: { label: prepareLabel(localLabel) },
 	})) as unknown;
 	const postError = (res as { error?: unknown } | undefined)?.error;
 	ContentstackError.throwIfError(postError, `Failed to create label`);
@@ -123,6 +135,16 @@ async function createLabel(
 	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 };
+	}
+	return rest;
+}
+
 async function handleLabel(
 	ctx: Ctx,
 	labelRaw: Record<string, unknown>,

package/src/schema/labels/toFilesystem.ts

@@ -1,5 +1,6 @@
 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';
@@ -9,16 +10,14 @@ export default async function toFilesystem(ctx: Ctx) {
 	const directory = schemaDirectory();
 	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(`${directory}/labels.yaml`, { labels: hierarchicalLabels });
 
 	const result = new MutableTransferResults();
 	result.created.add('labels.yaml');
 	bar.increment();
 	return result;
 }
-
-//# sourceMappingURL=toFilesystem.js.map