core-3nweb-client-lib 0.49.5 → 0.49.7

package/build/lib-common/dataset-sync/per-device-json-array-logs.js

@@ -0,0 +1,432 @@
+"use strict";
+/*
+ Copyright (C) 2026 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.makeRecentChangesLogs = makeRecentChangesLogs;
+exports.startDatasetSync = startDatasetSync;
+const synced_1 = require("../processes/synced");
+const buffer_utils_1 = require("../buffer-utils");
+const rng_def_1 = require("../rng-def");
+const sink_utils_1 = require("../obj-streaming/sink-utils");
+const DEVICE_ID_FILE = 'device-id';
+const DEV_LOGS_PROCESSING_FILE = 'dev-logs-processing';
+const DEV_ID_LEN = 24;
+const LOG_EXT = '.recent-changes';
+function getOrMakeIdForThisDevice(localFS, logsFS) {
+    return localFS.readTxtFile(DEVICE_ID_FILE)
+        .catch(async (exc) => {
+        if (!exc.notFound) {
+            throw exc;
+        }
+        let devId = await (0, rng_def_1.stringOfB64UrlSafeChars)(DEV_ID_LEN, rng_def_1.pseudoRNG);
+        while (await logsFS.checkFilePresence(logsFileName(devId))) {
+            devId = await (0, rng_def_1.stringOfB64UrlSafeChars)(DEV_ID_LEN, rng_def_1.pseudoRNG);
+        }
+        await localFS.writeTxtFile(DEVICE_ID_FILE, devId);
+        return devId;
+    });
+}
+function logsFileName(devId) {
+    return `${devId}${LOG_EXT}`;
+}
+function devIdFromFileName(fName) {
+    if (fName.endsWith(LOG_EXT)) {
+        return fName.slice(0, fName.length - LOG_EXT.length);
+    }
+}
+function serializeLogs(logs) {
+    const json = JSON.stringify(logs);
+    return json.substring(1, json.length - 1);
+}
+function deserializeLogs(choppedJSON) {
+    const json = `[${choppedJSON}]`;
+    return JSON.parse(json);
+}
+/**
+ * This is a catch callback, which returns undefined on file(folder) not found
+ * exception, and re-throws all other exceptions/errors.
+ */
+function notFoundOrReThrow(exc) {
+    if (!exc.notFound) {
+        throw exc;
+    }
+    return;
+}
+async function makeRecentChangesLogs(logsFS, localLogsFS, areOpsEqual, logError) {
+    const thisDevId = await getOrMakeIdForThisDevice(localLogsFS, logsFS);
+    const { logs, thisDevLogsFile } = await (async function readOrCreateLogsFile() {
+        const thisDevLogsFile = await logsFS.writableFile(logsFileName(thisDevId), { create: false })
+            .catch(notFoundOrReThrow);
+        if (thisDevLogsFile) {
+            const logsTxt = await thisDevLogsFile.readTxt();
+            try {
+                const logs = deserializeLogs(logsTxt);
+                return { logs, thisDevLogsFile };
+            }
+            catch (err) {
+                // if there was anything wrong, by ignoring, we'll effectively overwrite file
+                await logError(err, `Fail to parse current changes from log file ${logsFS.name}/${thisDevLogsFile.name}`);
+                return { logs: [], thisDevLogsFile };
+            }
+        }
+        else {
+            const thisDevLogsFile = await logsFS.writableFile(logsFileName(thisDevId));
+            await thisDevLogsFile.writeTxt('');
+            return { logs: [], thisDevLogsFile };
+        }
+    })();
+    let numOfEntriesOnLastSave = logs.length;
+    let needToSave = false;
+    let needToUpload = (await thisDevLogsFile.v.sync.status(true)).state !== 'synced';
+    const { snapshotOpsInfoForSync, shouldProcessOp, addToRecent, addDoneOnThisDeviceRecent } = await makeLogsProcessingState(localLogsFS, thisDevId, areOpsEqual);
+    await saveAndUploadIfNeeded();
+    function watchAndApplyOpsFromOtherDevices(changeProc, sink) {
+        const stopWatching = logsFS.watchTree('.', 1, {
+            next: fsEvent => changeProc.startOrChain(async () => {
+                if (fsEvent.path.endsWith(thisDevLogsFile.name)) {
+                    return;
+                }
+                if (fsEvent.type === 'remote-change') {
+                    if (fsEvent.path === '.') {
+                        await logsFS.v.sync.adoptRemote(fsEvent.path);
+                    }
+                    else {
+                        await doOnNewRemoteVersionOfLog(fsEvent, sink);
+                    }
+                }
+                else if ((fsEvent.type === 'entry-addition') && (fsEvent.src === 'sync') && fsEvent.entry.isFile) {
+                    await doOnAppearanceOfNewDeviceLog(fsEvent.entry.name, sink);
+                }
+            })
+        });
+        changeProc.startOrChain(() => getAndProcessOpsFromOtherDevicesLogs(sink));
+        return stopWatching;
+    }
+    async function doOnAppearanceOfNewDeviceLog(logFile, sink) {
+        const devId = devIdFromFileName(logFile);
+        if (!devId) {
+            return;
+        }
+        try {
+            const content = (await logsFS.readBytes(logFile));
+            if (!content) {
+                return;
+            }
+            const appendedEvents = deserializeLogs(buffer_utils_1.utf8.open(content));
+            processFromLogFile(devId, appendedEvents, sink);
+        }
+        catch (err) {
+            if (err.type !== 'connect') {
+                logError(err);
+            }
+        }
+    }
+    function processFromLogFile(devId, ops, sink) {
+        const newOps = ops.filter(op => shouldProcessOp(devId, op));
+        if (newOps.length > 0) {
+            const recordCompletion = addToRecent(devId, newOps);
+            sink(newOps).finally(recordCompletion);
+        }
+    }
+    async function doOnNewRemoteVersionOfLog({ path, newRemoteVersion }, sink) {
+        const devId = devIdFromFileName(path);
+        if (!devId) {
+            return;
+        }
+        try {
+            const { size: initSize, version: initVersion } = await logsFS.v.stat(path);
+            if (initVersion === newRemoteVersion) {
+                return;
+            }
+            await logsFS.v.sync.adoptRemote(path);
+            const { size: newSize } = await logsFS.v.stat(path);
+            let additionalBytes;
+            if (initSize < newSize) {
+                additionalBytes = (await logsFS.readBytes(path, (initSize > 0) ? initSize + 1 : undefined));
+            }
+            else if (initSize > newSize) {
+                additionalBytes = (await logsFS.readBytes(path));
+            }
+            else {
+                return;
+            }
+            const appendedOps = deserializeLogs(buffer_utils_1.utf8.open(additionalBytes));
+            processFromLogFile(devId, appendedOps, sink);
+        }
+        catch (err) {
+            if (err.type !== 'connect') {
+                logError(err);
+            }
+        }
+    }
+    function numOfLogs() {
+        return logs.length;
+    }
+    function appendLogsAndUpload(...ops) {
+        if (ops.length > 0) {
+            const logEntries = [];
+            const ts = Date.now();
+            let n = ((logs.length === 0) ? 0 : logs[logs.length - 1].n);
+            for (let p of ops) {
+                n += 1;
+                logEntries.push({ n, ts, p });
+            }
+            logs.push(...logEntries);
+            addDoneOnThisDeviceRecent(logEntries);
+            needToSave = true;
+            return saveAndUploadIfNeeded();
+        }
+    }
+    function cutLogOnDatasetSyncAndUpload(syncPointV, params) {
+        if (logs.length === 0) {
+            return;
+        }
+        const lastN = logs[logs.length - 1].n;
+        logs.splice(0, logs.length, {
+            n: lastN + 1,
+            ts: Date.now(),
+            syncPoint: {
+                v: syncPointV,
+                logSyncedPoints: snapshotOpsInfoForSync(lastN),
+                params
+            }
+        });
+        needToSave = true;
+        return saveAndUploadIfNeeded();
+    }
+    async function saveAndUploadIfNeeded() {
+        if (needToSave && (logs.length > numOfEntriesOnLastSave)) {
+            needToSave = false;
+            if (numOfEntriesOnLastSave > 0) {
+                const logsToAppend = logs.slice(numOfEntriesOnLastSave);
+                const logsTxt = serializeLogs(logsToAppend);
+                const sink = await thisDevLogsFile.getByteSink(false);
+                try {
+                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(','), false);
+                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(logsTxt), true);
+                }
+                catch (err) {
+                    await sink.done(err);
+                }
+                numOfEntriesOnLastSave += logsToAppend.length;
+            }
+            else {
+                const logsTxt = serializeLogs(logs);
+                const numOfLogs = logs.length;
+                await thisDevLogsFile.writeTxt(logsTxt)
+                    .catch(_exc => {
+                    needToSave = true;
+                });
+                numOfEntriesOnLastSave += numOfLogs;
+            }
+            needToUpload = true;
+        }
+        if (needToUpload) {
+            needToUpload = false;
+            await thisDevLogsFile.v.sync.upload()
+                .catch(_exc => {
+                needToUpload = true;
+            });
+            const { existsInSyncedParent } = await thisDevLogsFile.v.sync.status(true);
+            if (!existsInSyncedParent) {
+                await syncLogsFS().catch((exc) => {
+                    if (exc.type !== 'connect') {
+                        logError(exc, `Fail to sync folder with messages index logs`);
+                    }
+                });
+            }
+        }
+    }
+    async function getAndProcessOpsFromOtherDevicesLogs(sink) {
+        // XXX current code assumes that dataset was brought up from synced point, if any, or has always existed
+        try {
+            await syncLogsFS();
+        }
+        catch (err) {
+            if (err.type === 'connect') {
+                return;
+            }
+            else {
+                logError(err);
+            }
+        }
+        const otherDevs = (await logsFS.listFolder(''))
+            .map(({ name }) => devIdFromFileName(name))
+            .filter(devId => !!devId && (devId !== thisDevId));
+        const opsFromAllDevices = [];
+        const recordCompletions = [];
+        for (const devId of otherDevs) {
+            try {
+                const logContent = await logsFS.readTxtFile(logsFileName(devId));
+                const devOps = deserializeLogs(logContent);
+                const newOps = devOps.filter(op => shouldProcessOp(devId, op));
+                if (newOps.length > 0) {
+                    opsFromAllDevices.push(...newOps);
+                    recordCompletions.push(addToRecent(devId, newOps));
+                }
+            }
+            catch (err) {
+                logError(err);
+            }
+        }
+        if (opsFromAllDevices.length > 0) {
+            opsFromAllDevices.sort((a, b) => (a.ts - b.ts));
+            sink(opsFromAllDevices).finally(() => Promise.all(recordCompletions.map(c => c())));
+        }
+    }
+    async function syncLogsFS() {
+        const { state } = await logsFS.v.sync.status('');
+        if (state === 'behind') {
+            await logsFS.v.sync.absorbRemoteFolderChanges('');
+        }
+        else if (state === 'conflicting') {
+            await logsFS.v.sync.absorbRemoteFolderChanges('');
+            await logsFS.v.sync.upload('');
+        }
+        else if (state === 'unsynced') {
+            await logsFS.v.sync.upload('');
+        }
+    }
+    return {
+        appendLogsAndUpload,
+        watchAndApplyOpsFromOtherDevices,
+        numOfLogs,
+        cutLogOnDatasetSyncAndUpload
+    };
+}
+async function makeLogsProcessingState(localLogsFS, thisDevId, areOpsEqual, maxRecentLen = 50) {
+    const procStateFile = await localLogsFS.writableFile(DEV_LOGS_PROCESSING_FILE);
+    const pState = (procStateFile.isNew ?
+        { logProcessedPoints: {} } : await procStateFile.readJSON());
+    const pStateSavingProc = new synced_1.SingleProc();
+    let needsSaving = false;
+    async function savePState() {
+        needsSaving = true;
+        pStateSavingProc.startOrChain(async () => {
+            if (needsSaving) {
+                needsSaving = false;
+                await procStateFile.writeJSON(pState);
+            }
+        });
+    }
+    async function recordOpAsProcessed(devId, opN) {
+        let lastProcessed = pState.logProcessedPoints[devId];
+        if (lastProcessed === undefined) {
+            pState.logProcessedPoints[devId] = opN;
+        }
+        else if (lastProcessed >= opN) {
+            return;
+        }
+        else {
+            pState.logProcessedPoints[devId] = opN;
+        }
+        await savePState();
+        if (recentOps.length > maxRecentLen) {
+            recentOps.splice(0, recentOps.length - maxRecentLen);
+        }
+    }
+    function snapshotOpsInfoForSync(lastN) {
+        const info = {};
+        for (const [devId, opN] of Object.entries(pState.logProcessedPoints)) {
+            info[devId] = opN;
+        }
+        info[thisDevId] = lastN;
+        return info;
+    }
+    function hasOpBeenProcessed(devId, opN) {
+        const lastProcessed = pState.logProcessedPoints[devId];
+        return ((lastProcessed === undefined) ? false : (lastProcessed >= opN));
+    }
+    // XXX should switch to keeping log entry and devId to trim recents when they get applied
+    //     should trim be done within recordOpAsProcessed() ?
+    //     And may be we should keep recent by ts, so as not to drop too recent, when there is a lot of them.
+    const recentOps = [];
+    const recentSyncPoint = undefined;
+    function shouldProcessOp(devId, op) {
+        if (hasOpBeenProcessed(devId, op.n)) {
+            return false;
+        }
+        if (op.p === undefined) {
+            if (op.syncPoint) {
+                if (pState.lastSyncV >= op.syncPoint.v) {
+                    return false;
+                }
+                else {
+                    return (!recentSyncPoint || (recentSyncPoint.v < op.syncPoint.v));
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return !recentOps.find(ev => areOpsEqual(ev, op.p));
+        }
+    }
+    function addToRecent(devId, newOps) {
+        newOps.sort((a, b) => (a.n - b.n));
+        const lastOpN = newOps[newOps.length - 1].n;
+        const payloads = newOps.map(({ p }) => p).filter(p => (p !== undefined));
+        if (payloads.length > 0) {
+            recentOps.splice(recentOps.length, 0, ...payloads);
+        }
+        return () => recordOpAsProcessed(devId, lastOpN);
+    }
+    function addDoneOnThisDeviceRecent(done) {
+        const payloads = done.map(({ p }) => p).filter(p => (p !== undefined));
+        recentOps.splice(0, 0, ...payloads);
+    }
+    return {
+        snapshotOpsInfoForSync,
+        shouldProcessOp,
+        addToRecent,
+        addDoneOnThisDeviceRecent
+    };
+}
+function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, logs, dataset) {
+    // We order fn calls and data-sync operation within single process chain to ensure consistency.
+    // This is simple, and may be good enough.
+    // We pass this single process point out to wrap fn's with it, in an attempt to explicitly keeping it at the
+    // boundary of incoming operations, either from fn calls, or from handling changes passed via fs events.
+    const changeProc = new synced_1.SingleProc();
+    function dbSyncCheckAndAction() {
+        changeProc.startOrChain(periodicCheckAndUploadOfData);
+    }
+    let interval = undefined;
+    function resetSyncInterval() {
+        if (interval !== undefined) {
+            clearInterval(interval);
+        }
+        interval = setInterval(dbSyncCheckAndAction, millisBeforeNextRun()).unref();
+    }
+    resetSyncInterval();
+    // XXX we should watch for reconnect events and run similar to start checks of possibly missed ops
+    // watch and absorb ops, coming from logs of other devices
+    const stopLogsWatching = logs.watchAndApplyOpsFromOtherDevices(changeProc, ops => dataset.absorbOpsFromOtherDevices(changeProc, ops));
+    // watch and absorb ops in dataset, coming from places that dataset sets itself
+    const stopDatasetWatching = dataset.watchAndApplyOpsFromOtherDevices(changeProc, resetSyncInterval);
+    function stopSyncing() {
+        if (interval !== undefined) {
+            stopLogsWatching();
+            stopDatasetWatching();
+            clearInterval(interval);
+            interval = undefined;
+        }
+    }
+    return { changeProc, stopSyncing };
+}
+Object.freeze(exports);

package/build/lib-common/number-line.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a utility function that adds a number into given number line segments.
+ * Each segment is represented by an array, in which 0-th element is the smallest number in the segment,
+ * while 1-st element is the largest. Segments don't overlap and are ordered as they would on a number line:
+ * segment with smaller numbers go first.
+ * This returns true when segment line was updated, and false, otherwise (then number was in segments already).
+ * @param segments
+ * @param n
+ */
+export declare function addToNumberLineSegments(segments: number[][], n: number): boolean;

package/build/lib-common/number-line.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2017, 2026 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.addToNumberLineSegments = addToNumberLineSegments;
+/**
+ * This is a utility function that adds a number into given number line segments.
+ * Each segment is represented by an array, in which 0-th element is the smallest number in the segment,
+ * while 1-st element is the largest. Segments don't overlap and are ordered as they would on a number line:
+ * segment with smaller numbers go first.
+ * This returns true when segment line was updated, and false, otherwise (then number was in segments already).
+ * @param segments
+ * @param n
+ */
+function addToNumberLineSegments(segments, n) {
+    for (let i = (segments.length - 1); i >= 0; i -= 1) {
+        const [low, high] = segments[i];
+        if (high < n) {
+            if ((high + 1) >= n) {
+                // segment should be grown on a high side.
+                // But now bigger segment won't merge with higher segment, cause if
+                // it does, it would've merge from lower side of a higher segment.
+                segments[i][1] = n;
+            }
+            else {
+                // new segment should be added higher than this one
+                segments.splice(i + 1, 0, [n, n]);
+            }
+            return true;
+        }
+        if ((low <= n) && (n <= high)) {
+            // do nothing as number falls into current segment
+            return false;
+        }
+        if (low <= (n + 1)) {
+            // segment should be grown on a lower side
+            segments[i][0] = n;
+            if ((i - 1) >= 0) {
+                // bigger segment may overlap with a lower one
+                const lowerSeg = segments[i - 1];
+                if ((lowerSeg[1] + 1) >= n) {
+                    lowerSeg[1] = high;
+                    segments.splice(i, 1);
+                }
+            }
+            return true;
+        }
+    }
+    segments.unshift([n, n]);
+    return true;
+}
+Object.freeze(exports);

package/build/lib-common/objs-on-disk/obj-version-file.d.ts

@@ -8,7 +8,7 @@ export declare class ObjVersionFile {
     private constructor();
     static forExisting(path: string): Promise<ObjVersionFile>;
     static createNew(path: string): Promise<ObjVersionFile>;
-    private startCreatingFileOnDisk;
+    private creatingFileOnDisk;
     moveFile(newPath: string, newHeader: Uint8Array | undefined): Promise<void>;
     removeFile(): Promise<void>;
     saveLayout(): Promise<void>;

package/build/lib-common/objs-on-disk/obj-version-file.js

@@ -43,11 +43,11 @@ class ObjVersionFile {
     static async createNew(path) {
         const layout = file_layout_1.ObjVersionBytesLayout.forNewFile();
         const objFile = new ObjVersionFile(path, layout);
-        objFile.startCreatingFileOnDisk();
+        await objFile.creatingFileOnDisk();
         return objFile;
     }
-    startCreatingFileOnDisk() {
-        this.writeProc.addStarted(createNewV1File(this.path));
+    async creatingFileOnDisk() {
+        await this.writeProc.addStarted(createNewV1File(this.path));
     }
     moveFile(newPath, newHeader) {
         return this.writeProc.startOrChain(async () => {

package/build/lib-common/rng-def.d.ts

@@ -1,3 +1,4 @@
 export type AsyncRNG = (n: number) => Promise<Uint8Array>;
 export declare function stringOfB64UrlSafeChars(numOfChars: number, random: AsyncRNG): Promise<string>;
 export declare function stringOfB64Chars(numOfChars: number, random: AsyncRNG): Promise<string>;
+export declare function pseudoRNG(n: number): Promise<Uint8Array>;

package/build/lib-common/rng-def.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringOfB64UrlSafeChars = stringOfB64UrlSafeChars;
 exports.stringOfB64Chars = stringOfB64Chars;
+exports.pseudoRNG = pseudoRNG;
 const buffer_utils_1 = require("./buffer-utils");
 async function stringOfB64UrlSafeChars(numOfChars, random) {
     const numOfbytes = 3 * (1 + Math.floor(numOfChars / 4));
@@ -29,4 +30,11 @@ async function stringOfB64Chars(numOfChars, random) {
     const byteArr = await random(numOfbytes);
     return byteArr.toString('base64').substring(0, numOfChars);
 }
+async function pseudoRNG(n) {
+    const bytes = new Uint8Array(n);
+    for (let i = 0; i < n; i += 1) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return bytes;
+}
 Object.freeze(exports);

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

@@ -0,0 +1,38 @@
+import { QueryExecResult } from './index.js';
+import { ParamsObject, SqlValue, Database } from './sqljs.js';
+export type TransformDefinition<T> = {
+    [field in keyof T]: {
+        toSQLValue: (v: any) => SqlValue;
+        fromSQLValue: (sv: SqlValue) => any;
+    } | 'as-is';
+};
+export declare function queryParamsFrom<T>(record: Partial<T>, transforms: TransformDefinition<T>, omit?: (keyof T)[]): ParamsObject;
+export declare function fromQueryResult<T extends object>(queryResult: QueryExecResult, transforms: TransformDefinition<T>): T[];
+export declare function queryParamsFromComplete<T>(record: T, transforms: TransformDefinition<T>): ParamsObject;
+export declare function forTableInsert<T extends object>(record: T, transforms: TransformDefinition<T>): {
+    orderedColumns: string;
+    orderedValues: string;
+    insertParams: ParamsObject;
+};
+export declare function performTableInsert<T extends object>(db: Database, tabName: string, record: T, transforms: TransformDefinition<T>): void;
+export declare function selectFromTable<T extends object>(db: Database, tabName: string, selectColumns: (keyof T)[] | '*', selectWith: Partial<T>, transforms: TransformDefinition<T>): Partial<T>[] | undefined;
+export declare function updateInTable<T extends object>(db: Database, tabName: string, valuesToSet: Partial<T>, updateWith: Partial<T>, transforms: TransformDefinition<T>): void;
+export declare function setExprFor<T extends object>(params: ParamsObject, omit?: (keyof T)[]): string;
+export declare function andEqualExprFor<T extends object>(params: ParamsObject, omit?: (keyof T)[]): string;
+export declare const optJsonTransform: {
+    toSQLValue: (v: object | null) => string | null;
+    fromSQLValue: (sv: SqlValue) => object | null;
+};
+export declare const jsonTransform: {
+    toSQLValue: (v: object) => string;
+    fromSQLValue: (sv: SqlValue) => object;
+};
+export declare const booleanTransform: {
+    toSQLValue: (b: boolean) => 1 | 0;
+    fromSQLValue: (flag: SqlValue) => boolean;
+};
+export declare const optStringAsEmptyTransform: {
+    toSQLValue: (s: string | null) => string;
+    fromSQLValue: (s: SqlValue) => string | null;
+};
+export declare function passOmitting<T extends object>(o: T, ...omitted: (keyof T)[]): Partial<T>;