@codecks/fetch 0.1.0 → 0.1.2

package/dist/_exploration/api-requester.d.ts

@@ -0,0 +1,18 @@
+import "../query-type-MH8IxqbW.js";
+import { FetchOptions } from "../loader-utils-CjrkQskt.js";
+import { BaseRequester, MissingDataRequest } from "../loader-types-DJdGWL4B.js";
+
+//#region src/_exploration/api-requester.d.ts
+declare class ApiRequester implements BaseRequester {
+  private readonly fetchOptions;
+  private readonly limiter;
+  constructor(fetchOptions: FetchOptions, maxConcurrent?: number);
+  request(requests: MissingDataRequest[]): Promise<{
+    model: string;
+    key: string;
+    partialInstance: Record<string, unknown>;
+  }[]>;
+  private _doRequest;
+}
+//#endregion
+export { ApiRequester };

package/dist/_exploration/api-requester.js

@@ -0,0 +1,120 @@
+import { configuredFetch, ensureMapValue } from "../collection-utils-CYJaA1a9.js";
+import { serializeModel } from "../query-helpers-DsMMOtSO.js";
+
+//#region src/_exploration/utils/concurrency-limiter.ts
+var ConcurrencyLimiter = class {
+	maxConcurrent;
+	running = 0;
+	queue = [];
+	constructor(maxConcurrent) {
+		if (maxConcurrent < 1) throw new Error("maxConcurrent must be at least 1");
+		this.maxConcurrent = maxConcurrent;
+	}
+	/**
+	* Run an async operation with concurrency limiting.
+	* If the limit is reached, the operation will be queued until a slot becomes available.
+	*/
+	async run(fn) {
+		await this.acquireSlot();
+		try {
+			return await fn();
+		} finally {
+			this.releaseSlot();
+		}
+	}
+	async acquireSlot() {
+		if (this.running < this.maxConcurrent) {
+			this.running++;
+			return;
+		}
+		return new Promise((resolve) => {
+			this.queue.push(() => {
+				this.running++;
+				resolve();
+			});
+		});
+	}
+	releaseSlot() {
+		this.running--;
+		const next = this.queue.shift();
+		if (next) next();
+	}
+	getRunningCount() {
+		return this.running;
+	}
+	getQueuedCount() {
+		return this.queue.length;
+	}
+};
+
+//#endregion
+//#region src/_exploration/api-requester.ts
+const mergeRelations = (r1, r2) => {
+	const nextRels = { ...r1.relations };
+	for (const [relKey, relQuery] of Object.entries(r2.relations || {})) {
+		const exist = nextRels[relKey];
+		if (exist && !exist.asField && !relQuery.asField) nextRels[relKey] = mergeRelations(exist, relQuery);
+		else nextRels[relKey] = relQuery;
+	}
+	return {
+		...r1,
+		fields: [...r1.fields ?? [], ...r2.fields ?? []],
+		relations: nextRels
+	};
+};
+var ApiRequester = class {
+	fetchOptions;
+	limiter;
+	constructor(fetchOptions, maxConcurrent = 3) {
+		this.fetchOptions = fetchOptions;
+		this.limiter = new ConcurrencyLimiter(maxConcurrent);
+	}
+	async request(requests) {
+		return this.limiter.run(() => this._doRequest(requests));
+	}
+	async _doRequest(requests) {
+		if (requests.length === 0) return [];
+		const dataByModel = new Map();
+		for (const req of requests) {
+			const instancesById = ensureMapValue(dataByModel, req.model, () => new Map());
+			let instanceData = ensureMapValue(instancesById, req.id, () => ({
+				fields: new Set(),
+				relations: new Map()
+			}));
+			if (req.type === "field") instanceData.fields.add(req.field);
+			else if (req.type === "relation") {
+				const existing = instanceData.relations.get(req.relKey);
+				if (existing && !existing.asField && !req.query.asField) instanceData.relations.set(req.relKey, mergeRelations(existing, req.query));
+				else instanceData.relations.set(req.relKey, req.query);
+			}
+		}
+		const query = {};
+		for (const [model, instancesById] of dataByModel) for (const [id, instanceData] of instancesById) {
+			const queryKey = model === "_root" ? "_root" : `${model}(${id})`;
+			query[queryKey] = serializeModel({
+				fields: [...instanceData.fields],
+				relations: Object.fromEntries(instanceData.relations)
+			});
+		}
+		const result = await configuredFetch(this.fetchOptions, "", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ query })
+		});
+		const results = [];
+		for (const [modelName, instances] of Object.entries(result)) if (modelName === "_root") results.push({
+			model: "_root",
+			key: "",
+			partialInstance: instances
+		});
+		else for (const [id, data] of Object.entries(instances)) results.push({
+			model: modelName,
+			key: id,
+			partialInstance: data
+		});
+		return results;
+	}
+};
+
+//#endregion
+export { ApiRequester };

