camox 0.77.0 → 0.79.0

package/dist/features/studio/usePublishDraft.js

@@ -0,0 +1,116 @@
+import { reads, useReadQuery, useStudioCache } from "../../lib/studio-reads.js";
+import { draftMutations } from "../../lib/queries.js";
+import { publishToast, useLeaveDraft } from "./viewSwitch.js";
+import * as React from "react";
+import { PUBLISH_BLOCKED_ERROR } from "@camox/api-contract/drafts";
+import { useMutation } from "@tanstack/react-query";
+import { toast } from "@camox/ui/toaster";
+
+//#region src/features/studio/usePublishDraft.ts
+const PUBLISH_FAILED = "The publish couldn't finish on Camox's side, and Live is as it was. Try again.";
+const PUBLISH_BLOCKED = "This draft has blockers to fix before it can publish.";
+/**
+* Why the last publish with code stopped, when it isn't a blocker, which the review shows
+* instead.
+*/
+const PUBLISH_STOPPED = {
+	revisionChanged: "The draft's code changed while publishing, so the publish stopped and Live is as it was. Publish again.",
+	liveCodeMoved: "Live's code changed while publishing, and the draft took too long to take it in, so the publish stopped and Live is as it was. Try again.",
+	conflictsChanged: PUBLISH_FAILED,
+	failed: PUBLISH_FAILED
+};
+/**
+* Whether a publish request failed on Camox's side rather than being refused: a server error,
+* or no answer at all. Either way the publish applied nothing.
+*/
+const failedOnCamoxSide = (error) => {
+	const status = error.status;
+	return typeof status !== "number" || status >= 500;
+};
+/** What Publish sends: the revision a draft with code shows, which publishing ships. */
+const publishInput = (projectId, shown) => ({
+	projectId,
+	...shown.code?.revision && { revision: shown.code.revision }
+});
+/**
+* Publishes the draft the studio views, at what its review reads now (ADR 0043). One toast
+* follows the publish: it says it's publishing, then turns into how it ended. Once the draft
+* ends, the studio switches to Live, and the toast says so. A draft with code publishes in the
+* background: `publishing` stays true until it lands or stops. Blockers, found before publishing
+* or stopping it, call `onBlocked`, for the review to show them.
+*
+* The review is read only to publish, and followed while a background publish runs: reading it
+* hurries the draft's overview.
+*/
+function usePublishDraft({ projectId, draftId, onBlocked }) {
+	const read = reads.publishPreview({
+		projectId,
+		draftId
+	});
+	const cache = useStudioCache();
+	const leaveDraft = useLeaveDraft();
+	const id = publishToast(draftId);
+	const [following, setFollowing] = React.useState(false);
+	const preview = useReadQuery(read, { enabled: following });
+	const blocked = () => {
+		toast.error(PUBLISH_BLOCKED, { id });
+		onBlocked?.();
+	};
+	const publish = useMutation({
+		...draftMutations.publish(),
+		onSuccess: async (result) => {
+			if ("publishing" in result && result.publishing) {
+				setFollowing(true);
+				await cache.reload(read).catch(() => {});
+				return;
+			}
+			if (!result.empty) return leaveDraft(result.ended);
+			toast.info("This draft has no changes, so there is nothing to publish.", { id });
+			cache.reload(read).catch(() => {});
+		},
+		onError: (error) => {
+			cache.reload(read).catch(() => {});
+			if (failedOnCamoxSide(error)) toast.error(PUBLISH_FAILED, { id });
+			else if (error.code === PUBLISH_BLOCKED_ERROR) blocked();
+			else toast.error(error.message, { id });
+		}
+	});
+	const [reading, setReading] = React.useState(false);
+	const start = async () => {
+		toast.loading("Publishing…", { id });
+		setReading(true);
+		let shown;
+		try {
+			shown = await cache.reload(read);
+		} catch {
+			toast.error(PUBLISH_FAILED, { id });
+			return;
+		} finally {
+			setReading(false);
+		}
+		if (shown.blockers.length > 0) return blocked();
+		publish.mutate(publishInput(projectId, shown));
+	};
+	const data = preview.data;
+	const backgroundPublish = !!data?.code?.publishing;
+	const [stopped, setStopped] = React.useState(null);
+	if (following && !publish.isPending && data && !backgroundPublish) {
+		setFollowing(false);
+		setStopped(data);
+	}
+	const reportStop = React.useEffectEvent((shown) => {
+		const reason = shown.code?.publishAborted;
+		if (shown.blockers.length > 0) return blocked();
+		toast.error((reason && PUBLISH_STOPPED[reason]) ?? "The publish couldn't finish on Camox's side, and Live is as it was. Try again.", { id });
+	});
+	React.useEffect(() => {
+		if (stopped) reportStop(stopped);
+	}, [stopped]);
+	return {
+		publish: start,
+		publishing: reading || publish.isPending || backgroundPublish
+	};
+}
+
+//#endregion
+export { PUBLISH_FAILED, PUBLISH_STOPPED, usePublishDraft };

