@arkebcacy/beacon-cli-temp 0.1.1

package/src/schema/clear.ts

@@ -0,0 +1,114 @@
+import type Client from '#cli/cs/api/Client.js';
+import type { RawAsset, RawFolder } from '#cli/cs/assets/Types.js';
+import { isRawAsset } from '#cli/cs/assets/Types.js';
+import deleteAsset from '#cli/cs/assets/delete.js';
+import deleteFolder from '#cli/cs/assets/deleteFolder.js';
+import indexAssets from '#cli/cs/assets/index.js';
+import deleteContentType from '#cli/cs/content-types/delete.js';
+import indexContentTypes from '#cli/cs/content-types/index.js';
+import deleteGlobalField from '#cli/cs/global-fields/delete.js';
+import indexGlobalFields from '#cli/cs/global-fields/index.js';
+import deleteTaxonomy from '#cli/cs/taxonomies/delete.js';
+import indexTaxonomies from '#cli/cs/taxonomies/index.js';
+import type UiContext from '#cli/ui/UiContext.js';
+import ProgressReporter from '../ui/progress/ProgressReporter.js';
+
+export default async function clear(client: Client, ui: UiContext) {
+	await Promise.allSettled([
+		deleteAllContentTypes(client, ui),
+		deleteAllGlobalFields(client, ui),
+		deleteAllTaxonomies(client, ui),
+		deleteAllAssets(client, ui),
+	]);
+}
+
+async function deleteAll<T>(
+	ui: UiContext,
+	pluralNoun: string,
+	humanize: (item: T) => string,
+	indexItems: () => Promise<ReadonlyMap<string, T>> | ReadonlyMap<string, T>,
+	deleteItem: (item: T) => Promise<void>,
+) {
+	const items = await indexItems();
+
+	if (!items.size) {
+		return;
+	}
+
+	{
+		using bar = ui.createProgressBar(pluralNoun, items.size);
+		for (const item of items.values()) {
+			using reporter = new ProgressReporter(bar, 'deleting', humanize(item));
+			await deleteItem(item);
+			bar.increment();
+			reporter.finish('deleted');
+		}
+	}
+}
+
+async function deleteAllContentTypes(client: Client, ui: UiContext) {
+	return deleteAll(
+		ui,
+		'Content Types',
+		(item) => item.title,
+		async () => indexContentTypes(client),
+		async (item) => deleteContentType(client, item.uid),
+	);
+}
+
+async function deleteAllGlobalFields(client: Client, ui: UiContext) {
+	return deleteAll(
+		ui,
+		'Global Fields',
+		(item) => item.title,
+		async () => indexGlobalFields(client),
+		async (item) => deleteGlobalField(client, item.uid),
+	);
+}
+
+async function deleteAllTaxonomies(client: Client, ui: UiContext) {
+	return deleteAll(
+		ui,
+		'Taxonomies',
+		(item) => item.name,
+		async () => indexTaxonomies(client),
+		async (item) => deleteTaxonomy(client, item.uid),
+	);
+}
+
+async function deleteAllAssets(client: Client, ui: UiContext) {
+	const assets = await indexAssets(client);
+	const folders = new Map<string, RawFolder>();
+	const files = new Map<string, RawAsset>();
+
+	for (const asset of assets.values()) {
+		// Nested assets get deleted when parents are deleted, so we only need to
+		// delete top-level assets
+		if (asset.parent_uid) {
+			continue;
+		}
+
+		if (isRawAsset(asset)) {
+			files.set(asset.uid, asset);
+		} else {
+			folders.set(asset.uid, asset);
+		}
+	}
+
+	await Promise.all([
+		deleteAll(
+			ui,
+			'Asset Folders',
+			(item) => item.name,
+			() => folders,
+			async (item) => deleteFolder(client, item.uid),
+		),
+		deleteAll(
+			ui,
+			'Assets',
+			(item) => item.title,
+			() => files,
+			async (item) => deleteAsset(client, item.uid),
+		),
+	]);
+}

package/src/schema/content-types/indexFromFilesystem.ts