package/dist/_exploration/create-hooks.d.ts

@@ -0,0 +1,12 @@
+import { AnyDesc, InferModelQuery, InferRelQuery, ModelQuery, RelQuery } from "../query-type-MH8IxqbW.js";
+import "../loader-types-DJdGWL4B.js";
+import { _rootDesc$1 as _rootDesc } from "../_root-BG9fhc-C.js";
+import { Store } from "../store-mAj3G67A.js";
+
+//#region src/_exploration/create-hooks.d.ts
+declare const createHooks: (store: Store) => {
+  useFetch: <K extends string, Id extends string, const Q extends ModelQuery<AnyDesc, Record<string, AnyDesc>>>(model: K, id: Id, q: Q) => InferModelQuery<AnyDesc, Q, Record<string, AnyDesc>>;
+  useFetchFromRoot: <const Q extends RelQuery<typeof _rootDesc, Record<string, AnyDesc>>>(q: Q) => InferRelQuery<typeof _rootDesc, Q, Record<string, AnyDesc>>;
+};
+//#endregion
+export { createHooks };

package/dist/_exploration/create-hooks.js

@@ -0,0 +1,137 @@
+import { queryToKey } from "../query-helpers-DsMMOtSO.js";
+import { use, useSyncExternalStore } from "react";
+
+//#region src/_exploration/user-query-manager.ts
+const diffResults = (prevResult, prevParts, nextResult) => {
+	const nextParts = [];
+	return {
+		added: nextParts,
+		removed: prevParts,
+		reconciledResult: {
+			parts: nextParts,
+			data: nextResult
+		}
+	};
+};
+const createStoreQuery = (opts) => {
+	const { onDispose, updateDataListener, store, q, ids, model } = opts;
+	const queryListeners = new Set();
+	let lastData = {
+		parts: [],
+		data: null
+	};
+	const reconcileNextResult = (nextData) => {
+		const { added, removed, reconciledResult } = diffResults(lastData.data, lastData.parts, nextData);
+		if (!added.length && !removed.length) {
+			lastData = reconciledResult;
+			updateDataListener({
+				added,
+				removed
+			}, notify);
+			queryListeners.forEach((listener) => listener());
+		}
+	};
+	const notify = () => {
+		loadData();
+	};
+	const loadData = () => {
+		const res = store.loadData(model, ids, q);
+		if (res.state === "pending") res.promise.then(reconcileNextResult);
+		else reconcileNextResult(res.value);
+		return res;
+	};
+	let data = loadData();
+	const subscribe = (listener) => {
+		queryListeners.add(listener);
+		return () => {
+			queryListeners.delete(listener);
+			if (queryListeners.size === 0) onDispose();
+			updateDataListener({
+				added: [],
+				removed: lastData.parts
+			}, notify);
+		};
+	};
+	const get = () => {
+		return data;
+	};
+	return {
+		subscribe,
+		get
+	};
+};
+var UserQueryManager = class {
+	queryCache = new Map();
+	activeParts = new Map();
+	constructor(store) {
+		this.store = store;
+	}
+	getQuery(model, ids, q) {
+		const cacheKey = JSON.stringify({
+			model,
+			ids,
+			q: queryToKey(q)
+		});
+		let query = this.queryCache.get(cacheKey);
+		if (!query) {
+			query = createStoreQuery({
+				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
+//#region src/_exploration/create-hooks.ts
+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);
+		if (val.state === "pending") return use(val.promise);
+		return val.value;
+	};
+	const useFetch = (model, id, q) => {
+		return useQueryManager(model, [id], q);
+	};
+	const useFetchFromRoot = (q) => {
+		return useQueryManager("_root", [""], { relations: q });
+	};
+	return {
+		useFetch,
+		useFetchFromRoot
+	};
+};
+
+//#endregion
+export { createHooks };

package/dist/_exploration/loader.d.ts

@@ -0,0 +1,26 @@
+import "../query-type-MH8IxqbW.js";
+import { BaseLoader, BaseRequester, MissingDataRequest, OnLoadedFn } from "../loader-types-DJdGWL4B.js";
+
+//#region src/_exploration/loader.d.ts
+type DataRequestWithKey = {
+  key: string;
+  request: MissingDataRequest;
+};
+declare class BatchedLoader implements BaseLoader {
+  private _currentBatch;
+  onLoaded: OnLoadedFn;
+  readonly requester: BaseRequester;
+  private ongoingKeysToBatches;
+  batchTimeoutMs: number;
+  constructor(opts: {
+    batchTimeoutMs: number;
+    requester: BaseRequester;
+  });
+  setOnLoaded(onLoaded: OnLoadedFn): void;
+  private getCurrentBatch;
+  private getOngoingBatches;
+  loadBatch(rawRequests: MissingDataRequest[]): Promise<void[]>;
+  onBatchCompleted(requests: DataRequestWithKey[]): void;
+}
+//#endregion
+export { BatchedLoader };

package/dist/_exploration/loader.js

@@ -0,0 +1,89 @@
+import { queryToKey } from "../query-helpers-DsMMOtSO.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)}`}`;
+	return {
+		key,
+		request: req
+	};
+};
+var BatchedLoader = class {
+	_currentBatch = null;
+	onLoaded = notYetLoaded;
+	requester;
+	ongoingKeysToBatches = new Map();
+	batchTimeoutMs;
+	constructor(opts) {
+		this.batchTimeoutMs = opts.batchTimeoutMs;
+		this.requester = opts.requester;
+	}
+	setOnLoaded(onLoaded) {
+		this.onLoaded = onLoaded;
+	}
+	getCurrentBatch() {
+		if (!this._currentBatch) this._currentBatch = new Batch(this, () => this._currentBatch = null);
+		return this._currentBatch;
+	}
+	getOngoingBatches(requests) {
+		const batches = new Set();
+		const remainingRequests = [];
+		requests.forEach((req) => {
+			const batch = this.ongoingKeysToBatches.get(req.key);
+			if (batch) batches.add(batch);
+			else remainingRequests.push(req);
+		});
+		return {
+			promises: [...batches].map((batch) => batch.promise),
+			remainingRequests
+		};
+	}
+	async loadBatch(rawRequests) {
+		const requests = rawRequests.map(augmentRequest);
+		const { promises, remainingRequests } = this.getOngoingBatches(requests);
+		if (remainingRequests.length === 0) return Promise.all(promises);
+		const batch = this.getCurrentBatch();
+		batch.addRequests(remainingRequests);
+		remainingRequests.forEach((req) => this.ongoingKeysToBatches.set(req.key, batch));
+		promises.push(batch.promise);
+		return Promise.all(promises);
+	}
+	onBatchCompleted(requests) {
+		requests.forEach((req) => this.ongoingKeysToBatches.delete(req.key));
+	}
+};
+var Batch = class {
+	requests = [];
+	onResolve = notYetLoaded;
+	onReject = notYetLoaded;
+	timeoutId = null;
+	promise;
+	constructor(loader, onStarted) {
+		this.loader = loader;
+		this.onStarted = onStarted;
+		this.promise = new Promise((resolve, reject) => {
+			this.onResolve = resolve;
+			this.onReject = reject;
+		});
+	}
+	addRequests(requests) {
+		this.requests.push(...requests);
+		if (!this.timeoutId) this.timeoutId = setTimeout(() => {
+			this.onStarted();
+			this.loader.requester.request(this.requests.map((r) => r.request)).then((results) => {
+				results.forEach(({ model, key, partialInstance }) => {
+					this.loader.onLoaded(model, key, partialInstance);
+				});
+				this.onResolve();
+			}, (err) => {
+				this.onReject(err);
+			}).finally(() => this.loader.onBatchCompleted(this.requests));
+		}, this.loader.batchTimeoutMs);
+	}
+};
+
+//#endregion
+export { BatchedLoader };

package/dist/_exploration/store.d.ts

@@ -0,0 +1,4 @@
+import "../query-type-MH8IxqbW.js";
+import "../loader-types-DJdGWL4B.js";
+import { Store } from "../store-mAj3G67A.js";
+export { Store };

package/dist/_exploration/store.js

@@ -0,0 +1,161 @@
+import { getRelKey, makeRelQuerySerializable, modelMap } from "../query-helpers-DsMMOtSO.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 calcPartKeys = (model, id, field) => {
+	return [`${model}:${id}:${field}`];
+};
+var Store = class {
+	cache = new ImmediateCache();
+	modelMap = modelMap;
+	constructor(loader) {
+		this.loader = loader;
+		loader.setOnLoaded((model, key, res) => this.onLoaded(model, key, res));
+	}
+	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",
+				value: {
+					value: resultObj,
+					partKeys: allPartKeys
+				}
+			};
+		}
+		const promise = this.loader.loadBatch(missingRequests).then(() => {
+			return this.loadData(model, ids, q, acceptDirty, iteration + 1);
+		});
+		return {
+			state: "pending",
+			promise
+		};
+	}
+	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" });
+	}
+	/**
+	* Recursively check if query data is in cache
+	* Accumulates missing requests in the missingRequests array
+	*/
+	checkQueryRecursive(desc, model, id, query, missingRequests, acceptDirty) {
+		const data = {};
+		const partKeys = [];
+		let allPresent = true;
+		if (query.fields) for (const field of query.fields) {
+			const cachedValue = this.cache.get(model, id, field);
+			const needsRequest = !cachedValue || cachedValue.meta.state === "dirty";
+			if (needsRequest) missingRequests.push({
+				type: "field",
+				model,
+				id,
+				field
+			});
+			const acceptsData = cachedValue && (cachedValue.meta.state === "fresh" || acceptDirty);
+			if (acceptsData) {
+				data[field] = cachedValue.value;
+				partKeys.push(...cachedValue.partKeys);
+			} else allPresent = false;
+		}
+		if (query.relations) for (const [relationName, rawRelationQuery] of Object.entries(query.relations)) {
+			if (!rawRelationQuery) continue;
+			const relatedModel = desc.relations[relationName].relName;
+			const relatedModelDesc = this.modelMap[relatedModel];
+			const relationQueryList = Array.isArray(rawRelationQuery) ? rawRelationQuery : [rawRelationQuery];
+			for (const relQuery of relationQueryList) {
+				const relKey = getRelKey(relQuery, relationName);
+				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)
+				});
+				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 (Array.isArray(cachedValue.value)) {
+						const relationResults = cachedValue.value.map((key) => this.checkQueryRecursive(relatedModelDesc, relatedModel, key, relQuery, missingRequests, acceptDirty));
+						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] = relationResult.data;
+						partKeys.push(...relationResult.partKeys);
+						if (!relationResult.allPresent) allPresent = false;
+					}
+				} else allPresent = false;
+			}
+		}
+		return {
+			data,
+			partKeys,
+			allPresent
+		};
+	}
+};
+
+//#endregion
+export { Store };

