@lde/search-typesense 0.2.0 → 0.4.0

package/dist/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAKhC;8EAC8E;AAC9E,MAAM,WAAW,cAAe,SAAQ,uBAAuB;IAC7D,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,OAAO,CAAC,QAAQ,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC3D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,EAClC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAwC1D"}

package/dist/adapter.js

@@ -1,214 +0,0 @@
-import { buildCollectionSchema, } from './collection-schema.js';
-const LOCK_COLLECTION = 'rebuild_locks';
-const DEFAULT_LOCK_TTL_MS = 10 * 60 * 1000;
-/**
- * Blue/green-rebuild the search index `options.name` from one declarative
- * source: the collection schema is derived from `searchType`
- * ({@link buildCollectionSchema}) and the documents are streamed in — one call
- * from declaration to live index.
- *
- * 1. create a fresh versioned collection (`${name}_<timestamp>`)
- * 2. stream `documents` into it in batches
- * 3. atomically repoint the `name` alias to the new collection, then
- *    drop the collection it superseded. The caller passes only the logical
- *    index `name`; the versioned collection name and the alias are managed here.
- *
- * The rebuild is **single-flight per index**: it first takes a lock (a marker
- * document in a `rebuild_locks` collection, created on demand) via Typesense’s
- * atomic create, so concurrent callers across pods never rebuild the same index
- * at once. This keeps blue/green safe under replication.
- *
- * `documents` is an async iterable (e.g. a streaming projection); only one
- * `batchSize`-sized chunk is held in memory at a time. On any failure before the
- * swap nothing is repointed, so the live alias never points at a partial build,
- * and the orphaned half-built collection is dropped.
- *
- * @returns the live collection name and the number of documents imported, or
- * `null` when the rebuild was skipped because another rebuild for the same index
- * was already running.
- *
- * Limitations:
- * - **Advisory, not a strict mutex.** The lock is built on Typesense, not a
- *   consensus store. Under a TTL-reclaim race two rebuilds can briefly run at
- *   once; this is safe because blue/green is idempotent (worst case: redundant
- *   work and a transient orphaned collection).
- * - **Single-flight, not coalescing.** A call made while a rebuild is in flight
- *   is skipped (returns `null`), not queued. If you must capture state that
- *   changed mid-build, re-trigger after the running rebuild finishes.
- * - **Lock TTL.** A rebuild that runs longer than `lockTtlMs` (default 10
- *   minutes) can be reclaimed by another caller and run concurrently; size the
- *   TTL above your longest rebuild.
- */
-export async function rebuild(client, documents, searchType, options) {
-    const { batchSize = 1000, lockTtlMs = DEFAULT_LOCK_TTL_MS, ...schemaOptions } = options;
-    const schema = buildCollectionSchema(searchType, schemaOptions);
-    const name = schemaOptions.name;
-    if (!(await acquireLock(client, name, lockTtlMs))) {
-        return null;
-    }
-    const collection = `${name}_${Date.now()}`;
-    try {
-        const previous = await aliasTarget(client, name);
-        await client.collections().create({ ...schema, name: collection });
-        let imported;
-        try {
-            imported = await importStreamed(client, collection, documents, batchSize);
-            await client.aliases().upsert(name, { collection_name: collection });
-        }
-        catch (error) {
-            // The build failed before the swap: the live alias is untouched, so just
-            // drop the orphaned half-built collection rather than let it accumulate.
-            await client
-                .collections(collection)
-                .delete()
-                .catch(() => undefined);
-            throw error;
-        }
-        if (previous !== undefined && previous !== collection) {
-            await client
-                .collections(previous)
-                .delete()
-                .catch(() => undefined);
-        }
-        return { collection, imported };
-    }
-    finally {
-        await releaseLock(client, name);
-    }
-}
-/** The collection an alias currently points at, or `undefined` if unset. */
-async function aliasTarget(client, alias) {
-    try {
-        const { collection_name } = await client.aliases(alias).retrieve();
-        return collection_name;
-    }
-    catch (error) {
-        if (httpStatus(error) === 404) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-/** Upsert a stream of documents in `batchSize` chunks; returns the count. */
-async function importStreamed(client, collection, documents, batchSize) {
-    let imported = 0;
-    let batch = [];
-    for await (const document of documents) {
-        batch.push(document);
-        if (batch.length >= batchSize) {
-            await importBatch(client, collection, batch);
-            imported += batch.length;
-            batch = [];
-        }
-    }
-    if (batch.length > 0) {
-        await importBatch(client, collection, batch);
-        imported += batch.length;
-    }
-    return imported;
-}
-/**
- * Create-or-replace one batch of whole documents, keyed on `id`, throwing if any
- * individual document fails (Typesense’s bulk import otherwise reports
- * per-document failures without rejecting).
- */
-async function importBatch(client, collection, batch) {
-    const results = (await client
-        .collections(collection)
-        .documents()
-        .import(batch, {
-        action: 'upsert',
-        // Collect per-document outcomes instead of throwing the client’s opaque
-        // ImportError, so we can report which documents failed and why.
-        throwOnFail: false,
-    }));
-    const failures = results.filter((result) => !result.success);
-    if (failures.length > 0) {
-        throw new Error(`Typesense upsert into “${collection}” failed for ${failures.length}/${results.length} documents: ${failures
-            .map((failure) => failure.error)
-            .join('; ')}`);
-    }
-}
-/**
- * Take the per-alias rebuild lock via an atomic create, reclaiming it if the
- * current holder is older than `ttlMs`. Returns `false` if another caller holds
- * a fresh lock.
- */
-async function acquireLock(client, alias, ttlMs) {
-    await ensureLockCollection(client);
-    try {
-        await client
-            .collections(LOCK_COLLECTION)
-            .documents()
-            .create({ id: alias, acquired_at: Date.now() });
-        return true;
-    }
-    catch (error) {
-        if (httpStatus(error) === 409) {
-            return reclaimIfStale(client, alias, ttlMs);
-        }
-        throw error;
-    }
-}
-/** Take over the lock if its holder has not refreshed it within `ttlMs`. */
-async function reclaimIfStale(client, alias, ttlMs) {
-    let held;
-    try {
-        held = (await client
-            .collections(LOCK_COLLECTION)
-            .documents(alias)
-            .retrieve());
-    }
-    catch (error) {
-        // Released between our create and this read — leave it for the next try.
-        if (httpStatus(error) === 404) {
-            return false;
-        }
-        throw error;
-    }
-    if (Date.now() - held.acquired_at <= ttlMs) {
-        return false;
-    }
-    await client
-        .collections(LOCK_COLLECTION)
-        .documents()
-        .upsert({ id: alias, acquired_at: Date.now() });
-    return true;
-}
-/** Release the per-alias lock; a no-op when it is not currently held. */
-async function releaseLock(client, alias) {
-    try {
-        await client.collections(LOCK_COLLECTION).documents(alias).delete();
-    }
-    catch (error) {
-        if (httpStatus(error) !== 404) {
-            throw error;
-        }
-    }
-}
-/** Create the lock collection on demand, tolerating a concurrent creator. */
-async function ensureLockCollection(client) {
-    try {
-        await client.collections(LOCK_COLLECTION).retrieve();
-        return;
-    }
-    catch (error) {
-        if (httpStatus(error) !== 404) {
-            throw error;
-        }
-    }
-    try {
-        await client.collections().create({
-            name: LOCK_COLLECTION,
-            fields: [{ name: 'acquired_at', type: 'int64' }],
-        });
-    }
-    catch (error) {
-        if (httpStatus(error) !== 409) {
-            throw error;
-        }
-    }
-}
-function httpStatus(error) {
-    return error.httpStatus;
-}