@@ -0,0 +1,11 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import { isSchema, itemKey } from '#cli/cs/Types.js';
+import type Filename from '../xfer/Filename.js';
+import baseIndexFromFilesystem from '../xfer/indexFromFilesystem.js';
+import schemaDirectory from './schemaDirectory.js';
+
+export default async function indexFromFilesystem(): Promise<
+	ReadonlyMap<ContentType['uid'], ContentType & { [Filename]: string }>
+> {
+	return baseIndexFromFilesystem(schemaDirectory(), isSchema, itemKey);
+}

package/src/schema/content-types/reduceToShim.ts

@@ -0,0 +1,32 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type { SchemaFields } from '#cli/cs/Types.js';
+import isRecord from '#cli/util/isRecord.js';
+
+export default function reduceToShim({
+	schema: originalSchema,
+	field_rules,
+	...rest
+}: ContentType): ContentType {
+	if (!Array.isArray(originalSchema)) {
+		throw new Error('Expected schema to be an array');
+	}
+
+	const schema = [findFieldByUid(originalSchema, 'title')];
+
+	const { options } = rest;
+	if (isRecord(options) && options.is_page === true) {
+		schema.push(findFieldByUid(originalSchema, 'url'));
+	}
+
+	return { ...rest, schema };
+}
+
+function findFieldByUid(schema: SchemaFields, uid: string) {
+	const match = schema.find((x) => isRecord(x) && x.uid === uid);
+
+	if (!match) {
+		throw new Error(`Expected schema to have a ${uid} field`);
+	}
+
+	return match;
+}

package/src/schema/content-types/schemaDirectory.ts

@@ -0,0 +1,12 @@
+import { resolve } from 'node:path';
+import getUi from '../lib/SchemaUi.js';
+
+export default function schemaDirectory() {
+	const {
+		options: {
+			schema: { schemaPath },
+		},
+	} = getUi();
+
+	return resolve(schemaPath, 'content-types');
+}

package/src/schema/content-types/shimsToContentstack.ts

@@ -0,0 +1,42 @@
+import importContentType from '#cli/cs/content-types/import.js';
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type Ctx from '../ctx/Ctx.js';
+import isEquivalentSchema from '../isEquivalentSchema.js';
+import createProgressBar from '../lib/createProgressBar.js';
+import planMerge from '../xfer/lib/planMerge.js';
+import processPlan from '../xfer/lib/processPlan.js';
+import reduceToShim from './reduceToShim.js';
+
+// See /doc/lessons-learned/circular-references.md for the reasoning behind
+// this function.
+export default async function shimsToContentstack(ctx: Ctx) {
+	const create = async (schema: ContentType) =>
+		importContentType(ctx.cs.client, reduceToShim(schema), false);
+
+	using bar = createProgressBar(
+		'Content Type Shims',
+		ctx.cs.contentTypes,
+		ctx.fs.contentTypes,
+	);
+
+	const plan = planMerge(
+		isEquivalentSchema,
+		ctx.fs.contentTypes,
+		ctx.cs.contentTypes,
+	);
+
+	return await processPlan<ContentType>({
+		create,
+		deletionStrategy: 'ignore',
+		plan,
+		progress: bar,
+		remove: noop,
+		update: noop,
+	});
+}
+
+async function noop() {
+	// no-op: content type shims are stand-ins for a full content type,
+	// and are only updated or updated when the full content type is removed
+	// or updated.
+}

package/src/schema/content-types/toContentstack.ts

@@ -0,0 +1,38 @@
+import deleteContentType from '#cli/cs/content-types/delete.js';
+import importContentType from '#cli/cs/content-types/import.js';
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import transform from '#cli/dto/schema/toCs.js';
+import type Ctx from '../ctx/Ctx.js';
+import isEquivalentSchema from '../isEquivalentSchema.js';
+import createProgressBar from '../lib/createProgressBar.js';
+import getUi from '../lib/SchemaUi.js';
+import planMerge from '../xfer/lib/planMerge.js';
+import processPlan from '../xfer/lib/processPlan.js';
+
+export default async function toContentstack(ctx: Ctx) {
+	const ui = getUi();
+
+	const write = async (schema: ContentType) =>
+		importContentType(ctx.cs.client, transform(schema), true);
+
+	using bar = createProgressBar(
+		'Content Types',
+		ctx.cs.contentTypes,
+		ctx.fs.contentTypes,
+	);
+
+	const plan = planMerge(
+		isEquivalentSchema,
+		ctx.fs.contentTypes,
+		ctx.cs.contentTypes,
+	);
+
+	return await processPlan<ContentType>({
+		create: write,
+		deletionStrategy: ui.options.schema.deletionStrategy,
+		plan,
+		progress: bar,
+		remove: async (schema) => deleteContentType(ctx.cs.client, schema.uid),
+		update: write,
+	});
+}

