@powerhousedao/powerhouse-vetra-packages 6.2.2-dev.70 → 6.2.2-dev.71

package/dist/node/{dist-CRrgpr8A.mjs → dist-CNlIJlyu.mjs}

@@ -1,6 +1,6 @@
 import { D as __commonJSMin, M as __toESM, t as capitalCase } from "./dist-DT7jI9ol.mjs";
-import { A as createZip, C as baseSaveToFileHandle, D as createPresignedHeader, H as replayDocumentVersioned, S as baseLoadFromInputVersioned, Z as setName, a as handleTargetNameCollisions, at as validateInitialState, ct as generateId, f as logger, i as generateNodesCopy, l as moveNode, n as copyNode, o as isFileNode, ot as validateModules, s as isFolderNode, st as validateStateSchemaName, t as addFolder, u as updateNode, v as assertAuthPreservedOnDuplicate, w as buildSignedAction, x as baseLoadFromInput } from "./document-drive-B65n0lIk.mjs";
-import { a as DriveCollectionId, i as SyncStatus, o as ModuleNotFoundError, t as require_main } from "./main-B5JSm6Hi.mjs";
+import { C as baseLoadFromInputVersioned, O as createPresignedHeader, Q as setName, S as baseLoadFromInput, T as buildSignedAction, U as replayDocumentVersioned, a as handleTargetNameCollisions, ct as validateStateSchemaName, f as logger, h as UnsupportedDocumentModelVersionError, i as generateNodesCopy, j as createZip, l as moveNode, lt as generateId, n as copyNode, o as isFileNode, ot as validateInitialState, s as isFolderNode, st as validateModules, t as addFolder, u as updateNode, w as baseSaveToFileHandle, y as assertAuthPreservedOnDuplicate } from "./document-drive-BV8zVgUr.mjs";
+import { a as DriveCollectionId, i as SyncStatus, o as ModuleNotFoundError, t as require_main } from "./main-DutzjcaZ.mjs";
 import { t as require_graphql } from "./graphql-BfAoPeWM.mjs";
 import { createContext, use, useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import "react/jsx-runtime";
@@ -1801,7 +1801,16 @@ slug.setLocale = function(locale) {
 	defaultLocale = locales[locale] || {};
 };
 //#endregion
-//#region ../reactor-browser/dist/document-operations-DQfMZpj8.js
+//#region ../reactor-browser/dist/document-operations-B2lxu6qg.js
+var UnsupportedDocumentTypeError = class extends Error {
+	constructor(documentType) {
+		super(`Document type ${documentType} is not supported`);
+		this.name = "UnsupportedDocumentTypeError";
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "UnsupportedDocumentTypeError";
+	}
+};
 var DocumentModelNotFoundError = class extends Error {
 	documentType;
 	name = "DocumentModelNotFoundError";
@@ -1839,6 +1848,20 @@ function showDeleteNodeModal(nodeOrId) {
 		id: typeof nodeOrId === "string" ? nodeOrId : nodeOrId.id
 	});
 }
+function isDocumentTypeSupported(documentType, supportedDocuments) {
+	if (!supportedDocuments?.length) return true;
+	return supportedDocuments.some((pattern) => {
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			return documentType.startsWith(prefix + "/");
+		}
+		if (pattern.endsWith("*") && !pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -1);
+			return documentType.startsWith(prefix);
+		}
+		return pattern === documentType;
+	});
+}
 function getUserPermissions() {
 	const user = window.ph?.renown?.user;
 	const allowList = window.ph?.allowList;
@@ -1852,6 +1875,40 @@ function getUserPermissions() {
 	};
 }
 const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
