@ludeo/cloud-common 1.0.32 → 1.1.0

package/src/v3/events/allocate-machine-request.ts

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

package/src/v3/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/v3/events/create-games-request.ts

@@ -0,0 +1,29 @@
+import { IsNumber, IsUUID } from "class-validator";
+
+import { PoolContext } from "../../v2/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: PoolContext) {
+    super(CreateGamesRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => CreateGamesRequestPayload)
+  payload: CreateGamesRequestPayload;
+}

package/src/v3/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/v3/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/v3/events/create-machines-request.ts

@@ -0,0 +1,29 @@
+import { IsNumber, IsUUID } from "class-validator";
+
+import { PoolContext } from "../../v2/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: PoolContext) {
+    super(CreateMachinesRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => CreateMachinesRequestPayload)
+  payload: CreateMachinesRequestPayload;
+}

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

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

package/src/v3/events/game-created-response.ts

@@ -0,0 +1,43 @@
+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 GameCreatedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+}
+
+export class GameCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.game-created-response";
+
+  constructor(
+    payload: GameCreatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(GameCreatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameCreatedResponsePayload)
+  payload: GameCreatedResponsePayload;
+}

package/src/v3/events/game-terminated-response.ts

@@ -0,0 +1,32 @@
+import { IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameTerminatedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+}
+
+export class GameTerminatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.game-terminated-response";
+
+  constructor(
+    payload: GameTerminatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(GameTerminatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameTerminatedResponsePayload)
+  payload: GameTerminatedResponsePayload;
+}

package/src/v3/events/index.ts

@@ -0,0 +1,17 @@
+export * from "./allocate-game-request";
+export * from "./allocate-game-resource-request";
+export * from "./allocate-machine-request";
+export * from "./create-game-resource-request";
+export * from "./create-games-request";
+export * from "./create-machine-resource-batch-request";
+export * from "./create-machines-request";
+export * from "./game-allocated-response";
+export * from "./game-created-response";
+export * from "./game-terminated-response";
+export * from "./machine-allocated-response";
+export * from "./machine-created-response";
+export * from "./set-pool.event";
+export * from "./terminate-game-resource-request";
+export * from "./terminate-games-request";
+export * from "./terminate-machine-resource-batch-request";
+export * from "./terminate-machines-request";

package/src/v3/events/machine-allocated-response.ts

@@ -0,0 +1,49 @@
+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 MachineAllocatedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+}
+
+export class MachineAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.machine-allocated-response";
+
+  constructor(
+    payload: MachineAllocatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineAllocatedResponsePayload)
+  payload: MachineAllocatedResponsePayload;
+}

package/src/v3/events/machine-created-response.ts

@@ -0,0 +1,32 @@
+import { IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineCreatedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class MachineCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.machine-created-response";
+
+  constructor(
+    payload: MachineCreatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineCreatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineCreatedResponsePayload)
+  payload: MachineCreatedResponsePayload;
+}

package/src/v3/events/set-pool.event.ts

@@ -0,0 +1,23 @@
+import { PoolContext } from "../../v2/contexts/pool-context";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { BaseCloudPoolConfiguration } from "../types";
+
+export class SetPoolEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.set-pool";
+
+  constructor(
+    payload: Partial<BaseCloudPoolConfiguration>,
+    context: PoolContext
+  ) {
+    super(SetPoolEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => BaseCloudPoolConfiguration)
+  payload: Partial<BaseCloudPoolConfiguration>;
+}

package/src/v3/events/terminate-game-resource-request.ts

@@ -0,0 +1,43 @@
+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 TerminateGameResourceRequestPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+}
+
+export class TerminateGameResourceRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.terminate-game-resource-request";
+
+  constructor(
+    payload: TerminateGameResourceRequestPayload,
+    context: CloudResourceContext
+  ) {
+    super(TerminateGameResourceRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => TerminateGameResourceRequestPayload)
+  payload: TerminateGameResourceRequestPayload;
+}

package/src/v3/events/terminate-games-request.ts

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

package/src/v3/events/terminate-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 TerminateMachineResourceBatchRequestPayload {
+  @IsArray()
+  machineResourceIds: string[];
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  cloudProviderSettings: CloudProviderSettings;
+}
+
+export class TerminateMachineResourceBatchRequest extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.terminate-machine-resource-batch-request";
+
+  constructor(
+    payload: TerminateMachineResourceBatchRequestPayload,
+    context: CloudResourceContext
+  ) {
+    super(TerminateMachineResourceBatchRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => TerminateMachineResourceBatchRequestPayload)
+  payload: TerminateMachineResourceBatchRequestPayload;
+}

package/src/v3/events/terminate-machines-request.ts

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

package/src/v3/index.ts

@@ -0,0 +1,2 @@
+export * as Events from "./events";
+export * as Types from "./types";