package/src/schema/content-types/toFilesystem.ts

@@ -0,0 +1,44 @@
+import exportContentType from '#cli/cs/content-types/export.js';
+import type { Schema } from '#cli/cs/Types.js';
+import writeYaml from '#cli/fs/writeYaml.js';
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import fromCs from '../../dto/schema/fromCs.js';
+import type Ctx from '../ctx/Ctx.js';
+import isEquivalentSchema from '../isEquivalentSchema.js';
+import createProgressBar from '../lib/createProgressBar.js';
+import planMerge from '../xfer/lib/planMerge.js';
+import processPlan from '../xfer/lib/processPlan.js';
+import schemaDirectory from './schemaDirectory.js';
+
+export default async function toFilesystem(ctx: Ctx) {
+	const directory = schemaDirectory();
+	const getPath = (uid: string) => resolve(directory, `${uid}.yaml`);
+
+	const write = async (schema: Schema) => {
+		const exported = await exportContentType(ctx.cs.client, schema.uid);
+		const transformed = fromCs(exported);
+		await writeYaml(getPath(schema.uid), transformed);
+	};
+
+	using bar = createProgressBar(
+		'Content Types',
+		ctx.cs.contentTypes,
+		ctx.fs.contentTypes,
+	);
+
+	const plan = planMerge(
+		isEquivalentSchema,
+		ctx.cs.contentTypes,
+		ctx.fs.contentTypes,
+	);
+
+	return await processPlan<Schema>({
+		create: write,
+		deletionStrategy: 'delete',
+		plan,
+		progress: bar,
+		remove: async (schema) => rm(getPath(schema.uid), { force: true }),
+		update: write,
+	});
+}

package/src/schema/ctx/Ctx.ts

