core-3nweb-client-lib 0.28.4 → 0.29.1

package/build/lib-sqlite-on-3nstorage/deferred.d.ts

@@ -0,0 +1,6 @@
+export interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (result?: T | PromiseLike<T>) => void;
+    reject: (err: any) => void;
+}
+export declare function defer<T>(): Deferred<T>;

package/build/lib-sqlite-on-3nstorage/deferred.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ Copyright (C) 2015, 2017, 2019 - 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defer = void 0;
+function defer() {
+    const d = {};
+    d.promise = new Promise((resolve, reject) => {
+        d.resolve = resolve;
+        d.reject = reject;
+    });
+    Object.freeze(d);
+    return d;
+}
+exports.defer = defer;

package/build/lib-sqlite-on-3nstorage/index.d.ts

@@ -1,32 +1,49 @@
-import { Action, SingleProc } from '../lib-common/processes/synced';
-import { Database as DBClass, BindParams as QueryParams, QueryExecResult as QueryResult } from './sqljs';
+import { Database as DBClass, BindParams as QueryParams, QueryExecResult as QueryResult } from './sqljs.js';
+import { SingleProc, Action } from './synced.js';
 export declare type Database = DBClass;
 export declare type BindParams = QueryParams;
 export declare type QueryExecResult = QueryResult;
 declare type WritableFile = web3n.files.WritableFile;
-declare type ReadonlyFile = web3n.files.ReadonlyFile;
+export interface SaveOpts {
+    skipUpload?: boolean;
+}
 export declare abstract class SQLiteOn3NStorage {
     protected readonly database: Database;
     protected readonly file: WritableFile;
     protected readonly syncProc: SingleProc;
     protected constructor(database: Database, file: WritableFile);
+    static makeAndStart(file: WritableFile): Promise<SQLiteOn3NStorage>;
+    private start;
+    saveToFile(opts?: SaveOpts): Promise<void>;
     get db(): Database;
-    get dbFile(): WritableFile;
     sync<T>(action: Action<T>): Promise<T>;
     listTables(): string[];
 }
