@wxn0brp/db-storage-sqlite 0.100.2 → 0.110.0

package/README.md

@@ -41,7 +41,9 @@ const db = createSQLiteValthera<{
     name: string;
     email: string;
   }
-}>(sqliteDB);
+}>(sqliteDB, {
+  users: "_id" // define the primary key (default: "_id")
+});
 
 // 4. Ensure the collection/table exists
 await db.ensureCollection("users");

package/dist/find.d.ts

@@ -1,4 +1,4 @@
 import { Data } from "@wxn0brp/db-core/types/data";
-import { FindQuery } from "@wxn0brp/db-core/types/query";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
 import { SQLiteValthera } from "./index.js";
-export declare function find(slv: SQLiteValthera, config: FindQuery): Promise<Data[]>;
+export declare function find(slv: SQLiteValthera, config: VQueryT.Find): Promise<Data[]>;

package/dist/find.js

@@ -1,7 +1,7 @@
 import { findUtil } from "@wxn0brp/db-core/utils/action";
-import { hasFieldsAdvanced } from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { findObj } from "@wxn0brp/db-core/utils/process";
 export async function find(slv, config) {
-    const { collection, search, context } = config;
+    const { collection, search } = config;
     let sqlResult = [];
     if (typeof search === "function" || Object.keys(search).length === 0) {
         const stmt = await slv._prepare(`SELECT * FROM ${collection}`);
@@ -17,10 +17,6 @@ export async function find(slv, config) {
         const stmt = await slv._prepare(baseSql);
         sqlResult = await Promise.resolve(stmt.all(...baseValues));
     }
-    let result = sqlResult.filter(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
-    return findUtil(config, {
-        find() {
-            return result;
-        }
-    }, [null]);
+    const result = sqlResult.filter(entry => findObj(entry, search));
+    return findUtil(config, result, []);
 }

package/dist/index.d.ts

@@ -5,8 +5,9 @@ import { VQueryT } from "@wxn0brp/db-core/types/query";
 import { SupportedDB, VStatement } from "./types.js";
 export declare class SQLiteValthera extends ActionsBase {
     db: SupportedDB;
+    primaryKey: Record<string, string>;
     _inited: boolean;
-    constructor(db: SupportedDB);
+    constructor(db: SupportedDB, primaryKey?: Record<string, string>);
     _prepare(sql: string): Promise<VStatement>;
     getCollections(): Promise<string[]>;
     add(config: VQueryT.Add): Promise<Data>;
@@ -22,8 +23,8 @@ export declare class SQLiteValthera extends ActionsBase {
 }
 export declare function createSQLiteValthera<T extends Record<string, Data> = {}>(sqlDB: SupportedDB): ValtheraClass & { [K in keyof T]: import("@wxn0brp/db-core/helpers/collection").Collection<T[K]>; };
 export declare const DYNAMIC: {
-    sqlite(file: string, opts?: any): Promise<SQLiteValthera>;
-    bun(file: string, opts?: any): Promise<SQLiteValthera>;
-    node(file: string, opts?: any): Promise<SQLiteValthera>;
-    better(file: string, opts?: any): Promise<SQLiteValthera>;
+    sqlite(file: string, keys?: Record<string, string>, opts?: any): Promise<SQLiteValthera>;
+    bun(file: string, keys?: Record<string, string>, opts?: any): Promise<SQLiteValthera>;
+    node(file: string, keys?: Record<string, string>, opts?: any): Promise<SQLiteValthera>;
+    better(file: string, keys?: Record<string, string>, opts?: any): Promise<SQLiteValthera>;
 };

package/dist/index.js

@@ -1,14 +1,17 @@
-import { forgeTypedValthera, genId, ValtheraClass } from "@wxn0brp/db-core";
+import { forgeTypedValthera, ValtheraClass } from "@wxn0brp/db-core";
 import { ActionsBase } from "@wxn0brp/db-core/base/actions";
+import { addId } from "@wxn0brp/db-core/helpers/addId";
 import { find } from "./find.js";
 import { remove } from "./remove.js";
 import { update } from "./update.js";
 export class SQLiteValthera extends ActionsBase {
     db;
+    primaryKey;
     _inited = true;
-    constructor(db) {
+    constructor(db, primaryKey = {}) {
         super();
         this.db = db;
+        this.primaryKey = primaryKey;
     }
     async _prepare(sql) {
         const db = this.db;
@@ -28,9 +31,8 @@ export class SQLiteValthera extends ActionsBase {
         return tables.map((t) => t.name);
     }
     async add(config) {
-        const { data, id_gen = true, collection } = config;
-        if (id_gen && !data._id)
-            data._id = genId();
+        const { data, collection } = config;
+        await addId(config, this, true);
         const keys = Object.keys(data);
         const placeholders = keys.map(() => "?").join(", ");
         const values = keys.map(k => data[k]);
@@ -87,21 +89,27 @@ export function createSQLiteValthera(sqlDB) {
     return forgeTypedValthera(db);
 }
 export const DYNAMIC = {
-    sqlite(file, opts) {
+    sqlite(file, keys = {}, opts) {
         if (typeof Bun !== "undefined")
-            return DYNAMIC.bun(file, opts);
-        return DYNAMIC.node(file, opts);
+            return DYNAMIC.bun(file, keys, opts);
+        return DYNAMIC.node(file, keys, opts);
     },
-    async bun(file, opts) {
+    async bun(file, keys = {}, opts = undefined) {
         const { Database } = await import("bun:sqlite");
-        return new SQLiteValthera(new Database(file, opts));
+        if (typeof opts === "object" && Object.keys(opts).length === 0)
+            opts = undefined;
+        return new SQLiteValthera(new Database(file, opts), keys);
     },
-    async node(file, opts) {
+    async node(file, keys = {}, opts) {
         const { DatabaseSync } = await import("node:sqlite");
-        return new SQLiteValthera(new DatabaseSync(file, opts));
+        if (!opts)
+            opts = {};
+        return new SQLiteValthera(new DatabaseSync(file, opts), keys);
     },
-    async better(file, opts) {
+    async better(file, keys = {}, opts) {
         const { default: def } = await import("better-sqlite3");
-        return new SQLiteValthera(new def(file, opts));
+        if (!opts)
+            opts = {};
+        return new SQLiteValthera(new def(file, opts), keys);
     }
 };

package/dist/remove.d.ts

@@ -1,4 +1,4 @@
 import { DataInternal } from "@wxn0brp/db-core/types/data";
-import { RemoveQuery } from "@wxn0brp/db-core/types/query";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
 import { SQLiteValthera } from "./index.js";
-export declare function remove(slv: SQLiteValthera, query: RemoveQuery, one: boolean): Promise<DataInternal[]>;
+export declare function remove(slv: SQLiteValthera, query: VQueryT.Remove, one: boolean): Promise<DataInternal[]>;

package/dist/remove.js

@@ -1,24 +1,16 @@
-import { hasFieldsAdvanced } from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { find } from "./find.js";
 export async function remove(slv, query, one) {
-    const { collection, search, context } = query;
-    let stmt = await slv._prepare(`SELECT * FROM "${collection}"`);
-    const allEntries = await Promise.resolve(stmt.all());
-    const toDelete = [];
-    for (const entry of allEntries) {
-        const match = typeof search === "function"
-            ? search(entry, context)
-            : hasFieldsAdvanced(entry, search);
-        if (match) {
-            toDelete.push(entry);
-            if (one)
-                break;
+    const { collection } = query;
+    const toDelete = await find(slv, {
+        ...query,
+        dbFindOpts: {
+            limit: one ? 1 : undefined
         }
-    }
+    });
     if (!toDelete.length)
         return [];
-    stmt = await slv._prepare(`DELETE FROM "${collection}" WHERE _id = ?`);
-    for (const entry of toDelete) {
-        await Promise.resolve(stmt.run(entry._id));
-    }
+    const key = slv.primaryKey[collection] || "_id";
+    const stmt = await slv._prepare(`DELETE FROM "${collection}" WHERE "${key}" IN (${toDelete.map(() => "?").join(", ")})`);
+    await Promise.resolve(stmt.run(...toDelete.map(d => d[key])));
     return toDelete;
 }

package/dist/update.d.ts

@@ -1,4 +1,4 @@
 import { DataInternal } from "@wxn0brp/db-core/types/data";
-import { UpdateQuery } from "@wxn0brp/db-core/types/query";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
 import { SQLiteValthera } from "./index.js";
-export declare function update(slv: SQLiteValthera, query: UpdateQuery, one: boolean): Promise<DataInternal[]>;
+export declare function update(slv: SQLiteValthera, query: VQueryT.Update, one: boolean): Promise<DataInternal[]>;

package/dist/update.js

@@ -1,33 +1,26 @@
-import { hasFieldsAdvanced } from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { updateObj } from "@wxn0brp/db-core/utils/process";
+import { find } from "./find.js";
 export async function update(slv, query, one) {
-    const { collection, search, updater, context } = query;
-    const stmt = await slv._prepare(`SELECT * FROM "${collection}"`);
-    const allEntries = await Promise.resolve(stmt.all());
-    const matched = [];
-    for (const entry of allEntries) {
-        const match = typeof search === "function"
-            ? search(entry, context)
-            : hasFieldsAdvanced(entry, search);
-        if (match) {
-            matched.push(entry);
-            if (one)
-                break;
+    const { collection } = query;
+    const matched = await find(slv, {
+        ...query,
+        dbFindOpts: {
+            limit: one ? 1 : undefined
         }
-    }
+    });
     if (matched.length === 0)
         return [];
+    const key = slv.primaryKey[collection] || "_id";
     const updateOne = async (target) => {
-        const newData = typeof updater === "function"
-            ? updater(target, context)
-            : { ...target, ...updater };
-        if (newData._id !== target._id)
-            newData._id = target._id;
-        const keys = Object.keys(newData).filter(k => k !== "_id");
+        const newData = updateObj(query, target);
+        if (newData[key] !== target[key])
+            newData[key] = target[key];
+        const keys = Object.keys(newData).filter(k => k !== key);
         const values = keys.map(k => newData[k]);
-        const sql = `UPDATE "${collection}" SET ${keys.map(k => `"${k}" = ?`).join(", ")} WHERE _id = ?`;
+        const sql = `UPDATE "${collection}" SET ${keys.map(k => `"${k}" = ?`).join(", ")} WHERE "${key}" = ?`;
         const stmt = await slv._prepare(sql);
-        await Promise.resolve(stmt.run(...values, target._id));
-        return await slv.findOne({ collection, search: { _id: target._id } });
+        await Promise.resolve(stmt.run(...values, target[key]));
+        return newData;
     };
     const results = [];
     for (const target of matched)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-storage-sqlite",
-  "version": "0.100.2",
+  "version": "0.110.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A pure SQLite storage adapter for the ValtheraDB database library",
@@ -22,13 +22,13 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "*",
     "@types/node": "*",
-    "@wxn0brp/db-core": "^0.10.4",
+    "@wxn0brp/db-core": "^0.11.0-alpha.4",
     "better-sqlite3": "^12.9.0",
     "tsc-alias": "^1",
     "typescript": "^6"
   },
   "peerDependencies": {
-    "@wxn0brp/db-core": "^0.10.4",
+    "@wxn0brp/db-core": "^0.11.0-alpha.4",
     "better-sqlite3": "^12.9.0"
   },
   "peerDependenciesMeta": {