browser-sqlite 1.0.0-rc.3 → 1.0.0-rc.5

package/package.json

@@ -1,9 +1,15 @@
 {
 	"name": "browser-sqlite",
-	"version": "1.0.0-rc.3",
+	"version": "1.0.0-rc.5",
 	"description": "Browser SQLite with concurrent read / serial write isolation, backed by Web Workers and wa-sqlite",
 	"author": "LAlex",
 	"license": "MIT",
+	"sideEffects": [
+		"./dist/worker/worker.js"
+	],
+	"engines": {
+		"node": ">=18"
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/lalexdotcom/browser-sqlite.git"
@@ -24,14 +30,17 @@
 	"type": "module",
 	"exports": {
 		".": {
-			"types": "./dist/esm/index.d.ts",
-			"import": "./dist/esm/index.js",
-			"default": "./dist/esm/index.js"
-		}
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./worker": "./dist/worker/worker.js"
 	},
-	"types": "./dist/esm/index.d.ts",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"files": [
-		"dist"
+		"dist",
+		"NOTICE"
 	],
 	"scripts": {
 		"build": "rslib build",
@@ -40,22 +49,36 @@
 		"dev": "rslib build --watch",
 		"format": "biome format --write",
 		"prepare": "simple-git-hooks",
-		"test": "rstest",
+		"test": "node scripts/bounded.mjs 900 rstest && node scripts/bounded.mjs 900 rstest --config rstest.firefox.config.ts && node scripts/bounded.mjs 600 rstest --config rstest.isolated.config.ts",
+		"test:isolated": "node scripts/bounded.mjs 600 rstest --config rstest.isolated.config.ts",
 		"test:watch": "rstest --watch",
 		"test:unit": "rstest --project unit",
-		"test:browser": "rstest --project browser"
+		"test:browser": "node scripts/bounded.mjs 900 rstest --project 'chromium*' && node scripts/bounded.mjs 900 rstest --config rstest.firefox.config.ts",
+		"test:chromium": "node scripts/bounded.mjs 900 rstest --project 'chromium*'",
+		"test:firefox": "node scripts/bounded.mjs 900 rstest --config rstest.firefox.config.ts",
+		"test:consumer": "node scripts/consumer-smoke.mjs",
+		"test:conformance": "node scripts/bounded.mjs 900 rstest --config rstest.conformance.config.ts && node scripts/bounded.mjs 900 rstest --config rstest.conformance.firefox.config.ts",
+		"test:conformance:chromium": "node scripts/bounded.mjs 900 rstest --config rstest.conformance.config.ts",
+		"test:conformance:firefox": "node scripts/bounded.mjs 900 rstest --config rstest.conformance.firefox.config.ts",
+		"test:matrix": "node scripts/test-matrix.mjs",
+		"docs:vfs": "node scripts/render-vfs-matrix.ts",
+		"bench:build": "pnpm build && node scripts/bench/assemble.mjs _site",
+		"bench:serve": "npx --yes kill-port 8099 && pnpm bench:build && node scripts/static-server.mjs _site 8099",
+		"bench:dev": "npx --yes kill-port 8099 && node scripts/bench/dev.mjs 8099"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.4.6",
-		"@rslib/core": "^0.20.0",
-		"@rstest/adapter-rslib": "^0.2.1",
-		"@rstest/browser": "0.9.4",
-		"@rstest/core": "^0.9.0",
+		"@biomejs/biome": "2.5.8",
+		"@mdn/browser-compat-data": "^8.0.13",
+		"@rslib/core": "^0.23.2",
+		"@rstest/adapter-rslib": "0.11.8",
+		"@rstest/browser": "0.11.8",
+		"@rstest/core": "0.11.8",
 		"@types/node": "^24.12.0",
 		"lint-staged": "^16.4.0",
-		"playwright": "1.58.2",
+		"playwright": "1.62.1",
 		"simple-git-hooks": "^2.13.1",
-		"typescript": "^5.9.3"
+		"typescript": "^7.0.2",
+		"wa-sqlite": "github:rhashimoto/wa-sqlite#93b9230892a4c440ddbc06936bcd8500e2d6e6cf"
 	},
 	"lint-staged": {
 		"*.{js,ts,jsx,tsx,mjs,cjs}": [
@@ -63,17 +86,18 @@
 		]
 	},
 	"simple-git-hooks": {
-		"pre-commit": "npx lint-staged && pnpm test && pnpm exec tsc --noEmit"
+		"pre-commit": "pnpm exec tsc --noEmit && npx lint-staged && if [ -f \"$(git rev-parse --git-path MERGE_HEAD)\" ]; then pnpm test; else pnpm test:unit; fi",
+		"pre-merge-commit": "pnpm exec tsc --noEmit && pnpm exec biome ci . && pnpm test",
+		"pre-push": "pnpm exec tsc --noEmit && pnpm exec biome ci . && pnpm docs:vfs && git diff --exit-code VFS.md && pnpm test"
 	},
 	"pnpm": {
 		"onlyBuiltDependencies": [
 			"simple-git-hooks"
-		]
+		],
+		"patchedDependencies": {
+			"wa-sqlite@1.1.2": "patches/wa-sqlite@1.1.2.patch"
+		}
 	},
 	"private": false,
-	"dependencies": {
-		"@lalex/promises": "^1.2.0",
-		"wa-sqlite": "github:rhashimoto/wa-sqlite#v1.0.9"
-	},
 	"packageManager": "pnpm@10.31.0"
 }

