@peerbit/document 13.0.34 → 13.0.35

package/src/program.ts

@@ -6,7 +6,10 @@ import {
 	variant,
 } from "@dao-xyz/borsh";
 import { AccessError, SignatureWithKey } from "@peerbit/crypto";
-import { NotFoundError, ResultIndexedValue } from "@peerbit/document-interface";
+import {
+	NotFoundError,
+	type ResultIndexedValue,
+} from "@peerbit/document-interface";
 import type { QueryCacheOptions } from "@peerbit/indexer-cache";
 import * as indexerTypes from "@peerbit/indexer-interface";
 import {
@@ -38,13 +41,14 @@ import {
 	isDeleteOperation,
 	isPutOperation,
 } from "./operation.js";
+import { isResultIndexedValue } from "./result-shape.js";
 import {
 	type CanRead,
 	type CanSearch,
 	DocumentIndex,
 	type GetOptions,
-	type IndexedContextOnly,
 	INDEX_CONTEXT_SHAPE,
+	type IndexedContextOnly,
 	type PrefetchOptions,
 	type ReachScope,
 	type TransformOptions,
@@ -196,12 +200,13 @@ export class Documents<
 			| indexerTypes.IndexedResult<IndexedContextOnly<I>>
 			| null
 			| undefined,
-	): indexerTypes.ReturnTypeFromShape<
-		WithContext<I>,
-		typeof INDEX_CONTEXT_SHAPE
-	>["__context"]
+	):
+		| indexerTypes.ReturnTypeFromShape<
+				WithContext<I>,
+				typeof INDEX_CONTEXT_SHAPE
+		  >["__context"]
 		| undefined {
-		return existing instanceof ResultIndexedValue
+		return isResultIndexedValue(existing)
 			? existing.context
 			: existing?.value.__context;
 	}
@@ -268,7 +273,7 @@ export class Documents<
 					results.results
 						.flat()
 						.map((x) =>
-							x instanceof ResultIndexedValue && x.entries.length > 0
+							isResultIndexedValue(x) && x.entries.length > 0
 								? x.entries[0]
 								: x.context.head,
 						),
@@ -499,10 +504,7 @@ export class Documents<
 					if (this.immutable) {
 						// key already exist but pick the oldest entry
 						// this is because we can not overwrite same id if immutable
-						if (
-							existingContext.created <
-							entry.meta.clock.timestamp.wallTime
-						) {
+						if (existingContext.created < entry.meta.clock.timestamp.wallTime) {
 							return false;
 						}
 

package/src/result-shape.ts

@@ -0,0 +1,47 @@
+import type { AbstractType } from "@dao-xyz/borsh";
+import * as types from "@peerbit/document-interface";
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+	value != null && typeof value === "object";
+
+const isResultLike = (
+	value: unknown,
+): value is {
+	context: unknown;
+	entries?: unknown;
+	init: (type: unknown) => void;
+} =>
+	isObject(value) &&
+	"_source" in value &&
+	"context" in value &&
+	typeof value.init === "function";
+
+export const isResultIndexedValue = <I>(
+	value: unknown,
+): value is types.ResultIndexedValue<I> =>
+	value instanceof types.ResultIndexedValue ||
+	(isResultLike(value) && Array.isArray(value.entries));
+
+export const isResultValue = <T, I = Record<string, any>>(
+	value: unknown,
+): value is types.ResultValue<T, I> =>
+	value instanceof types.ResultValue ||
+	(isResultLike(value) && !Array.isArray(value.entries));
+
+export const isResults = <R extends types.Result>(
+	value: unknown,
+): value is types.Results<R> =>
+	value instanceof types.Results ||
+	(isObject(value) && Array.isArray(value.results) && "kept" in value);
+
+export const initializeResultType = <T, I>(
+	result: unknown,
+	documentType: AbstractType<T>,
+	indexedType: AbstractType<I>,
+) => {
+	if (isResultValue(result)) {
+		result.init(documentType);
+		return;
+	}
+	(result as types.ResultIndexedValue<I>).init(indexedType);
+};