@nymphjs/nymph 1.0.0-beta.9 → 1.0.0-beta.91

package/src/errors/EntityUniqueConstraintError.ts

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

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

@@ -1,15 +1,19 @@
-export * from './ClassNotAvailableError';
+export * from './ClassNotAvailableError.js';
 
-export * from './EntityConflictError';
+export * from './EntityConflictError.js';
 
-export * from './EntityInvalidDataError';
+export * from './EntityInvalidDataError.js';
 
-export * from './EntityIsSleepingReferenceError';
+export * from './EntityIsSleepingReferenceError.js';
 
-export * from './InvalidParametersError';
+export * from './EntityUniqueConstraintError.js';
 
-export * from './NotConfiguredError';
+export * from './InvalidParametersError.js';
 
-export * from './QueryFailedError';
+export * from './InvalidStateError.js';
 
-export * from './UnableToConnectError';
+export * from './NotConfiguredError.js';
+
+export * from './QueryFailedError.js';
+
+export * from './UnableToConnectError.js';

package/src/index.ts

@@ -1,20 +1,20 @@
-export * from './conf';
-export * from './driver';
-export * from './errors';
+export * from './conf/index.js';
+export * from './driver/index.js';
+export * from './errors/index.js';
 
-export * from './Entity.types';
+export * from './Entity.types.js';
 
-export * from './Entity';
-import Entity from './Entity';
+export * from './Entity.js';
+import Entity from './Entity.js';
 export { Entity };
 
-export * from './Nymph.types';
+export * from './Nymph.types.js';
 
-export * from './Nymph';
-import Nymph from './Nymph';
+export * from './Nymph.js';
+import Nymph from './Nymph.js';
 export { Nymph };
 
-import nymphJoiProps from './nymphJoiProps';
+import nymphJoiProps from './nymphJoiProps.js';
 export { nymphJoiProps };
 
-export * from './utils';
+export * from './utils.js';

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

