Migrate to a monorepo structure (#2909)

packages/twenty-server/src/integrations/logger/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './logger.interface';

packages/twenty-server/src/integrations/logger/interfaces/logger.interface.ts

@@ -0,0 +1,9 @@
+export enum LoggerDriverType {
+  Console = 'console',
+}
+
+export interface ConsoleDriverFactoryOptions {
+  type: LoggerDriverType.Console;
+}
+
+export type LoggerModuleOptions = ConsoleDriverFactoryOptions;

packages/twenty-server/src/integrations/logger/logger.constants.ts

@@ -0,0 +1 @@
+export const LOGGER_DRIVER = Symbol('LOGGER_DRIVER');

packages/twenty-server/src/integrations/logger/logger.module-definition.ts

@@ -0,0 +1,25 @@
+import {
+  ConfigurableModuleBuilder,
+  FactoryProvider,
+  ModuleMetadata,
+} from '@nestjs/common';
+
+import { LoggerModuleOptions } from './interfaces';
+
+export const {
+  ConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN,
+  OPTIONS_TYPE,
+  ASYNC_OPTIONS_TYPE,
+} = new ConfigurableModuleBuilder<LoggerModuleOptions>({
+  moduleName: 'LoggerService',
+})
+  .setClassMethodName('forRoot')
+  .build();
+
+export type LoggerModuleAsyncOptions = {
+  useFactory: (
+    ...args: any[]
+  ) => LoggerModuleOptions | Promise<LoggerModuleOptions>;
+} & Pick<ModuleMetadata, 'imports'> &
+  Pick<FactoryProvider, 'inject'>;

packages/twenty-server/src/integrations/logger/logger.module-factory.ts

@@ -0,0 +1,28 @@
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
+import {
+  LoggerModuleOptions,
+  LoggerDriverType,
+} from 'src/integrations/logger/interfaces';
+
+/**
+ * Logger Module factory
+ * @param environment
+ * @returns LoggerModuleOptions
+ */
+export const loggerModuleFactory = async (
+  environmentService: EnvironmentService,
+): Promise<LoggerModuleOptions> => {
+  const driverType = environmentService.getLoggerDriverType();
+
+  switch (driverType) {
+    case LoggerDriverType.Console: {
+      return {
+        type: LoggerDriverType.Console,
+      };
+    }
+    default:
+      throw new Error(
+        `Invalid logger driver type (${driverType}), check your .env file`,
+      );
+  }
+};

packages/twenty-server/src/integrations/logger/logger.module.ts

@@ -0,0 +1,58 @@
+import { DynamicModule, Global, ConsoleLogger, Module } from '@nestjs/common';
+
+import { LoggerDriverType } from 'src/integrations/logger/interfaces';
+
+import { LoggerService } from './logger.service';
+import { LOGGER_DRIVER } from './logger.constants';
+import {
+  ASYNC_OPTIONS_TYPE,
+  ConfigurableModuleClass,
+  OPTIONS_TYPE,
+} from './logger.module-definition';
+
+@Global()
+@Module({
+  providers: [LoggerService],
+  exports: [LoggerService],
+})
+export class LoggerModule extends ConfigurableModuleClass {
+  static forRoot(options: typeof OPTIONS_TYPE): DynamicModule {
+    const provider = {
+      provide: LOGGER_DRIVER,
+      useValue:
+        options.type === LoggerDriverType.Console
+          ? new ConsoleLogger()
+          : undefined,
+    };
+    const dynamicModule = super.forRoot(options);
+
+    return {
+      ...dynamicModule,
+      providers: [...(dynamicModule.providers ?? []), provider],
+    };
+  }
+
+  static forRootAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+    const provider = {
+      provide: LOGGER_DRIVER,
+      useFactory: async (...args: any[]) => {
+        const config = await options?.useFactory?.(...args);
+
+        if (!config) {
+          return null;
+        }
+
+        return config?.type === LoggerDriverType.Console
+          ? new ConsoleLogger()
+          : undefined;
+      },
+      inject: options.inject || [],
+    };
+    const dynamicModule = super.forRootAsync(options);
+
+    return {
+      ...dynamicModule,
+      providers: [...(dynamicModule.providers ?? []), provider],
+    };
+  }
+}

packages/twenty-server/src/integrations/logger/logger.service.spec.ts

@@ -0,0 +1,26 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { LoggerService } from './logger.service';
+import { LOGGER_DRIVER } from './logger.constants';
+
+describe('LoggerService', () => {
+  let service: LoggerService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        LoggerService,
+        {
+          provide: LOGGER_DRIVER,
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    service = module.get<LoggerService>(LoggerService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

packages/twenty-server/src/integrations/logger/logger.service.ts

@@ -0,0 +1,49 @@
+import {
+  Inject,
+  Injectable,
+  LogLevel,
+  LoggerService as LoggerServiceInterface,
+} from '@nestjs/common';
+
+import { LOGGER_DRIVER } from './logger.constants';
+
+@Injectable()
+export class LoggerService implements LoggerServiceInterface {
+  constructor(@Inject(LOGGER_DRIVER) private driver: LoggerServiceInterface) {}
+
+  log(message: any, category: string, ...optionalParams: any[]) {
+    this.driver.log.apply(this.driver, [message, category, ...optionalParams]);
+  }
+
+  error(message: any, category: string, ...optionalParams: any[]) {
+    this.driver.error.apply(this.driver, [
+      message,
+      category,
+      ...optionalParams,
+    ]);
+  }
+
+  warn(message: any, category: string, ...optionalParams: any[]) {
+    this.driver.warn.apply(this.driver, [message, category, ...optionalParams]);
+  }
+
+  debug?(message: any, category: string, ...optionalParams: any[]) {
+    this.driver.debug?.apply(this.driver, [
+      message,
+      category,
+      ...optionalParams,
+    ]);
+  }
+
+  verbose?(message: any, category: string, ...optionalParams: any[]) {
+    this.driver.verbose?.apply(this.driver, [
+      message,
+      category,
+      ...optionalParams,
+    ]);
+  }
+
+  setLogLevels(levels: LogLevel[]) {
+    this.driver.setLogLevels?.apply(this.driver, [levels]);
+  }
+}