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

package/dist/QueryStreamKeyLayout.js

@@ -0,0 +1,167 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { hasPrefix, make as make$1 } from "./QueryStreamKeyLabels.js";
+import { identity } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Array from "effect/Array";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+import * as Equivalence_ from "effect/Equivalence";
+//#region src/QueryStreamKeyLayout.ts
+var QueryStreamKeyLayout_exports = /* @__PURE__ */ __exportAll({
+	Equivalence: () => Equivalence,
+	InvalidEqualityPrefixError: () => InvalidEqualityPrefixError,
+	InvalidLabelPrefixError: () => InvalidLabelPrefixError,
+	KeyLayoutMismatchError: () => KeyLayoutMismatchError,
+	LabelCountMismatchError: () => LabelCountMismatchError,
+	concat: () => concat,
+	format: () => format,
+	fromIndex: () => fromIndex,
+	positions: () => positions,
+	rename: () => rename,
+	resolvePrefix: () => resolvePrefix,
+	runtimeWidth: () => runtimeWidth,
+	validateEquivalence: () => validateEquivalence,
+	visibleLabels: () => visibleLabels
+});
+const Position = Data.taggedEnum();
+const TypeId = "@confect/server/QueryStreamKeyLayout";
+const make = (positions) => ({ [TypeId]: {
+	_Labels: identity,
+	positions
+} });
+/**
+* The runtime positions, including implicit ID tiebreakers.
+*
+* @experimental
+*/
+const positions = (self) => self[TypeId].positions;
+/**
+* The equality prefix cannot select a whole number of source field paths.
+*
+* @experimental
+*/
+var InvalidEqualityPrefixError = class extends Data.TaggedError("InvalidEqualityPrefixError") {
+	get message() {
+		return `QueryStreamKeyLayout.fromIndex: invalid equality prefix length (${this.eqCount}) for ${this.fieldPaths.length} field paths`;
+	}
+};
+/**
+* The requested labels do not form a prefix of the layout's visible labels.
+*
+* @experimental
+*/
+var InvalidLabelPrefixError = class extends Data.TaggedError("InvalidLabelPrefixError") {
+	get message() {
+		return `Labels ([${Array.join(this.prefixKeyLabels, ", ")}]) must be a prefix of the ordering labels ([${Array.join(this.keyLabels, ", ")}])`;
+	}
+};
+/**
+* The replacement labels cannot fill exactly the layout's visible positions.
+*
+* @experimental
+*/
+var LabelCountMismatchError = class extends Data.TaggedError("LabelCountMismatchError") {
+	get message() {
+		return `Replacement labels ([${Array.join(this.replacementKeyLabels, ", ")}]) must have as many labels as the ordering labels ([${Array.join(this.keyLabels, ", ")}])`;
+	}
+};
+function fromIndex(fieldPaths, eqCount = 0) {
+	if (!Number.isInteger(eqCount) || eqCount < 0 || eqCount > fieldPaths.length) return Result.fail(new InvalidEqualityPrefixError({
+		fieldPaths,
+		eqCount
+	}));
+	const visible = Array.map(Array.drop(fieldPaths, eqCount), (label) => Position.Visible({ label }));
+	const keyPositions = Option.exists(Array.last(fieldPaths), (fieldPath) => fieldPath === "_id") ? visible : Array.append(visible, Position.ImplicitId());
+	return Result.succeed(make(keyPositions));
+}
+/**
+* Concatenate layouts without losing component tiebreakers.
+*
+* @experimental
+*/
+const concat = (self, that) => make(Array.appendAll(positions(self), positions(that)));
+/**
+* Format visible labels and implicit IDs for diagnostics.
+*
+* @experimental
+*/
+const format = (self) => {
+	const tokens = Array.map(positions(self), Position.$match({
+		Visible: ({ label }) => JSON.stringify(label),
+		ImplicitId: () => "<implicit _id>"
+	}));
+	return `[${Array.join(tokens, ", ")}]`;
+};
+function visibleLabels(self) {
+	return make$1(Array.filterMap(positions(self), Position.$match({
+		Visible: ({ label }) => Result.succeed(label),
+		ImplicitId: () => Result.failVoid
+	})));
+}
+/**
+* Number of positions in an element's runtime key.
+*
+* @experimental
+*/
+const runtimeWidth = (self) => positions(self).length;
+const visiblePositions = (self) => Array.filterMap(positions(self), (position, index) => Position.$is("Visible")(position) ? Result.succeed(index) : Result.failVoid);
+const PositionsEquivalence = Equivalence_.Array((self, that) => Position.$match(self, {
+	Visible: ({ label }) => Position.$is("Visible")(that) && label === that.label,
+	ImplicitId: () => Position.$is("ImplicitId")(that)
+}));
+/**
+* @experimental
+*/
+const Equivalence = Equivalence_.mapInput(PositionsEquivalence, positions);
+/**
+* @experimental
+*/
+var KeyLayoutMismatchError = class extends Data.TaggedError("KeyLayoutMismatchError") {
+	get message() {
+		return `Key layout (${format(this.actualKeyLayout)}) does not match the expected layout (${format(this.expectedKeyLayout)})`;
+	}
+};
+/**
+* @experimental
+*/
+const validateEquivalence = (expectedKeyLayout, actualKeyLayout) => Equivalence(expectedKeyLayout, actualKeyLayout) ? Result.succeed(void 0) : Result.fail(new KeyLayoutMismatchError({
+	expectedKeyLayout,
+	actualKeyLayout
+}));
+/**
+* Parse a visible label prefix and resolve its runtime width. Implicit IDs
+* before the last selected label are included; implicit IDs after it are not.
+*
+* @experimental
+*/
+const resolvePrefix = (self, prefixKeyLabels) => {
+	const keyLabels = visibleLabels(self);
+	if (!hasPrefix(keyLabels, prefixKeyLabels)) return Result.fail(new InvalidLabelPrefixError({
+		keyLabels,
+		prefixKeyLabels
+	}));
+	return Result.succeed(Option.match(Array.get(visiblePositions(self), prefixKeyLabels.length - 1), {
+		onNone: () => 0,
+		onSome: (position) => position + 1
+	}));
+};
+/**
+* Relabel visible positions, preserving every implicit ID.
+*
+* @experimental
+*/
+const rename = (self, replacementKeyLabels) => {
+	const [consumed, renamed] = Array.mapAccum(positions(self), 0, (index, position) => Position.$match(position, {
+		ImplicitId: () => [index, Option.some(position)],
+		Visible: () => [index + 1, Option.map(Array.get(replacementKeyLabels, index), (label) => Position.Visible({ label }))]
+	}));
+	const parsed = consumed === replacementKeyLabels.length ? Option.all(renamed) : Option.none();
+	return Result.fromOption(Option.map(parsed, make), () => new LabelCountMismatchError({
+		keyLabels: visibleLabels(self),
+		replacementKeyLabels
+	}));
+};
+//#endregion
+export { Equivalence, InvalidEqualityPrefixError, InvalidLabelPrefixError, KeyLayoutMismatchError, LabelCountMismatchError, QueryStreamKeyLayout_exports, concat, format, fromIndex, positions, rename, resolvePrefix, runtimeWidth, validateEquivalence, visibleLabels };
+
+//# sourceMappingURL=QueryStreamKeyLayout.js.map

