Guard yarn database:migrate:prod (#19008)

## Motivations
A lot of self hosters hands up using the `yarn database:migrated:prod`
either manually or through AI assisted debug while they try to upgrade
an instance while their workspace is still blocked in a previous one
Leading to their whole database permanent corruption

## What happened
Replaced the direct call the the typeorm cli to a command calling it
programmatically, adding a layer of security in case a workspace seems
to be blocked in a previous version than the one just before the one
being installed ( e.g 1.0 when you try to upgrade from 1.1 to 1.2 )

For our cloud we still need a way to bypass this security explaining the
-f flag

## Remark
Centralized this logic and refactored creating new services
`WorkspaceVersionService` and `CoreEngineVersionService` that will
become useful for the upcoming upgrade refactor

Related to https://github.com/twentyhq/twenty-infra/pull/529

packages/twenty-server/src/engine/api/graphql/graphql-config/graphql-config.service.ts

@@ -23,8 +23,8 @@ import { useDirectExecution } from 'src/engine/api/graphql/direct-execution/hook
 import { WorkspaceSchemaFactory } from 'src/engine/api/graphql/workspace-schema.factory';
 import { CoreEngineModule } from 'src/engine/core-modules/core-engine.module';
 import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { useSentryTracing } from 'src/engine/core-modules/exception-handler/hooks/use-sentry-tracing';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { useDisableIntrospectionAndSuggestionsForUnauthenticatedUsers } from 'src/engine/core-modules/graphql/hooks/use-disable-introspection-and-suggestions-for-unauthenticated-users.hook';
 import { useGraphQLErrorHandlerHook } from 'src/engine/core-modules/graphql/hooks/use-graphql-error-handler.hook';
 import { useGraphQLQueryTiming } from 'src/engine/core-modules/graphql/hooks/use-graphql-query-timing.hook';

packages/twenty-server/src/engine/constants/upgrade-command-supported-versions.constant.ts

@@ -0,0 +1,10 @@
+export const UPGRADE_COMMAND_SUPPORTED_VERSIONS = [
+  '1.16.0',
+  '1.17.0',
+  '1.18.0',
+  '1.19.0',
+  '1.20.0',
+] as const;
+
+export type UpgradeCommandVersion =
+  (typeof UPGRADE_COMMAND_SUPPORTED_VERSIONS)[number];

packages/twenty-server/src/engine/core-engine-version/core-engine-version.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+
+import { CoreEngineVersionService } from 'src/engine/core-engine-version/services/core-engine-version.service';
+
+@Module({
+  providers: [CoreEngineVersionService],
+  exports: [CoreEngineVersionService],
+})
+export class CoreEngineVersionModule {}

packages/twenty-server/src/engine/core-engine-version/services/core-engine-version.service.ts

@@ -0,0 +1,47 @@
+import { Injectable } from '@nestjs/common';
+
+import { SemVer } from 'semver';
+import { isDefined } from 'twenty-shared/utils';
+
+import { UPGRADE_COMMAND_SUPPORTED_VERSIONS } from 'src/engine/constants/upgrade-command-supported-versions.constant';
+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { getPreviousVersion } from 'src/utils/version/get-previous-version';
+
+@Injectable()
+export class CoreEngineVersionService {
+  constructor(private readonly twentyConfigService: TwentyConfigService) {}
+
+  getCurrentVersion(): SemVer {
+    const appVersion = this.twentyConfigService.get('APP_VERSION');
+
+    if (!isDefined(appVersion)) {
+      throw new Error(
+        'APP_VERSION is not defined, please double check your env variables',
+      );
+    }
+
+    try {
+      return new SemVer(appVersion);
+    } catch {
+      throw new Error(`APP_VERSION is not a valid semver: "${appVersion}"`);
+    }
+  }
+
+  getPreviousVersion(): SemVer {
+    const currentAppVersion = this.getCurrentVersion();
+    const currentVersionMajorMinor = `${currentAppVersion.major}.${currentAppVersion.minor}.0`;
+
+    const previousVersion = getPreviousVersion({
+      currentVersion: currentVersionMajorMinor,
+      versions: [...UPGRADE_COMMAND_SUPPORTED_VERSIONS],
+    });
+
+    if (!isDefined(previousVersion)) {
+      throw new Error(
+        `No previous version found for version ${currentAppVersion}. Available versions: ${UPGRADE_COMMAND_SUPPORTED_VERSIONS.join(', ')}`,
+      );
+    }
+
+    return previousVersion;
+  }
+}

packages/twenty-server/src/engine/workspace-manager/workspace-version/services/workspace-version.service.ts

@@ -0,0 +1,83 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { isDefined } from 'twenty-shared/utils';
+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
+import { In, Repository } from 'typeorm';
+
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { compareVersionMajorAndMinor } from 'src/utils/version/compare-version-minor-and-major';
+
+@Injectable()
+export class WorkspaceVersionService {
+  private readonly logger = new Logger(WorkspaceVersionService.name);
+
+  constructor(
+    @InjectRepository(WorkspaceEntity)
+    private readonly workspaceRepository: Repository<WorkspaceEntity>,
+  ) {}
+
+  async hasActiveOrSuspendedWorkspaces(): Promise<boolean> {
+    return this.workspaceRepository.exists({
+      where: {
+        activationStatus: In([
+          WorkspaceActivationStatus.ACTIVE,
+          WorkspaceActivationStatus.SUSPENDED,
+        ]),
+      },
+    });
+  }
+
+  async getWorkspacesBelowVersion(
+    version: string,
+  ): Promise<Pick<WorkspaceEntity, 'id' | 'displayName' | 'version'>[]> {
+    const allActiveOrSuspendedWorkspaces =
+      await this.loadActiveOrSuspendedWorkspaces();
+
+    if (allActiveOrSuspendedWorkspaces.length === 0) {
+      this.logger.log(
+        'No workspaces found. Running migrations for fresh installation.',
+      );
+
+      return [];
+    }
+
+    return allActiveOrSuspendedWorkspaces.filter((workspace) => {
+      if (!isDefined(workspace.version)) {
+        return true;
+      }
+
+      try {
+        const versionCompareResult = compareVersionMajorAndMinor(
+          workspace.version,
+          version,
+        );
+
+        return versionCompareResult === 'lower';
+      } catch (error) {
+        this.logger.error(
+          `Error checking workspace ${workspace.id} version: ${error.message}`,
+        );
+
+        return true;
+      }
+    });
+  }
+
+  private async loadActiveOrSuspendedWorkspaces(): Promise<
+    Pick<WorkspaceEntity, 'id' | 'version' | 'displayName'>[]
+  > {
+    return this.workspaceRepository.find({
+      select: ['id', 'version', 'displayName'],
+      where: {
+        activationStatus: In([
+          WorkspaceActivationStatus.ACTIVE,
+          WorkspaceActivationStatus.SUSPENDED,
+        ]),
+      },
+      order: {
+        id: 'ASC',
+      },
+    });
+  }
+}

packages/twenty-server/src/engine/workspace-manager/workspace-version/workspace-version.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-version/services/workspace-version.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([WorkspaceEntity])],
+  providers: [WorkspaceVersionService],
+  exports: [WorkspaceVersionService],
+})
+export class WorkspaceVersionModule {}