@@ -0,0 +1,134 @@
+import type Client from '#cli/cs/api/Client.js';
+import CsAssets from '#cli/cs/assets/Assets.js';
+import indexAssets from '#cli/cs/assets/index.js';
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import indexAllCsEntries from '#cli/cs/entries/indexAllCsEntries.js';
+import type { Entry } from '#cli/cs/entries/Types.js';
+import type indexGlobalFields from '#cli/cs/global-fields/index.js';
+import type { Schema } from '#cli/cs/Types.js';
+import transformEntry from '#cli/dto/entry/fromCs.js';
+import fromCs from '#cli/dto/schema/fromCs.js';
+import FsAssets from '#cli/fs/assets/Assets.js';
+import EntryCollection from '#cli/schema/entries/EntryCollection.js';
+import indexFsTaxonomies from '#cli/schema/taxonomies/lib/indexFs.js';
+import indexAllFsEntries from '../entries/indexAllFsEntries.js';
+import { ReferenceMap } from '../references/ReferenceMap.js';
+import indexCsTaxonomies from '../taxonomies/lib/indexCs.js';
+import CsTaxonomyCollection from './lib/CsTaxonomyCollection.js';
+import FsTaxonomyCollection from './lib/FsTaxonomyCollection.js';
+import type TaxonomyCollection from './lib/TaxonomyCollection.js';
+
+interface BaseCtx {
+	readonly contentTypes: ReadonlyMap<ContentType['uid'], ContentType>;
+	readonly entries: EntryCollection;
+	readonly taxonomies: TaxonomyCollection;
+}
+
+interface CsCtx extends BaseCtx {
+	readonly client: Client;
+	readonly assets: CsAssets;
+	readonly globalFields: ReadonlyMap<Schema['uid'], Schema>;
+}
+
+interface FsCtx extends BaseCtx {
+	readonly assets: FsAssets;
+}
+
+export default class Ctx {
+	public readonly references = new ReferenceMap();
+	public readonly cs: CsCtx;
+	public readonly fs: FsCtx;
+
+	private constructor(
+		client: Client,
+		csTaxonomies: Awaited<ReturnType<typeof indexCsTaxonomies>>,
+		csAssets: Awaited<ReturnType<typeof indexAssets>>,
+		csGlobalFields: Awaited<ReturnType<typeof indexGlobalFields>>,
+		csEntries: ReadonlyMap<ContentType, ReadonlySet<Entry>>,
+		fsTaxonomies: Awaited<ReturnType<typeof indexFsTaxonomies>>,
+		fsEntries: Awaited<ReturnType<typeof indexAllFsEntries>>,
+		fsAssets: FsAssets,
+	) {
+		this.cs = {
+			assets: new CsAssets(client, csAssets),
+			client,
+			contentTypes: transformCsSchema(csEntries.keys()),
+			entries: new EntryCollection(csEntries),
+			globalFields: transformCsSchema(csGlobalFields.values()),
+			taxonomies: new CsTaxonomyCollection(client, csTaxonomies),
+		};
+
+		this.fs = {
+			assets: fsAssets,
+			contentTypes: new Map(
+				[...fsEntries.keys()].map((contentType) => [
+					contentType.uid,
+					contentType,
+				]),
+			),
+
+			entries: new EntryCollection(fsEntries),
+			taxonomies: new FsTaxonomyCollection(fsTaxonomies),
+		};
+
+		this.cs = { ...this.cs, entries: this.#transformCsEntries(csEntries) };
+	}
+
+	public static async prepare(client: Client): Promise<Ctx> {
+		const [
+			csTaxonomies,
+			csAssets,
+			[csGlobalFields, csEntries],
+			fsTaxonomies,
+			fsEntries,
+			fsAssets,
+		] = await Promise.all([
+			indexCsTaxonomies(client),
+			indexAssets(client),
+			indexAllCsEntries(client),
+			indexFsTaxonomies(),
+			indexAllFsEntries(),
+			FsAssets.create(),
+		]);
+
+		return new Ctx(
+			client,
+			csTaxonomies,
+			csAssets,
+			csGlobalFields,
+			csEntries,
+			fsTaxonomies,
+			fsEntries,
+			fsAssets,
+		);
+	}
+
+	#transformCsEntries(
+		csEntries: ReadonlyMap<ContentType, ReadonlySet<Entry>>,
+	): EntryCollection {
+		const result = new Map<ContentType, ReadonlySet<Entry>>();
+
+		for (const [contentType, entries] of csEntries) {
+			const transformed = new Set<Entry>();
+			result.set(contentType, transformed);
+
+			for (const entry of entries) {
+				transformed.add(transformEntry(this, contentType, entry));
+			}
+		}
+
+		return new EntryCollection(result);
+	}
+}
+
+function transformCsSchema(
+	schemas: IterableIterator<Schema>,
+): ReadonlyMap<Schema['uid'], Schema> {
+	const result = new Map<Schema['uid'], Schema>();
+
+	for (const schema of schemas) {
+		result.set(schema.uid, fromCs(schema));
+	}
+
+	return result;
+}

package/src/schema/ctx/lib/CsTaxonomyCollection.ts

@@ -0,0 +1,48 @@
+import type Client from '#cli/cs/api/Client.js';
+import deleteTaxonomy from '#cli/cs/taxonomies/delete.js';
+import importTaxonomy from '#cli/cs/taxonomies/import.js';
+import type Taxonomy from '#cli/cs/taxonomies/Taxonomy.js';
+import updateTaxonomy from '#cli/cs/taxonomies/update.js';
+import type NormalizedTaxonomy from '#cli/dto/taxonomy/NormalizedTaxonomy.js';
+import toCs from '#cli/dto/taxonomy/toCs.js';
+import type TaxonomyCollection from './TaxonomyCollection.js';
+
+export default class CsTaxonomyCollection implements TaxonomyCollection {
+	readonly #taxonomies: Map<Taxonomy['uid'], NormalizedTaxonomy>;
+
+	public constructor(
+		private readonly client: Client,
+		taxonomies: ReadonlyMap<Taxonomy['uid'], NormalizedTaxonomy>,
+	) {
+		this.#taxonomies = new Map(taxonomies);
+	}
+
+	public get byUid(): ReadonlyMap<Taxonomy['uid'], NormalizedTaxonomy> {
+		return this.#taxonomies;
+	}
+
+	public async create(normalized: NormalizedTaxonomy): Promise<void> {
+		await importTaxonomy(this.client, toCs(normalized));
+		this.#taxonomies.set(normalized.taxonomy.uid, normalized);
+	}
+
+	public async remove(normalized: NormalizedTaxonomy): Promise<void> {
+		await deleteTaxonomy(this.client, normalized.taxonomy.uid);
+		this.#taxonomies.delete(normalized.taxonomy.uid);
+	}
+
+	public async update(normalized: NormalizedTaxonomy): Promise<void> {
+		const existing = this.#taxonomies.get(normalized.taxonomy.uid);
+
+		if (!existing) {
+			throw new Error(`Taxonomy ${normalized.taxonomy.uid} does not exist`);
+		}
+
+		await updateTaxonomy(this.client, toCs(normalized).taxonomy);
+
+		this.#taxonomies.set(normalized.taxonomy.uid, {
+			...existing,
+			taxonomy: normalized.taxonomy,
+		});
+	}
+}

