@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.2

package/dist/QueryStreamPagination.js

@@ -0,0 +1,172 @@
+import { Order } from "./QueryStreamKeyValues.js";
+import * as Schema from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+import * as Chunk from "effect/Chunk";
+//#region src/QueryStreamPagination.ts
+const PageSize = Schema.Natural.pipe(Schema.brand("~@confect/server/QueryStreamPagination/PageSize"));
+/**
+* @experimental
+*/
+var InvalidPageSizeError = class extends Data.TaggedError("InvalidPageSizeError") {
+	get message() {
+		return `QueryStream.paginate: numItems must be a nonnegative integer (received ${this.numItems})`;
+	}
+};
+/**
+* @experimental
+*/
+var EmptyInitialPageError = class extends Data.TaggedError("EmptyInitialPageError") {
+	get message() {
+		return "QueryStream.paginate: numItems of 0 with a null cursor is not supported";
+	}
+};
+/**
+* @experimental
+*/
+const Range = Data.taggedEnum();
+/**
+* @experimental
+*/
+const Start = Data.taggedEnum();
+const Request = Data.taggedEnum();
+/**
+* @experimental
+*/
+const parseRequest = (numItems, start, range) => Result.flatMap(Schema.decodeResult(PageSize)(numItems).pipe(Result.mapError(() => new InvalidPageSizeError({ numItems }))), (size) => size === 0 ? Start.$match(start, {
+	Beginning: () => Result.fail(new EmptyInitialPageError()),
+	After: ({ cursor }) => Result.succeed(Request.Unchanged({ cursor }))
+}) : Result.succeed(Request.Scan({
+	numItems: size,
+	after: Start.$match(start, {
+		Beginning: () => Option.none(),
+		After: ({ key }) => Option.some(key)
+	}),
+	range
+})));
+const append = (progress, key) => Option.match(progress, {
+	onNone: () => Chunk.of(key),
+	onSome: (keys) => Chunk.append(keys, key)
+});
+const midpoint = (progress) => Option.getOrElse(Chunk.get(progress, Math.floor((Chunk.size(progress) - 1) / 2)), () => Chunk.headNonEmpty(progress));
+const QueryStreamPagination = Data.taggedEnum();
+/**
+* @experimental
+*/
+const initial = () => QueryStreamPagination.Reading({
+	page: Chunk.empty(),
+	progress: Option.none()
+});
+/**
+* @experimental
+*/
+const record = (request, self, doc, key, readLimit) => Match.value(self).pipe(Match.tagsExhaustive({
+	Reading: (reading) => {
+		const progress = append(reading.progress, key);
+		const page = Option.match(doc, {
+			onNone: () => reading.page,
+			onSome: (value) => Chunk.append(reading.page, value)
+		});
+		const continueReading = () => QueryStreamPagination.Reading({
+			page,
+			progress: Option.some(progress)
+		});
+		return readLimit ? QueryStreamPagination.ReadLimit({
+			page,
+			progress
+		}) : Range.$match(request.range, {
+			Unpinned: () => Chunk.size(page) >= request.numItems ? QueryStreamPagination.ItemLimit({
+				page,
+				progress
+			}) : continueReading(),
+			ThroughKey: continueReading,
+			ThroughEnd: continueReading
+		});
+	},
+	ItemLimit: () => self,
+	ReadLimit: () => self
+}));
+const Continuation = Data.taggedEnum();
+/**
+* @experimental
+*/
+var UnsafePageBoundaryError = class extends Data.TaggedError("UnsafePageBoundaryError") {
+	get message() {
+		return Match.value(this.reason).pipe(Match.when("NoProgress", () => "The read budget stopped the page before any key was scanned"), Match.when("NoInteriorSplit", () => "The read budget stopped the page without an interior split key"), Match.exhaustive);
+	}
+};
+const SOFT_MAX_SCAN_LENGTH = 16e3;
+/**
+* Decide the page result without reading a stream or serializing a cursor.
+*
+* @experimental
+*/
+const finish = (request, self, upstreamStopped) => {
+	const page = Chunk.toArray(self.page);
+	const stopped = (progress, readLimit) => Result.flatMap(Result.fromOption(progress, () => new UnsafePageBoundaryError({ reason: "NoProgress" })), (scanned) => {
+		const splitKey = midpoint(scanned);
+		const atEnd = Range.$match(request.range, {
+			Unpinned: () => false,
+			ThroughEnd: () => false,
+			ThroughKey: ({ key }) => Order("asc")(splitKey.values, key.values) === 0
+		});
+		if (readLimit && atEnd) return Result.fail(new UnsafePageBoundaryError({ reason: "NoInteriorSplit" }));
+		const key = Chunk.lastNonEmpty(scanned);
+		if (readLimit) return Result.succeed({
+			_tag: "SplitRequired",
+			page,
+			continuation: Continuation.Key({ key }),
+			splitKey
+		});
+		return Result.succeed(Chunk.size(scanned) >= SOFT_MAX_SCAN_LENGTH ? {
+			_tag: "SplitRecommended",
+			page,
+			continuation: Continuation.Key({ key }),
+			splitKey
+		} : {
+			_tag: "Continue",
+			page,
+			key
+		});
+	});
+	const exhausted = (progress) => {
+		const finishRange = (continuation, pinned) => {
+			const split = Option.filter(progress, (scanned) => pinned && (Chunk.size(scanned) >= SOFT_MAX_SCAN_LENGTH || page.length > request.numItems + 1));
+			return Option.match(split, {
+				onSome: (scanned) => ({
+					_tag: "SplitRecommended",
+					page,
+					continuation,
+					splitKey: midpoint(scanned)
+				}),
+				onNone: () => Continuation.$match(continuation, {
+					End: () => ({
+						_tag: "Done",
+						page
+					}),
+					Key: ({ key }) => ({
+						_tag: "Continue",
+						page,
+						key
+					})
+				})
+			});
+		};
+		return Range.$match(request.range, {
+			Unpinned: () => finishRange(Continuation.End(), false),
+			ThroughEnd: () => finishRange(Continuation.End(), true),
+			ThroughKey: ({ key }) => finishRange(Continuation.Key({ key }), true)
+		});
+	};
+	return Match.value(self).pipe(Match.tagsExhaustive({
+		Reading: ({ progress }) => upstreamStopped ? stopped(progress, true) : Result.succeed(exhausted(progress)),
+		ItemLimit: ({ progress }) => stopped(Option.some(progress), upstreamStopped),
+		ReadLimit: ({ progress }) => stopped(Option.some(progress), true)
+	}));
+};
+//#endregion
+export { EmptyInitialPageError, InvalidPageSizeError, Range, Start, UnsafePageBoundaryError, finish, initial, parseRequest, record };
+
+//# sourceMappingURL=QueryStreamPagination.js.map

