@nymphjs/driver-postgresql 1.0.0-beta.62 → 1.0.0-beta.63

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 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-postgresql

package/dist/PostgreSQLDriver.d.ts

@@ -1,5 +1,5 @@
 import { Pool, PoolClient } from 'pg';
-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 { PostgreSQLDriverConfig } from './conf';
 type PostgreSQLDriverConnection = {
     client: PoolClient;
@@ -63,7 +63,10 @@ export default class PostgreSQLDriver 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 PostgreSQL query.
      * @param options The options array.
@@ -86,13 +89,24 @@ export default class PostgreSQLDriver 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>;
-    private internalTransaction;
+    protected internalTransaction(name: string): Promise<PostgreSQLDriverTransaction>;
     startTransaction(name: string): Promise<import("@nymphjs/nymph").Nymph>;
 }
 export {};

package/dist/PostgreSQLDriver.js

@@ -12,6 +12,13 @@ const conf_1 = require("./conf");
  * The PostgreSQL Nymph database driver.
  */
 class PostgreSQLDriver extends nymph_1.NymphDriver {
+    config;
+    postgresqlConfig;
+    prefix;
+    connected = false;
+    // @ts-ignore: this is assigned in connect(), which is called by the constructor.
+    link;
+    transaction = null;
     static escape(input) {
         return pg_format_1.default.ident(input);
     }
@@ -20,8 +27,6 @@ class PostgreSQLDriver extends nymph_1.NymphDriver {
     }
     constructor(config, link, transaction) {
         super();
-        this.connected = false;
-        this.transaction = null;
         this.config = { ...conf_1.PostgreSQLDriverConfigDefaults, ...config };
         const { host, user, password, database, port, customPoolConfig } = this.config;
         this.postgresqlConfig = customPoolConfig ?? {
@@ -398,27 +403,49 @@ class PostgreSQLDriver extends nymph_1.NymphDriver {
         });
         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 = await this.queryIter(`SELECT * FROM ${PostgreSQLDriver.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 = await this.queryIter('SELECT relname FROM pg_stat_user_tables ORDER BY relname;');
         const etypes = [];
@@ -441,9 +468,10 @@ class PostgreSQLDriver extends nymph_1.NymphDriver {
                 const tags = datum.value.tags.join(',');
                 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. $row will end on the next entity.
@@ -453,7 +481,7 @@ class PostgreSQLDriver 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);
                 }
@@ -461,9 +489,12 @@ class PostgreSQLDriver 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 PostgreSQL query.
@@ -1481,161 +1512,138 @@ class PostgreSQLDriver extends nymph_1.NymphDriver {
         });
         return result?.cur_uid == null ? null : Number(result.cur_uid);
     }
-    async import(filename, transaction) {
+    async importEntity({ guid, cdate, mdate, tags, sdata, etype, }) {
         try {
-            const result = await this.importFromFile(filename, async (guid, tags, sdata, etype) => {
-                try {
-                    await this.internalTransaction(`nymph-import-entity-${guid}`);
-                    const cdate = Number(JSON.parse(sdata.cdate));
-                    delete sdata.cdate;
-                    const mdate = Number(JSON.parse(sdata.mdate));
-                    delete sdata.mdate;
-                    await this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    });
-                    await this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}entities_${etype}`)} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @mdate);`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                            tags,
-                            cdate: isNaN(cdate) ? null : cdate,
-                            mdate: isNaN(mdate) ? null : mdate,
-                        },
-                    });
-                    const promises = [];
-                    promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}data_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    }));
-                    promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}comparisons_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    }));
-                    promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}references_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
-                        etypes: [etype],
-                        params: {
-                            guid,
-                        },
-                    }));
-                    promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}uniques_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+            await this.internalTransaction(`nymph-import-entity-${guid}`);
+            await this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            });
+            await this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}entities_${etype}`)} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @mdate);`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                    tags,
+                    cdate: isNaN(cdate) ? null : cdate,
+                    mdate: isNaN(mdate) ? null : mdate,
+                },
+            });
+            const promises = [];
+            promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}data_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            }));
+            promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}comparisons_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            }));
+            promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}references_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            }));
+            promises.push(this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}uniques_${etype}`)} WHERE "guid"=decode(@guid, 'hex');`, {
+                etypes: [etype],
+                params: {
+                    guid,
+                },
+            }));
+            await Promise.all(promises);
+            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;
+                const promises = [];
+                promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}data_${etype}`)} ("guid", "name", "value") VALUES (decode(@guid, 'hex'), @name, @storageValue);`, {
+                    etypes: [etype],
+                    params: {
+                        guid,
+                        name,
+                        storageValue,
+                    },
+                }));
+                promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}comparisons_${etype}`)} ("guid", "name", "truthy", "string", "number") VALUES (decode(@guid, 'hex'), @name, @truthy, @string, @number);`, {
+                    etypes: [etype],
+                    params: {
+                        guid,
+                        name,
+                        truthy: !!uvalue,
+                        string: `${uvalue}`,
+                        number: isNaN(Number(uvalue)) ? null : Number(uvalue),
+                    },
+                }));
+                const references = this.findReferences(value);
+                for (const reference of references) {
+                    promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}references_${etype}`)} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`, {
                         etypes: [etype],
                         params: {
                             guid,
-                        },
-                    }));
-                    await Promise.all(promises);
-                    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;
-                        const promises = [];
-                        promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}data_${etype}`)} ("guid", "name", "value") VALUES (decode(@guid, 'hex'), @name, @storageValue);`, {
-                            etypes: [etype],
-                            params: {
-                                guid,
-                                name,
-                                storageValue,
-                            },
-                        }));
-                        promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}comparisons_${etype}`)} ("guid", "name", "truthy", "string", "number") VALUES (decode(@guid, 'hex'), @name, @truthy, @string, @number);`, {
-                            etypes: [etype],
-                            params: {
-                                guid,
-                                name,
-                                truthy: !!uvalue,
-                                string: `${uvalue}`,
-                                number: isNaN(Number(uvalue)) ? null : Number(uvalue),
-                            },
-                        }));
-                        const references = this.findReferences(value);
-                        for (const reference of references) {
-                            promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}references_${etype}`)} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`, {
-                                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) {
-                        promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}uniques_${etype}`)} ("guid", "unique") VALUES (decode(@guid, 'hex'), @unique);`, {
-                            etypes: [etype],
-                            params: {
-                                guid,
-                                unique,
-                            },
-                        }).catch((e) => {
-                            if (e instanceof nymph_1.EntityUniqueConstraintError) {
-                                this.nymph.config.debugError('postgresql', `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`);
-                            }
-                            return e;
-                        }));
-                    }
-                    await Promise.all(promises);
-                    await this.commit(`nymph-import-entity-${guid}`);
-                }
-                catch (e) {
-                    this.nymph.config.debugError('postgresql', `Import entity error: "${e}"`);
-                    await this.rollback(`nymph-import-entity-${guid}`);
-                    throw e;
-                }
-            }, async (name, curUid) => {
-                try {
-                    await this.internalTransaction(`nymph-import-uid-${name}`);
-                    await this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
-                        params: {
                             name,
+                            reference,
                         },
-                    });
-                    await this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}uids`)} ("name", "cur_uid") VALUES (@name, @curUid);`, {
-                        params: {
-                            name,
-                            curUid,
-                        },
-                    });
-                    await this.commit(`nymph-import-uid-${name}`);
-                }
-                catch (e) {
-                    this.nymph.config.debugError('postgresql', `Import UID error: "${e}"`);
-                    await this.rollback(`nymph-import-uid-${name}`);
-                    throw e;
-                }
-            }, async () => {
-                if (transaction) {
-                    await this.internalTransaction('nymph-import');
-                }
-            }, async () => {
-                if (transaction) {
-                    await this.commit('nymph-import');
+                    }));
                 }
+            }
+            const uniques = await this.nymph
+                .getEntityClassByEtype(etype)
+                .getUniques({ guid, cdate, mdate, tags, data: {}, sdata });
+            for (const unique of uniques) {
+                promises.push(this.queryRun(`INSERT INTO ${PostgreSQLDriver.escape(`${this.prefix}uniques_${etype}`)} ("guid", "unique") VALUES (decode(@guid, 'hex'), @unique);`, {
+                    etypes: [etype],
+                    params: {
+                        guid,
+                        unique,
+                    },
+                }).catch((e) => {
+                    if (e instanceof nymph_1.EntityUniqueConstraintError) {
+                        this.nymph.config.debugError('postgresql', `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`);
+                    }
+                    return e;
+                }));
+            }
+            await Promise.all(promises);
+            await this.commit(`nymph-import-entity-${guid}`);
+        }
+        catch (e) {
+            this.nymph.config.debugError('postgresql', `Import entity error: "${e}"`);
+            await this.rollback(`nymph-import-entity-${guid}`);
+            throw e;
+        }
+    }
+    async importUID({ name, value }) {
+        try {
+            await this.internalTransaction(`nymph-import-uid-${name}`);
+            await this.queryRun(`DELETE FROM ${PostgreSQLDriver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
+                params: {
+                    name,
+                },
             });
-            return result;
+            await this.queryRun(`INSERT INTO ${PostgreSQLDriver.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('postgresql', `Import error: "${e}"`);
-            if (transaction) {
-                await this.rollback('nymph-import');
-            }
-            return false;
+            this.nymph.config.debugError('postgresql', `Import UID error: "${e}"`);
+            await this.rollback(`nymph-import-uid-${name}`);
+            throw e;
         }
     }
     async newUID(name) {