package/src/schema/ctx/lib/FsTaxonomyCollection.ts

@@ -0,0 +1,46 @@
+import type Taxonomy from '#cli/cs/taxonomies/Taxonomy.js';
+import type NormalizedTaxonomy from '#cli/dto/taxonomy/NormalizedTaxonomy.js';
+import writeYaml from '#cli/fs/writeYaml.js';
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import schemaDirectory from '../../taxonomies/schemaDirectory.js';
+import type TaxonomyCollection from './TaxonomyCollection.js';
+
+export default class FsTaxonomyCollection implements TaxonomyCollection {
+	readonly #directory = schemaDirectory();
+	readonly #taxonomies: Map<Taxonomy['uid'], NormalizedTaxonomy>;
+
+	public constructor(
+		taxonomies: ReadonlyMap<Taxonomy['uid'], NormalizedTaxonomy>,
+	) {
+		this.#taxonomies = new Map(taxonomies);
+	}
+
+	public get byUid(): ReadonlyMap<Taxonomy['uid'], NormalizedTaxonomy> {
+		return this.#taxonomies;
+	}
+
+	public async create(normalized: NormalizedTaxonomy): Promise<void> {
+		await this.#write(normalized);
+		this.#taxonomies.set(normalized.taxonomy.uid, normalized);
+	}
+
+	public async remove(normalized: NormalizedTaxonomy): Promise<void> {
+		await rm(this.#getPath(normalized.taxonomy.uid), { force: true });
+		this.#taxonomies.delete(normalized.taxonomy.uid);
+	}
+
+	public async update(normalized: NormalizedTaxonomy): Promise<void> {
+		await this.#write(normalized);
+		this.#taxonomies.set(normalized.taxonomy.uid, normalized);
+	}
+
+	async #write(normalized: NormalizedTaxonomy) {
+		const path = this.#getPath(normalized.taxonomy.uid);
+		return writeYaml(path, normalized, { sortMapEntries: false });
+	}
+
+	#getPath(uid: string) {
+		return resolve(this.#directory, `${uid}.yaml`);
+	}
+}

package/src/schema/ctx/lib/TaxonomyCollection.ts

@@ -0,0 +1,9 @@
+import type Taxonomy from '#cli/cs/taxonomies/Taxonomy.js';
+import type NormalizedTaxonomy from '#cli/dto/taxonomy/NormalizedTaxonomy.js';
+
+export default interface TaxonomyCollection {
+	readonly byUid: ReadonlyMap<Taxonomy['uid'], NormalizedTaxonomy>;
+	create(normalized: NormalizedTaxonomy): Promise<void>;
+	remove(normalized: NormalizedTaxonomy): Promise<void>;
+	update(normalized: NormalizedTaxonomy): Promise<void>;
+}

package/src/schema/entries/EntryCollection.ts