package/dist/QueryStreamPagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamPagination.js","names":["QueryStreamKeyValues.Order"],"sources":["../src/QueryStreamPagination.ts"],"sourcesContent":["import * as Chunk from \"effect/Chunk\";\nimport * as Data from \"effect/Data\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport type * as QueryStreamKey from \"./QueryStreamKey\";\nimport * as QueryStreamKeyValues from \"./QueryStreamKeyValues\";\n\nconst PageSize = Schema.Natural.pipe(\n  Schema.brand(\"~@confect/server/QueryStreamPagination/PageSize\"),\n);\ntype PageSize = typeof PageSize.Type;\n\n/**\n * @experimental\n */\nexport class InvalidPageSizeError extends Data.TaggedError(\n  \"InvalidPageSizeError\",\n)<{\n  readonly numItems: number;\n}> {\n  override get message(): string {\n    return `QueryStream.paginate: numItems must be a nonnegative integer (received ${this.numItems})`;\n  }\n}\n\n/**\n * @experimental\n */\nexport class EmptyInitialPageError extends Data.TaggedError(\n  \"EmptyInitialPageError\",\n) {\n  override get message(): string {\n    return \"QueryStream.paginate: numItems of 0 with a null cursor is not supported\";\n  }\n}\n\n/**\n * @experimental\n */\nexport type Range = Data.TaggedEnum<{\n  Unpinned: {};\n  ThroughKey: { readonly key: QueryStreamKey.Complete };\n  ThroughEnd: {};\n}>;\n/**\n * @experimental\n */\nexport const Range = Data.taggedEnum<Range>();\n\n/**\n * @experimental\n */\nexport type Start = Data.TaggedEnum<{\n  Beginning: {};\n  After: {\n    readonly key: QueryStreamKey.Complete;\n    readonly cursor: string;\n  };\n}>;\n/**\n * @experimental\n */\nexport const Start = Data.taggedEnum<Start>();\n\n/**\n * @experimental\n */\nexport interface ScanRequest {\n  readonly numItems: PageSize;\n  readonly after: Option.Option<QueryStreamKey.Complete>;\n  readonly range: Range;\n}\n\n/**\n * @experimental\n */\nexport type Request = Data.TaggedEnum<{\n  Unchanged: { readonly cursor: string };\n  Scan: ScanRequest;\n}>;\nconst Request = Data.taggedEnum<Request>();\n\n/**\n * @experimental\n */\nexport const parseRequest = (\n  numItems: number,\n  start: Start,\n  range: Range,\n): Result.Result<Request, InvalidPageSizeError | EmptyInitialPageError> =>\n  Result.flatMap(\n    Schema.decodeResult(PageSize)(numItems).pipe(\n      Result.mapError(() => new InvalidPageSizeError({ numItems })),\n    ),\n    (size): Result.Result<Request, EmptyInitialPageError> =>\n      size === 0\n        ? Start.$match(start, {\n            Beginning: () => Result.fail(new EmptyInitialPageError()),\n            After: ({ cursor }) =>\n              Result.succeed(Request.Unchanged({ cursor })),\n          })\n        : Result.succeed(\n            Request.Scan({\n              numItems: size,\n              after: Start.$match(start, {\n                Beginning: () => Option.none(),\n                After: ({ key }) => Option.some(key),\n              }),\n              range,\n            }),\n          ),\n  );\n\n/**\n * A nonempty scan, including filtered markers.\n */\ntype Progress = Chunk.NonEmptyChunk<QueryStreamKey.Complete>;\nconst append = (\n  progress: Option.Option<Progress>,\n  key: QueryStreamKey.Complete,\n): Progress =>\n  Option.match(progress, {\n    onNone: () => Chunk.of(key),\n    onSome: (keys) => Chunk.append(keys, key),\n  });\nconst midpoint = (progress: Progress): QueryStreamKey.Complete =>\n  Option.getOrElse(\n    Chunk.get(progress, Math.floor((Chunk.size(progress) - 1) / 2)),\n    () => Chunk.headNonEmpty(progress),\n  );\n\ninterface Stopped<Doc> {\n  readonly page: Chunk.Chunk<Doc>;\n  readonly progress: Progress;\n}\n\n/**\n * @experimental\n */\nexport type QueryStreamPagination<Doc> = Data.TaggedEnum<{\n  Reading: {\n    readonly page: Chunk.Chunk<Doc>;\n    readonly progress: Option.Option<Progress>;\n  };\n  ItemLimit: Stopped<Doc>;\n  ReadLimit: Stopped<Doc>;\n}>;\ninterface PaginationDefinition extends Data.TaggedEnum.WithGenerics<1> {\n  readonly taggedEnum: QueryStreamPagination<this[\"A\"]>;\n}\nconst QueryStreamPagination = Data.taggedEnum<PaginationDefinition>();\n\n/**\n * @experimental\n */\nexport const initial = <Doc>(): QueryStreamPagination<Doc> =>\n  QueryStreamPagination.Reading({\n    page: Chunk.empty<Doc>(),\n    progress: Option.none(),\n  });\n\n/**\n * @experimental\n */\nexport const record = <Doc>(\n  request: ScanRequest,\n  self: QueryStreamPagination<Doc>,\n  doc: Option.Option<Doc>,\n  key: QueryStreamKey.Complete,\n  readLimit: boolean,\n): QueryStreamPagination<Doc> =>\n  Match.value(self).pipe(\n    Match.tagsExhaustive({\n      Reading: (reading) => {\n        const progress = append(reading.progress, key);\n        const page = Option.match(doc, {\n          onNone: () => reading.page,\n          onSome: (value) => Chunk.append(reading.page, value),\n        });\n        const continueReading = () =>\n          QueryStreamPagination.Reading({\n            page,\n            progress: Option.some(progress),\n          });\n        return readLimit\n          ? QueryStreamPagination.ReadLimit({ page, progress })\n          : Range.$match(request.range, {\n              Unpinned: () =>\n                Chunk.size(page) >= request.numItems\n                  ? QueryStreamPagination.ItemLimit({ page, progress })\n                  : continueReading(),\n              ThroughKey: continueReading,\n              ThroughEnd: continueReading,\n            });\n      },\n      ItemLimit: () => self,\n      ReadLimit: () => self,\n    }),\n  );\n\n/**\n * @experimental\n */\nexport type Continuation = Data.TaggedEnum<{\n  End: {};\n  Key: { readonly key: QueryStreamKey.Complete };\n}>;\nconst Continuation = Data.taggedEnum<Continuation>();\n\ninterface Split<Doc> {\n  readonly page: ReadonlyArray<Doc>;\n  readonly continuation: Continuation;\n  readonly splitKey: QueryStreamKey.Complete;\n}\n\n/**\n * @experimental\n */\nexport type Outcome<Doc> = Data.TaggedEnum<{\n  Done: { readonly page: ReadonlyArray<Doc> };\n  Continue: {\n    readonly page: ReadonlyArray<Doc>;\n    readonly key: QueryStreamKey.Complete;\n  };\n  SplitRequired: Split<Doc>;\n  SplitRecommended: Split<Doc>;\n}>;\n\n/**\n * @experimental\n */\nexport class UnsafePageBoundaryError extends Data.TaggedError(\n  \"UnsafePageBoundaryError\",\n)<{\n  readonly reason: \"NoProgress\" | \"NoInteriorSplit\";\n}> {\n  override get message(): string {\n    return Match.value(this.reason).pipe(\n      Match.when(\n        \"NoProgress\",\n        () => \"The read budget stopped the page before any key was scanned\",\n      ),\n      Match.when(\n        \"NoInteriorSplit\",\n        () => \"The read budget stopped the page without an interior split key\",\n      ),\n      Match.exhaustive,\n    );\n  }\n}\n\nconst SOFT_MAX_SCAN_LENGTH = 16000;\n\n/**\n * Decide the page result without reading a stream or serializing a cursor.\n *\n * @experimental\n */\nexport const finish = <Doc>(\n  request: ScanRequest,\n  self: QueryStreamPagination<Doc>,\n  upstreamStopped: boolean,\n): Result.Result<Outcome<Doc>, UnsafePageBoundaryError> => {\n  const page = Chunk.toArray(self.page);\n  const stopped = (\n    progress: Option.Option<Progress>,\n    readLimit: boolean,\n  ): Result.Result<Outcome<Doc>, UnsafePageBoundaryError> =>\n    Result.flatMap(\n      Result.fromOption(\n        progress,\n        () => new UnsafePageBoundaryError({ reason: \"NoProgress\" }),\n      ),\n      (scanned): Result.Result<Outcome<Doc>, UnsafePageBoundaryError> => {\n        const splitKey = midpoint(scanned);\n        const atEnd = Range.$match(request.range, {\n          Unpinned: () => false,\n          ThroughEnd: () => false,\n          ThroughKey: ({ key }) =>\n            QueryStreamKeyValues.Order(\"asc\")(splitKey.values, key.values) ===\n            0,\n        });\n        if (readLimit && atEnd) {\n          return Result.fail(\n            new UnsafePageBoundaryError({ reason: \"NoInteriorSplit\" }),\n          );\n        }\n        const key = Chunk.lastNonEmpty(scanned);\n        if (readLimit)\n          return Result.succeed({\n            _tag: \"SplitRequired\",\n            page,\n            continuation: Continuation.Key({ key }),\n            splitKey,\n          });\n        return Result.succeed(\n          Chunk.size(scanned) >= SOFT_MAX_SCAN_LENGTH\n            ? {\n                _tag: \"SplitRecommended\",\n                page,\n                continuation: Continuation.Key({ key }),\n                splitKey,\n              }\n            : { _tag: \"Continue\", page, key },\n        );\n      },\n    );\n  const exhausted = (progress: Option.Option<Progress>): Outcome<Doc> => {\n    const finishRange = (\n      continuation: Continuation,\n      pinned: boolean,\n    ): Outcome<Doc> => {\n      const split = Option.filter(\n        progress,\n        (scanned) =>\n          pinned &&\n          (Chunk.size(scanned) >= SOFT_MAX_SCAN_LENGTH ||\n            page.length > request.numItems + 1),\n      );\n      return Option.match(split, {\n        onSome: (scanned): Outcome<Doc> => ({\n          _tag: \"SplitRecommended\",\n          page,\n          continuation,\n          splitKey: midpoint(scanned),\n        }),\n        onNone: () =>\n          Continuation.$match(continuation, {\n            End: (): Outcome<Doc> => ({ _tag: \"Done\", page }),\n            Key: ({ key }): Outcome<Doc> => ({\n              _tag: \"Continue\",\n              page,\n              key,\n            }),\n          }),\n      });\n    };\n    return Range.$match(request.range, {\n      Unpinned: () => finishRange(Continuation.End(), false),\n      ThroughEnd: () => finishRange(Continuation.End(), true),\n      ThroughKey: ({ key }) => finishRange(Continuation.Key({ key }), true),\n    });\n  };\n  return Match.value(self).pipe(\n    Match.tagsExhaustive({\n      Reading: ({ progress }) =>\n        upstreamStopped\n          ? stopped(progress, true)\n          : Result.succeed(exhausted(progress)),\n      ItemLimit: ({ progress }) =>\n        stopped(Option.some(progress), upstreamStopped),\n      ReadLimit: ({ progress }) => stopped(Option.some(progress), true),\n    }),\n  );\n};\n"],"mappings":"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"}

