@arkebcacy/beacon-cli-temp 0.1.4 → 0.1.6

package/src/schema/labels/toContentstack.ts

@@ -0,0 +1,161 @@
+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';
+
+export default async function toContentstack(ctx: Ctx) {
+	const directory = schemaDirectory();
+	const path = `${directory}/labels.yaml`;
+
+	const ui = getUi();
+
+	let data: unknown;
+	try {
+		data = await readYaml(path);
+	} catch {
+		ui.info(`Labels: no file at ${path}, skipping`);
+		return new MutableTransferResults();
+	}
+
+	// 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 ${flatLabels.length} label(s) from ${path}`);
+
+	const results = new MutableTransferResults();
+
+	for (const labelRaw of flatLabels) {
+		if (!isRecord(labelRaw)) continue;
+		// keep per-label logic in helper to reduce complexity of this function
+
+		await handleLabel(ctx, labelRaw, 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;
+	}
+	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;
+	}
+
+	const remoteLabel = remoteData.label;
+	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);
+}
+
+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;
+	}
+	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>,
+	results: MutableTransferResults,
+) {
+	const uid = typeof labelRaw.uid === 'string' ? labelRaw.uid : '';
+
+	if (uid.length) {
+		await updateIfNecessary(ctx, uid, labelRaw, results);
+		return;
+	}
+
+	await createLabel(ctx, labelRaw, results);
+}

package/src/schema/labels/toFilesystem.ts

@@ -0,0 +1,23 @@
+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';
+
+export default async function toFilesystem(ctx: Ctx) {
+	const directory = schemaDirectory();
+	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 });
+
+	const result = new MutableTransferResults();
+	result.created.add('labels.yaml');
+	bar.increment();
+	return result;
+}

package/src/schema/lib/createProgressBar.ts

@@ -2,8 +2,16 @@ import getUi from './SchemaUi.js';
 
 export default function createProgressBar(
 	name: string,
-	...indicies: readonly ReadonlyMap<unknown, unknown>[]
+	...indicies: readonly (ReadonlyMap<unknown, unknown> | number)[]
 ) {
-	const totalSize = new Set(indicies.flatMap((x) => [...x.keys()])).size;
+	const sizes = indicies.map((x) => {
+		if (typeof x === 'number') return x;
+		try {
+			return [...x.keys()].length;
+		} catch {
+			return 0;
+		}
+	});
+	const totalSize = sizes.reduce((a, b) => a + b, 0);
 	return getUi().createProgressBar(name, totalSize);
 }

package/src/schema/lib/pullModules.ts

@@ -1,6 +1,7 @@
 import type { ContentType } from '#cli/cs/content-types/Types.js';
 import assets from '../assets/toFilesystem.js';
 import contentTypes from '../content-types/toFilesystem.js';
+import labels from '../labels/toFilesystem.js';
 import type Ctx from '../ctx/Ctx.js';
 import clean from '../entries/clean.js';
 import entries from '../entries/toFilesystem.js';
@@ -15,6 +16,7 @@ export default async function* pullModules(
 	yield ['Assets', assets(ctx)];
 	yield ['Global Fields', globalFields(ctx)];
 	yield ['Taxonomies', taxonomies(ctx)];
+	yield ['Labels', labels(ctx)];
 	yield ['Content Types', contentTypes(ctx)];
 
 	const summary = summarizeContentTypes(ctx);

package/src/schema/push.ts

@@ -11,6 +11,7 @@ import PushResults from './lib/PushResults.js';
 import getUi from './lib/SchemaUi.js';
 import taxonomies from './taxonomies/toContentstack.js';
 import terms from './terms/toContentstack.js';
+import labels from './labels/toContentstack.js';
 
 export default async function push(client: Client) {
 	const results = new PushResults();
@@ -62,6 +63,7 @@ export default async function push(client: Client) {
 	}
 
 	await results.set('References', updateMissedReferences(ctx));
+	await results.set('Labels', labels(ctx));
 	return results.value;
 }