@magieno/sqlite-client - npm Package Compare versions

Comparing version 3.43.2 to 3.45.1-test1

dist/esm/messages/create-database.message.d.ts

 import { SqliteMessageInterface } from "../interfaces/sqlite-message.interface";
 import { SqliteMessageTypeEnum } from "../enums/sqlite-message-type.enum";
+import { SqliteClientOptions } from "../types/sqlite-client.options";
 export declare class CreateDatabaseMessage implements SqliteMessageInterface {
-    readonly filename: string;
-    readonly flags: string;
+    options: SqliteClientOptions;
     type: SqliteMessageTypeEnum;
     uniqueId: string;
-    constructor(filename: string, flags: string);
+    constructor(options: SqliteClientOptions);
 }

dist/esm/messages/create-database.message.js

 import { SqliteMessageTypeEnum } from "../enums/sqlite-message-type.enum";
 export class CreateDatabaseMessage {
-    constructor(filename, flags) {
-        this.filename = filename;
-        this.flags = flags;
+    constructor(options) {
+        this.options = options;
         this.type = SqliteMessageTypeEnum.CreateDatabase;
@@ -7,0 +6,0 @@ this.uniqueId = crypto.randomUUID();

dist/esm/messages/execute-sql-result.message.d.ts

@@ -5,6 +5,6 @@ import { SqliteMessageInterface } from "../interfaces/sqlite-message.interface";
     readonly uniqueId: string;
-    readonly result: string[];
+    readonly result: any[];
     readonly error?: any;
     type: SqliteMessageTypeEnum;
-    constructor(uniqueId: string, result: string[], error?: any);
+    constructor(uniqueId: string, result: any[], error?: any);
 }

dist/esm/messages/execute-sql.message.d.ts

 import { SqliteMessageInterface } from "../interfaces/sqlite-message.interface";
 import { SqliteMessageTypeEnum } from "../enums/sqlite-message-type.enum";
+import { ReturnValueEnum } from "../enums/return-value.enum";
+import { RowModeEnum } from "../enums/row-mode.enum";
 export declare class ExecuteSqlMessage implements SqliteMessageInterface {
     readonly sqlStatement: string;
     readonly bindingParameters: (string | number)[];
+    readonly returnValue: ReturnValueEnum;
+    readonly rowMode: RowModeEnum | number;
     type: SqliteMessageTypeEnum;
     uniqueId: string;
-    constructor(sqlStatement: string, bindingParameters?: (string | number)[]);
+    constructor(sqlStatement: string, bindingParameters: (string | number)[], returnValue: ReturnValueEnum, rowMode: RowModeEnum | number);
 }

dist/esm/messages/execute-sql.message.js

 import { SqliteMessageTypeEnum } from "../enums/sqlite-message-type.enum";
 export class ExecuteSqlMessage {
-    constructor(sqlStatement, bindingParameters = []) {
+    constructor(sqlStatement, bindingParameters = [], returnValue, rowMode) {
         this.sqlStatement = sqlStatement;
         this.bindingParameters = bindingParameters;
+        this.returnValue = returnValue;
+        this.rowMode = rowMode;
         this.type = SqliteMessageTypeEnum.ExecuteSql;
@@ -7,0 +9,0 @@ this.uniqueId = crypto.randomUUID();

dist/esm/sqlite-client-worker.js

@@ -0,1 +1,10 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { SqliteMessageTypeEnum } from "./enums/sqlite-message-type.enum";
@@ -5,42 +14,105 @@ import { CreateDatabaseResultMessage } from "./messages/create-database-result.message";
 import { ExecuteSqlResultMessage } from "./messages/execute-sql-result.message";
-let db;
+import { SqliteClientTypeEnum } from "./enums/sqlite-client-type.enum";
 const log = (...args) => console.log(...args);
 const error = (...args) => console.error(...args);
-self.onmessage = (messageEvent) => {
-    const sqliteMessage = messageEvent.data;
-    switch (sqliteMessage.type) {
-        case SqliteMessageTypeEnum.CreateDatabase:
-            sqlite3InitModule({
-                print: log,
-                printErr: error,
-            }).then((sqlite3) => {
-                const createDatabaseMessage = sqliteMessage;
-                const uniqueId = createDatabaseMessage.uniqueId;
-                try {
-                    db = new sqlite3.oo1.OpfsDb(createDatabaseMessage.filename, createDatabaseMessage.flags);
-                    self.postMessage(new CreateDatabaseResultMessage(uniqueId));
-                }
-                catch (err) {
-                    error(err.name, err.message);
-                    self.postMessage(new CreateDatabaseResultMessage(uniqueId, err));
-                }
-            });
-            break;
-        case SqliteMessageTypeEnum.ExecuteSql:
-            const executeSqlMessage = sqliteMessage;
+class SqliteClientWorker {
+    constructor() {
+    }
+    onMessageReceivedFromMainThread(messageEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sqliteMessage = messageEvent.data;
+            switch (sqliteMessage.type) {
+                case SqliteMessageTypeEnum.CreateDatabase:
+                    yield this.createDatabase(sqliteMessage);
+                    break;
+                case SqliteMessageTypeEnum.ExecuteSql:
+                    this.executeSql(sqliteMessage);
+                    break;
+            }
+        });
+    }
+    postBackMessageToMainThread(message) {
+        self.postMessage(message);
+    }
+    createDatabase(createDatabaseMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uniqueId = createDatabaseMessage.uniqueId;
             try {
-                const result = db.exec({
-                    sql: executeSqlMessage.sqlStatement,
-                    bind: executeSqlMessage.bindingParameters,
-                    returnValue: "resultRows",
-                    rowMode: 'array',
+                const sqlite3 = yield sqlite3InitModule({
+                    print: log,
+                    printErr: error,
                 });
-                self.postMessage(new ExecuteSqlResultMessage(executeSqlMessage.uniqueId, result));
+                switch (createDatabaseMessage.options.type) {
+                    case SqliteClientTypeEnum.MemoryMainThread:
+                        this.postBackMessageToMainThread(new CreateDatabaseResultMessage(createDatabaseMessage.uniqueId, new Error(`The Sqlite-Client-Worker does not support the [${SqliteClientTypeEnum.MemoryMainThread}] types. This type can be used directly in the main thread.`)));
+                        break;
+                    case SqliteClientTypeEnum.MemoryWorker:
+                        try {
+                            const options = createDatabaseMessage.options;
+                            this.db = new sqlite3.oo1.DB(options.filename, options.flags);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId));
+                        }
+                        catch (err) {
+                            error(err.name, err.message);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId, err));
+                        }
+                        break;
+                    case SqliteClientTypeEnum.OpfsWorker:
+                        try {
+                            const options = createDatabaseMessage.options;
+                            this.db = new sqlite3.oo1.OpfsDb(options.filename, options.flags);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId));
+                        }
+                        catch (err) {
+                            error(err.name, err.message);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId, err));
+                        }
+                        break;
+                    case SqliteClientTypeEnum.OpfsSahWorker:
+                        try {
+                            const options = createDatabaseMessage.options;
+                            const poolUtil = yield sqlite3.installOpfsSAHPoolVfs({
+                                name: createDatabaseMessage.options.name,
+                                directory: createDatabaseMessage.options.directory,
+                                clearOnInit: createDatabaseMessage.options.clearOnInit,
+                            });
+                            this.db = new poolUtil.OpfsSAHPoolDb(createDatabaseMessage.options.filename);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId));
+                        }
+                        catch (err) {
+                            error(err.name, err.message);
+                            this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId, err));
+                        }
+                        break;
+                }
             }