package/dist/QueryStreamReadBudget.d.ts

@@ -0,0 +1,63 @@
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+/**
+ * @experimental
+ */
+export interface QueryStreamReadBudget {
+    readonly isUnlimited: Effect.Effect<boolean>;
+    readonly isStopped: Effect.Effect<boolean>;
+    readonly isExhausted: Effect.Effect<boolean>;
+    readonly getReadCounts: Effect.Effect<ReadCounts>;
+    /**
+     * Returns a stream that records reads against this budget and stops
+     * requesting further batches once exhausted. Apply directly to the document
+     * source before buffering, filtering, or combining its output.
+     */
+    readonly accountFor: (encodedDocuments: Stream.Stream<unknown>) => Stream.Stream<unknown>;
+}
+/**
+ * @experimental
+ */
+export declare const Limits: Schema.Struct<{
+    readonly maximumRowsRead: Schema.OptionFromOptionalKey<Schema.brand<Schema.Natural, "~@confect/server/QueryStreamReadBudget/ReadLimit">>;
+    readonly maximumBytesRead: Schema.OptionFromOptionalKey<Schema.brand<Schema.Natural, "~@confect/server/QueryStreamReadBudget/ReadLimit">>;
+}>;
+/**
+ * @experimental
+ */
+export type Limits = typeof Limits.Type;
+declare const InvalidReadLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "InvalidReadLimitError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class InvalidReadLimitError extends InvalidReadLimitError_base<{
+    readonly cause: Schema.SchemaError;
+}> {
+    get message(): string;
+}
+/**
+ * @experimental
+ */
+export interface ReadCounts {
+    readonly rowsRead: number;
+    readonly bytesRead: number;
+}
+/**
+ * @experimental
+ */
+export declare const QueryStreamReadBudget: Context.Service<QueryStreamReadBudget, QueryStreamReadBudget>;
+/**
+ * @experimental
+ */
+export declare const make: (limits: {
+    readonly maximumRowsRead: Option.Option<number & import("effect/Brand").Brand<"~@confect/server/QueryStreamReadBudget/ReadLimit">>;
+    readonly maximumBytesRead: Option.Option<number & import("effect/Brand").Brand<"~@confect/server/QueryStreamReadBudget/ReadLimit">>;
+}) => Effect.Effect<QueryStreamReadBudget, never, never>;
+export {};
+//# sourceMappingURL=QueryStreamReadBudget.d.ts.map

