@prismicio/e2e-tests-utils 1.18.0 → 1.19.0-canary.d349d21

package/src/managers/repository.ts

@@ -1,32 +1,28 @@
-import { expect } from "@playwright/test";
-import { AxiosResponse } from "axios";
-
-import {
-	CustomType,
-	SharedSlice,
-} from "@prismicio/types-internal/lib/customtypes";
-
-import { IntegrationFieldConfig } from "../types";
-
-import { AssetApiClient } from "../clients/assetApi";
-import { AuthenticationApiClient } from "../clients/authenticationApi";
-import { ContentApiClient } from "../clients/contentApi";
-import {
+import { expect } from "@playwright/test"
+import type { DynamicCustomTypeModel, SharedSliceModel } from "@prismicio/types-internal"
+import type { AxiosResponse } from "axios"
+
+import type { AssetApiClient } from "../clients/assetApi"
+import type { AuthenticationApiClient } from "../clients/authenticationApi"
+import { ContentApiClient } from "../clients/contentApi"
+import type {
 	CoreApiClient,
 	CoreApiDocumentCreationPayload,
 	CoreApiDocumentCreationResponse,
 	CoreApiDocumentData,
 	CoreApiDocumentsPayload,
 	CoreApiDocumentsResponse,
+	CoreApiDocumentUpdatePayload,
 	Release,
-} from "../clients/coreApi";
-import { CustomTypesApiClient } from "../clients/customTypesApi";
-import { IntegrationFieldsClient } from "../clients/integrationFields";
-import { ManageV2Client } from "../clients/manageV2";
-import { MigrationApiClient } from "../clients/migrationApi";
-import { WroomClient } from "../clients/wroom";
-import { logHttpResponse, logger } from "../utils/log";
-import { getRepositoryUrl } from "../utils/urls";
+} from "../clients/coreApi"
+import type { CustomTypesApiClient } from "../clients/customTypesApi"
+import type { IntegrationFieldsClient } from "../clients/integrationFields"
+import type { ManageV2Client } from "../clients/manageV2"
+import type { MigrationApiClient } from "../clients/migrationApi"
+import type { WroomClient } from "../clients/wroom"
+import type { IntegrationFieldConfig } from "../types"
+import { logHttpResponse, logger } from "../utils/log"
+import { getRepositoryUrl } from "../utils/urls"
 
 /** Utility to manage test data for a Prismic repository */
 export class RepositoryManager {
@@ -39,25 +35,22 @@ export class RepositoryManager {
 		private readonly migrationApiClient: MigrationApiClient | undefined,
 		private readonly assetApiClient: AssetApiClient,
 		private readonly manageV2Client: ManageV2Client,
-		private readonly integrationFieldsClient:
-			| IntegrationFieldsClient
-			| undefined,
+		private readonly integrationFieldsClient: IntegrationFieldsClient | undefined,
 	) {}
 
 	async configure(config: RepositoryConfig): Promise<void> {
-		const hasLangConfig =
-			config.defaultLocale || config.locales || config.customLocale;
+		const hasLangConfig = config.defaultLocale || config.locales || config.customLocale
 		if (hasLangConfig) {
-			const languages = await this.coreApiClient.getLanguages();
-			let updateDefaultLocaleAtTheEnd = false;
+			const languages = await this.coreApiClient.getLanguages()
+			let updateDefaultLocaleAtTheEnd = false
 			// if no locale exists on repo, the master locale needs to be set first
 			if (config.defaultLocale) {
-				const master = languages.find(({ is_master }) => is_master === true);
+				const master = languages.find(({ is_master }) => is_master === true)
 				if (!master) {
-					await this.setDefaultLocale(config.defaultLocale, "create");
+					await this.setDefaultLocale(config.defaultLocale, "create")
 				} else if (master.id !== config.defaultLocale) {
 					// update the master lang at the end, after it is created.
-					updateDefaultLocaleAtTheEnd = true;
+					updateDefaultLocaleAtTheEnd = true
 				}
 			}
 
@@ -65,258 +58,238 @@ export class RepositoryManager {
 				// No need to add default locale and already existing languages
 				const localesToAdd = config.locales.filter(
 					(id) => !languages.some((language) => language.id === id),
-				);
+				)
 				if (localesToAdd.length > 0) {
-					await this.createLocales(localesToAdd);
+					await this.createLocales(localesToAdd)
 				}
 			}
 
 			if (config.customLocale) {
 				if (!languages.find(({ id }) => id === config.customLocale?.lang.id)) {
-					await this.createCustomLocale(config.customLocale);
+					await this.createCustomLocale(config.customLocale)
 				}
 			}
 
 			if (config.defaultLocale && updateDefaultLocaleAtTheEnd) {
-				await this.setDefaultLocale(config.defaultLocale, "update");
+				await this.setDefaultLocale(config.defaultLocale, "update")
 			}
 		}
 
 		if (config.slices) {
-			await this.createSlices(config.slices);
+			await this.createSlices(config.slices)
 		}
 
 		if (config.customTypes) {
-			await this.createCustomTypes(config.customTypes);
+			await this.createCustomTypes(config.customTypes)
 		}
 
 		if (config.preview) {
-			await this.createPreview(config.preview);
+			await this.createPreview(config.preview)
 		}
 
 		if (config.simulatorURL) {
-			await this.setSimulatorURL(config.simulatorURL);
+			await this.setSimulatorURL(config.simulatorURL)
 		}
 
 		if (config.rolePerLocal) {
-			await this.toggleRolePerLocal(true);
+			await this.toggleRolePerLocal(true)
 		}
 
 		if (config.customRoles) {
-			await this.toggleCustomRoles(true);
+			await this.toggleCustomRoles(true)
 		}
 
 		if (config.integrationFields) {
-			await this.toggleIntegrationFields(true);
-			await this.setupIntegrationFields(config.integrationFields);
+			await this.toggleIntegrationFields(true)
+			await this.setupIntegrationFields(config.integrationFields)
 		}
 	}
 
