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

package/src/PostgreSQLDriver.ts

@@ -767,18 +767,39 @@ export default class PostgreSQLDriver extends NymphDriver {
     return true;
   }
 
-  protected async exportEntities(writeLine: (line: string) => void) {
-    writeLine('#nex2');
-    writeLine('# Nymph Entity Exchange v2');
-    writeLine('# http://nymph.io');
-    writeLine('#');
-    writeLine('# Generation Time: ' + new Date().toLocaleString());
-    writeLine('');
-
-    writeLine('#');
-    writeLine('# UIDs');
-    writeLine('#');
-    writeLine('');
+  public async *exportDataIterator(): AsyncGenerator<
+    { type: 'comment' | 'uid' | 'entity'; content: string },
+    void,
+    false | undefined
+  > {
+    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(
@@ -787,14 +808,25 @@ export default class PostgreSQLDriver extends NymphDriver {
       )} 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;
+      }
     }
 
-    writeLine('');
-    writeLine('#');
-    writeLine('# Entities');
-    writeLine('#');
-    writeLine('');
+    if (
+      yield {
+        type: 'comment',
+        content: `
+
+#
+# Entities
+#
+
+`,
+      }
+    ) {
+      return;
+    }
 
     // Get the etypes.
     const tables = await this.queryIter(
@@ -829,9 +861,10 @@ export default class PostgreSQLDriver extends 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: string[] = [];
+        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.
@@ -842,17 +875,20 @@ export default class PostgreSQLDriver extends 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);
         } else {
           // Make sure that datum is incremented :)
           datum = dataIterator.next();
         }
+        currentEntityExport.push('');
+
+        if (yield { type: 'entity', content: currentEntityExport.join('\n') }) {
+          return;
+        }
       }
     }
-
-    return;
   }
 
   /**
@@ -1993,253 +2029,232 @@ export default class PostgreSQLDriver extends NymphDriver {
     return result?.cur_uid == null ? null : Number(result.cur_uid);
   }
 
-  public async import(filename: string, transaction?: boolean) {
+  public async importEntity({
+    guid,
+    cdate,
+    mdate,
+    tags,
+    sdata,
+    etype,
+  }: {
+    guid: string;
+    cdate: number;
+    mdate: number;
+    tags: string[];
+    sdata: SerializedEntityData;
+    etype: string;
+  }) {
     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.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,
               },
-            );
-            await this.queryRun(
+            },
+          ),
+        );
+        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}entities_${etype}`,
-              )} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @mdate);`,
+                `${this.prefix}references_${etype}`,
+              )} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`,
               {
                 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,
-                        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: any) => {
-                  if (e instanceof 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: any) {
-            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,
-                },
+            ),
+          );
+        }
+      }
+      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,
               },
-            );
-            await this.commit(`nymph-import-uid-${name}`);
-          } catch (e: any) {
-            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');
-          }
+            },
+          ).catch((e: any) => {
+            if (e instanceof 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: any) {
+      this.nymph.config.debugError('postgresql', `Import entity error: "${e}"`);
+      await this.rollback(`nymph-import-entity-${guid}`);
+      throw e;
+    }
+  }
+
+  public async importUID({ name, value }: { name: string; value: number }) {
+    try {
+      await this.internalTransaction(`nymph-import-uid-${name}`);
+      await this.queryRun(
+        `DELETE FROM ${PostgreSQLDriver.escape(
+          `${this.prefix}uids`,
+        )} WHERE "name"=@name;`,
+        {
+          params: {
+            name,
+          },
         },
-        async () => {
-          if (transaction) {
-            await this.commit('nymph-import');
-          }
+      );
+      await this.queryRun(
+        `INSERT INTO ${PostgreSQLDriver.escape(
+          `${this.prefix}uids`,
+        )} ("name", "cur_uid") VALUES (@name, @value);`,
+        {
+          params: {
+            name,
+            value,
+          },
         },
       );
-
-      return result;
+      await this.commit(`nymph-import-uid-${name}`);
     } catch (e: any) {
-      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;
     }
   }
 
@@ -2685,7 +2700,7 @@ export default class PostgreSQLDriver extends NymphDriver {
     return true;
   }
 
-  private async internalTransaction(name: string) {
+  protected async internalTransaction(name: string) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(
         'Transaction start attempted without a name.',

package/tsconfig.json

@@ -2,8 +2,8 @@
   "extends": "@tsconfig/recommended/tsconfig.json",
 
   "compilerOptions": {
-    "lib": ["ES2021"],
-    "target": "ES2021",
+    "lib": ["ES2023"],
+    "target": "ES2022",
     "noImplicitAny": true,
     "removeComments": false,
     "sourceMap": true,