Initial commit - Event Planner application

2026-03-18 14:55:56 -03:00
commit 86d779eb4d
7548 changed files with 1006324 additions and 0 deletions
--- a/node_modules/@mikro-orm/nestjs/mikro-orm.providers.js
+++ b/node_modules/@mikro-orm/nestjs/mikro-orm.providers.js
@@ -0,0 +1,102 @@
+import { EntityManager, EntitySchema, MetadataStorage, MikroORM } from '@mikro-orm/core';
+import { Scope } from '@nestjs/common';
+import { MIKRO_ORM_MODULE_OPTIONS, getEntityManagerToken, getMikroORMToken, getRepositoryToken, logger, } from './mikro-orm.common.js';
+import { MikroOrmEntitiesStorage } from './mikro-orm.entities.storage.js';
+export function createMikroOrmProvider(contextName, type = MikroORM) {
+    if (!contextName && type !== MikroORM) {
+        return {
+            provide: type,
+            useFactory: orm => orm, // just a simple alias
+            inject: [MikroORM], // depend on the ORM from core package
+        };
+    }
+    return {
+        provide: contextName ? getMikroORMToken(contextName) : type,
+        useFactory: async (options) => {
+            options = { logger: logger.log.bind(logger), ...options };
+            if (options.autoLoadEntities) {
+                options.entities = [
+                    ...(options.entities || []),
+                    ...MikroOrmEntitiesStorage.getEntities(contextName),
+                ];
+                options.entitiesTs = [
+                    ...(options.entitiesTs || []),
+                    ...MikroOrmEntitiesStorage.getEntities(contextName),
+                ];
+                delete options.autoLoadEntities;
+            }
+            return MikroORM.init(options);
+        },
+        inject: [MIKRO_ORM_MODULE_OPTIONS],
+    };
+}
+export function createEntityManagerProvider(scope = Scope.DEFAULT, entityManager = EntityManager, contextName, forkOptions) {
+    if (!contextName && entityManager !== EntityManager) {
+        return {
+            provide: entityManager,
+            scope,
+            useFactory: (em) => em, // just a simple alias, unlike `useExisting` from nest, this works with request scopes too
+            inject: [EntityManager], // depend on the EM from core package
+        };
+    }
+    return {
+        provide: contextName ? getEntityManagerToken(contextName) : entityManager,
+        scope,
+        useFactory: (orm) => (scope === Scope.DEFAULT ? orm.em : orm.em.fork({ useContext: true, ...forkOptions })),
+        inject: [contextName ? getMikroORMToken(contextName) : MikroORM],
+    };
+}
+export function createMikroOrmAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+        return {
+            provide: MIKRO_ORM_MODULE_OPTIONS,
+            useFactory: async (...args) => {
+                const factoryOptions = await options.useFactory(...args);
+                return options.contextName ? { contextName: options.contextName, ...factoryOptions } : factoryOptions;
+            },
+            inject: options.inject || [],
+        };
+    }
+    const inject = [];
+    if (options.useClass || options.useExisting) {
+        inject.push(options.useClass ?? options.useExisting);
+    }
+    return {
+        provide: MIKRO_ORM_MODULE_OPTIONS,
+        useFactory: async (optionsFactory) => await optionsFactory.createMikroOrmOptions(options.contextName),
+        inject,
+    };
+}
+export function createAsyncProviders(options) {
+    if (options.useExisting || options.useFactory) {
+        return [createMikroOrmAsyncOptionsProvider(options)];
+    }
+    if (options.useClass) {
+        return [createMikroOrmAsyncOptionsProvider(options), { provide: options.useClass, useClass: options.useClass }];
+    }
+    throw new Error('Invalid MikroORM async options: one of `useClass`, `useExisting` or `useFactory` should be defined.');
+}
+export function createMikroOrmRepositoryProviders(entities, contextName) {
+    const metadata = Object.values(MetadataStorage.getMetadata());
+    const providers = [];
+    const inject = contextName ? getEntityManagerToken(contextName) : EntityManager;
+    (entities || []).forEach(entity => {
+        const meta = entity instanceof EntitySchema
+            ? entity.meta
+            : (typeof entity === 'function' ? EntitySchema.REGISTRY.get(entity)?.meta : undefined) ?? metadata.find(meta => meta.class === entity);
+        const repository = meta?.repository;
+        if (repository) {
+            providers.push({
+                provide: repository(),
+                useFactory: em => em.getRepository(entity),
+                inject: [inject],
+            });
+        }
+        providers.push({
+            provide: getRepositoryToken(entity, contextName),
+            useFactory: em => em.getRepository(entity),
+            inject: [inject],
+        });
+    });
+    return providers;
+}