@nymphjs/driver-sqlite3 1.0.0-beta.61 → 1.0.0-beta.63

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-beta.63](https://github.com/sciactive/nymphjs/compare/v1.0.0-beta.62...v1.0.0-beta.63) (2024-06-18)
+
+### Bug Fixes
+
+- undo ts compilation to module change ([84be6d4](https://github.com/sciactive/nymphjs/commit/84be6d434be29f8afd53907d15be2eb77d1736ce))
+
+### Features
+
+- allow importing from text and iterables ([9d766bd](https://github.com/sciactive/nymphjs/commit/9d766bdad4b0f17bc2dd68b0336a0064857eb4e9))
+- export data iterator ([b86aa19](https://github.com/sciactive/nymphjs/commit/b86aa19fc77d744b5a683046dfb697fc4746df5c))
+
+# [1.0.0-beta.62](https://github.com/sciactive/nymphjs/compare/v1.0.0-beta.61...v1.0.0-beta.62) (2024-06-15)
+
+**Note:** Version bump only for package @nymphjs/driver-sqlite3
+
 # [1.0.0-beta.61](https://github.com/sciactive/nymphjs/compare/v1.0.0-beta.60...v1.0.0-beta.61) (2024-06-14)
 
 **Note:** Version bump only for package @nymphjs/driver-sqlite3

package/dist/SQLite3Driver.d.ts

@@ -1,5 +1,5 @@
 import SQLite3 from 'better-sqlite3';
-import { NymphDriver, type EntityConstructor, type EntityInterface, type EntityInstanceType, type FormattedSelector, type Options, type Selector } from '@nymphjs/nymph';
+import { NymphDriver, type EntityConstructor, type EntityInterface, type EntityInstanceType, type SerializedEntityData, type FormattedSelector, type Options, type Selector } from '@nymphjs/nymph';
 import { SQLite3DriverConfig } from './conf';
 declare class InternalStore {
     link: SQLite3.Database;
@@ -56,7 +56,10 @@ export default class SQLite3Driver extends NymphDriver {
     commit(name: string): Promise<boolean>;
     deleteEntityByID(guid: string, className?: EntityConstructor | string | null): Promise<boolean>;
     deleteUID(name: string): Promise<boolean>;
-    protected exportEntities(writeLine: (line: string) => void): Promise<void>;
+    exportDataIterator(): AsyncGenerator<{
+        type: 'comment' | 'uid' | 'entity';
+        content: string;
+    }, void, false | undefined>;
     /**
      * Generate the SQLite3 query.
      * @param options The options array.
@@ -79,12 +82,24 @@ export default class SQLite3Driver extends NymphDriver {
     }, ...selectors: Selector[]): Promise<string[]>;
     getEntities<T extends EntityConstructor = EntityConstructor>(options?: Options<T>, ...selectors: Selector[]): Promise<EntityInstanceType<T>[]>;
     getUID(name: string): Promise<number | null>;
-    import(filename: string, transaction?: boolean): Promise<boolean>;
+    importEntity({ guid, cdate, mdate, tags, sdata, etype, }: {
+        guid: string;
+        cdate: number;
+        mdate: number;
+        tags: string[];
+        sdata: SerializedEntityData;
+        etype: string;
+    }): Promise<void>;
+    importUID({ name, value }: {
+        name: string;
+        value: number;
+    }): Promise<void>;
     newUID(name: string): Promise<number>;
     renameUID(oldName: string, newName: string): Promise<boolean>;
     rollback(name: string): Promise<boolean>;
     saveEntity(entity: EntityInterface): Promise<boolean>;
     setUID(name: string, curUid: number): Promise<boolean>;
+    internalTransaction(name: string): Promise<void>;
     startTransaction(name: string): Promise<import("@nymphjs/nymph").Nymph>;
 }
 export {};

package/dist/SQLite3Driver.js

@@ -8,9 +8,11 @@ const nymph_1 = require("@nymphjs/nymph");
 const guid_1 = require("@nymphjs/guid");
 const conf_1 = require("./conf");
 class InternalStore {
+    link;
+    linkWrite;
+    connected = false;
+    transactionsStarted = 0;
     constructor(link) {
-        this.connected = false;
-        this.transactionsStarted = 0;
         this.link = link;
     }
 }
@@ -18,6 +20,10 @@ class InternalStore {
  * The SQLite3 Nymph database driver.
  */
 class SQLite3Driver extends nymph_1.NymphDriver {
+    config;
+    prefix;
+    // @ts-ignore: this is assigned in connect(), which is called by the constructor.
+    store;
     static escape(input) {
         if (input.indexOf('\x00') !== -1) {
             throw new nymph_1.InvalidParametersError('SQLite3 identifiers (like entity ETYPE) cannot contain null characters.');
@@ -346,27 +352,49 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         await this.commit('nymph-delete-uid');
         return true;
     }
-    async exportEntities(writeLine) {
-        writeLine('#nex2');
-        writeLine('# Nymph Entity Exchange v2');
-        writeLine('# http://nymph.io');
-        writeLine('#');
-        writeLine('# Generation Time: ' + new Date().toLocaleString());
-        writeLine('');
-        writeLine('#');
-        writeLine('# UIDs');
-        writeLine('#');
-        writeLine('');
+    async *exportDataIterator() {
+        if (yield {
+            type: 'comment',
+            content: `#nex2
+# Nymph Entity Exchange v2
+# http://nymph.io
+#
+# Generation Time: ${new Date().toLocaleString()}
+`,
+        }) {
+            return;
+        }
+        if (yield {
+            type: 'comment',
+            content: `
+
+#
+# UIDs
+#
+
+`,
+        }) {
+            return;
+        }
         // Export UIDs.
         let uids = this.queryIter(`SELECT * FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} ORDER BY "name";`);
         for (const uid of uids) {
-            writeLine(`<${uid.name}>[${uid.cur_uid}]`);
+            if (yield { type: 'uid', content: `<${uid.name}>[${uid.cur_uid}]\n` }) {
+                return;
+            }
+        }
+        if (yield {
+            type: 'comment',
+            content: `
+
+#
+# Entities
+#
+
+`,
+        }) {
+            return;
         }
-        writeLine('');
-        writeLine('#');
-        writeLine('# Entities');
-        writeLine('#');
-        writeLine('');
         // Get the etypes.
         const tables = this.queryIter("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name;");
         const etypes = [];
@@ -384,9 +412,10 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 const tags = datum.value.tags.slice(1, -1);
                 const cdate = datum.value.cdate;
                 const mdate = datum.value.mdate;
-                writeLine(`{${guid}}<${etype}>[${tags}]`);
-                writeLine(`\tcdate=${JSON.stringify(cdate)}`);
-                writeLine(`\tmdate=${JSON.stringify(mdate)}`);
+                let currentEntityExport = [];
+                currentEntityExport.push(`{${guid}}<${etype}>[${tags}]`);
+                currentEntityExport.push(`\tcdate=${JSON.stringify(cdate)}`);
+                currentEntityExport.push(`\tmdate=${JSON.stringify(mdate)}`);
                 if (datum.value.dname != null) {
                     // This do will keep going and adding the data until the
                     // next entity is reached. datum will end on the next entity.
@@ -396,7 +425,7 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                             : datum.value.dvalue === 'S'
                                 ? JSON.stringify(datum.value.string)
                                 : datum.value.dvalue;
-                        writeLine(`\t${datum.value.dname}=${value}`);
+                        currentEntityExport.push(`\t${datum.value.dname}=${value}`);
                         datum = dataIterator.next();
                     } while (!datum.done && datum.value.guid === guid);
                 }
@@ -404,9 +433,12 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                     // Make sure that datum is incremented :)
                     datum = dataIterator.next();
                 }
+                currentEntityExport.push('');
+                if (yield { type: 'entity', content: currentEntityExport.join('\n') }) {
+                    return;
+                }
             }
         }
-        return;
     }
     /**
      * Generate the SQLite3 query.
@@ -1381,158 +1413,136 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         });
         return result?.cur_uid ?? null;
     }
-    async import(filename, transaction) {
+    async importEntity({ guid, cdate, mdate, tags, sdata, etype, }) {
         try {
-            return this.importFromFile(filename, async (guid, tags, sdata, etype) => {
-                try {
-                    await this.startTransaction(`nymph-import-entity-${guid}`);
-                    const cdate = Number(JSON.parse(sdata.cdate));
-                    delete sdata.cdate;
-                    const mdate = Number(JSON.parse(sdata.mdate));
-                    delete sdata.mdate;
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=@guid;`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}data_${etype}`)} WHERE "guid"=@guid;`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}comparisons_${etype}`)} WHERE "guid"=@guid;`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}references_${etype}`)} WHERE "guid"=@guid;`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uniques_${etype}`)} WHERE "guid"=@guid;`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @mdate);`, {
+            await this.startTransaction(`nymph-import-entity-${guid}`);
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=@guid;`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}data_${etype}`)} WHERE "guid"=@guid;`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}comparisons_${etype}`)} WHERE "guid"=@guid;`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}references_${etype}`)} WHERE "guid"=@guid;`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uniques_${etype}`)} WHERE "guid"=@guid;`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @mdate);`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                    tags: ',' + tags.join(',') + ',',
+                    cdate,
+                    mdate,
+                },
+            });
+            for (const name in sdata) {
+                const value = sdata[name];
+                const uvalue = JSON.parse(value);
+                if (value === undefined) {
+                    continue;
+                }
+                const storageValue = typeof uvalue === 'number'
+                    ? 'N'
+                    : typeof uvalue === 'string'
+                        ? 'S'
+                        : value;
+                this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}data_${etype}`)} ("guid", "name", "value") VALUES (@guid, @name, @storageValue);`, {
+                    etypes: [etype],
+                    params: {
+                        guid,
+                        name,
+                        storageValue,
+                    },
+                });
+                this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}comparisons_${etype}`)} ("guid", "name", "truthy", "string", "number") VALUES (@guid, @name, @truthy, @string, @number);`, {
+                    etypes: [etype],
+                    params: {
+                        guid,
+                        name,
+                        truthy: uvalue ? 1 : 0,
+                        string: `${uvalue}`,
+                        number: Number(uvalue),
+                    },
+                });
+                const references = this.findReferences(value);
+                for (const reference of references) {
+                    this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}references_${etype}`)} ("guid", "name", "reference") VALUES (@guid, @name, @reference);`, {
                         etypes: [etype],
                         params: {
                             guid,
-                            tags: ',' + tags.join(',') + ',',
-                            cdate,
-                            mdate,
+                            name,
+                            reference,
                         },
                     });
-                    for (const name in sdata) {
-                        const value = sdata[name];
-                        const uvalue = JSON.parse(value);
-                        if (value === undefined) {
-                            continue;
-                        }
-                        const storageValue = typeof uvalue === 'number'
-                            ? 'N'
-                            : typeof uvalue === 'string'
-                                ? 'S'
-                                : value;
-                        this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}data_${etype}`)} ("guid", "name", "value") VALUES (@guid, @name, @storageValue);`, {
-                            etypes: [etype],
-                            params: {
-                                guid,
-                                name,
-                                storageValue,
-                            },
-                        });
-                        this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}comparisons_${etype}`)} ("guid", "name", "truthy", "string", "number") VALUES (@guid, @name, @truthy, @string, @number);`, {
-                            etypes: [etype],
-                            params: {
-                                guid,
-                                name,
-                                truthy: uvalue ? 1 : 0,
-                                string: `${uvalue}`,
-                                number: Number(uvalue),
-                            },
-                        });
-                        const references = this.findReferences(value);
-                        for (const reference of references) {
-                            this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}references_${etype}`)} ("guid", "name", "reference") VALUES (@guid, @name, @reference);`, {
-                                etypes: [etype],
-                                params: {
-                                    guid,
-                                    name,
-                                    reference,
-                                },
-                            });
-                        }
-                    }
-                    const uniques = await this.nymph
-                        .getEntityClassByEtype(etype)
-                        .getUniques({ guid, cdate, mdate, tags, data: {}, sdata });
-                    for (const unique of uniques) {
-                        try {
-                            this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}uniques_${etype}`)} ("guid", "unique") VALUES (@guid, @unique);`, {
-                                etypes: [etype],
-                                params: {
-                                    guid,
-                                    unique,
-                                },
-                            });
-                        }
-                        catch (e) {
-                            if (e instanceof nymph_1.EntityUniqueConstraintError) {
-                                this.nymph.config.debugError('sqlite3', `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`);
-                            }
-                            throw e;
-                        }
-                    }
-                    await this.commit(`nymph-import-entity-${guid}`);
                 }
-                catch (e) {
-                    this.nymph.config.debugError('sqlite3', `Import entity error: "${e}"`);
-                    await this.rollback(`nymph-import-entity-${guid}`);
-                    throw e;
-                }
-            }, async (name, curUid) => {
+            }
+            const uniques = await this.nymph
+                .getEntityClassByEtype(etype)
+                .getUniques({ guid, cdate, mdate, tags, data: {}, sdata });
+            for (const unique of uniques) {
                 try {
-                    await this.startTransaction(`nymph-import-uid-${name}`);
-                    this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
-                        params: {
-                            name,
-                        },
-                    });
-                    this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}uids`)} ("name", "cur_uid") VALUES (@name, @curUid);`, {
+                    this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}uniques_${etype}`)} ("guid", "unique") VALUES (@guid, @unique);`, {
+                        etypes: [etype],
                         params: {
-                            name,
-                            curUid,
+                            guid,
+                            unique,
                         },
                     });
-                    await this.commit(`nymph-import-uid-${name}`);
                 }
                 catch (e) {
-                    this.nymph.config.debugError('sqlite3', `Import UID error: "${e}"`);
-                    await this.rollback(`nymph-import-uid-${name}`);
+                    if (e instanceof nymph_1.EntityUniqueConstraintError) {
+                        this.nymph.config.debugError('sqlite3', `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`);
+                    }
                     throw e;
                 }
-            }, async () => {
-                if (transaction) {
-                    await this.startTransaction('nymph-import');
-                }
-            }, async () => {
-                if (transaction) {
-                    await this.commit('nymph-import');
-                }
+            }
+            await this.commit(`nymph-import-entity-${guid}`);
+        }
+        catch (e) {
+            this.nymph.config.debugError('sqlite3', `Import entity error: "${e}"`);
+            await this.rollback(`nymph-import-entity-${guid}`);
+            throw e;
+        }
+    }
+    async importUID({ name, value }) {
+        try {
+            await this.startTransaction(`nymph-import-uid-${name}`);
+            this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
+                params: {
+                    name,
+                },
+            });
+            this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}uids`)} ("name", "cur_uid") VALUES (@name, @value);`, {
+                params: {
+                    name,
+                    value,
+                },
             });
+            await this.commit(`nymph-import-uid-${name}`);
         }
         catch (e) {
-            this.nymph.config.debugError('sqlite3', `Import error: "${e}"`);
-            if (transaction) {
-                await this.rollback('nymph-import');
-            }
+            this.nymph.config.debugError('sqlite3', `Import UID error: "${e}"`);
+            await this.rollback(`nymph-import-uid-${name}`);
             throw e;
         }
     }
@@ -1777,6 +1787,9 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         await this.commit('nymph-set-uid');
         return true;
     }
+    async internalTransaction(name) {
+        await this.startTransaction(name);
+    }
     async startTransaction(name) {
         if (name == null || typeof name !== 'string' || name.length === 0) {
             throw new nymph_1.InvalidParametersError('Transaction start attempted without a name.');