@nymphjs/nymph 1.0.0-alpha.32 → 1.0.0-alpha.36

package/src/driver/NymphDriver.ts

@@ -9,6 +9,7 @@ import {
   EntityConstructor,
   EntityData,
   EntityInterface,
+  EntityReference,
   SerializedEntityData,
 } from '../Entity.types';
 import { InvalidParametersError, UnableToConnectError } from '../errors';
@@ -69,6 +70,10 @@ export default abstract class NymphDriver {
   protected abstract exportEntities(
     writeLine: (line: string) => void
   ): Promise<void>;
+  abstract getEntities<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'count' },
+    ...selectors: Selector[]
+  ): Promise<number>;
   abstract getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
@@ -80,7 +85,13 @@ export default abstract class NymphDriver {
   abstract getEntities<T extends EntityConstructor = EntityConstructor>(
     options?: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']>[] | string[]>;
+  ): Promise<ReturnType<T['factorySync']>[] | string[] | number>;
+  protected abstract getEntitiesSync<
+    T extends EntityConstructor = EntityConstructor
+  >(
+    options: Options<T> & { return: 'count' },
+    ...selectors: Selector[]
+  ): number;
   protected abstract getEntitiesSync<
     T extends EntityConstructor = EntityConstructor
   >(
@@ -98,7 +109,7 @@ export default abstract class NymphDriver {
   >(
     options?: Options<T>,
     ...selectors: Selector[]
-  ): ReturnType<T['factorySync']>[] | string[];
+  ): ReturnType<T['factorySync']>[] | string[] | number;
   abstract getUID(name: string): Promise<number | null>;
   abstract import(filename: string): Promise<boolean>;
   abstract newUID(name: string): Promise<number | null>;
@@ -516,16 +527,26 @@ export default abstract class NymphDriver {
    */
   protected entityReferenceSearch(
     value: any,
-    entity: EntityInterface | string | (EntityInterface | string)[]
+    entity:
+      | EntityInterface
+      | EntityReference
+      | string
+      | (EntityInterface | EntityReference | string)[]
   ) {
     // Get the GUID, if the passed $entity is an object.
     const guids: string[] = [];
     if (Array.isArray(entity)) {
-      for (const curEntity of entity) {
-        if (typeof curEntity === 'string') {
-          guids.push(curEntity);
-        } else if (typeof curEntity.guid === 'string') {
-          guids.push(curEntity.guid);
+      if (entity[0] === 'nymph_entity_reference') {
+        guids.push(value[1]);
+      } else {
+        for (const curEntity of entity) {
+          if (typeof curEntity === 'string') {
+            guids.push(curEntity);
+          } else if (Array.isArray(curEntity)) {
+            guids.push(curEntity[1]);
+          } else if (typeof curEntity.guid === 'string') {
+            guids.push(curEntity.guid);
+          }
         }
       }
     } else if (typeof entity === 'string') {
@@ -684,6 +705,10 @@ export default abstract class NymphDriver {
    * @param selectors Unlimited optional selectors to search for, or a single GUID. If none are given, all entities are searched for the given options.
    * @returns An entity, or null on failure or nothing found.
    */
+  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'count' },
+    ...selectors: Selector[]
+  ): number;
   public getEntitySync<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
@@ -692,6 +717,10 @@ export default abstract class NymphDriver {
     options: Options<T>,
     ...selectors: Selector[]
   ): ReturnType<T['factorySync']> | null;
+  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'count' },
+    guid: string
+  ): number;
   public getEntitySync<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string
@@ -703,7 +732,7 @@ export default abstract class NymphDriver {
   public getEntitySync<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): ReturnType<T['factorySync']> | string | null {
+  ): ReturnType<T['factorySync']> | string | number | null {
     // Set up options and selectors.
     if (typeof selectors[0] === 'string') {
       selectors = [{ type: '&', guid: selectors[0] }];
@@ -713,12 +742,39 @@ export default abstract class NymphDriver {
       options,
       ...(selectors as Selector[])
     );
+    if (options.return === 'count') {
+      return entities as unknown as number;
+    }
     if (!entities || !entities.length) {
       return null;
     }
     return entities[0];
   }
 
+  protected getEntitesRowLike<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'count' },
+    selectors: Selector[],
+    performQueryCallback: (
+      options: Options<T>,
+      formattedSelectors: FormattedSelector[],
+      etype: string
+    ) => {
+      result: any;
+    },
+    rowFetchCallback: () => any,
+    freeResultCallback: () => void,
+    getCountCallback: (row: any) => number,
+    getGUIDCallback: (row: any) => string,
+    getTagsAndDatesCallback: (row: any) => {
+      tags: string[];
+      cdate: number;
+      mdate: number;
+    },
+    getDataNameAndSValueCallback: (row: any) => {
+      name: string;
+      svalue: string;
+    }
+  ): { result: any; process: () => number };
   protected getEntitesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     selectors: Selector[],
@@ -731,6 +787,7 @@ export default abstract class NymphDriver {
     },
     rowFetchCallback: () => any,
     freeResultCallback: () => void,
+    getCountCallback: (row: any) => number,
     getGUIDCallback: (row: any) => string,
     getTagsAndDatesCallback: (row: any) => {
       tags: string[];
@@ -754,6 +811,7 @@ export default abstract class NymphDriver {
     },
     rowFetchCallback: () => any,
     freeResultCallback: () => void,
+    getCountCallback: (row: any) => number,
     getGUIDCallback: (row: any) => string,
     getTagsAndDatesCallback: (row: any) => {
       tags: string[];
@@ -777,6 +835,7 @@ export default abstract class NymphDriver {
     },
     rowFetchCallback: () => any,
     freeResultCallback: () => void,
+    getCountCallback: (row: any) => number,
     getGUIDCallback: (row: any) => string,
     getTagsAndDatesCallback: (row: any) => {
       tags: string[];
@@ -787,7 +846,10 @@ export default abstract class NymphDriver {
       name: string;
       svalue: string;
     }
-  ): { result: any; process: () => ReturnType<T['factorySync']>[] | string[] } {
+  ): {
+    result: any;
+    process: () => ReturnType<T['factorySync']>[] | string[] | number;
+  } {
     if (!this.isConnected()) {
       throw new UnableToConnectError('not connected to DB');
     }
@@ -805,6 +867,7 @@ export default abstract class NymphDriver {
     }
 
     let entities: ReturnType<T['factorySync']>[] | string[] = [];
+    let count = 0;
     const EntityClass =
       options.class ?? (this.nymph.getEntityClass('Entity') as T);
     const etype = EntityClass.ETYPE;
@@ -842,7 +905,14 @@ export default abstract class NymphDriver {
           const guid = entity.guid;
           return {
             result: Promise.resolve(null),
-            process: () => (options.return === 'guid' ? [guid] : [entity]),
+            process: () =>
+              options.return === 'count'
+                ? guid
+                  ? 1
+                  : 0
+                : options.return === 'guid'
+                ? [guid]
+                : [entity],
           };
         }
       }
@@ -856,7 +926,12 @@ export default abstract class NymphDriver {
       result,
       process: () => {
         let row = rowFetchCallback();
-        if (options.return === 'guid') {
+        if (options.return === 'count') {
+          while (row != null) {
+            count += getCountCallback(row);
+            row = rowFetchCallback();
+          }
+        } else if (options.return === 'guid') {
           while (row != null) {
             (entities as string[]).push(getGUIDCallback(row));
             row = rowFetchCallback();
@@ -912,7 +987,7 @@ export default abstract class NymphDriver {
 
         freeResultCallback();
 
-        return entities;
+        return options.return === 'count' ? count : entities;
       },
     };
   }

package/src/driver/testArtifacts.ts

@@ -1319,6 +1319,55 @@ This one's zip code is 92064.`;
     expect(testEntity.$inArray(resultEntity)).toEqual(true);
   });
 
+  it('count return', async () => {
+    await createTestEntities();
+
+    const result = await nymph.getEntities({ class: TestModel });
+
+    // Testing count return...
+    const resultCount = await nymph.getEntities({
+      class: TestModel,
+      return: 'count',
+    });
+    expect(resultCount).toBeGreaterThanOrEqual(1);
+    expect(resultCount).toEqual(result.length);
+
+    const resultSelectors = await nymph.getEntities(
+      { class: TestModel },
+      { type: '&', ref: ['reference', refGuid] }
+    );
+
+    // Testing count return with selectors...
+    const resultSelectorsCount = await nymph.getEntities(
+      { class: TestModel, return: 'count' },
+      { type: '&', ref: ['reference', refGuid] }
+    );
+    expect(resultSelectorsCount).toBeGreaterThanOrEqual(1);
+    expect(resultSelectorsCount).toEqual(resultSelectors.length);
+
+    // Testing count return with limit...
+    const resultSelectorsLimit = await nymph.getEntities({
+      class: TestModel,
+      limit: 1,
+      return: 'count',
+    });
+    expect(resultSelectorsLimit).toEqual(1);
+
+    // Testing count return with limit...
+    const resultSelectorsSingle = await nymph.getEntity({
+      class: TestModel,
+      return: 'count',
+    });
+    expect(resultSelectorsSingle).toEqual(1);
+
+    // Testing empty count...
+    const resultSelectorsEmpty = await nymph.getEntities(
+      { class: TestModel, return: 'count' },
+      { type: '&', ref: ['reference', newGUID()] }
+    );
+    expect(resultSelectorsEmpty).toEqual(0);
+  });
+
   it('guid return', async () => {
     await createTestEntities();
 

package/src/utils.ts

@@ -1,6 +1,7 @@
 import Entity from './Entity';
 import { EntityReference } from './Entity.types';
 import Nymph from './Nymph';
+import { Options, Selector } from './Nymph.types';
 
 export function xor(a: any, b: any): boolean {
   return !!(a && !b) || (!a && b);
@@ -14,6 +15,64 @@ export function uniqueStrings(array: string[]) {
   return Object.keys(obj);
 }
 
+export function classNamesToEntityConstructors(
+  nymph: Nymph,
+  selectors: Selector[]
+): Selector[] {
+  const newSelectors: Selector[] = [];
+
+  for (const curSelector of selectors) {
+    const newSelector: Selector = { type: curSelector.type };
+
+    for (const k in curSelector) {
+      const key = k as keyof Selector;
+      const value = curSelector[key];
+
+      if (key === 'type') {
+        continue;
+      }
+
+      if (value === undefined) {
+        continue;
+      }
+
+      if (key === 'qref' || key === '!qref') {
+        const tmpArr = (
+          Array.isArray(((value as Selector['qref']) ?? [])[0])
+            ? value
+            : [value]
+        ) as [string, [Options, ...Selector[]]][];
+        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 options = { ...qrefOptions, class: QrefEntityClass };
+          if (!newSelector[key]) {
+            newSelector[key] = [];
+          }
+          (newSelector[key] as [string, [Options, ...Selector[]]][]).push([
+            name,
+            [options, ...classNamesToEntityConstructors(nymph, selectors)],
+          ]);
+        }
+      } else if (key === 'selector' || key === '!selector') {
+        const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
+        newSelector[key] = classNamesToEntityConstructors(nymph, tmpArr);
+      } else {
+        // @ts-ignore: ts doesn't know what value is here.
+        newSelector[key] = value;
+      }
+    }
+
+    newSelectors.push(newSelector);
+  }
+
+  return newSelectors;
+}
+
 export function entitiesToReferences(item: any): any {
   if (item instanceof Entity && typeof item.$toReference === 'function') {
     // Convert entities to references.