@nymphjs/nymph 1.0.0-alpha.4 → 1.0.0-alpha.40

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/index.ts

@@ -17,4 +17,7 @@ export * from './Nymph';
 import Nymph from './Nymph';
 export { 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/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.