ignotum 0.0.5 → 0.0.7

package/dist/runtime/{api-D2bsAz4T.d.ts → api-Dp4J-xt-.d.ts}

@@ -1,5 +1,4 @@
-import { i as InternalServerError, r as ErrorValue } from "./result-BgcHn25t.js";
-import "./id-Btwac71X-B9OeBzvq.js";
+import { a as InternalServerError, i as ErrorValue } from "./id-Btwac71X-DhnKYsjY.js";
 import { Effect, Schema } from "effect";
 //#region ../contracts/dist/runtime/sync.d.ts
 declare const FunctionAddress: Schema.TemplateLiteral<readonly ["api.", Schema.String, ".", Schema.String]>;
@@ -45,4 +44,4 @@ declare const functionPathOf: <Kind extends FunctionKind, Args, Success, Failure
 declare function createApi<Modules>(): Api<Modules>;
 //#endregion
 export { functionPathOf as i, FunctionReference as n, createApi as r, Api as t };
-//# sourceMappingURL=api-D2bsAz4T.d.ts.map
+//# sourceMappingURL=api-Dp4J-xt-.d.ts.map

package/dist/runtime/client.d.ts

@@ -1,5 +1,7 @@
-import { a as Match, c as SettledResult, i as InternalServerError, o as QueryResult$1, r as ErrorValue } from "./result-BgcHn25t.js";
-import { n as FunctionReference } from "./api-D2bsAz4T.js";
+import { a as InternalServerError, i as ErrorValue, l as SettledResult, o as Match, s as QueryResult$1 } from "./id-Btwac71X-DhnKYsjY.js";
+import { n as FunctionReference } from "./api-Dp4J-xt-.js";
+import { n as PaginationPage, t as PaginationOptions } from "./pagination-B1BzNkh8-BUSTbeSg.js";
+import "./pagination-BKPko9Hm.js";
 import { Dispatch, Reducer, StateUpdater, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useReducer, useRef, useState } from "preact/hooks";
 import { AnyComponent, Attributes, ClassAttributes, Component, ComponentChild, ComponentChildren, ComponentClass, ComponentConstructor, ComponentFactory, ComponentProps, ComponentType, ComponentType as ComponentType$1, Consumer, Context, ContextType, ErrorInfo, Fragment, FunctionComponent, FunctionalComponent, JSX, Key, PreactConsumer, PreactContext, PreactDOMAttributes, PreactProvider, Provider, Ref, RefCallback, RefObject, RenderableProps, TargetedAnimationEvent, TargetedClipboardEvent, TargetedCommandEvent, TargetedCompositionEvent, TargetedDragEvent, TargetedEvent, TargetedFocusEvent, TargetedInputEvent, TargetedKeyboardEvent, TargetedMouseEvent, TargetedPictureInPictureEvent, TargetedPointerEvent, TargetedSnapEvent, TargetedSubmitEvent, TargetedToggleEvent, TargetedTouchEvent, TargetedTransitionEvent, TargetedUIEvent, TargetedWheelEvent, VNode, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray } from "preact";
 //#region src/client/query.d.ts
