@nymphjs/nymph 1.0.0-beta.124 → 1.0.0-beta.126

package/src/driver/NymphDriver.ts

@@ -6,6 +6,7 @@ import { Tokenizer } from '@sciactive/tokenizer';
 
 import type Nymph from '../Nymph.js';
 import type { Selector, Options, FormattedSelector } from '../Nymph.types.js';
+import Entity from '../Entity.js';
 import type { EntityInstanceType, EntityObjectType } from '../Entity.js';
 import type {
   EntityConstructor,
@@ -19,7 +20,13 @@ import {
   InvalidParametersError,
   UnableToConnectError,
 } from '../errors/index.js';
-import { xor } from '../utils.js';
+import {
+  classNamesToEntityConstructors,
+  entitiesToReferences,
+  entityConstructorsToClassNames,
+  referencesToEntities,
+  xor,
+} from '../utils.js';
 
 // from: https://stackoverflow.com/a/6969486/664915
 function escapeRegExp(string: string): string {
@@ -735,8 +742,19 @@ export default abstract class NymphDriver {
     ) {
       return true;
     }
+    if (
+      value instanceof Entity &&
+      value.guid != null &&
+      guids.indexOf(value.guid) !== -1
+    ) {
+      return true;
+    }
     // Search through arrays and objects looking for the reference.
-    if (value != null && (Array.isArray(value) || typeof value === 'object')) {
+    if (
+      value != null &&
+      (Array.isArray(value) ||
+        (typeof value === 'object' && !(value instanceof Entity)))
+    ) {
       for (const key in value) {
         if (this.entityReferenceSearch(value[key], guids)) {
           return true;
@@ -1328,7 +1346,20 @@ export default abstract class NymphDriver {
               entity.cdate = cdate;
               entity.mdate = mdate;
               entity.tags = tags;
-              entity.$putData(data, sdata, 'server');
+              entity.$putData(
+                classNamesToEntityConstructors(
+                  this.nymph,
+                  referencesToEntities(
+                    data,
+                    this.nymph,
+                    !!options.skipAc,
+                    false,
+                  ),
+                  false,
+                ),
+                sdata,
+                'server',
+              );
               return {
                 result: Promise.resolve(null),
                 process: () => [entity],
@@ -1446,11 +1477,29 @@ export default abstract class NymphDriver {
                   cdate,
                   mdate,
                   tags,
-                  ...data,
+                  ...classNamesToEntityConstructors(
+                    this.nymph,
+                    referencesToEntities(
+                      data,
+                      this.nymph,
+                      !!options.skipAc,
+                      false,
+                    ),
+                    false,
+                  ),
                   ...Object.fromEntries(
                     Object.entries(sdata).map(([name, value]) => [
                       name,
-                      JSON.parse(value),
+                      classNamesToEntityConstructors(
+                        this.nymph,
+                        referencesToEntities(
+                          JSON.parse(value),
+                          this.nymph,
+                          !!options.skipAc,
+                          false,
+                        ),
+                        false,
+                      ),
                     ]),
                   ),
                 } as EntityObjectType<T>);
@@ -1469,7 +1518,20 @@ export default abstract class NymphDriver {
                 if (this.putDataCounter == 100) {
                   throw new Error('Infinite loop detected in Entity loading.');
                 }
-                entity.$putData(data, sdata, 'server');
+                entity.$putData(
+                  classNamesToEntityConstructors(
+                    this.nymph,
+                    referencesToEntities(
+                      data,
+                      this.nymph,
+                      !!options.skipAc,
+                      false,
+                    ),
+                    false,
+                  ),
+                  sdata,
+                  'server',
+                );
                 this.putDataCounter--;
                 entities.push(entity);
               }
@@ -1537,7 +1599,11 @@ export default abstract class NymphDriver {
       }
     }
     const tags = difference(entity.tags, ['']);
-    const data = entity.$getData();
+    const data = entityConstructorsToClassNames(
+      // Explicitly save references to entities that aren't saved yet to help
+      // save circular references by saving with a guaranteed GUID.
+      entitiesToReferences(entity.$getData(), false),
+    );
     const sdata = entity.$getSData();
     const uniques = await entity.$getUniques();
     const EntityClass = entity.constructor as EntityConstructor;

package/src/driver/testArtifacts.ts

@@ -15,6 +15,10 @@ import {
   TestModelData,
   TestEmptyModel as TestEmptyModelClass,
 } from '../testArtifacts.js';
+import {
+  entitiesToReferences,
+  entityConstructorsToClassNames,
+} from '../utils.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -2706,7 +2710,9 @@ export function ExportImportTest(
       expect(model).not.toBeNull();
 
       if (model != null) {
-        const data = model.$getData(true);
+        const data = entityConstructorsToClassNames(
+          entitiesToReferences(model.$getData(true), true),
+        );
         // These should not actually be saved in the DB.
         data.number = 424242424242;
         // But this should become searchable.

package/src/testMocks.ts

@@ -10,6 +10,12 @@ import type {
 import { Options, Selector } from './Nymph.types.js';
 import { ClassNotAvailableError, EntityConflictError } from './errors/index.js';
 import Entity from './Entity.js';
+import {
+  classNamesToEntityConstructors,
+  entitiesToReferences,
+  entityConstructorsToClassNames,
+  referencesToEntities,
+} from './utils.js';
 
 const entities: { [k: string]: EntityJson } = {};
 
@@ -62,7 +68,20 @@ export class MockNymphDriver {
     entity.cdate = entityJson.cdate;
     entity.mdate = entityJson.mdate;
     entity.tags = entityJson.tags;
-    entity.$putData(entityJson.data, {}, 'server');
+    entity.$putData(
+      classNamesToEntityConstructors(
+        this.nymph as unknown as Nymph,
+        referencesToEntities(
+          entityJson.data,
+          this.nymph as unknown as Nymph,
+          !!options.skipAc,
+          false,
+        ),
+        false,
+      ),
+      {},
+      'server',
+    );
 
     return entity as EntityInstanceType<T>;
   }
@@ -154,8 +173,6 @@ export class MockNymph {
   }
 
   public async saveEntity(entity: EntityInterface): Promise<boolean> {
-    const className = (entity.constructor as any).class as string;
-
     if (entity.guid == null) {
       entity.guid = guid();
       entity.cdate = Date.now();
@@ -171,12 +188,18 @@ export class MockNymph {
     entity.mdate = Date.now();
 
     const entityJson: EntityJson = {
-      class: className,
+      class: entity.constructor as EntityConstructor,
       guid: entity.guid,
       cdate: entity.cdate,
       mdate: entity.mdate,
       tags: [...entity.tags],
-      data: JSON.parse(JSON.stringify(entity.$getData(true))),
+      data: JSON.parse(
+        JSON.stringify(
+          entityConstructorsToClassNames(
+            entitiesToReferences(entity.$getData(true), true),
+          ),
+        ),
+      ),
     };
 
     entities[entity.guid] = entityJson;

package/src/utils.ts

@@ -1,7 +1,6 @@
 import Entity from './Entity.js';
 import { EntityReference } from './Entity.types.js';
 import Nymph from './Nymph.js';
-import { Options, Selector } from './Nymph.types.js';
 
 export function xor(a: any, b: any): boolean {
   return !!(a && !b) || (!a && b);
@@ -15,6 +14,29 @@ export function uniqueStrings(array: string[]) {
   return Object.keys(obj);
 }
 
+export function entityConstructorsToClassNames(item: any): any {
+  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
+    return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Convert entity classes to class references.
+    return ['nymph_class_reference', item.class];
+  } else if (item instanceof Entity) {
+    // Don't touch entities.
+    return item;
+  } else if (Array.isArray(item)) {
+    // Recurse into lower arrays.
+    return item.map((entry) => entityConstructorsToClassNames(entry));
+  } else if (item instanceof Object) {
+    let newObj = Object.create(item);
+    for (let [key, value] of Object.entries(item)) {
+      newObj[key] = entityConstructorsToClassNames(value);
+    }
+    return newObj;
+  }
+  // Not an entity or array, just return it.
+  return item;
+}
+
 export function classNamesToEntityConstructors<T extends any>(
   nymph: Nymph,
   item: T,
@@ -34,12 +56,12 @@ export function classNamesToEntityConstructors<T extends any>(
       throw new Error('Not accessible.');
     }
     return EntityClass as T;
-  } else if (
-    item instanceof Entity &&
-    typeof item.$toReference === 'function'
-  ) {
+  } else if (item instanceof Entity) {
     // Don't touch entities.
     return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Don't touch Entity classes.
+    return item;
   } else if (Array.isArray(item)) {
     // Recurse into lower arrays.
     return item.map((entry) =>
@@ -60,50 +82,13 @@ export function classNamesToEntityConstructors<T extends any>(
   return item;
 }
 
-export function entityConstructorsToClassNames(item: any): any {
-  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
-    return item;
-  } else if (
-    typeof item === 'function' &&
-    item.prototype instanceof Entity &&
-    typeof item.class === 'string'
-  ) {
-    // Convert entity classes to class references.
-    return ['nymph_class_reference', item.class];
-  } else if (
-    item instanceof Entity &&
-    typeof item.$toReference === 'function'
-  ) {
-    // Don't touch entities.
-    return item;
-  } else if (Array.isArray(item)) {
-    // Recurse into lower arrays.
-    return item.map((entry) => entityConstructorsToClassNames(entry));
-  } else if (item instanceof Object) {
-    let newObj = Object.create(item);
-    for (let [key, value] of Object.entries(item)) {
-      newObj[key] = entityConstructorsToClassNames(value);
-    }
-    return newObj;
-  }
-  // Not an entity or array, just return it.
-  return item;
-}
-
 export function entitiesToReferences(item: any, existingOnly?: boolean): any {
   if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
     return item;
-  } else if (
-    item instanceof Entity &&
-    typeof item.$toReference === 'function'
-  ) {
+  } else if (item instanceof Entity) {
     // Convert entities to references.
     return item.$toReference(existingOnly);
-  } else if (
-    typeof item === 'function' &&
-    item.prototype instanceof Entity &&
-    typeof item.class === 'string'
-  ) {
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
     // Don't touch Entity classes.
     return item;
   } else if (Array.isArray(item)) {
@@ -145,12 +130,27 @@ export function referencesToEntities(
       }
     } else {
       // Recurse into lower arrays.
-      return item.map((entry) => referencesToEntities(entry, nymph, useSkipAc));
+      return item.map((entry) =>
+        referencesToEntities(entry, nymph, useSkipAc, enforceRestEnabledFlag),
+      );
     }
-  } else if (Entity && item instanceof Object && !(item instanceof Entity)) {
+  } else if (item instanceof Entity) {
+    // Don't touch entities.
+    return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Don't touch Entity classes.
+    return item;
+  } else if (item instanceof Object) {
+    let newObj = Object.create(item);
     for (let [key, value] of Object.entries(item)) {
-      item[key] = referencesToEntities(value, nymph);
+      newObj[key] = referencesToEntities(
+        value,
+        nymph,
+        useSkipAc,
+        enforceRestEnabledFlag,
+      );
     }
+    return newObj;
   }
   // Not an array, just return it.
   return item;