@peerbit/document-interface 6.0.7-0691c73

package/src/query.ts

@@ -0,0 +1,478 @@
+import {
+	type AbstractType,
+	deserialize,
+	field,
+	fixedArray,
+	serialize,
+	variant,
+	vec
+} from "@dao-xyz/borsh";
+
+import { randomBytes, sha256Base64Sync, toBase64 } from "@peerbit/crypto";
+import {
+	BigUnsignedIntegerValue,
+	IntegerValue,
+	UnsignedIntegerValue
+} from "./id.js";
+
+export enum Compare {
+	Equal = 0,
+	Greater = 1,
+	GreaterOrEqual = 2,
+	Less = 3,
+	LessOrEqual = 4
+}
+export const compare = (
+	test: bigint | number,
+	compare: Compare,
+	value: bigint | number
+) => {
+	switch (compare) {
+		case Compare.Equal:
+			return test == value; // == because with want bigint == number at some cases
+		case Compare.Greater:
+			return test > value;
+		case Compare.GreaterOrEqual:
+			return test >= value;
+		case Compare.Less:
+			return test < value;
+		case Compare.LessOrEqual:
+			return test <= value;
+		default:
+			console.warn("Unexpected compare");
+			return false;
+	}
+};
+
+/// ----- QUERY -----
+
+export abstract class Query {
+	clone() {
+		return deserialize(serialize(this), this.constructor) as this;
+	}
+}
+
+export enum SortDirection {
+	ASC = 0,
+	DESC = 1
+}
+
+@variant(0)
+export class Sort {
+	@field({ type: vec("string") })
+	key: string[];
+
+	@field({ type: "u8" })
+	direction: SortDirection;
+
+	constructor(properties: {
+		key: string[] | string;
+		direction?: SortDirection;
+	}) {
+		this.key = Array.isArray(properties.key)
+			? properties.key
+			: [properties.key];
+		this.direction = properties.direction || SortDirection.ASC;
+	}
+}
+
+export abstract class AbstractSearchRequest { }
+
+/**
+ * Search with query and collect with sort conditionss
+ */
+
+const toArray = <T>(arr: T | T[] | undefined) =>
+	(arr ? (Array.isArray(arr) ? arr : [arr]) : undefined) || [];
+
+@variant(0)
+export class SearchRequest extends AbstractSearchRequest {
+	@field({ type: fixedArray("u8", 32) })
+	id: Uint8Array; // Session id
+
+	@field({ type: vec(Query) })
+	query: Query[];
+
+	@field({ type: vec(Sort) })
+	sort: Sort[];
+
+	@field({ type: "u32" })
+	fetch: number;
+
+	constructor(props?: { query?: Query[] | Query; sort?: Sort[] | Sort }) {
+		super();
+		this.id = randomBytes(32);
+		this.query = toArray(props?.query);
+		this.sort = toArray(props?.sort);
+		this.fetch = 1;
+	}
+
+	private _idString: string;
+	get idString(): string {
+		return this._idString || (this._idString = sha256Base64Sync(this.id));
+	}
+}
+
+/**
+ * Collect documents from peers using 'collect' session ids. This is used for distributed sorting internally
+ */
+@variant(2)
+export class CollectNextRequest extends AbstractSearchRequest {
+	@field({ type: fixedArray("u8", 32) })
+	id: Uint8Array; // collect with id
+
+	@field({ type: "u32" })
+	amount: number; // number of documents to ask for
+
+	constructor(properties: { id: Uint8Array; amount: number }) {
+		super();
+		this.id = properties.id;
+		this.amount = properties.amount;
+	}
+
+	private _idString: string;
+	get idString(): string {
+		return this._idString || (this._idString = sha256Base64Sync(this.id));
+	}
+}
+
+@variant(3)
+export class CloseIteratorRequest extends AbstractSearchRequest {
+	@field({ type: fixedArray("u8", 32) })
+	id: Uint8Array; // collect with id
+
+	constructor(properties: { id: Uint8Array }) {
+		super();
+		this.id = properties.id;
+	}
+
+	private _idString: string;
+	get idString(): string {
+		return this._idString || (this._idString = sha256Base64Sync(this.id));
+	}
+}
+
+@variant(1)
+export abstract class LogicalQuery extends Query { }
+
+@variant(0)
+export class And extends LogicalQuery {
+	@field({ type: vec(Query) })
+	and: Query[];
+
+	constructor(and: Query[]) {
+		super();
+		this.and = and;
+	}
+}
+
+@variant(1)
+export class Or extends LogicalQuery {
+	@field({ type: vec(Query) })
+	or: Query[];
+
+	constructor(or: Query[]) {
+		super();
+		this.or = or;
+	}
+}
+
+@variant(2)
+export abstract class StateQuery extends Query { }
+
+@variant(1)
+export class StateFieldQuery extends StateQuery {
+	@field({ type: vec("string") })
+	key: string[];
+
+	constructor(props: { key: string[] | string }) {
+		super();
+		this.key = Array.isArray(props.key) ? props.key : [props.key];
+	}
+}
+
+@variant(1)
+export class ByteMatchQuery extends StateFieldQuery {
+	@field({ type: Uint8Array })
+	value: Uint8Array;
+
+	@field({ type: "u8" })
+	// @ts-ignore: unused
+	private _reserved: number; // Replcate MemoryCompare query with this?
+
+	constructor(props: { key: string[] | string; value: Uint8Array }) {
+		super(props);
+		this.value = props.value;
+		this._reserved = 0;
+	}
+
+	_valueString: string;
+	/**
+	 * value `asString`
+	 */
+	get valueString() {
+		return this._valueString ?? (this._valueString = toBase64(this.value));
+	}
+}
+
+export enum StringMatchMethod {
+	"exact" = 0,
+	"prefix" = 1,
+	"contains" = 2
+}
+
+@variant(2)
+export class StringMatch extends StateFieldQuery {
+	@field({ type: "string" })
+	value: string;
+
+	@field({ type: "u8" })
+	method: StringMatchMethod;
+
+	@field({ type: "bool" })
+	caseInsensitive: boolean;
+
+	constructor(props: {
+		key: string[] | string;
+		value: string;
+		method?: StringMatchMethod;
+		caseInsensitive?: boolean;
+	}) {
+		super(props);
+		this.value = props.value;
+		this.method = props.method ?? StringMatchMethod.exact;
+		this.caseInsensitive = props.caseInsensitive ?? false;
+	}
+}
+
+@variant(3)
+export class IntegerCompare extends StateFieldQuery {
+	@field({ type: "u8" })
+	compare: Compare;
+
+	@field({ type: IntegerValue })
+	value: IntegerValue;
+
+	constructor(props: {
+		key: string[] | string;
+		value: bigint | number | IntegerValue;
+		compare: Compare;
+	}) {
+		super(props);
+		if (props.value instanceof IntegerValue) {
+			this.value = props.value;
+		} else {
+			if (typeof props.value === "bigint") {
+				this.value = new BigUnsignedIntegerValue(props.value);
+			} else {
+				this.value = new UnsignedIntegerValue(props.value);
+			}
+		}
+
+		this.compare = props.compare;
+	}
+}
+
+@variant(4)
+export class MissingField extends StateFieldQuery {
+	constructor(props: { key: string[] | string }) {
+		super(props);
+	}
+}
+
+@variant(5)
+export class BoolQuery extends StateFieldQuery {
+	@field({ type: "bool" })
+	value: boolean;
+
+	constructor(props: { key: string[] | string; value: boolean }) {
+		super(props);
+		this.value = props.value;
+	}
+}
+
+// TODO MemoryCompareQuery can be replaces with ByteMatchQuery? Or Nesteed Queries + ByteMatchQuery?
+/* @variant(0)
+export class MemoryCompare {
+	@field({ type: Uint8Array })
+	bytes: Uint8Array;
+
+	@field({ type: "u64" })
+	offset: bigint;
+
+	constructor(opts?: { bytes: Uint8Array; offset: bigint }) {
+		if (opts) {
+			this.bytes = opts.bytes;
+			this.offset = opts.offset;
+		}
+	}
+}
+
+@variant(4)
+export class MemoryCompareQuery extends Query {
+	@field({ type: vec(MemoryCompare) })
+	compares: MemoryCompare[];
+
+	constructor(opts?: { compares: MemoryCompare[] }) {
+		super();
+		if (opts) {
+			this.compares = opts.compares;
+		}
+	}
+} */
+
+/// ----- RESULTS -----
+
+export abstract class Result { }
+
+@variant(0)
+export class Context {
+	@field({ type: "u64" })
+	created: bigint;
+
+	@field({ type: "u64" })
+	modified: bigint;
+
+	@field({ type: "string" })
+	head: string;
+
+	@field({ type: "string" })
+	gid: string;
+
+	constructor(properties: {
+		created: bigint;
+		modified: bigint;
+		head: string;
+		gid: string;
+	}) {
+		this.created = properties.created;
+		this.modified = properties.modified;
+		this.head = properties.head;
+		this.gid = properties.gid;
+	}
+}
+
+@variant(0)
+export class ResultWithSource<T> extends Result {
+	@field({ type: Uint8Array })
+	_source: Uint8Array;
+
+	@field({ type: Context })
+	context: Context;
+
+	_type: AbstractType<T>;
+	constructor(opts: {
+		source: Uint8Array;
+		context: Context;
+		value?: T;
+		indexed?: Record<string, any>;
+	}) {
+		super();
+		this._source = opts.source;
+		this.context = opts.context;
+		this._value = opts.value;
+		this.indexed = opts.indexed;
+	}
+
+	init(type: AbstractType<T>) {
+		this._type = type;
+	}
+
+	_value?: T;
+	get value(): T {
+		if (this._value) {
+			return this._value;
+		}
+		if (!this._source) {
+			throw new Error("Missing source binary");
+		}
+		this._value = deserialize(this._source, this._type);
+		return this._value;
+	}
+
+	indexed?: Record<string, any>;
+}
+
+export abstract class AbstractSearchResult<T> { }
+
+@variant(0)
+export class Results<T> extends AbstractSearchResult<T> {
+	@field({ type: vec(ResultWithSource) })
+	results: ResultWithSource<T>[];
+
+	@field({ type: "u64" })
+	kept: bigint; // how many results that were not sent, but can be collected later
+
+	constructor(properties: { results: ResultWithSource<T>[]; kept: bigint }) {
+		super();
+		this.kept = properties.kept;
+		this.results = properties.results;
+	}
+}
+
+@variant(1)
+export class NoAccess extends AbstractSearchResult<any> { }
+
+/* @variant(5)
+export class LogQuery extends Query { } */
+
+/**
+ * Find logs that can be decrypted by certain keys
+ */
+/* 
+@variant(0)
+export class EntryEncryptedByQuery
+	extends LogQuery
+	implements
+	EntryEncryptionTemplate<
+		X25519PublicKey[],
+		X25519PublicKey[],
+		X25519PublicKey[],
+		X25519PublicKey[]
+	>
+{
+	@field({ type: vec(X25519PublicKey) })
+	meta: X25519PublicKey[];
+
+	@field({ type: vec(X25519PublicKey) })
+	payload: X25519PublicKey[];
+
+	@field({ type: vec(X25519PublicKey) })
+	next: X25519PublicKey[];
+
+	@field({ type: vec(X25519PublicKey) })
+	signatures: X25519PublicKey[];
+
+	constructor(properties?: {
+		meta: X25519PublicKey[];
+		next: X25519PublicKey[];
+		payload: X25519PublicKey[];
+		signatures: X25519PublicKey[];
+	}) {
+		super();
+		if (properties) {
+			this.metadata = properties.metadata;
+			this.payload = properties.payload;
+			this.next = properties.next;
+			this.signatures = properties.signatures;
+		}
+	}
+}
+
+@variant(1)
+export class SignedByQuery extends LogQuery {
+	@field({ type: vec(PublicSignKey) })
+	_publicKeys: PublicSignKey[];
+
+	constructor(properties: { publicKeys: PublicSignKey[] }) {
+		super();
+		if (properties) {
+			this._publicKeys = properties.publicKeys;
+		}
+	}
+
+	get publicKeys() {
+		return this._publicKeys;
+	}
+}
+ */

