kindagoose

1
import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
2
import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
3
import { addModelToTypegoose, buildSchema, getName } from '@typegoose/typegoose';
4
import { ModelType } from '@typegoose/typegoose/lib/types';
5
import { Connection } from 'mongoose';
6

7
import { EVENT_TRACKER_FOR_KEY, POST_METADATA_KEY, PRE_METADATA_KEY } from '../constants/kindagoose.constants';
8
import { AnyClass } from '../interfaces/any-class.interface';
9
import { getModelToken } from './get-model-token';
10

11
export const discriminatorFactory = (discriminator: AnyClass, connectionName?: string) => {
12
    return (
13
        connection: Connection,
14
        model: ModelType<any>,
15
        discoveryService: DiscoveryService,
16
        reflector: Reflector,
17
        metadataScanner: MetadataScanner,
18
    ) => {
19
        const existingDiscriminator = discoveryService
20
            .getProviders()
21
            .find(provider => provider.token === getModelToken(discriminator.name, connectionName))?.instance;
22

23
        if (existingDiscriminator) {
24
            return existingDiscriminator;
25
        }
26

27
        const providers = discoveryService.getProviders().filter(provider => provider.instance);
28
        let tracker: InstanceWrapper | null = null;
29

30
        for (const provider of providers) {
31
            const trackerMetadata = reflector.get(EVENT_TRACKER_FOR_KEY, provider.instance.constructor);
32

33
            if (trackerMetadata === discriminator.name) {
34
                tracker = provider;
35
                break;
36
            }
37
        }
38

39
        const mongooseDiscriminatorSchema = buildSchema(discriminator);
40

41
        if (tracker) {
42
            const { instance } = tracker;
43

44
            const methodNames = metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance));
45

46
            for (const methodName of methodNames) {
47
                const propertyPreMetadata = reflector.get(PRE_METADATA_KEY, instance[methodName]) || [];
48
                const propertyPostMetadata = reflector.get(POST_METADATA_KEY, instance[methodName]) || [];
49

50
                for (const preEventName of propertyPreMetadata) {
51
                    mongooseDiscriminatorSchema.pre(preEventName, instance[methodName].bind(instance));
52
                }
53

54
                for (const postEventName of propertyPostMetadata) {
55
                    mongooseDiscriminatorSchema.post(postEventName, instance[methodName].bind(instance));
56
                }
57
            }
58
        }
59

60
        return addModelToTypegoose(
61
            model.discriminator(getName(discriminator), mongooseDiscriminatorSchema),
62
            discriminator,
63
        );
64
    };
65
};
66