@decaf-ts/for-nano
Version:
decaf-ts persistence adapter for CouchDB via nano
210 lines • 25.8 kB
JavaScript
import { Dispatch } from "@decaf-ts/core";
import { InternalError, OperationKeys } from "@decaf-ts/db-decorators";
import { CouchDBKeys } from "@decaf-ts/for-couchdb";
/**
* @description Dispatcher for Nano database change events
* @summary Handles the subscription to and processing of database change events from a Nano database,
* notifying observers when documents are created, updated, or deleted
* @template DocumentScope - The Nano document scope type
* @param {number} [timeout=5000] - Timeout in milliseconds for change feed requests
* @class NanoDispatch
* @example
* ```typescript
* // Create a dispatcher for a Nano database
* const db = server.db.use('my_database');
* const adapter = new NanoAdapter(db);
* const dispatch = new NanoDispatch();
*
* // The dispatcher will automatically subscribe to changes
* // and notify observers when documents change
* ```
* @mermaid
* classDiagram
* class Dispatch {
* +initialize()
* +updateObservers()
* }
* class NanoDispatch {
* -observerLastUpdate?: string
* -attemptCounter: number
* -timeout: number
* +constructor(timeout)
* #changeHandler()
* #initialize()
* }
* Dispatch <|-- NanoDispatch
*/
export class NanoDispatch extends Dispatch {
constructor(timeout = 5000) {
super();
this.timeout = timeout;
this.attemptCounter = 0;
}
/**
* @description Processes database change events
* @summary Handles the response from the Nano changes feed, processes the changes,
* and notifies observers about document changes
* @param {RequestError | null} error - Error object if the request failed
* @param response - The changes response from Nano
* @param {any} [headers] - Response headers (unused)
* @return {Promise<void>} A promise that resolves when all changes have been processed
* @mermaid
* sequenceDiagram
* participant D as NanoDispatch
* participant L as Logger
* participant O as Observers
* Note over D: Receive changes from Nano
* alt Error in response
* D->>L: Log error
* D-->>D: Return early
* end
* alt Response is string
* D->>D: Parse JSON from string
* end
* D->>D: Process changes
* D->>D: Group changes by table and operation
* loop For each table
* loop For each operation
* D->>O: updateObservers(table, operation, ids)
* D->>D: Update observerLastUpdate
* D->>L: Log successful dispatch
* end
* end
*/
async changeHandler(error, response,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
headers) {
const log = this.log.for(this.changeHandler);
if (error)
return log.error(`Error in change request: ${error}`);
try {
response = (typeof response === "string"
? response
.split("\n")
.filter((r) => !!r)
.map((r) => JSON.parse(r))
: response);
}
catch (e) {
return log.error(`Error parsing couchdb change feed: ${e}`);
}
const count = response.length;
if (count > 0) {
log.debug(`Received ${count} changes. processing...`);
const changes = response
.map((rec, i) => {
if (i === count - 1) {
if (this.observerLastUpdate ===
rec.last_seq)
log.error(`Invalid last update check: ${this.observerLastUpdate} !== ${rec.last_seq}`);
return;
}
const r = rec;
const [table, id] = r.id.split(CouchDBKeys.SEPARATOR);
return {
table: table,
id: id,
operation: r.deleted
? OperationKeys.DELETE
: r.changes[r.changes.length - 1].rev.split("-")[0] === "1"
? OperationKeys.CREATE
: OperationKeys.UPDATE,
step: r.changes[r.changes.length - 1].rev,
};
})
.reduce((accum, r) => {
if (!r)
return accum;
const { table, id, operation, step } = r;
if (!accum[table])
accum[table] = {};
if (!accum[table][operation])
accum[table][operation] = { ids: new Set(), step: step };
accum[table][operation].ids.add(id);
accum[table][operation].step = step;
return accum;
}, {});
for (const table of Object.keys(changes)) {
for (const op of Object.keys(changes[table])) {
try {
await this.updateObservers(table, op, [
...changes[table][op].ids.values(),
]);
this.observerLastUpdate = changes[table][op].step;
log.verbose(`Observer refresh dispatched by ${op} for ${table}`);
log.debug(`pks: ${Array.from(changes[table][op].ids.values())}`);
}
catch (e) {
log.error(`Failed to dispatch observer refresh for ${table}, op ${op}: ${e}`);
}
}
}
}
}
/**
* @description Initializes the dispatcher and subscribes to database changes
* @summary Sets up the continuous changes feed subscription to the Nano database
* and handles reconnection attempts if the connection fails
* @return {Promise<void>} A promise that resolves when the subscription is established
* @mermaid
* sequenceDiagram
* participant D as NanoDispatch
* participant S as subscribeToCouch
* participant DB as Nano Database
* participant L as Logger
* D->>S: Call subscribeToCouch
* S->>S: Check adapter and native
* alt No adapter or native
* S-->>S: throw InternalError
* end
* S->>DB: changes(options, changeHandler)
* alt Success
* DB-->>S: Subscription established
* S-->>D: Promise resolves
* D->>L: Log successful subscription
* else Error
* DB-->>S: Error
* S->>S: Increment attemptCounter
* alt attemptCounter > 3
* S->>L: Log error
* S-->>D: Promise rejects
* else attemptCounter <= 3
* S->>L: Log retry
* S->>S: Wait timeout
* S->>S: Recursive call to subscribeToCouch
* end
* end
*/
async initialize() {
const log = this.log.for(this.initialize);
const subLog = log.for(subscribeToCouch);
async function subscribeToCouch() {
if (!this.adapter || !this.native)
throw new InternalError(`No adapter/native observed for dispatch`);
try {
this.native.changes({
feed: "continuous",
include_docs: false,
since: this.observerLastUpdate || "now",
timeout: this.timeout,
}, this.changeHandler.bind(this));
}
catch (e) {
if (++this.attemptCounter > 3)
return subLog.error(`Failed to subscribe to couchdb changes: ${e}`);
subLog.info(`Failed to subscribe to couchdb changes: ${e}. Retrying in 5 seconds...`);
await new Promise((resolve) => setTimeout(resolve, this.timeout));
return subscribeToCouch.call(this);
}
}
subscribeToCouch
.call(this)
.then(() => {
this.log.info(`Subscribed to couchdb changes`);
})
.catch((e) => {
throw new InternalError(`Failed to subscribe to couchdb changes: ${e}`);
});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NanoDispatch.js","sourceRoot":"","sources":["../../src/NanoDispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Dispatch } from \"@decaf-ts/core\";\nimport {\n  DatabaseChangesResponse,\n  DatabaseChangesResultItem,\n  DocumentScope,\n  RequestError,\n} from \"nano\";\nimport { InternalError, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { CouchDBKeys } from \"@decaf-ts/for-couchdb\";\n\n/**\n * @description Dispatcher for Nano database change events\n * @summary Handles the subscription to and processing of database change events from a Nano database,\n * notifying observers when documents are created, updated, or deleted\n * @template DocumentScope - The Nano document scope type\n * @param {number} [timeout=5000] - Timeout in milliseconds for change feed requests\n * @class NanoDispatch\n * @example\n * ```typescript\n * // Create a dispatcher for a Nano database\n * const db = server.db.use('my_database');\n * const adapter = new NanoAdapter(db);\n * const dispatch = new NanoDispatch();\n *\n * // The dispatcher will automatically subscribe to changes\n * // and notify observers when documents change\n * ```\n * @mermaid\n * classDiagram\n *   class Dispatch {\n *     +initialize()\n *     +updateObservers()\n *   }\n *   class NanoDispatch {\n *     -observerLastUpdate?: string\n *     -attemptCounter: number\n *     -timeout: number\n *     +constructor(timeout)\n *     #changeHandler()\n *     #initialize()\n *   }\n *   Dispatch <|-- NanoDispatch\n */\nexport class NanoDispatch extends Dispatch<DocumentScope<any>> {\n  private observerLastUpdate?: string;\n  private attemptCounter: number = 0;\n  constructor(private timeout = 5000) {\n    super();\n  }\n\n  /**\n   * @description Processes database change events\n   * @summary Handles the response from the Nano changes feed, processes the changes,\n   * and notifies observers about document changes\n   * @param {RequestError | null} error - Error object if the request failed\n   * @param response - The changes response from Nano\n   * @param {any} [headers] - Response headers (unused)\n   * @return {Promise<void>} A promise that resolves when all changes have been processed\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as NanoDispatch\n   *   participant L as Logger\n   *   participant O as Observers\n   *   Note over D: Receive changes from Nano\n   *   alt Error in response\n   *     D->>L: Log error\n   *     D-->>D: Return early\n   *   end\n   *   alt Response is string\n   *     D->>D: Parse JSON from string\n   *   end\n   *   D->>D: Process changes\n   *   D->>D: Group changes by table and operation\n   *   loop For each table\n   *     loop For each operation\n   *       D->>O: updateObservers(table, operation, ids)\n   *       D->>D: Update observerLastUpdate\n   *       D->>L: Log successful dispatch\n   *     end\n   *   end\n   */\n  protected async changeHandler(\n    error: RequestError | null,\n    response: (DatabaseChangesResponse | DatabaseChangesResultItem)[] | string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    headers?: any\n  ) {\n    const log = this.log.for(this.changeHandler);\n    if (error) return log.error(`Error in change request: ${error}`);\n    try {\n      response = (\n        typeof response === \"string\"\n          ? response\n              .split(\"\\n\")\n              .filter((r) => !!r)\n              .map((r) => JSON.parse(r))\n          : response\n      ) as DatabaseChangesResponse[];\n    } catch (e: unknown) {\n      return log.error(`Error parsing couchdb change feed: ${e}`);\n    }\n    const count = response.length;\n    if (count > 0) {\n      log.debug(`Received ${count} changes. processing...`);\n      const changes = response\n        .map((rec, i) => {\n          if (i === count - 1) {\n            if (\n              this.observerLastUpdate ===\n              (rec as DatabaseChangesResponse).last_seq\n            )\n              log.error(\n                `Invalid last update check: ${this.observerLastUpdate} !== ${(rec as DatabaseChangesResponse).last_seq}`\n              );\n            return;\n          }\n          const r = rec as DatabaseChangesResultItem;\n          const [table, id] = r.id.split(CouchDBKeys.SEPARATOR);\n          return {\n            table: table,\n            id: id,\n            operation: r.deleted\n              ? OperationKeys.DELETE\n              : r.changes[r.changes.length - 1].rev.split(\"-\")[0] === \"1\"\n                ? OperationKeys.CREATE\n                : OperationKeys.UPDATE,\n            step: r.changes[r.changes.length - 1].rev,\n          };\n        })\n        .reduce(\n          (\n            accum: Record<\n              string,\n              Record<\n                string,\n                {\n                  ids: Set<any>;\n                  step: string;\n                }\n              >\n            >,\n            r\n          ) => {\n            if (!r) return accum;\n            const { table, id, operation, step } = r as {\n              table: string;\n              id: string;\n              operation: OperationKeys;\n              step: string;\n            };\n            if (!accum[table]) accum[table] = {};\n            if (!accum[table][operation])\n              accum[table][operation] = { ids: new Set(), step: step };\n            accum[table][operation].ids.add(id);\n            accum[table][operation].step = step;\n            return accum;\n          },\n          {}\n        );\n\n      for (const table of Object.keys(changes)) {\n        for (const op of Object.keys(changes[table])) {\n          try {\n            await this.updateObservers(table, op, [\n              ...changes[table][op].ids.values(),\n            ]);\n            this.observerLastUpdate = changes[table][op].step;\n            log.verbose(`Observer refresh dispatched by ${op} for ${table}`);\n            log.debug(`pks: ${Array.from(changes[table][op].ids.values())}`);\n          } catch (e: unknown) {\n            log.error(\n              `Failed to dispatch observer refresh for ${table}, op ${op}: ${e}`\n            );\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * @description Initializes the dispatcher and subscribes to database changes\n   * @summary Sets up the continuous changes feed subscription to the Nano database\n   * and handles reconnection attempts if the connection fails\n   * @return {Promise<void>} A promise that resolves when the subscription is established\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as NanoDispatch\n   *   participant S as subscribeToCouch\n   *   participant DB as Nano Database\n   *   participant L as Logger\n   *   D->>S: Call subscribeToCouch\n   *   S->>S: Check adapter and native\n   *   alt No adapter or native\n   *     S-->>S: throw InternalError\n   *   end\n   *   S->>DB: changes(options, changeHandler)\n   *   alt Success\n   *     DB-->>S: Subscription established\n   *     S-->>D: Promise resolves\n   *     D->>L: Log successful subscription\n   *   else Error\n   *     DB-->>S: Error\n   *     S->>S: Increment attemptCounter\n   *     alt attemptCounter > 3\n   *       S->>L: Log error\n   *       S-->>D: Promise rejects\n   *     else attemptCounter <= 3\n   *       S->>L: Log retry\n   *       S->>S: Wait timeout\n   *       S->>S: Recursive call to subscribeToCouch\n   *     end\n   *   end\n   */\n  protected override async initialize(): Promise<void> {\n    const log = this.log.for(this.initialize);\n    const subLog = log.for(subscribeToCouch);\n    async function subscribeToCouch(this: NanoDispatch): Promise<void> {\n      if (!this.adapter || !this.native)\n        throw new InternalError(`No adapter/native observed for dispatch`);\n\n      try {\n        this.native.changes(\n          {\n            feed: \"continuous\",\n            include_docs: false,\n            since: this.observerLastUpdate || \"now\",\n            timeout: this.timeout,\n          },\n          this.changeHandler.bind(this) as any\n        );\n      } catch (e: unknown) {\n        if (++this.attemptCounter > 3)\n          return subLog.error(`Failed to subscribe to couchdb changes: ${e}`);\n        subLog.info(\n          `Failed to subscribe to couchdb changes: ${e}. Retrying in 5 seconds...`\n        );\n        await new Promise((resolve) => setTimeout(resolve, this.timeout));\n        return subscribeToCouch.call(this);\n      }\n    }\n\n    subscribeToCouch\n      .call(this)\n      .then(() => {\n        this.log.info(`Subscribed to couchdb changes`);\n      })\n      .catch((e: unknown) => {\n        throw new InternalError(`Failed to subscribe to couchdb changes: ${e}`);\n      });\n  }\n}\n"]}