@arkebcacy/beacon-cli-temp 0.1.1

package/src/cs/assets/index.ts

@@ -0,0 +1,48 @@
+import type Client from '../api/Client.js';
+import readPaginatedItems from '../api/paginate/readPaginatedItems.js';
+import typecheckArray from '../typecheckArray.js';
+import { itemKey } from '../Types.js';
+import type { RawAssetItem } from './Types.js';
+import { isRawAssetItem } from './Types.js';
+
+export default async function index(
+	client: Client,
+): Promise<ReadonlyMap<string, RawAssetItem>> {
+	return readPaginatedItems<RawAssetItem>(
+		'assets',
+		itemKey,
+		fetchFn.bind(null, client),
+		mapFn,
+	);
+}
+
+function mapFn(data: Record<string, unknown>) {
+	const { assets: items, count } = data;
+
+	if (!typecheckArray(isRawAssetItem, 'assets', items)) {
+		throw new Error('Invalid response from Contentstack');
+	}
+
+	return {
+		items,
+		...(typeof count === 'number' ? { count } : {}),
+	};
+}
+
+async function fetchFn(client: Client, skip: number) {
+	const query: {
+		include_folders: 'true';
+		include_count?: 'true';
+		skip?: number;
+	} = { include_folders: 'true' };
+
+	if (skip) {
+		query.skip = skip;
+	} else {
+		query.include_count = 'true';
+	}
+
+	return client.GET('/v3/assets', {
+		params: { query },
+	});
+}

package/src/cs/assets/lib/assetBody.ts

@@ -0,0 +1,52 @@
+import mime from 'mime/lite';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { getBlobPath } from '../../../schema/assets/lib/NamingConvention.js';
+import type { RawAsset } from '../Types.js';
+
+type MutableFields = 'description' | 'parent_uid' | 'tags' | 'title';
+type Props = Partial<Pick<RawAsset, MutableFields>> & {
+	readonly filePath?: string;
+};
+
+export default async function assetBody({
+	description,
+	filePath,
+	parent_uid: parentUid,
+	tags: allTags,
+	title,
+}: Props) {
+	const tags = new Set(allTags ?? []);
+	const fd = new FormData();
+
+	if (description) {
+		fd.append('asset[description]', description);
+	}
+
+	if (parentUid) {
+		fd.append('asset[parent_uid]', parentUid);
+	}
+
+	if (tags.size > 0) {
+		fd.append('asset[tags]', [...tags].join(', '));
+	}
+
+	if (title) {
+		fd.append('asset[title]', title);
+	}
+
+	if (filePath) {
+		const value = await readFile(getBlobPath(filePath));
+
+		fd.append(
+			'asset[upload]',
+			new Blob([value], {
+				endings: 'transparent',
+				type: mime.getType(filePath) ?? 'application/octet-stream',
+			}),
+			basename(filePath),
+		);
+	}
+
+	return fd;
+}

package/src/cs/assets/lib/indexByParent.ts

@@ -0,0 +1,20 @@
+import type { RawAssetItem } from '../Types.js';
+
+export default function indexByParent(
+	byUid: ReadonlyMap<string, RawAssetItem>,
+): ReadonlyMap<string | null, ReadonlySet<RawAssetItem>> {
+	const byParentId = new Map<string | null, Set<RawAssetItem>>();
+
+	for (const item of byUid.values()) {
+		const parentId = item.parent_uid;
+		const existing = byParentId.get(parentId);
+
+		if (existing) {
+			existing.add(item);
+		} else {
+			byParentId.set(parentId, new Set([item]));
+		}
+	}
+
+	return byParentId;
+}

package/src/cs/assets/lib/resolveRawAssetItem.ts

@@ -0,0 +1,25 @@
+import type { RawAssetItem } from '../Types.js';
+import { isRawAsset } from '../Types.js';
+
+export default function resolveRawAssetItem(
+	byParent: ReadonlyMap<string | null, ReadonlySet<RawAssetItem>>,
+	itemPath: string,
+): RawAssetItem | undefined {
+	const path = itemPath.split('/');
+	const name = path.pop();
+	const parentPath = path.join('/');
+
+	const parent = parentPath
+		? (resolveRawAssetItem(byParent, parentPath) ?? null)
+		: null;
+
+	for (const child of byParent.get(parent?.uid ?? null) ?? []) {
+		if (isRawAsset(child)) {
+			if (child.filename === name) {
+				return child;
+			}
+		} else if (child.name === name) {
+			return child;
+		}
+	}
+}

package/src/cs/assets/update.ts