package/dist/QueryStreamKeyLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyLayout.js","names":["QueryStreamKeyLabels.make","QueryStreamKeyLabels.hasPrefix"],"sources":["../src/QueryStreamKeyLayout.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport * as Data from \"effect/Data\";\nimport * as Equivalence_ from \"effect/Equivalence\";\nimport { identity } from \"effect/Function\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport type * as Types from \"effect/Types\";\n\nimport * as QueryStreamKeyLabels from \"./QueryStreamKeyLabels\";\n\n/**\n * One runtime position of a stream key. Explicit IDs and their aliases are\n * visible; implicit ID tiebreakers have no label. Empty keys have no\n * positions.\n *\n * @experimental\n */\nexport type Position = Data.TaggedEnum<{\n  Visible: { readonly label: string };\n  ImplicitId: {};\n}>;\n\nconst Position = Data.taggedEnum<Position>();\nconst TypeId = \"@confect/server/QueryStreamKeyLayout\";\n\n/**\n * Describes the positions in a stream's keys: their sequence, their labels, and\n * where implicit document-ID tiebreakers occur. Every element has its own key\n * values; the stream has one shared layout.\n *\n * For example, labels `[\"text\", \"_creationTime\"]` describe the labeled\n * positions in a key such as `[\"apple\", 1, \"n1\"]`. Its layout also records the\n * final implicit ID position. Joined layouts retain each component's ID, so\n * their labels alone do not describe every key position.\n *\n * Layouts are compatible when they have the same total width, labels in the\n * same positions, and implicit-ID positions. Direction is separate. Layouts\n * contain no key values, value-type schemas, table identity, or equality-pinned\n * values. Labels start as index field paths but may be renamed. An explicit ID,\n * such as in `by_id`, has a label.\n *\n * Reuse a stream's `keyLayout` with `empty` or `flatMap`'s `innerKeyLayout`.\n * Creating a stream to obtain its layout does not read documents. The\n * `KeyLabels` parameter tracks only labels; implicit-ID positions are checked\n * at runtime. Normally this type is inferred from the source stream.\n *\n * @experimental\n */\nexport interface QueryStreamKeyLayout<\n  out KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels =\n    QueryStreamKeyLabels.QueryStreamKeyLabels,\n> {\n  readonly [TypeId]: {\n    readonly _Labels: Types.Covariant<KeyLabels>;\n    readonly positions: ReadonlyArray<Position>;\n  };\n}\n\n// Private construction keeps the visible label witness with the operations\n// that derive it from index fields, concatenation, or renaming.\nconst make = <KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels>(\n  positions: ReadonlyArray<Position>,\n): QueryStreamKeyLayout<KeyLabels> => ({\n  [TypeId]: { _Labels: identity, positions },\n});\n\n/**\n * The runtime positions, including implicit ID tiebreakers.\n *\n * @experimental\n */\nexport const positions = (\n  self: QueryStreamKeyLayout,\n): ReadonlyArray<Position> => self[TypeId].positions;\n\n/**\n * The source field paths remaining after an equality prefix.\n *\n * @experimental\n */\nexport type RemainingFieldPaths<\n  FieldPaths extends ReadonlyArray<string>,\n  Count extends number,\n> = Count extends unknown ? DropPrefix<FieldPaths, Count> : never;\n\ntype DropPrefix<\n  FieldPaths extends ReadonlyArray<string>,\n  Count extends number,\n  Prefix extends ReadonlyArray<unknown> = [],\n> = number extends Count\n  ? ReadonlyArray<string>\n  : Prefix[\"length\"] extends Count\n    ? Types.Mutable<FieldPaths>\n    : FieldPaths extends readonly [\n          string,\n          ...infer TailFieldPaths extends ReadonlyArray<string>,\n        ]\n      ? DropPrefix<TailFieldPaths, Count, readonly [...Prefix, unknown]>\n      : FieldPaths extends readonly []\n        ? []\n        : ReadonlyArray<string>;\n\n/**\n * The equality prefix cannot select a whole number of source field paths.\n *\n * @experimental\n */\nexport class InvalidEqualityPrefixError extends Data.TaggedError(\n  \"InvalidEqualityPrefixError\",\n)<{\n  readonly fieldPaths: ReadonlyArray<string>;\n  readonly eqCount: number;\n}> {\n  override get message(): string {\n    return `QueryStreamKeyLayout.fromIndex: invalid equality prefix length (${this.eqCount}) for ${this.fieldPaths.length} field paths`;\n  }\n}\n\n/**\n * The requested labels do not form a prefix of the layout's visible labels.\n *\n * @experimental\n */\nexport class InvalidLabelPrefixError extends Data.TaggedError(\n  \"InvalidLabelPrefixError\",\n)<{\n  readonly keyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;\n  readonly prefixKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;\n}> {\n  override get message(): string {\n    return `Labels ([${Array.join(this.prefixKeyLabels, \", \")}]) must be a prefix of the ordering labels ([${Array.join(this.keyLabels, \", \")}])`;\n  }\n}\n\n/**\n * The replacement labels cannot fill exactly the layout's visible positions.\n *\n * @experimental\n */\nexport class LabelCountMismatchError extends Data.TaggedError(\n  \"LabelCountMismatchError\",\n)<{\n  readonly keyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;\n  readonly replacementKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;\n}> {\n  override get message(): string {\n    return `Replacement labels ([${Array.join(this.replacementKeyLabels, \", \")}]) must have as many labels as the ordering labels ([${Array.join(this.keyLabels, \", \")}])`;\n  }\n}\n\n/**\n * Construct a scan layout from the original index field paths, before equality\n * pinning. Only an ID absent from the end of that original key is implicit.\n * Pinning every field of `by_id` produces a zero-width layout; pinning every\n * visible field of another index leaves its implicit ID. Invalid equality\n * prefix lengths return `InvalidEqualityPrefixError`.\n *\n * @experimental\n */\nexport function fromIndex<const FieldPaths extends ReadonlyArray<string>>(\n  fieldPaths: FieldPaths,\n): Result.Result<\n  QueryStreamKeyLayout<QueryStreamKeyLabels.QueryStreamKeyLabels<FieldPaths>>,\n  InvalidEqualityPrefixError\n>;\n/**\n * @experimental\n */\nexport function fromIndex<\n  const FieldPaths extends ReadonlyArray<string>,\n  const Count extends number,\n>(\n  fieldPaths: FieldPaths,\n  eqCount: Count,\n): Result.Result<\n  QueryStreamKeyLayout<\n    QueryStreamKeyLabels.QueryStreamKeyLabels<\n      RemainingFieldPaths<FieldPaths, Count>\n    >\n  >,\n  InvalidEqualityPrefixError\n>;\nexport function fromIndex(\n  fieldPaths: ReadonlyArray<string>,\n  eqCount = 0,\n): Result.Result<QueryStreamKeyLayout, InvalidEqualityPrefixError> {\n  if (\n    !Number.isInteger(eqCount) ||\n    eqCount < 0 ||\n    eqCount > fieldPaths.length\n  ) {\n    return Result.fail(new InvalidEqualityPrefixError({ fieldPaths, eqCount }));\n  }\n  const visible = Array.map(Array.drop(fieldPaths, eqCount), (label) =>\n    Position.Visible({ label }),\n  );\n  const keyPositions = Option.exists(\n    Array.last(fieldPaths),\n    (fieldPath) => fieldPath === \"_id\",\n  )\n    ? visible\n    : Array.append(visible, Position.ImplicitId());\n  return Result.succeed(make(keyPositions));\n}\n\n/**\n * Concatenate layouts without losing component tiebreakers.\n *\n * @experimental\n */\nexport const concat = <\n  LeftKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,\n  RightKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,\n>(\n  self: QueryStreamKeyLayout<LeftKeyLabels>,\n  that: QueryStreamKeyLayout<RightKeyLabels>,\n): QueryStreamKeyLayout<\n  QueryStreamKeyLabels.Concat<LeftKeyLabels, RightKeyLabels>\n> => make(Array.appendAll(positions(self), positions(that)));\n\n/**\n * Format visible labels and implicit IDs for diagnostics.\n *\n * @experimental\n */\nexport const format = (self: QueryStreamKeyLayout): string => {\n  const tokens = Array.map(\n    positions(self),\n    Position.$match({\n      Visible: ({ label }) => JSON.stringify(label),\n      ImplicitId: () => \"<implicit _id>\",\n    }),\n  );\n  return `[${Array.join(tokens, \", \")}]`;\n};\n\n/**\n * The labels available to `distinct` and `renameKey`.\n *\n * @experimental\n */\nexport function visibleLabels<\n  KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,\n>(self: QueryStreamKeyLayout<KeyLabels>): KeyLabels;\nexport function visibleLabels(\n  self: QueryStreamKeyLayout,\n): QueryStreamKeyLabels.QueryStreamKeyLabels {\n  return QueryStreamKeyLabels.make(\n    Array.filterMap(\n      positions(self),\n      Position.$match({\n        Visible: ({ label }) => Result.succeed(label),\n        ImplicitId: () => Result.failVoid,\n      }),\n    ),\n  );\n}\n\n/**\n * Number of positions in an element's runtime key.\n *\n * @experimental\n */\nexport const runtimeWidth = (self: QueryStreamKeyLayout): number =>\n  positions(self).length;\n\n// Runtime offsets of visible labels, used to resolve label prefixes.\nconst visiblePositions = (self: QueryStreamKeyLayout): ReadonlyArray<number> =>\n  Array.filterMap(positions(self), (position, index) =>\n    Position.$is(\"Visible\")(position) ? Result.succeed(index) : Result.failVoid,\n  );\n\nconst PositionsEquivalence = Equivalence_.Array<Position>((self, that) =>\n  Position.$match(self, {\n    Visible: ({ label }) =>\n      Position.$is(\"Visible\")(that) && label === that.label,\n    ImplicitId: () => Position.$is(\"ImplicitId\")(that),\n  }),\n);\n\n/**\n * @experimental\n */\nexport const Equivalence: Equivalence_.Equivalence<QueryStreamKeyLayout> =\n  Equivalence_.mapInput(PositionsEquivalence, positions);\n\n/**\n * @experimental\n */\nexport class KeyLayoutMismatchError extends Data.TaggedError(\n  \"KeyLayoutMismatchError\",\n)<{\n  readonly expectedKeyLayout: QueryStreamKeyLayout;\n  readonly actualKeyLayout: QueryStreamKeyLayout;\n}> {\n  override get message(): string {\n    return `Key layout (${format(this.actualKeyLayout)}) does not match the expected layout (${format(this.expectedKeyLayout)})`;\n  }\n}\n\n/**\n * @experimental\n */\nexport const validateEquivalence = (\n  expectedKeyLayout: QueryStreamKeyLayout,\n  actualKeyLayout: QueryStreamKeyLayout,\n): Result.Result<void, KeyLayoutMismatchError> =>\n  Equivalence(expectedKeyLayout, actualKeyLayout)\n    ? Result.succeed(undefined)\n    : Result.fail(\n        new KeyLayoutMismatchError({ expectedKeyLayout, actualKeyLayout }),\n      );\n\n/**\n * Parse a visible label prefix and resolve its runtime width. Implicit IDs\n * before the last selected label are included; implicit IDs after it are not.\n *\n * @experimental\n */\nexport const resolvePrefix = (\n  self: QueryStreamKeyLayout,\n  prefixKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels,\n): Result.Result<number, InvalidLabelPrefixError> => {\n  const keyLabels = visibleLabels(self);\n  if (!QueryStreamKeyLabels.hasPrefix(keyLabels, prefixKeyLabels)) {\n    return Result.fail(\n      new InvalidLabelPrefixError({ keyLabels, prefixKeyLabels }),\n    );\n  }\n  return Result.succeed(\n    Option.match(\n      Array.get(visiblePositions(self), prefixKeyLabels.length - 1),\n      {\n        onNone: () => 0,\n        onSome: (position) => position + 1,\n      },\n    ),\n  );\n};\n\n/**\n * Relabel visible positions, preserving every implicit ID.\n *\n * @experimental\n */\nexport const rename = <\n  ReplacementKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,\n>(\n  self: QueryStreamKeyLayout,\n  replacementKeyLabels: ReplacementKeyLabels,\n): Result.Result<\n  QueryStreamKeyLayout<ReplacementKeyLabels>,\n  LabelCountMismatchError\n> => {\n  const [consumed, renamed] = Array.mapAccum(\n    positions(self),\n    0,\n    (index, position): readonly [number, Option.Option<Position>] =>\n      Position.$match(position, {\n        ImplicitId: () => [index, Option.some(position)] as const,\n        Visible: () =>\n          [\n            index + 1,\n            Option.map(Array.get(replacementKeyLabels, index), (label) =>\n              Position.Visible({ label }),\n            ),\n          ] as const,\n      }),\n  );\n  const parsed =\n    consumed === replacementKeyLabels.length\n      ? Option.all(renamed)\n      : Option.none();\n  return Result.fromOption(\n    Option.map(parsed, make<ReplacementKeyLabels>),\n    () =>\n      new LabelCountMismatchError({\n        keyLabels: visibleLabels(self),\n        replacementKeyLabels,\n      }),\n  );\n};\n"],"mappings":"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"}