-            catch (e) {
-                self.postMessage(new ExecuteSqlResultMessage(executeSqlMessage.uniqueId, [], e));
+            catch (err) {
+                error(err.name, err.message);
+                this.postBackMessageToMainThread(new CreateDatabaseResultMessage(uniqueId, err));
             }
-            break;
+        });
     }
-};
+    executeSql(executeSqlMessage) {
+        if (!this.db) {
+            this.postBackMessageToMainThread(new ExecuteSqlResultMessage(executeSqlMessage.uniqueId, [], new Error("The database has not been created yet. Send a CreateDatabaseMessage first.")));
+            return;
+        }
+        try {
+            const result = this.db.exec({
+                sql: executeSqlMessage.sqlStatement,
+                bind: executeSqlMessage.bindingParameters,
+                returnValue: executeSqlMessage.returnValue,
+                rowMode: executeSqlMessage.rowMode,
+            });
+            this.postBackMessageToMainThread(new ExecuteSqlResultMessage(executeSqlMessage.uniqueId, result));
+        }
+        catch (e) {
+            this.postBackMessageToMainThread(new ExecuteSqlResultMessage(executeSqlMessage.uniqueId, [], e));
+        }
+    }
+}
+const sqliteClientWorker = new SqliteClientWorker();
+self.onmessage = (messageEvent) => __awaiter(void 0, void 0, void 0, function* () {
+    yield sqliteClientWorker.onMessageReceivedFromMainThread(messageEvent);
+});
 //# sourceMappingURL=sqlite-client-worker.js.map