@@ -0,0 +1,47 @@
+import isRecord from '#cli/util/isRecord.js';
+import type Client from '../api/Client.js';
+import type { operations } from '../api/cma-openapi-3.js';
+import ContentstackError from '../api/ContentstackError.js';
+import assetBody from './lib/assetBody.js';
+import { isRawAsset, type RawAsset } from './Types.js';
+
+type MutableFields = 'description' | 'parent_uid' | 'tags' | 'title';
+type Operation = operations['uploadasset'];
+type Body = Operation['requestBody']['content']['multipart/form-data'];
+
+type UpdatedAsset = Partial<Pick<RawAsset, MutableFields>> &
+	Pick<RawAsset, 'uid'> & {
+		readonly filePath?: string;
+	};
+
+export default async function update(client: Client, updated: UpdatedAsset) {
+	const body = await assetBody(updated);
+
+	const { data, error, response } = await client.PUT('/v3/assets/{asset_uid}', {
+		// as unknown as Body because the typing in the OpenAPI spec gets
+		// tricky with FormData
+		body: body as unknown as Body,
+		params: { path: { asset_uid: updated.uid } },
+	});
+
+	const msg = `Failed to update asset: ${updated.uid}`;
+	ContentstackError.throwIfError(error, msg);
+
+	if (!response.ok) {
+		throw new Error(msg);
+	}
+
+	const result = data as unknown;
+
+	if (!isRecord(result)) {
+		throw new Error(msg);
+	}
+
+	const { asset } = result;
+
+	if (!isRawAsset(asset)) {
+		throw new Error(msg);
+	}
+
+	return asset;
+}

package/src/cs/content-types/Types.ts

@@ -0,0 +1,4 @@
+import type { Schema } from '../Types.js';
+
+// Using aliases to try to make this code a little more readable.
+export type ContentType = Schema;

package/src/cs/content-types/delete.ts

@@ -0,0 +1,21 @@
+import type Client from '../api/Client.js';
+import ContentstackError from '../api/ContentstackError.js';
+
+export default async function deleteContentType(client: Client, uid: string) {
+	const { error, response } = await client.DELETE(
+		'/v3/content_types/{content_type_uid}',
+		{
+			params: {
+				path: { content_type_uid: uid },
+				query: { force: 'true' },
+			},
+		},
+	);
+
+	const msg = `Failed to delete content type: ${uid}`;
+	ContentstackError.throwIfError(error, msg);
+
+	if (!response.ok) {
+		throw new Error(msg);
+	}
+}

package/src/cs/content-types/export.ts

@@ -0,0 +1,25 @@
+import type Client from '../api/Client.js';
+import ContentstackError from '../api/ContentstackError.js';
+import { isSchema } from '../Types.js';
+
+export default async function exportContentType(client: Client, uid: string) {
+	const { data, error } = await client.GET(
+		'/v3/content_types/{content_type_uid}/export',
+		{
+			params: {
+				path: { content_type_uid: uid },
+			},
+		},
+	);
+
+	const msg = `Failed to export content type: ${uid}`;
+	ContentstackError.throwIfError(error, msg);
+
+	const result = data as unknown;
+
+	if (!isSchema(result)) {
+		throw new Error(msg);
+	}
+
+	return result;
+}

package/src/cs/content-types/import.ts

@@ -0,0 +1,88 @@
+import type Client from '#cli/cs/api/Client.js';
+import ContentstackError from '#cli/cs/api/ContentstackError.js';
+import fileUploadInit from '#cli/cs/api/fileUploadInit.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import { inspect, isDeepStrictEqual } from 'node:util';
+import { isSchema, type Schema } from '../Types.js';
+
+export default async function importContentType(
+	client: Client,
+	schema: Schema,
+	overwrite: boolean,
+) {
+	const result = await client.POST('/v3/content_types/import', {
+		...fileUploadInit,
+
+		body: { content_type: JSON.stringify(schema) },
+
+		params: {
+			query: { overwrite: overwrite.toString() },
+		},
+	});
+
+	const y = createStylus('yellowBright');
+	const errorContext = y`Failed to import content type: ${schema.uid}.`;
+
+	ContentstackError.throwIfError(result.error, errorContext);
+	throwIfNotOk(result.response, errorContext);
+	const imported = selectImported(result, errorContext);
+	throwIfNotImportedAccurately(schema, imported, errorContext);
+}
+
+function throwIfNotImportedAccurately(
+	schema: Schema,
+	imported: Schema,
+	errorContext: string,
+) {
+	if (isDeepStrictEqual(schema.schema, imported.schema)) {
+		return;
+	}
+
+	const msg2 = 'Expected the imported content type to match the schema.';
+
+	const msg3 =
+		'Provided to Contentstack: ' +
+		inspect(schema.schema, { colors: true, depth: Infinity });
+
+	const msg4 =
+		'Imported by Contentstack: ' +
+		inspect(imported.schema, { colors: true, depth: Infinity });
+
+	throw new Error(`${errorContext} ${msg2}\n${msg3}\n${msg4}`);
+}
+
+function throwIfNotOk(response: Response, errorContext: string) {
+	if (!response.ok) {
+		const y = createStylus('yellowBright');
+		const msg2 = 'Contentstack responded with status';
+		const msg3 = y`${response.status.toString()}:`;
+		const msg4 = y`${response.statusText}.`;
+		throw new Error(`${errorContext} ${msg2} ${msg3} ${msg4}`);
+	}
+}
+
+function selectImported(result: unknown, errorContext: string) {
+	if (!isRecord(result)) {
+		const msg2 = 'Expected response to be an object.';
+		throw new Error(`${errorContext} ${msg2}`);
+	}
+
+	const { data } = result;
+	if (!isRecord(data)) {
+		const msg2 = 'Expected response data to be an object.';
+
+		const { response, ...rest } = result;
+		const msg3 = inspect(rest, { colors: true, depth: Infinity });
+
+		throw new Error(`${errorContext} ${msg2} ${msg3}`);
+	}
+
+	const { content_type: imported } = data;
+	if (!isSchema(imported)) {
+		const msg2 = 'Expected response data to include the imported content type.';
+		throw new Error(`${errorContext} ${msg2}`);
+	}
+
+	return imported;
+}