package/dist/QueryStreamKeyValues.d.ts

@@ -0,0 +1,40 @@
+import { type Value } from "convex/values";
+import * as Order_ from "effect/Order";
+import type * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
+import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
+declare const KeyValue: Schema.decodeTo<Schema.declare<Value | undefined, Value | undefined>, Schema.Codec<Schema.Json, Schema.Json, never, never>, never, never>;
+/**
+ * @experimental
+ */
+export type KeyValue = typeof KeyValue.Type;
+/**
+ * @experimental
+ */
+export declare const QueryStreamKeyValues: Schema.$Array<Schema.decodeTo<Schema.declare<Value | undefined, Value | undefined>, Schema.Codec<Schema.Json, Schema.Json, never, never>, never, never>>;
+/**
+ * @experimental
+ */
+export type QueryStreamKeyValues = typeof QueryStreamKeyValues.Type;
+/**
+ * `Order` over Convex values, matching Convex's index ordering—a wrapper around
+ * the canonical `compareValues` from `convex/values` (type rank first, then
+ * within the type, including UTF-8 string order and NaN bit-level ordering).
+ *
+ * @experimental
+ */
+export declare const ValueOrder: Order_.Order<KeyValue>;
+/**
+ * Compare key values in the requested direction. Ascending order is
+ * lexicographic by `ValueOrder`, then by length, matching Convex array values;
+ * descending order reverses it.
+ *
+ * @experimental
+ */
+export declare const Order: (orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection) => Order_.Order<QueryStreamKeyValues>;
+/**
+ * @experimental
+ */
+export declare const extract: (encoded: Record.ReadonlyRecord<string, unknown>, keyPaths: ReadonlyArray<ReadonlyArray<string>>) => QueryStreamKeyValues;
+export {};
+//# sourceMappingURL=QueryStreamKeyValues.d.ts.map

