@social-mail/social-mail-client 1.2.490 → 1.2.492

package/src/services/local-db/core/SqlDbFactory.ts

@@ -0,0 +1,173 @@
+/* eslint-disable no-cond-assign */
+/* eslint-disable no-var */
+import { UMD } from "@web-atoms/core/dist/core/types";
+
+export type ISqlString = any;
+export type IPreparedStatement = any;
+
+export interface ISqlFactory {
+    open_v2(name: string): Promise<any>;
+    close(db: any): Promise<void>;
+    exec(db: any, text: string, fx: (rows:any[], columns: string[]) => void): Promise<number>;
+    prepare_v2(db: any, sql: ISqlString): Promise<{ sql: number, stmt: number }>;
+    statements(db: any, text: string, options?: any): any;
+    bind(stmt: number, i: number, value: any );
+    finalize(stmt: number): Promise<number>;
+    step(stmt: number): Promise<number>;
+    row(stmt: number): string[];
+    column_names(stmt: number): string[];
+    bind_parameter_count(stmt: number): number;
+    bind_parameter_name(stmt: number, i: number): string;
+    changes(stmt: number): number;
+}
+
+export interface ISqlResult<T = any> {
+    rows: T[];
+    updated: number;
+}
+
+declare var SQLite: any;
+
+export class SqlDb {
+
+    private prev: Promise<ISqlResult> = Promise.resolve(null);
+
+    private db: any;
+
+    constructor(
+        private sqlFactory: ISqlFactory,
+        private name: string) {}
+
+    async query(query, values) {
+        const prev = this.prev;
+        const { sqlFactory } = this;
+        return await (this.prev = (async () => {
+            try {
+                await prev;
+            } catch (error) {
+                // ignore...
+            }
+            const d = await sqlFactory.open_v2(this.name);
+            this.db = d;
+            await using d1 = { [Symbol.asyncDispose]: () => sqlFactory.close(d) };
+            const rows = [];
+
+            let updated = 0;
+
+            for await (const stmt of sqlFactory.statements(d, query)) {
+                let i = 0;
+                let columns;
+                for (const p of values) {
+                    sqlFactory.bind(stmt, ++i, p);
+                }
+                while(await sqlFactory.step(stmt) === SQLite.SQLITE_ROW) {
+                    columns ??= sqlFactory.column_names(stmt);
+                    const row = sqlFactory.row(stmt);
+                    const item = {};
+                    for (let index = 0; index < columns.length; index++) {
+                        const element = columns[index];
+                        item[element] = row[index];
+                    }
+                    rows.push(item);
+                }
+                updated = sqlFactory.changes(this.db);
+            }
+
+            // const updated = await sqlFactory.exec(d, query, (row, columns) => {
+            //     const item = {};
+            //     for (let index = 0; index < columns.length; index++) {
+            //         const element = columns[index];
+            //         item[element] = row[index];
+            //     }
+            //     rows.push(item);
+            // });
+
+            return {
+                rows,
+                updated
+            };
+        })());
+    }
+
+    // async exec(query: string) {
+    //     const { sqlFactory } = this;
+    //     const db = await sqlFactory.open_v2(this.name);
+    //     await using a = { [Symbol.asyncDispose]: () => sqlFactory.close(db)};
+    //     const rows = [];
+    //     const updated = 0;
+    //     await sqlFactory.exec(db, query, (items, columns) => {
+    //         const row = {};
+    //         for (let index = 0; index < columns.length; index++) {
+    //             const element = columns[index];
+    //             row[element] = items[index];
+    //         }
+    //         rows.push(row);
+    //     });
+    //     return {
+    //         rows,
+    //         updated
+    //     };
+    // }
+
+    // private async * prepare({query, values}:{ query: string, values: any}) {
+    //     const { sqlFactory } = this;
+    //     let prepared = { stmt: null, sql: query } as any;
+    //     try {
+    //         while(prepared = await sqlFactory.prepare_v2(this.db, prepared.sql)){
+
+    //             // bind parameters...
+    //             const { stmt } = prepared;
+    //             // bind parameters...
+    //             const total = sqlFactory.bind_parameter_count(stmt);
+    //             for (let index = 0; index < total; index++) {
+    //                 const name = sqlFactory.bind_parameter_name(stmt, index);
+    //                 if (values.hasOwnProperty(name)) {
+    //                     sqlFactory.bind(stmt, index, values[name]);
+    //                 }
+    //             }
+    //             yield stmt;
+    //             await sqlFactory.finalize(stmt);
+    //             prepared.stmt = null;
+    //         }
+    //     } finally {
+    //         if (prepared?.stmt) {
+    //             await sqlFactory.finalize(prepared.stmt);
+    //         }
+    //     }
+    // }
+
+    // private newString(txt: string) {
+    //     const { sqlFactory } = this;
+    //     const str = sqlFactory.str_new(this.db, txt);
+    //     return {
+    //         str,
+    //         [Symbol.dispose]() {
+    //             return sqlFactory.str_finish(str);
+    //         }
+    //     };
+    // }
+}
+
+let factory: Promise<ISqlFactory>;
+
+const loadSqlFactory = () => {
+    return factory ??= new Promise<ISqlFactory>((resolve, reject) => {
+        const script = document.createElement("script");
+        script.type = "module";
+        script.src = UMD.resolvePath("@social-mail/social-mail-client/sqlite-loader.mjs");
+        script.onerror = reject;
+        document.body.addEventListener("sqliteLoaded", (ce: CustomEvent) => {
+            resolve(ce.detail);
+        }, { once: true });
+        document.body.appendChild(script);
+    });
+};
+
+export default class SqlDbFactory {
+
+    static async load(name: string) {
+        const sqlFactory = await loadSqlFactory();
+        return new SqlDb(sqlFactory, name);
+    }
+
+}