package/dist/QueryStreamReadBudget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamReadBudget.d.ts","sourceRoot":"","sources":["../src/QueryStreamReadBudget.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;CAC7B;AAMD;;GAEG;AACH,eAAO,MAAM,MAAM;;;EAGjB,CAAC;AACH;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAC;;;;AAExC;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,2BAEzC;IACA,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC;CACpC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AASD;;GAEG;AACH,eAAO,MAAM,qBAAqB,+DAEjC,CAAC;AA2BF;;GAEG;AACH,eAAO,MAAM,IAAI;;;wDAuDf,CAAC"}

package/dist/QueryStreamReadBudget.js

@@ -0,0 +1,81 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import { getDocumentSize } from "convex/values";
+import * as Array from "effect/Array";
+import * as Data from "effect/Data";
+import * as Stream from "effect/Stream";
+import * as Tuple from "effect/Tuple";
+import * as Cause from "effect/Cause";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+//#region src/QueryStreamReadBudget.ts
+var QueryStreamReadBudget_exports = /* @__PURE__ */ __exportAll({
+	InvalidReadLimitError: () => InvalidReadLimitError,
+	Limits: () => Limits,
+	QueryStreamReadBudget: () => QueryStreamReadBudget,
+	make: () => make
+});
+const ReadLimit = Schema.Natural.pipe(Schema.brand("~@confect/server/QueryStreamReadBudget/ReadLimit"));
+/**
+* @experimental
+*/
+const Limits = Schema.Struct({
+	maximumRowsRead: Schema.OptionFromOptionalKey(ReadLimit),
+	maximumBytesRead: Schema.OptionFromOptionalKey(ReadLimit)
+});
+/**
+* @experimental
+*/
+var InvalidReadLimitError = class extends Data.TaggedError("InvalidReadLimitError") {
+	get message() {
+		return `Invalid read limits: ${this.cause.message}`;
+	}
+};
+const State = Data.taggedEnum();
+/**
+* @experimental
+*/
+const QueryStreamReadBudget = Context.Service("@confect/server/QueryStreamReadBudget");
+const isExhausted = (state, limits) => State.$match(state, {
+	Stopped: () => true,
+	Active: ({ rowsRead, bytesRead }) => Option.exists(limits.maximumRowsRead, (limit) => rowsRead >= limit) || Option.exists(limits.maximumBytesRead, (limit) => bytesRead >= limit)
+});
+const readCounts = ({ rowsRead, bytesRead }) => ({
+	rowsRead,
+	bytesRead
+});
+const record = (counts, documents) => ({
+	rowsRead: counts.rowsRead + documents.length,
+	bytesRead: Array.reduce(documents, counts.bytesRead, (bytes, document) => bytes + getDocumentSize(document))
+});
+/**
+* @experimental
+*/
+const make = Effect.fnUntraced(function* (limits) {
+	const unlimited = Option.isNone(limits.maximumRowsRead) && Option.isNone(limits.maximumBytesRead);
+	const stateRef = yield* SynchronizedRef.make(State.Active({
+		rowsRead: 0,
+		bytesRead: 0
+	}));
+	const accountForPull = unlimited ? (pull) => Effect.uninterruptibleMask((restore) => Effect.tap(restore(pull), (documents) => SynchronizedRef.update(stateRef, (state) => State.Active(record(state, documents))))) : (pull) => SynchronizedRef.modifyEffect(stateRef, (state) => Effect.gen(function* () {
+		if (isExhausted(state, limits)) return Tuple.make(Option.none(), State.Stopped(readCounts(state)));
+		const documents = yield* pull;
+		return Tuple.make(Option.some(documents), State.Active(record(state, documents)));
+	})).pipe(Effect.flatMap(Option.match({
+		onNone: () => Cause.done(),
+		onSome: Effect.succeed
+	})));
+	return QueryStreamReadBudget.of({
+		isUnlimited: Effect.succeed(unlimited),
+		isStopped: Effect.map(SynchronizedRef.get(stateRef), State.$is("Stopped")),
+		isExhausted: Effect.map(SynchronizedRef.get(stateRef), (state) => isExhausted(state, limits)),
+		getReadCounts: Effect.map(SynchronizedRef.get(stateRef), readCounts),
+		accountFor: (encodedDocuments) => Stream.transformPull(encodedDocuments, (pull) => Effect.succeed(accountForPull(pull))).pipe(Stream.scoped)
+	});
+});
+//#endregion
+export { InvalidReadLimitError, Limits, QueryStreamReadBudget, QueryStreamReadBudget_exports, make };
+
+//# sourceMappingURL=QueryStreamReadBudget.js.map

