@codecks/fetch 0.1.5 → 0.1.7

package/dist/immediate-cache-DiH8tpJM.js

@@ -0,0 +1,237 @@
+//#region src/_exploration/optimistic-manager.ts
+/**
+* Represents a single optimistic update layer
+* Contains field updates for one mutation
+* Internal implementation - wrapped by ImmediateCache to provide full OptimisticUpdater interface
+*/
+var OptimisticLayer = class {
+	data = new Map();
+	affectedFields = new Set();
+	setField(model, id, field, value) {
+		const fieldKey = getFieldKey(model, id, field);
+		this.data.set(fieldKey, value);
+		this.affectedFields.add(fieldKey);
+	}
+	hasChanges() {
+		return this.affectedFields.size > 0;
+	}
+	getAffectedFieldKeys() {
+		return this.affectedFields;
+	}
+	entries() {
+		return this.data.entries();
+	}
+};
+/**
+* Manages a stack of optimistic layers with O(1) lookups
+*
+* Design:
+* - Maintains a stack of layers (one per in-flight mutation)
+* - Rebuilds flattened view when layers added/removed for fast reads
+* - Later layers override earlier ones (parallel updates supported)
+* - Auto-cleanup via promise lifecycle
+*/
+var OptimisticManager = class {
+	layers = [];
+	flatView = new Map();
+	/**
+	* Add a new optimistic layer
+	* @returns Object with the layer and a dispose function that returns affected field keys
+	*/
+	addLayer() {
+		const layer = new OptimisticLayer();
+		this.layers.push(layer);
+		const dispose = () => this.removeLayer(layer);
+		return {
+			layer,
+			dispose
+		};
+	}
+	/**
+	* Get optimistic value for a field (O(1) via flat view)
+	* Returns undefined if no optimistic update exists for this field
+	*/
+	get(model, id, field) {
+		const fieldKey = getFieldKey(model, id, field);
+		const entry = this.flatView.get(fieldKey);
+		if (!entry) return void 0;
+		const meta = { state: "optimistic" };
+		return {
+			value: entry.value,
+			partKeys: [fieldKey],
+			meta
+		};
+	}
+	/**
+	* Remove a layer from the stack
+	* Returns affected field keys for notification
+	*/
+	removeLayer(layer) {
+		const layerIndex = this.layers.indexOf(layer);
+		if (layerIndex === -1) return;
+		this.layers.splice(layerIndex, 1);
+		this.rebuildFlatView();
+	}
+	/**
+	* Rebuild the flattened view from the layer stack
+	* Later layers override earlier ones for the same field
+	*/
+	rebuildFlatView() {
+		this.flatView.clear();
+		for (let i = 0; i < this.layers.length; i++) {
+			const layer = this.layers[i];
+			for (const [fieldKey, value] of layer.entries()) this.flatView.set(fieldKey, {
+				value,
+				layerIndex: i
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/_exploration/immediate-cache.ts
+const getFieldKey = (model, id, field) => `${model}:${id}:${field}`;
+/**
+* Wrapper that provides full OptimisticUpdater interface
+* Delegates writes to OptimisticLayer and reads to ImmediateCache
+*/
+var OptimisticUpdater = class {
+	constructor(layer, cache) {
+		this.layer = layer;
+		this.cache = cache;
+	}
+	setField(model, id, field, value) {
+		this.layer.setField(model, id, field, value);
+	}
+	getField(model, id, field) {
+		return this.cache.get(model, id, field);
+	}
+};
+var ImmediateCache = class {
+	cache = new Map();
+	partKeyToFields = new Map();
+	fieldSubscriptions = new Map();
+	optimisticManager = new OptimisticManager();
+	getInstanceKey(model, id) {
+		return `${model}:${id}`;
+	}
+	get(model, key, field) {
+		const optimistic = this.optimisticManager.get(model, key, field);
+		if (optimistic) return optimistic;
+		return this.cache.get(this.getInstanceKey(model, key))?.get(field);
+	}
+	subscribe(fieldKey, notifyFn) {
+		const exists = this.fieldSubscriptions.get(fieldKey);
+		if (exists) exists.add(notifyFn);
+		else this.fieldSubscriptions.set(fieldKey, new Set([notifyFn]));
+		return () => {
+			const subs = this.fieldSubscriptions.get(fieldKey);
+			if (!subs) return;
+			subs.delete(notifyFn);
+			if (subs.size === 0) this.fieldSubscriptions.delete(fieldKey);
+		};
+	}
+	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);
+		}
+		const subs = [];
+		for (const field in partialInstance) {
+			const f = partialInstance[field];
+			const oldEntry = entry.get(field);
+			const oldValue = oldEntry?.value;
+			const newValue = f.value;
+			const fieldEntry = {
+				value: newValue,
+				partKeys: f.partKeys,
+				meta
+			};
+			const fieldKey = getFieldKey(model, key, field);
+			entry.set(field, fieldEntry);
+			for (const partKey of f.partKeys) {
+				const location = {
+					model,
+					id: key,
+					field,
+					fieldKey,
+					cache: fieldEntry,
+					type: f.type
+				};
+				const maybeFields = this.partKeyToFields.get(partKey);
+				if (!maybeFields) this.partKeyToFields.set(partKey, [location]);
+				else maybeFields.push(location);
+			}
+			if (oldValue !== newValue) {
+				const fieldSubs = this.fieldSubscriptions.get(fieldKey);
+				if (fieldSubs) subs.push(...fieldSubs);
+			}
+		}
+		return subs;
+	}
+	markDirty(partKeys) {
+		const subscribedFields = [];
+		for (const partKey of partKeys) {
+			const locations = this.partKeyToFields.get(partKey);
+			console.log(locations);
+			if (!locations) continue;
+			for (const location of locations) {
+				location.cache.meta = { state: "dirty" };
+				if (this.fieldSubscriptions.has(location.fieldKey)) if (location.type === "field") subscribedFields.push({
+					type: "field",
+					model: location.model,
+					id: location.id,
+					field: location.field
+				});
+				else subscribedFields.push({
+					type: "relation",
+					model: location.model,
+					id: location.id,
+					relKey: location.fieldKey,
+					contents: {
+						asField: false,
+						fields: []
+					}
+				});
+			}
+		}
+		return subscribedFields;
+	}
+	/**
+	* Create a new optimistic layer bound to a promise and apply updates
+	* The layer will be automatically removed when the promise settles
+	* @param promise - Promise to bind the layer lifecycle to
+	* @param updateFn - Function to apply optimistic updates to the layer
+	* @returns The updater object with both read and write capabilities
+	*/
+	createOptimisticLayer(promise, updateFn) {
+		const { layer, dispose } = this.optimisticManager.addLayer();
+		const updater = new OptimisticUpdater(layer, this);
+		updateFn(updater);
+		if (layer.hasChanges()) {
+			this.optimisticManager.rebuildFlatView();
+			const affectedFields = layer.getAffectedFieldKeys();
+			const notify = () => {
+				const subs = [];
+				for (const fieldKey of affectedFields) {
+					const fieldSubs = this.fieldSubscriptions.get(fieldKey);
+					if (fieldSubs) subs.push(...fieldSubs);
+				}
+				new Set(subs).forEach((fn) => fn());
+			};
+			notify();
+			promise.finally(() => {
+				dispose();
+				notify();
+			});
+		} else promise.finally(() => {
+			dispose();
+		});
+		return updater;
+	}
+};
+
+//#endregion
+export { ImmediateCache, getFieldKey };

package/dist/{index-DUBsesYl.d.ts → index-k-KPWV9R.d.ts}

@@ -1,4 +1,4 @@
-import { ModelDesc, Nominal, RelationEntry, TypedField } from "./query-type-Dx5ZCv5N.js";
+import { ModelDesc, Nominal, RelationEntry, TypedField } from "./query-type-BqQ9oX_U.js";
 
 //#region src/models/AccountOnboardingStep.d.ts
 type AccountOnboardingStepId = Nominal<string, "accountOnboardingStep">;
@@ -947,6 +947,7 @@ declare const modelMap: {
     }>;
     attachments: RelationEntry<"attachment", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     diffs: RelationEntry<"cardHistory", {
       readonly type: "hasMany";
@@ -959,15 +960,19 @@ declare const modelMap: {
     }>;
     childCards: RelationEntry<"card", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     inDeps: RelationEntry<"card", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     outDeps: RelationEntry<"card", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     cardReferences: RelationEntry<"card", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     upvotes: RelationEntry<"cardUpvote", {
       readonly type: "hasMany";
@@ -2663,9 +2668,11 @@ declare const modelMap: {
     }>;
     inDeps: RelationEntry<"workflowItem", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
     outDeps: RelationEntry<"workflowItem", {
       readonly type: "hasMany";
+      readonly fkAsArray: true;
     }>;
   }, ["itemId"]>;
 };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { InferModelQuery, InferRelQuery, Instance, ModelQuery, RelQuery } from "./query-type-Dx5ZCv5N.js";
-import { modelMap$1 as modelMap } from "./index-DUBsesYl.js";
-import { DataLoader, FetchOptions } from "./loader-utils-Du-CTKH-.js";
-import { _rootDesc$1 as _rootDesc } from "./_root-D1Faf8cg.js";
+import { InferModelQuery, InferRelQuery, Instance, ModelQuery, RelQuery } from "./query-type-BqQ9oX_U.js";
+import { modelMap$1 as modelMap } from "./index-k-KPWV9R.js";
+import { DataLoader, FetchOptions } from "./loader-utils-BqZKAn_v.js";
+import { _rootDesc$1 as _rootDesc } from "./_root-BW9uzB79.js";
 
 //#region src/loaders/simple-loader.d.ts
 type SimpleLoaderOptions = FetchOptions;

package/dist/index.js

@@ -1,5 +1,5 @@
 import { configuredFetch, ensureMapValue } from "./collection-utils-CYJaA1a9.js";
-import { _rootDesc, getRelKey, makeModelQuerySerializable, modelMap, serializeInstanceQuery } from "./query-helpers-DsMMOtSO.js";
+import { _rootDesc, getRelKey, makeModelQuerySerializable, modelMap, serializeInstanceQuery } from "./query-helpers-iX1fiqLv.js";
 
 //#region src/model-pool.ts
 const ROOT_ID = "";
@@ -12,7 +12,7 @@ const dateStrToDay = (dateAsStr) => {
 	};
 };
 const parseField = (v, field) => {
-	if (!field) return v;
+	if (!field || v == null) return v;
 	switch (field.type) {
 		case "date": return new Date(v);
 		case "day": return dateStrToDay(v);
@@ -76,7 +76,7 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, store) => {
 				case "belongsTo":
 					result[opts.fk] = instance[relName];
 					result[`~${relName}`] = instance[relName] != null ? `${instance[relName]}` : null;
-					result[relName] = opts.fk ? reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, store) : null;
+					result[relName] = instance[relName] != null ? reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, store) : null;
 					break;
 				case "hasOne":
 					result[`~${relName}`] = instance[relName] != null ? `${instance[relName]}` : null;
@@ -97,8 +97,9 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, store) => {
 							result[asName] = reconcileInstanceQuery(relEntry, response, relModel, `${val}`, store);
 							break;
 						default: {
-							result[`~${asName}`] = val.map((v) => `${v}`);
-							result[asName] = val.map((id) => reconcileInstanceQuery(relEntry, response, relModel, `${id}`, store));
+							const ids = val ?? [];
+							result[`~${asName}`] = ids.map((v) => `${v}`);
+							result[asName] = ids.map((id) => reconcileInstanceQuery(relEntry, response, relModel, `${id}`, store));
 						}
 					}
 					break;