package/dist/QueryStreamKeyValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyValues.d.ts","sourceRoot":"","sources":["../src/QueryStreamKeyValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,KAAK,yBAAyB,MAAM,6BAA6B,CAAC;AAG9E,QAAA,MAAM,QAAQ,2IAmCb,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,oBAAoB,0JAAyB,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAC;AAEpE;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAE7C,CAAC;AAKF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,mBACA,yBAAyB,CAAC,yBAAyB,KAClE,MAAM,CAAC,KAAK,CAAC,oBAAoB,CACyB,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,OAAO,YACT,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,YACrC,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,KAC7C,oBAUwB,CAAC"}

package/dist/QueryStreamKeyValues.js

@@ -0,0 +1,57 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { compareValues, convexToJson, jsonToConvex } from "convex/values";
+import * as Array from "effect/Array";
+import * as Order_ from "effect/Order";
+import * as Result from "effect/Result";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaGetter from "effect/SchemaGetter";
+//#region src/QueryStreamKeyValues.ts
+var QueryStreamKeyValues_exports = /* @__PURE__ */ __exportAll({
+	Order: () => Order,
+	QueryStreamKeyValues: () => QueryStreamKeyValues,
+	ValueOrder: () => ValueOrder,
+	extract: () => extract
+});
+const UNDEFINED_SENTINEL = { $undefined: true };
+const KeyValue = Schema.Json.pipe(Schema.decodeTo(Schema.declare((value) => value === void 0 || Result.isSuccess(Result.try(() => convexToJson(value)))), {
+	decode: SchemaGetter.transformEffect((value, options) => Effect.try({
+		try: () => Result.match(Schema.decodeUnknownResult(Schema.Struct({ $undefined: Schema.Literal(true) }), { onExcessProperty: "error" })(value), {
+			onSuccess: () => void 0,
+			onFailure: () => jsonToConvex(value)
+		}),
+		catch: () => new SchemaIssue.InvalidValue({ message: "Invalid Convex key value" }, value, options)
+	})),
+	encode: SchemaGetter.transform((value) => value === void 0 ? UNDEFINED_SENTINEL : convexToJson(value))
+}));
+/**
+* @experimental
+*/
+const QueryStreamKeyValues = Schema.Array(KeyValue);
+/**
+* `Order` over Convex values, matching Convex's index ordering—a wrapper around
+* the canonical `compareValues` from `convex/values` (type rank first, then
+* within the type, including UTF-8 string order and NaN bit-level ordering).
+*
+* @experimental
+*/
+const ValueOrder = Order_.make((self, that) => Math.sign(compareValues(self, that)));
+const AscendingOrder = Order_.Array(ValueOrder);
+const DescendingOrder = Order_.flip(AscendingOrder);
+/**
+* Compare key values in the requested direction. Ascending order is
+* lexicographic by `ValueOrder`, then by length, matching Convex array values;
+* descending order reverses it.
+*
+* @experimental
+*/
+const Order = (orderDirection) => orderDirection === "asc" ? AscendingOrder : DescendingOrder;
+/**
+* @experimental
+*/
+const extract = (encoded, keyPaths) => Array.map(keyPaths, (path) => Array.reduce(path, encoded, (value, segment) => value?.[segment]));
+//#endregion
+export { Order, QueryStreamKeyValues, QueryStreamKeyValues_exports, ValueOrder, extract };
+
+//# sourceMappingURL=QueryStreamKeyValues.js.map