-	/** @returns the repository base url, like https://my-repo.prismic.io */
+	/** @returns The repository base url, like https://my-repo.prismic.io */
 	getBaseURL(): string {
-		return getRepositoryUrl(this.wroomClient.getBaseURL(), this.name);
+		return getRepositoryUrl(this.wroomClient.getBaseURL(), this.name)
 	}
 
-	/** @returns the repository base cdn url, like https://my-repo.cdn.prismic.io */
+	/** @returns The repository base cdn url, like https://my-repo.cdn.prismic.io */
 	getBaseCdnURL(): string {
-		return getRepositoryUrl(this.wroomClient.getBaseURL(), `${this.name}.cdn`);
+		return getRepositoryUrl(this.wroomClient.getBaseURL(), `${this.name}.cdn`)
 	}
 
 	/**
-	 * @returns a Content Type api client configured to target the repository CDN
-	 *   url. Uses Playwright for requests so if your project uses Playwright too,
-	 *   any network request will be present in Playwright test reports.
+	 * @returns A Content Type api client configured to target the repository CDN url. Uses Playwright
+	 *   for requests so if your project uses Playwright too, any network request will be present in
+	 *   Playwright test reports.
 	 */
-	getContentApiClient(config?: {
-		version?: "v1" | "v2";
-		accessToken?: string;
-	}): ContentApiClient {
-		return new ContentApiClient(this.getBaseCdnURL(), config);
+	getContentApiClient(config?: { version?: "v1" | "v2"; accessToken?: string }): ContentApiClient {
+		return new ContentApiClient(this.getBaseCdnURL(), config)
 	}
 
 	/**
-	 * @returns an instance of the Migration api client, see
+	 * @returns An instance of the Migration api client, see
 	 *   https://prismic.io/docs/migration-api-technical-reference
 	 */
 	getMigrationApiClient(): MigrationApiClient {
 		if (!this.migrationApiClient) {
-			throw "No client found for the migration api. Did you provide a migration api url in the configuration?";
+			throw "No client found for the migration api. Did you provide a migration api url in the configuration?"
 		}
 
-		return this.migrationApiClient;
+		return this.migrationApiClient
 	}
 
 	/**
-	 * @returns an instance of the Asset api client, see
+	 * @returns An instance of the Asset api client, see
 	 *   https://prismic.io/docs/asset-api-technical-reference
 	 */
 	getAssetApiClient(): AssetApiClient {
-		return this.assetApiClient;
+		return this.assetApiClient
 	}
 
-	/** @returns the Wroom commit hash deployed on the current repository */
+	/** @returns The Wroom commit hash deployed on the current repository */
 	async getDeployedVersion(): Promise<string | undefined> {
 		const response = await this.wroomClient.get(
 			this.name,
 			"underground/834b34f16f451e00f268dd5c8c81d16e3c020275",
-		);
+		)
 
 		// Somehow axios directly parses the text response `Prismic version: <commit hash> into a version attribute
-		return response.data.version;
+		return response.data.version
 	}
 
 	/**
-	 * Set additional standard locales for a repository in Wroom, does not fail if
-	 * the locales already exist.
+	 * Set additional standard locales for a repository in Wroom, does not fail if the locales already
+	 * exist.
 	 *
 	 * @param locales - An array of all locales to be added to the repository.
-	 *
 	 * @throws Error if setting the locales fails.
 	 */
 	async createLocales(locales: string[]): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const response = await this.wroomClient.post(
-			this.name,
-			"app/settings/multilanguages",
-			{ languages: locales },
-		);
+		const response = await this.wroomClient.post(this.name, "app/settings/multilanguages", {
+			languages: locales,
+		})
 
-		const { data, status } = response;
+		const { data, status } = response
 		const success =
-			status === 200 ||
-			(status === 400 &&
-				(data as string).includes("already existing languages"));
+			status === 200 || (status === 400 && (data as string).includes("already existing languages"))
 		if (!success) {
-			logHttpResponse(response);
-			throw new Error(`Could not add locales ${locales.join(", ")}`);
+			logHttpResponse(response)
+			throw new Error(`Could not add locales ${locales.join(", ")}`)
 		}
-		profiler.done({ message: `locales '${locales}' created` });
+		profiler.done({ message: `locales '${locales}' created` })
 	}
 
 	/**
-	 * Set additional custom locale for a repository in Wroom, does not fail if
-	 * the locales already exist.
+	 * Set additional custom locale for a repository in Wroom, does not fail if the locales already
+	 * exist.
 	 *
 	 * @param locale - The locale to be added to the repository.
-	 *
 	 * @throws Error if setting the locale fails.
 	 */
 	async createCustomLocale(locale: CustomLocale): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.wroomClient.post(
 			this.name,
 			"app/settings/multilanguages/custom",
 			locale,
-		);
+		)
 