package/src/store.ts

@@ -0,0 +1,5 @@
+import { SearchRequest } from "./query.js";
+
+export type IDocumentStore<T> = {
+	index: { search: (query: SearchRequest) => Promise<T[]> };
+};

package/src/utils.ts

@@ -0,0 +1,65 @@
+import { Context, Sort, SortDirection } from "./query.js";
+
+export const stringArraysEquals = (
+	a: string[] | string,
+	b: string[] | string
+) => {
+	if (a.length !== b.length) {
+		return false;
+	}
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) {
+			return false;
+		}
+	}
+	return true;
+};
+
+export const resolvedSort = async <
+	Q extends { indexed: Record<string, any>; context: Context }
+>(
+	arr: Q[],
+	sorts: Sort[]
+) => {
+	arr.sort((a, b) => extractSortCompare(a.indexed, b.indexed, sorts));
+	return arr;
+};
+
+export const extractSortCompare = (
+	a: Record<string, any>,
+	b: Record<string, any>,
+	sorts: Sort[]
+) => {
+	for (const sort of sorts) {
+		const av = extractFieldValue(a, sort.key);
+		const bv = extractFieldValue(b, sort.key);
+		const cmp = sortCompare(av, bv);
+		if (cmp != 0) {
+			if (sort.direction === SortDirection.ASC) {
+				return cmp;
+			} else {
+				return -cmp;
+			}
+		}
+	}
+	return 0;
+};
+
+export const sortCompare = (av: any, bv: any) => {
+	if (typeof av === "string" && typeof bv === "string") {
+		return av.localeCompare(bv);
+	}
+	if (av < bv) {
+		return -1;
+	} else if (av > bv) {
+		return 1;
+	}
+	return 0;
+};
+
+export const extractFieldValue = <T>(doc: any, path: string[]): T => {
+	for (let i = 0; i < path.length; i++) {
+		doc = doc[path[i]];
+	}
+	return doc;
+};