@lossless.org/client 0.1.0

package/ts/nosqldb/classes.cursor.ts

@@ -0,0 +1,88 @@
+import { SmartDataDbDoc } from './classes.doc.js';
+import * as plugins from './plugins.js';
+
+/**
+ * a wrapper for the native mongodb cursor. Exposes better
+ */
+export class SmartdataDbCursor<T = any> {
+  // STATIC
+
+  // INSTANCE
+  public mongodbCursor: plugins.mongodb.FindCursor<T>;
+  private smartdataDbDoc: typeof SmartDataDbDoc;
+  constructor(cursorArg: plugins.mongodb.FindCursor<T>, dbDocArg: typeof SmartDataDbDoc) {
+    this.mongodbCursor = cursorArg;
+    this.smartdataDbDoc = dbDocArg;
+  }
+
+  public async next(closeAtEnd = true): Promise<T | null> {
+    let nextDocument: T | null;
+    try {
+      nextDocument = await this.mongodbCursor.next();
+    } catch (readError) {
+      return await this.closeAfterError(readError);
+    }
+    if (nextDocument === null) {
+      if (closeAtEnd) {
+        await this.close();
+      }
+      return null;
+    }
+    try {
+      return this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(
+        nextDocument,
+      ) as T;
+    } catch (conversionError) {
+      return await this.closeAfterError(conversionError);
+    }
+  }
+
+  public async forEach(forEachFuncArg: (itemArg: T) => Promise<any>, closeCursorAtEnd = true) {
+    try {
+      let nextDocument: any;
+      do {
+        nextDocument = await this.mongodbCursor.next();
+        if (nextDocument) {
+          const nextClassInstance =
+            this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(nextDocument);
+          await forEachFuncArg(nextClassInstance as any);
+        }
+      } while (nextDocument);
+    } catch (iterationError) {
+      if (closeCursorAtEnd) {
+        await this.closeAfterError(iterationError);
+      }
+      throw iterationError;
+    }
+    if (closeCursorAtEnd) {
+      await this.close();
+    }
+  }
+
+  public async toArray(): Promise<T[]> {
+    let convertedResult: T[];
+    try {
+      const result = await this.mongodbCursor.toArray();
+      convertedResult = result.map((itemArg) =>
+        this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(itemArg),
+      ) as T[];
+    } catch (conversionError) {
+      return await this.closeAfterError(conversionError);
+    }
+    await this.close();
+    return convertedResult;
+  }
+
+  public async close() {
+    await this.mongodbCursor.close();
+  }
+
+  private async closeAfterError(errorArg: unknown): Promise<never> {
+    try {
+      await this.close();
+    } catch {
+      // Preserve the operation error when cursor cleanup also fails.
+    }
+    throw errorArg;
+  }
+}

package/ts/nosqldb/classes.cursoroperation.ts

@@ -0,0 +1,38 @@
+/**
+ * Keep one native cleanup promise, including cleanup started by a driver's
+ * abort listener. This module stays internal: callers receive results only.
+ */
+export const runCursorOperation = async <
+  TCursor extends { close: (...args: any[]) => Promise<void> },
+  TResult,
+>(
+  cursorArg: TCursor,
+  operationArg: (cursorArg: TCursor) => Promise<TResult>,
+  signalArg?: AbortSignal,
+  closeArgumentsArg?: () => Parameters<TCursor['close']>,
+): Promise<TResult> => {
+  const nativeClose = cursorArg.close.bind(cursorArg);
+  let closePromise: Promise<void> | undefined;
+  cursorArg.close = (...args: Parameters<TCursor['close']>) => {
+    closePromise ??= nativeClose(...(closeArgumentsArg?.() ?? args));
+    return closePromise;
+  };
+  const onAbort = () => { void cursorArg.close().catch(() => undefined); };
+  signalArg?.addEventListener('abort', onAbort, { once: true });
+  try {
+    let result: TResult;
+    try {
+      signalArg?.throwIfAborted();
+      result = await operationArg(cursorArg);
+      signalArg?.throwIfAborted();
+    } catch (errorArg) {
+      try { await cursorArg.close(); } catch { /* Preserve the operation error. */ }
+      throw errorArg;
+    }
+    await cursorArg.close();
+    signalArg?.throwIfAborted();
+    return result;
+  } finally {
+    signalArg?.removeEventListener('abort', onAbort);
+  }
+};