@@ -1,4 +1,4 @@
-import Entity from './Entity';
+import Entity from './Entity.js';
 
 export type TestModelData = {
   name?: string;
@@ -17,8 +17,10 @@ export type TestModelData = {
     [k: string]: TestModel & TestModelData;
   };
   parent?: TestModel & TestModelData;
-  // For Import/Export Tests.
+  // For import/export tests.
   index?: string;
+  // For uniqueness tests.
+  uniques?: string[];
 };
 
 /**
@@ -34,21 +36,16 @@ export class TestModel extends Entity<TestModelData> {
   protected $protectedTags = ['test', 'notag'];
   protected $allowlistTags? = ['newtag'];
 
-  static async factory(guid?: string): Promise<TestModel & TestModelData> {
-    return (await super.factory(guid)) as TestModel & TestModelData;
-  }
+  constructor() {
+    super();
 
-  static factorySync(guid?: string): TestModel & TestModelData {
-    return super.factorySync(guid) as TestModel & TestModelData;
+    this.$addTag('test');
+    this.$data.boolean = true;
+    this.$data.uniques = [];
   }
 
-  constructor(guid?: string) {
-    super(guid);
-
-    if (this.guid == null) {
-      this.$addTag('test');
-      this.$data.boolean = true;
-    }
+  public async $getUniques() {
+    return this.$data.uniques ?? [];
   }
 
   public $useProtectedData() {
@@ -77,12 +74,14 @@ export class TestModel extends Entity<TestModelData> {
 export class TestBModel extends TestModel {
   static ETYPE = 'test_b_model';
   static class = 'TestBModel';
+}
 
-  static async factory(guid?: string): Promise<TestBModel & TestModelData> {
-    return (await super.factory(guid)) as TestBModel & TestModelData;
-  }
+export type TestEmptyModelData = {};
 
-  static factorySync(guid?: string): TestBModel & TestModelData {
-    return super.factorySync(guid) as TestBModel & TestModelData;
-  }
+/**
+ * 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';
 }

package/src/testMocks.ts

@@ -1,10 +1,15 @@
 import { guid } from '@nymphjs/guid';
 
-import type Nymph from './Nymph';
-import { EntityConstructor, EntityInterface, EntityJson } from './Entity.types';
-import { Options, Selector } from './Nymph.types';
-import { ClassNotAvailableError } from './errors';
-import Entity from './Entity';
+import type Nymph from './Nymph.js';
+import type { EntityInstanceType } from './Entity.js';
+import type {
+  EntityConstructor,
+  EntityInterface,
+  EntityJson,
+} from './Entity.types.js';
+import { Options, Selector } from './Nymph.types.js';
+import { ClassNotAvailableError } from './errors/index.js';
+import Entity from './Entity.js';
 
 const entities: { [k: string]: EntityJson } = {};
 
@@ -15,43 +20,43 @@ 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<EntityInstanceType<T> | 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<EntityInstanceType<T> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): ReturnType<T['factorySync']> | string | null {
+  ): Promise<EntityInstanceType<T> | string | null> {
     const guid =
       typeof selectors[0] === 'string' ? selectors[0] : selectors[0].guid;
     if (!options || !guid || typeof guid !== 'string' || !(guid in entities)) {
       return null;
     }
 
-    const entity: EntityInterface = (
-      (options.class as T) ?? this.nymph.getEntityClass('Entity')
+    const entity = (
+      (options.class ?? this.nymph.getEntityClass('Entity')) as T
     ).factorySync();
     const entityJson = entities[guid];
     entity.guid = guid;
     entity.cdate = entityJson.cdate;
     entity.mdate = entityJson.mdate;
     entity.tags = entityJson.tags;
-    entity.$putData(entityJson.data, {});
+    entity.$putData(entityJson.data, {}, 'server');
 
-    return entity as ReturnType<T['factorySync']>;
+    return entity as EntityInstanceType<T>;
   }
 }
 
@@ -68,24 +73,44 @@ export class MockNymph {
     this.Entity = this.addEntityClass(Entity);
   }
 
-  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+  public addEntityClass<T extends EntityConstructor>(EntityClass: T): T {
     const nymph = this;
-    class NymphEntity extends entityClass {
+    this.entityClasses[EntityClass.class] = class extends EntityClass {
       static nymph: Nymph = nymph as unknown as Nymph;
 
       constructor(...args: any[]) {
         super(...args);
       }
+    };
+    return this.entityClasses[EntityClass.class] as T;
+  }
+
+  public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
+  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];
     }
-    this.entityClasses[entityClass.class] = NymphEntity;
-    return NymphEntity;
+    throw new ClassNotAvailableError(`Tried to use missing class "${key}".`);
   }
 
-  public getEntityClass(className: string): EntityConstructor {
-    if (className in this.entityClasses) {
-      return this.entityClasses[className];
+  public getEntityClassByEtype(etype: string): EntityConstructor {
+    for (const EntityClass of Object.values(this.entityClasses)) {
+      if (EntityClass.ETYPE === etype) {
+        return EntityClass;
+      }
     }
-    throw new ClassNotAvailableError('Tried to use class: ' + className);
+    throw new ClassNotAvailableError(
+      `Tried to use missing class by etype "${etype}".`,
+    );
   }
 
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
@@ -95,21 +120,21 @@ export class MockNymph {
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']> | null>;
+  ): Promise<EntityInstanceType<T> | 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
-  ): Promise<ReturnType<T['factorySync']> | null>;
+    guid: string,
+  ): Promise<EntityInstanceType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): Promise<ReturnType<T['factorySync']> | string | null> {
+  ): Promise<EntityInstanceType<T> | 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/type/locutus.d.ts

@@ -0,0 +1,3 @@
+declare module 'locutus/php/datetime/strtotime.js' {
+  export default function (str: string, now?: number): number;
+}

package/src/utils.ts

@@ -1,7 +1,7 @@
-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';
+import { Options, Selector } from './Nymph.types.js';
 
 export function xor(a: any, b: any): boolean {
   return !!(a && !b) || (!a && b);
@@ -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;
@@ -73,17 +87,22 @@ export function classNamesToEntityConstructors(
   return newSelectors;
 }
 
-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 &&
+    typeof item.$toReference === 'function'
+  ) {
     // Convert entities to references.
-    return item.$toReference();
+    return item.$toReference(existingOnly);
   } 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,9 +113,11 @@ export function entitiesToReferences(item: any): any {
 export function referencesToEntities(
   item: any,
   nymph: Nymph,
-  useSkipAc = false
+  useSkipAc = 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 {

package/tsconfig.json

@@ -2,10 +2,12 @@
   "extends": "@tsconfig/recommended/tsconfig.json",
 
   "compilerOptions": {
-    "lib": ["ES2021"],
-    "target": "ES2021",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "target": "ES2022",
     "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"]
+}