@nymphjs/nymph 1.0.0-alpha.1 → 1.0.0-alpha.13

package/src/index.ts

@@ -16,6 +16,8 @@ export * from './Nymph.types';
 export * from './Nymph';
 import Nymph from './Nymph';
 export { Nymph };
-export default Nymph;
+
+import nymphJoiProps from './nymphJoiProps';
+export { nymphJoiProps };
 
 export * from './utils';

package/src/nymphJoiProps.ts

@@ -0,0 +1,24 @@
+import Joi from 'joi';
+
+export default {
+  guid: Joi.alternatives()
+    .try(
+      Joi.any().only().allow(null),
+      Joi.string().trim(false).length(24).hex()
+    )
+    .required(),
+  cdate: Joi.alternatives()
+    .try(Joi.any().only().allow(null), Joi.number())
+    .required(),
+  mdate: Joi.alternatives()
+    .try(Joi.any().only().allow(null), Joi.number())
+    .required(),
+  tags: Joi.array()
+    .items(
+      Joi.string().pattern(/[[\x01-\x1F\x7F]]/, {
+        name: 'control characters',
+        invert: true,
+      })
+    )
+    .required(),
+};

package/src/testArtifacts.ts

@@ -1,5 +1,4 @@
 import Entity from './Entity';
-import Nymph from './Nymph';
 
 export type TestModelData = {
   name?: string;
@@ -72,8 +71,6 @@ export class TestModel extends Entity<TestModelData> {
   }
 }
 
-Nymph.setEntityClass(TestModel.class, TestModel);
-
 /**
  * This class is a test class that extends the Entity class.
  */
@@ -89,5 +86,3 @@ export class TestBModel extends TestModel {
     return super.factorySync(guid) as TestBModel & TestModelData;
   }
 }
-
-Nymph.setEntityClass(TestBModel.class, TestBModel);

package/src/testMocks.ts

@@ -1,11 +1,19 @@
+import type Nymph from './Nymph';
 import { EntityConstructor, EntityInterface, EntityJson } from './Entity.types';
 import { Options, Selector } from './Nymph.types';
 import newGUID from './newGUID';
 import { ClassNotAvailableError } from './errors';
+import Entity from './Entity';
 
 const entities: { [k: string]: EntityJson } = {};
 
 export class MockNymphDriver {
+  private nymph: MockNymph;
+
+  public constructor(nymph: MockNymph) {
+    this.nymph = nymph;
+  }
+
   public getEntitySync<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
@@ -33,7 +41,7 @@ export class MockNymphDriver {
     }
 
     const entity: EntityInterface = (
-      (options.class as T) ?? MockNymph.getEntityClass('Entity')
+      (options.class as T) ?? this.nymph.getEntityClass('Entity')
     ).factorySync();
     const entityJson = entities[guid];
     entity.guid = guid;
@@ -47,51 +55,48 @@ export class MockNymphDriver {
 }
 
 export class MockNymph {
-  public static entityClasses: { [k: string]: EntityConstructor } = {};
-  public static driver = new MockNymphDriver();
-  public static Tilmeld: any = undefined;
-
-  public static setEntityClass(
-    className: string,
-    entityClass: EntityConstructor
-  ) {
-    this.entityClasses[className] = entityClass;
+  private entityClasses: { [k: string]: EntityConstructor } = {};
+  public driver: MockNymphDriver;
+  public Tilmeld: any = undefined;
+
+  public constructor() {
+    this.driver = new MockNymphDriver(this);
+
+    // class NymphEntity extends Entity {}
+    this.addEntityClass(Entity);
+  }
+
+  public addEntityClass(entityClass: EntityConstructor) {
+    this.entityClasses[entityClass.class] = entityClass;
+    entityClass.nymph = this as unknown as Nymph;
   }
 
-  public static getEntityClass(className: string): EntityConstructor {
+  public getEntityClass(className: string): EntityConstructor {
     if (className in this.entityClasses) {
-      return this.entityClasses[className];
+      const EntityClass = this.entityClasses[className];
+      EntityClass.nymph = this as unknown as Nymph;
+      return EntityClass;
     }
     throw new ClassNotAvailableError('Tried to use class: ' + className);
   }
 
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
   ): Promise<ReturnType<T['factorySync']> | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string
   ): Promise<string | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     guid: string
   ): Promise<ReturnType<T['factorySync']> | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
   ): Promise<ReturnType<T['factorySync']> | string | null> {
@@ -99,7 +104,7 @@ export class MockNymph {
     return this.driver.getEntitySync(options, ...selectors);
   }
 
-  public static async saveEntity(entity: EntityInterface): Promise<boolean> {
+  public async saveEntity(entity: EntityInterface): Promise<boolean> {
     const className = (entity.constructor as any).class as string;
 
     if (entity.guid == null) {
@@ -127,7 +132,7 @@ export class MockNymph {
     return true;
   }
 
-  public static async deleteEntity(entity: EntityInterface): Promise<boolean> {
+  public async deleteEntity(entity: EntityInterface): Promise<boolean> {
     if (entity.guid != null && entity.guid in entities) {
       delete entities[entity.guid];
       return true;

package/src/utils.ts

@@ -1,3 +1,4 @@
+import Entity from './Entity';
 import { EntityReference } from './Entity.types';
 import Nymph from './Nymph';
 
@@ -14,14 +15,12 @@ export function uniqueStrings(array: string[]) {
 }
 
 export function entitiesToReferences(item: any): any {
-  const EntityClass = Nymph.getEntityClass('Entity');
-
-  if (item instanceof EntityClass && typeof item.$toReference === 'function') {
+  if (item instanceof Entity && typeof item.$toReference === 'function') {
     // Convert entities to references.
     return item.$toReference();
   } else if (Array.isArray(item)) {
     // Recurse into lower arrays.
-    return item.map(entitiesToReferences);
+    return item.map((entry) => entitiesToReferences(entry));
   } else if (item instanceof Object) {
     let newObj = Object.create(item);
     for (let [key, value] of Object.entries(item)) {
@@ -33,27 +32,30 @@ export function entitiesToReferences(item: any): any {
   return item;
 }
 
-export function referencesToEntities(item: any, useSkipAc = false): any {
-  const Entity = Nymph.getEntityClass('Entity');
-
+export function referencesToEntities(
+  item: any,
+  nymph: Nymph,
+  useSkipAc = false
+): any {
   if (Array.isArray(item)) {
     // Check if it's a reference.
     if (item[0] === 'nymph_entity_reference') {
       try {
-        const EntityClass = Nymph.getEntityClass(item[2]);
+        const EntityClass = nymph.getEntityClass(item[2]);
         const entity = EntityClass.factoryReference(item as EntityReference);
         entity.$useSkipAc(useSkipAc);
+        entity.$nymph = nymph;
         return entity;
       } catch (e: any) {
         return item;
       }
     } else {
       // Recurse into lower arrays.
-      return item.map((item) => referencesToEntities(item, useSkipAc));
+      return item.map((entry) => referencesToEntities(entry, nymph, useSkipAc));
     }
   } else if (Entity && item instanceof Object && !(item instanceof Entity)) {
     for (let [key, value] of Object.entries(item)) {
-      item[key] = referencesToEntities(value);
+      item[key] = referencesToEntities(value, nymph);
     }
   }
   // Not an array, just return it.