+/** An unreadable drive cannot be shown to hold no duplicate, so reads throw. */
+async function isDocumentInLocation(reactorClient, document, driveId, parentFolder) {
+	const drive = await reactorClient.get(driveId);
+	const nodeById = drive.state.global.nodes.find((node) => node.id === document.header.id);
+	if (nodeById && nodeById.parentFolder === (parentFolder ?? null)) return {
+		isDuplicate: true,
+		duplicateType: "id",
+		nodeId: nodeById.id
+	};
+	const nodeByNameAndType = drive.state.global.nodes.find((node) => isFileNode(node) && node.name === document.header.name && node.documentType === document.header.documentType && node.parentFolder === (parentFolder ?? null));
+	if (nodeByNameAndType) return {
+		isDuplicate: true,
+		duplicateType: "name",
+		nodeId: nodeByNameAndType.id
+	};
+	return { isDuplicate: false };
+}
+function getDocumentTypeIcon(document) {
+	switch (document.header.documentType) {
+		case "powerhouse/document-model": return "document-model";
+		case "powerhouse/app": return "app";
+		case "powerhouse/document-editor": return "editor";
+		case "powerhouse/subgraph": return "subgraph";
+		case "powerhouse/package": return "package";
+		case "powerhouse/processor": {
+			const processorType = document.state.global?.type;
+			if (processorType === "analytics") return "analytics-processor";
+			if (processorType === "relational") return "relational-processor";
+			if (processorType === "codegen") return "codegen-processor";
+			return;
+		}
+		default: return;
+	}
+}
 async function downloadFile(document, fileName) {
 	try {
 		const data = await createZip(document);
@@ -2056,37 +2113,201 @@ async function addDocument(driveId, name, documentType, parentFolder, document,
 		kind: "file"
 	};
 }
-async function addFile(file, driveId, name, parentFolder) {
-	logger.verbose(`addFile(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+/**
+* How many ids an import will try before giving up. The check before the create
+* catches an id that is already taken; this bound covers the window between the
+* two, where a create can still lose to a claim made in the meantime.
+*/
+const IMPORT_ID_ATTEMPTS = 3;
+/** True when this error, or anything it wraps, is a taken document id. */
+function isDocumentAlreadyExists(error) {
+	let current = error;
+	while (current instanceof Error) {
+		if (current.name === "DocumentAlreadyExistsError") return true;
+		current = current.cause;
+	}
+	return false;
+}
+/**
+* Creates the imported document under an id that is free, retrying on a
+* collision.
+*
+* The check cannot stand on its own: it answers for the moment it ran, and the
+* create that follows can still land on an id claimed in between. The store
+* rejects that create as DocumentAlreadyExistsError, which is not retryable
+* under the same id and is resolved by minting another one. A create that
+* fails leaves the drive untouched, so a retry has nothing to clean up.
+*/
+async function createImportedDocument(reactor, document, driveId, name, parentFolder) {
+	let documentId = await reactor.isDocumentIdTaken(document.header.id) ? generateId() : document.header.id;
+	for (let attempt = 1;; attempt++) {
+		const header = createPresignedHeader(documentId, document.header.documentType);
+		header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
+		header.meta = document.header.meta;
+		header.name = name || document.header.name;
+		const initialDocument = {
+			...document,
+			header,
+			state: document.initialState,
+			operations: Object.keys(document.operations).reduce((acc, key) => {
+				acc[key] = [];
+				return acc;
+			}, {})
+		};
+		try {
+			const fileNode = await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
+			if (!fileNode) throw new Error("There was an error adding file");
+			return {
+				documentId,
+				fileNode
+			};
+		} catch (error) {
+			if (!isDocumentAlreadyExists(error) || attempt === IMPORT_ID_ATTEMPTS) throw error;
+			logger.warn(`Document id ${documentId} was taken between the check and the create; importing under a new id`);
+			documentId = generateId();
+		}
+	}
+}
+async function addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	logger.verbose(`addFileWithProgress(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const reactor = window.ph?.reactorClientModule?.client;
+	if (!reactor) {
+		onProgress?.({
+			stage: "failed",
+			progress: 100,
+			error: "ReactorClient not initialized"
+		});
+		throw new Error("ReactorClient not initialized");
+	}
 	const { isAllowedToCreateDocuments } = getUserPermissions();
 	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create files");
-	const document = await loadFile(file);
-	let duplicateId = false;
-	const reactorClient = window.ph?.reactorClient;
-	if (!reactorClient) throw new Error("ReactorClient not initialized");
 	try {
-		await reactorClient.get(document.header.id);
-		duplicateId = true;
-	} catch {}
-	const documentId = duplicateId ? generateId() : document.header.id;
-	const header = createPresignedHeader(documentId, document.header.documentType);
-	header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
-	header.meta = document.header.meta;
-	header.name = name || document.header.name;
-	const initialDocument = {
-		...document,
-		header,
-		state: document.initialState,
-		operations: Object.keys(document.operations).reduce((acc, key) => {
-			acc[key] = [];
-			return acc;
-		}, {})
-	};
-	await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
-	for (const segment of splitAtUpgradeBoundaries(document.operations)) {
-		await uploadOperations(documentId, segment.operations, queueOperations);
-		if (segment.upgradeTo !== void 0) await upgradeDocument(documentId, segment.upgradeTo);
+		onProgress?.({
+			stage: "loading",
+			progress: 0
+		});
+		let document;
+		try {
+			document = await loadFile(file);
+		} catch (loadError) {
+			if (UnsupportedDocumentModelVersionError.isError(loadError)) {
+				showPHModal({
+					type: "documentVersionUnsupported",
+					documentType: loadError.documentType,
+					requiredVersion: loadError.requiredVersion,
+					availableVersions: loadError.availableVersions
+				});
+				onProgress?.({
+					stage: "failed",
+					progress: 100,
+					error: loadError.message
+				});
+				return;
+			}
+			const discoveryService = window.ph?.packageDiscoveryService;
+			if (discoveryService && DocumentModelNotFoundError.isError(loadError)) {
+				retryAfterDiscovery(discoveryService, loadError.documentType, file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict).catch((retryError) => {
+					logger.error("Import retry after discovery failed: @error", retryError);
+					onProgress?.({
+						stage: "failed",
+						progress: 100,
+						error: retryError instanceof Error ? retryError.message : String(retryError)
+					});
+				});
+				return;
+			}
+			throw loadError;
+		}
+		const duplicateCheck = await isDocumentInLocation(reactor, document, driveId, parentFolder);
+		if (duplicateCheck.isDuplicate && !resolveConflict) {
+			onProgress?.({
+				stage: "conflict",
+				progress: 0,
+				duplicateType: duplicateCheck.duplicateType
+			});
+			return;
+		}
+		const documentType = getDocumentTypeIcon(document);
+		if (documentType) onProgress?.({
+			stage: "loading",
+			progress: 10,
+			documentType
+		});
+		else onProgress?.({
+			stage: "loading",
+			progress: 10
+		});
+		if (!isDocumentTypeSupported(document.header.documentType, documentTypes)) {
+			onProgress?.({
+				stage: "unsupported-document-type",
+				progress: 100,
+				error: `Document type ${document.header.documentType} is not supported`
+			});
+			throw new UnsupportedDocumentTypeError(document.header.documentType);
+		}
+		await reactor.getDocumentModelModule(document.header.documentType);
+		onProgress?.({
+			stage: "initializing",
+			progress: 10
+		});
+		const created = await createImportedDocument(reactor, document, driveId, name, parentFolder);
+		const documentId = created.documentId;
+		const fileNode = created.fileNode;
+		onProgress?.({
+			stage: "initializing",
+			progress: 20
+		});
+		await reactor.get(documentId);
+		console.log("Document created, starting upload of operations");
+		const segments = splitAtUpgradeBoundaries(document.operations);
+		const totalOperations = segments.reduce((total, segment) => total + countOperations(segment.operations), 0);
+		let uploadedBefore = 0;
+		for (const segment of segments) {
+			await uploadOperations(documentId, segment.operations, queueOperations, { onProgress: (uploadProgress) => {
+				if (uploadProgress.uploadedOperations === void 0) return;
+				const uploaded = uploadedBefore + uploadProgress.uploadedOperations;
+				const uploadPercent = totalOperations > 0 ? uploaded / totalOperations : 0;
+				onProgress?.({
+					stage: "uploading",
+					progress: 20 + Math.round(uploadPercent * 80),
+					totalOperations,
+					uploadedOperations: uploaded
+				});
+			} });
+			uploadedBefore += countOperations(segment.operations);
+			if (segment.upgradeTo !== void 0) await reactor.upgradeDocument(documentId, segment.upgradeTo);
+		}
+		onProgress?.({
+			stage: "complete",
+			progress: 100,
+			fileNode
+		});
+		return fileNode;
+	} catch (error) {
+		if (!UnsupportedDocumentTypeError.isError(error)) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			onProgress?.({
+				stage: "failed",
+				progress: 100,
+				error: errorMessage
+			});
+		}
+		throw error;
+	}
+}
+async function retryAfterDiscovery(discoveryService, documentType, file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	if (!discoveryService) return;
+	try {
+		await discoveryService.load(documentType);
+	} catch {
+		onProgress?.({
+			stage: "unsupported-document-type",
+			progress: 100,
+			error: `Document type ${documentType} is not supported`
+		});
+		return;
 	}
+	await addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict);
 }
 async function addFolder$1(driveId, name, parentFolder) {
 	const { isAllowedToCreateDocuments } = getUserPermissions();
@@ -2216,15 +2437,6 @@ async function copyNode$1(driveId, src, target) {
 	return await queueActions(drive, copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput)));
 }
 /**
-* Upgrades a document to a newer document model version. Defaults to the
-* latest registered version for the document's type.
-*/
-async function upgradeDocument(documentId, toVersion) {
-	const reactorClient = window.ph?.reactorClientModule?.client;
-	if (!reactorClient) throw new Error("ReactorClient not initialized");
-	return reactorClient.upgradeDocument(documentId, toVersion);
-}
-/**
 * The operation selection of `GetDocumentOperations`, lifted into a fragment so
 * the write path can reuse `remoteOperationToLocal` on the items it selects.
 */
