@codecks/fetch 0.0.3 → 0.1.0

package/README.md

@@ -3,9 +3,9 @@
 ## Usage
 
 ```ts
-import {buildFetchers} from "@codecks/fetch";
+import {buildFetchersWithSimpleLoader} from "@codecks/fetch";
 
-const {fetchFromRoot, fetchInstance} = buildFetchers({
+const {fetchFromRoot, fetchInstance} = buildFetchersWithSimpleLoader({
   baseUrl: "https://api.codecks.io/",
   subdomain: "my-org",
 });

package/dist/index.d.ts

@@ -2716,7 +2716,7 @@ declare const modelMap: {
 };
 //#endregion
 //#region src/has-many-filter-type.d.ts
-type ModelMap$2 = Record<string, AnyDesc>;
+type ModelMap$3 = Record<string, AnyDesc>;
 type OneOrArray<T> = T | T[];
 type NormalAndNegatedKeys<T> = T & { [K in keyof T & string as `!${K}`]: T[K] };
 type OrderString<T extends string> = `${T}` | `-${T}`;
@@ -2745,20 +2745,20 @@ type Operators<T> = {
   value: El[];
 } : never);
 type FieldQuery<T extends AnyDesc> = { [K in keyof T["fields"]]?: null | OneOrArray<InferFieldType<T["fields"][K]>> | Operators<InferFieldType<T["fields"][K]>> };
-type RelationQuery<T extends AnyDesc, TMap extends ModelMap$2> = NormalAndNegatedKeys<{ [K in keyof T["relations"]]?: SimpleFilter<TMap[T["relations"][K]["relName"]], TMap> }>;
-type SimpleFilter<T extends AnyDesc, TMap extends ModelMap$2> = FieldQuery<T> | RelationQuery<T, TMap>;
-type Filter<T extends AnyDesc, TMap extends ModelMap$2> = SimpleFilter<T, TMap> & {
+type RelationQuery<T extends AnyDesc, TMap extends ModelMap$3> = NormalAndNegatedKeys<{ [K in keyof T["relations"]]?: SimpleFilter<TMap[T["relations"][K]["relName"]], TMap> }>;
+type SimpleFilter<T extends AnyDesc, TMap extends ModelMap$3> = FieldQuery<T> | RelationQuery<T, TMap>;
+type Filter<T extends AnyDesc, TMap extends ModelMap$3> = SimpleFilter<T, TMap> & {
   $and?: Filter<T, TMap>[];
   $or?: Filter<T, TMap>[];
 };
 //#endregion
 //#region src/query-type.d.ts
-type ModelMap$1 = Record<string, AnyDesc>;
-interface ModelQuery<T extends AnyDesc, TMap extends ModelMap$1> {
-  fields?: (keyof T["fields"])[];
+type ModelMap$2 = Record<string, AnyDesc>;
+interface ModelQuery<T extends AnyDesc, TMap extends ModelMap$2> {
+  fields?: (keyof T["fields"] & string)[];
   relations?: RelQuery<T, TMap>;
 }
-interface SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap$1> extends ModelQuery<T, TMap> {
+interface SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap$2> extends ModelQuery<T, TMap> {
   type?: "query";
   orderBy?: Order<T>;
   limit?: number;
@@ -2766,20 +2766,20 @@ interface SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap$1> extends
   filter?: Filter<T, TMap>;
   as?: string;
 }
-interface CountOrExistQuery<T extends AnyDesc, TMap extends ModelMap$1> {
+interface CountOrExistQuery<T extends AnyDesc, TMap extends ModelMap$2> {
   type: "count" | "exists";
   filter?: Filter<T, TMap>;
   as: string;
   fields?: never;
   relations?: never;
 }
-interface FirstOrLastQuery<T extends AnyDesc, TMap extends ModelMap$1> extends ModelQuery<T, TMap> {
+interface FirstOrLastQuery<T extends AnyDesc, TMap extends ModelMap$2> extends ModelQuery<T, TMap> {
   type: "first";
   filter?: Filter<T, TMap>;
   as: string;
   orderBy: Order<T>;
 }
-type HasManyQuery<T extends AnyDesc, TMap extends ModelMap$1> = SimpleHasManyQuery<T, TMap> | CountOrExistQuery<T, TMap> | FirstOrLastQuery<T, TMap>;
+type HasManyQuery<T extends AnyDesc, TMap extends ModelMap$2> = SimpleHasManyQuery<T, TMap> | CountOrExistQuery<T, TMap> | FirstOrLastQuery<T, TMap>;
 type AbstractHasManyQuery = (ModelQuery<any, any> & {
   type?: "query" | "first";
   as?: string;
@@ -2787,57 +2787,57 @@ type AbstractHasManyQuery = (ModelQuery<any, any> & {
   type: "count" | "exists";
   as: string;
 };
-type HasManyQueryWithAs<T extends AnyDesc, TMap extends ModelMap$1> = HasManyQuery<T, TMap> & {
+type HasManyQueryWithAs<T extends AnyDesc, TMap extends ModelMap$2> = HasManyQuery<T, TMap> & {
   as: string;
 };
-type HasManyRelQueryEntry<T extends AnyDesc, TMap extends ModelMap$1, K extends keyof ExtractHasMany<T, TMap>> = HasManyQuery<TMap[T["relations"][K]["relName"]], TMap> | HasManyQueryWithAs<TMap[T["relations"][K]["relName"]], TMap>[];
-type RelQueryEntry<T extends AnyDesc, TMap extends ModelMap$1, K extends keyof T["relations"]> = K extends keyof ExtractHasMany<T, TMap> ? HasManyRelQueryEntry<T, TMap, K> : ModelQuery<TMap[T["relations"][K]["relName"]], TMap>;
+type HasManyRelQueryEntry<T extends AnyDesc, TMap extends ModelMap$2, K extends keyof ExtractHasMany<T, TMap>> = HasManyQuery<TMap[T["relations"][K]["relName"]], TMap> | HasManyQueryWithAs<TMap[T["relations"][K]["relName"]], TMap>[];
+type RelQueryEntry<T extends AnyDesc, TMap extends ModelMap$2, K extends keyof T["relations"]> = K extends keyof ExtractHasMany<T, TMap> ? HasManyRelQueryEntry<T, TMap, K> : ModelQuery<TMap[T["relations"][K]["relName"]], TMap>;
 /**
  * examples for account:
  * {disabledBy: {fields: []}} // belongst
  * {cards: {fields: []}}
  * {cards: [{as: "myCards", fields: []}]}
  */
-type RelQuery<T extends AnyDesc, TMap extends ModelMap$1> = { [K in keyof T["relations"]]?: RelQueryEntry<T, TMap, K> };
+type RelQuery<T extends AnyDesc, TMap extends ModelMap$2> = { [K in keyof T["relations"]]?: RelQueryEntry<T, TMap, K> };
 type EnsureModelQuery<T> = T extends ModelQuery<any, any> ? T : never;
 type EnsureHasManyQuery<T> = T extends AbstractHasManyQuery ? T : never;
-type EnrichBelongsTo<M extends AnyDesc, TMap extends ModelMap$1> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<any, infer Opts> ? Opts extends BelongsToOpts<infer TFk> ? {
+type EnrichBelongsTo<M extends AnyDesc, TMap extends ModelMap$2> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<any, infer Opts> ? Opts extends BelongsToOpts<infer TFk> ? {
   model: TMap[M["relations"][K]["relName"]];
   fk: TFk;
   field: M["fields"][TFk] extends TypedField<"belongsTo", infer FieldType, infer FieldOpts> ? {
     type: FieldType;
   } & FieldOpts : never;
 } : never : never }>;
-type ExtractHasMany<M extends AnyDesc, TMap extends ModelMap$1> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
+type ExtractHasMany<M extends AnyDesc, TMap extends ModelMap$2> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
   type: "hasMany";
 }> ? {
   model: TMap[RelName];
 } : never }>;
-type ExtractHasOne<M extends AnyDesc, TMap extends ModelMap$1> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
+type ExtractHasOne<M extends AnyDesc, TMap extends ModelMap$2> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
   type: "hasOne";
 }> ? {
   model: TMap[RelName];
 } : never }>;
-type InferModelQuery<M extends AnyDesc, Q extends ModelQuery<M, TMap>, TMap extends ModelMap$1> = (Q["fields"] extends (keyof M["fields"])[] ? { [K in Q["fields"][number]]: InferFieldType<M["fields"][K]> } : {}) & (Q["relations"] extends RelQuery<M, TMap> ? InferRelQuery<M, Q["relations"], TMap> : {}) & { [K in M["keys"][number] & string]: InferFieldType<M["fields"][K]> } & {
+type InferModelQuery<M extends AnyDesc, Q extends ModelQuery<M, TMap>, TMap extends ModelMap$2> = (Q["fields"] extends (keyof M["fields"])[] ? { [K in Q["fields"][number]]: InferFieldType<M["fields"][K]> } : {}) & (Q["relations"] extends RelQuery<M, TMap> ? InferRelQuery<M, Q["relations"], TMap> : {}) & { [K in M["keys"][number] & string]: InferFieldType<M["fields"][K]> } & {
   "~model": M["name"];
   "~key": string;
 };
 type IsOptional<T, Test> = Test extends true ? T | null : T;
 type EmptyObjIfNever<T> = [T] extends [never] ? {} : T;
-type ExtractRelQueryArray<M extends AnyDesc, TMap extends ModelMap$1, Q extends RelQuery<M, TMap>> = { [K in keyof Q]: K extends keyof ExtractHasMany<M, TMap> ? Q[K] extends HasManyQueryWithAs<any, any>[] ? { [Item in Q[K][number] as Item["as"]]: InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, Item> } : never : never }[keyof Q];
-type InferHasMany<M extends AnyDesc, TMap extends ModelMap$1, QM extends HasManyQuery<M, TMap>> = QM extends {
+type ExtractRelQueryArray<M extends AnyDesc, TMap extends ModelMap$2, Q extends RelQuery<M, TMap>> = { [K in keyof Q]: K extends keyof ExtractHasMany<M, TMap> ? Q[K] extends HasManyQueryWithAs<any, any>[] ? { [Item in Q[K][number] as Item["as"]]: InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, Item> } : never : never }[keyof Q];
+type InferHasMany<M extends AnyDesc, TMap extends ModelMap$2, QM extends HasManyQuery<M, TMap>> = QM extends {
   type: "count";
 } ? number : QM extends {
   type: "exist";
 } ? boolean : QM extends {
   type: "first";
 } ? InferModelQuery<M, EnsureModelQuery<QM>, TMap> | null : InferModelQuery<M, EnsureModelQuery<QM>, TMap>[];
-type InferRelEntry<M extends AnyDesc, TMap extends ModelMap$1, Q extends RelQuery<any, any>, K extends keyof Q> = K extends keyof EnrichBelongsTo<M, TMap> ? IsOptional<InferModelQuery<EnrichBelongsTo<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap>, EnrichBelongsTo<M, TMap>[K]["field"]["optional"]> : K extends keyof ExtractHasMany<M, TMap> ? InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, EnsureHasManyQuery<Q[K]>> : K extends keyof ExtractHasOne<M, TMap> ? InferModelQuery<ExtractHasOne<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap> : never;
+type InferRelEntry<M extends AnyDesc, TMap extends ModelMap$2, Q extends RelQuery<any, any>, K extends keyof Q> = K extends keyof EnrichBelongsTo<M, TMap> ? IsOptional<InferModelQuery<EnrichBelongsTo<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap>, EnrichBelongsTo<M, TMap>[K]["field"]["optional"]> : K extends keyof ExtractHasMany<M, TMap> ? InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, EnsureHasManyQuery<Q[K]>> : K extends keyof ExtractHasOne<M, TMap> ? InferModelQuery<ExtractHasOne<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap> : never;
 type InferKeyName<Q extends RelQuery<any, any>, K extends keyof Q> = Q[K] extends Array<any> ? never : Q[K] extends {
   as: string;
 } ? K extends keyof ExtractHasMany<any, any> ? Q[K]["as"] : K : K;
-type InferRelQuery<M extends AnyDesc, Q extends RelQuery<M, TMap>, TMap extends ModelMap$1> = EmptyObjIfNever<ExtractRelQueryArray<M, TMap, Q>> & EmptyObjIfNever<{ [K in keyof Q as InferKeyName<Q, K>]: InferRelEntry<M, TMap, Q, K> }>;
-type Instance<M extends keyof ModelMap$1> = {
+type InferRelQuery<M extends AnyDesc, Q extends RelQuery<M, TMap>, TMap extends ModelMap$2> = EmptyObjIfNever<ExtractRelQueryArray<M, TMap, Q>> & EmptyObjIfNever<{ [K in keyof Q as InferKeyName<Q, K>]: InferRelEntry<M, TMap, Q, K> }>;
+type Instance<M extends keyof ModelMap$2> = {
   "~model": M;
   "~key": string;
 };
@@ -2873,16 +2873,13 @@ declare const _rootDesc: ModelDesc<"_root", {}, {
   }>;
 }, []>;
 //#endregion
-//#region src/index.d.ts
-type ModelMap = typeof modelMap;
-type Fetchers = {
-  fetchFromRoot: <const Q extends RelQuery<typeof _rootDesc, ModelMap>>(q: Q) => Promise<InferRelQuery<typeof _rootDesc, Q, ModelMap>>;
-  fetchFromInstance: <M extends keyof ModelMap, const Q extends ModelQuery<ModelMap[M], ModelMap>>(instance: Instance<M>, q: Q) => Promise<InferModelQuery<ModelMap[M], Q, ModelMap>>;
-  fetchInstance: <K extends keyof ModelMap, const Q extends RelQuery<ModelMap[K], ModelMap>>(model: K, id: string, q: Q) => Promise<InferModelQuery<ModelMap[K], Q, ModelMap>>;
-  fetchInstances: <K extends keyof ModelMap, Id extends string, const Q extends RelQuery<ModelMap[K], ModelMap>>(model: K, id: Id[], q: Q) => Promise<Record<Id, InferModelQuery<ModelMap[K], Q, ModelMap>>>;
+//#region src/loaders/loader-utils.d.ts
+type ModelMap$1 = typeof modelMap;
+type DataLoader = {
+  fetchModel: <K extends keyof ModelMap$1, Id extends string, const Q extends ModelQuery<ModelMap$1[K], ModelMap$1>>(model: K, id: Id[], q: Q) => Promise<Record<Id, InferModelQuery<ModelMap$1[K], Q, ModelMap$1>>>;
 };
 type FetchFunction = (url: string, init?: RequestInit) => Promise<Response>;
-type FetcherOptions = {
+type FetchOptions = {
   fetch?: FetchFunction;
   accessToken?: string;
   subdomain?: string;
@@ -2890,6 +2887,19 @@ type FetcherOptions = {
   headers?: Record<string, string>;
   timeout?: number;
 };
-declare const buildFetchers: (opts?: FetcherOptions) => Fetchers;
 //#endregion
-export { buildFetchers };
+//#region src/loaders/simple-loader.d.ts
+type SimpleLoaderOptions = FetchOptions;
+//#endregion
+//#region src/index.d.ts
+type ModelMap = typeof modelMap;
+type Fetchers = {
+  fetchFromRoot: <const Q extends RelQuery<typeof _rootDesc, ModelMap>>(q: Q) => Promise<InferRelQuery<typeof _rootDesc, Q, ModelMap>>;
+  fetchFromInstance: <M extends keyof ModelMap, const Q extends ModelQuery<ModelMap[M], ModelMap>>(instance: Instance<M>, q: Q) => Promise<InferModelQuery<ModelMap[M], Q, ModelMap>>;
+  fetchInstance: <K extends keyof ModelMap, const Q extends ModelQuery<ModelMap[K], ModelMap>>(model: K, id: string, q: Q) => Promise<InferModelQuery<ModelMap[K], Q, ModelMap>>;
+  fetchInstances: <K extends keyof ModelMap, Id extends string, const Q extends ModelQuery<ModelMap[K], ModelMap>>(model: K, id: Id[], q: Q) => Promise<Record<Id, InferModelQuery<ModelMap[K], Q, ModelMap>>>;
+};
+declare const buildFetchersWithSimpleLoader: (opts: SimpleLoaderOptions) => Fetchers;
+declare const buildFetchers: (loader: DataLoader) => Fetchers;
+//#endregion
+export { buildFetchers, buildFetchersWithSimpleLoader };

package/dist/index.js

@@ -1,13 +1,3 @@
-//#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
 //#region src/models/_desc.ts
 const makeModel = (opts) => {
 	return opts;
@@ -38,57 +28,6 @@ const _rootDesc = makeModel({
 	keys: []
 });
 
-//#endregion
-//#region src/model-pool.ts
-const ROOT_ID = "";
-const dateStrToDay = (dateAsStr) => {
-	const parts = dateAsStr.split("-");
-	return {
-		year: parseInt(parts[0], 10),
-		month: parseInt(parts[1], 10),
-		day: parseInt(parts[2], 10)
-	};
-};
-const parseField = (v, field) => {
-	if (!field) return v;
-	switch (field.type) {
-		case "date": return new Date(v);
-		case "day": return dateStrToDay(v);
-		default: return v;
-	}
-};
-const transformData = (desc, data) => {
-	return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, parseField(v, desc.fields[k])]));
-};
-var ModelPool = class {
-	data = new Map();
-	modelMap;
-	constructor(modelMap$1) {
-		this.modelMap = modelMap$1;
-	}
-	addModelInstance(model, id$1, _data) {
-		const instanceById = ensureMapValue(this.data, model, () => new Map());
-		const exists = instanceById.get(id$1);
-		const desc = this.modelMap[model];
-		if (!desc) throw new Error(`Unknown model: ${model}`);
-		const data = transformData(desc, _data);
-		if (exists) Object.assign(exists, data);
-		else instanceById.set(id$1, data);
-	}
-	add(data) {
-		Object.entries(data).forEach(([modelName, payload]) => {
-			if (modelName === _rootDesc.name) this.addModelInstance(modelName, ROOT_ID, payload);
-			else Object.entries(payload).forEach(([id$1, payload$1]) => {
-				this.addModelInstance(modelName, id$1, payload$1);
-			});
-		});
-	}
-	get(model, id$1) {
-		const instances = this.data.get(model);
-		return instances?.get(id$1) ?? null;
-	}
-};
-
 //#endregion
 //#region src/models/_fields.ts
 const id = () => {
@@ -3012,9 +2951,100 @@ const modelMap = {
 	workflowItem: workflowItemDesc
 };
 
+//#endregion
+//#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
+//#region src/model-pool.ts
+const ROOT_ID = "";
+const dateStrToDay = (dateAsStr) => {
+	const parts = dateAsStr.split("-");
+	return {
+		year: parseInt(parts[0], 10),
+		month: parseInt(parts[1], 10),
+		day: parseInt(parts[2], 10)
+	};
+};
+const parseField = (v, field) => {
+	if (!field) return v;
+	switch (field.type) {
+		case "date": return new Date(v);
+		case "day": return dateStrToDay(v);
+		default: return v;
+	}
+};
+const transformData = (desc, data) => {
+	return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, parseField(v, desc.fields[k])]));
+};
+var ModelPool = class {
+	data = new Map();
+	modelMap;
+	constructor(modelMap$1) {
+		this.modelMap = modelMap$1;
+	}
+	addModelInstance(model, id$1, _data) {
+		const instanceById = ensureMapValue(this.data, model, () => new Map());
+		const exists = instanceById.get(id$1);
+		const desc = this.modelMap[model];
+		if (!desc) throw new Error(`Unknown model: ${model}`);
+		const data = transformData(desc, _data);
+		if (exists) Object.assign(exists, data);
+		else instanceById.set(id$1, data);
+	}
+	add(data) {
+		Object.entries(data).forEach(([modelName, payload]) => {
+			if (modelName === _rootDesc.name) this.addModelInstance(modelName, ROOT_ID, payload);
+			else Object.entries(payload).forEach(([id$1, payload$1]) => {
+				this.addModelInstance(modelName, id$1, payload$1);
+			});
+		});
+	}
+	get(model, id$1) {
+		const instances = this.data.get(model);
+		return instances?.get(id$1) ?? null;
+	}
+};
+
 //#endregion
 //#region src/query-helpers.ts
+const normalizeQuery = (q) => {
+	return JSON.stringify(q);
+};
 const getRelKey = (r, k) => {
+	const getSuffix = () => {
+		if (r.type === "exists") return `exists:`;
+		if (r.type === "count") return `count:`;
+		return "";
+	};
+	const suffix = getSuffix();
 	const isPlainKey = () => {
 		if (r.type === "first") return false;
 		if (r.filter && Object.keys(r.filter).length > 0) return false;
@@ -3023,7 +3053,7 @@ const getRelKey = (r, k) => {
 		}
 		return true;
 	};
-	if (isPlainKey()) return k;
+	if (isPlainKey()) return `${suffix}${k}`;
 	const q = { ...r.filter };
 	if (r.type === "first") {
 		q.$first = true;
@@ -3034,52 +3064,65 @@ const getRelKey = (r, k) => {
 		if (r.offset) q.$offset = r.offset;
 		if (r.orderBy) q.$order = r.orderBy;
 	}
-	return `${k}(${JSON.stringify(q)})`;
+	return `${suffix}${k}(${normalizeQuery(q)})`;
+};
+const processRelations = (rels) => {
+	const result = {};
+	for (const [key, relq] of Object.entries(rels)) {
+		const asArray = Array.isArray(relq) ? relq : [relq];
+		for (const rel of asArray) {
+			if (!rel) continue;
+			result[getRelKey(rel, key)] = makeRelQuerySerializable(rel);
+		}
+	}
+	return result;
+};
+const makeModelQuerySerializable = (q) => {
+	if (!q.relations) return q;
+	return {
+		...q,
+		relations: processRelations(q.relations)
+	};
 };
-const serializeModel = (q, modelDesc) => {
+const makeRelQuerySerializable = (r) => {
+	if (r.type === "exists" || r.type === "count") return { asField: true };
+	return {
+		asField: false,
+		fields: r.fields,
+		relations: r.relations ? processRelations(r.relations) : void 0
+	};
+};
+const serializeModel = (q) => {
 	const list = q.fields ? [...q.fields] : [];
 	if (!q.relations) return list;
 	const relObj = {};
-	Object.entries(q.relations).forEach(([k, _v]) => {
-		const rels = Array.isArray(_v) ? _v : [_v];
-		rels.forEach((r) => {
-			switch (r?.type) {
-				case "count": {
-					list.push(`count:${getRelKey(r, k)}`);
-					break;
-				}
-				case "exists": {
-					list.push(`exists:${getRelKey(r, k)}`);
-					break;
-				}
-				default:
-					relObj[getRelKey(r, k)] = serializeModel(r, modelDesc);
-					break;
-			}
-		});
+	Object.entries(q.relations).forEach(([k, r]) => {
+		if (r.asField) list.push(k);
+		else relObj[k] = serializeModel(r);
 	});
 	if (Object.keys(relObj).length) list.push(relObj);
 	return list;
 };
-const serializeRootQuery = (q) => {
-	return { _root: serializeModel({ relations: q }, _rootDesc) };
-};
-const serializeInstanceQuery = (q, instances, modelMap$1) => {
+const serializeInstanceQuery = (q, instances) => {
 	return Object.fromEntries(instances.map((instance) => {
 		const name = instance["~model"];
-		return [`${name}(${instance["~key"]})`, serializeModel(q, modelMap$1[name])];
+		const getKey = () => {
+			if (name === "_root") return "_root";
+			return `${name}(${instance["~key"]})`;
+		};
+		return [getKey(), serializeModel(q)];
 	}));
 };
 
 //#endregion
 //#region src/reconcile-query.ts
-const reconcileInstanceQuery = (query, response, instanceModel, key, store, skipMeta = false) => {
+const reconcileInstanceQuery = (query, response, instanceModel, key, store) => {
 	const instance = store.get(instanceModel.name, key);
 	if (!instance) {
 		console.warn(`no instance found in pool: [${instanceModel.name}, ${key}]`);
 		return null;
 	}
-	const result = skipMeta ? {} : {
+	const result = instanceModel.name === "_root" ? {} : {
 		"~model": instanceModel.name,
 		"~key": key
 	};
@@ -3106,12 +3149,9 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, store, skip
 					const relKey = getRelKey(relEntry, relName);
 					const val = instance[relKey];
 					switch (relEntry.type) {
-						case "count": {
-							result[asName] = instance[`count:${relKey}`];
-							break;
-						}
+						case "count":
 						case "exists": {
-							result[asName] = instance[`exists:${relKey}`];
+							result[asName] = instance[relKey];
 							break;
 						}
 						case "first":
@@ -3131,67 +3171,52 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, store, skip
 };
 
 //#endregion
-//#region src/index.ts
-const buildFetchers = (opts = {}) => {
-	const fetchImpl = opts.fetch || globalThis.fetch;
-	const configuredFetch = async (url, init = {}) => {
-		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
-		});
-	};
+//#region src/loaders/simple-loader.ts
+const createSimpleLoader = (opts = {}) => {
 	const fetchWithQuery = async (query) => {
-		const response = await configuredFetch("", {
+		return configuredFetch(opts, "", {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ query })
-		}).then(async (r) => {
-			const content = await r.json();
-			if (r.status !== 200) throw new Error(`[${r.status}] ${JSON.stringify(content)}`);
-			return content;
 		});
-		return response;
 	};
-	const _fetchSingleInstance = async (instance, q) => {
-		const response = await fetchWithQuery(serializeInstanceQuery(q, [instance], modelMap));
+	return { fetchModel: async (model, ids, q) => {
+		const modelDesc = modelMap[model];
+		const instances = ids.map((id$1) => ({
+			"~model": model,
+			"~key": id$1
+		}));
+		const response = await fetchWithQuery(serializeInstanceQuery(makeModelQuerySerializable(q), instances));
 		const pool = new ModelPool(modelMap);
 		pool.add(response);
-		return reconcileInstanceQuery(q, response, modelMap[instance["~model"]], instance["~key"], pool);
-	};
+		return Object.fromEntries(ids.map((id$1) => [id$1, reconcileInstanceQuery(q, response, modelDesc, id$1, pool)]));
+	} };
+};
+
+//#endregion
+//#region src/index.ts
+const buildFetchersWithSimpleLoader = (opts) => {
+	const loader = createSimpleLoader(opts);
+	return buildFetchers(loader);
+};
+const buildFetchers = (loader) => {
 	return {
 		fetchFromRoot: async (q) => {
-			const response = await fetchWithQuery(serializeRootQuery(q));
-			const pool = new ModelPool(modelMap);
-			pool.add(response);
-			return reconcileInstanceQuery({ relations: q }, response, _rootDesc, "", pool, true);
+			const res = await loader.fetchModel("_root", [""], { relations: q });
+			return res[""];
 		},
-		fetchFromInstance: _fetchSingleInstance,
-		fetchInstance: async (model, id$1, q) => {
-			return _fetchSingleInstance({
-				"~model": model,
-				"~key": id$1
-			}, q);
+		fetchFromInstance: async (instance, q) => {
+			const key = instance["~key"];
+			const res = await loader.fetchModel(instance["~model"], [key], q);
+			return res[key];
 		},
-		fetchInstances: async (model, ids, q) => {
-			const modelDesc = modelMap[model];
-			const instances = ids.map((id$1) => ({
-				"~model": model,
-				"~key": id$1
-			}));
-			const response = await fetchWithQuery(serializeInstanceQuery(q, instances, modelMap));
-			const pool = new ModelPool(modelMap);
-			pool.add(response);
-			return Object.fromEntries(ids.map((id$1) => [id$1, reconcileInstanceQuery(q, response, modelDesc, id$1, pool)]));
-		}
+		fetchInstance: async (model, key, q) => {
+			const res = await loader.fetchModel(model, [key], q);
+			return res[key];
+		},
+		fetchInstances: loader.fetchModel
 	};
 };
 
 //#endregion
-export { buildFetchers };
+export { buildFetchers, buildFetchersWithSimpleLoader };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codecks/fetch",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Quickly create deeply nested queries for the Codecks API with advanced TypeScript support",
   "type": "module",
   "license": "MIT",
@@ -21,6 +21,10 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
+    "./_exploration/store": "./dist/_exploration/store.js",
+    "./_exploration/loader": "./dist/_exploration/loader.js",
+    "./_exploration/api-requester": "./dist/_exploration/api-requester.js",
+    "./_exploration/react": "./dist/_exploration/create-hooks.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -32,19 +36,24 @@
     "check-format": "prettier --check .",
     "dev": "tsdown --watch",
     "test": "vitest",
+    "test:run": "vitest run",
     "typecheck": "tsc --noEmit",
-    "ci": "npm run typecheck && npm run build && npm run check-format && npm run test",
+    "ci": "npm run typecheck && npm run build && npm run check-format && npm run test:run",
     "local-release": "changeset version && changeset publish",
     "prepublishOnly": "npm run ci"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",
     "@types/node": "^22.15.17",
+    "@types/react": "^19.2.2",
     "msw": "^2.10.4",
     "prettier": "^3.6.2",
     "tsdown": "^0.11.9",
     "typescript": "^5.9.2",
     "vite-node": "^3.2.4",
     "vitest": "^3.1.3"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
   }
 }