@codecks/fetch 0.1.5 → 0.1.7

package/dist/_exploration/create-hooks.js

@@ -1,85 +1,212 @@
-import { queryToKey } from "../query-helpers-DsMMOtSO.js";
+import { queryToKey } from "../query-helpers-iX1fiqLv.js";
+import { getFieldKey } from "../immediate-cache-DiH8tpJM.js";
 import { use, useSyncExternalStore } from "react";
 
-//#region src/_exploration/user-query-manager.ts
-const diffResults = (prevTrackedData, nextStorePayload) => {
-	const nextPartKeys = nextStorePayload.partKeys;
-	const prevSet = new Set(prevTrackedData.partKeys);
-	const nextSet = new Set(nextPartKeys);
-	const added = nextPartKeys.filter((key) => !prevSet.has(key));
-	const removed = prevTrackedData.partKeys.filter((key) => !nextSet.has(key));
+//#region src/_exploration/utils/deepUpdateTree.ts
+/**
+* Reconciles two arrays using key-based matching (similar to React's reconciliation).
+* Assumes all elements have a `~key` property - caller must verify this before calling.
+* Returns the new array with structural sharing for unchanged elements.
+*/
+function reconcileKeyedArray(prevArray, nextArray, update, added, removed) {
+	if (prevArray.length === nextArray.length) {
+		let keysUnchanged = true;
+		for (let i = 0; i < prevArray.length; i++) if (prevArray[i]["~key"] !== nextArray[i]["~key"]) {
+			keysUnchanged = false;
+			break;
+		}
+		if (keysUnchanged) {
+			const result$1 = [];
+			let hasChanges = false;
+			for (let i = 0; i < nextArray.length; i++) {
+				const updated = update(prevArray[i], nextArray[i]);
+				result$1.push(updated);
+				if (updated !== prevArray[i]) hasChanges = true;
+			}
+			if (!hasChanges) return prevArray;
+			return result$1;
+		}
+	}
+	const prevByKey = new Map(prevArray.map((i) => [i["~key"], i]));
+	const nextByKey = new Map(nextArray.map((i) => [i["~key"], i]));
+	const result = [];
+	for (const nextItem of nextArray) {
+		const key = nextItem["~key"];
+		if (prevByKey.has(key)) {
+			const prevItem = prevByKey.get(key);
+			const updated = update(prevItem, nextItem);
+			result.push(updated);
+		} else {
+			added.push(nextItem);
+			result.push(nextItem);
+		}
+	}
+	for (const [key, value] of prevByKey) if (!nextByKey.has(key)) removed.push(value);
+	return result;
+}
+function isInstance(value) {
+	return typeof value === "object" && value !== null && "~key" in value;
+}
+function deepUpdateTree(prev, next) {
+	const added = [];
+	const removed = [];
+	function update(prevVal, nextVal) {
+		if (prevVal === nextVal) return prevVal;
+		if (prevVal["~key"] !== nextVal["~key"]) {
+			removed.push(prevVal);
+			added.push(nextVal);
+			return nextVal;
+		}
+		let hasChanges = false;
+		const result$1 = {
+			"~model": prevVal["~model"],
+			"~key": prevVal["~key"]
+		};
+		for (const key in nextVal) {
+			if (key === "~model" || key === "~key") continue;
+			const prevField = prevVal[key];
+			const nextField = nextVal[key];
+			if (prevField === nextField) {
+				result$1[key] = prevField;
+				continue;
+			}
+			if (Array.isArray(prevField) && Array.isArray(nextField)) {
+				if (prevField.length === 0 && nextField.length === 0) {
+					result$1[key] = prevField;
+					continue;
+				}
+				const isInstanceArray = isInstance(prevField[0]) && isInstance(nextField[0]);
+				if (isInstanceArray) {
+					const reconciled = reconcileKeyedArray(prevField, nextField, update, added, removed);
+					result$1[key] = reconciled;
+					if (reconciled !== prevField) hasChanges = true;
+					continue;
+				}
+				result$1[key] = nextField;
+				if (prevField !== nextField) hasChanges = true;
+				continue;
+			}
+			if (isInstance(prevField) && isInstance(nextField)) {
+				const updated = update(prevField, nextField);
+				result$1[key] = updated;
+				if (updated !== prevField) hasChanges = true;
+				continue;
+			}
+			result$1[key] = nextField;
+			if (prevField !== nextField) hasChanges = true;
+		}
+		return hasChanges ? result$1 : prevVal;
+	}
+	const result = update(prev, next);
 	return {
+		result,
 		added,
-		removed,
-		nextTrackedData: {
-			partKeys: nextPartKeys,
-			value: nextStorePayload.value
-		}
-	};
-};
-const createStoreQuery = (opts) => {
-	const { onDispose, updateDataListener, store, q, ids, model } = opts;
-	const queryListeners = new Set();
-	let trackedData = {
-		partKeys: [],
-		value: null
+		removed
 	};
-	const reconcileNextResult = (storePayload) => {
-		const { added, removed, nextTrackedData } = diffResults(trackedData, storePayload);
-		if (added.length || removed.length) {
-			trackedData = nextTrackedData;
-			updateDataListener({
-				added,
-				removed
-			}, notify);
-			queryListeners.forEach((listener) => listener());
+}
+
+//#endregion
+//#region src/_exploration/user-query-manager.ts
+/**
+* Extracts all field keys from a data tree for subscription tracking.
+* Returns a set of field keys in the format "model:id:field"
+*/
+function extractFieldKeys(data) {
+	const fields = new Set();
+	function traverse(obj) {
+		if (!obj || typeof obj !== "object") return;
+		if (obj["~model"] && obj["~key"]) {
+			const model = obj["~model"];
+			const key = obj["~key"];
+			for (const field in obj) {
+				if (field.startsWith("~")) continue;
+				fields.add(getFieldKey(model, key, field));
+				const value = obj[field];
+				if (Array.isArray(value)) value.forEach(traverse);
+				else traverse(value);
+			}
+		}
+	}
+	traverse(data);
+	return fields;
+}
+var UserQuery = class {
+	queryListeners = new Set();
+	subscribedFields = new Map();
+	currentData = null;
+	userQueryResult;
+	constructor(opts) {
+		this.opts = opts;
+		this.loadData();
+	}
+	reconcileNextResult(nextData) {
+		if (!this.currentData) {
+			this.currentData = nextData;
+			const fieldKeys = extractFieldKeys(nextData);
+			for (const fieldKey of fieldKeys) this.subscribedFields.set(fieldKey, this.opts.store.subscribeToField(fieldKey, this.onFieldChanged));
+		} else {
+			const { result, added, removed } = deepUpdateTree(this.currentData, nextData);
+			if (result === this.currentData) return;
+			for (const instance of removed) {
+				const fieldKeys = extractFieldKeys(instance);
+				for (const fieldKey of fieldKeys) {
+					const unsubscribe = this.subscribedFields.get(fieldKey);
+					if (!unsubscribe) throw new Error(`Unsubscribe not found for field ${fieldKey}`);
+					unsubscribe();
+					this.subscribedFields.delete(fieldKey);
+				}
+			}
+			for (const instance of added) {
+				const fieldKeys = extractFieldKeys(instance);
+				for (const fieldKey of fieldKeys) this.subscribedFields.set(fieldKey, this.opts.store.subscribeToField(fieldKey, this.onFieldChanged));
+			}
+			this.currentData = result;
+			this.notify();
 		}
+		return this.currentData;
+	}
+	onFieldChanged = () => {
+		this.loadData();
 	};
-	const notify = () => {
-		loadData();
+	notify = () => {
+		this.queryListeners.forEach((listener) => listener());
 	};
-	let userQueryResult;
-	const loadData = () => {
-		const storeResult = store.loadData(model, ids, q);
-		if (storeResult.state === "pending") userQueryResult = {
+	loadData() {
+		const { store, model, ids, q } = this.opts;
+		const storeResult = store.loadData(model, ids, q, true);
+		if (storeResult.state === "pending") this.userQueryResult = {
 			state: "pending",
-			promise: storeResult.promise.then((storePayload) => {
-				reconcileNextResult(storePayload);
-				return storePayload.value;
+			promise: storeResult.promise.then((value) => {
+				const result = this.reconcileNextResult(value);
+				this.userQueryResult = {
+					state: "resolved",
+					value: result
+				};
+				return result;
 			})
 		};
-		else {
-			const storePayload = storeResult.payload;
-			reconcileNextResult(storePayload);
-			userQueryResult = {
-				state: "resolved",
-				value: storePayload.value
-			};
-		}
-	};
-	loadData();
-	const subscribe = (listener) => {
-		queryListeners.add(listener);
+		else this.userQueryResult = {
+			state: "resolved",
+			value: this.reconcileNextResult(storeResult.payload)
+		};
+	}
+	subscribe = (listener) => {
+		this.queryListeners.add(listener);
 		return () => {
-			queryListeners.delete(listener);
-			if (queryListeners.size === 0) onDispose();
-			updateDataListener({
-				added: [],
-				removed: trackedData.partKeys
-			}, notify);
+			this.queryListeners.delete(listener);
+			if (this.queryListeners.size === 0) {
+				this.opts.onDispose();
+				for (const unsub of this.subscribedFields.values()) unsub();
+				this.subscribedFields.clear();
+			}
 		};
 	};
-	const get = () => {
-		return userQueryResult;
-	};
-	return {
-		subscribe,
-		get
+	getSnapshot = () => {
+		return this.userQueryResult;
 	};
 };
 var UserQueryManager = class {
 	queryCache = new Map();
-	activeParts = new Map();
 	constructor(store) {
 		this.store = store;
 	}
@@ -91,41 +218,19 @@ var UserQueryManager = class {
 		});
 		let query = this.queryCache.get(cacheKey);
 		if (!query) {
-			query = createStoreQuery({
+			query = new UserQuery({
 				model,
 				ids,
 				q,
 				store: this.store,
 				onDispose: () => {
 					this.queryCache.delete(cacheKey);
-				},
-				updateDataListener: ({ added, removed }, notify) => {
-					added.forEach((partKey) => {
-						let partListeners = this.activeParts.get(partKey);
-						if (!partListeners) {
-							partListeners = new Set();
-							this.activeParts.set(partKey, partListeners);
-						}
-						partListeners.add(notify);
-					});
-					removed.forEach((partKey) => {
-						const partListeners = this.activeParts.get(partKey);
-						if (partListeners) {
-							partListeners.delete(notify);
-							if (partListeners.size === 0) this.activeParts.delete(partKey);
-						}
-					});
 				}
 			});
 			this.queryCache.set(cacheKey, query);
 		}
 		return query;
 	}
-	onInvalidation(partKeys) {
-		const notifyFns = new Set();
-		for (const partKey of partKeys) this.activeParts.get(partKey)?.forEach((fn) => notifyFns.add(fn));
-		notifyFns.forEach((fn) => fn());
-	}
 };
 
 //#endregion
@@ -134,7 +239,7 @@ const createHooks = (store) => {
 	const queryManager = new UserQueryManager(store);
 	const useQueryManager = (model, ids, q) => {
 		const queryObj = queryManager.getQuery(model, ids, q);
-		const val = useSyncExternalStore(queryObj.subscribe, queryObj.get);
+		const val = useSyncExternalStore(queryObj.subscribe, queryObj.getSnapshot);
 		if (val.state === "pending") return use(val.promise);
 		return val.value;
 	};

package/dist/_exploration/loader.d.ts

@@ -1,5 +1,5 @@
-import "../query-type-Dx5ZCv5N.js";
-import { BaseLoader, BaseRequester, MissingDataRequest, OnLoadedFn } from "../loader-types-Dp0CSVTf.js";
+import "../query-type-BqQ9oX_U.js";
+import { BaseLoader, BaseRequester, MissingDataRequest, OnLoadedFn } from "../loader-types-fd5tV0FD.js";
 
 //#region src/_exploration/loader.d.ts
 type DataRequestWithKey = {

package/dist/_exploration/loader.js

@@ -1,11 +1,16 @@
-import { queryToKey } from "../query-helpers-DsMMOtSO.js";
+import { serializeModel } from "../query-helpers-iX1fiqLv.js";
 
 //#region src/_exploration/loader.ts
 const notYetLoaded = () => {
 	throw new Error("Not yet loaded");
 };
 const augmentRequest = (req) => {
-	const key = `${req.model}:${req.id}:${req.type === "field" ? req.field : `${req.relKey}:${queryToKey(req.query)}`}`;
+	const getFieldKey = () => {
+		if (req.type === "field") return req.field;
+		else if (req.contents.asField) return req.relKey;
+		else return JSON.stringify(serializeModel(req.contents));
+	};
+	const key = `${req.model}:${req.id}:${getFieldKey()}`;
 	return {
 		key,
 		request: req

package/dist/_exploration/store.d.ts

@@ -1,5 +1,5 @@
-import "../query-type-Dx5ZCv5N.js";
-import "../index-DUBsesYl.js";
-import "../loader-types-Dp0CSVTf.js";
-import { Store } from "../store-B6JWZnAO.js";
+import "../query-type-BqQ9oX_U.js";
+import "../index-k-KPWV9R.js";
+import "../loader-types-fd5tV0FD.js";
+import { Store } from "../store-BvEJzUVp.js";
 export { Store };

package/dist/_exploration/store.js

@@ -1,80 +1,46 @@
-import { getRelKey, makeRelQuerySerializable, modelMap } from "../query-helpers-DsMMOtSO.js";
+import { getRelKey, makeRelQuerySerializable, modelMap } from "../query-helpers-iX1fiqLv.js";
+import { ImmediateCache } from "../immediate-cache-DiH8tpJM.js";
 
-//#region src/_exploration/immediate-cache.ts
-var ImmediateCache = class {
-	cache = new Map();
-	partKeyToFields = new Map();
-	getInstanceKey(model, id) {
-		return `${model}:${id}`;
-	}
-	get(model, key, field) {
-		return this.cache.get(this.getInstanceKey(model, key))?.get(field);
-	}
-	set(model, key, partialInstance, meta) {
-		const instanceKey = this.getInstanceKey(model, key);
-		let entry = this.cache.get(instanceKey);
-		if (!entry) {
-			entry = new Map();
-			this.cache.set(instanceKey, entry);
-		}
-		for (const field in partialInstance) {
-			const f = partialInstance[field];
-			const fieldEntry = {
-				value: f.value,
-				partKeys: f.partKeys,
-				meta
-			};
-			entry.set(field, fieldEntry);
-			for (const partKey of f.partKeys) {
-				const maybeFields = this.partKeyToFields.get(partKey);
-				if (!maybeFields) this.partKeyToFields.set(partKey, [fieldEntry]);
-				else maybeFields.push(fieldEntry);
-			}
-		}
-	}
-	setMetaByPartKeys(partKeys, meta) {
-		for (const partKey of partKeys) {
-			const fields = this.partKeyToFields.get(partKey);
-			if (!fields) continue;
-			for (const field of fields) field.meta = meta;
-		}
-	}
-};
-
-//#endregion
 //#region src/_exploration/store.ts
+const getQueryDep = (_q) => {
+	return { keys: [] };
+};
 const calcPartKeys = (model, id, field) => {
 	return [`${model}:${id}:${field}`];
 };
 var Store = class {
 	cache = new ImmediateCache();
 	modelMap = modelMap;
+	requestedRelationKeys = new Map();
 	constructor(loader) {
 		this.loader = loader;
 		loader.setOnLoaded((model, key, res) => this.onLoaded(model, key, res));
 	}
+	subscribeToField(fieldKey, notifyFn) {
+		return this.cache.subscribe(fieldKey, notifyFn);
+	}
+	invalidate(partKeyPatterns) {
+		const subscribedFieldRequests = this.cache.markDirty(partKeyPatterns);
+		if (subscribedFieldRequests.length === 0) return;
+		this.loader.loadBatch(subscribedFieldRequests);
+	}
 	loadData(model, ids, q, acceptDirty, iteration = 0) {
 		const desc = this.modelMap[model];
 		if (!desc) throw new Error(`Model ${model} not found`);
 		const missingRequests = [];
 		const resultObj = {};
-		const allPartKeys = [];
 		let allPresent = true;
 		for (const id of ids) {
 			const result = this.checkQueryRecursive(desc, model, id, q, missingRequests, acceptDirty);
 			if (!result.allPresent) allPresent = false;
 			resultObj[id] = result.data;
-			allPartKeys.push(...result.partKeys);
 		}
 		if (!allPresent && iteration > 5) throw new Error(`Can't seem to load ${JSON.stringify(missingRequests)} after 5 iterations`);
 		if (allPresent) {
 			if (missingRequests.length > 0) this.loader.loadBatch(missingRequests);
 			return {
 				state: "resolved",
-				payload: {
-					value: resultObj,
-					partKeys: allPartKeys
-				}
+				payload: resultObj
 			};
 		}
 		const promise = this.loader.loadBatch(missingRequests).then(() => {
@@ -87,11 +53,17 @@ var Store = class {
 		};
 	}
 	onLoaded(model, key, partialInstance) {
-		const withPartKeys = Object.fromEntries(Object.entries(partialInstance).map(([field, value]) => [field, {
-			value,
-			partKeys: calcPartKeys(model, key, field)
-		}]));
-		this.cache.set(model, key, withPartKeys, { state: "fresh" });
+		const withPartKeys = Object.fromEntries(Object.entries(partialInstance).map(([field, value]) => {
+			const relDeps = this.requestedRelationKeys.get(`${model}:${field}`);
+			console.log(`${model}:${field}`, relDeps);
+			return [field, {
+				value,
+				partKeys: relDeps ? [...relDeps.keys, ...calcPartKeys(model, key, field)] : calcPartKeys(model, key, field),
+				type: relDeps ? "relation" : "field"
+			}];
+		}));
+		const fieldSubs = this.cache.set(model, key, withPartKeys, { state: "fresh" });
+		new Set(fieldSubs).forEach((fn) => fn());
 	}
 	/**
 	* Recursively check if query data is in cache
@@ -102,7 +74,6 @@ var Store = class {
 			"~model": model,
 			"~key": id
 		};
-		const partKeys = [];
 		let allPresent = true;
 		if (query.fields) for (const field of query.fields) {
 			const cachedValue = this.cache.get(model, id, field);
@@ -114,10 +85,8 @@ var Store = class {
 				field
 			});
 			const acceptsData = cachedValue && (cachedValue.meta.state === "fresh" || acceptDirty);
-			if (acceptsData) {
-				data[field] = cachedValue.value;
-				partKeys.push(...cachedValue.partKeys);
-			} else allPresent = false;
+			if (acceptsData) data[field] = cachedValue.value;
+			else allPresent = false;
 		}
 		if (query.relations) for (const [relationName, rawRelationQuery] of Object.entries(query.relations)) {
 			if (!rawRelationQuery) continue;
@@ -126,33 +95,33 @@ var Store = class {
 			const relationQueryList = Array.isArray(rawRelationQuery) ? rawRelationQuery : [rawRelationQuery];
 			for (const relQuery of relationQueryList) {
 				const relKey = getRelKey(relQuery, relationName);
+				this.requestedRelationKeys.set(`${model}:${relKey}`, getQueryDep(relQuery));
 				const cachedValue = this.cache.get(model, id, relKey);
 				const needsRequest = !cachedValue || cachedValue.meta.state === "dirty";
-				if (needsRequest) missingRequests.push({
-					type: "relation",
-					model,
-					id,
-					relKey,
-					query: makeRelQuerySerializable(relQuery)
-				});
+				if (needsRequest) {
+					const contents = makeRelQuerySerializable(relQuery);
+					missingRequests.push({
+						type: "relation",
+						model,
+						id,
+						relKey,
+						contents
+					});
+				}
 				const acceptsData = cachedValue && (cachedValue.meta.state === "fresh" || acceptDirty);
 				if (acceptsData) {
 					if (!relatedModelDesc) throw new Error(`Model ${relatedModel} not found`);
 					const fieldName = relQuery.as || relationName;
-					if (relQuery.type === "count" || relQuery.type === "exists") {
-						data[fieldName] = cachedValue.value;
-						partKeys.push(...cachedValue.partKeys);
-					} else if (Array.isArray(cachedValue.value)) {
+					if (relQuery.type === "count" || relQuery.type === "exists") data[fieldName] = cachedValue.value;
+					else if (Array.isArray(cachedValue.value)) {
 						const relationResults = cachedValue.value.map((key) => this.checkQueryRecursive(relatedModelDesc, relatedModel, `${key}`, relQuery, missingRequests, acceptDirty));
 						data[`~${fieldName}`] = cachedValue.value.map((v) => `${v}`);
 						data[fieldName] = relationResults.map((result) => result.data);
-						partKeys.push(...relationResults.flatMap((result) => result.partKeys));
 						if (relationResults.some((result) => !result.allPresent)) allPresent = false;
 					} else {
 						const relationResult = this.checkQueryRecursive(relatedModelDesc, relatedModel, `${cachedValue.value}`, relQuery, missingRequests, acceptDirty);
 						data[`~${fieldName}`] = cachedValue.value != null ? `${cachedValue.value}` : null;
 						data[fieldName] = relationResult.data;
-						partKeys.push(...relationResult.partKeys);
 						if (!relationResult.allPresent) allPresent = false;
 					}
 				} else allPresent = false;
@@ -160,10 +129,44 @@ var Store = class {
 		}
 		return {
 			data,
-			partKeys,
 			allPresent
 		};
 	}
+	/**
+	* Execute a mutation with optimistic updates
+	*
+	* @example
+	* ```typescript
+	* await store.mutate(
+	*   () => api.updateCard('123', {title: 'New Title'}),
+	*   {
+	*     onMutate: (layer) => {
+	*       layer.setField('Card', '123', 'title', 'New Title');
+	*     },
+	*     onSuccess: () => {
+	*       // Optional: invalidate related queries
+	*       store.invalidate(['Card:123:title']);
+	*     }
+	*   }
+	* );
+	* ```
+	*/
+	mutate(mutationFn, options = {}) {
+		const promise = mutationFn();
+		if (options.onMutate) try {
+			this.cache.createOptimisticLayer(promise, options.onMutate);
+		} catch (error) {
+			console.error("Error in onMutate:", error);
+		}
+		promise.then((data) => {
+			options.onSuccess?.(data);
+			return data;
+		}).catch((error) => {
+			options.onError?.(error);
+			throw error;
+		});
+		return promise;
+	}
 };
 
 //#endregion

package/dist/{_root-D1Faf8cg.d.ts → _root-BW9uzB79.d.ts}

@@ -1,4 +1,4 @@
-import { ModelDesc, RelationEntry } from "./query-type-Dx5ZCv5N.js";
+import { ModelDesc, RelationEntry } from "./query-type-BqQ9oX_U.js";
 
 //#region src/models/_root.d.ts
 declare const _rootDesc: ModelDesc<"_root", {}, {