package/dist/{loader-types-Dp0CSVTf.d.ts → loader-types-fd5tV0FD.d.ts}

@@ -1,4 +1,4 @@
-import { SerializableRelationQuery } from "./query-type-Dx5ZCv5N.js";
+import { SerializableRelationQuery } from "./query-type-BqQ9oX_U.js";
 
 //#region src/_exploration/loader-types.d.ts
 type OnLoadedFn = (model: string, key: string, partialInstance: Record<string, unknown>) => void;
@@ -6,16 +6,12 @@ interface BaseLoader {
   setOnLoaded(onLoaded: OnLoadedFn): void;
   loadBatch(requests: MissingDataRequest[]): Promise<unknown>;
 }
-type LoaderPayload = {
-  value: unknown;
-  partKeys: string[];
-};
 type LoaderResult = {
   state: "resolved";
-  payload: LoaderPayload;
+  payload: unknown;
 } | {
   state: "pending";
-  promise: Promise<LoaderPayload>;
+  promise: Promise<unknown>;
 };
 type MissingDataRequest = {
   type: "field";
@@ -27,7 +23,7 @@ type MissingDataRequest = {
   model: string;
   id: string;
   relKey: string;
-  query: SerializableRelationQuery;
+  contents: SerializableRelationQuery;
 };
 interface BaseRequester {
   request: (requests: MissingDataRequest[]) => Promise<{

package/dist/{loader-utils-Du-CTKH-.d.ts → loader-utils-BqZKAn_v.d.ts}

@@ -1,5 +1,5 @@
-import { InferModelQuery, ModelQuery } from "./query-type-Dx5ZCv5N.js";
-import { modelMap$1 as modelMap } from "./index-DUBsesYl.js";
+import { InferModelQuery, ModelQuery } from "./query-type-BqQ9oX_U.js";
+import { modelMap$1 as modelMap } from "./index-k-KPWV9R.js";
 
 //#region src/loaders/loader-utils.d.ts
 type ModelMap = typeof modelMap;

package/dist/{query-helpers-DsMMOtSO.js → query-helpers-iX1fiqLv.js}

@@ -33,33 +33,37 @@ const _rootDesc = makeModel({
 const id = () => {
 	return { type: "id" };
 };
+const withOpts = (type, opts) => opts.optional ? {
+	type,
+	optional: true
+} : { type };
 const string = (opts) => {
-	return { type: "string" };
+	return withOpts("string", opts);
 };
 const int = (opts) => {
-	return { type: "int" };
+	return withOpts("int", opts);
 };
 const bigint = (opts) => {
-	return { type: "bigint" };
+	return withOpts("bigint", opts);
 };
 const bool = (opts) => {
-	return { type: "bool" };
+	return withOpts("bool", opts);
 };
 const date = (opts) => {
-	return { type: "date" };
+	return withOpts("date", opts);
 };
 const day = (opts) => {
-	return { type: "day" };
+	return withOpts("day", opts);
 };
 const object = (opts) => {
-	return { type: "obj" };
+	return withOpts("obj", opts);
 };
 const array = (opts) => {
-	return { type: "array" };
+	return withOpts("array", opts);
 };
 const belongsTo = (opts) => {
 	return { type: () => {
-		return { type: "belongsTo" };
+		return withOpts("belongsTo", opts);
 	} };
 };
 
@@ -746,8 +750,14 @@ const workflowItemDesc = makeModel({
 			fk: "creatorId"
 		}),
 		diffs: relation("workflowItemHistory", { type: "hasMany" }),
-		inDeps: relation("workflowItem", { type: "hasMany" }),
-		outDeps: relation("workflowItem", { type: "hasMany" })
+		inDeps: relation("workflowItem", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		outDeps: relation("workflowItem", {
+			type: "hasMany",
+			fkAsArray: true
+		})
 	},
 	keys: ["itemId"]
 });
@@ -911,14 +921,29 @@ const cardDesc = makeModel({
 		cardOrders: relation("cardOrder", { type: "hasMany" }),
 		resolvableEntries: relation("resolvableEntry", { type: "hasMany" }),
 		queueEntries: relation("queueEntry", { type: "hasMany" }),
-		attachments: relation("attachment", { type: "hasMany" }),
+		attachments: relation("attachment", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
 		diffs: relation("cardHistory", { type: "hasMany" }),
 		totalTimeTrackingSums: relation("timeTrackingSum", { type: "hasOne" }),
 		userTimeTrackingSums: relation("timeTrackingSum", { type: "hasMany" }),
-		childCards: relation("card", { type: "hasMany" }),
-		inDeps: relation("card", { type: "hasMany" }),
-		outDeps: relation("card", { type: "hasMany" }),
-		cardReferences: relation("card", { type: "hasMany" }),
+		childCards: relation("card", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		inDeps: relation("card", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		outDeps: relation("card", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		cardReferences: relation("card", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
 		upvotes: relation("cardUpvote", { type: "hasMany" })
 	},
 	keys: ["cardId"]

package/dist/{query-type-Dx5ZCv5N.d.ts → query-type-BqQ9oX_U.d.ts}

@@ -16,7 +16,7 @@ type BaseOpts = {
 type FieldEntry = TypedField<string, any, any>;
 type InferSimpleFieldEntry<T extends FieldEntry> = T extends TypedField<any, infer X, infer Opts> ? Opts extends {
   optional: true;
-} ? X | null | "yes" : X : never;
+} ? X | null : X : never;
 //#endregion
 //#region src/models/_desc.d.ts
 type ModelDesc<TName extends string, TFields extends FieldDesc, TRelations extends RelationsDesc, TKey extends (keyof TFields & string)[]> = {
@@ -33,6 +33,7 @@ type BelongsToOpts<TFk extends string> = {
 };
 type HasManyOpts = {
   type: "hasMany";
+  fkAsArray?: boolean;
 };
 type HasOneOpts = {
   type: "hasOne";
@@ -95,14 +96,26 @@ interface ModelQuery<T extends AnyDesc, TMap extends ModelMap> {
   fields?: (keyof T["fields"] & string)[];
   relations?: RelQuery<T, TMap>;
 }
-interface SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap> extends ModelQuery<T, TMap> {
+interface BaseHasManyQuery<T extends AnyDesc, TMap extends ModelMap> extends ModelQuery<T, TMap> {
   type?: "query";
-  orderBy?: Order<T>;
-  limit?: number;
-  offset?: number;
   filter?: Filter<T, TMap>;
   as?: string;
 }
+/**
+ * A `limit`/`offset` "subset" requires an `orderBy` server-side (otherwise the
+ * API rejects the query with "needs an order ... to be able to use subset"), and
+ * `offset` is only meaningful together with `limit`. The union below makes the
+ * omission a compile error instead of a runtime 500.
+ */
+type SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap> = BaseHasManyQuery<T, TMap> & ({
+  orderBy?: Order<T>;
+  limit?: never;
+  offset?: never;
+} | {
+  orderBy: Order<T>;
+  limit: number;
+  offset?: number;
+});
 interface CountOrExistQuery<T extends AnyDesc, TMap extends ModelMap> {
   type: "count" | "exists";
   filter?: Filter<T, TMap>;
@@ -117,6 +130,30 @@ interface FirstOrLastQuery<T extends AnyDesc, TMap extends ModelMap> extends Mod
   orderBy: Order<T>;
 }
 type HasManyQuery<T extends AnyDesc, TMap extends ModelMap> = SimpleHasManyQuery<T, TMap> | CountOrExistQuery<T, TMap> | FirstOrLastQuery<T, TMap>;
+/**
+ * `fkAsArray` hasMany relations (e.g. card `childCards`/`inDeps`/`outDeps`/
+ * `cardReferences`/`attachments`, workflowItem `inDeps`/`outDeps`) are stored as
+ * a plain id array column server-side. They support only plain selection
+ * (`fields` + nested `relations`) and the `count`/`exists` aggregates — any
+ * relQuery modifier (`filter`, `orderBy`, `limit`, `offset`, `type: "first"`) is
+ * rejected at runtime ("doesn't support relQueries"). The types mirror that.
+ */
+interface FkAsArrayQuery<T extends AnyDesc, TMap extends ModelMap> extends ModelQuery<T, TMap> {
+  type?: "query";
+  as?: string;
+  orderBy?: never;
+  limit?: never;
+  offset?: never;
+  filter?: never;
+}
+interface FkAsArrayCountOrExistQuery {
+  type: "count" | "exists";
+  as: string;
+  fields?: never;
+  relations?: never;
+  filter?: never;
+}
+type FkAsArrayHasManyQuery<T extends AnyDesc, TMap extends ModelMap> = FkAsArrayQuery<T, TMap> | FkAsArrayCountOrExistQuery;
 type AbstractHasManyQuery = (ModelQuery<any, any> & {
   type?: "query" | "first";
   as?: string;
@@ -127,7 +164,12 @@ type AbstractHasManyQuery = (ModelQuery<any, any> & {
 type HasManyQueryWithAs<T extends AnyDesc, TMap extends ModelMap> = HasManyQuery<T, TMap> & {
   as: string;
 };
-type HasManyRelQueryEntry<T extends AnyDesc, TMap extends ModelMap, K extends keyof ExtractHasMany<T, TMap>> = HasManyQuery<TMap[T["relations"][K]["relName"]], TMap> | HasManyQueryWithAs<TMap[T["relations"][K]["relName"]], TMap>[];
+type FkAsArrayHasManyQueryWithAs<T extends AnyDesc, TMap extends ModelMap> = FkAsArrayHasManyQuery<T, TMap> & {
+  as: string;
+};
+type HasManyRelQueryEntry<T extends AnyDesc, TMap extends ModelMap, K extends keyof ExtractHasMany<T, TMap>> = ExtractHasMany<T, TMap>[K] extends {
+  fkAsArray: true;
+} ? FkAsArrayHasManyQuery<ExtractHasMany<T, TMap>[K]["model"], TMap> | FkAsArrayHasManyQueryWithAs<ExtractHasMany<T, TMap>[K]["model"], TMap>[] : HasManyQuery<ExtractHasMany<T, TMap>[K]["model"], TMap> | HasManyQueryWithAs<ExtractHasMany<T, TMap>[K]["model"], TMap>[];
 type RelQueryEntry<T extends AnyDesc, TMap extends ModelMap, 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:
@@ -145,11 +187,14 @@ type EnrichBelongsTo<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys
     type: FieldType;
   } & FieldOpts : never;
 } : never : never }>;
-type ExtractHasMany<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
+type ExtractHasMany<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, infer Opts> ? Opts extends {
   type: "hasMany";
-}> ? {
+} ? {
   model: TMap[RelName];
-} : never }>;
+  fkAsArray: Opts extends {
+    fkAsArray: true;
+  } ? true : false;
+} : never : never }>;
 type ExtractHasOne<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
   type: "hasOne";
 }> ? {
@@ -165,7 +210,7 @@ type ExtractRelQueryArray<M extends AnyDesc, TMap extends ModelMap, Q extends Re
 type InferHasMany<M extends AnyDesc, TMap extends ModelMap, QM extends HasManyQuery<M, TMap>> = QM extends {
   type: "count";
 } ? number : QM extends {
-  type: "exist";
+  type: "exists";
 } ? boolean : QM extends {
   type: "first";
 } ? InferModelQuery<M, EnsureModelQuery<QM>, TMap> | null : InferModelQuery<M, EnsureModelQuery<QM>, TMap>[];