-		const { data, status } = response;
+		const { data, status } = response
 		const success =
-			status === 200 ||
-			(status === 400 && JSON.stringify(data).includes("code is already used"));
+			status === 200 || (status === 400 && JSON.stringify(data).includes("code is already used"))
 		if (!success) {
-			logHttpResponse(response);
-			throw new Error(`Could not create custom locale ${locale}`);
+			logHttpResponse(response)
+			throw new Error(`Could not create custom locale ${locale}`)
 		}
 		profiler.done({
 			message: `custom locale ${JSON.stringify(locale)} created`,
-		});
+		})
 	}
 
 	private failIfNot200(response: AxiosResponse, msg: string) {
 		if (response.status !== 200) {
-			logHttpResponse(response);
-			throw new Error(msg);
+			logHttpResponse(response)
+			throw new Error(msg)
 		}
 	}
 
 	/**
 	 * Delete a locale from a repository.
 	 *
-	 * @param locale - locale to remove from the repository configuration.
-	 *
+	 * @param locale - Locale to remove from the repository configuration.
 	 * @throws Error if deleting the locale fails.
 	 */
 	async deleteLocale(locale: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.wroomClient.post(
 			this.name,
 			`app/settings/multilanguages/${locale}/delete`,
-		);
-		this.failIfNot200(response, `Could not delete locale ${locale}`);
-		profiler.done({ message: `locale '${locale}' deleted` });
+		)
+		this.failIfNot200(response, `Could not delete locale ${locale}`)
+		profiler.done({ message: `locale '${locale}' deleted` })
 	}
 
 	/**
-	 * Create or update the default (master) locale for a repository in Wroom, the
-	 * locale needs to exist in the repository.
+	 * Create or update the default (master) locale for a repository in Wroom, the locale needs to
+	 * exist in the repository.
 	 *
 	 * @param locale - The locale to be set as the default.
-	 * @param endpoint - "createMasterLang" to create it, "defineAsMaster" to
-	 *   update it.
-	 *
+	 * @param endpoint - "createMasterLang" to create it, "defineAsMaster" to update it.
 	 * @throws Error if setting the default locale fails.
 	 */
-	async setDefaultLocale(
-		locale: string,
-		action: "create" | "update",
-	): Promise<void> {
-		const profiler = logger.startTimer();
+	async setDefaultLocale(locale: string, action: "create" | "update"): Promise<void> {
+		const profiler = logger.startTimer()
 
 		const endpoint = {
 			create: "createMasterLang",
 			update: "defineAsMaster",
-		};
+		}
 		const response = await this.wroomClient.post(
 			this.name,
 			`/app/settings/multilanguages/${locale}/${endpoint[action]}`,
-		);
+		)
 
-		const { data, status } = response;
+		const { data, status } = response
 		const success =
 			status === 200 ||
 			(status === 400 &&
 				// returns 400 if master lang is already set
-				JSON.stringify(data).includes("Unable to set as master language"));
+				JSON.stringify(data).includes("Unable to set as master language"))
 		if (!success) {
-			logHttpResponse(response);
-			throw new Error(`Could not set default locale to ${locale}`);
+			logHttpResponse(response)
+			throw new Error(`Could not set default locale to ${locale}`)
 		}
-		profiler.done({ message: `default locale set to '${locale}'` });
+		profiler.done({ message: `default locale set to '${locale}'` })
 	}
 
 	/**
 	 * Retrieves documents.
 	 *
 	 * @param args - Configure which documents are retrieved.
-	 *
 	 * @returns A paginated set of documents.
 	 */
-	async getDocuments(
-		args: CoreApiDocumentsPayload,
-	): Promise<CoreApiDocumentsResponse> {
-		return this.coreApiClient.getDocuments(args);
+	async getDocuments(args: CoreApiDocumentsPayload): Promise<CoreApiDocumentsResponse> {
+		return this.coreApiClient.getDocuments(args)
 	}
 
 	/**
 	 * Creates a release.
 	 *
 	 * @param label - The label for the release.
-	 *
 	 * @returns A Promise that resolves when the release is created.
 	 */
 	async createRelease(label: string): Promise<{ id: string }> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.wroomClient.post(this.name, "app/releases", {
 			label,
-		});
-		this.failIfNot200(response, `Could not create release ${label}`);
-		profiler.done({ message: `release '${label}' created` });
+		})
+		this.failIfNot200(response, `Could not create release ${label}`)
+		profiler.done({ message: `release '${label}' created` })
 