package/dist/QueryStreamReadBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamReadBudget.js","names":[],"sources":["../src/QueryStreamReadBudget.ts"],"sourcesContent":["import type { GenericDocument } from \"convex/server\";\nimport { getDocumentSize } from \"convex/values\";\nimport * as Array from \"effect/Array\";\nimport * as Cause from \"effect/Cause\";\nimport * as Context from \"effect/Context\";\nimport * as Data from \"effect/Data\";\nimport * as Effect from \"effect/Effect\";\nimport * as Option from \"effect/Option\";\nimport type * as Pull from \"effect/Pull\";\nimport * as Schema from \"effect/Schema\";\nimport * as Stream from \"effect/Stream\";\nimport * as SynchronizedRef from \"effect/SynchronizedRef\";\nimport * as Tuple from \"effect/Tuple\";\n\n/**\n * @experimental\n */\nexport interface QueryStreamReadBudget {\n  readonly isUnlimited: Effect.Effect<boolean>;\n  readonly isStopped: Effect.Effect<boolean>;\n  readonly isExhausted: Effect.Effect<boolean>;\n  readonly getReadCounts: Effect.Effect<ReadCounts>;\n  /**\n   * Returns a stream that records reads against this budget and stops\n   * requesting further batches once exhausted. Apply directly to the document\n   * source before buffering, filtering, or combining its output.\n   */\n  readonly accountFor: (\n    encodedDocuments: Stream.Stream<unknown>,\n  ) => Stream.Stream<unknown>;\n}\n\nconst ReadLimit = Schema.Natural.pipe(\n  Schema.brand(\"~@confect/server/QueryStreamReadBudget/ReadLimit\"),\n);\n\n/**\n * @experimental\n */\nexport const Limits = Schema.Struct({\n  maximumRowsRead: Schema.OptionFromOptionalKey(ReadLimit),\n  maximumBytesRead: Schema.OptionFromOptionalKey(ReadLimit),\n});\n/**\n * @experimental\n */\nexport type Limits = typeof Limits.Type;\n\n/**\n * @experimental\n */\nexport class InvalidReadLimitError extends Data.TaggedError(\n  \"InvalidReadLimitError\",\n)<{\n  readonly cause: Schema.SchemaError;\n}> {\n  override get message(): string {\n    return `Invalid read limits: ${this.cause.message}`;\n  }\n}\n\n/**\n * @experimental\n */\nexport interface ReadCounts {\n  readonly rowsRead: number;\n  readonly bytesRead: number;\n}\n\ntype State = Data.TaggedEnum<{\n  Active: ReadCounts;\n  Stopped: ReadCounts;\n}>;\n\nconst State = Data.taggedEnum<State>();\n\n/**\n * @experimental\n */\nexport const QueryStreamReadBudget = Context.Service<QueryStreamReadBudget>(\n  \"@confect/server/QueryStreamReadBudget\",\n);\n\nconst isExhausted = (state: State, limits: Limits): boolean =>\n  State.$match(state, {\n    Stopped: () => true,\n    Active: ({ rowsRead, bytesRead }) =>\n      Option.exists(limits.maximumRowsRead, (limit) => rowsRead >= limit) ||\n      Option.exists(limits.maximumBytesRead, (limit) => bytesRead >= limit),\n  });\n\nconst readCounts = ({ rowsRead, bytesRead }: ReadCounts): ReadCounts => ({\n  rowsRead,\n  bytesRead,\n});\n\nconst record = (\n  counts: ReadCounts,\n  documents: Array.NonEmptyReadonlyArray<unknown>,\n): ReadCounts => ({\n  rowsRead: counts.rowsRead + documents.length,\n  bytesRead: Array.reduce(\n    documents,\n    counts.bytesRead,\n    (bytes, document) => bytes + getDocumentSize(document as GenericDocument),\n  ),\n});\n\n/**\n * @experimental\n */\nexport const make = Effect.fnUntraced(function* (\n  limits: Limits,\n): Effect.fn.Return<QueryStreamReadBudget> {\n  const unlimited =\n    Option.isNone(limits.maximumRowsRead) &&\n    Option.isNone(limits.maximumBytesRead);\n  const stateRef = yield* SynchronizedRef.make<State>(\n    State.Active({ rowsRead: 0, bytesRead: 0 }),\n  );\n  const accountForPull: (\n    pull: Pull.Pull<Array.NonEmptyReadonlyArray<unknown>>,\n  ) => Pull.Pull<Array.NonEmptyReadonlyArray<unknown>> = unlimited\n    ? (pull) =>\n        Effect.uninterruptibleMask((restore) =>\n          Effect.tap(restore(pull), (documents) =>\n            SynchronizedRef.update(stateRef, (state) =>\n              State.Active(record(state, documents)),\n            ),\n          ),\n        )\n    : (pull) =>\n        SynchronizedRef.modifyEffect(stateRef, (state) =>\n          Effect.gen(function* () {\n            if (isExhausted(state, limits)) {\n              return Tuple.make(\n                Option.none(),\n                State.Stopped(readCounts(state)),\n              );\n            }\n            const documents = yield* pull;\n            return Tuple.make(\n              Option.some(documents),\n              State.Active(record(state, documents)),\n            );\n          }),\n        ).pipe(\n          Effect.flatMap(\n            Option.match({\n              onNone: () => Cause.done(),\n              onSome: Effect.succeed,\n            }),\n          ),\n        );\n  return QueryStreamReadBudget.of({\n    isUnlimited: Effect.succeed(unlimited),\n    isStopped: Effect.map(SynchronizedRef.get(stateRef), State.$is(\"Stopped\")),\n    isExhausted: Effect.map(SynchronizedRef.get(stateRef), (state) =>\n      isExhausted(state, limits),\n    ),\n    getReadCounts: Effect.map(SynchronizedRef.get(stateRef), readCounts),\n    accountFor: (encodedDocuments) =>\n      Stream.transformPull(encodedDocuments, (pull) =>\n        Effect.succeed(accountForPull(pull)),\n      ).pipe(Stream.scoped),\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgCA,MAAM,YAAY,OAAO,QAAQ,KAC/B,OAAO,MAAM,kDAAkD,CACjE;;;;AAKA,MAAa,SAAS,OAAO,OAAO;CAClC,iBAAiB,OAAO,sBAAsB,SAAS;CACvD,kBAAkB,OAAO,sBAAsB,SAAS;AAC1D,CAAC;;;;AASD,IAAa,wBAAb,cAA2C,KAAK,YAC9C,uBACF,CAAC,CAEE;CACD,IAAa,UAAkB;EAC7B,OAAO,wBAAwB,KAAK,MAAM;CAC5C;AACF;AAeA,MAAM,QAAQ,KAAK,WAAkB;;;;AAKrC,MAAa,wBAAwB,QAAQ,QAC3C,uCACF;AAEA,MAAM,eAAe,OAAc,WACjC,MAAM,OAAO,OAAO;CAClB,eAAe;CACf,SAAS,EAAE,UAAU,gBACnB,OAAO,OAAO,OAAO,kBAAkB,UAAU,YAAY,KAAK,KAClE,OAAO,OAAO,OAAO,mBAAmB,UAAU,aAAa,KAAK;AACxE,CAAC;AAEH,MAAM,cAAc,EAAE,UAAU,iBAAyC;CACvE;CACA;AACF;AAEA,MAAM,UACJ,QACA,eACgB;CAChB,UAAU,OAAO,WAAW,UAAU;CACtC,WAAW,MAAM,OACf,WACA,OAAO,YACN,OAAO,aAAa,QAAQ,gBAAgB,QAA2B,CAC1E;AACF;;;;AAKA,MAAa,OAAO,OAAO,WAAW,WACpC,QACyC;CACzC,MAAM,YACJ,OAAO,OAAO,OAAO,eAAe,KACpC,OAAO,OAAO,OAAO,gBAAgB;CACvC,MAAM,WAAW,OAAO,gBAAgB,KACtC,MAAM,OAAO;EAAE,UAAU;EAAG,WAAW;CAAE,CAAC,CAC5C;CACA,MAAM,iBAEiD,aAClD,SACC,OAAO,qBAAqB,YAC1B,OAAO,IAAI,QAAQ,IAAI,IAAI,cACzB,gBAAgB,OAAO,WAAW,UAChC,MAAM,OAAO,OAAO,OAAO,SAAS,CAAC,CACvC,CACF,CACF,KACD,SACC,gBAAgB,aAAa,WAAW,UACtC,OAAO,IAAI,aAAa;EACtB,IAAI,YAAY,OAAO,MAAM,GAC3B,OAAO,MAAM,KACX,OAAO,KAAK,GACZ,MAAM,QAAQ,WAAW,KAAK,CAAC,CACjC;EAEF,MAAM,YAAY,OAAO;EACzB,OAAO,MAAM,KACX,OAAO,KAAK,SAAS,GACrB,MAAM,OAAO,OAAO,OAAO,SAAS,CAAC,CACvC;CACF,CAAC,CACH,CAAC,CAAC,KACA,OAAO,QACL,OAAO,MAAM;EACX,cAAc,MAAM,KAAK;EACzB,QAAQ,OAAO;CACjB,CAAC,CACH,CACF;CACN,OAAO,sBAAsB,GAAG;EAC9B,aAAa,OAAO,QAAQ,SAAS;EACrC,WAAW,OAAO,IAAI,gBAAgB,IAAI,QAAQ,GAAG,MAAM,IAAI,SAAS,CAAC;EACzE,aAAa,OAAO,IAAI,gBAAgB,IAAI,QAAQ,IAAI,UACtD,YAAY,OAAO,MAAM,CAC3B;EACA,eAAe,OAAO,IAAI,gBAAgB,IAAI,QAAQ,GAAG,UAAU;EACnE,aAAa,qBACX,OAAO,cAAc,mBAAmB,SACtC,OAAO,QAAQ,eAAe,IAAI,CAAC,CACrC,CAAC,CAAC,KAAK,OAAO,MAAM;CACxB,CAAC;AACH,CAAC"}