package/dist/QueryStreamKeyValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyValues.js","names":[],"sources":["../src/QueryStreamKeyValues.ts"],"sourcesContent":["import {\n  convexToJson,\n  jsonToConvex,\n  compareValues,\n  type Value,\n} from \"convex/values\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Order_ from \"effect/Order\";\nimport type * as Record from \"effect/Record\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as SchemaGetter from \"effect/SchemaGetter\";\nimport * as SchemaIssue from \"effect/SchemaIssue\";\nimport type * as QueryStreamOrderDirection from \"./QueryStreamOrderDirection\";\n\nconst UNDEFINED_SENTINEL = { $undefined: true } as const;\nconst KeyValue = Schema.Json.pipe(\n  Schema.decodeTo(\n    Schema.declare<Value | undefined>(\n      (value): value is Value | undefined =>\n        value === undefined ||\n        Result.isSuccess(Result.try(() => convexToJson(value as Value))),\n    ),\n    {\n      decode: SchemaGetter.transformEffect((value, options) =>\n        Effect.try({\n          try: () =>\n            Result.match(\n              Schema.decodeUnknownResult(\n                Schema.Struct({ $undefined: Schema.Literal(true) }),\n                { onExcessProperty: \"error\" },\n              )(value),\n              {\n                onSuccess: () => undefined,\n                onFailure: () =>\n                  jsonToConvex(value as Parameters<typeof jsonToConvex>[0]),\n              },\n            ),\n          catch: () =>\n            new SchemaIssue.InvalidValue(\n              { message: \"Invalid Convex key value\" },\n              value,\n              options,\n            ),\n        }),\n      ),\n      encode: SchemaGetter.transform((value) =>\n        value === undefined ? UNDEFINED_SENTINEL : convexToJson(value),\n      ),\n    },\n  ),\n);\n\n/**\n * @experimental\n */\nexport type KeyValue = typeof KeyValue.Type;\n\n/**\n * @experimental\n */\nexport const QueryStreamKeyValues = Schema.Array(KeyValue);\n\n/**\n * @experimental\n */\nexport type QueryStreamKeyValues = typeof QueryStreamKeyValues.Type;\n\n/**\n * `Order` over Convex values, matching Convex's index ordering—a wrapper around\n * the canonical `compareValues` from `convex/values` (type rank first, then\n * within the type, including UTF-8 string order and NaN bit-level ordering).\n *\n * @experimental\n */\nexport const ValueOrder: Order_.Order<KeyValue> = Order_.make(\n  (self, that) => Math.sign(compareValues(self, that)) as -1 | 0 | 1,\n);\n\nconst AscendingOrder = Order_.Array(ValueOrder);\nconst DescendingOrder = Order_.flip(AscendingOrder);\n\n/**\n * Compare key values in the requested direction. Ascending order is\n * lexicographic by `ValueOrder`, then by length, matching Convex array values;\n * descending order reverses it.\n *\n * @experimental\n */\nexport const Order = (\n  orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection,\n): Order_.Order<QueryStreamKeyValues> =>\n  orderDirection === \"asc\" ? AscendingOrder : DescendingOrder;\n\n/**\n * @experimental\n */\nexport const extract = (\n  encoded: Record.ReadonlyRecord<string, unknown>,\n  keyPaths: ReadonlyArray<ReadonlyArray<string>>,\n): QueryStreamKeyValues =>\n  Array.map(keyPaths, (path) =>\n    Array.reduce(\n      path,\n      encoded as unknown,\n      (value, segment) =>\n        (value as Record.ReadonlyRecord<string, unknown> | undefined)?.[\n          segment\n        ],\n    ),\n  ) as QueryStreamKeyValues;\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,qBAAqB,EAAE,YAAY,KAAK;AAC9C,MAAM,WAAW,OAAO,KAAK,KAC3B,OAAO,SACL,OAAO,SACJ,UACC,UAAU,KAAA,KACV,OAAO,UAAU,OAAO,UAAU,aAAa,KAAc,CAAC,CAAC,CACnE,GACA;CACE,QAAQ,aAAa,iBAAiB,OAAO,YAC3C,OAAO,IAAI;EACT,WACE,OAAO,MACL,OAAO,oBACL,OAAO,OAAO,EAAE,YAAY,OAAO,QAAQ,IAAI,EAAE,CAAC,GAClD,EAAE,kBAAkB,QAAQ,CAC9B,CAAC,CAAC,KAAK,GACP;GACE,iBAAiB,KAAA;GACjB,iBACE,aAAa,KAA2C;EAC5D,CACF;EACF,aACE,IAAI,YAAY,aACd,EAAE,SAAS,2BAA2B,GACtC,OACA,OACF;CACJ,CAAC,CACH;CACA,QAAQ,aAAa,WAAW,UAC9B,UAAU,KAAA,IAAY,qBAAqB,aAAa,KAAK,CAC/D;AACF,CACF,CACF;;;;AAUA,MAAa,uBAAuB,OAAO,MAAM,QAAQ;;;;;;;;AAczD,MAAa,aAAqC,OAAO,MACtD,MAAM,SAAS,KAAK,KAAK,cAAc,MAAM,IAAI,CAAC,CACrD;AAEA,MAAM,iBAAiB,OAAO,MAAM,UAAU;AAC9C,MAAM,kBAAkB,OAAO,KAAK,cAAc;;;;;;;;AASlD,MAAa,SACX,mBAEA,mBAAmB,QAAQ,iBAAiB;;;;AAK9C,MAAa,WACX,SACA,aAEA,MAAM,IAAI,WAAW,SACnB,MAAM,OACJ,MACA,UACC,OAAO,YACL,QACC,QAEN,CACF"}