-		return response.data;
+		return response.data
 	}
 
 	/**
@@ -325,39 +298,33 @@ export class RepositoryManager {
 	 * @returns The migration relese metadata.
 	 */
 	async getMigrationRelease(): Promise<Release> {
-		const releases = await this.coreApiClient.getReleases();
-		const migrationRelease = releases.find((release) => release.migration);
+		const releases = await this.coreApiClient.getReleases()
+		const migrationRelease = releases.find((release) => release.migration)
 		if (!migrationRelease) {
-			throw new Error(`The repository does not have a migration release`);
+			throw new Error(`The repository does not have a migration release`)
 		}
 
-		return migrationRelease;
+		return migrationRelease
 	}
 
 	/**
 	 * Publishes a release.
 	 *
 	 * @param id - The ID of the release.
-	 *
-	 * @returns A Promise that resolves when the release is published and a new
-	 *   master ref is available.
+	 * @returns A Promise that resolves when the release is published and a new master ref is
+	 *   available.
 	 */
 	async publishRelease(id: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const contentApi = this.getContentApiClient();
-		const masterRef = await contentApi.getMasterRef();
-		await this.coreApiClient.publishRelease(id);
-		await expect
-			.poll(async () => contentApi.getMasterRef(), {
-				timeout: 10_000,
-				message: "Waiting for new master ref to be available",
-			})
-			.not.toBe(masterRef);
+		const contentApi = this.getContentApiClient()
+		const masterRef = await contentApi.getMasterRef()
+		await this.coreApiClient.publishRelease(id)
+		await this.waitForNewMasterRef(contentApi, masterRef)
 
 		profiler.done({
 			message: `release '${id}' published and new master ref available`,
-		});
+		})
 	}
 
 	/**
@@ -366,16 +333,12 @@ export class RepositoryManager {
 	 * @param id - The ID of the release to be deleted.
 	 */
 	async deleteRelease(id: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const response = await this.wroomClient.post(
-			this.name,
-			`app/releases/${id}/delete`,
-			{},
-		);
+		const response = await this.wroomClient.post(this.name, `app/releases/${id}/delete`, {})
 
-		this.failIfNot200(response, `Could not delete release with id ${id}`);
-		profiler.done({ message: `release '${id}' deleted` });
+		this.failIfNot200(response, `Could not delete release with id ${id}`)
+		profiler.done({ message: `release '${id}' deleted` })
 	}
 
 	/**
@@ -384,18 +347,14 @@ export class RepositoryManager {
 	 * @param data - The data for creating the preview.
 	 */
 	async createPreview(data: Preview): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const response = await this.wroomClient.post(
-			this.name,
-			`previews/new`,
-			data,
-		);
+		const response = await this.wroomClient.post(this.name, `previews/new`, data)
 
-		this.failIfNot200(response, `Could not create preview ${data.name}`);
-		profiler.done({ message: `preview '${data.name}' created` });
+		this.failIfNot200(response, `Could not create preview ${data.name}`)
+		profiler.done({ message: `preview '${data.name}' created` })
 
-		return response.data;
+		return response.data
 	}
 
 	/**
@@ -404,17 +363,17 @@ export class RepositoryManager {
 	 * @param data - The simulator URL to set.
 	 */
 	async setSimulatorURL(simulatorURL: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const repository = await this.coreApiClient.getRepository();
+		const repository = await this.coreApiClient.getRepository()
 		await this.coreApiClient.updateRepository({
 			...repository,
 			simulator_url: simulatorURL,
-		});
+		})
 
 		profiler.done({
 			message: `simulator preview '${simulatorURL}' created`,
-		});
+		})
 	}
 
 	/**
@@ -423,16 +382,12 @@ export class RepositoryManager {
 	 * @param id - The ID of the preview to be deleted.
 	 */
 	async deletePreview(id: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const response = await this.wroomClient.post(
-			this.name,
-			`previews/delete/${id}`,
-			{},
-		);
+		const response = await this.wroomClient.post(this.name, `previews/delete/${id}`, {})
 
-		this.failIfNot200(response, `Could not delete preview with id ${id}`);
-		profiler.done({ message: `preview '${id}' deleted` });
+		this.failIfNot200(response, `Could not delete preview with id ${id}`)
+		profiler.done({ message: `preview '${id}' deleted` })
 	}
 
 	/**
@@ -445,32 +400,28 @@ export class RepositoryManager {
 		url: string,
 		secret: string,
 		triggers: {
-			documentsPublished?: boolean;
-			documentsUnpublished?: boolean;
-			releasesCreated?: boolean;
-			releasesUpdated?: boolean;
-			tagsCreated?: boolean;
-			tagsDeleted?: boolean;
+			documentsPublished?: boolean
+			documentsUnpublished?: boolean
+			releasesCreated?: boolean
+			releasesUpdated?: boolean
+			tagsCreated?: boolean
+			tagsDeleted?: boolean
 		},
 		active: boolean,
 	): Promise<string> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const response = await this.wroomClient.post(
-			this.name,
-			"app/settings/webhooks/create",
-			{
-				name,
-				url,
-				secret,
-				active: active ? "on" : "off",
-				...triggers,
-			},
-		);
-		this.failIfNot200(response, `Could not create webhook ${name}`);
-		profiler.done({ message: `webhook '${name}' created` });
+		const response = await this.wroomClient.post(this.name, "app/settings/webhooks/create", {
+			name,
+			url,
+			secret,
+			active: active ? "on" : "off",
+			...triggers,
+		})
+		this.failIfNot200(response, `Could not create webhook ${name}`)
+		profiler.done({ message: `webhook '${name}' created` })
 
-		return response.data.created;
+		return response.data.created
 	}
 
 	/**
@@ -479,120 +430,118 @@ export class RepositoryManager {
 	 * @param id - The webhook ID.
 	 */
 	async deleteWebhook(id: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.wroomClient.post(
 			this.name,
 			`app/settings/webhooks/${id}/delete`,
 			{},
-		);
+		)
 
