@nymphjs/nymph 1.0.0-beta.5 → 1.0.0-beta.50

package/src/errors/InvalidStateError.ts

@@ -0,0 +1,6 @@
+export class InvalidStateError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidStateError';
+  }
+}

package/src/errors/index.ts

@@ -8,6 +8,8 @@ export * from './EntityIsSleepingReferenceError';
 
 export * from './InvalidParametersError';
 
+export * from './InvalidStateError';
+
 export * from './NotConfiguredError';
 
 export * from './QueryFailedError';

package/src/nymphJoiProps.ts

@@ -4,7 +4,7 @@ export default {
   guid: Joi.alternatives()
     .try(
       Joi.any().only().allow(null),
-      Joi.string().trim(false).length(24).hex()
+      Joi.string().trim(false).length(24).hex(),
     )
     .required(),
   cdate: Joi.alternatives()
@@ -18,7 +18,7 @@ export default {
       Joi.string().pattern(/[[\x01-\x1F\x7F]]/, {
         name: 'control characters',
         invert: true,
-      })
+      }),
     )
     .required(),
 };

package/src/testArtifacts.ts

@@ -38,17 +38,15 @@ export class TestModel extends Entity<TestModelData> {
     return (await super.factory(guid)) as TestModel & TestModelData;
   }
 
