@nymphjs/nymph 1.0.0-beta.13 → 1.0.0-beta.130

package/src/utils.ts

@@ -1,7 +1,6 @@
-import Entity from './Entity';
-import { EntityReference } from './Entity.types';
-import Nymph from './Nymph';
-import { Options, Selector } from './Nymph.types';
+import Entity from './Entity.js';
+import { EntityReference } from './Entity.types.js';
+import Nymph from './Nymph.js';
 
 export function xor(a: any, b: any): boolean {
   return !!(a && !b) || (!a && b);
@@ -15,75 +14,90 @@ 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;
-      }
+export function entityConstructorsToClassNames(item: any): any {
+  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
+    return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Convert entity classes to class references.
+    return ['nymph_class_reference', item.class];
+  } else if (item instanceof Entity) {
+    // Don't touch entities.
+    return item;
+  } else if (Array.isArray(item)) {
+    // Recurse into lower arrays.
+    return item.map((entry) => entityConstructorsToClassNames(entry));
+  } else if (item instanceof Object) {
+    let newObj = Object.create(item);
+    for (let [key, value] of Object.entries(item)) {
+      newObj[key] = entityConstructorsToClassNames(value);
     }
-
-    newSelectors.push(newSelector);
+    return newObj;
   }
+  // Not an entity or array, just return it.
+  return item;
+}
 
-  return newSelectors;
+export function classNamesToEntityConstructors<T extends any>(
+  nymph: Nymph,
+  item: T,
+  enforceRestEnabledFlag = false,
+): T {
+  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
+    return item;
+  } else if (
+    Array.isArray(item) &&
+    item.length === 2 &&
+    item[0] === 'nymph_class_reference' &&
+    typeof item[1] === 'string'
+  ) {
+    // Convert class references to entity classes.
+    const EntityClass = nymph.getEntityClass(item[1]);
+    if (enforceRestEnabledFlag && !EntityClass.restEnabled) {
+      throw new Error('Not accessible.');
+    }
+    return EntityClass as T;
+  } else if (item instanceof Entity) {
+    // Don't touch entities.
+    return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Don't touch Entity classes.
+    return item;
+  } else if (Array.isArray(item)) {
+    // Recurse into lower arrays.
+    return item.map((entry) =>
+      classNamesToEntityConstructors(nymph, entry, enforceRestEnabledFlag),
+    ) as T;
+  } else if (item instanceof Object) {
+    let newObj = Object.create(item);
+    for (let [key, value] of Object.entries(item)) {
+      newObj[key] = classNamesToEntityConstructors(
+        nymph,
+        value,
+        enforceRestEnabledFlag,
+      );
+    }
+    return newObj;
+  }
+  // Not an entity or array, just return it.
+  return item;
 }
 
-export function entitiesToReferences(item: any): any {
-  if (item instanceof Entity && typeof item.$toReference === 'function') {
+export function entitiesToReferences(item: any, existingOnly?: boolean): any {
+  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
+    return item;
+  } else if (item instanceof Entity) {
     // Convert entities to references.
-    return item.$toReference();
+    return item.$toReference(existingOnly);
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Don't touch Entity classes.
+    return item;
   } else if (Array.isArray(item)) {
     // Recurse into lower arrays.
-    return item.map((entry) => entitiesToReferences(entry));
+    return item.map((entry) => entitiesToReferences(entry, existingOnly));
   } else if (item instanceof Object) {
     let newObj = Object.create(item);
     for (let [key, value] of Object.entries(item)) {
-      newObj[key] = entitiesToReferences(value);
+      newObj[key] = entitiesToReferences(value, existingOnly);
     }
     return newObj;
   }
@@ -94,13 +108,19 @@ export function entitiesToReferences(item: any): any {
 export function referencesToEntities(
   item: any,
   nymph: Nymph,
-  useSkipAc = false
+  useSkipAc = false,
+  enforceRestEnabledFlag = false,
 ): any {
-  if (Array.isArray(item)) {
+  if (item == null || Buffer.isBuffer(item) || ArrayBuffer.isView(item)) {
+    return item;
+  } else if (Array.isArray(item)) {
     // Check if it's a reference.
     if (item[0] === 'nymph_entity_reference') {
       try {
         const EntityClass = nymph.getEntityClass(item[2]);
+        if (enforceRestEnabledFlag && !EntityClass.restEnabled) {
+          throw new Error('Not accessible.');
+        }
         const entity = EntityClass.factoryReference(item as EntityReference);
         entity.$useSkipAc(useSkipAc);
         entity.$nymph = nymph;
@@ -110,12 +130,27 @@ export function referencesToEntities(
       }
     } else {
       // Recurse into lower arrays.
-      return item.map((entry) => referencesToEntities(entry, nymph, useSkipAc));
+      return item.map((entry) =>
+        referencesToEntities(entry, nymph, useSkipAc, enforceRestEnabledFlag),
+      );
     }
-  } else if (Entity && item instanceof Object && !(item instanceof Entity)) {
+  } else if (item instanceof Entity) {
+    // Don't touch entities.
+    return item;
+  } else if (typeof item === 'function' && item.prototype instanceof Entity) {
+    // Don't touch Entity classes.
+    return item;
+  } else if (item instanceof Object) {
+    let newObj = Object.create(item);
     for (let [key, value] of Object.entries(item)) {
-      item[key] = referencesToEntities(value, nymph);
+      newObj[key] = referencesToEntities(
+        value,
+        nymph,
+        useSkipAc,
+        enforceRestEnabledFlag,
+      );
     }
+    return newObj;
   }
   // Not an array, just return it.
   return item;

package/tsconfig.json

@@ -2,10 +2,13 @@
   "extends": "@tsconfig/recommended/tsconfig.json",
 
   "compilerOptions": {
-    "lib": ["ES2021"],
-    "target": "ES2021",
+    "types": ["node", "jest"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": ["es2024"],
+    "target": "es2024",
     "noImplicitAny": true,
-    "removeComments": true,
+    "removeComments": false,
     "sourceMap": true,
     "outDir": "dist",
     "resolveJsonModule": true,

package/typedoc.json

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

package/dist/conf/d.d.ts

@@ -1,6 +0,0 @@
-export interface Config {
-    cache: boolean;
-    cacheThreshold: number;
-    cacheLimit: number;
-    emptyListError: boolean;
-}

package/dist/conf/d.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=d.js.map

package/dist/conf/d.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"d.js","sourceRoot":"","sources":["../../src/conf/d.ts"],"names":[],"mappings":""}

package/src/conf/d.ts

@@ -1,24 +0,0 @@
-/**
- * Nymph Config
- */
-export interface Config {
-  /**
-   * Cache recently retrieved entities to speed up database queries. Uses more
-   * memory.
-   */
-  cache: boolean;
-  /**
-   * Cache entities after they're accessed this many times.
-   */
-  cacheThreshold: number;
-  /**
-   * The number of recently retrieved entities to cache. If you're running out
-   * of memory, try lowering this value. 0 means unlimited.
-   */
-  cacheLimit: number;
-  /**
-   * When querying for multiple entities with NymphREST, if the list is empty,
-   * return a 404 error.
-   */
-  emptyListError: boolean;
-}