-		this.failIfNot200(response, `Could not delete webhook with id ${id}`);
-		profiler.done({ message: `webhook '${id}' deleted` });
+		this.failIfNot200(response, `Could not delete webhook with id ${id}`)
+		profiler.done({ message: `webhook '${id}' deleted` })
 	}
 
 	/**
 	 * Create Custom Types using the Custom types api.
 	 *
-	 * @param customTypes -
+	 * @param customTypes
 	 */
-	async createCustomTypes(customTypes: CustomType[]): Promise<void> {
-		await this.customTypesApiClient.createCustomTypes(customTypes);
+	async createCustomTypes(customTypes: DynamicCustomTypeModel[]): Promise<void> {
+		await this.customTypesApiClient.createCustomTypes(customTypes)
 	}
 
 	async deleteCustomType(customTypeId: string): Promise<void> {
-		await this.customTypesApiClient.deleteCustomType(customTypeId);
+		await this.customTypesApiClient.deleteCustomType(customTypeId)
 	}
 
 	/**
 	 * Create slices using the Custom types api.
 	 *
-	 * @param slices -
+	 * @param slices
 	 */
-	async createSlices(slices: SharedSlice[]): Promise<void> {
-		await this.customTypesApiClient.createSlices(slices);
+	async createSlices(slices: SharedSliceModel[]): Promise<void> {
+		await this.customTypesApiClient.createSlices(slices)
 	}
 
 	/**
 	 * Create an access token to query private items of the Content api.
 	 *
-	 * @param appName - mandatory authorized application name
-	 * @param tokenScope - access token scope. Use "master" to when your content
-	 *   api is fully private or "master+releases" to access private releases
+	 * @param appName - Mandatory authorized application name
+	 * @param tokenScope - Access token scope. Use "master" to when your content api is fully private
+	 *   or "master+releases" to access private releases
 	 */
 	async createContentAPIToken(
 		appName: string,
 		tokenScope: "master" | "master+releases" = "master",
 	): Promise<string> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 		type AuthorizedAppResponse = {
-			id: string;
-			name: string;
-			wroom_auths: { token: string; scope: "master" | "master+releases" }[];
-		};
-		const existingApps: AxiosResponse<AuthorizedAppResponse[]> =
-			await this.wroomClient.get(this.name, "settings/security/contentapi");
+			id: string
+			name: string
+			wroom_auths: { token: string; scope: "master" | "master+releases" }[]
+		}
+		const existingApps: AxiosResponse<AuthorizedAppResponse[]> = await this.wroomClient.get(
+			this.name,
+			"settings/security/contentapi",
+		)
 
 		this.failIfNot200(
 			existingApps,
 			`Could not get status of existing applications to generate a content api token`,
-		);
+		)
 		let app = existingApps.data.find(({ name, wroom_auths }) => {
-			return name === appName && wroom_auths.length > 0;
-		});
+			return name === appName && wroom_auths.length > 0
+		})
 
 		if (!app) {
-			const response: AxiosResponse<AuthorizedAppResponse> =
-				await this.wroomClient.post(this.name, "settings/security/oauthapp", {
+			const response: AxiosResponse<AuthorizedAppResponse> = await this.wroomClient.post(
+				this.name,
+				"settings/security/oauthapp",
+				{
 					app_name: appName,
-				});
+				},
+			)
 
-			this.failIfNot200(
-				response,
-				`Could not create content api app ${appName}`,
-			);
-			app = response.data;
+			this.failIfNot200(response, `Could not create content api app ${appName}`)
+			app = response.data
 		}
 
-		let tokenInfo = app.wroom_auths.find(({ scope }) => scope === tokenScope);
+		let tokenInfo = app.wroom_auths.find(({ scope }) => scope === tokenScope)
 		if (!tokenInfo) {
-			const response = await this.wroomClient.post(
-				this.name,
-				"settings/security/authorizations",
-				{
-					app: app.id,
-					scope: tokenScope,
-				},
-			);
+			const response = await this.wroomClient.post(this.name, "settings/security/authorizations", {
+				app: app.id,
+				scope: tokenScope,
+			})
 			this.failIfNot200(
 				response,
 				`Could not create content api access token for app ${appName} with scope ${tokenScope}`,
-			);
-			tokenInfo = response.data;
+			)
+			tokenInfo = response.data
 		}
 
 		profiler.done({
 			message: `content api access token for app '${appName}' created`,
-		});
+		})
 
 		if (!tokenInfo?.token) {
-			throw `Could not create content api access token for app ${appName} with scope ${tokenScope}`;
+			throw `Could not create content api access token for app ${appName} with scope ${tokenScope}`
 		}
 
-		return tokenInfo.token;
+		return tokenInfo.token
 	}
 
 	/** Create a permanent access token to authenticate to Prismic public apis. */
 	async createPermanentAccessToken(): Promise<string> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
-		const token = await this.authApiClient.getMachine2MachineToken(this.name);
+		const token = await this.authApiClient.getMachine2MachineToken(this.name)
 
 		profiler.done({
 			message: `machine2machine token created`,
-		});
+		})
 