package/dist/QueryTransactionContext.d.ts

@@ -0,0 +1,16 @@
+import * as Ref from "@confect/core/Ref";
+import type { GenericDataModel, GenericQueryCtx, TransactionLimits } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+export type { TransactionLimits } from "convex/server";
+export interface Options {
+    readonly transactionLimits?: TransactionLimits;
+}
+declare const QueryTransactionContext_base: Context.ServiceClass<QueryTransactionContext, "@confect/server/QueryTransactionContext", {
+    runQuery: <Query extends Ref.AnyQuery>(query: Query, args: Ref.Args<Query>, options: Options) => Effect.Effect<Ref.Returns<Query>, import("effect/Schema").SchemaError | Ref.Error<Query>, never>;
+}>;
+export declare class QueryTransactionContext extends QueryTransactionContext_base {
+}
+export declare const layer: (ctx: Pick<GenericQueryCtx<GenericDataModel>, "runQuery">) => Layer.Layer<QueryTransactionContext, never, never>;
+//# sourceMappingURL=QueryTransactionContext.d.ts.map

package/dist/QueryTransactionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryTransactionContext.d.ts","sourceRoot":"","sources":["../src/QueryTransactionContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,mBAAmB,CAAC;AACzC,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CAChD;;eAII,KAAK,SAAS,GAAG,CAAC,QAAQ;;AAW/B,qBAAa,uBAAwB,SAAQ,4BAGC;CAAG;AAEjD,eAAO,MAAM,KAAK,QACX,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,UAAU,CAAC,uDACJ,CAAC"}