package/dist/features/studio/viewSwitch.js

@@ -32,9 +32,14 @@ function useSwitchView() {
 	return t0;
 }
 /**
+* The toast of a draft's publish, from Publish to the studio showing Live: each toast with this
+* id replaces the last.
+*/
+const publishToast = (draftId) => `publish:${draftId}`;
+/**
 * Switches the studio to Live once the draft it views ended or was archived, by this member, here
-* or in another tab, replacing the draft's URL entry. An ended draft's dialog already showed it
-* working, so its toast only says so once Live shows; an archived draft's toast shows meanwhile
+* or in another tab, replacing the draft's URL entry. An ended draft's publish toast already
+* showed it working, so it only turns into saying so once Live shows; an archived draft's toast shows meanwhile
 * too. Called once the studio already left the draft, it does nothing.
 */
 function useLeaveDraft() {
@@ -48,7 +53,8 @@ function useLeaveDraft() {
 			draftScope.leave(left);
 			if (!left) return;
 			if ("outcome" in left) {
-				shown().then(() => toast.success(`Draft ${left.outcome}. You're now viewing Live.`), _temp);
+				const id = publishToast(left.draftId);
+				shown().then(() => toast.success(`Draft ${left.outcome}. You're now viewing Live.`, { id }), () => toast.error(SWITCH_FAILED, { id }));
 				return;
 			}
 			toastSwitch(shown(), {
@@ -62,9 +68,6 @@ function useLeaveDraft() {
 	} else t0 = $[2];
 	return t0;
 }
-function _temp() {
-	return toast.error(SWITCH_FAILED);
-}
 
 //#endregion
-export { useLeaveDraft, useSwitchView };
+export { publishToast, useLeaveDraft, useSwitchView };

package/dist/features/vite/vite.js

@@ -87,6 +87,7 @@ const CAMOX_OPTIMIZED_DEPS = [
 	"camox > @base-ui/react/popover",
 	"camox > @base-ui/react/select",
 	"camox > @base-ui/react/separator",
+	"camox > @base-ui/react/slider",
 	"camox > @base-ui/react/switch",
 	"camox > @base-ui/react/tabs",
 	"camox > @base-ui/react/toggle",

package/dist/lib/queries.js

@@ -80,6 +80,16 @@ const localeMutations = {
 	/** Adds a page or record deleted from the locale viewed back to it. */
 	addBack: () => getOrpc().locales.addBack.mutationOptions()
 };
+/**
+* Correcting memory and saving the Voice: content writes, so on Live they start a draft (ADR 0049,
+* ADR 0051).
+*/
+const memoryMutations = {
+	add: () => getOrpc().memories.add.mutationOptions(),
+	change: () => getOrpc().memories.change.mutationOptions(),
+	delete: () => getOrpc().memories.delete.mutationOptions(),
+	saveVoice: () => getOrpc().memories.saveVoice.mutationOptions()
+};
 const blockMutations = {
 	delete: () => getOrpc().blocks.delete.mutationOptions(),
 	deleteMany: () => getOrpc().blocks.deleteMany.mutationOptions(),
@@ -153,4 +163,4 @@ const fileMutations = {
 };
 
 //#endregion
-export { blockMutations, collectionMutations, draftMutations, fileMutations, localeMutations, pageMutations, projectMutations, publicationMutations, repeatableItemMutations, specialistMutations };
+export { blockMutations, collectionMutations, draftMutations, fileMutations, localeMutations, memoryMutations, pageMutations, projectMutations, publicationMutations, repeatableItemMutations, specialistMutations };

package/dist/lib/studio-reads.d.ts

@@ -8,6 +8,7 @@ import "react";
 import "@camox/api-contract/query-keys";
 import "@camox/api-contract/specialists";
 import { QueryClient } from "@tanstack/react-query";
+import "@camox/api-contract/voice";
 //#region src/lib/studio-reads.d.ts
 type LayoutRead = Awaited<ReturnType<ApiClient["layouts"]["get"]>>;
 /** A layout's structure: its blocks before and after the content of its pages. */

package/dist/lib/studio-reads.js

@@ -59,6 +59,18 @@ const reads = {
 		fetch: ({ api, signal }, { projectId }) => api.locales.list({ projectId }, { signal }),
 		staleTime: Infinity
 	}),
+	memories: entry({
+		key: ({ projectId }) => [...queryKeys.memories.list, projectId],
+		everyLocale: true,
+		fetch: ({ api, signal }, { projectId }) => api.memories.list({ projectId }, { signal }),
+		staleTime: Infinity
+	}),
+	voice: entry({
+		key: ({ projectId }) => [...queryKeys.memories.voice, projectId],
+		everyLocale: true,
+		fetch: ({ api, signal }, { projectId }) => api.memories.voice({ projectId }, { signal }),
+		staleTime: Infinity
+	}),
 	missingFromLocale: entry({
 		key: ({ projectId }) => [
 			"camox",

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.77.0";
+var version = "0.79.0";
 
 //#endregion
 export { version };