-		return token;
+		return token
 	}
 
 	/**
@@ -601,22 +550,20 @@ export class RepositoryManager {
 	 * @param enabled - The feature new status
 	 */
 	async toggleRolePerLocal(enabled: boolean): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.toggleRolePerLocal({
 			repository: this.name,
 			enabled: enabled,
-		});
+		})
 
 		this.failIfNot200(
 			response,
-			`Could not ${enabled ? "enable" : "disable"} Role per local for ${
-				this.name
-			}`,
-		);
+			`Could not ${enabled ? "enable" : "disable"} Role per local for ${this.name}`,
+		)
 		profiler.done({
 			message: `Role per local ${enabled ? "enabled" : "disabled"}`,
-		});
+		})
 	}
 
 	/**
@@ -625,22 +572,20 @@ export class RepositoryManager {
 	 * @param enabled - The feature new status
 	 */
 	async toggleCustomRoles(enabled: boolean): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.toggleCustomRoles({
 			repository: this.name,
 			enabled: enabled,
-		});
+		})
 
 		this.failIfNot200(
 			response,
-			`Could not ${enabled ? "enable" : "disable"} Custom Roles for ${
-				this.name
-			}`,
-		);
+			`Could not ${enabled ? "enable" : "disable"} Custom Roles for ${this.name}`,
+		)
 		profiler.done({
 			message: `Custom Roles ${enabled ? "enabled" : "disabled"}`,
-		});
+		})
 	}
 
 	/**
@@ -649,22 +594,20 @@ export class RepositoryManager {
 	 * @param enabled - The feature new status
 	 */
 	async toggleIntegrationFields(enabled: boolean): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.toggleIntegrationFields({
 			repository: this.name,
 			enabled: enabled,
-		});
+		})
 
 		this.failIfNot200(
 			response,
-			`Could not ${enabled ? "enable" : "disable"} Integration Fields for ${
-				this.name
-			}`,
-		);
+			`Could not ${enabled ? "enable" : "disable"} Integration Fields for ${this.name}`,
+		)
 		profiler.done({
 			message: `Integration Fields ${enabled ? "enabled" : "disabled"}`,
-		});
+		})
 	}
 
 	/**
@@ -673,18 +616,18 @@ export class RepositoryManager {
 	 * @param {string} newPlanId - The Id of the new Plan to apply
 	 */
 	async changePlan(newPlanId: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.changePlan({
 			repository: this.name,
 			newPlanId: newPlanId,
 			bypassManualBilling: true, // For now the library does not support Stripe features
-		});
+		})
 
-		this.failIfNot200(response, "Could not change the Repository Plan");
+		this.failIfNot200(response, "Could not change the Repository Plan")
 		profiler.done({
 			message: `Repository Plan changed to ${newPlanId}`,
-		});
+		})
 	}
 
 	/**
@@ -693,25 +636,24 @@ export class RepositoryManager {
 	 * @param {string} email - The email of the user
 	 */
 	async addUser(email: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.addUserToRepository({
 			repository: this.name,
 			email: email,
-		});
+		})
 
-		const { data, status } = response;
+		const { data, status } = response
 		const success =
 			status === 200 ||
-			(status === 409 &&
-				JSON.stringify(data).includes("already a member of the repo"));
+			(status === 409 && JSON.stringify(data).includes("already a member of the repo"))
 		if (!success) {
-			logHttpResponse(response);
-			throw new Error(`Could not add a new user ${email} to the repository`);
+			logHttpResponse(response)
+			throw new Error(`Could not add a new user ${email} to the repository`)
 		}
 		profiler.done({
 			message: `User ${email} was added to the repository`,
-		});
+		})
 	}
 
 	/**
@@ -720,29 +662,25 @@ export class RepositoryManager {
 	 * @param {string} email - The email of the user
 	 */
 	async removeUser(email: string): Promise<void> {
-		const profiler = logger.startTimer();
+		const profiler = logger.startTimer()
 
 		const response = await this.manageV2Client.removeUserFromRepository({
 			repository: this.name,
 			email: email,
-		});
+		})
 
-		this.failIfNot200(
-			response,
-			`Could not remove the user ${email} from the repository`,
-		);
+		this.failIfNot200(response, `Could not remove the user ${email} from the repository`)
 		profiler.done({
 			message: `User ${email} was removed from the repository`,
-		});
+		})
 	}
 
 	/**
 	 * Update the role of a user in a repository
 	 *
 	 * @param {string} email - The email of the user
-	 * @param {string | Record<string, string>} role - The new Role of the user,
-	 *   either a string for basic workflow or an object such as `{ "lang_id":
-	 *   "Writer" }`
+	 * @param {string | Record<string, string>} role - The new Role of the user, either a string for
+	 *   basic workflow or an object such as `{ "lang_id": "Writer" }`
 	 *
 	 *   Example of roles are
 	 *
@@ -751,150 +689,244 @@ export class RepositoryManager {
 	 *   - Contributor
 	 *   - Manager (publisher)
 	 */
