@nymphjs/nymph/dist/testMocks.js

Nymph.js - Nymph ORM

import { guid } from '@nymphjs/guid';
import { ClassNotAvailableError } from './errors/index.js';
import Entity from './Entity.js';
const entities = {};
export class MockNymphDriver {
    nymph;
    constructor(nymph) {
        this.nymph = nymph;
    }
    async getEntity(options = {}, ...selectors) {
        const guid = typeof selectors[0] === 'string' ? selectors[0] : selectors[0].guid;
        if (!options || !guid || typeof guid !== 'string' || !(guid in entities)) {
            return null;
        }
        const entity = (options.class ?? this.nymph.getEntityClass('Entity')).factorySync();
        const entityJson = entities[guid];
        entity.guid = guid;
        entity.cdate = entityJson.cdate;
        entity.mdate = entityJson.mdate;
        entity.tags = entityJson.tags;
        entity.$putData(entityJson.data, {}, 'server');
        return entity;
    }
}
export class MockNymph {
    entityClasses = {};
    driver;
    Tilmeld = undefined;
    Entity;
    constructor() {
        this.driver = new MockNymphDriver(this);
        // class NymphEntity extends Entity {}
        this.Entity = this.addEntityClass(Entity);
    }
    addEntityClass(EntityClass) {
        const nymph = this;
        this.entityClasses[EntityClass.class] = class extends EntityClass {
            static nymph = nymph;
            constructor(...args) {
                super(...args);
            }
        };
        return this.entityClasses[EntityClass.class];
    }
    getEntityClass(className) {
        let key = null;
        if (typeof className === 'string') {
            key = className;
        }
        else {
            key = className.class;
        }
        if (key in this.entityClasses) {
            return this.entityClasses[key];
        }
        throw new ClassNotAvailableError(`Tried to use missing class "${key}".`);
    }
    getEntityClassByEtype(etype) {
        for (const EntityClass of Object.values(this.entityClasses)) {
            if (EntityClass.ETYPE === etype) {
                return EntityClass;
            }
        }
        throw new ClassNotAvailableError(`Tried to use missing class by etype "${etype}".`);
    }
    async getEntity(options = {}, ...selectors) {
        // @ts-ignore: The selector type is correct here.
        return await this.driver.getEntity(options, ...selectors);
    }
    async saveEntity(entity) {
        const className = entity.constructor.class;
        if (entity.guid == null) {
            entity.guid = guid();
            entity.cdate = Date.now();
        }
        else if (entity.guid in entities &&
            (entity.mdate ?? 0) < (entities[entity.guid].mdate ?? 0)) {
            return false;
        }
        entity.mdate = Date.now();
        const entityJson = {
            class: className,
            guid: entity.guid,
            cdate: entity.cdate,
            mdate: entity.mdate,
            tags: [...entity.tags],
            data: JSON.parse(JSON.stringify(entity.$getData(true))),
        };
        entities[entity.guid] = entityJson;
        return true;
    }
    async deleteEntity(entity) {
        if (entity.guid != null && entity.guid in entities) {
            delete entities[entity.guid];
            return true;
        }
        return false;
    }
}
//# sourceMappingURL=testMocks.js.map