@arkebcacy/beacon-cli-temp 0.1.3 → 0.1.5

package/package.json

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

package/src/cs/entries/getEntryLocales.ts

@@ -11,23 +11,8 @@ export interface LocaleInfo {
 	readonly uid: string;
 }
 
-interface LocalesResponse {
-	readonly locales: readonly LocaleInfo[];
-}
-
-function isLocaleInfo(o: unknown): o is LocaleInfo {
-	return (
-		isRecord(o) &&
-		typeof o.code === 'string' &&
-		typeof o.name === 'string' &&
-		typeof o.uid === 'string'
-	);
-}
-
-function isLocalesResponse(o: unknown): o is LocalesResponse {
-	return (
-		isRecord(o) && Array.isArray(o.locales) && o.locales.every(isLocaleInfo)
-	);
+function isLocaleInfoRecord(o: unknown): o is Record<string, unknown> {
+	return isRecord(o) && typeof o.code === 'string';
 }
 
 /**
@@ -73,9 +58,33 @@ export default async function getEntryLocales(
 
 	const result = data as unknown;
 
-	if (!isLocalesResponse(result)) {
+	if (!isRecord(result)) {
 		throw new Error(msg);
 	}
 
-	return result.locales;
+	const raw = result.locales;
+	if (!Array.isArray(raw)) {
+		throw new Error(msg);
+	}
+
+	const normalized: LocaleInfo[] = raw.map((item) => {
+		const rec = isLocaleInfoRecord(item)
+			? item
+			: ({ code: '' } as Record<string, unknown>);
+		const code = typeof rec.code === 'string' ? rec.code : '';
+		const name = typeof rec.name === 'string' ? rec.name : code;
+		const uid = typeof rec.uid === 'string' ? rec.uid : code;
+
+		// Only include `fallback_locale` when present as a string. Construct
+		// the object with the correct shape so TypeScript can verify it against
+		// `LocaleInfo` without unsafe casts.
+		const locale =
+			typeof rec.fallback_locale === 'string'
+				? { code, fallback_locale: rec.fallback_locale, name, uid }
+				: { code, name, uid };
+
+		return locale;
+	});
+
+	return normalized;
 }

package/src/cs/labels/getAllLabels.ts

@@ -0,0 +1,18 @@
+import ContentstackError from '../api/ContentstackError.js';
+import type Client from '../api/Client.js';
+import isRecord from '#cli/util/isRecord.js';
+
+export default async function getAllLabels(client: Client): Promise<unknown[]> {
+	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);
+	if (isRecord(data) && Array.isArray(data.labels)) {
+		return data.labels as unknown[];
+	}
+	if (Array.isArray(data)) {
+		return data as unknown[];
+	}
+	return [];
+}

package/src/dto/entry/beaconReplacer/lib/mapItemPathToAsset.ts

@@ -6,7 +6,15 @@ export default function mapItemPathToAsset(
 	this: BeaconReplacer,
 	itemPath: string,
 ) {
-	const result = resolveRawAssetItem(this.ctx.cs.assets.byParentUid, itemPath);
+	const normalized = itemPath
+		.split('/')
+		.map((s) => s.replace(/\s+/gu, ' ').trim())
+		.join('/');
+
+	const result = resolveRawAssetItem(
+		this.ctx.cs.assets.byParentUid,
+		normalized,
+	);
 
 	if (!result) {
 		throw new Error(`Could not find asset ${itemPath}.`);

package/src/schema/entries/toFilesystem.ts

@@ -5,6 +5,7 @@ import type { Entry } from '#cli/cs/entries/Types.js';
 import transformEntry from '#cli/dto/entry/fromCs.js';
 import writeYaml from '#cli/fs/writeYaml.js';
 import getUi from '#cli/schema/lib/SchemaUi.js';
+import sanitize from 'sanitize-filename';
 import escapeRegex from '#cli/util/escapeRegex.js';
 import type ProgressBar from '#cli/ui/progress/ProgressBar.js';
 import { readdir, rm } from 'node:fs/promises';
@@ -78,8 +79,17 @@ function createWriteFn(
 			return;
 		}
 
-		// If only one locale, save without locale suffix for backward compatibility
-		const useLocaleSuffix = locales.length > 1;
+		// 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.
 
 		// Write all locale versions in parallel for better performance
 		const writePromises = locales.map(async (locale) =>
@@ -162,10 +172,20 @@ function resolveFilename(
 	}
 
 	const generated = filenamesByTitle.get(entry.title);
-	if (!generated) {
-		const msg = `No filename found for entry [${entry.uid}]: ${entry.title}`;
-		throw new Error(msg);
+	if (generated) {
+		return generated;
 	}
 
-	return generated;
+	// Fallback: sanitize the entry title to produce a filename so deletions
+	// and other operations do not fail when a mapping is missing. This can
+	// happen when entries exist on one side but not the other during merge
+	// plans. Use the same sanitization rules as `generateFilenames`.
+	const fallback = sanitizeFilename(entry.title) + '.yaml';
+	return fallback;
+}
+
+function sanitizeFilename(name: string): string {
+	const raw = name.trim();
+	const sanitized = sanitize(raw, { replacement: '_' });
+	return sanitized.trim() || 'Untitled';
 }

package/src/schema/isEquivalentSchema.test.ts

@@ -22,3 +22,87 @@ test('Equal schemas are equal', () => {
 		expect(isEquivalentSchema(read, exportFixture)).toBe(true);
 	}),
 );
+
+test('Schemas with different labels are not equivalent', () => {
+	const baseSchema: Schema = {
+		description: '',
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	const schemaWithLabels: Schema = {
+		...baseSchema,
+		labels: ['label1', 'label2'],
+	};
+
+	expect(isEquivalentSchema(baseSchema, schemaWithLabels)).toBe(false);
+});
+
+test('Schemas with same labels are equivalent', () => {
+	const schema1: Schema = {
+		description: '',
+		labels: ['label1', 'label2'],
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	const schema2: Schema = {
+		description: '',
+		labels: ['label1', 'label2'],
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	expect(isEquivalentSchema(schema1, schema2)).toBe(true);
+});

package/src/schema/labels/toContentstack.ts

@@ -0,0 +1,139 @@
+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';
+
+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();
+	}
+
+	const labels =
+		isRecord(data) && Array.isArray(data.labels)
+			? data.labels
+			: Array.isArray(data)
+				? (data as unknown[])
+				: [];
+
+	ui.info(`Labels: read ${labels.length} label(s) from ${path}`);
+
+	const results = new MutableTransferResults();
+
+	for (const labelRaw of labels) {
+		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;
+			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: 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: 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: 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>');
+}
+
+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,24 @@
+import getAllLabels from '#cli/cs/labels/getAllLabels.js';
+import writeYaml from '#cli/fs/writeYaml.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 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 });
+
+	const result = new MutableTransferResults();
+	result.created.add('labels.yaml');
+	bar.increment();
+	return result;
+}
+
+//# sourceMappingURL=toFilesystem.js.map

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/normalize.test.ts

@@ -18,3 +18,101 @@ test('Normalization of an exported schema should match snapshot', async () => {
 	const snapPath = getSnapshotPath('normalize-exported-schema.yaml');
 	await expect(output).toMatchFileSnapshot(snapPath);
 });
+
+test('Normalization preserves labels when present', () => {
+	// Arrange
+	const schemaWithLabels: Schema = {
+		description: 'Test content type',
+		labels: ['label1', 'label2'],
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	// Act
+	const normalized = normalize(schemaWithLabels);
+
+	// Assert
+	expect(normalized.labels).toEqual(['label1', 'label2']);
+});
+
+test('Normalization preserves empty labels array', () => {
+	// Arrange
+	const schemaWithEmptyLabels: Schema = {
+		description: 'Test content type',
+		labels: [],
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	// Act
+	const normalized = normalize(schemaWithEmptyLabels);
+
+	// Assert
+	expect(normalized.labels).toEqual([]);
+});
+
+test('Normalization does not add labels when absent', () => {
+	// Arrange
+	const schemaWithoutLabels: Schema = {
+		description: 'Test content type',
+		options: {
+			is_page: false,
+			singleton: false,
+			sub_title: [],
+			title: 'title',
+		},
+		schema: [
+			{
+				data_type: 'text',
+				display_name: 'Title',
+				mandatory: true,
+				multiple: false,
+				non_localizable: false,
+				uid: 'title',
+				unique: true,
+			},
+		],
+		title: 'Test',
+		uid: 'test',
+	};
+
+	// Act
+	const normalized = normalize(schemaWithoutLabels);
+
+	// Assert
+	expect(normalized).not.toHaveProperty('labels');
+});

package/src/schema/normalize.ts

@@ -7,15 +7,26 @@ import type { Schema } from '#cli/cs/Types.js';
 //   - SYS_ACL
 //
 // Last observed: 2024-07-26.
+//
+// This function normalizes a schema by extracting only the fields that are
+// considered stable and should be compared for equivalence. Fields like
+// labels are preserved when present to ensure they are not lost during
+// serialization/deserialization cycles.
 export default function normalize({
 	description,
+	labels,
 	options,
 	schema,
 	title,
 	uid,
 }: Schema) {
+	const normalizedLabels = Array.isArray(labels)
+		? (labels as string[]).slice().sort()
+		: labels;
+
 	return {
 		description,
+		...(normalizedLabels ? { labels: normalizedLabels } : {}),
 		options,
 		schema: normalizeSchema(schema),
 		title,

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;
 }