-	async updateUserRole(
-		email: string,
-		role: string | Record<string, string>,
-	): Promise<void> {
-		const profiler = logger.startTimer();
+	async updateUserRole(email: string, role: string | Record<string, string>): Promise<void> {
+		const profiler = logger.startTimer()
 
 		const response =
 			typeof role === "string"
 				? await this.wroomClient.updateRole(this.name, email, role)
-				: await this.wroomClient.updateRolePerLocal(this.name, email, role);
+				: await this.wroomClient.updateRolePerLocal(this.name, email, role)
 
 		this.failIfNot200(
 			response,
 			`Could not update the ${
 				typeof role === "string" ? "role" : "rolePerLocal"
 			} of the user ${email}`,
-		);
+		)
 		profiler.done({
 			message: `Updated User's ${
 				typeof role === "string" ? "role" : "rolePerLocal"
 			} for user ${email}`,
-		});
+		})
 	}
 
 	/**
-	 * Creates a document using the core api. If the Core api format is too
-	 * specific, use the migration api client to create a document with the
-	 * MigrationApiClient. See the `getMigrationApiClient()` method.
-	 *
-	 * @example To create a document by converting it from the Page Builder to
-	 * Core api format
-	 *
-	 * ```js
-	 * import { DocumentLegacy, UIDContentType } from '@prismicio/types-internal/lib/content';
-	 *
-	 * const document = {
-	 *   title: 'A new document',
-	 *   custom_type_id: 'home-page',
-	 *   locale: 'en-gb',
-	 *   integration_field_ids: [],
-	 *   tags: [],
-	 *   data: DocumentLegacy.encode({
-	 *     uid: {
-	 *       __TYPE__: UIDContentType,
-	 *       value: 'home-page',
-	 *     },
-	 *   })
-	 *   }
-	 *   await repository.createDocument(document, 'published');
-	 * 	 * ```
-	 * ```
-	 *
-	 * @returns
-	 *
-	 * @param document - in the core api format.
-	 *
-	 * @param status - status of the document, if published, the function will
-	 * wait for a new content api master ref to be created
+	 * Creates a document using the core api. If the Core api format is too specific, use the
+	 * migration api client to create a document with the MigrationApiClient. See the
+	 * `getMigrationApiClient()` method.
+	 *
+	 * @example
+	 * 	To create a document by converting it from the Page Builder to
+	 * 	Core api format
+	 *
+	 * 	```js
+	 * 	import { DocumentLegacy, UIDContentType } from '@prismicio/types-internal/lib/content';
+	 *
+	 * 	const document = {
+	 * 	title: 'A new document',
+	 * 	custom_type_id: 'home-page',
+	 * 	locale: 'en-gb',
+	 * 	integration_field_ids: [],
+	 * 	tags: [],
+	 * 	data: DocumentLegacy.encode({
+	 * 	uid: {
+	 * 	__TYPE__: UIDContentType,
+	 * 	value: 'home-page',
+	 * 	},
+	 * 	})
+	 * 	}
+	 * 	await repository.createDocument(document, 'published');
+	 * 	* ```
+	 * 	```
+	 *
+	 * 	@returns
+	 *
+	 * 	@param document - in the core api format.
+	 *
+	 * 	@param status - status of the document, if published, the function will
+	 * 	wait for a new content api master ref to be created
 	 */
 	async createDocument(
 		document: CoreApiDocumentCreationPayload,
 		status: "draft" | "published",
 	): Promise<CoreApiDocumentCreationResponse> {
-		const profiler = logger.startTimer();
-		const result = await this.coreApiClient.createDraft(document);
+		const profiler = logger.startTimer()
+		const result = await this.coreApiClient.createDraft(document)
 
-		let message = `Document created with id '${result.id}'`;
+		let message = `Document created with id '${result.id}'`
 		if (status === "published") {
-			const contentApi = this.getContentApiClient();
-			const masterRef = await contentApi.getMasterRef();
-			await this.coreApiClient.publishDraft(result.id);
-			await expect
-				.poll(async () => contentApi.getMasterRef(), {
-					timeout: 10_000,
-					message: "Waiting for new master ref to be available",
-				})
-				.not.toBe(masterRef);
-			message += ", status 'published' and new master ref available";
+			const contentApi = this.getContentApiClient()
+			const masterRef = await contentApi.getMasterRef()
+			await this.coreApiClient.publishDraft(result.id)
+			await this.waitForNewMasterRef(contentApi, masterRef)
+			message += ", status 'published' and new master ref available"
 		}
 		profiler.done({
 			message,
-		});
+		})
 
