@ludeo/cloud-common 1.1.143 → 1.2.1

package/src/v4/events/cloud-machine-auth-ready.ts

@@ -0,0 +1,38 @@
+import { IsOptional, IsString, IsUUID } from "class-validator";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra";
+import { CloudResourceContext } from "../contexts";
+import { CreateGameResourceRequestPayload } from "./create-game-resource-request";
+
+class CloudAuthReadyPayload {
+  @IsUUID()
+  authToken: string;
+
+  @IsString()
+  sessionToken: string;
+
+  // Backwards compatibility - remove once ticket is done
+  @IsUUID()
+  resourceId: string;
+
+  @IsOptional()
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  gameResourceCreationPayload?: CreateGameResourceRequestPayload;
+}
+
+export class CloudMachineAuthReady extends LudeoEvent {
+  static readonly EVENT_NAME = "authentication.cloud-machine-auth-ready";
+
+  constructor(payload: CloudAuthReadyPayload, context: CloudResourceContext) {
+    super(CloudMachineAuthReady.EVENT_NAME);
+
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudAuthReadyPayload)
+  public payload: CloudAuthReadyPayload;
+
+  @ValidateNestedType(() => CloudResourceContext)
+  public context: CloudResourceContext;
+}

package/src/v4/events/cloud-session-allocated.ts

@@ -0,0 +1,34 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { AwsAllocationData, CloudProviderAllocationData } from "../types";
+import { IsOptional, IsString } from "class-validator";
+
+export class CloudSessionAllocatedPayload {
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData?: CloudProviderAllocationData;
+
+  @IsString()
+  @IsOptional()
+  region?: string;
+}
+
+export class CloudSessionAllocated extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.cloud-session-allocated";
+
+  constructor(
+    payload: CloudSessionAllocatedPayload,
+    context: CloudSessionContext,
+  ) {
+    super(CloudSessionAllocated.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionAllocatedPayload)
+  payload: CloudSessionAllocatedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/v4/events/cloud-session-created.ts

@@ -0,0 +1,20 @@
+import { LudeoEvent } from "../../infra";
+import { ValidateNestedType } from "../../decorators";
+import { CloudSession } from "../types";
+import { CloudSessionContext } from "../contexts";
+
+export class CloudSessionCreated extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.cloud-session-created";
+
+  constructor(payload: CloudSession, context: CloudSessionContext) {
+    super(CloudSessionCreated.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSession)
+  payload: CloudSession;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/v4/events/cloud-session-ended.ts

@@ -0,0 +1,34 @@
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudSessionContext } from "../contexts";
+import { IsUUID } from "class-validator";
+
+export class CloudSessionEndedPayload {
+  @IsUUID()
+  cloudSessionId: string;
+
+  @IsUUID()
+  gameId: string;
+
+  @IsUUID()
+  userId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+}
+
+export class CloudSessionEnded extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.cloud-session-ended";
+
+  constructor(payload: CloudSessionEndedPayload, context: CloudSessionContext) {
+    super(CloudSessionEnded.EVENT_NAME);
+    this.context = context;
+    this.payload = payload;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => CloudSessionEndedPayload)
+  payload: CloudSessionEndedPayload;
+}

package/src/v4/events/cloud-session-optimal-region-selected.ts

@@ -0,0 +1,29 @@
+import { LudeoEvent } from "../../infra";
+import { CloudSessionContext } from "../contexts";
+import { IsString } from "class-validator";
+import { ValidateNestedType } from "../../decorators";
+
+class CloudSessionOptimalRegionSelectedPayload {
+  @IsString()
+  region: string;
+}
+
+export class CloudSessionOptimalRegionSelected extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.cloud-session-optimal-region-selected";
+
+  constructor(
+    payload: CloudSessionOptimalRegionSelectedPayload,
+    context: CloudSessionContext,
+  ) {
+    super(CloudSessionOptimalRegionSelected.EVENT_NAME);
+    this.context = context;
+    this.payload = payload;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => CloudSessionOptimalRegionSelectedPayload)
+  payload: CloudSessionOptimalRegionSelectedPayload;
+}

package/src/v4/events/cloud-session-provider-requested.ts