package/src/cs/content-types/index.ts

@@ -0,0 +1,38 @@
+import type Client from '../api/Client.js';
+import readPaginatedItems from '../api/paginate/readPaginatedItems.js';
+import typecheckArray from '../typecheckArray.js';
+import { isSchema, itemKey } from '../Types.js';
+
+export default async function index(client: Client) {
+	return readPaginatedItems(
+		'content types',
+		itemKey,
+		fetchFn.bind(null, client),
+		mapFn.bind(null),
+	);
+}
+
+async function fetchFn(client: Client, skip = 0) {
+	return client.GET('/v3/content_types', {
+		params: {
+			query: {
+				include_count: 'true',
+				include_global_field_schema: 'false',
+				...(skip > 0 ? { skip } : {}),
+			},
+		},
+	});
+}
+
+function mapFn(data: Record<string, unknown>) {
+	const { content_types: items, count } = data;
+
+	if (!typecheckArray(isSchema, 'content types', items)) {
+		throw new Error('Invalid response from Contentstack');
+	}
+
+	return {
+		items,
+		...(typeof count === 'number' ? { count } : {}),
+	};
+}

package/src/cs/entries/Types.ts

@@ -0,0 +1,21 @@
+import type { ContentType } from '../content-types/Types.js';
+import type { Item } from '../Types.js';
+import { isItem } from '../Types.js';
+
+export interface Entry extends Item {
+	readonly title: string;
+}
+
+export function isEntry(o: unknown): o is Entry {
+	return isItem(o) && typeof o.title === 'string';
+}
+
+export function key(o: Entry) {
+	return o.title;
+}
+
+export type ReferencePath = `${ContentType['uid']}/${Entry['title']}`;
+
+export function isReferencePath(value: unknown): value is ReferencePath {
+	return typeof value === 'string' && value.includes('/');
+}

package/src/cs/entries/delete.ts

@@ -0,0 +1,37 @@
+import isRecord from '#cli/util/isRecord.js';
+import type Client from '../api/Client.js';
+import ContentstackError from '../api/ContentstackError.js';
+
+const EntryNotFound = 141;
+
+export default async function deleteEntry(
+	client: Client,
+	contentTypeUid: string,
+	entryUid: string,
+) {
+	const result = await client.DELETE(
+		'/v3/content_types/{content_type_uid}/entries/{entry_uid}',
+		{
+			params: {
+				path: {
+					content_type_uid: contentTypeUid,
+					entry_uid: entryUid,
+				},
+			},
+		},
+	);
+
+	const msg = `Failed to delete ${contentTypeUid} entry: ${entryUid}`;
+	const error = result.error as unknown;
+
+	if (isRecord(error) && error.error_code === EntryNotFound) {
+		// Safe to ignore
+		return;
+	}
+
+	ContentstackError.throwIfError(error, msg);
+
+	if (!result.response.ok) {
+		throw new Error(msg);
+	}
+}

package/src/cs/entries/export.ts