package/dist/_root-BG9fhc-C.d.ts

@@ -0,0 +1,34 @@
+import { ModelDesc, RelationEntry } from "./query-type-MH8IxqbW.js";
+
+//#region src/models/_root.d.ts
+declare const _rootDesc: ModelDesc<"_root", {}, {
+  releases: RelationEntry<"release", {
+    readonly type: "hasMany";
+  }>;
+  accountOnboardingSteps: RelationEntry<"accountOnboardingStep", {
+    readonly type: "hasMany";
+  }>;
+  apps: RelationEntry<"app", {
+    readonly type: "hasMany";
+  }>;
+  account: RelationEntry<"account", {
+    readonly type: "hasOne";
+  }>;
+  loggedInUser: RelationEntry<"user", {
+    readonly type: "hasOne";
+  }>;
+  cardsStatusHistory: RelationEntry<"cardsStatusHistory", {
+    readonly type: "hasMany";
+  }>;
+  cardsEffortHistory: RelationEntry<"cardsEffortHistory", {
+    readonly type: "hasMany";
+  }>;
+  cardsFinishedHistory: RelationEntry<"cardsFinishedHistory", {
+    readonly type: "hasMany";
+  }>;
+  cardsTimeToFinished: RelationEntry<"cardsTimeToFinished", {
+    readonly type: "hasMany";
+  }>;
+}, []>;
+//#endregion
+export { _rootDesc as _rootDesc$1 };