package/dist/QueryTransactionContext.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+//#region src/QueryTransactionContext.ts
+var QueryTransactionContext_exports = /* @__PURE__ */ __exportAll({
+	QueryTransactionContext: () => QueryTransactionContext,
+	layer: () => layer
+});
+const make = (ctx) => ({ runQuery: Effect.fn("QueryTransactionContext.runQuery")((query, args, options) => Ref.runWithCodec(query, args, (ref, encodedArgs) => ctx.runQuery(ref, encodedArgs, options))) });
+var QueryTransactionContext = class extends Context.Service()("@confect/server/QueryTransactionContext") {};
+const layer = (ctx) => Layer.succeed(QueryTransactionContext, make(ctx));
+//#endregion
+export { QueryTransactionContext, QueryTransactionContext_exports, layer };
+
+//# sourceMappingURL=QueryTransactionContext.js.map

package/dist/QueryTransactionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryTransactionContext.js","names":[],"sources":["../src/QueryTransactionContext.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport type {\n  GenericDataModel,\n  GenericQueryCtx,\n  TransactionLimits,\n} from \"convex/server\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\nexport type { TransactionLimits } from \"convex/server\";\n\nexport interface Options {\n  readonly transactionLimits?: TransactionLimits;\n}\n\nconst make = (ctx: Pick<GenericQueryCtx<GenericDataModel>, \"runQuery\">) => ({\n  runQuery: Effect.fn(\"QueryTransactionContext.runQuery\")(\n    <Query extends Ref.AnyQuery>(\n      query: Query,\n      args: Ref.Args<Query>,\n      options: Options,\n    ) =>\n      Ref.runWithCodec(query, args, (ref, encodedArgs) =>\n        ctx.runQuery(ref, encodedArgs, options),\n      ),\n  ),\n});\n\nexport class QueryTransactionContext extends Context.Service<\n  QueryTransactionContext,\n  ReturnType<typeof make>\n>()(\"@confect/server/QueryTransactionContext\") {}\n\nexport const layer = (\n  ctx: Pick<GenericQueryCtx<GenericDataModel>, \"runQuery\">,\n) => Layer.succeed(QueryTransactionContext, make(ctx));\n"],"mappings":";;;;;;;;;;AAgBA,MAAM,QAAQ,SAA8D,EAC1E,UAAU,OAAO,GAAG,kCAAkC,CAAC,EAEnD,OACA,MACA,YAEA,IAAI,aAAa,OAAO,OAAO,KAAK,gBAClC,IAAI,SAAS,KAAK,aAAa,OAAO,CACxC,CACJ,EACF;AAEA,IAAa,0BAAb,cAA6C,QAAQ,QAGnD,CAAC,CAAC,yCAAyC,CAAC,CAAC,CAAC;AAEhD,MAAa,SACX,QACG,MAAM,QAAQ,yBAAyB,KAAK,GAAG,CAAC"}