package/dist/esm/index.js

@@ -1,424 +0,0 @@
-import { defer } from "@lalex/promises";
-const FlagsIndexes = {
-    INIT_LOCK: 0
-};
-const WorkerLock = {
-    FREE: 0,
-    LOCKED: 1
-};
-const WorkerStatuses = {
-    EMPTY: -3,
-    NEW: -2,
-    INITIALIZING: -1,
-    INITIALIZED: 0,
-    READY: 10,
-    RESERVED: 49,
-    RUNNING: 50,
-    ABORTING: 99,
-    DONE: 100
-};
-const FLAGS_WORKER_STATUS_OFFSET = Math.max(...Object.values(FlagsIndexes)) + 1;
-class WorkerOrchestrator {
-    sharedArrayBuffer;
-    flags;
-    size;
-    constructor(init){
-        if ('number' == typeof init) this.sharedArrayBuffer = new SharedArrayBuffer((init + FLAGS_WORKER_STATUS_OFFSET) * Int32Array.BYTES_PER_ELEMENT);
-        else this.sharedArrayBuffer = init;
-        this.flags = new Int32Array(this.sharedArrayBuffer);
-        if ('number' == typeof init) {
-            this.size = init;
-            this.flags[FlagsIndexes.INIT_LOCK] = WorkerLock.FREE;
-            this.flags.fill(WorkerStatuses.EMPTY, FLAGS_WORKER_STATUS_OFFSET);
-        } else this.size = init.byteLength / Int32Array.BYTES_PER_ELEMENT - FLAGS_WORKER_STATUS_OFFSET;
-    }
-    lock() {
-        while(Atomics.compareExchange(this.flags, FlagsIndexes.INIT_LOCK, WorkerLock.FREE, WorkerLock.LOCKED) !== WorkerLock.FREE)Atomics.wait(this.flags, FlagsIndexes.INIT_LOCK, WorkerLock.LOCKED);
-    }
-    unlock() {
-        if (Atomics.compareExchange(this.flags, FlagsIndexes.INIT_LOCK, WorkerLock.LOCKED, WorkerLock.FREE) === WorkerLock.LOCKED) Atomics.notify(this.flags, FlagsIndexes.INIT_LOCK, 1);
-    }
-    setStatus(index, status, from) {
-        let oldValue;
-        const workerStatusIndex = index + FLAGS_WORKER_STATUS_OFFSET;
-        if (void 0 !== from) {
-            if (Atomics.compareExchange(this.flags, workerStatusIndex, from, status) === from) oldValue = from;
-        } else {
-            const oldStatus = Atomics.exchange(this.flags, workerStatusIndex, status);
-            if (oldStatus !== status) oldValue = oldStatus;
-        }
-        const success = void 0 !== oldValue;
-        return success;
-    }
-    getStatus(index) {
-        return Atomics.load(this.flags, index + FLAGS_WORKER_STATUS_OFFSET);
-    }
-}
-const isWriteQuery = (sql)=>/(INSERT|REPLACE|UPDATE|DELETE|CREATE|DROP|PRAGMA|ATTACH|DETACH)\s/gim.test(sql);
-const DEFAULT_POOL_SIZE = 2;
-let clientCount = 0;
-const DEFAULT_VFS = 'OPFSPermutedVFS';
-const createSQLiteClient = (file, clientOptions)=>{
-    const clientIndex = ++clientCount;
-    const clientPrefix = `${clientOptions?.name ?? 'SQLite'} ${clientIndex}`;
-    const poolSize = clientOptions?.poolSize ?? DEFAULT_POOL_SIZE;
-    const pool = [];
-    const orchestrator = new WorkerOrchestrator(poolSize);
-    const vfs = clientOptions?.vfs ?? DEFAULT_VFS;
-    if ('AccessHandlePoolVFS' === vfs && poolSize > 1) throw new Error('AccessHandlePoolVFS does not support pool sizes greater than 1');
-    const { state: debug, createRequestDebugState, createWorkerDebugState, createQueryDebugState } = {};
-    const createWorker = ()=>{
-        const deferredInit = defer();
-        const workerName = `${clientPrefix} / Worker ${pool.length + 1}`;
-        const index = pool.push(new Worker(new URL('./worker.ts', import.meta.url), {
-            name: workerName
-        })) - 1;
-        const worker = Object.assign(pool[index], {
-            index,
-            available: false
-        });
-        const state = createWorkerDebugState?.(index, workerName);
-        let currentCallId = 0;
-        let deferredChunk;
-        worker.onmessage = ({ data })=>{
-            const { callId, type } = data;
-            if (0 === callId && 'ready' === type) {
-                worker.available = true;
-                if (state) state.initializationTime = Date.now();
-                deferredInit.resolve(worker);
-            }
-            if (deferredChunk && callId === currentCallId) switch(type){
-                case 'chunk':
-                    if (state?.currentRequest?.currentQuery) state.currentRequest.currentQuery.firstRowTime ??= Date.now();
-                    deferredChunk.resolve(data.data);
-                    deferredChunk = defer();
-                    break;
-                case 'done':
-                    {
-                        const affected = data.affected;
-                        if (state?.currentRequest?.currentQuery) {
-                            state.currentRequest.currentQuery.affectedRows = affected;
-                            state.currentRequest.affectedRows += affected;
-                            state.currentRequest.currentQuery.endTime = Date.now();
-                        }
-                        deferredChunk.resolve(affected);
-                        deferredChunk = void 0;
-                        break;
-                    }
-                case 'error':
-                    {
-                        const error = new Error(data.message, {
-                            cause: data.cause
-                        });
-                        if (state?.currentRequest?.currentQuery) {
-                            state.currentRequest.currentQuery.error = error;
-                            state.currentRequest.currentQuery.endTime = Date.now();
-                        }
-                        deferredChunk.reject(error);
-                        deferredChunk = void 0;
-                        break;
-                    }
-            }
-        };
-        const query = async function*(sql, params, options) {
-            try {
-                worker.available = false;
-                if (deferredChunk) {
-                    console.error(`Previous query not finished on worker ${index + 1}`);
-                    throw new Error('Worker is already processing a query');
-                }
-                if (state?.currentRequest) {
-                    const queryState = createQueryDebugState?.(index, sql, params);
-                    state.currentRequest.currentQuery = queryState;
-                }
-                const { chunkSize = 500, signal } = options ?? {};
-                const signalAbortHandler = ()=>{
-                    orchestrator.setStatus(index, WorkerStatuses.ABORTING, WorkerStatuses.RUNNING);
-                };
-                signal?.addEventListener('abort', signalAbortHandler);
-                deferredChunk = defer();
-                worker.postMessage({
-                    type: 'query',
-                    callId: ++currentCallId,
-                    sql,
-                    params,
-                    options: {
-                        chunkSize
-                    }
-                });
-                while(deferredChunk){
-                    const chunk = await deferredChunk.promise;
-                    yield chunk;
-                }
-                signal?.removeEventListener('abort', signalAbortHandler);
-            } finally{
-                deferredChunk = void 0;
-                worker.available = true;
-            }
-        };
-        Object.assign(worker, {
-            query
-        });
-        worker.postMessage({
-            callId: 0,
-            type: 'open',
-            file,
-            flags: orchestrator.sharedArrayBuffer,
-            index,
-            vfs,
-            pragmas: clientOptions?.pragmas
-        });
-        return deferredInit.promise;
-    };
-    const readerRequestQueue = [];
-    const writerRequestQueue = [];
-    let currentWriterIndex = -1;
-    const acquireWorker = (write = false)=>{
-        if (write && currentWriterIndex > -1) {
-            const writer = pool[currentWriterIndex];
-            if (writer.available) return writer;
-            return;
-        }
-        const availableWorker = pool.find((w)=>{
-            if (w.available) return true;
-            return false;
-        });
-        if (availableWorker && write) currentWriterIndex = availableWorker.index;
-        return availableWorker;
-    };
-    const acquireNextWorker = async (write = false)=>{
-        const availableWorker = acquireWorker(write);
-        if (availableWorker) {
-            availableWorker.available = false;
-            return availableWorker;
-        }
-        const { promise, resolve } = defer();
-        if (write) {
-            if (debug) debug.queue.write++;
-            writerRequestQueue.push((worker)=>{
-                worker.available = false;
-                resolve(worker);
-            });
-        } else {
-            if (debug) debug.queue.read++;
-            readerRequestQueue.push((worker)=>{
-                worker.available = false;
-                resolve(worker);
-            });
-        }
-        return promise;
-    };
-    const getNextAvailableWorker = async (write = false)=>{
-        const requestState = createRequestDebugState?.();
-        const availableWorker = await acquireNextWorker(write);
-        requestState?.assign(availableWorker.index);
-        return pool[availableWorker.index];
-    };
-    const releaseWorker = (worker)=>{
-        const requestState = debug?.workers[worker.index]?.currentRequest;
-        if (requestState) requestState.releaseTime = Date.now();
-        if (writerRequestQueue.length) {
-            if (currentWriterIndex === worker.index || -1 === currentWriterIndex) {
-                if (debug) debug.queue.write--;
-                writerRequestQueue.shift()?.(worker);
-                return;
-            }
-        }
-        if (readerRequestQueue.length) {
-            if (currentWriterIndex === worker.index) currentWriterIndex = -1;
-            if (debug) debug.queue.read--;
-            readerRequestQueue.shift()?.(worker);
-            return;
-        }
-        orchestrator.setStatus(worker.index, WorkerStatuses.READY);
-    };
-    const readWorker = async (worker, sql, params, options)=>{
-        const result = [];
-        for await (const chunk of worker.query(sql, params, options))if ('number' != typeof chunk) result.push(...chunk);
-        return result;
-    };
-    const read = async (sql, params, options)=>{
-        const worker = await getNextAvailableWorker(isWriteQuery(sql));
-        try {
-            return await readWorker(worker, sql, params, options);
-        } finally{
-            releaseWorker(worker);
-        }
-    };
-    const streamWorker = async function*(worker, sql, params, options) {
-        for await (const chunk of worker.query(sql, params, options))if ('number' != typeof chunk) yield chunk;
-    };
-    const stream = async function*(sql, params, options) {
-        const worker = await getNextAvailableWorker(isWriteQuery(sql));
-        try {
-            for await (const chunk of streamWorker(worker, sql, params, options))yield chunk;
-        } finally{
-            releaseWorker(worker);
-        }
-    };
-    const writeWorker = async (worker, sql, params, options)=>{
-        const result = [];
-        let affected = 0;
-        for await (const chunk of worker.query(sql, params, options))if ('number' != typeof chunk) result.push(...chunk);
-        else affected = chunk;
-        return {
-            result,
-            affected
-        };
-    };
-    const write = async (sql, params, options)=>{
-        const worker = await getNextAvailableWorker(isWriteQuery(sql));
-        try {
-            return await writeWorker(worker, sql, params, options);
-        } finally{
-            releaseWorker(worker);
-        }
-    };
-    const oneWorker = async (worker, sql, params, options)=>{
-        let result;
-        const abortController = new AbortController();
-        for await (const chunk of streamWorker(worker, sql, params, {
-            ...options,
-            signal: abortController.signal,
-            chunkSize: 1
-        })){
-            result = chunk[0];
-            abortController.abort();
-            break;
-        }
-        return result;
-    };
-    const one = async (sql, params, options)=>{
-        const worker = await getNextAvailableWorker(isWriteQuery(sql));
-        try {
-            return await oneWorker(worker, sql, params, options);
-        } finally{
-            releaseWorker(worker);
-        }
-    };
-    const bulkWrite = (table, keys)=>{
-        const SQLITE_MAX_VARS = 32766;
-        const maxBufferSize = Math.floor(SQLITE_MAX_VARS / keys.length);
-        const buffer = [];
-        let writePromise = Promise.resolve(0);
-        const flush = ()=>{
-            const toInsert = [
-                ...buffer
-            ];
-            buffer.length = 0;
-            writePromise = writePromise.then((currentAffected)=>write(`INSERT INTO ${table} (${keys.join(',')}) VALUES ${toInsert.map(()=>`(${keys.map(()=>'?')})`)}`, toInsert.flatMap((data)=>keys.map((k)=>data[k]))).then(({ affected: chunkAffected })=>currentAffected + chunkAffected));
-        };
-        return {
-            enqueue: (data)=>{
-                buffer.push(data);
-                if (buffer.length >= maxBufferSize) flush();
-            },
-            close: ()=>{
-                if (buffer.length) flush();
-                return writePromise;
-            }
-        };
-    };
-    const output = (table, schema, options)=>{
-        const { enqueue, close } = bulkWrite(table, Object.keys(schema).filter((col)=>'object' != typeof schema[col] || !schema[col].generated));
-        const normalizedSchema = Object.entries(schema).map(([k, v])=>{
-            const type = 'string' == typeof v ? v : v.type;
-            const unique = 'object' == typeof v && !!v.unique;
-            const notnull = 'object' == typeof v && !!v.required;
-            const generated = 'object' == typeof v ? v.generated : void 0;
-            return {
-                name: k,
-                type,
-                unique,
-                notnull,
-                generated
-            };
-        });
-        const createTablePromise = write(`
-			DROP TABLE IF EXISTS ${table}
-		`).then(async ()=>{
-            await write(`
-				CREATE ${options?.temp ? 'TEMPORARY' : ''} TABLE ${table}(
-					${normalizedSchema.map(({ name, type, unique, notnull, generated })=>`${name} ${type} ${unique ? 'UNIQUE' : ''} ${notnull ? 'NOT NULL' : ''} ${generated ? `GENERATED ALWAYS AS ${generated}` : ''}`).join(',')}
-				)
-			`);
-        });
-        return {
-            enqueue: (data)=>{
-                createTablePromise.then(()=>enqueue(data));
-            },
-            close: ()=>createTablePromise.then(()=>close()).then(async (affected)=>{
-                    if (options?.indexes) for (const index of options.indexes){
-                        const columns = 'string' == typeof index ? [
-                            index
-                        ] : Array.isArray(index) ? index : 'object' == typeof index ? 'column' in index ? [
-                            index.column
-                        ] : index.columns : void 0;
-                        const unique = !Array.isArray(index) && 'object' == typeof index && !!index.unique;
-                        if (columns) await write(`CREATE ${unique ? 'UNIQUE' : ''} INDEX IF NOT EXISTS ${table}_${columns.join('_')}_${unique ? 'U' : 'IDX'} ON ${table}(${columns.join(',')})`);
-                    }
-                    return affected;
-                })
-        };
-    };
-    const transaction = async (callback, options)=>{
-        const { readOnly = false, autoCommit = true } = options ?? {};
-        const worker = await getNextAvailableWorker(!readOnly);
-        const checksql = (sql)=>{
-            if (readOnly && isWriteQuery(sql)) throw new Error('Cannot werite in read-only transaction');
-            return sql;
-        };
-        let done = false;
-        const db = {
-            read: (sql, ...args)=>readWorker(worker, checksql(sql), ...args),
-            write: (sql, ...args)=>writeWorker(worker, checksql(sql), ...args),
-            stream: (sql, ...args)=>streamWorker(worker, checksql(sql), ...args),
-            one: (sql, ...args)=>oneWorker(worker, checksql(sql), ...args),
-            commit: async ()=>{
-                done = true;
-                await oneWorker(worker, 'COMMIT');
-            },
-            rollback: async ()=>{
-                done = true;
-                await oneWorker(worker, 'ROLLBACK');
-            }
-        };
-        try {
-            await db.read('BEGIN');
-            const result = await callback(db);
-            if (!done) if (autoCommit) await db.commit();
-            else await db.rollback();
-            return result;
-        } catch (e) {
-            await db.rollback();
-            throw e;
-        } finally{
-            releaseWorker(worker);
-        }
-    };
-    const close = ()=>{
-        let worker = pool.shift();
-        while(void 0 !== worker){
-            worker.terminate();
-            worker = pool.shift();
-        }
-    };
-    Promise.all(Array.from({
-        length: poolSize
-    }).map(()=>createWorker().then((worker)=>worker))).then((allWorkers)=>{
-        for (const worker of allWorkers)releaseWorker(worker);
-    });
-    const api = {
-        read,
-        write,
-        stream,
-        one,
-        transaction,
-        bulkWrite,
-        output,
-        close,
-        debug
-    };
-    return api;
-};
-export { createSQLiteClient };

package/dist/esm/rslib.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("@rslib/core").RslibConfig;
-export default _default;

package/dist/esm/rstest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("@rstest/core").RstestConfig;
-export default _default;