-		return result;
+		return result
+	}
+
+	/**
+	 * Updates an existing document using the core api by creating a new draft version on top of the
+	 * given base version. If the status is published, the function will, unless disabled, wait for a
+	 * new content api master ref to be created.
+	 *
+	 * @param documentId - The id of the document to update.
+	 * @param data - The new version payload in the core api format.
+	 * @param baseVersionId - The id of the version the draft is created from.
+	 * @param status - Status of the new version, if published, the function will wait for a new
+	 *   content api master ref to be created.
+	 * @param options - Additional options.
+	 * @param options.skipMasterRefWait - When publishing, skip waiting for a new content api master
+	 *   ref to be available (default false). Set to true to return without waiting for the
+	 *   projection.
+	 * @returns The updated document, including the new version's id. When publishing, the document is
+	 *   retrieved again after publication so that the returned versions reflect the published state.
+	 */
+	async updateDocument(
+		documentId: string,
+		data: CoreApiDocumentUpdatePayload,
+		baseVersionId: string,
+		status: "draft" | "published",
+		options: { skipMasterRefWait?: boolean } = {},
+	): Promise<CoreApiDocumentCreationResponse> {
+		const { skipMasterRefWait = false } = options
+		const profiler = logger.startTimer()
+		const draft = await this.coreApiClient.updateDraft(documentId, data, baseVersionId)
+
+		if (status === "draft") {
+			profiler.done({ message: `Document '${documentId}' updated` })
+
+			return draft
+		}
+
+		let message = `Document '${documentId}' updated, status 'published'`
+		if (skipMasterRefWait) {
+			await this.coreApiClient.publishDraft(documentId)
+		} else {
+			const contentApi = this.getContentApiClient()
+			const masterRef = await contentApi.getMasterRef()
+			await this.coreApiClient.publishDraft(documentId)
+			await this.waitForNewMasterRef(contentApi, masterRef)
+			message += " and new master ref available"
+		}
+
+		const { results } = await this.coreApiClient.getDocuments({
+			documentIds: [documentId],
+			limit: 1,
+		})
+		const publishedDocument = results[0]
+		if (!publishedDocument) {
+			throw new Error(`Could not retrieve document '${documentId}' after publication`)
+		}
+
+		profiler.done({
+			message,
+		})
+
+		return publishedDocument
+	}
+
+	/**
+	 * Unpublishes (archives) a live document using the core api. Unless disabled, waits for a new
+	 * content api master ref to be available.
+	 *
+	 * @param documentId - The id of the document to unpublish.
+	 * @param options - Additional options.
+	 * @param options.skipMasterRefWait - Skip waiting for a new content api master ref to be
+	 *   available (default false). Set to true to return without waiting for the projection.
+	 */
+	async unpublishDocument(
+		documentId: string,
+		options: { skipMasterRefWait?: boolean } = {},
+	): Promise<void> {
+		const { skipMasterRefWait = false } = options
+		const profiler = logger.startTimer()
+
+		if (skipMasterRefWait) {
+			await this.coreApiClient.unpublishDocument(documentId)
+			profiler.done({ message: `Document '${documentId}' unpublished` })
+
+			return
+		}
+
+		const contentApi = this.getContentApiClient()
+		const masterRef = await contentApi.getMasterRef()
+		await this.coreApiClient.unpublishDocument(documentId)
+		await this.waitForNewMasterRef(contentApi, masterRef)
+
+		profiler.done({
+			message: `Document '${documentId}' unpublished and new master ref available`,
+		})
 	}
 
 	/**
 	 * Retrieves data for a specific document version.
 	 *
 	 * @param versionId - The document's version ID.
-	 *
 	 * @returns The document's version data.
 	 */
 	async getDocumentData(versionId: string): Promise<CoreApiDocumentData> {
-		return await this.coreApiClient.getDocumentData(versionId);
+		return await this.coreApiClient.getDocumentData(versionId)
 	}
 
-	async setupIntegrationFields(
-		integrationFields: IntegrationFieldConfig[],
-	): Promise<void> {
-		const profiler = logger.startTimer();
+	async setupIntegrationFields(integrationFields: IntegrationFieldConfig[]): Promise<void> {
+		const profiler = logger.startTimer()
 
 		if (!this.integrationFieldsClient) {
 			throw new Error(
 				"Integration Fields client not found. Did you provide a integration fields api url in the configuration?",
-			);
+			)
 		}
 
-		await this.integrationFieldsClient.setupIntegrationFields(
-			integrationFields,
-		);
+		await this.integrationFieldsClient.setupIntegrationFields(integrationFields)
 		profiler.done({
 			message: `Integration Fields setup`,
-		});
+		})
+	}
+
+	private async waitForNewMasterRef(
+		contentApi: ContentApiClient,
+		previousMasterRef: string,
+	): Promise<void> {
+		await expect
+			.poll(async () => contentApi.getMasterRef(), {
+				timeout: 10_000,
+				message: "Waiting for new master ref to be available",
+			})
+			.not.toBe(previousMasterRef)
 	}
 }
 
 export type RepositoryConfig = {
-	customLocale?: CustomLocale;
-	locales?: string[];
-	defaultLocale?: string;
-	slices?: SharedSlice[];
-	customTypes?: CustomType[];
-	preview?: Preview;
-	simulatorURL?: string;
-	rolePerLocal?: boolean;
-	customRoles?: boolean;
-	integrationFields?: IntegrationFieldConfig[];
-};
+	customLocale?: CustomLocale
+	locales?: string[]
+	defaultLocale?: string
+	slices?: SharedSliceModel[]
+	customTypes?: DynamicCustomTypeModel[]
+	preview?: Preview
+	simulatorURL?: string
+	rolePerLocal?: boolean
+	customRoles?: boolean
+	integrationFields?: IntegrationFieldConfig[]
+}
 
 export type Preview = {
-	name: string;
-	websiteURL: string;
-	resolverPath: string;
-};
+	name: string
+	websiteURL: string
+	resolverPath: string
+}
 
 export type CustomLocale = {
 	lang: {
-		label: string;
-		id: string;
-		useStandardAnalyzer?: boolean;
-	};
+		label: string
+		id: string
+		useStandardAnalyzer?: boolean
+	}
 	region: {
-		label: string;
-		id: string;
-	};
-};
+		label: string
+		id: string
+	}
+}