package/dist/QueryStreamOrderDirection.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The direction a stream is ordered in. Tracked covariantly in the type: a
+ * stream of a known direction is also a stream of `"asc" | "desc"`, the class
+ * default, so annotations that omit the direction accept every stream.
+ * Combining streams of different known directions—`merge`, or a `flatMap` whose
+ * inner streams run the other way—is a type error; a direction chosen at
+ * runtime types as the union, and the runtime check catches what the types
+ * can't see (`merge` throws when the streams are combined, `flatMap` fails when
+ * the join runs).
+ *
+ * @experimental
+ */
+export type QueryStreamOrderDirection = "asc" | "desc";
+/**
+ * The opposite of a direction; a runtime-chosen direction stays the union.
+ *
+ * @experimental
+ */
+export type Flip<OrderDirection extends QueryStreamOrderDirection> = OrderDirection extends "asc" ? "desc" : "asc";
+/**
+ * @experimental
+ */
+export declare const flip: <OrderDirection extends QueryStreamOrderDirection>(orderDirection: OrderDirection) => Flip<OrderDirection>;
+//# sourceMappingURL=QueryStreamOrderDirection.d.ts.map

package/dist/QueryStreamOrderDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamOrderDirection.d.ts","sourceRoot":"","sources":["../src/QueryStreamOrderDirection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,yBAAyB,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvD;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,cAAc,SAAS,yBAAyB,IAC/D,cAAc,SAAS,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,cAAc,SAAS,yBAAyB,kBACnD,cAAc,KAC7B,IAAI,CAAC,cAAc,CAC+C,CAAC"}