-export declare class SQLiteOnUnversionedFS extends SQLiteOn3NStorage {
-    static makeAndStart(file: WritableFile): Promise<SQLiteOnUnversionedFS>;
-    saveToFile(): Promise<void>;
-}
-export declare class SQLiteOnVersionedFS extends SQLiteOn3NStorage {
-    protected constructor(db: Database, file: WritableFile);
-    static makeAndStart(file: WritableFile): Promise<SQLiteOnVersionedFS>;
-    saveToFile(): Promise<number>;
-}
-export declare class SQLiteOnSyncedFS extends SQLiteOnVersionedFS {
-    protected constructor(db: Database, file: WritableFile);
-    static makeAndStart(file: WritableFile): Promise<SQLiteOnSyncedFS>;
+export declare function objectFromQueryExecResult<T>(sqlResult: QueryExecResult): Array<T>;
+declare type KeyedInfo<T> = {
+    [columnName in keyof T]: string;
+};
+export declare class TableColumnsAndParams<EntryType extends object> {
+    readonly name: string;
+    private readonly columnDefs;
+    readonly c: KeyedInfo<EntryType>;
+    readonly cReversed: {
+        [colName: string]: keyof EntryType;
+    };
+    readonly p: KeyedInfo<EntryType>;
+    readonly q: KeyedInfo<EntryType>;
+    readonly columnsCreateSection: string;
+    constructor(name: string, columnDefs: {
+        [columnName in keyof EntryType]: [string, string];
+    });
+    private toC;
+    toParams<T extends {
+        [field in keyof EntryType]: any;
+    }>(value: Partial<T>, addNullsForMissingFields?: boolean): any;
+    fromQueryExecResult<T>(sqlResult: QueryExecResult[]): Array<T>;
+    get insertQuery(): string;
+    updateQuery(withTabName: boolean, fields?: (keyof EntryType)[] | undefined, skipColumns?: boolean): string;
+    colsEqualSection(...fields: (keyof EntryType)[]): string;
+    colsSection(...fields: (keyof EntryType)[]): string;
 }
-export declare function readDbFrom(file: ReadonlyFile): Promise<Database>;
 export {};

package/build/lib-sqlite-on-3nstorage/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2022 3NSoft Inc.
+ Copyright (C) 2022 - 2023 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -16,21 +16,45 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readDbFrom = exports.SQLiteOnSyncedFS = exports.SQLiteOnVersionedFS = exports.SQLiteOnUnversionedFS = exports.SQLiteOn3NStorage = void 0;
-const synced_1 = require("../lib-common/processes/synced");
-const sqljs_1 = require("./sqljs");
+exports.TableColumnsAndParams = exports.objectFromQueryExecResult = exports.SQLiteOn3NStorage = void 0;
+const sqljs_js_1 = require("./sqljs.js");
+const synced_js_1 = require("./synced.js");
 class SQLiteOn3NStorage {
     constructor(database, file) {
         this.database = database;
         this.file = file;
-        this.syncProc = new synced_1.SingleProc();
+        this.syncProc = new synced_js_1.SingleProc();
+    }
+    static async makeAndStart(file) {
+        var _a;
+        const SQL = await (0, sqljs_js_1.default)(true);
+        const fileContent = await readFileContent(file);
+        const db = new SQL.Database(fileContent);
+        let sqlite;
+        if ((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync) {
+            sqlite = new SQLiteOnSyncedFS(db, file);
+        }
+        else if (file.v) {
+            sqlite = new SQLiteOnLocalFS(db, file);
+        }
+        else {
+            sqlite = new SQLiteOnDeviceFS(db, file);
+        }
+        await sqlite.start();
+        return sqlite;
+    }
+    async start() {
+        // XXX add listening process(es)
+    }
+    async saveToFile(opts) {
+        await this.syncProc.startOrChain(async () => {
+            const dbFileContent = this.database.export();
+            await this.file.writeBytes(dbFileContent);
+        });
     }
     get db() {
         return this.database;
     }
-    get dbFile() {
-        return this.file;
-    }
     sync(action) {
         return this.syncProc.startOrChain(action);
     }
@@ -44,64 +68,39 @@ class SQLiteOn3NStorage {
 exports.SQLiteOn3NStorage = SQLiteOn3NStorage;
 Object.freeze(SQLiteOn3NStorage.prototype);
 Object.freeze(SQLiteOn3NStorage);
-class SQLiteOnUnversionedFS extends SQLiteOn3NStorage {
-    static async makeAndStart(file) {
-        const db = await readDbFrom(file);
-        return new SQLiteOnUnversionedFS(db, file);
+class SQLiteOnSyncedFS extends SQLiteOn3NStorage {
+    constructor(db, file) {
+        super(db, file);
+        Object.seal(this);
     }
-    async saveToFile() {
-        await this.syncProc.startOrChain(async () => {
-            const dbFileContent = this.database.export();
-            await this.file.writeBytes(dbFileContent);
-        });
+    async saveToFile(opts) {
+        await super.saveToFile();
+        if (opts === null || opts === void 0 ? void 0 : opts.skipUpload) {
+            return;
+        }
+        else {
+            await this.file.v.sync.upload();
+        }
     }
 }
-exports.SQLiteOnUnversionedFS = SQLiteOnUnversionedFS;
-Object.freeze(SQLiteOnUnversionedFS.prototype);
-Object.freeze(SQLiteOnUnversionedFS);
-class SQLiteOnVersionedFS extends SQLiteOn3NStorage {
+Object.freeze(SQLiteOnSyncedFS.prototype);
+Object.freeze(SQLiteOnSyncedFS);
+class SQLiteOnLocalFS extends SQLiteOn3NStorage {
     constructor(db, file) {
         super(db, file);
-        if (!file.v) {
-            throw new Error(`Given file is not versioned`);
-        }
-    }
-    static async makeAndStart(file) {
-        const db = await readDbFrom(file);
-        return new SQLiteOnVersionedFS(db, file);
-    }
-    async saveToFile() {
-        return await this.syncProc.startOrChain(async () => {
-            const dbFileContent = this.database.export();
-            return await this.file.v.writeBytes(dbFileContent);
-        });
+        Object.seal(this);
     }
 }
-exports.SQLiteOnVersionedFS = SQLiteOnVersionedFS;
-Object.freeze(SQLiteOnVersionedFS.prototype);
-Object.freeze(SQLiteOnVersionedFS);
-class SQLiteOnSyncedFS extends SQLiteOnVersionedFS {
+Object.freeze(SQLiteOnLocalFS.prototype);
+Object.freeze(SQLiteOnLocalFS);
+class SQLiteOnDeviceFS extends SQLiteOn3NStorage {
     constructor(db, file) {
-        var _a;
         super(db, file);
-        if (!((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync)) {
-            throw new Error(`Given file is not synced`);
-        }
-    }
-    static async makeAndStart(file) {
-        const db = await readDbFrom(file);
-        return new SQLiteOnSyncedFS(db, file);
+        Object.seal(this);
     }
 }
-exports.SQLiteOnSyncedFS = SQLiteOnSyncedFS;
-Object.freeze(SQLiteOnSyncedFS.prototype);
-Object.freeze(SQLiteOnSyncedFS);
-async function readDbFrom(file) {
-    const SQL = await (0, sqljs_1.default)(true);
-    const fileContent = await readFileContent(file);
-    return new SQL.Database(fileContent);
-}
-exports.readDbFrom = readDbFrom;
+Object.freeze(SQLiteOnDeviceFS.prototype);
+Object.freeze(SQLiteOnDeviceFS);
 async function readFileContent(file) {
     try {
         return await file.readBytes();
@@ -115,3 +114,107 @@ async function readFileContent(file) {
         }
     }
 }
+function objectFromQueryExecResult(sqlResult) {
+    const { columns, values: rows } = sqlResult;
+    return rows.map(row => row.reduce((obj, cellValue, index) => {
+        const field = columns[index];
+        obj[field] = cellValue;
+        return obj;
+    }, {}));
+}
+exports.objectFromQueryExecResult = objectFromQueryExecResult;
+class TableColumnsAndParams {
+    constructor(name, columnDefs) {
+        this.name = name;
+        this.columnDefs = columnDefs;
+        this.columnsCreateSection = Object.values(columnDefs)
+            .map(([colName, colCreate]) => `${colName} ${colCreate}`)
+            .join(`,\n`);
+        this.c = {};
+        this.cReversed = {};
+        this.p = {};
+        this.q = {};
+        for (const [field, [colName]] of Object.entries(this.columnDefs)) {
+            this.c[field] = colName;
+            this.cReversed[colName] = field;
+            this.p[field] = `$${field}`;
+            this.q[field] = `${this.name}.${colName}`;
+        }
+        Object.freeze(this.c);
+        Object.freeze(this.p);
+        Object.freeze(this.q);
+        Object.freeze(this.name);
+        Object.freeze(this.columnsCreateSection);
+    }
+    toC(field) {
+        const colName = this.c[field];
+        if (colName === undefined) {
+            throw new Error(`Column for ${field} is not found among columns of table ${this.name}`);
+        }
+        return colName;
+    }
+    toParams(value, addNullsForMissingFields = false) {
+        const params = {};
+        for (const [field, columnValue] of Object.entries(value)) {
+            this.toC(field); // does implicit check for column existence
+            params[this.p[field]] = columnValue;
+        }
+        if (addNullsForMissingFields) {
+            for (const paramName of Object.values(this.p)) {
+                if (params[paramName] === undefined) {
+                    params[paramName] = null;
+                }
+            }
+        }
+        return params;
+    }
+    fromQueryExecResult(sqlResult) {
+        if (sqlResult.length === 0) {
+            return [];
+        }
+        if (sqlResult.length > 1) {
+            throw new Error(`This method will not process result of many queries`);
+        }
+        const { columns, values: rows } = sqlResult[0];
+        return rows.map(row => row.reduce((obj, cellValue, index) => {
+            const tabColumn = columns[index];
+            let field = this.cReversed[tabColumn];
+            if (field === undefined) {
+                field = tabColumn;
+            }
+            obj[field] = cellValue;
+            return obj;
+        }, {}));
+    }
+    get insertQuery() {
+        const colAndParamNames = Object.entries(this.p);
+        return `INSERT INTO ${this.name} (${colAndParamNames.map(([field]) => this.toC(field)).join(', ')}) VALUES (${colAndParamNames.map(([n, colParam]) => colParam).join(', ')})`;
+    }
+    updateQuery(withTabName, fields = undefined, skipColumns = false) {
+        let fieldAndParamNames = Object.entries(this.p);
+        if (fields) {
+            if (skipColumns) {
+                fieldAndParamNames = fieldAndParamNames.filter(([field]) => !fields.includes(field));
+            }
+            else {
+                fieldAndParamNames = fieldAndParamNames.filter(([field]) => fields.includes(field));
+            }
+        }
+        return `UPDATE ${withTabName ? `${this.name} ` : ''}SET ${fieldAndParamNames
+            .map(([field, pName]) => `${this.toC(field)}=${pName}`)
+            .join(', ')}`;
+    }
+    colsEqualSection(...fields) {
+        return (fields)
+            .map(n => `${this.toC(n)}=${this.p[n]}`)
+            .join(' AND ');
+    }
+    colsSection(...fields) {
+        return (fields)
+            .map(n => this.toC(n))
+            .join(', ');
+    }
+}
+exports.TableColumnsAndParams = TableColumnsAndParams;
+Object.freeze(TableColumnsAndParams.prototype);
+Object.freeze(TableColumnsAndParams);