@wxn0brp/db 0.8.0 → 0.8.2

package/dist/file/utils.d.ts

@@ -2,7 +2,7 @@
  * Repairs a file path by replacing double slashes
  */
 export declare function pathRepair(path: string): string;
-/**
- * Creates a Readline interface for reading large files with a specified high water mark.
- */
-export declare function createRL(file: string): import("readline").Interface;
+export interface LineReader extends AsyncIterable<string> {
+    close: () => void;
+}
+export declare function createRL(file: string): LineReader;

package/dist/file/utils.js

@@ -1,19 +1,84 @@
 import { createReadStream } from "fs";
-import { createInterface } from "readline";
 /**
  * Repairs a file path by replacing double slashes
  */
 export function pathRepair(path) {
     return path.replaceAll("//", "/");
 }
-/**
- * Creates a Readline interface for reading large files with a specified high water mark.
- */
 export function createRL(file) {
-    const read_stream = createReadStream(file, { highWaterMark: 10 * 1024 * 1024 }); //10MB
-    const rl = createInterface({
-        input: read_stream,
-        crlfDelay: Infinity
+    const stream = createReadStream(file, { highWaterMark: 64 * 1024 });
+    let buffer = "";
+    let done = false;
+    let error = null;
+    const lines = [];
+    let waiting = null;
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        let index;
+        while ((index = buffer.search(/\r?\n/)) >= 0) {
+            const line = buffer.slice(0, index);
+            lines.push(line);
+            buffer = buffer.slice(index + (buffer[index] === "\r" && buffer[index + 1] === "\n" ? 2 : 1));
+        }
+        feed();
+    });
+    stream.on("end", () => {
+        if (buffer.length > 0) {
+            lines.push(buffer);
+            buffer = "";
+        }
+        done = true;
+        feed();
+    });
+    stream.on("error", (err) => {
+        error = err;
+        done = true;
+        feed();
     });
+    const feed = () => {
+        if (waiting) {
+            if (error) {
+                waiting(Promise.reject(error));
+            }
+            else if (lines.length > 0) {
+                waiting({ value: lines.shift(), done: false });
+            }
+            else if (done) {
+                waiting({ value: undefined, done: true });
+            }
+            else {
+                return;
+            }
+            waiting = null;
+        }
+    };
+    const iterator = {
+        next() {
+            if (error)
+                return Promise.reject(error);
+            if (lines.length > 0)
+                return Promise.resolve({ value: lines.shift(), done: false });
+            if (done)
+                return Promise.resolve({ value: undefined, done: true });
+            return new Promise(res => {
+                waiting = res;
+            });
+        },
+        return() {
+            rl.close();
+            return Promise.resolve({ value: undefined, done: true });
+        }
+    };
+    const rl = {
+        [Symbol.asyncIterator]() {
+            return iterator;
+        },
+        close() {
+            if (!done) {
+                done = true;
+                stream.destroy();
+            }
+        }
+    };
     return rl;
 }

package/dist/helpers/relation.js

@@ -57,6 +57,20 @@ async function processRelations(dbs, cfg, data, parentList = null) {
                 item[as] = result;
             }
         }
+        else if (type === "11") {
+            const cache = new Map();
+            for (const item of targets) {
+                const id = item[pk];
+                if (!cache.has(id)) {
+                    cache.set(id, await db.findOne(coll, { [fk]: id }, {}, { select }));
+                }
+                const result = cache.get(id) || null;
+                if (result && rel.relations) {
+                    await processRelations(dbs, rel.relations, result);
+                }
+                item[as] = result;
+            }
+        }
         else if (type === "1n") {
             const ids = targets.map(i => i[pk]);
             const results = await db.find(coll, { $in: { [fk]: ids } }, {}, findOpts || {}, { select });

package/dist/types/relation.d.ts

@@ -16,7 +16,7 @@ export declare namespace RelationTypes {
         as?: string;
         select?: string[];
         findOpts?: DbFindOpts;
-        type?: "1" | "1n" | "nm";
+        type?: "1" | "11" | "1n" | "nm";
         relations?: Relation;
         through?: {
             table: string;

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.8.0";
+export const version = "0.8.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",
@@ -21,8 +21,7 @@
   "type": "module",
   "dependencies": {
     "json5": "^2.2.3",
-    "ky": "^1.7.4",
-    "readline": "^1.3.0"
+    "ky": "^1.7.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",