package/dist/QueryStreamOrderDirection.js

@@ -0,0 +1,11 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/QueryStreamOrderDirection.ts
+var QueryStreamOrderDirection_exports = /* @__PURE__ */ __exportAll({ flip: () => flip });
+/**
+* @experimental
+*/
+const flip = (orderDirection) => orderDirection === "asc" ? "desc" : "asc";
+//#endregion
+export { QueryStreamOrderDirection_exports, flip };
+
+//# sourceMappingURL=QueryStreamOrderDirection.js.map

package/dist/QueryStreamOrderDirection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamOrderDirection.js","names":[],"sources":["../src/QueryStreamOrderDirection.ts"],"sourcesContent":["/**\n * The direction a stream is ordered in. Tracked covariantly in the type: a\n * stream of a known direction is also a stream of `\"asc\" | \"desc\"`, the class\n * default, so annotations that omit the direction accept every stream.\n * Combining streams of different known directions—`merge`, or a `flatMap` whose\n * inner streams run the other way—is a type error; a direction chosen at\n * runtime types as the union, and the runtime check catches what the types\n * can't see (`merge` throws when the streams are combined, `flatMap` fails when\n * the join runs).\n *\n * @experimental\n */\nexport type QueryStreamOrderDirection = \"asc\" | \"desc\";\n\n/**\n * The opposite of a direction; a runtime-chosen direction stays the union.\n *\n * @experimental\n */\nexport type Flip<OrderDirection extends QueryStreamOrderDirection> =\n  OrderDirection extends \"asc\" ? \"desc\" : \"asc\";\n\n/**\n * @experimental\n */\nexport const flip = <OrderDirection extends QueryStreamOrderDirection>(\n  orderDirection: OrderDirection,\n): Flip<OrderDirection> =>\n  (orderDirection === \"asc\" ? \"desc\" : \"asc\") as Flip<OrderDirection>;\n"],"mappings":";;;;;;AAyBA,MAAa,QACX,mBAEC,mBAAmB,QAAQ,SAAS"}

package/dist/QueryStreamPagination.d.ts