package/src/services/local-db/core/TemplateQuery.ts

@@ -88,10 +88,15 @@ export default class TemplateQuery {
                 text += literal;
                 continue;
             }
-            const av = arg ?? null;
-            if (av === null) {
-                text += " NULL ";
-                continue;
+            let av = arg ?? null;
+            // if (av === null) {
+            //     text += " NULL ";
+            //     continue;
+            // }
+            if (typeof av === "boolean") {
+                av = av ? 1 : 0;
+            } else if (av instanceof Date) {
+                av = av.getTime();
             }
             let an = map.get(av);
             if (an === void 0) {
@@ -115,7 +120,7 @@ export default class TemplateQuery {
             return null;
         }
         if (av instanceof Date) {
-            return av.toJSON();
+            return av.getTime();
         }
         switch(typeof av) {
             case "boolean":

package/src/services/local-db/mailboxes/LocalMailbox.ts

@@ -9,43 +9,6 @@ export default class LocalMailbox extends LocalTable<IMailbox> {
 
     model = Mailbox;
 
-    public async startSync() {
-
-        const es = this.service.entityService;
-
-        let q = es.query(this.model);
-
-        let max = null;
-
-        // get last max updated...
-        const { rows:[first] } = await this.query `SELECT * FROM ${this.name} ORDER BY dateUpdated DESC LIMIT 1`;
-        if (first) {
-            max = first.dateUpdated;
-            q = q.where({ max}, (p) => (x) => x.dateUpdated >= p.max);
-        }
-
-        let min = DateTime.now;
-
-        do {
-            const result = await q.where({ min }, (p) => (x) => x.dateUpdated < p.min)
-                .orderByDescending((x) => x.dateUpdated)
-                .toPagedList({
-                    start: 0,
-                    size: 200,
-                    count: false
-                });
-
-            if (!result.items.length) {
-                break;
-            }
-
-            for (const element of result.items) {
-                await this.save(element);
-                min = element.dateUpdated;
-            }
-        } while(true);
-    }
-
     // public async init() {
     //     await this.service.query `CREATE TABLE IF NOT EXISTS ${this.name}
     //     (