@@ -3837,7 +4049,7 @@ function useNodeActions() {
 	const drives = useDrives();
 	async function onAddFile(file, parent) {
 		if (!selectedDriveId) return;
-		return addFile(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id);
+		return addFileWithProgress(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id, void 0, void 0, "duplicate");
 	}
 	async function onAddFolder(name, parent) {
 		if (!selectedDriveId) return;
@@ -4161,4 +4373,4 @@ createDebouncedRefreshReactorDataClient();
 //#endregion
 export { showRevisionHistory as A, t$2 as B, addFolder$1 as C, setSelectedNode as D, setSelectedDrive as E, useSelectedDriveId as F, useDocumentById as H, useSelectedDriveSafe as I, useStudioMode as L, useDragNode as M, useDropNode as N, showDeleteNodeModal as O, usePHToast as P, e$1 as R, addDocument as S, isFolderNodeKind as T, t$5 as V, useSelectedNodePath as _, useDownloadDocument as a, useTheme as b, useGetSwitchboardLink as c, useNodeParentFolderById as d, useNodesInSelectedDriveOrFolder as f, useSelectedFolder as g, useSelectedDocumentSafe as h, useDocumentVersionStatus as i, useDisabledEditors as j, showPHModal as k, useNodeActions as l, useSelectedDocumentOfType as m, preloadEditorModule as n, useEditorModules as o, useParentFolderForSelectedNode as p, useAllowedDocumentModelModules as r, useEditorModulesForDocumentType as s, getSyncStatusSync as t, useNodeById as u, useSetPHAppConfig as v, isFileNodeKind as w, useUserPermissions as x, useSetPHDocumentEditorConfig as y, e$4 as z };
 
-//# sourceMappingURL=dist-CRrgpr8A.mjs.map
+//# sourceMappingURL=dist-CNlIJlyu.mjs.map