@@ -0,0 +1,34 @@
+import type Client from '../api/Client.js';
+import ContentstackError from '../api/ContentstackError.js';
+import type { ContentType } from '../content-types/Types.js';
+import type { Entry } from './Types.js';
+import { isEntry } from './Types.js';
+
+export default async function exportEntry(
+	contentTypeUid: ContentType['uid'],
+	client: Client,
+	entryUid: Entry['uid'],
+) {
+	const { data, error } = await client.GET(
+		'/v3/content_types/{content_type_uid}/entries/{entry_uid}/export',
+		{
+			params: {
+				path: {
+					content_type_uid: contentTypeUid,
+					entry_uid: entryUid,
+				},
+			},
+		},
+	);
+
+	const msg = `Failed to export ${contentTypeUid} entry: ${entryUid}`;
+	ContentstackError.throwIfError(error, msg);
+
+	const result = data as unknown;
+
+	if (!isEntry(result)) {
+		throw new Error(msg);
+	}
+
+	return result;
+}

package/src/cs/entries/exportEntryLocale.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it, vi } from 'vitest';
+import type Client from '../api/Client.js';
+import exportEntryLocale from './exportEntryLocale.js';
+
+describe('exportEntryLocale', () => {
+	it('should export entry with locale parameter', async () => {
+		const mockEntry = {
+			locale: 'en-us',
+			title: 'Test Entry',
+			uid: 'blt123456',
+		};
+
+		const mockClient = {
+			GET: vi.fn().mockResolvedValue({
+				data: mockEntry,
+				error: undefined,
+			}),
+		} as unknown as Client;
+
+		const result = await exportEntryLocale(
+			'test_content_type',
+			mockClient,
+			'blt123456',
+			'en-us',
+		);
+
+		expect(result).toEqual(mockEntry);
+		expect(mockClient.GET).toHaveBeenCalledWith(
+			'/v3/content_types/{content_type_uid}/entries/{entry_uid}/export',
+			{
+				params: {
+					path: {
+						content_type_uid: 'test_content_type',
+						entry_uid: 'blt123456',
+					},
+					query: {
+						locale: 'en-us',
+					},
+				},
+			},
+		);
+	});
+
+	it('should throw error when API returns error', async () => {
+		const mockClient = {
+			GET: vi.fn().mockResolvedValue({
+				data: undefined,
+				error: { message: 'Not found' },
+			}),
+		} as unknown as Client;
+
+		await expect(
+			exportEntryLocale('test_content_type', mockClient, 'blt123456', 'fr'),
+		).rejects.toThrow();
+	});
+
+	it('should throw error when response is not a valid entry', async () => {
+		const mockClient = {
+			GET: vi.fn().mockResolvedValue({
+				data: { invalid: 'data' },
+				error: undefined,
+			}),
+		} as unknown as Client;
+
+		await expect(
+			exportEntryLocale('test_content_type', mockClient, 'blt123456', 'de'),
+		).rejects.toThrow(
+			'Failed to export test_content_type entry: blt123456 (locale: de)',
+		);
+	});
+
+	it('should handle different locale codes correctly', async () => {
+		const locales = ['en-us', 'fr-fr', 'de', 'zh_CN', 'es-mx'];
+
+		for (const locale of locales) {
+			const mockEntry = {
+				locale,
+				title: 'Test Entry',
+				uid: 'blt123456',
+			};
+
+			const mockClient = {
+				GET: vi.fn().mockResolvedValue({
+					data: mockEntry,
+					error: undefined,
+				}),
+			} as unknown as Client;
+
+			const result = await exportEntryLocale(
+				'test_content_type',
+				mockClient,
+				'blt123456',
+				locale,
+			);
+
+			expect(result.locale).toBe(locale);
+			expect(mockClient.GET).toHaveBeenCalledWith(
+				expect.any(String),
+				expect.objectContaining({
+					params: expect.objectContaining({
+						query: { locale },
+					}),
+				}),
+			);
+		}
+	});
+});

package/src/cs/entries/exportEntryLocale.ts

@@ -0,0 +1,38 @@
+import type Client from '../api/Client.js';
+import ContentstackError from '../api/ContentstackError.js';
+import type { ContentType } from '../content-types/Types.js';
+import type { Entry } from './Types.js';
+import { isEntry } from './Types.js';
+
+export default async function exportEntryLocale(
+	contentTypeUid: ContentType['uid'],
+	client: Client,
+	entryUid: Entry['uid'],
+	locale: string,
+) {
+	const { data, error } = await client.GET(
+		'/v3/content_types/{content_type_uid}/entries/{entry_uid}/export',
+		{
+			params: {
+				path: {
+					content_type_uid: contentTypeUid,
+					entry_uid: entryUid,
+				},
+				query: {
+					locale,
+				},
+			},
+		},
+	);
+
+	const msg = `Failed to export ${contentTypeUid} entry: ${entryUid} (locale: ${locale})`;
+	ContentstackError.throwIfError(error, msg);
+
+	const result = data as unknown;
+
+	if (!isEntry(result)) {
+		throw new Error(msg);
+	}
+
+	return result;
+}