@codecks/fetch 0.0.2 → 0.0.4

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> {
+type ModelMap$2 = Record<string, AnyDesc>;
+interface ModelQuery<T extends AnyDesc, TMap extends ModelMap$2> {
   fields?: (keyof T["fields"])[];
   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/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/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,58 +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);
-		if (!instances) return null;
-		return instances.get(id$1) ?? null;
-	}
-};
-
 //#endregion
 //#region src/models/_fields.ts
 const id = () => {
@@ -3013,6 +2951,84 @@ const modelMap = {
 	workflowItem: workflowItemDesc
 };
 
+//#endregion
+//#region src/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
+	});
+};
+
+//#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 getRelKey = (r, k) => {
@@ -3046,11 +3062,11 @@ const serializeModel = (q, modelDesc) => {
 		rels.forEach((r) => {
 			switch (r?.type) {
 				case "count": {
-					list.push(`count(${getRelKey(r, k)})`);
+					list.push(`count:${getRelKey(r, k)}`);
 					break;
 				}
 				case "exists": {
-					list.push(`exists(${getRelKey(r, k)})`);
+					list.push(`exists:${getRelKey(r, k)}`);
 					break;
 				}
 				default:
@@ -3062,41 +3078,26 @@ const serializeModel = (q, modelDesc) => {
 	if (Object.keys(relObj).length) list.push(relObj);
 	return list;
 };
-const serializeRelations = (q, modelDesc) => {
-	return Object.fromEntries(Object.entries(q).map(([k, v]) => [k, serializeModel(v, modelDesc.relations[k])]));
-};
-const serializeRootQuery = (q) => {
-	return { _root: [serializeRelations(q, _rootDesc)] };
-};
 const serializeInstanceQuery = (q, instances, modelMap$1) => {
 	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, modelMap$1[name])];
 	}));
 };
 
 //#endregion
 //#region src/reconcile-query.ts
-const reconcileRootQuery = (query, response, pool) => {
-	const result = {};
-	const responsePart = response._root;
-	for (const [relName, modelFields] of Object.entries(query)) {
-		const relDesc = _rootDesc.relations[relName];
-		const id$1 = responsePart[relName];
-		if (!id$1) {
-			result[relName] = null;
-			continue;
-		} else result[relName] = reconcileInstanceQuery(modelFields, response, modelMap[relDesc.relName], `${id$1}`, pool);
-	}
-	return result;
-};
-const reconcileInstanceQuery = (query, response, instanceModel, key, pool) => {
-	const instance = pool.get(instanceModel.name, key);
+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 = {
+	const result = instanceModel.name === "_root" ? {} : {
 		"~model": instanceModel.name,
 		"~key": key
 	};
@@ -3112,11 +3113,11 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, pool) => {
 			switch (opts.type) {
 				case "belongsTo":
 					result[opts.fk] = instance[relName];
-					result[relName] = opts.fk ? reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, pool) : null;
+					result[relName] = opts.fk ? reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, store) : null;
 					break;
 				case "hasOne":
 					result[`~${relName}`] = instance[relName];
-					result[relName] = reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, pool);
+					result[relName] = reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, store);
 					break;
 				case "hasMany":
 					const asName = relEntry.as ?? relName;
@@ -3124,20 +3125,20 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, pool) => {
 					const val = instance[relKey];
 					switch (relEntry.type) {
 						case "count": {
-							result[asName] = instance[`count(${relKey})`];
+							result[asName] = instance[`count:${relKey}`];
 							break;
 						}
 						case "exists": {
-							result[asName] = instance[`exists(${relKey})`];
+							result[asName] = instance[`exists:${relKey}`];
 							break;
 						}
 						case "first":
 							result[`~${asName}`] = val;
-							result[asName] = reconcileInstanceQuery(relEntry, response, relModel, `${val}`, pool);
+							result[asName] = reconcileInstanceQuery(relEntry, response, relModel, `${val}`, store);
 							break;
 						default: {
 							result[`~${asName}`] = val;
-							result[asName] = val.map((id$1) => reconcileInstanceQuery(relEntry, response, relModel, `${id$1}`, pool));
+							result[asName] = val.map((id$1) => reconcileInstanceQuery(relEntry, response, relModel, `${id$1}`, store));
 						}
 					}
 					break;
@@ -3148,24 +3149,10 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, pool) => {
 };
 
 //#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/simple-loader.ts
+const createSimpleLoader = (opts = {}) => {
 	const fetchWithQuery = async (query) => {
-		const response = await configuredFetch("", {
+		const response = await configuredFetch(opts, "", {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ query })
@@ -3176,40 +3163,43 @@ const buildFetchers = (opts = {}) => {
 		});
 		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(q, instances, modelMap));
 		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 reconcileRootQuery(q, response, pool);
+			const res = await loader.fetchModel("_root", [""], { relations: q });
+			return res[""];
 		},
-		fetchFromInstance: _fetchSingleInstance,
-		fetchInstance: async (key, id$1, q) => {
-			const instance = {
-				"~model": key,
-				"~key": id$1
-			};
-			return _fetchSingleInstance(instance, q);
+		fetchFromInstance: async (instance, q) => {
+			const key = instance["~key"];
+			const res = await loader.fetchModel(instance["~model"], [key], q);
+			return res[key];
 		},
-		fetchInstances: async (key, ids, q) => {
-			const modelDesc = modelMap[key];
-			const instances = ids.map((id$1) => ({
-				"~model": key,
-				"~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.2",
+  "version": "0.0.4",
   "description": "Quickly create deeply nested queries for the Codecks API with advanced TypeScript support",
   "type": "module",
   "license": "MIT",
@@ -32,8 +32,9 @@
     "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"
   },