@wxn0brp/db-storage-sqlite 0.110.4 → 0.120.0

package/README.md

@@ -59,6 +59,9 @@ await db.users.update({ name: "John Doe" }, { email: "newemail@example.com" });
 
 // 8. Remove entries
 await db.users.remove({ name: "John Doe" });
+
+// 9. Close the SQLite handle
+await db.close();
 ```
 
 ## API Notes

package/dist/buildWhere.d.ts

@@ -0,0 +1,7 @@
+import { AffinityMap } from "./types.js";
+export interface WhereResult {
+    sql: string;
+    values: any[];
+    postFilter?: (row: any) => boolean;
+}
+export declare function buildWhere(search: any, affinities: AffinityMap): WhereResult;

package/dist/buildWhere.js

@@ -0,0 +1,240 @@
+import { hasFieldsAdvanced } from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { PUSHABLE_OPS } from "./const.js";
+import { qid, toSqlValue } from "./utils.js";
+const FALSE_SQL = "1 = 0";
+function isMatchAllCondition(cond) {
+    return (cond === undefined ||
+        cond === null ||
+        (typeof cond === "object" &&
+            !Array.isArray(cond) &&
+            Object.keys(cond).length === 0));
+}
+export function buildWhere(search, affinities) {
+    if (search === undefined || search === null) {
+        return {
+            sql: "",
+            values: [],
+        };
+    }
+    if (typeof search === "function") {
+        return {
+            sql: "",
+            values: [],
+            postFilter: search,
+        };
+    }
+    if (typeof search !== "object" || Array.isArray(search)) {
+        return {
+            sql: FALSE_SQL,
+            values: [],
+        };
+    }
+    if (Object.keys(search).length === 0) {
+        return {
+            sql: "",
+            values: [],
+        };
+    }
+    const $fields = {};
+    const flatFields = {};
+    for (const key of Object.keys(search)) {
+        if (key.startsWith("$")) {
+            $fields[key.toLowerCase()] = search[key];
+        }
+        else {
+            flatFields[key] = search[key];
+        }
+    }
+    const clauses = [];
+    const allValues = [];
+    const postFilters = [];
+    for (const [key, value] of Object.entries(flatFields)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            postFilters.push(row => {
+                try {
+                    return hasFieldsAdvanced(row, {
+                        [key]: value,
+                    });
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        else if (value === undefined) {
+            postFilters.push(() => false);
+        }
+        else {
+            clauses.push(`${qid(key)} = ?`);
+            allValues.push(toSqlValue(value, affinities[key]));
+        }
+    }
+    if ("$subset" in $fields) {
+        const subsetSearch = {
+            $subset: $fields["$subset"],
+        };
+        postFilters.push(row => {
+            try {
+                return hasFieldsAdvanced(row, subsetSearch);
+            }
+            catch {
+                return false;
+            }
+        });
+        delete $fields["$subset"];
+    }
+    if ("$not" in $fields) {
+        const notResult = buildWhere($fields["$not"], affinities);
+        if (notResult.sql && !notResult.postFilter) {
+            clauses.push(`NOT (${notResult.sql})`);
+            allValues.push(...notResult.values);
+        }
+        else {
+            const innerSearch = $fields["$not"];
+            postFilters.push(row => {
+                try {
+                    return !hasFieldsAdvanced(row, innerSearch);
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        delete $fields["$not"];
+    }
+    if ("$and" in $fields) {
+        const andResult = buildAnd($fields["$and"], affinities);
+        if (andResult.sql) {
+            clauses.push(`(${andResult.sql})`);
+            allValues.push(...andResult.values);
+        }
+        if (andResult.postFilter) {
+            postFilters.push(andResult.postFilter);
+        }
+        delete $fields["$and"];
+    }
+    if ("$or" in $fields) {
+        const orResult = buildOr($fields["$or"], affinities);
+        if (orResult.sql) {
+            clauses.push(`(${orResult.sql})`);
+            allValues.push(...orResult.values);
+        }
+        if (orResult.postFilter) {
+            postFilters.push(orResult.postFilter);
+        }
+        delete $fields["$or"];
+    }
+    for (const [opKey, fieldMap] of Object.entries($fields)) {
+        if (typeof fieldMap !== "object" || fieldMap === null)
+            continue;
+        for (const [field, value] of Object.entries(fieldMap)) {
+            let pushed = false;
+            const pushable = PUSHABLE_OPS[opKey];
+            const isSimpleValue = !(value instanceof RegExp) &&
+                (typeof value !== "object" || value === null || Array.isArray(value));
+            if (pushable && !field.includes(".") && isSimpleValue) {
+                const result = pushable(field, value, affinities[field]);
+                if (result) {
+                    clauses.push(result.sql);
+                    allValues.push(...result.values);
+                    pushed = true;
+                }
+            }
+            if (!pushed) {
+                postFilters.push(row => {
+                    try {
+                        return hasFieldsAdvanced(row, {
+                            [opKey]: {
+                                [field]: value,
+                            },
+                        });
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+            }
+        }
+    }
+    let postFilter;
+    if (postFilters.length > 0) {
+        postFilter = row => postFilters.every(fn => fn(row));
+    }
+    return {
+        sql: clauses.join(" AND "),
+        values: allValues,
+        postFilter,
+    };
+}
+function buildAnd(conditions, affinities) {
+    if (!Array.isArray(conditions)) {
+        return {
+            sql: FALSE_SQL,
+            values: [],
+        };
+    }
+    const clauses = [];
+    const allValues = [];
+    const postFilters = [];
+    for (const condition of conditions) {
+        const result = buildWhere(condition, affinities);
+        if (result.sql) {
+            clauses.push(`(${result.sql})`);
+            allValues.push(...result.values);
+        }
+        if (result.postFilter) {
+            postFilters.push(result.postFilter);
+        }
+    }
+    let postFilter;
+    if (postFilters.length > 0) {
+        postFilter = row => postFilters.every(fn => fn(row));
+    }
+    return {
+        sql: clauses.join(" AND "),
+        values: allValues,
+        postFilter,
+    };
+}
+function buildOr(conditions, affinities) {
+    if (!Array.isArray(conditions)) {
+        return {
+            sql: FALSE_SQL,
+            values: [],
+        };
+    }
+    if (conditions.some(isMatchAllCondition)) {
+        return {
+            sql: "",
+            values: [],
+        };
+    }
+    const results = conditions.map(c => buildWhere(c, affinities));
+    const allFullyPushable = results.every(r => !r.postFilter);
+    if (allFullyPushable) {
+        const nonEmpty = results.filter(r => r.sql && r.sql !== FALSE_SQL);
+        if (nonEmpty.length === 0)
+            return {
+                sql: FALSE_SQL,
+                values: [],
+            };
+        return {
+            sql: nonEmpty.map(r => `(${r.sql})`).join(" OR "),
+            values: nonEmpty.flatMap(r => r.values),
+        };
+    }
+    return {
+        sql: "",
+        values: [],
+        postFilter: row => {
+            try {
+                return hasFieldsAdvanced(row, {
+                    $or: conditions,
+                });
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/const.d.ts

@@ -0,0 +1,12 @@
+import { Affinity } from "./types.js";
+export declare const MAX_STMT_CACHE = 100;
+export declare const BATCH_SIZE: number;
+interface PushResult {
+    sql: string;
+    values: any[];
+}
+type PushFn = (field: string, value: any, affinity?: Affinity) => PushResult | null;
+export declare const PUSHABLE_OPS: Record<string, PushFn>;
+export declare const NON_PUSHABLE_OPS: Set<string>;
+export declare const COMPLEX_OPS: string[];
+export {};

package/dist/const.js

@@ -0,0 +1,155 @@
+import { globEscape, qid, toSqlValue } from "./utils.js";
+export const MAX_STMT_CACHE = 100;
+export const BATCH_SIZE = +process.env.VALTHERA_SQLITE_BATCH_SIZE || 500;
+const NUMERIC_TYPEOF = "IN ('integer','real')";
+function numGuard(field, op, value) {
+    const f = qid(field);
+    return {
+        sql: `(typeof(${f}) ${NUMERIC_TYPEOF} AND ${f} ${op} ?)`,
+        values: [
+            value,
+        ],
+    };
+}
+function textGuard(field, op, value) {
+    const f = qid(field);
+    return {
+        sql: `(typeof(${f}) = 'text' AND ${f} ${op} ?)`,
+        values: [
+            value,
+        ],
+    };
+}
+function rangeOp(field, value, op) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return numGuard(field, op, value);
+    if (typeof value === "string")
+        return textGuard(field, op, value);
+    return null;
+}
+function buildInComposite(field, list) {
+    if (list.some(v => v === undefined || (typeof v === "number" && !Number.isFinite(v))))
+        return null;
+    const f = qid(field);
+    const numbers = list.filter(v => typeof v === "number");
+    const strings = list.filter(v => typeof v === "string");
+    const others = list.filter(v => typeof v === "boolean" || v === null);
+    const groups = [];
+    const values = [];
+    if (numbers.length > 0) {
+        groups.push(`(typeof(${f}) ${NUMERIC_TYPEOF} AND ${f} IN (${numbers.map(() => "?").join(",")}))`);
+        values.push(...numbers);
+    }
+    if (strings.length > 0) {
+        groups.push(`(typeof(${f}) = 'text' AND ${f} IN (${strings.map(() => "?").join(",")}))`);
+        values.push(...strings);
+    }
+    if (others.length > 0) {
+        groups.push(`${f} IN (${others.map(() => "?").join(",")})`);
+        values.push(...others.map(v => toSqlValue(v)));
+    }
+    if (groups.length === 0)
+        return null;
+    return {
+        sql: groups.join(" OR "),
+        values,
+    };
+}
+export const PUSHABLE_OPS = {
+    $gt: (field, value) => rangeOp(field, value, ">"),
+    $lt: (field, value) => rangeOp(field, value, "<"),
+    $gte: (field, value) => rangeOp(field, value, ">="),
+    $lte: (field, value) => rangeOp(field, value, "<="),
+    $in: (field, value) => {
+        if (!Array.isArray(value))
+            return null;
+        return buildInComposite(field, value);
+    },
+    $nin: (field, value) => {
+        if (!Array.isArray(value))
+            return null;
+        const composite = buildInComposite(field, value);
+        if (!composite)
+            return null;
+        return {
+            sql: `NOT (${composite.sql})`,
+            values: composite.values,
+        };
+    },
+    $between: (field, value) => {
+        if (!Array.isArray(value) || value.length !== 2)
+            return null;
+        const f = qid(field);
+        const [min, max] = value;
+        if (typeof min !== "number" ||
+            typeof max !== "number" ||
+            !Number.isFinite(min) ||
+            !Number.isFinite(max))
+            return null;
+        return {
+            sql: `(typeof(${f}) ${NUMERIC_TYPEOF} AND ${f} BETWEEN ? AND ?)`,
+            values: [
+                min,
+                max,
+            ],
+        };
+    },
+    $exists: (field, value) => {
+        const f = qid(field);
+        if (value === true)
+            return {
+                sql: `${f} IS NOT NULL`,
+                values: [],
+            };
+        if (value === false)
+            return {
+                sql: `${f} IS NULL`,
+                values: [],
+            };
+        return null;
+    },
+    $startswith: (field, value) => {
+        if (typeof value !== "string")
+            return null;
+        const f = qid(field);
+        return {
+            sql: `(typeof(${f}) = 'text' AND ${f} GLOB ?)`,
+            values: [
+                globEscape(value) + "*",
+            ],
+        };
+    },
+    $endswith: (field, value) => {
+        if (typeof value !== "string")
+            return null;
+        const f = qid(field);
+        return {
+            sql: `(typeof(${f}) = 'text' AND ${f} GLOB ?)`,
+            values: [
+                "*" + globEscape(value),
+            ],
+        };
+    },
+};
+export const NON_PUSHABLE_OPS = new Set([
+    "$type",
+    "$size",
+    "$arrinc",
+    "$arrincall",
+    "$idgt",
+    "$idlt",
+    "$idgte",
+    "$idlte",
+    "$regex",
+]);
+export const COMPLEX_OPS = [
+    "$push",
+    "$pushall",
+    "$pushset",
+    "$pull",
+    "$pullall",
+    "$rename",
+    "$unset",
+    "$merge",
+    "$deepmerge",
+];

package/dist/find.js

@@ -1,27 +1,46 @@
 import { findUtil } from "@wxn0brp/db-core/utils/action";
 import { findObj } from "@wxn0brp/db-core/utils/process";
-import { toSqlValue } from "./index.js";
+import { buildWhere } from "./buildWhere.js";
+import { decodeSqlValue, execStmt, qid } from "./utils.js";
+function parseRow(row) {
+    const parsed = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (value instanceof Uint8Array) {
+            parsed[key] = decodeSqlValue(value);
+            continue;
+        }
+        if (value === null)
+            continue;
+        if (typeof value === "string" &&
+            ((value.startsWith("[") && value.endsWith("]")) ||
+                (value.startsWith("{") && value.endsWith("}")))) {
+            try {
+                parsed[key] = JSON.parse(value);
+                continue;
+            }
+            catch { }
+        }
+        parsed[key] = value;
+    }
+    return parsed;
+}
 export async function find(slv, config) {
     const { collection, search } = config;
+    const affinities = await slv._getColumnAffinities(collection);
+    const where = buildWhere(search, affinities);
     let sqlResult = [];
-    const baseKeys = typeof search === "object" && search !== null && !Array.isArray(search)
-        ? Object.keys(search)
-            .filter(k => search[k] !== undefined)
-            .filter(k => !k.startsWith("$"))
-            .filter(k => typeof search[k] !== "object")
-        : [];
-    if (typeof search === "function" || baseKeys.length === 0) {
-        const stmt = await slv._prepare(`SELECT * FROM ${collection}`);
-        sqlResult = await Promise.resolve(stmt.all());
+    if (where.sql) {
+        const stmt = await slv._prepare(`SELECT * FROM ${qid(collection)} WHERE ${where.sql}`);
+        sqlResult = await execStmt(stmt, "all", ...where.values);
     }
     else {
-        const baseSql = `SELECT * FROM ${collection} WHERE ${baseKeys.map(k => `${k} = ?`).join(" AND ")}`;
-        const baseValues = baseKeys.map(k => toSqlValue(search[k]));
-        const stmt = await slv._prepare(baseSql);
-        sqlResult = await Promise.resolve(stmt.all(...baseValues));
+        const stmt = await slv._prepare(`SELECT * FROM ${qid(collection)}`);
+        sqlResult = await execStmt(stmt, "all");
+    }
+    sqlResult = sqlResult.map(parseRow);
+    if (where.postFilter) {
+        sqlResult = sqlResult.filter(where.postFilter);
     }
-    const result = sqlResult
-        .map(entry => findObj(config, entry))
-        .filter(Boolean);
+    const result = sqlResult.map(entry => findObj(config, entry)).filter(Boolean);
     return findUtil(config, result, []);
 }

package/dist/index.d.ts

@@ -2,14 +2,26 @@ import { ValtheraClass } from "@wxn0brp/db-core";
 import { ActionsBase } from "@wxn0brp/db-core/base/actions";
 import { Data } from "@wxn0brp/db-core/types/data";
 import { VQueryT } from "@wxn0brp/db-core/types/query";
-import { SupportedDB, VStatement } from "./types.js";
-export declare function toSqlValue(v: any): any;
+import { AffinityMap, SupportedDB, VStatement } from "./types.js";
 export declare class SQLiteValthera extends ActionsBase {
     db: SupportedDB;
     primaryKey: Record<string, string>;
     _inited: boolean;
+    _stmtCache: Map<string, VStatement>;
+    _stmtCacheKeys: string[];
+    _pendingStmts: Map<string, Promise<VStatement>>;
+    _tableColumns: Map<string, Set<string>>;
+    _tableAffinities: Map<string, AffinityMap>;
     constructor(db: SupportedDB, primaryKey?: Record<string, string>);
+    _getTableInfo(collection: string): Promise<Record<string, string>>;
+    _invalidateTableCache(collection: string): Promise<void>;
+    _getTableColumns(collection: string): Promise<Set<string>>;
+    _getColumnAffinities(collection: string): Promise<AffinityMap>;
+    _ensureColumns(collection: string, keys: string[]): Promise<void>;
+    close(): Promise<void>;
     _prepare(sql: string): Promise<VStatement>;
+    private _prepareUncached;
+    _cacheStmt(sql: string, stmt: VStatement): void;
     getCollections(): Promise<string[]>;
     add(config: VQueryT.Add): Promise<Data>;
     find(config: VQueryT.Find): Promise<Data[]>;

package/dist/index.js

@@ -1,56 +1,152 @@
 import { forgeTypedValthera, ValtheraClass } from "@wxn0brp/db-core";
 import { ActionsBase } from "@wxn0brp/db-core/base/actions";
 import { addId } from "@wxn0brp/db-core/helpers/addId";
+import { MAX_STMT_CACHE } from "./const.js";
 import { find } from "./find.js";
 import { remove } from "./remove.js";
+import { execStmt, computeAffinity, qid, toSqlValue } from "./utils.js";
 import { update } from "./update.js";
-export function toSqlValue(v) {
-    if (typeof v === "boolean")
-        return v ? 1 : 0;
-    return v;
-}
 export class SQLiteValthera extends ActionsBase {
     db;
     primaryKey;
     _inited = true;
+    _stmtCache = new Map();
+    _stmtCacheKeys = [];
+    _pendingStmts = new Map();
+    _tableColumns = new Map();
+    _tableAffinities = new Map();
     constructor(db, primaryKey = {}) {
         super();
         this.db = db;
         this.primaryKey = primaryKey;
     }
+    async _getTableInfo(collection) {
+        const stmt = await this._prepare(`PRAGMA table_info(${qid(collection)})`);
+        const rows = await execStmt(stmt, "all");
+        const info = {};
+        for (const r of rows)
+            info[r.name] = r.type || "";
+        return info;
+    }
+    async _invalidateTableCache(collection) {
+        this._tableColumns.delete(collection);
+        this._tableAffinities.delete(collection);
+    }
+    async _getTableColumns(collection) {
+        const cached = this._tableColumns.get(collection);
+        if (cached)
+            return cached;
+        const info = await this._getTableInfo(collection);
+        const cols = new Set(Object.keys(info));
+        this._tableColumns.set(collection, cols);
+        return cols;
+    }
+    async _getColumnAffinities(collection) {
+        const cached = this._tableAffinities.get(collection);
+        if (cached)
+            return cached;
+        const info = await this._getTableInfo(collection);
+        const affinities = {};
+        for (const [name, type] of Object.entries(info))
+            affinities[name] = computeAffinity(type);
+        this._tableAffinities.set(collection, affinities);
+        return affinities;
+    }
+    async _ensureColumns(collection, keys) {
+        const existing = await this._getTableColumns(collection);
+        const missing = keys.filter(k => k !== "_id" && !existing.has(k));
+        if (missing.length === 0)
+            return;
+        for (const col of missing) {
+            const stmt = await this._prepare(`ALTER TABLE ${qid(collection)} ADD COLUMN ${qid(col)}`);
+            await execStmt(stmt, "run");
+        }
+        await this._invalidateTableCache(collection);
+    }
+    async close() {
+        this._stmtCache.clear();
+        this._stmtCacheKeys = [];
+        this._pendingStmts.clear();
+        this._tableColumns.clear();
+        this._tableAffinities.clear();
+        const close = this.db.close;
+        if (typeof close === "function")
+            await Promise.resolve(close.call(this.db));
+    }
     async _prepare(sql) {
+        const cached = this._stmtCache.get(sql);
+        if (cached)
+            return cached;
+        const pending = this._pendingStmts.get(sql);
+        if (pending)
+            return pending;
+        const promise = this._prepareUncached(sql).finally(() => {
+            this._pendingStmts.delete(sql);
+        });
+        this._pendingStmts.set(sql, promise);
+        return promise;
+    }
+    async _prepareUncached(sql) {
         const db = this.db;
-        if (typeof db.prepare !== "undefined")
-            return await db.prepare(sql);
-        if (typeof db.prepareSync !== "undefined")
-            return await db.prepareSync(sql);
-        if (typeof db.query === "function") {
+        let stmt;
+        if (typeof db.prepare !== "undefined") {
+            stmt = await db.prepare(sql);
+        }
+        else if (typeof db.prepareSync !== "undefined") {
+            stmt = await db.prepareSync(sql);
+        }
+        else if (typeof db.query === "function") {
             const q = await db.query(sql);
-            if (q && (q.all || q.get || q.run))
-                return q;
+            if (q && (q.all || q.get || q.run)) {
+                stmt = q;
+            }
+            else {
+                throw new Error("Unsupported database");
+            }
+        }
+        else {
+            throw new Error("Unsupported database");
+        }
+        this._cacheStmt(sql, stmt);
+        return stmt;
+    }
+    _cacheStmt(sql, stmt) {
+        if (this._stmtCache.size >= MAX_STMT_CACHE) {
+            const oldest = this._stmtCacheKeys.shift();
+            if (oldest)
+                this._stmtCache.delete(oldest);
         }
-        throw new Error("Unsupported database");
+        this._stmtCache.set(sql, stmt);
+        this._stmtCacheKeys.push(sql);
     }
     async getCollections() {
-        const tables = (await this._prepare("SELECT name FROM sqlite_master WHERE type='table'")).all();
+        const stmt = await this._prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+        const tables = await execStmt(stmt, "all");
         return tables.map((t) => t.name);
     }
     async add(config) {
         const { data, collection } = config;
         await addId(config, this, true);
-        const keys = Object.keys(data);
+        const entries = Object.entries(data).filter(([, v]) => v !== undefined);
+        if (entries.length === 0)
+            throw new Error(`Cannot insert an empty document into "${collection}"`);
+        await this._ensureColumns(collection, entries.map(([k]) => k));
+        const affinities = await this._getColumnAffinities(collection);
+        const keys = entries.map(([k]) => k);
         const placeholders = keys.map(() => "?").join(", ");
-        const values = keys.map(k => toSqlValue(data[k]));
-        const sql = `INSERT INTO ${collection} (${keys.join(", ")}) VALUES (${placeholders})`;
+        const values = entries.map(([k, v]) => toSqlValue(v, affinities[k]));
+        const sql = `INSERT INTO ${qid(collection)} (${keys.map(k => qid(k)).join(", ")}) VALUES (${placeholders})`;
         const stmt = await this._prepare(sql);
-        await Promise.resolve(stmt.run(...values));
+        await execStmt(stmt, "run", ...values);
         return data;
     }
     find(config) {
         return find(this, config);
     }
     async findOne(config) {
-        config.dbFindOpts = { limit: 1 };
+        config.dbFindOpts = {
+            limit: 1,
+        };
         const result = await this.find(config);
         return result.length ? result[0] : null;
     }
@@ -69,15 +165,15 @@ export class SQLiteValthera extends ActionsBase {
         return res[0] || null;
     }
     async removeCollection(collection) {
-        const sql = `DROP TABLE IF EXISTS ${collection}`;
+        const sql = `DROP TABLE IF EXISTS ${qid(collection)}`;
         const stmt = await this._prepare(sql);
-        await Promise.resolve(stmt.run());
+        await execStmt(stmt, "run");
+        await this._invalidateTableCache(collection);
         return true;
     }
     async issetCollection(collection) {
-        const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
-        const stmt = await this._prepare(sql);
-        const result = await Promise.resolve(stmt.all(collection));
+        const stmt = await this._prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?");
+        const result = await execStmt(stmt, "all", collection);
         return result.length > 0;
     }
     async ensureCollection(collection) {
@@ -89,8 +185,10 @@ export class SQLiteValthera extends ActionsBase {
     }
 }
 export function createSQLiteValthera(sqlDB) {
-    const dbAction = new SQLiteValthera(sqlDB);
-    const db = new ValtheraClass({ dbAction });
+    const adapter = new SQLiteValthera(sqlDB);
+    const db = new ValtheraClass({
+        adapter,
+    });
     return forgeTypedValthera(db);
 }
 export const DYNAMIC = {
@@ -116,5 +214,5 @@ export const DYNAMIC = {
         if (!opts)
             opts = {};
         return new SQLiteValthera(new def(file, opts), keys);
-    }
+    },
 };

package/dist/remove.js

@@ -1,20 +1,21 @@
+import { BATCH_SIZE } from "./const.js";
 import { find } from "./find.js";
-const BATCH_SIZE = +process.env.VALTHERA_SQLITE_BATCH_SIZE || 500;
+import { execStmt, qid } from "./utils.js";
 export async function remove(slv, query, one) {
     const { collection } = query;
     const toDelete = await find(slv, {
         ...query,
         dbFindOpts: {
-            limit: one ? 1 : undefined
-        }
+            limit: one ? 1 : undefined,
+        },
     });
     if (!toDelete.length)
         return [];
     const key = slv.primaryKey[collection] || "_id";
     for (let i = 0; i < toDelete.length; i += BATCH_SIZE) {
         const batch = toDelete.slice(i, i + BATCH_SIZE);
-        const stmt = await slv._prepare(`DELETE FROM "${collection}" WHERE "${key}" IN (${batch.map(() => "?").join(", ")})`);
-        await Promise.resolve(stmt.run(...batch.map(d => d[key])));
+        const stmt = await slv._prepare(`DELETE FROM ${qid(collection)} WHERE ${qid(key)} IN (${batch.map(() => "?").join(", ")})`);
+        await execStmt(stmt, "run", ...batch.map(d => d[key]));
     }
     return toDelete;
 }

package/dist/types.d.ts

@@ -5,3 +5,5 @@ import type NodeSqlite from "node:sqlite";
 import type { DatabaseSync as NodeSqliteDB } from "node:sqlite";
 export type SupportedDB = BetterSqliteDB | NodeSqliteDB | BunSqliteDB;
 export type VStatement = BetterSqlite3.Statement | NodeSqlite.StatementSync;
+export type Affinity = "INTEGER" | "TEXT" | "BLOB" | "REAL" | "NUMERIC" | "NONE";
+export type AffinityMap = Record<string, Affinity>;

package/dist/update.js

@@ -1,30 +1,190 @@
 import { updateObj } from "@wxn0brp/db-core/utils/process";
-import { toSqlValue } from "./index.js";
+import { buildWhere } from "./buildWhere.js";
+import { COMPLEX_OPS } from "./const.js";
 import { find } from "./find.js";
+import { execStmt, qid, toSqlValue } from "./utils.js";
 export async function update(slv, query, one) {
-    const { collection } = query;
+    const { collection, updater } = query;
     const matched = await find(slv, {
         ...query,
         dbFindOpts: {
-            limit: one ? 1 : undefined
-        }
+            limit: one ? 1 : undefined,
+        },
     });
     if (matched.length === 0)
         return [];
     const key = slv.primaryKey[collection] || "_id";
-    const updateOne = async (target) => {
-        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 => toSqlValue(newData[k]));
-        const sql = `UPDATE "${collection}" SET ${keys.map(k => `"${k}" = ?`).join(", ")} WHERE "${key}" = ?`;
+    if (typeof updater === "function") {
+        const results = [];
+        for (const target of matched)
+            results.push(await updateOne(slv, query, target, key));
+        return results;
+    }
+    const affinities = await slv._getColumnAffinities(collection);
+    const where = buildWhere(query.search, affinities);
+    if (where.sql && !where.postFilter) {
+        const incFields = collectIncDecFields(updater);
+        const incCompatible = incFields.length === 0 ||
+            matched.every(row => incFields.every(field => {
+                const v = row[field];
+                return v === undefined || v === null || typeof v === "number";
+            }));
+        const simpleUpdateSql = incCompatible
+            ? tryBuildSimpleUpdate(updater, key, affinities)
+            : null;
+        if (simpleUpdateSql) {
+            await slv._ensureColumns(collection, simpleUpdateSql.columns);
+            const sql = `UPDATE ${qid(collection)} SET ${simpleUpdateSql.set} WHERE ${where.sql}`;
+            const values = [
+                ...simpleUpdateSql.values,
+                ...where.values,
+            ];
+            const stmt = await slv._prepare(sql);
+            await execStmt(stmt, "run", ...values);
+            return matched.map(row => {
+                const pk = row[key];
+                const newData = updateObj(query, row);
+                if (newData[key] !== pk)
+                    newData[key] = pk;
+                return newData;
+            });
+        }
+    }
+    const stmtCache = new Map();
+    const getStmt = async (sql) => {
+        const cached = stmtCache.get(sql);
+        if (cached)
+            return cached;
         const stmt = await slv._prepare(sql);
-        await Promise.resolve(stmt.run(...values, target[key]));
-        return newData;
+        stmtCache.set(sql, stmt);
+        return stmt;
     };
     const results = [];
     for (const target of matched)
-        results.push(await updateOne(target));
+        results.push(await updateOne(slv, query, target, key, getStmt));
     return results;
 }
+async function updateOne(slv, query, target, key, getStmt) {
+    const beforeKeys = Object.keys(target);
+    const pkValue = target[key];
+    const newData = updateObj(query, target);
+    if (newData[key] !== pkValue)
+        newData[key] = pkValue;
+    const affinities = await slv._getColumnAffinities(query.collection);
+    const setClauses = [];
+    const values = [];
+    const columns = [];
+    for (const k of Object.keys(newData)) {
+        if (k === key)
+            continue;
+        columns.push(k);
+        if (newData[k] === undefined) {
+            setClauses.push(`${qid(k)} = NULL`);
+            continue;
+        }
+        setClauses.push(`${qid(k)} = ?`);
+        values.push(toSqlValue(newData[k], affinities[k]));
+    }
+    for (const k of beforeKeys) {
+        if (k === key || k in newData)
+            continue;
+        columns.push(k);
+        setClauses.push(`${qid(k)} = NULL`);
+    }
+    await slv._ensureColumns(query.collection, columns);
+    if (setClauses.length === 0)
+        return newData;
+    const sql = `UPDATE ${qid(query.collection)} SET ${setClauses.join(", ")} WHERE ${qid(key)} = ?`;
+    const stmt = getStmt ? await getStmt(sql) : await slv._prepare(sql);
+    await execStmt(stmt, "run", ...values, pkValue);
+    return newData;
+}
+function tryBuildSimpleUpdate(updater, key, affinities) {
+    const $fields = {};
+    const flatFields = {};
+    for (const k of Object.keys(updater)) {
+        if (k.startsWith("$")) {
+            $fields[k.toLowerCase()] = updater[k];
+        }
+        else {
+            flatFields[k] = updater[k];
+        }
+    }
+    const hasComplex = Object.keys($fields).some(k => COMPLEX_OPS.includes("$" + k));
+    if (hasComplex)
+        return null;
+    const setClauses = [];
+    const values = [];
+    const columns = [];
+    if ("$set" in $fields) {
+        for (const [field, value] of Object.entries($fields["$set"])) {
+            if (field === key)
+                continue;
+            columns.push(field);
+            if (value === undefined) {
+                setClauses.push(`${qid(field)} = NULL`);
+                continue;
+            }
+            setClauses.push(`${qid(field)} = ?`);
+            values.push(toSqlValue(value, affinities[field]));
+        }
+    }
+    if ("$inc" in $fields) {
+        for (const [field, value] of Object.entries($fields["$inc"])) {
+            if (field === key)
+                continue;
+            if (typeof value !== "number")
+                return null;
+            columns.push(field);
+            setClauses.push(incDecClause(field, "+"));
+            values.push(value, value);
+        }
+    }
+    if ("$dec" in $fields) {
+        for (const [field, value] of Object.entries($fields["$dec"])) {
+            if (field === key)
+                continue;
+            if (typeof value !== "number")
+                return null;
+            columns.push(field);
+            setClauses.push(incDecClause(field, "-"));
+            values.push(value, value);
+        }
+    }
+    for (const [field, value] of Object.entries(flatFields)) {
+        if (field === key)
+            continue;
+        if (typeof value === "object" && value !== null)
+            return null;
+        columns.push(field);
+        if (value === undefined) {
+            setClauses.push(`${qid(field)} = NULL`);
+            continue;
+        }
+        setClauses.push(`${qid(field)} = ?`);
+        values.push(toSqlValue(value, affinities[field]));
+    }
+    if (setClauses.length === 0)
+        return null;
+    return {
+        set: setClauses.join(", "),
+        values,
+        columns,
+    };
+}
+function incDecClause(field, op) {
+    const f = qid(field);
+    return `${f} = CASE WHEN ${f} IS NULL THEN ? WHEN typeof(${f}) IN ('integer','real') THEN ${f} ${op} ? ELSE ${f} END`;
+}
+function collectIncDecFields(updater) {
+    const fields = [];
+    for (const op of [
+        "$inc",
+        "$dec",
+    ]) {
+        const map = updater[op];
+        if (typeof map === "object" && map !== null)
+            fields.push(...Object.keys(map));
+    }
+    return fields;
+}

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { Affinity, VStatement } from "./types.js";
+export declare function qid(identifier: string): string;
+export declare function computeAffinity(type: string): Affinity;
+export declare function toSqlValue(v: any, affinity?: Affinity): any;
+export declare function decodeSqlValue(value: any): any;
+export declare function globEscape(value: string): string;
+export declare function execStmt(stmt: VStatement, method: "all" | "run" | "get", ...args: any[]): Promise<any>;

package/dist/utils.js

@@ -0,0 +1,78 @@
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export function qid(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+}
+export function computeAffinity(type) {
+    const t = (type || "").toUpperCase();
+    if (!t)
+        return "NONE";
+    if (t.includes("INT"))
+        return "INTEGER";
+    if (t.includes("CHAR") || t.includes("CLOB") || t.includes("TEXT"))
+        return "TEXT";
+    if (t.includes("BLOB"))
+        return "NONE";
+    if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB"))
+        return "REAL";
+    return "NUMERIC";
+}
+const BLOB_PREFIX = "VJ:";
+const BLOB_PREFIX_BYTES = textEncoder.encode(BLOB_PREFIX);
+function encodeJsonBlob(v) {
+    const json = textEncoder.encode(JSON.stringify(v));
+    const out = new Uint8Array(BLOB_PREFIX_BYTES.length + json.length);
+    out.set(BLOB_PREFIX_BYTES);
+    out.set(json, BLOB_PREFIX_BYTES.length);
+    return out;
+}
+function isNumericLike(s) {
+    return s.trim() !== "" && !Number.isNaN(Number(s));
+}
+export function toSqlValue(v, affinity) {
+    if (typeof v === "boolean")
+        return encodeJsonBlob(v);
+    if (v === null)
+        return encodeJsonBlob(null);
+    if (typeof v === "string") {
+        if ((affinity === "INTEGER" ||
+            affinity === "REAL" ||
+            affinity === "NUMERIC") &&
+            isNumericLike(v)) {
+            return encodeJsonBlob(v);
+        }
+        return v;
+    }
+    if (typeof v === "object" && v !== null)
+        return JSON.stringify(v);
+    return v;
+}
+export function decodeSqlValue(value) {
+    if (value instanceof Uint8Array) {
+        if (startsWithBytes(value, BLOB_PREFIX_BYTES)) {
+            const text = textDecoder.decode(value.subarray(BLOB_PREFIX_BYTES.length));
+            try {
+                return JSON.parse(text);
+            }
+            catch { }
+        }
+        return value;
+    }
+    return value;
+}
+function startsWithBytes(value, prefix) {
+    if (value.length < prefix.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++)
+        if (value[i] !== prefix[i])
+            return false;
+    return true;
+}
+const GLOB_META = /[*?[\]]/g;
+export function globEscape(value) {
+    return value.replace(GLOB_META, c => `[${c}]`);
+}
+export async function execStmt(stmt, method, ...args) {
+    const result = stmt[method](...args);
+    return result instanceof Promise ? await result : result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-storage-sqlite",
-  "version": "0.110.4",
+  "version": "0.120.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A pure SQLite storage adapter for the ValtheraDB database library",
@@ -19,17 +19,18 @@
     "sqlite"
   ],
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
+    "@types/better-sqlite3": "^9.6.0",
     "@types/bun": "*",
     "@types/node": "*",
-    "@wxn0brp/db-core": "^0.11.0",
-    "better-sqlite3": "^12.10.0",
+    "@wxn0brp/biome": "*",
+    "@wxn0brp/db-core": "^0.12.0",
+    "better-sqlite3": "^13.0.3",
     "tsc-alias": "^1",
-    "typescript": "^6"
+    "typescript": "^7"
   },
   "peerDependencies": {
-    "@wxn0brp/db-core": "^0.11.0",
-    "better-sqlite3": "^12.10.0"
+    "@wxn0brp/db-core": "^0.12.0",
+    "better-sqlite3": "^13.0.3"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/db-core": {