@kairos-es/feed-algolia 0.0.0-stage → 0.0.0

package/dist/esm/sink.js

@@ -0,0 +1,454 @@
+/**
+ * `makeAlgoliaSink` — a `FeedSink` onto one served Algolia index, with both optional
+ * parts: a `FeedResync` built on Algolia's index copy and move, and a
+ * `FeedReconcile` built on `browse`.
+ *
+ * ## The steady state
+ *
+ * `apply` is ONE `batch` to the served index (`records.ts` owns what goes in it and
+ * which records are refused before it is sent), and its receipt is the index and
+ * the task Algolia returned. `confirm` polls `getTask` on that index until the task
+ * is `published`, which is the moment Algolia serves the batch — the moment the
+ * port's `confirm` promises. The poll runs on an Effect `Schedule`: it backs off
+ * from `taskPolling.initialDelay`, doubling to `taskPolling.maxDelay`, and no poll
+ * STARTS after `taskPolling.timeout` has passed since the wait began — the last
+ * wait is cut short to land on that deadline rather than overrun it by up to
+ * `maxDelay`. A task still unpublished then is a `SinkRetryable`: the driver
+ * resends the batch, which is safe, rather than waiting on a task without bound.
+ * A poll that has started can still outlast the deadline by its own request
+ * timeout (`rest.ts`). A `Schedule` rather than a hand-written loop because the
+ * curve is then one declared value, run under the `Clock`, so a test's
+ * `TestClock` drives it like any other wait.
+ *
+ * ## Resync: a fresh index, swapped in whole
+ *
+ * Algolia's `operationIndex` move replaces the destination index atomically, which
+ * is exactly the swap `FeedResync` asks for. So:
+ *
+ * - `begin(generation)` names the target `<served>__kairos_g<generation>_<attempt>`,
+ *   where `<attempt>` is drawn from Effect's `Random` afresh on every call, and
+ *   then COPIES the served index into it with `scope` limited to settings, synonyms
+ *   and rules. The fresh index then ranks and matches exactly as the served one does,
+ *   and holds none of its records. A served index that has never been written has no
+ *   scope to copy, and that is not an error: `begin` reads the served index's
+ *   settings first and makes no copy when it does not exist. Algolia would copy a
+ *   missing source as an empty index, but the copy's task is polled on the served
+ *   index, and `getTask` on an index that does not exist answers 404, so skipping
+ *   the copy is what keeps that wait off a missing index. The name is the ATTEMPT's, not the
+ *   generation's, because two workers can be resyncing one generation at once —
+ *   one of them having lost its lease without knowing it yet — and a target they
+ *   shared is one either could publish half-built; `runFeedSync.ts` owns the
+ *   argument. Random rather than the lease holder's id, because the port hands a
+ *   sink no lease, and a draw needs none.
+ * - `begin` then MARKS the target as its attempt's own: it writes the target's
+ *   `userData` setting as whatever the copy brought from the served index, plus one
+ *   key, `kairosResyncAttempt`, holding the attempt. Algolia creates an index on a
+ *   settings write, so this is also what makes the target EXIST whatever the copy
+ *   did — over a served index never written, and for a rebuild that loads nothing.
+ *   The mark is what `publish` checks, below. It goes in `userData` because that
+ *   is the one setting Algolia keeps for the application's own data and reads
+ *   nothing from, so the mark changes nothing about how the target ranks or
+ *   matches.
+ * - `begin` first drops every OTHER resync index of this served index it can list,
+ *   whatever its generation, settings snapshots included. Each was left by an attempt that will never publish
+ *   it now — one that crashed, one abandoned because the generation moved, or one
+ *   a worker that lost its lease is still loading — and every such index holds
+ *   records against the application's quota; an ephemeral feed, whose generation
+ *   is new on every boot, would otherwise leave one behind per interrupted boot.
+ *   Dropping the one a stale worker is loading is also what makes that worker's
+ *   `publish` fail rather than land. Listing needs the key to carry Algolia's
+ *   `listIndexes` ACL, and the sink REQUIRES it rather than skipping the drop when
+ *   it is missing: without the drop, a stale worker's `publish` could land and
+ *   abandoned targets would pile up. A key without it is refused like any other
+ *   4xx, a `SinkHalted` at the start of the resync, before the copy, so nothing is
+ *   created.
+ * - `load` is `apply`, against the target. It does not check the mark: that would
+ *   cost a settings read per page and still race the drop, and `publish` is where
+ *   a target is served, so `publish` is where the check has to hold.
+ * - `publish` reads the target's settings and refuses, `SinkRetryable`, a target
+ *   that is missing or does not carry this attempt's mark; only then does it move
+ *   the target over the served index and wait on the move's task. Then it reads the
+ *   SERVED index's settings and reports success only if the served index now
+ *   carries this attempt's mark, which only this move could have put there;
+ *   otherwise it fails `SinkRetryable`. That read is the authority, and the
+ *   move's own answer is not: Algolia ignores a move of a missing index "without
+ *   returning an error", so a target dropped after the check gets a task back, the
+ *   task publishes, and the served index still holds the old copy. Taking that for
+ *   success would let the driver save its cursor at the new generation over an
+ *   index that never got it. For the same
+ *   reason a 404 on the move's task poll — `getTask` on an index that no longer
+ *   exists — ends the wait rather than halting, and the read decides. An empty rebuild
+ *   is a move like any other, of a target that holds no records, and it leaves the
+ *   served index empty. A target can go missing before its publish in two ways: a
+ *   newer `begin` dropped it, or something moved it over the served index first.
+ *   Only the second could ever land a half-built target, and the per-attempt name
+ *   is what rules it out: the one `publish` that names this target is this
+ *   attempt's own, so no other worker's can move it. What is left is the first,
+ *   and it has a second form, which is why the mark exists: a worker that lost its
+ *   lease without knowing it goes on LOADING into its dropped target, and Algolia
+ *   creates an index on a batch write, so the target comes back holding the stale
+ *   worker's later pages alone. A name alone cannot tell that index from the one
+ *   `begin` made; the missing mark can, since only `begin` writes it. Either way
+ *   `publish` fails `SinkRetryable` and the resync starts again. It never touches
+ *   the served index on that account, since the worker that finds its target gone
+ *   is the one most likely to have lost the lease. An index a stale load brought
+ *   back is left where it is, and the next `begin` drops it with the rest.
+ * - Before it marks the target, `begin` takes a SNAPSHOT of the served index's
+ *   settings into `<target>__settings`, a settings-scoped copy, or an empty
+ *   settings write when the served index does not exist. After the move has landed,
+ *   `publish` takes the mark back off the served index by copying the snapshot's
+ *   settings over it, scoped to settings, then drops the snapshot. The drop is a
+ *   best effort of its own, and runs whether or not the restore landed. A copy is
+ *   the one write that REMOVES a setting: Algolia stores a `null` written to `userData` as
+ *   the value `null`, and `{}` or `resetToDefault` leave an empty object, so a
+ *   rebuild of an index that had no `userData` would otherwise leave one behind.
+ *   The snapshot is a second copy of the same served index's settings, made just
+ *   after the target's, so the restore changes nothing else unless those settings
+ *   changed between the two copies, when it applies the later ones. Its scope is
+ *   SETTINGS ONLY, and must stay so: the snapshot holds no synonyms or rules, so a
+ *   wider restore would wipe the served index's. Records are untouched, and so are the
+ *   served index's replicas (see below). A mark an earlier failed restore left on the
+ *   served index is taken off the snapshot as it is made, so it cannot come
+ *   back; when it was all the `userData` there was, a settings write is the only
+ *   way to take it off, and the `null` Algolia stores for it is what remains.
+ *   The move and the restore are two steps, so a search index briefly carries the
+ *   key, which nothing reads. The restore is BEST-EFFORT: the swap has
+ *   already landed, and failing `publish` now would tell the driver it had not. A
+ *   snapshot that is gone (a newer `begin` dropped it) is not copied, since a copy
+ *   from a missing index changes nothing and its task never publishes; the mark
+ *   then stays until the next rebuild's restore, and a warning says so. One that
+ *   goes between that check and the copy is reported the same way, once the wait
+ *   on the copy's task ends: at the first poll, if `getTask` on the missing index
+ *   answers 404 as above, and at `pollTimeout` if it does not. The swap has landed
+ *   by then, so the worst cost is a `publish` that returns late, not a wrong one.
+ *
+ * Check-then-move leaves no gap a stale load can use: the only worker that loads
+ * into this target is the one publishing it, and its loads have finished. A drop
+ * between the check and the move makes the move a no-op, which the read of the
+ * served index after it turns into a `SinkRetryable`, as above. Taking the mark
+ * off the TARGET before the move would open one: a drop between that write and
+ * the move, and the write itself would bring back an empty target for the move to
+ * land.
+ *
+ * Replicas are the one thing this does not settle by construction: a copy with
+ * `scope` is not documented to carry a primary's replicas to the target, nor a
+ * move over a primary, or the restore's settings-scoped copy over it, to keep
+ * them. Measured against a real application, all three leave them where they
+ * were, and the package's live test checks it after `publish` when credentials
+ * are present.
+ *
+ * ## Reconcile
+ *
+ * `listKeys` browses the served index page by page, retrieving `objectID` and nothing
+ * else, so listing a large index costs the ids and not the records.
+ *
+ * ## The key's ACLs
+ *
+ * A scoped key needs `addObject` (record writes, and the copy and the move),
+ * `deleteObject`, `deleteIndex` (the drop), `settings` (the mark check),
+ * `editSettings` (writing and removing the mark), `browse` (reconcile) and
+ * `listIndexes` (the drop's listing), on the served index and its resync indices.
+ * The README states the same set, ACL by ACL, for a consumer.
+ *
+ * ## What the sink holds
+ *
+ * Nothing between calls but its options and the captured `HttpClient`: no queue, no
+ * cursor, no buffered batch. Every piece of progress is the driver's, which is what
+ * lets a resent batch and a restarted resync be safe.
+ */
+import { FeedKey, SinkHalted, SinkRetryable } from '@kairos-es/feed';
+import { Clock, Duration, Effect, Option, Random, Schedule, Stream } from 'effect';
+import { AlgoliaIndexName } from "./identifiers.js";
+import { DEFAULT_MAX_RECORD_BYTES, encodeBatch } from "./records.js";
+import { makeAlgoliaRest } from "./rest.js";
+/**
+ * The resync target's name for one attempt at `generation`. PACKAGE-INTERNAL, and
+ * kept off the entry point deliberately: `attempt` is what `begin` draws for each
+ * call, so a real target's name is the one `begin` returns, and a consumer has no
+ * use for composing one.
+ *
+ * It does not check `attempt`. Every caller here passes lower-case base-36
+ * digits, which `begin` draws and the tests write by hand, and that shape is all
+ * `resyncGenerationOf` below recognises: a suffix of any other shape would name an
+ * index that `begin` never drops and `publish` never accepts.
+ */
+export const resyncIndexName = (served, generation, attempt) => AlgoliaIndexName.make(`${served}__kairos_g${generation}_${attempt}`);
+/**
+ * The generation `name` rebuilds, when it is a resync target of `served` for SOME
+ * generation and attempt, and `undefined` otherwise: the prefix, the decimal digits
+ * a `Generation` prints as, an underscore, then base-36 digits and nothing else,
+ * so a served index that merely starts with this one's name plus `__kairos_g` is not
+ * mistaken for one of its targets.
+ */
+const resyncGenerationOf = (served, name) => {
+  const prefix = `${served}__kairos_g`;
+  if (!name.startsWith(prefix)) {
+    return undefined;
+  }
+  return /^(\d+)_[0-9a-z]+$/.exec(name.slice(prefix.length))?.[1];
+};
+/**
+ * The settings snapshot `begin` takes for `target`: the served index's settings as
+ * the target got them, before the mark. Named after its target, so it is a resync
+ * index of the same served index and `begin`'s drop of leftovers takes a snapshot an
+ * interrupted attempt left, as it takes the target.
+ */
+const settingsSnapshotName = target => AlgoliaIndexName.make(`${target}__settings`);
+/**
+ * Whether `name` is any resync index of `served`: a target, or a target's settings
+ * snapshot. What `begin` drops; `resyncGenerationOf` alone is what a target must be.
+ */
+const isResyncIndexOf = (served, name) => resyncGenerationOf(served, name.replace(/__settings$/, '')) !== undefined;
+/**
+ * The attempt a resync target's name ends in: the base-36 digits after its last
+ * underscore. Called only on a name `targetIndex` has already checked.
+ */
+const attemptOf = name => /_([0-9a-z]+)$/.exec(name)?.[1] ?? '';
+/** The `userData` key `begin` marks its target with; see the module doc. */
+const ATTEMPT_MARK = 'kairosResyncAttempt';
+/** Digits in a resync target's attempt suffix: 12 base-36 digits, about 62 bits. */
+const ATTEMPT_DIGITS = 12;
+/** One base-36 digit's worth of `Random`, `ATTEMPT_DIGITS` times. */
+const drawAttempt = /*#__PURE__*/Effect.map(/*#__PURE__*/Effect.all(/*#__PURE__*/Array.from({
+  length: ATTEMPT_DIGITS
+}, () => Random.nextIntBetween(0, 35))), digits => digits.map(d => d.toString(36)).join(''));
+const RESYNC_SCOPE = ['settings', 'synonyms', 'rules'];
+/** Index names per `listIndices` page; Algolia's own default. */
+const LIST_PAGE_SIZE = 100;
+const DEFAULT_POLL_INITIAL = /*#__PURE__*/Duration.millis(100);
+const DEFAULT_POLL_MAX = /*#__PURE__*/Duration.seconds(2);
+const DEFAULT_POLL_TIMEOUT = /*#__PURE__*/Duration.seconds(60);
+const DEFAULT_BROWSE_PAGE = 1_000;
+/** A positive duration from an option, or the default; dies on nonsense. */
+const durationOption = (label, input, fallback) => {
+  if (input === undefined) {
+    return fallback;
+  }
+  const decoded = Duration.fromInputUnsafe(input);
+  if (!Duration.isFinite(decoded) || Duration.toMillis(decoded) <= 0) {
+    throw new Error(`feed-algolia: ${label} must be a positive, finite duration`);
+  }
+  return decoded;
+};
+const positiveInteger = (label, value, fallback) => {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`feed-algolia: ${label} must be a positive integer (got ${value})`);
+  }
+  return value;
+};
+/**
+ * An index's `userData` setting as an object to add a key to or take one from:
+ * empty when the index has none. A `userData` that is not a JSON object leaves no
+ * room for the mark beside it, and is a halt rather than something to overwrite.
+ */
+const userDataOf = (index, settings) => {
+  const userData = Option.isSome(settings) ? settings.value.userData : undefined;
+  if (userData === undefined || userData === null) {
+    return Effect.succeed({});
+  }
+  return typeof userData === 'object' && !Array.isArray(userData) ? Effect.succeed(userData) : Effect.fail(new SinkHalted({
+    reason: `feed-algolia: the userData setting of '${index}' is not a JSON object, so a resync cannot mark its target beside it`
+  }));
+};
+/**
+ * The resync mark an index's settings carry, if any. Unlike {@link userDataOf} it
+ * never halts: after a move, a `userData` that is not an object only means the
+ * move did not land, which is the retryable case.
+ */
+const attemptMarkOf = settings => {
+  const userData = Option.isSome(settings) ? settings.value.userData : undefined;
+  return typeof userData === 'object' && userData !== null && !Array.isArray(userData) ? userData[ATTEMPT_MARK] : undefined;
+};
+/**
+ * Narrow a call that sends no records. Only a write can be refused per record, so
+ * a `SinkRejected` from anything else is a bug in this package's classification;
+ * it is reported as a halt rather than silently dropped.
+ */
+const noRejection = effect => Effect.mapError(effect, failure => failure._tag === 'SinkRejected' ? new SinkHalted({
+  reason: `feed-algolia: a call that sends no records was refused per record: ${failure.message}`
+}) : failure);
+/**
+ * Build an Algolia sink over the `HttpClient` in context; see the module doc.
+ * Dies at once on options out of range.
+ */
+export const makeAlgoliaSink = options => Effect.gen(function* () {
+  const settings = yield* Effect.try({
+    try: () => ({
+      maxRecordBytes: positiveInteger('maxRecordBytes', options.maxRecordBytes, DEFAULT_MAX_RECORD_BYTES),
+      browsePageSize: positiveInteger('browsePageSize', options.browsePageSize, DEFAULT_BROWSE_PAGE),
+      pollInitial: durationOption('taskPolling.initialDelay', options.taskPolling?.initialDelay, DEFAULT_POLL_INITIAL),
+      pollMax: durationOption('taskPolling.maxDelay', options.taskPolling?.maxDelay, DEFAULT_POLL_MAX),
+      pollTimeout: durationOption('taskPolling.timeout', options.taskPolling?.timeout, DEFAULT_POLL_TIMEOUT)
+    }),
+    catch: error => error
+  }).pipe(Effect.orDie);
+  const rest = yield* makeAlgoliaRest(options);
+  const served = options.index;
+  const pollTimeoutMillis = Duration.toMillis(settings.pollTimeout);
+  /**
+   * The curve a task poll waits on between polls: doubling from the first delay,
+   * capped, and never past `deadline` — the last delay is cut to land on it, and
+   * nothing recurs once it is reached. Built per wait, since the deadline is
+   * the wait's own; the curve is the same for every one.
+   */
+  const pollSchedule = deadline => Schedule.min([Schedule.exponential(settings.pollInitial, 2), Schedule.spaced(settings.pollMax)]).pipe(Schedule.while(({
+    now
+  }) => now < deadline), Schedule.modifyDelay(({
+    now,
+    duration
+  }) => Effect.succeed(Duration.millis(Math.min(Duration.toMillis(duration), deadline - now)))));
+  /**
+   * Poll until `poll` is done; see the module doc for the curve. `poll` answers
+   * whether to stop, which for every wait but one is "the task is published".
+   */
+  const pollUntil = (index, taskID, poll) => Effect.gen(function* () {
+    const deadline = (yield* Clock.currentTimeMillis) + pollTimeoutMillis;
+    const done = yield* poll.pipe(Effect.repeat({
+      schedule: pollSchedule(deadline),
+      until: d => d
+    }));
+    if (!done) {
+      return yield* Effect.fail(new SinkRetryable({
+        reason: `Algolia task ${taskID} on index '${index}' was not published within ${Duration.format(settings.pollTimeout)}`
+      }));
+    }
+  });
+  /** Poll a task until it is published; see the module doc for the curve. */
+  const awaitTask = (index, taskID) => pollUntil(index, taskID, noRejection(rest.taskPublished(index, taskID)));
+  /** Wait on a task an index operation may or may not have returned. */
+  const awaitIfAny = (index, task) => Option.match(task, {
+    onNone: () => Effect.void,
+    onSome: taskID => awaitTask(index, taskID)
+  });
+  const send = (index, batch) => Effect.gen(function* () {
+    const encoded = yield* encodeBatch(options.doc, settings.maxRecordBytes, batch);
+    const taskID = yield* rest.batch(index, encoded.operations, encoded.keys);
+    return {
+      index,
+      taskID
+    };
+  });
+  /**
+   * The target's index name, refusing a target this sink did not begin: a
+   * target is named after the served index, its generation and its attempt, and a
+   * load into any other index would write somewhere no publish of this sink will
+   * move.
+   */
+  const targetIndex = target => resyncGenerationOf(served, target.name) === `${target.generation}` ? Effect.succeed(AlgoliaIndexName.make(target.name)) : Effect.die(new Error(`feed-algolia: the resync target '${target.name}' is not one of this sink's targets for generation ${target.generation} ('${served}__kairos_g${target.generation}_<attempt>')`));
+  /** Every name `listIndices` returns, page by page. */
+  const allIndexNames = Stream.paginate(0, page => Effect.map(noRejection(rest.listIndexNames(page, LIST_PAGE_SIZE)), answer => [answer.names, answer.more ? Option.some(page + 1) : Option.none()]));
+  /** Drop every resync target of `served` but `keep`; see the module doc. */
+  const dropAbandonedTargets = keep => Effect.gen(function* () {
+    const names = yield* Stream.runCollect(allIndexNames);
+    for (const name of names) {
+      if (name === keep || !isResyncIndexOf(served, name)) {
+        continue;
+      }
+      const index = AlgoliaIndexName.make(name);
+      yield* awaitIfAny(index, yield* noRejection(rest.deleteIndex(index)));
+    }
+  });
+  const resync = {
+    begin: generation => Effect.gen(function* () {
+      const attempt = yield* drawAttempt;
+      const target = resyncIndexName(served, generation, attempt);
+      yield* dropAbandonedTargets(target);
+      const snapshot = settingsSnapshotName(target);
+      // No copy of a served index that does not exist; see the module doc.
+      if (Option.isSome(yield* noRejection(rest.readSettings(served)))) {
+        yield* awaitTask(served, yield* noRejection(rest.operation(served, {
+          operation: 'copy',
+          destination: target,
+          scope: RESYNC_SCOPE
+        })));
+        yield* awaitTask(served, yield* noRejection(rest.operation(served, {
+          operation: 'copy',
+          destination: snapshot,
+          scope: ['settings']
+        })));
+        // A mark a failed restore left on the served index must not ride into
+        // the snapshot, or every restore would put it back.
+        const {
+          [ATTEMPT_MARK]: stale,
+          ...kept
+        } = yield* userDataOf(snapshot, yield* noRejection(rest.readSettings(snapshot)));
+        if (stale !== undefined) {
+          yield* awaitTask(snapshot, yield* noRejection(rest.writeSettings(snapshot, {
+            userData: Object.keys(kept).length === 0 ? null : kept
+          })));
+        }
+      } else {
+        // An index with every setting at its default, which is what the
+        // served index has; an empty settings write creates it.
+        yield* awaitTask(snapshot, yield* noRejection(rest.writeSettings(snapshot, {})));
+      }
+      const userData = yield* userDataOf(target, yield* noRejection(rest.readSettings(target)));
+      yield* awaitTask(target, yield* noRejection(rest.writeSettings(target, {
+        userData: {
+          ...userData,
+          [ATTEMPT_MARK]: attempt
+        }
+      })));
+      return {
+        generation,
+        name: target
+      };
+    }),
+    load: (target, batch) => Effect.flatMap(targetIndex(target), index => send(index, batch)),
+    publish: target => Effect.gen(function* () {
+      const index = yield* targetIndex(target);
+      const found = yield* noRejection(rest.readSettings(index));
+      const userData = yield* userDataOf(index, found);
+      if (userData[ATTEMPT_MARK] !== attemptOf(index)) {
+        return yield* Effect.fail(new SinkRetryable({
+          reason: Option.isNone(found) ? `the resync index '${index}' vanished before it could be moved over '${served}'` : `the resync index '${index}' is not the one its begin made (a load after a newer begin dropped it brought it back), so it is not moved over '${served}'`
+        }));
+      }
+      const moved = yield* noRejection(rest.operation(index, {
+        operation: 'move',
+        destination: served
+      }));
+      // A 404 on the poll ends the wait; the read below decides.
+      yield* pollUntil(index, moved, Effect.map(noRejection(rest.taskStateUnlessIndexMissing(index, moved)), state => state !== 'pending'));
+      const landed = yield* noRejection(rest.readSettings(served));
+      if (attemptMarkOf(landed) !== attemptOf(index)) {
+        return yield* Effect.fail(new SinkRetryable({
+          reason: `the move of the resync index '${index}' over '${served}' did not land: '${served}' does not carry its mark, so the index was dropped after publish checked it, or another attempt's move landed over it`
+        }));
+      }
+      // Best-effort, after the swap has landed; see the module doc.
+      const snapshot = settingsSnapshotName(index);
+      yield* Effect.gen(function* () {
+        // A copy from a missing snapshot changes nothing, and its task never
+        // publishes, so a snapshot a newer `begin` dropped is not waited on,
+        // unless it goes between this read and the copy; see the module doc.
+        if (Option.isNone(yield* noRejection(rest.readSettings(snapshot)))) {
+          return yield* Effect.fail(new SinkRetryable({
+            reason: `its settings snapshot '${snapshot}' is gone`
+          }));
+        }
+        yield* awaitTask(snapshot, yield* noRejection(rest.operation(snapshot, {
+          operation: 'copy',
+          destination: served,
+          scope: ['settings']
+        })));
+      }).pipe(Effect.catch(failure => Effect.logWarning(`feed-algolia: the resync mark was left in the userData of '${served}', and the next rebuild will take it off: ${failure.reason}`)));
+      // Separately, so a failed drop is not reported as a failed restore.
+      yield* Effect.flatMap(noRejection(rest.deleteIndex(snapshot)), task => awaitIfAny(snapshot, task)).pipe(Effect.catch(failure => Effect.logWarning(`feed-algolia: the settings snapshot '${snapshot}' was left behind, and the next rebuild will drop it: ${failure.reason}`)));
+    })
+  };
+  const reconcile = {
+    listKeys: Stream.paginate(Option.none(), cursor => Effect.map(noRejection(rest.browseObjectIds(served, cursor, settings.browsePageSize)), page => [page.objectIDs.filter(id => id.length > 0).map(id => FeedKey.make(id)), Option.map(page.cursor, Option.some)]))
+  };
+  return {
+    name: options.name,
+    apply: batch => send(served, batch),
+    confirm: receipt => awaitTask(receipt.index, receipt.taskID),
+    resync,
+    reconcile
+  };
+});
+//# sourceMappingURL=sink.js.map