@@ -15,6 +17,21 @@ declare const Query: {
 declare function useQuery<Success, Failure extends ErrorValue>(reference: FunctionReference<"Query", void, Success, Failure>): QueryResult$1<Success, Failure>;
 declare function useQuery<Success, Failure extends ErrorValue>(reference: FunctionReference<"Query", void, Success, Failure>, args: QuerySkip): QueryResult$1<Success, Failure>;
 declare function useQuery<Args extends object, Success, Failure extends ErrorValue>(reference: FunctionReference<"Query", Args, Success, Failure>, args: NoInfer<Args> | QuerySkip): QueryResult$1<Success, Failure>;
+type PaginationStatus = "CanLoadMore" | "Exhausted" | "LoadingMore";
+interface PaginatedQueryValue<Item> {
+  readonly items: ReadonlyArray<Item>;
+  readonly loadMore: () => void;
+  readonly status: PaginationStatus;
+}
+interface PaginatedQueryOptions {
+  readonly pageSize?: number;
+}
+type PaginationArguments = {
+  readonly pagination: PaginationOptions;
+};
+type ApplicationPaginationArguments<Args extends PaginationArguments> = Omit<Args, "pagination">;
+declare function usePaginatedQuery<Args extends PaginationArguments, Item, Failure extends ErrorValue>(reference: keyof ApplicationPaginationArguments<Args> extends never ? FunctionReference<"Query", Args, PaginationPage<Item>, Failure> : never): QueryResult$1<PaginatedQueryValue<Item>, Failure>;
+declare function usePaginatedQuery<Args extends PaginationArguments, Item, Failure extends ErrorValue>(reference: FunctionReference<"Query", Args, PaginationPage<Item>, Failure>, args: NoInfer<ApplicationPaginationArguments<Args>> | QuerySkip, options?: PaginatedQueryOptions): QueryResult$1<PaginatedQueryValue<Item>, Failure>;
 type Mutation<Args, Success, Failure extends ErrorValue> = [Args] extends [void] ? () => Promise<SettledResult<Success, Failure>> : (args: Args) => Promise<SettledResult<Success, Failure>>;
 declare const useMutation: <Args extends object | void, Success, Failure extends ErrorValue>(reference: FunctionReference<"Mutation", Args, Success, Failure>) => Mutation<Args, Success, Failure>;
 //#endregion
@@ -32,5 +49,5 @@ declare const Result: {
 type Result<Value, Error extends ErrorValue> = SettledResult<Value, Error>;
 type QueryResult<Value, Error extends ErrorValue> = QueryResult$1<Value, Error>;
 //#endregion
-export { type AnyComponent, type AppDefinition, type Attributes, type ClassAttributes, Component, type ComponentChild, type ComponentChildren, type ComponentClass, type ComponentConstructor, type ComponentFactory, type ComponentProps, type ComponentType, type Consumer, type Context, type ContextType, type Dispatch, type ErrorInfo, Fragment, type FunctionComponent, type FunctionalComponent, type InternalServerError, type JSX, type Key, type PreactConsumer, type PreactContext, type PreactDOMAttributes, type PreactProvider, type Provider, Query, QueryResult, type QuerySkip, type Reducer, type Ref, type RefCallback, type RefObject, type RenderableProps, Result, type StateUpdater, type TargetedAnimationEvent, type TargetedClipboardEvent, type TargetedCommandEvent, type TargetedCompositionEvent, type TargetedDragEvent, type TargetedEvent, type TargetedFocusEvent, type TargetedInputEvent, type TargetedKeyboardEvent, type TargetedMouseEvent, type TargetedPictureInPictureEvent, type TargetedPointerEvent, type TargetedSnapEvent, type TargetedSubmitEvent, type TargetedToggleEvent, type TargetedTouchEvent, type TargetedTransitionEvent, type TargetedUIEvent, type TargetedWheelEvent, type VNode, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, useQuery, useReducer, useRef, useState };
+export { type AnyComponent, type AppDefinition, type Attributes, type ClassAttributes, Component, type ComponentChild, type ComponentChildren, type ComponentClass, type ComponentConstructor, type ComponentFactory, type ComponentProps, type ComponentType, type Consumer, type Context, type ContextType, type Dispatch, type ErrorInfo, Fragment, type FunctionComponent, type FunctionalComponent, type InternalServerError, type JSX, type Key, type PaginatedQueryOptions, type PaginatedQueryValue, type PaginationStatus, type PreactConsumer, type PreactContext, type PreactDOMAttributes, type PreactProvider, type Provider, Query, QueryResult, type QuerySkip, type Reducer, type Ref, type RefCallback, type RefObject, type RenderableProps, Result, type StateUpdater, type TargetedAnimationEvent, type TargetedClipboardEvent, type TargetedCommandEvent, type TargetedCompositionEvent, type TargetedDragEvent, type TargetedEvent, type TargetedFocusEvent, type TargetedInputEvent, type TargetedKeyboardEvent, type TargetedMouseEvent, type TargetedPictureInPictureEvent, type TargetedPointerEvent, type TargetedSnapEvent, type TargetedSubmitEvent, type TargetedToggleEvent, type TargetedTouchEvent, type TargetedTransitionEvent, type TargetedUIEvent, type TargetedWheelEvent, type VNode, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
 //# sourceMappingURL=client.d.ts.map

package/dist/runtime/client.js

@@ -1,12 +1,23 @@
 import { a as InvocationId, c as SubscriptionId, i as IdAlphabet, l as TableId, n as DeploymentId, r as GeneratedId, s as RuntimeRequestNonce, t as AppId } from "./id-D570vudg.js";
-import { g as encodeTransportObject, h as decodeTransportValue, l as failureFromWire, s as Result$1, t as ValueDescriptor, u as pending } from "./descriptor-t6BOEGw9-BTHR-ZMv.js";
+import { d as failureFromWire, f as inspectResult, l as Result$1, o as PaginationPageSize, p as pending, t as ValueDescriptor, v as decodeTransportValue, y as encodeTransportObject } from "./descriptor-t6BOEGw9-C1rwYIlx.js";
 import { a as FunctionAddress, c as ServerMessageJson, d as WireSuccess, f as AppStateRevision, i as DeploymentChangedCloseCode, l as WireFailure, m as InvocationKey, n as functionPathOf, o as Operation, p as DeploymentGeneration, r as ClientMessageJson, s as ProtocolErrorCode, u as WireResult } from "./api-DtX8qPrq.js";
-import { Array, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema, String } from "effect";
-import { useCallback, useContext, useDebugValue, useDebugValue as useDebugValue$1, useEffect, useEffect as useEffect$1, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMemo as useMemo$1, useReducer, useRef, useState, useState as useState$1 } from "preact/hooks";
+import { Array as Array$1, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema, String } from "effect";
+import { useCallback, useCallback as useCallback$1, useContext, useDebugValue, useDebugValue as useDebugValue$1, useEffect, useEffect as useEffect$1, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMemo as useMemo$1, useReducer, useRef, useState, useState as useState$1 } from "preact/hooks";
 import * as Socket from "effect/unstable/socket/Socket";
 import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
 import { customAlphabet } from "nanoid";
 import { Component, Fragment, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray } from "preact";
+//#region ../contracts/dist/json.js
+const encodeScalar = (value) => Schema.decodeSync(Schema.String)(JSON.stringify(value));
+const encodeCanonicalJson = (value) => {
+	if (value === null || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return encodeScalar(value);
+	if (Predicate.isObject(value)) return `{${Array$1.map(Array$1.sort(String.Order)(Object.keys(value)), (key) => {
+		const field = Schema.decodeUnknownSync(Schema.Json)(value[key]);
+		return `${encodeScalar(key)}:${encodeCanonicalJson(field)}`;
+	}).join(",")}}`;
+	return `[${Schema.decodeUnknownSync(Schema.Array(Schema.Json))(value).map(encodeCanonicalJson).join(",")}]`;
+};
+//#endregion
 //#region src/client/errors.ts
 /** @effect-diagnostics globalConsole:skip-file */
 var ConnectionUnavailable = class extends Schema.TaggedError()("ConnectionUnavailable", {
@@ -55,16 +66,14 @@ const skip = Object.freeze(new QuerySkipToken());
 const Query = { skip };
 const isQuerySkip = (value) => value === skip;
 //#endregion
-//#region ../contracts/dist/json.js
-const encodeScalar = (value) => Schema.decodeSync(Schema.String)(JSON.stringify(value));
-const encodeCanonicalJson = (value) => {
-	if (value === null || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return encodeScalar(value);
-	if (Predicate.isObject(value)) return `{${Array.map(Array.sort(String.Order)(Object.keys(value)), (key) => {
-		const field = Schema.decodeUnknownSync(Schema.Json)(value[key]);
-		return `${encodeScalar(key)}:${encodeCanonicalJson(field)}`;
-	}).join(",")}}`;
-	return `[${Schema.decodeUnknownSync(Schema.Array(Schema.Json))(value).map(encodeCanonicalJson).join(",")}]`;
-};
+//#region ../contracts/dist/runtime/index.js
+const IndexIdentity = Schema.String.pipe(Schema.brand("ignotum/runtime/IndexIdentity"));
+const EncodedIndexKey = Schema.String.check(Schema.isPattern(/^(?:[0-9a-f]{2})*$/)).pipe(Schema.brand("ignotum/runtime/EncodedIndexKey"));
+Schema.Union([
+	Schema.Boolean,
+	Schema.Finite,
+	Schema.String
+]);
 Schema.String.pipe(Schema.brand("ignotum/hosted/QueryKey"));
 const TableDependency = Schema.Struct({
 	type: Schema.Literal("Table"),
@@ -75,9 +84,32 @@ const DocumentDependency = Schema.Struct({
 	tableId: TableId,
 	id: GeneratedId
 });
-const DependencyKey = Schema.Union([TableDependency, DocumentDependency]);
-const DependencySet = Schema.Array(DependencyKey);
-const InvalidationSet = Schema.Array(DependencyKey);
+const IndexRangeDependency = Schema.Struct({
+	type: Schema.Literal("IndexRange"),
+	tableId: TableId,
+	index: IndexIdentity,
+	lower: Schema.optional(EncodedIndexKey),
+	upper: Schema.optional(EncodedIndexKey)
+});
+const IndexPointInvalidation = Schema.Struct({
+	type: Schema.Literal("IndexPoint"),
+	tableId: TableId,
+	index: IndexIdentity,
+	key: EncodedIndexKey
+});
+const ReadDependency = Schema.Union([
+	TableDependency,
+	DocumentDependency,
+	IndexRangeDependency
+]);
+const WriteInvalidation = Schema.Union([
+	TableDependency,
+	DocumentDependency,
+	IndexPointInvalidation
+]);
+Schema.Union([ReadDependency, IndexPointInvalidation]);
+const DependencySet = Schema.Array(ReadDependency);
+const InvalidationSet = Schema.Array(WriteInvalidation);
 const RuntimeQueryResult = Schema.Struct({
 	type: Schema.Literal("Query"),
 	result: WireResult,
@@ -196,6 +228,7 @@ const Sha256 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)).pipe(Sche
 const ArtifactKind = Schema.Literals([
 	"ClientAsset",
 	"ClientDocument",
+	"ClientManifest",
 	"ClientPublicFile",
 	"ClientShell",
 	"FunctionBundle",
@@ -218,23 +251,41 @@ const ArtifactFile = Schema.Struct({
 });
 const ClientRoute = Schema.Struct({
 	pathname: ClientPath,
-	artifact: ArtifactPath
+	artifact: ArtifactReference
 });
 Schema.Struct({
 	formatVersion: Schema.Literal(1),
-	client: Schema.Struct({ routes: Schema.Array(ClientRoute) }),
 	files: Schema.Array(ArtifactFile)
 });
+Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	shell: ArtifactReference,
+	routes: Schema.Array(ClientRoute)
+});
+const ClientRoutingRoute = Schema.Struct({
+	pathname: ClientPath,
+	artifact: ArtifactPath
+});
+Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	shell: ArtifactPath,
+	routes: Schema.Array(ClientRoutingRoute)
+});
 const SchemaSnapshotField = Schema.Struct({
 	name: Schema.String,
 	value: ValueDescriptor
 });
+const SchemaSnapshotIndex = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(Schema.String)
+});
 const SchemaSnapshotTable = Schema.Struct({
 	name: Schema.String,
-	fields: Schema.Array(SchemaSnapshotField)
+	fields: Schema.Array(SchemaSnapshotField),
+	indexes: Schema.Array(SchemaSnapshotIndex)
 });
 Schema.Struct({
-	formatVersion: Schema.Literal(1),
+	formatVersion: Schema.Literal(2),
 	tables: Schema.Array(SchemaSnapshotTable)
 });
 const ServerFunctionArtifact = Schema.Struct({
@@ -249,16 +300,25 @@ Schema.Struct({
 	functions: Schema.Array(ServerFunctionArtifact)
 });
 ArtifactPath.make("inventory.json");
-ArtifactPath.make("client/_shell.html");
-`${ArtifactPath.make("client/_ignotum/assets")}`;
+ArtifactPath.make("client/manifest.json");
+ArtifactPath.make("client/shell.html");
+`${ArtifactPath.make("client/assets")}`;
+`${ArtifactPath.make("client/routes")}`;
 ArtifactPath.make("server/manifest.json");
 ArtifactPath.make("server/schema.json");
 //#endregion
 //#region ../contracts/dist/runtime/transport.js
 const runtimeInvocationPath = "/v1/invoke";
 const runtimeRevisionPath = "/v1/revision";
+const runtimeIndexPreparePath = "/v1/indexes/prepare";
+const runtimeIndexCommitPath = "/v1/indexes/commit";
 const appSyncPath = `/_ignotum/v1/sync`;
-const RuntimeRequestPath = Schema.Literals([runtimeInvocationPath, runtimeRevisionPath]);
+const RuntimeRequestPath = Schema.Literals([
+	runtimeInvocationPath,
+	runtimeRevisionPath,
+	runtimeIndexPreparePath,
+	runtimeIndexCommitPath
+]);
 const RuntimeRequestTimestamp = Schema.FiniteFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ignotum/runtime/RequestTimestamp"));
 const RuntimeRequestSignature = Sha256.pipe(Schema.brand("ignotum/runtime/RequestSignature"));
 Schema.Struct({
@@ -277,6 +337,11 @@ Schema.Struct({
 	deploymentId: Schema.optional(DeploymentId),
 	bodySha256: Sha256
 });
+Schema.Struct({
+	appId: AppId,
+	deploymentId: DeploymentId
+});
+Schema.Struct({ completed: Schema.Literal(true) });
 const RuntimeErrorCode = Schema.Literals([
 	"InvalidRequest",
 	"InvalidSignature",
@@ -603,6 +668,134 @@ function useQuery(reference, args) {
 	if (Schema.is(ClientInfrastructureError)(result)) throw result;
 	return result;
 }
+function usePaginatedQuery(reference, args, options = {}) {
+	const functionPath = functionPathOf(reference);
+	const skipped = isQuerySkip(args);
+	const input = args === void 0 || skipped ? {} : args;
+	const jsonArgs = encodeTransportObject(input);
+	const pageSize = Schema.decodeSync(PaginationPageSize)(options.pageSize ?? 20);
+	const identity = skipped ? `skip:${functionPath}` : syncClientInternals.queryIdentity(functionPath, jsonArgs);
+	const [requestedPages, setRequestedPages] = useState$1(1);
+	const [refresh, setRefresh] = useState$1(0);
+	const [state, setState] = useState$1(() => ({
+		identity,
+		result: pending()
+	}));
+	const loadMore = useCallback$1(() => setRequestedPages((count) => count + 1), []);
+	useDebugValue$1({
+		args: input,
+		function: functionPath,
+		result: state.result
+	});
+	useEffect$1(() => {
+		setRequestedPages(1);
+		setState({
+			identity,
+			result: pending()
+		});
+	}, [identity, pageSize]);
+	useEffect$1(() => {
+		if (skipped) return;
+		let active = true;
+		const releases = [];
+		syncRuntime.runPromise(Effect.gen(function* () {
+			const client = yield* SyncClient;
+			const items = [];
+			let cursor = null;
+			for (let pageNumber = 0; pageNumber < requestedPages; pageNumber += 1) {
+				const pageArgs = encodeTransportObject({
+					...input,
+					pagination: {
+						cursor,
+						pageSize
+					}
+				});
+				const observer = yield* client.observe(functionPath, pageArgs);
+				if (!active) {
+					yield* observer.release;
+					return;
+				}
+				const releaseSubscription = observer.subscribe(() => {
+					if (active) setRefresh((version) => version + 1);
+				});
+				releases.push(() => {
+					releaseSubscription();
+					syncRuntime.runFork(observer.release);
+				});
+				const snapshot = observer.getSnapshot();
+				if (Schema.is(ClientInfrastructureError)(snapshot)) {
+					setState({
+						identity,
+						result: snapshot
+					});
+					return;
+				}
+				const inspected = inspectResult(snapshot);
+				if (inspected === void 0) {
+					setState({
+						identity,
+						result: items.length === 0 ? pending() : Result$1.succeed({
+							items,
+							loadMore,
+							status: "LoadingMore"
+						})
+					});
+					return;
+				}
+				if (inspected.type === "Failure") {
+					setState({
+						identity,
+						result: snapshot
+					});
+					return;
+				}
+				const page = inspected.value;
+				items.push(...page.items);
+				cursor = page.nextCursor;
+				if (cursor === null) {
+					setState({
+						identity,
+						result: Result$1.succeed({
+							items,
+							loadMore,
+							status: "Exhausted"
+						})
+					});
+					return;
+				}
+			}
+			setState({
+				identity,
+				result: Result$1.succeed({
+					items,
+					loadMore,
+					status: "CanLoadMore"
+				})
+			});
+		})).catch((error) => {
+			if (active && Schema.is(ClientInfrastructureError)(error)) setState({
+				identity,
+				result: error
+			});
+		});
+		return () => {
+			active = false;
+			for (const release of releases) release();
+		};
+	}, [
+		functionPath,
+		identity,
+		loadMore,
+		pageSize,
+		refresh,
+		requestedPages,
+		skipped
+	]);
+	if (skipped || state.identity !== identity) return pending();
+	const result = state.result;
+	if (Schema.is(ClientInfrastructureError)(result)) throw result;
+	return result;
+}
 const useMutation = (reference) => useMemo$1(() => {
 	const mutate = (args) => {
 		const functionPath = functionPathOf(reference);
@@ -632,6 +825,6 @@ const app = (definition) => {
 //#region src/client/index.ts
 const Result = { match: Result$1.match };
 //#endregion
-export { Component, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, useQuery, useReducer, useRef, useState };
+export { Component, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
 
 //# sourceMappingURL=client.js.map