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

package/src/SQLite3Driver.ts

@@ -602,18 +602,39 @@ export default class SQLite3Driver 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('');
+  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;
+    }
 
-    writeLine('#');
-    writeLine('# UIDs');
-    writeLine('#');
-    writeLine('');
+    if (
+      yield {
+        type: 'comment',
+        content: `
+
+#
+# UIDs
+#
+
+`,
+      }
+    ) {
+      return;
+    }
 
     // Export UIDs.
     let uids: IterableIterator<any> = this.queryIter(
@@ -622,14 +643,25 @@ export default class SQLite3Driver 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: IterableIterator<any> = this.queryIter(
@@ -659,9 +691,10 @@ export default class SQLite3Driver extends 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: 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. datum will end on the next entity.
@@ -672,17 +705,20 @@ export default class SQLite3Driver 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;
   }
 
   /**
@@ -1740,230 +1776,214 @@ export default class SQLite3Driver extends NymphDriver {
     return (result?.cur_uid as number | null) ?? null;
   }
 
-  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 {
-      return this.importFromFile(
-        filename,
-        async (guid, tags, sdata, etype) => {
-          try {
-            await this.startTransaction(`nymph-import-entity-${guid}`);
+      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(
-              `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,
+                name,
+                reference,
               },
-            );
-
-            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,
-                },
+            },
+          );
+        }
+      }
+      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,
               },
-            );
-            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: any) {
-                if (e instanceof 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: any) {
+            },
+          );
+        } catch (e: any) {
+          if (e instanceof EntityUniqueConstraintError) {
             this.nymph.config.debugError(
               'sqlite3',
-              `Import entity error: "${e}"`,
-            );
-            await this.rollback(`nymph-import-entity-${guid}`);
-            throw e;
-          }
-        },
-        async (name, curUid) => {
-          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);`,
-              {
-                params: {
-                  name,
-                  curUid,
-                },
-              },
+              `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
             );
-            await this.commit(`nymph-import-uid-${name}`);
-          } catch (e: any) {
-            this.nymph.config.debugError('sqlite3', `Import UID error: "${e}"`);
-            await this.rollback(`nymph-import-uid-${name}`);
-            throw e;
-          }
-        },
-        async () => {
-          if (transaction) {
-            await this.startTransaction('nymph-import');
           }
+          throw e;
+        }
+      }
+      await this.commit(`nymph-import-entity-${guid}`);
+    } catch (e: any) {
+      this.nymph.config.debugError('sqlite3', `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.startTransaction(`nymph-import-uid-${name}`);
+      this.queryRun(
+        `DELETE FROM ${SQLite3Driver.escape(
+          `${this.prefix}uids`,
+        )} WHERE "name"=@name;`,
+        {
+          params: {
+            name,
+          },
         },
-        async () => {
-          if (transaction) {
-            await this.commit('nymph-import');
-          }
+      );
+      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: any) {
-      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;
     }
   }
@@ -2318,6 +2338,10 @@ export default class SQLite3Driver extends NymphDriver {
     return true;
   }
 
+  public async internalTransaction(name: string) {
+    await this.startTransaction(name);
+  }
+
   public async startTransaction(name: string) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(

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,