@dokebi/search 0.1.1 → 0.1.2

package/dist/plugin.js

@@ -5,7 +5,7 @@ import { SearchError } from './errors.js';
 import { indexesOf } from './indexes.js';
 import { DEFAULT_SECRETS_ENV, MIN_SECRET_LENGTH, options } from './options.js';
 import { detectDriver, isMissingTable, isQueryable, isRetryable, serverDialect, session, } from './sql.js';
-import { COUNTS_TABLE, INDEXES_TABLE, Store, TERMS_TABLE, } from './store.js';
+import { COUNT_BATCH, COUNTS_TABLE, INDEXES_TABLE, Store, TERMS_TABLE, } from './store.js';
 import { MAX_QUERY_WORDS, queryTerms, terms } from './terms.js';
 const db = providerDependency({
     name: 'dokebi-db',
@@ -398,8 +398,8 @@ class SearchRuntime {
             this.#flushSoon();
     }
     /**
-     * Adds the buffered count changes to the table, one autocommit statement per index on the
-     * plugin's pool, words in sorted order. A failure is logged and the changes are kept for the
+     * Adds the buffered count changes to the table, in autocommit statements of up to COUNT_BATCH
+     * words per index on the plugin's pool, words in sorted order. A failure is logged and the changes are kept for the
      * next flush. Never rejects.
      */
     #flush() {
@@ -432,14 +432,23 @@ class SearchRuntime {
             }
             for (const [index, deltas] of byIndex) {
                 deltas.sort((a, b) => byKey(a.field, b.field) || byKey(a.term, b.term));
+                // One autocommit statement per COUNT_BATCH words: `written` words are in the table.
+                let written = 0;
                 try {
-                    await live.store.addCounts(live.pool, index, deltas);
+                    for (; written < deltas.length; written += COUNT_BATCH)
+                        await live.store.addCounts(live.pool, index, deltas.slice(written, written + COUNT_BATCH));
                 }
                 catch (error) {
-                    // Kept for the next flush: the counts are late, never lost while the process runs.
-                    for (const row of deltas) {
+                    // Kept for the next flush: the counts are late, never lost while the process runs. Only
+                    // the words from the failed statement on: the statements before it are committed, and
+                    // keeping their words too would add them twice (R9-g14-3).
+                    for (const row of deltas.slice(written)) {
                         const key = `${index}${SEP}${row.field}${SEP}${row.term}`;
-                        this.#pending.set(key, (this.#pending.get(key) ?? 0) + row.delta);
+                        const value = (this.#pending.get(key) ?? 0) + row.delta;
+                        if (value === 0)
+                            this.#pending.delete(key);
+                        else
+                            this.#pending.set(key, value);
                     }
                     this.#repeats?.log('error', 'Search word counts could not be written; they are kept for the next flush.', 'SEARCH_COUNTS_FAILED', error);
                 }
@@ -697,7 +706,7 @@ class SearchRuntime {
 /** Factory input: `{ app, options?, entry }`: `entry` is the module of src/infra/search/indexes.ts. */
 export const createPlugin = definePlugin({
     name: 'dokebi-search',
-    version: '0.1.1',
+    version: '0.1.2',
     core: '^0.4.2',
     options,
     dependencies: () => [db],

package/dist/store.d.ts

@@ -3,6 +3,8 @@ import type { Dialect, Session } from './sql.js';
 export declare const TERMS_TABLE = "dokebi_search_terms";
 export declare const COUNTS_TABLE = "dokebi_search_counts";
 export declare const INDEXES_TABLE = "dokebi_search_indexes";
+/** Words of one count statement: a flush hands `addCounts` this many at a time. */
+export declare const COUNT_BATCH = 500;
 export interface TermRow {
     readonly field: string;
     readonly term: string;
@@ -47,7 +49,10 @@ export declare class Store {
     insertRows(db: Session, index: string, id: string, sortKey: number, rows: readonly TermRow[]): Promise<void>;
     /**
      * Moves the item counts of words by their deltas, in one slot chosen at random, in the order
-     * given (the caller sorts them, so two writers lock the same rows in the same order).
+     * given (the caller sorts them, so two writers lock the same rows in the same order). One
+     * statement for up to COUNT_BATCH deltas: all of them are written or none. More are several
+     * statements, and a failure then leaves the earlier ones written, so a caller that keeps what
+     * failed hands over COUNT_BATCH at a time.
      */
     addCounts(db: Session, index: string, deltas: readonly CountDelta[]): Promise<void>;
     /** The item count of each word (its slots summed); a word without rows is absent. */

package/dist/store.js

@@ -10,6 +10,8 @@ export const COUNTS_TABLE = 'dokebi_search_counts';
 export const INDEXES_TABLE = 'dokebi_search_indexes';
 /** Rows of one multi-row INSERT or DELETE (parameters stay far below every driver's limit). */
 const BATCH = 500;
+/** Words of one count statement: a flush hands `addCounts` this many at a time. */
+export const COUNT_BATCH = BATCH;
 export class Store {
     #dialect;
     /** MySQL and MariaDB read an older snapshot in a REPEATABLE READ transaction. */
@@ -98,7 +100,10 @@ export class Store {
     }
     /**
      * Moves the item counts of words by their deltas, in one slot chosen at random, in the order
-     * given (the caller sorts them, so two writers lock the same rows in the same order).
+     * given (the caller sorts them, so two writers lock the same rows in the same order). One
+     * statement for up to COUNT_BATCH deltas: all of them are written or none. More are several
+     * statements, and a failure then leaves the earlier ones written, so a caller that keeps what
+     * failed hands over COUNT_BATCH at a time.
      */
     async addCounts(db, index, deltas) {
         const slot = Math.floor(Math.random() * this.#slots);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dokebi/search",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Search in an application's lists for Dokebi by @dokebi/db AI.md 6.10: a term table in display order written in the text's transaction, Korean word prefixes, the rarest word leads, bounded requests and searches with a signed cursor.",
   "keywords": [
     "dokebi",