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

package/src/Nymph.types.ts

@@ -1,8 +1,10 @@
 import { EntityConstructor, EntityInterface } from './Entity.types';
+import Nymph from './Nymph';
 
 export type NymphEventType =
   | 'connect'
   | 'disconnect'
+  | 'query'
   | 'beforeGetEntity'
   | 'beforeGetEntities'
   | 'beforeSaveEntity'
@@ -19,38 +21,83 @@ export type NymphEventType =
   | 'afterRenameUID'
   | 'beforeDeleteUID'
   | 'afterDeleteUID';
-export type NymphConnectCallback = (result: Promise<boolean>) => void;
-export type NymphDisconnectCallback = (result: Promise<boolean>) => void;
+export type NymphConnectCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
+export type NymphDisconnectCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
+/** The NymphQueryCallback will be called on both top level and qref queries. */
+export type NymphQueryCallback = (
+  nymph: Nymph,
+  options: Options,
+  selectors: FormattedSelector[]
+) => void;
 export type NymphBeforeGetEntityCallback = (
+  nymph: Nymph,
   options: Options,
   selectors: Selector[]
 ) => void;
 export type NymphBeforeGetEntitiesCallback = (
+  nymph: Nymph,
   options: Options,
   selectors: Selector[]
 ) => void;
-export type NymphBeforeSaveEntityCallback = (entity: EntityInterface) => void;
-export type NymphAfterSaveEntityCallback = (result: Promise<boolean>) => void;
-export type NymphBeforeDeleteEntityCallback = (entity: EntityInterface) => void;
-export type NymphAfterDeleteEntityCallback = (result: Promise<boolean>) => void;
+export type NymphBeforeSaveEntityCallback = (
+  nymph: Nymph,
+  entity: EntityInterface
+) => void;
+export type NymphAfterSaveEntityCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
+export type NymphBeforeDeleteEntityCallback = (
+  nymph: Nymph,
+  entity: EntityInterface
+) => void;
+export type NymphAfterDeleteEntityCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
 export type NymphBeforeDeleteEntityByIDCallback = (
+  nymph: Nymph,
   guid: string,
   className?: string
 ) => void;
 export type NymphAfterDeleteEntityByIDCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
+export type NymphBeforeNewUIDCallback = (nymph: Nymph, name: string) => void;
+export type NymphAfterNewUIDCallback = (
+  nymph: Nymph,
+  result: Promise<number | null>
+) => void;
+export type NymphBeforeSetUIDCallback = (
+  nymph: Nymph,
+  name: string,
+  value: number
+) => void;
+export type NymphAfterSetUIDCallback = (
+  nymph: Nymph,
   result: Promise<boolean>
 ) => void;
-export type NymphBeforeNewUIDCallback = (name: string) => void;
-export type NymphAfterNewUIDCallback = (result: Promise<number | null>) => void;
-export type NymphBeforeSetUIDCallback = (name: string, value: number) => void;
-export type NymphAfterSetUIDCallback = (result: Promise<boolean>) => void;
 export type NymphBeforeRenameUIDCallback = (
+  nymph: Nymph,
   oldName: string,
   newName: string
 ) => void;