-  static factorySync(guid?: string): TestModel & TestModelData {
-    return super.factorySync(guid) as TestModel & TestModelData;
+  static factorySync(): TestModel & TestModelData {
+    return super.factorySync() as TestModel & TestModelData;
   }
 
-  constructor(guid?: string) {
-    super(guid);
+  constructor() {
+    super();
 
-    if (this.guid == null) {
-      this.$addTag('test');
-      this.$data.boolean = true;
-    }
+    this.$addTag('test');
+    this.$data.boolean = true;
   }
 
   public $useProtectedData() {
@@ -82,7 +80,27 @@ export class TestBModel extends TestModel {
     return (await super.factory(guid)) as TestBModel & TestModelData;
   }
 
-  static factorySync(guid?: string): TestBModel & TestModelData {
-    return super.factorySync(guid) as TestBModel & TestModelData;
+  static factorySync(): TestBModel & TestModelData {
+    return super.factorySync() as TestBModel & TestModelData;
+  }
+}
+
+export type TestEmptyModelData = {};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class TestEmptyModel extends Entity<TestEmptyModelData> {
+  static ETYPE = 'test_empty_model';
+  static class = 'TestEmptyModel';
+
+  static async factory(
+    guid?: string,
+  ): Promise<TestEmptyModel & TestEmptyModelData> {
+    return (await super.factory(guid)) as TestEmptyModel & TestEmptyModelData;
+  }
+
+  static factorySync(): TestEmptyModel & TestEmptyModelData {
+    return super.factorySync() as TestEmptyModel & TestEmptyModelData;
   }
 }

package/src/testMocks.ts

@@ -15,26 +15,26 @@ export class MockNymphDriver {
     this.nymph = nymph;
   }
 
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
-  ): string | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): ReturnType<T['factorySync']> | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  ): Promise<ReturnType<T['factorySync']> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
-    guid: string
-  ): string | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    guid: string,
+  ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
-    guid: string
-  ): ReturnType<T['factorySync']> | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    guid: string,
+  ): Promise<ReturnType<T['factorySync']> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): ReturnType<T['factorySync']> | string | null {
+  ): Promise<ReturnType<T['factorySync']> | string | null> {
     const guid =
       typeof selectors[0] === 'string' ? selectors[0] : selectors[0].guid;
     if (!options || !guid || typeof guid !== 'string' || !(guid in entities)) {
@@ -59,26 +59,43 @@ export class MockNymph {
   private entityClasses: { [k: string]: EntityConstructor } = {};
   public driver: MockNymphDriver;
   public Tilmeld: any = undefined;
+  public Entity: typeof Entity;
 
   public constructor() {
     this.driver = new MockNymphDriver(this);
 
     // class NymphEntity extends Entity {}
-    this.addEntityClass(Entity);
+    this.Entity = this.addEntityClass(Entity);
   }
 
-  public addEntityClass(entityClass: EntityConstructor) {
-    this.entityClasses[entityClass.class] = entityClass;
-    entityClass.nymph = this as unknown as Nymph;
+  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+    const nymph = this;
+    class NymphEntity extends entityClass {
+      static nymph: Nymph = nymph as unknown as Nymph;
+
+      constructor(...args: any[]) {
+        super(...args);
+      }
+    }
+    this.entityClasses[entityClass.class] = NymphEntity;
+    return NymphEntity;
   }
 
-  public getEntityClass(className: string): EntityConstructor {
-    if (className in this.entityClasses) {
-      const EntityClass = this.entityClasses[className];
-      EntityClass.nymph = this as unknown as Nymph;
-      return EntityClass;
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
+  public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor = EntityConstructor>(
+    className: T | string,
+  ): T | EntityConstructor {
+    let key: string | null = null;
+    if (typeof className === 'string') {
+      key = className;
+    } else {
+      key = className.class;
+    }
+    if (key in this.entityClasses) {
+      return this.entityClasses[key];
     }
-    throw new ClassNotAvailableError('Tried to use class: ' + className);
+    throw new ClassNotAvailableError('Tried to use class: ' + key);
   }
 
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
@@ -91,18 +108,18 @@ export class MockNymph {
   ): Promise<ReturnType<T['factorySync']> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
-    guid: string
+    guid: string,
   ): Promise<string | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
-    guid: string
+    guid: string,
   ): Promise<ReturnType<T['factorySync']> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
   ): Promise<ReturnType<T['factorySync']> | string | null> {
     // @ts-ignore: The selector type is correct here.
-    return this.driver.getEntitySync(options, ...selectors);
+    return await this.driver.getEntity(options, ...selectors);
   }
 
   public async saveEntity(entity: EntityInterface): Promise<boolean> {

package/src/utils.ts

@@ -17,7 +17,8 @@ export function uniqueStrings(array: string[]) {
 
 export function classNamesToEntityConstructors(
   nymph: Nymph,
-  selectors: Selector[]
+  selectors: Selector[],
+  enforceRestEnabledFlag = false,
 ): Selector[] {
   const newSelectors: Selector[] = [];
 
@@ -45,22 +46,35 @@ export function classNamesToEntityConstructors(
         for (let i = 0; i < tmpArr.length; i++) {
           const name = tmpArr[i][0];
           const [qrefOptions, ...selectors] = tmpArr[i][1];
-          const QrefEntityClass =
-            typeof qrefOptions.class === 'string'
-              ? nymph.getEntityClass(qrefOptions.class)
-              : qrefOptions.class ?? nymph.getEntityClass('Entity');
+          const QrefEntityClass = qrefOptions.class
+            ? nymph.getEntityClass(qrefOptions.class)
+            : nymph.getEntityClass('Entity');
+          if (enforceRestEnabledFlag && !QrefEntityClass.restEnabled) {
+            throw new Error('Not accessible.');
+          }
           const options = { ...qrefOptions, class: QrefEntityClass };
           if (!newSelector[key]) {
             newSelector[key] = [];
           }
           (newSelector[key] as [string, [Options, ...Selector[]]][]).push([
             name,
-            [options, ...classNamesToEntityConstructors(nymph, selectors)],
+            [
+              options,
+              ...classNamesToEntityConstructors(
+                nymph,
+                selectors,
+                enforceRestEnabledFlag,
+              ),
+            ],
           ]);
         }
       } else if (key === 'selector' || key === '!selector') {
         const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
-        newSelector[key] = classNamesToEntityConstructors(nymph, tmpArr);
+        newSelector[key] = classNamesToEntityConstructors(
+          nymph,
+          tmpArr,
+          enforceRestEnabledFlag,
+        );
       } else {
         // @ts-ignore: ts doesn't know what value is here.
         newSelector[key] = value;
@@ -94,7 +108,7 @@ export function entitiesToReferences(item: any): any {
 export function referencesToEntities(
   item: any,
   nymph: Nymph,
-  useSkipAc = false
+  useSkipAc = false,
 ): any {
   if (Array.isArray(item)) {
     // Check if it's a reference.

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}