@@ -0,0 +1,86 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type { Entry } from '#cli/cs/entries/Types.js';
+
+export interface ReadonlyEntryCollection {
+	// readonly byPath: ReadonlyMap<ReferencePath, Entry>;
+
+	// When Contentstack serializes an entry that contains references, those
+	// references are stored as:
+	//
+	//   ref: { uid: bltc0ddae0dc0eb1e8d, _content_type_uid: site_header }
+	//
+	// This structure provdies uid values for both entries and content types.
+	//
+	// The entry uid values are not stable across stacks, so when we store this
+	// in the file system, we store it as:
+	//
+	//   ref: site_header/entry-title
+	//
+	// The `byTypedUid` index lets us quickly map a content type uid and an entry
+	// uid into the entry object (which can be used to find the entry title).
+	readonly byTypedUid: ReadonlyMap<
+		`${ContentType['uid']}/${Entry['uid']}`,
+		Entry
+	>;
+
+	// When comparing entries between the file system and Contentstack, we match
+	// entries on their title (since the uid values are not stable across stacks).
+	// This index lets us quickly locate a specific entry by its title, within the
+	// context of a given content type.
+	byTitleFor(
+		contentTypeUid: ContentType['uid'],
+	): ReadonlyMap<Entry['title'], Entry>;
+}
+
+export default class EntryCollection implements ReadonlyEntryCollection {
+	readonly #byTypedUid = new Map<
+		`${ContentType['uid']}/${Entry['uid']}`,
+		Entry
+	>();
+
+	readonly #byTitle = new Map<ContentType['uid'], Map<Entry['title'], Entry>>();
+
+	public constructor(initial: ReadonlyMap<ContentType, ReadonlySet<Entry>>) {
+		for (const [contentType, entries] of initial) {
+			const byTitle = new Map<Entry['title'], Entry>();
+
+			for (const entry of entries) {
+				this.#byTypedUid.set(`${contentType.uid}/${entry.uid}`, entry);
+				byTitle.set(entry.title, entry);
+			}
+
+			this.#byTitle.set(contentType.uid, byTitle);
+		}
+	}
+
+	public get byTypedUid(): ReadonlyMap<
+		`${ContentType['uid']}/${Entry['uid']}`,
+		Entry
+	> {
+		return this.#byTypedUid;
+	}
+
+	public byTitleFor(
+		contentTypeUid: ContentType['uid'],
+	): ReadonlyMap<Entry['title'], Entry> {
+		return this.#byTitle.get(contentTypeUid) ?? new Map();
+	}
+
+	public set(contentTypeUid: ContentType['uid'], entry: Entry) {
+		const uidPath = `${contentTypeUid}/${entry.uid}` as const;
+		const previous = this.#byTypedUid.get(uidPath);
+		this.#byTypedUid.set(uidPath, entry);
+
+		const byTitle = this.#byTitle.get(contentTypeUid);
+
+		if (byTitle) {
+			if (previous && previous.title !== entry.title) {
+				byTitle.delete(previous.title);
+			}
+
+			byTitle.set(entry.title, entry);
+		} else {
+			this.#byTitle.set(contentTypeUid, new Map([[entry.title, entry]]));
+		}
+	}
+}

package/src/schema/entries/clean.test.ts

@@ -0,0 +1,23 @@
+import { randomUUID } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { expect, it, vi } from 'vitest';
+import clean from './clean';
+
+vi.mock('node:fs/promises');
+
+vi.mock(import('../../fs/tryReadDir.js'), () => {
+	return { default: async () => Promise.resolve([]) };
+});
+
+it('handles missing directories', async () => {
+	// Arrange
+	const testPath = resolve(randomUUID(), 'does', 'not', 'exist');
+
+	// Act
+	await clean(testPath, new Set());
+
+	// Assert
+	const mockedRm = vi.mocked(rm);
+	expect(mockedRm).not.toHaveBeenCalled();
+});

package/src/schema/entries/clean.ts

@@ -0,0 +1,30 @@
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import tryReadDir from '../../fs/tryReadDir.js';
+import type TransferResults from '../xfer/TransferResults.js';
+import { MutableTransferResults } from '../xfer/TransferResults.js';
+
+export default async function clean(
+	baseSchemaPath: string,
+	exceptForContentTypeUids: ReadonlySet<string>,
+): Promise<TransferResults> {
+	const baseDirectory = resolve(baseSchemaPath, 'entries');
+	const results = new MutableTransferResults();
+	const children = await tryReadDir(baseDirectory);
+
+	for (const child of children) {
+		if (!child.isDirectory()) {
+			continue;
+		}
+
+		if (exceptForContentTypeUids.has(child.name)) {
+			continue;
+		}
+
+		const fullPath = resolve(baseDirectory, child.name);
+		await rm(fullPath, { recursive: true });
+		results.deleted.add(child.name);
+	}
+
+	return results;
+}