package/dist/esm/sink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink.js","names":["FeedKey","SinkHalted","SinkRetryable","Clock","Duration","Effect","Option","Random","Schedule","Stream","AlgoliaIndexName","DEFAULT_MAX_RECORD_BYTES","encodeBatch","makeAlgoliaRest","resyncIndexName","served","generation","attempt","make","resyncGenerationOf","name","prefix","startsWith","undefined","exec","slice","length","settingsSnapshotName","target","isResyncIndexOf","replace","attemptOf","ATTEMPT_MARK","ATTEMPT_DIGITS","drawAttempt","map","all","Array","from","nextIntBetween","digits","d","toString","join","RESYNC_SCOPE","LIST_PAGE_SIZE","DEFAULT_POLL_INITIAL","millis","DEFAULT_POLL_MAX","seconds","DEFAULT_POLL_TIMEOUT","DEFAULT_BROWSE_PAGE","durationOption","label","input","fallback","decoded","fromInputUnsafe","isFinite","toMillis","Error","positiveInteger","value","Number","isInteger","userDataOf","index","settings","userData","isSome","succeed","isArray","fail","reason","attemptMarkOf","noRejection","effect","mapError","failure","_tag","message","makeAlgoliaSink","options","gen","try","maxRecordBytes","browsePageSize","pollInitial","taskPolling","initialDelay","pollMax","maxDelay","pollTimeout","timeout","catch","error","pipe","orDie","rest","pollTimeoutMillis","pollSchedule","deadline","min","exponential","spaced","while","now","modifyDelay","duration","Math","pollUntil","taskID","poll","currentTimeMillis","done","repeat","schedule","until","format","awaitTask","taskPublished","awaitIfAny","task","match","onNone","void","onSome","send","batch","encoded","doc","operations","keys","targetIndex","die","allIndexNames","paginate","page","listIndexNames","answer","names","more","some","none","dropAbandonedTargets","keep","runCollect","deleteIndex","resync","begin","snapshot","readSettings","operation","destination","scope","stale","kept","writeSettings","Object","load","flatMap","publish","found","isNone","moved","taskStateUnlessIndexMissing","state","landed","logWarning","reconcile","listKeys","cursor","browseObjectIds","objectIDs","filter","id","apply","confirm","receipt"],"sources":["../../src/sink.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@kairos-es/feed-algolia",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "An Algolia sink for the kairos-es change feed, over effect's own HttpClient",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/neverbland/kairos-es.git",
+    "directory": "packages/feed-algolia"
+  },
+  "sideEffects": [],
+  "homepage": "https://github.com/neverbland/kairos-es",
+  "peerDependencies": {
+    "effect": "^4.0.5",
+    "@kairos-es/feed": "^0.0.0"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts-cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/dts-esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/dts-cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {}
+  }
 }