@@ -0,0 +1,37 @@
+import { IsEnum, IsString, IsUUID } from "class-validator";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { CloudProvider } from "../types";
+
+export class CloudSessionProviderRequestedPayload {
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsString()
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsString()
+  region: string;
+}
+
+export class CloudSessionProviderRequested extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.cloud-session-provider-requested";
+
+  constructor(
+    payload: CloudSessionProviderRequestedPayload,
+    context: CloudSessionContext
+  ) {
+    super(CloudSessionProviderRequested.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionProviderRequestedPayload)
+  payload: CloudSessionProviderRequestedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/v4/events/cloud-session-timeout-task.ts

@@ -0,0 +1,26 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class CloudSessionTimeoutEventTaskEventPayload {
+  @IsUUID()
+  cloudSessionId: string;
+}
+
+export class CloudSessionTimeoutTask extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.cloud-session-timeout-task";
+
+  constructor(
+    payload: CloudSessionTimeoutEventTaskEventPayload,
+    context: never,
+  ) {
+    super(CloudSessionTimeoutTask.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => CloudSessionTimeoutEventTaskEventPayload)
+  payload: CloudSessionTimeoutEventTaskEventPayload;
+}

package/src/v4/events/create-game-resource-request.ts

@@ -0,0 +1,46 @@
+import { IsUUID, IsEnum } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProviderSettings,
+  CloudProvider,
+} from "../types";
+
+export class CreateGameResourceRequestPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsUUID()
+  cloudToken: string;
+}
+
+export class CreateGameResourceRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-game-resource-request";
+
+  constructor(
+    payload: CreateGameResourceRequestPayload,
+    context: CloudResourceContext
+  ) {
+    super(CreateGameResourceRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  payload: CreateGameResourceRequestPayload;
+}

package/src/v4/events/create-games-request.ts

@@ -0,0 +1,29 @@
+import { IsNumber, IsUUID } from "class-validator";
+
+import { CloudPoolContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class CreateGamesRequestPayload {
+  @IsUUID()
+  poolId: string;
+
+  @IsNumber()
+  quantity: number;
+}
+
+export class CreateGamesRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-games-request";
+
+  constructor(payload: CreateGamesRequestPayload, context: CloudPoolContext) {
+    super(CreateGamesRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudPoolContext)
+  context: CloudPoolContext;
+
+  @ValidateNestedType(() => CreateGamesRequestPayload)
+  payload: CreateGamesRequestPayload;
+}

package/src/v4/events/create-ludeos-request.ts

@@ -0,0 +1,29 @@
+import { IsNumber, IsUUID } from "class-validator";
+
+import { CloudPoolContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class CreateLudeosRequestPayload {
+  @IsUUID()
+  poolId: string;
+
+  @IsNumber()
+  quantity: number;
+}
+
+export class CreateLudeosRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-ludeos-request";
+
+  constructor(payload: CreateLudeosRequestPayload, context: CloudPoolContext) {
+    super(CreateLudeosRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudPoolContext)
+  context: CloudPoolContext;
+
+  @ValidateNestedType(() => CreateLudeosRequestPayload)
+  payload: CreateLudeosRequestPayload;
+}

package/src/v4/events/create-machine-resource-batch-request.ts

@@ -0,0 +1,44 @@
+import { IsArray, IsEnum, IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProvider,
+  CloudProviderSettings,
+} from "../types";
+
+export class CreateMachineResourceBatchRequestPayload {
+  @IsArray()
+  machineResourceIds: string[];
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  cloudProviderSettings: CloudProviderSettings;
+}
+
+export class CreateMachineResourceBatchRequest extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.create-machine-resource-batch-request";
+
+  constructor(
+    payload: CreateMachineResourceBatchRequestPayload,
+    context: CloudResourceContext
+  ) {
+    super(CreateMachineResourceBatchRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => CreateMachineResourceBatchRequestPayload)
+  payload: CreateMachineResourceBatchRequestPayload;
+}

package/src/v4/events/create-machine-resource-request.ts

@@ -0,0 +1,43 @@
+import { IsEnum, IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProvider,
+  CloudProviderSettings,
+} from "../types";
+
+export class CreateMachineResourceRequestPayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  cloudProviderSettings: CloudProviderSettings;
+}
+
+export class CreateMachineResourceRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-machine-resource-request";
+
+  constructor(
+    payload: CreateMachineResourceRequestPayload,
+    context: CloudResourceContext
+  ) {
+    super(CreateMachineResourceRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => CreateMachineResourceRequestPayload)
+  payload: CreateMachineResourceRequestPayload;
+}

package/src/v4/events/create-machines-request.ts

@@ -0,0 +1,32 @@
+import { IsNumber, IsUUID } from "class-validator";
+
+import { CloudPoolContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class CreateMachinesRequestPayload {
+  @IsUUID()
+  poolId: string;
+
+  @IsNumber()
+  quantity: number;
+}
+
+export class CreateMachinesRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-machines-request";
+
+  constructor(
+    payload: CreateMachinesRequestPayload,
+    context: CloudPoolContext
+  ) {
+    super(CreateMachinesRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudPoolContext)
+  context: CloudPoolContext;
+
+  @ValidateNestedType(() => CreateMachinesRequestPayload)
+  payload: CreateMachinesRequestPayload;
+}

package/src/v4/events/deallocate-machine-request.ts

@@ -0,0 +1,39 @@
+import { IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { getCloudContextType } from "../contexts/getCloudContextType";
+import { CloudSessionContext, CloudResourceContext } from "../contexts";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class DeallocateMachineRequestPayload {
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+}
+
+export class DeallocateMachineRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.deallocate-machine-request";
+
+  constructor(
+    payload: DeallocateMachineRequestPayload,
+    context: CloudSessionContext | CloudResourceContext
+  ) {
+    super(DeallocateMachineRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudResourceContext;
+
+  @ValidateNestedType(() => DeallocateMachineRequestPayload)
+  payload: DeallocateMachineRequestPayload;
+}

package/src/v4/events/game-allocated-response.ts

@@ -0,0 +1,28 @@
+import { CloudSessionContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { AwsAllocationData, CloudProviderAllocationData } from "../types";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameAllocatedResponsePayload {
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData: CloudProviderAllocationData;
+}
+
+export class GameAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.game-allocated-response";
+
+  constructor(
+    payload: GameAllocatedResponsePayload,
+    context: CloudSessionContext
+  ) {
+    super(GameAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => GameAllocatedResponsePayload)
+  payload: GameAllocatedResponsePayload;
+}

package/src/v4/events/game-allocation-failed-response.ts

@@ -0,0 +1,33 @@
+import { IsString } from "class-validator";
+
+import { AllocationRequestData } from "../types";
+import { CloudSessionContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameAllocationFailedResponsePayload {
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class GameAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.game-allocation-failed-response";
+
+  constructor(
+    payload: GameAllocationFailedResponsePayload,
+    context: CloudSessionContext
+  ) {
+    super(GameAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => GameAllocationFailedResponsePayload)
+  payload: GameAllocationFailedResponsePayload;
+}

package/src/v4/events/game-available.ts

@@ -0,0 +1,26 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudPoolContext } from "../contexts";
+
+export class GameAvailablePayload {
+  @IsUUID()
+  gamePoolId: string;
+}
+
+export class GameAvailable extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.game-available";
+
+  constructor(payload: GameAvailablePayload, context: CloudPoolContext) {
+    super(GameAvailable.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudPoolContext)
+  context: CloudPoolContext;
+
+  @ValidateNestedType(() => GameAvailablePayload)
+  payload: GameAvailablePayload;
+}

package/src/v4/events/game-resource-allocated-response.ts

@@ -0,0 +1,44 @@
+import { IsUUID } from "class-validator";
+
+import { CloudSessionContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AllocationRequestData,
+  AwsAllocationData,
+  CloudProviderAllocationData,
+} from "../types";
+
+export class GameResourceAllocatedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData: CloudProviderAllocationData;
+
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+}
+
+export class GameResourceAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-allocated-response";
+
+  constructor(
+    payload: GameResourceAllocatedResponsePayload,
+    context: CloudSessionContext
+  ) {
+    super(GameResourceAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => GameResourceAllocatedResponsePayload)
+  payload: GameResourceAllocatedResponsePayload;
+}

package/src/v4/events/game-resource-allocation-failed-response.ts

@@ -0,0 +1,40 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { AllocationRequestData } from "../types";
+import { CloudSessionContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameResourceAllocationFailedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsString()
+  errorMessage: string;
+
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+}
+
+export class GameResourceAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-allocation-failed-response";
+
+  constructor(
+    payload: GameResourceAllocationFailedResponsePayload,
+    context: CloudSessionContext
+  ) {
+    super(GameResourceAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => GameResourceAllocationFailedResponsePayload)
+  payload: GameResourceAllocationFailedResponsePayload;
+}