dist/esm/sqlite-client.d.ts

@@ -0,11 +1,11 @@
+import { SqliteClientOptions } from "./types/sqlite-client.options";
+import { SqliteAdapterInterface } from "./interfaces/sqlite-adapter.interface";
+import { ReturnValueEnum } from "./enums/return-value.enum";
+import { RowModeEnum } from "./enums/row-mode.enum";
 export declare class SqliteClient {
-    private readonly filename;
-    private readonly flags;
-    private sqliteWorkerPath;
-    private queuedPromises;
-    private worker;
-    constructor(filename: string, flags: string, sqliteWorkerPath: string);
+    private readonly options;
+    readonly adapter: SqliteAdapterInterface;
+    constructor(options: SqliteClientOptions);
     init(): Promise<any>;
-    private messageReceived;
-    executeSql(sqlStatement: string, bindParameters?: (string | number)[]): Promise<any>;
+    executeSql(sqlStatement: string, bindParameters: (string | number)[], returnValue: ReturnValueEnum, rowMode: RowModeEnum | number): Promise<any>;
 }

dist/esm/sqlite-client.js

@@ -1,54 +0,40 @@
-import { ExecuteSqlMessage } from "./messages/execute-sql.message";
-import { CreateDatabaseMessage } from "./messages/create-database.message";
-import { SqliteMessageTypeEnum } from "./enums/sqlite-message-type.enum";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SqliteClientTypeEnum } from "./enums/sqlite-client-type.enum";
+import { InMainThreadSqliteAdapter } from "./adapters/in-main-thread.sqlite-adapter";
+import { InWorkerSqliteAdapter } from "./adapters/in-worker.sqlite-adapter";
 export class SqliteClient {
-    constructor(filename, flags, sqliteWorkerPath) {
-        this.filename = filename;
-        this.flags = flags;
-        this.sqliteWorkerPath = sqliteWorkerPath;
-        this.queuedPromises = {};
+    constructor(options) {
+        this.options = options;
+        switch (this.options.type) {
+            case SqliteClientTypeEnum.MemoryMainThread:
+                this.adapter = new InMainThreadSqliteAdapter(this.options);
+                break;
+            case SqliteClientTypeEnum.MemoryWorker:
+            case SqliteClientTypeEnum.OpfsWorker:
+            case SqliteClientTypeEnum.OpfsSahWorker:
+                this.adapter = new InWorkerSqliteAdapter(this.options);
+                break;
+            default:
+                throw new Error(`Unknown sqlite client type for options: '${this.options}.`);
+        }
     }
     init() {
-        this.worker = new Worker(this.sqliteWorkerPath, {
-            type: "module",
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.adapter.init();
         });
-        this.worker.onmessage = this.messageReceived.bind(this);
-        const createDatabaseMessage = new CreateDatabaseMessage(this.filename, this.flags);
-        this.worker.postMessage(createDatabaseMessage);
-        return new Promise((resolve, reject) => {
-            this.queuedPromises[createDatabaseMessage.uniqueId] = {
-                resolve,
-                reject,
-            };
-        });
     }
-    messageReceived(message) {
-        const sqliteMessage = message.data;
-        if (sqliteMessage.uniqueId !== undefined && this.queuedPromises.hasOwnProperty(sqliteMessage.uniqueId)) {
-            const promise = this.queuedPromises[sqliteMessage.uniqueId];
-            delete this.queuedPromises[sqliteMessage.uniqueId];
-            switch (sqliteMessage.type) {
-                case SqliteMessageTypeEnum.ExecuteSqlResult:
-                    const executeSqlResultMessage = sqliteMessage;
-                    if (executeSqlResultMessage.error) {
-                        return promise.reject(executeSqlResultMessage.error);
-                    }
-                    return promise.resolve(executeSqlResultMessage.result);
-                case SqliteMessageTypeEnum.CreateDatabaseResult:
-                    const createDatabaseResultMessage = sqliteMessage;
-                    if (createDatabaseResultMessage.error) {
-                        return promise.reject(createDatabaseResultMessage.error);
-                    }
-                    return promise.resolve();
+    executeSql(sqlStatement, bindParameters, returnValue, rowMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.adapter === undefined) {
+                throw new Error("You need to call `init` before calling `executeSql`.");
             }
-        }
-    }
-    executeSql(sqlStatement, bindParameters = []) {
-        const executeSqlMessage = new ExecuteSqlMessage(sqlStatement, bindParameters);
-        this.worker.postMessage(executeSqlMessage);
-        return new Promise((resolve, reject) => {
-            this.queuedPromises[executeSqlMessage.uniqueId] = {
-                resolve,
-                reject,
-            };
+            return this.adapter.executeSql(sqlStatement, bindParameters, returnValue, rowMode);
         });
@@ -55,0 +41,0 @@ }

package.json

 {
   "name": "@magieno/sqlite-client",
-  "version": "3.43.2",
+  "version": "3.45.1-test1",
   "description": "SQLite Client is a wrapper for Sqlite on Wasm that uses the Origin Private File System to persist the sqlite database file.",
@@ -42,3 +42,3 @@ "keywords": [
   "dependencies": {
-    "@sqlite.org/sqlite-wasm": "^3.43.2-build1"
+    "@sqlite.org/sqlite-wasm": "^3.45.1-build1"
   },
@@ -45,0 +45,0 @@ "devDependencies": {

README.md

@@ -25,6 +25,9 @@ # SQLite Client
 
-const sqliteClientWorkerPath = "assets/js/sqlite-client-worker.js"; // Must correspond to the path in your final deployed build.
+const sqliteWorkerPath = "assets/js/sqlite-client-worker.js"; // Must correspond to the path in your final deployed build.
 const filename = "/test.sqlite3"; // This is the name of your database. It corresponds to the path in the OPFS.
 
-const sqliteClient = new SqliteClient(filename, sqliteClientWorkerPath)
+const sqliteClient = new SqliteClient({
+    filename,
+    sqliteWorkerPath,
+})
 await sqliteClient.init();
@@ -31,0 +34,0 @@

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1002010

increased by102.51%

Number of package files

65

increased by103.13%

Lines of code

27223

increased by104.9%

Number of lines in readme file

54

increased by5.88%

Worsened metrics

Number of low quality alerts

1

increased byInfinity%

Number of low supply chain risk alerts

2

increased by100%

Number of medium supply chain risk alerts

12

increased by100%

Dependency changes

• + [e-mail]/sqlite-wasm@3.45.1-build1(transitive)

• - [e-mail]/sqlite-wasm@3.43.2-prebuild1(transitive)

• - Removedcomlink@4.4.2(transitive)

• [e-mail]/sqlite-wasm@^3.45.1-build1