@@ -0,0 +1,264 @@
+import * as Chunk from "effect/Chunk";
+import * as Data from "effect/Data";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import type * as QueryStreamKey from "./QueryStreamKey";
+declare const PageSize: Schema.brand<Schema.Natural, "~@confect/server/QueryStreamPagination/PageSize">;
+type PageSize = typeof PageSize.Type;
+declare const InvalidPageSizeError_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]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidPageSizeError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class InvalidPageSizeError extends InvalidPageSizeError_base<{
+    readonly numItems: number;
+}> {
+    get message(): string;
+}
+declare const EmptyInitialPageError_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]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EmptyInitialPageError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class EmptyInitialPageError extends EmptyInitialPageError_base {
+    get message(): string;
+}
+/**
+ * @experimental
+ */
+export type Range = Data.TaggedEnum<{
+    Unpinned: {};
+    ThroughKey: {
+        readonly key: QueryStreamKey.Complete;
+    };
+    ThroughEnd: {};
+}>;
+/**
+ * @experimental
+ */
+export declare const Range: {
+    readonly $is: <Tag extends "ThroughEnd" | "ThroughKey" | "Unpinned">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "ThroughEnd";
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "ThroughKey";
+        readonly key: QueryStreamKey.Complete;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Unpinned";
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "ThroughEnd" | "ThroughKey" | "Unpinned"]: (args: Extract<{
+            readonly _tag: "ThroughEnd";
+        } | {
+            readonly _tag: "ThroughKey";
+            readonly key: QueryStreamKey.Complete;
+        } | {
+            readonly _tag: "Unpinned";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "ThroughEnd";
+        } | {
+            readonly _tag: "ThroughKey";
+            readonly key: QueryStreamKey.Complete;
+        } | {
+            readonly _tag: "Unpinned";
+        }) => import("effect/Unify").Unify<ReturnType<Cases["ThroughEnd" | "ThroughKey" | "Unpinned"]>>;
+        <Cases extends { readonly [Tag in "ThroughEnd" | "ThroughKey" | "Unpinned"]: (args: Extract<{
+            readonly _tag: "ThroughEnd";
+        } | {
+            readonly _tag: "ThroughKey";
+            readonly key: QueryStreamKey.Complete;
+        } | {
+            readonly _tag: "Unpinned";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "ThroughEnd";
+        } | {
+            readonly _tag: "ThroughKey";
+            readonly key: QueryStreamKey.Complete;
+        } | {
+            readonly _tag: "Unpinned";
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["ThroughEnd" | "ThroughKey" | "Unpinned"]>>;
+    };
+    readonly ThroughEnd: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "ThroughEnd";
+    }, "_tag">;
+    readonly ThroughKey: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "ThroughKey";
+        readonly key: QueryStreamKey.Complete;
+    }, "_tag">;
+    readonly Unpinned: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Unpinned";
+    }, "_tag">;
+};
+/**
+ * @experimental
+ */
+export type Start = Data.TaggedEnum<{
+    Beginning: {};
+    After: {
+        readonly key: QueryStreamKey.Complete;
+        readonly cursor: string;
+    };
+}>;
+/**
+ * @experimental
+ */
+export declare const Start: {
+    readonly $is: <Tag extends "After" | "Beginning">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "After";
+        readonly key: QueryStreamKey.Complete;
+        readonly cursor: string;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Beginning";
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "After" | "Beginning"]: (args: Extract<{
+            readonly _tag: "After";
+            readonly key: QueryStreamKey.Complete;
+            readonly cursor: string;
+        } | {
+            readonly _tag: "Beginning";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "After";
+            readonly key: QueryStreamKey.Complete;
+            readonly cursor: string;
+        } | {
+            readonly _tag: "Beginning";
+        }) => import("effect/Unify").Unify<ReturnType<Cases["After" | "Beginning"]>>;
+        <Cases extends { readonly [Tag in "After" | "Beginning"]: (args: Extract<{
+            readonly _tag: "After";
+            readonly key: QueryStreamKey.Complete;
+            readonly cursor: string;
+        } | {
+            readonly _tag: "Beginning";
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "After";
+            readonly key: QueryStreamKey.Complete;
+            readonly cursor: string;
+        } | {
+            readonly _tag: "Beginning";
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["After" | "Beginning"]>>;
+    };
+    readonly After: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "After";
+        readonly key: QueryStreamKey.Complete;
+        readonly cursor: string;
+    }, "_tag">;
+    readonly Beginning: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Beginning";
+    }, "_tag">;
+};
+/**
+ * @experimental
+ */
+export interface ScanRequest {
+    readonly numItems: PageSize;
+    readonly after: Option.Option<QueryStreamKey.Complete>;
+    readonly range: Range;
+}
+/**
+ * @experimental
+ */
+export type Request = Data.TaggedEnum<{
+    Unchanged: {
+        readonly cursor: string;
+    };
+    Scan: ScanRequest;
+}>;
+/**
+ * @experimental
+ */
+export declare const parseRequest: (numItems: number, start: Start, range: Range) => Result.Result<Request, InvalidPageSizeError | EmptyInitialPageError>;
+/**
+ * A nonempty scan, including filtered markers.
+ */
+type Progress = Chunk.NonEmptyChunk<QueryStreamKey.Complete>;
+interface Stopped<Doc> {
+    readonly page: Chunk.Chunk<Doc>;
+    readonly progress: Progress;
+}
+/**
+ * @experimental
+ */
+export type QueryStreamPagination<Doc> = Data.TaggedEnum<{
+    Reading: {
+        readonly page: Chunk.Chunk<Doc>;
+        readonly progress: Option.Option<Progress>;
+    };
+    ItemLimit: Stopped<Doc>;
+    ReadLimit: Stopped<Doc>;
+}>;
+/**
+ * @experimental
+ */
+export declare const initial: <Doc>() => QueryStreamPagination<Doc>;
+/**
+ * @experimental
+ */
+export declare const record: <Doc>(request: ScanRequest, self: QueryStreamPagination<Doc>, doc: Option.Option<Doc>, key: QueryStreamKey.Complete, readLimit: boolean) => QueryStreamPagination<Doc>;
+/**
+ * @experimental
+ */
+export type Continuation = Data.TaggedEnum<{
+    End: {};
+    Key: {
+        readonly key: QueryStreamKey.Complete;
+    };
+}>;
+interface Split<Doc> {
+    readonly page: ReadonlyArray<Doc>;
+    readonly continuation: Continuation;
+    readonly splitKey: QueryStreamKey.Complete;
+}
+/**
+ * @experimental
+ */
+export type Outcome<Doc> = Data.TaggedEnum<{
+    Done: {
+        readonly page: ReadonlyArray<Doc>;
+    };
+    Continue: {
+        readonly page: ReadonlyArray<Doc>;
+        readonly key: QueryStreamKey.Complete;
+    };
+    SplitRequired: Split<Doc>;
+    SplitRecommended: Split<Doc>;
+}>;
+declare const UnsafePageBoundaryError_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]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnsafePageBoundaryError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class UnsafePageBoundaryError extends UnsafePageBoundaryError_base<{
+    readonly reason: "NoProgress" | "NoInteriorSplit";
+}> {
+    get message(): string;
+}
+/**
+ * Decide the page result without reading a stream or serializing a cursor.
+ *
+ * @experimental
+ */
+export declare const finish: <Doc>(request: ScanRequest, self: QueryStreamPagination<Doc>, upstreamStopped: boolean) => Result.Result<Outcome<Doc>, UnsafePageBoundaryError>;
+export {};
+//# sourceMappingURL=QueryStreamPagination.d.ts.map

package/dist/QueryStreamPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamPagination.d.ts","sourceRoot":"","sources":["../src/QueryStreamPagination.ts"],"names":[],"mappings":"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"}