-export type NymphAfterRenameUIDCallback = (result: Promise<boolean>) => void;
-export type NymphBeforeDeleteUIDCallback = (name: string) => void;
-export type NymphAfterDeleteUIDCallback = (result: Promise<boolean>) => void;
+export type NymphAfterRenameUIDCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
+export type NymphBeforeDeleteUIDCallback = (nymph: Nymph, name: string) => void;
+export type NymphAfterDeleteUIDCallback = (
+  nymph: Nymph,
+  result: Promise<boolean>
+) => void;
 
 export type Options<T extends EntityConstructor = EntityConstructor> = {
   class?: T;
@@ -169,7 +216,7 @@ export type Selector = {
   ref?: Clause<PrimitiveSelector['ref']>;
   '!ref'?: Clause<PrimitiveSelector['ref']>;
 
-  qref?: [string, [Options, ...Selector[]]];
+  qref?: Clause<[string, [Options, ...Selector[]]]>;
   '!qref'?: Selector['qref'];
 
   selector?: Clause<Selector>;
@@ -179,17 +226,17 @@ export type Selector = {
 export type FormattedSelector = {
   type: '&' | '|' | '!&' | '!|';
 
-  guid?: PrimitiveSelector['guid'][];
-  '!guid'?: PrimitiveSelector['guid'][];
+  guid?: PrimitiveSelector['guid'][][];
+  '!guid'?: PrimitiveSelector['guid'][][];
 
-  tag?: PrimitiveSelector['tag'][];
-  '!tag'?: PrimitiveSelector['tag'][];
+  tag?: PrimitiveSelector['tag'][][];
+  '!tag'?: PrimitiveSelector['tag'][][];
 
-  defined?: PrimitiveSelector['defined'][];
-  '!defined'?: PrimitiveSelector['defined'][];
+  defined?: PrimitiveSelector['defined'][][];
+  '!defined'?: PrimitiveSelector['defined'][][];
 
-  truthy?: PrimitiveSelector['truthy'][];
-  '!truthy'?: PrimitiveSelector['truthy'][];
+  truthy?: PrimitiveSelector['truthy'][][];
+  '!truthy'?: PrimitiveSelector['truthy'][][];
 
   equal?: PrimitiveSelector['equal'][];
   '!equal'?: PrimitiveSelector['equal'][];
@@ -230,3 +277,25 @@ export type FormattedSelector = {
   selector?: FormattedSelector[];
   '!selector'?: FormattedSelector['selector'];
 };
+
+export enum TilmeldAccessLevels {
+  NO_ACCESS = 0,
+  READ_ACCESS = 1,
+  WRITE_ACCESS = 2,
+  // Keeping 3 open in case we ever need one between write and full.
+  FULL_ACCESS = 4,
+}
+
+export interface TilmeldInterface {
+  nymph: Nymph;
+  request: any;
+  response: any;
+  init(nymph: Nymph): void;
+  clone(): TilmeldInterface;
+  gatekeeper(ability?: string): boolean;
+  authenticate(): void;
+  clearSession(): void;
+  extractToken(token: string): Promise<any>;
+  fillSession(user: any): void;
+  checkClientUIDPermissions(name: string, type?: TilmeldAccessLevels): boolean;
+}

package/src/driver/NymphDriver.ts

@@ -3,6 +3,7 @@ import { difference } from 'lodash';
 import ReadLines from 'n-readlines';
 import strtotime from 'locutus/php/datetime/strtotime';
 
+import type Nymph from '../Nymph';
 import newGUID from '../newGUID';
 import {
   EntityConstructor,
@@ -11,7 +12,6 @@ import {
   SerializedEntityData,
 } from '../Entity.types';
 import { InvalidParametersError, UnableToConnectError } from '../errors';
-import Nymph from '../Nymph';
 import { Selector, Options, FormattedSelector } from '../Nymph.types';
 import { xor } from '../utils';
 
@@ -24,6 +24,14 @@ function escapeRegExp(string: string): string {
  * A Nymph database driver.
  */
 export default abstract class NymphDriver {
+  protected nymph: Nymph = new Proxy({} as Nymph, {
+    get() {
+      throw new Error(
+        'Attempted access of Nymph instance before driver initialization!'
+      );
+    },
+  });
+
   /**
    * A cache to make entity retrieval faster.
    */
@@ -47,7 +55,7 @@ export default abstract class NymphDriver {
 
   abstract connect(): Promise<boolean>;
   abstract isConnected(): boolean;
-  abstract startTransaction(name: string): Promise<boolean>;
+  abstract startTransaction(name: string): Promise<Nymph>;
   abstract commit(name: string): Promise<boolean>;
   abstract rollback(name: string): Promise<boolean>;
   abstract inTransaction(): Promise<boolean>;
@@ -98,6 +106,17 @@ export default abstract class NymphDriver {
   abstract saveEntity(entity: EntityInterface): Promise<boolean>;
   abstract setUID(name: string, value: number): Promise<boolean>;
 
+  /**
+   * Initialize the Nymph driver.
+   *
+   * This is meant to be called internally by Nymph. Don't call this directly.
+   *
+   * @param nymph The Nymph instance.
+   */
+  public init(nymph: Nymph) {
+    this.nymph = nymph;
+  }
+
   protected posixRegexMatch(
     pattern: string,
     subject: string,
@@ -277,8 +296,7 @@ export default abstract class NymphDriver {
           );
         } else {
           if (key === 'qref' || key === '!qref') {
-            // TODO: implement qref clauses
-            throw new Error('not implemented');
+            throw new Error("Can't use checkData on qref clauses.");
           } else {
             // Check if it doesn't pass any for &, check if it
             // passes any for |.
@@ -533,7 +551,10 @@ export default abstract class NymphDriver {
     return false;
   }
 
-  public formatSelectors(selectors: Selector[]): FormattedSelector[] {
+  public formatSelectors(
+    selectors: Selector[],
+    options: Options = {}
+  ): FormattedSelector[] {
     const newSelectors: FormattedSelector[] = [];
 
     for (const curSelector of selectors) {
@@ -549,17 +570,37 @@ export default abstract class NymphDriver {
           continue;
         }
 
-        if (key === 'qref' || key === '!qref') {
-          throw new Error("qref isn't implemented yet.");
-        }
-
         if (value === undefined) {
           continue;
         }
 
-        if (key === 'selector' || key === '!selector') {
+        if (key === 'qref' || key === '!qref') {
+          const tmpArr = (
+            Array.isArray(((value as Selector['qref']) ?? [])[0])
+              ? value
+              : [value]
+          ) as [string, [Options, ...Selector[]]][];
+          const formatArr: [string, [Options, ...FormattedSelector[]]][] = [];
+          for (let i = 0; i < tmpArr.length; i++) {
+            const name = tmpArr[i][0];
+            const [qrefOptions, ...qrefSelectors] = tmpArr[i][1];
+            const QrefEntityClass =
+              typeof qrefOptions.class === 'string'
+                ? this.nymph.getEntityClass(qrefOptions.class)
+                : qrefOptions.class ?? this.nymph.getEntityClass('Entity');
+            const newOptions = {
+              ...qrefOptions,
+              class: QrefEntityClass,
+              source: options.source,
+            };
+            const newSelectors = this.formatSelectors(qrefSelectors, options);
+            this.nymph.runQueryCallbacks(newOptions, newSelectors);
+            formatArr[i] = [name, [newOptions, ...newSelectors]];
+          }
+          newSelector[key] = formatArr;
+        } else if (key === 'selector' || key === '!selector') {
           const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
-          newSelector[key] = this.formatSelectors(tmpArr);
+          newSelector[key] = this.formatSelectors(tmpArr, options);
         } else if (!Array.isArray(value)) {
           // @ts-ignore: ts doesn't know what value is here.
           newSelector[key] = [[value]];
@@ -764,12 +805,13 @@ export default abstract class NymphDriver {
     }
 
     let entities: ReturnType<T['factorySync']>[] | string[] = [];
-    const EntityClass = options.class ?? (Nymph.getEntityClass('Entity') as T);
+    const EntityClass =
+      options.class ?? (this.nymph.getEntityClass('Entity') as T);
     const etype = EntityClass.ETYPE;
 
     // Check if the requested entity is cached.
     if (
-      Nymph.config.cache &&
+      this.nymph.config.cache &&
       !options.skipCache &&
       'guid' in selectors[0] &&
       typeof selectors[0].guid === 'number'
@@ -806,43 +848,47 @@ export default abstract class NymphDriver {
       }
     }
 
-    const formattedSelectors = this.formatSelectors(selectors);
+    const formattedSelectors = this.formatSelectors(selectors, options);
+    this.nymph.runQueryCallbacks(options, formattedSelectors);
     const { result } = performQueryCallback(options, formattedSelectors, etype);
 
     return {
       result,
       process: () => {
         let row = rowFetchCallback();
-        while (row != null) {
-          const guid = getGUIDCallback(row);
-          const tagsAndDates = getTagsAndDatesCallback(row);
-          const tags = tagsAndDates.tags;
-          const cdate = tagsAndDates.cdate;
-          const mdate = tagsAndDates.mdate;
-          let dataNameAndSValue = getDataNameAndSValueCallback(row);
-          // Data.
-          const data: EntityData = {};
-          // Serialized data.
-          const sdata: SerializedEntityData = {};
-          if (dataNameAndSValue.name !== '') {
-            // This do will keep going and adding the data until the
-            // next entity is reached. $row will end on the next entity.
-            do {
-              dataNameAndSValue = getDataNameAndSValueCallback(row);
-              sdata[dataNameAndSValue.name] = dataNameAndSValue.svalue;
-              row = rowFetchCallback();
-            } while (row != null && getGUIDCallback(row) === guid);
-          } else {
-            // Make sure that $row is incremented :)
+        if (options.return === 'guid') {
+          while (row != null) {
+            (entities as string[]).push(getGUIDCallback(row));
             row = rowFetchCallback();
           }
-          if (options.return === 'guid') {
-            // @ts-ignore: ts doesn't know the return type here.
-            entities.push(guid);
-          } else {
+        } else {
+          while (row != null) {
+            const guid = getGUIDCallback(row);
+            const tagsAndDates = getTagsAndDatesCallback(row);
+            const tags = tagsAndDates.tags;
+            const cdate = tagsAndDates.cdate;
+            const mdate = tagsAndDates.mdate;
+            let dataNameAndSValue = getDataNameAndSValueCallback(row);
+            // Data.
+            const data: EntityData = {};
+            // Serialized data.
+            const sdata: SerializedEntityData = {};
+            if (dataNameAndSValue.name !== '') {
+              // This do will keep going and adding the data until the
+              // next entity is reached. $row will end on the next entity.
+              do {
+                dataNameAndSValue = getDataNameAndSValueCallback(row);
+                sdata[dataNameAndSValue.name] = dataNameAndSValue.svalue;
+                row = rowFetchCallback();
+              } while (row != null && getGUIDCallback(row) === guid);
+            } else {
+              // Make sure that $row is incremented :)
+              row = rowFetchCallback();
+            }
             const entity = EntityClass.factorySync() as ReturnType<
               T['factorySync']
             >;
+            entity.$nymph = this.nymph;
             if (options.skipAc != null) {
               entity.$useSkipAc(!!options.skipAc);
             }
@@ -856,7 +902,7 @@ export default abstract class NymphDriver {
             }
             entity.$putData(data, sdata);
             this.putDataCounter--;
-            if (Nymph.config.cache) {
+            if (this.nymph.config.cache) {
               this.pushCache(guid, cdate, mdate, tags, data, sdata);
             }
             // @ts-ignore: ts doesn't know the return type here.
@@ -926,7 +972,7 @@ export default abstract class NymphDriver {
       }
     } else {
       // Removed any cached versions of this entity.
-      if (Nymph.config.cache) {
+      if (this.nymph.config.cache) {
         this.cleanCache(entity.guid);
       }
       success = await saveExistingEntityCallback(
@@ -946,7 +992,7 @@ export default abstract class NymphDriver {
       success = await commitTransactionCallback(success);
     }
     // Cache the entity.
-    if (success && Nymph.config.cache) {
+    if (success && this.nymph.config.cache) {
       this.pushCache(
         entity.guid as string,
         entity.cdate as number,
@@ -978,8 +1024,9 @@ export default abstract class NymphDriver {
     }
     this.entityCount[guid]++;
     if (guid in this.entityCache) {
-      const entity = Nymph.getEntityClass(className).factorySync() as T;
+      const entity = this.nymph.getEntityClass(className).factorySync() as T;
       if (entity) {
+        entity.$nymph = this.nymph;
         entity.$useSkipAc(!!useSkipAc);
         entity.guid = guid;
         entity.cdate = this.entityCache[guid]['cdate'];
@@ -1022,7 +1069,7 @@ export default abstract class NymphDriver {
     }
     this.entityCount[guid]++;
     // Check the threshold.
-    if (this.entityCount[guid] < Nymph.config.cacheThreshold) {
+    if (this.entityCount[guid] < this.nymph.config.cacheThreshold) {
       return;
     }
     // Cache the entity.
@@ -1034,8 +1081,8 @@ export default abstract class NymphDriver {
       sdata: sdata,
     };
     while (
-      Nymph.config.cacheLimit &&
-      Object.keys(this.entityCache).length >= Nymph.config.cacheLimit
+      this.nymph.config.cacheLimit &&
+      Object.keys(this.entityCache).length >= this.nymph.config.cacheLimit
     ) {
       // Find which entity has been accessed the least.
       const least =