package/dist/collection-utils-CYJaA1a9.js

@@ -0,0 +1,32 @@
+//#region src/loaders/loader-utils.ts
+const configuredFetch = async (opts, url, init = {}) => {
+	const fetchImpl = opts.fetch || globalThis.fetch;
+	const headers = new Headers(init.headers);
+	if (opts.accessToken) headers.set("X-Auth-Token", opts.accessToken);
+	if (opts.subdomain) headers.set("X-Account", opts.subdomain);
+	if (opts.headers) Object.entries(opts.headers).forEach(([key, value]) => {
+		headers.set(key, value);
+	});
+	const fullUrl = opts.baseUrl ? `${opts.baseUrl}${url}` : url;
+	return fetchImpl(fullUrl, {
+		...init,
+		headers
+	}).then(async (r) => {
+		const content = await r.json();
+		if (r.status !== 200) throw new Error(`[${r.status}] ${JSON.stringify(content)}`);
+		return content;
+	});
+};
+
+//#endregion
+//#region src/collection-utils.ts
+const ensureMapValue = (map, key, fallback) => {
+	const exist = map.get(key);
+	if (exist) return exist;
+	const newValue = fallback();
+	map.set(key, newValue);
+	return newValue;
+};
+
+//#endregion
+export { configuredFetch, ensureMapValue };