@ludeo/cloud-common 1.1.7 → 1.1.8

package/src/decorators/validate-nested-type.decorator.ts

@@ -1,7 +1,9 @@
 import { applyDecorators } from "@nestjs/common";
 import { ValidateNested } from "class-validator";
-import { Type } from "class-transformer";
+import { Type, TypeHelpOptions } from "class-transformer";
 
-export function ValidateNestedType(typeFunction: () => any) {
+export function ValidateNestedType(
+  typeFunction: (type: TypeHelpOptions) => any
+) {
   return applyDecorators(ValidateNested(), Type(typeFunction));
 }

package/src/v3/contexts/cloud-pool-context.ts

@@ -0,0 +1,14 @@
+import { IsEnum, IsOptional, IsUUID, IsString } from "class-validator";
+import { CloudProvider } from "../types";
+
+export class CloudPoolContext {
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsUUID()
+  poolId: string;
+
+  @IsString()
+  @IsOptional()
+  streamGroupId?: string;
+}

package/src/v3/contexts/cloud-session-context.ts

@@ -0,0 +1,46 @@
+import { IsEnum, IsOptional, IsString, IsUUID } from "class-validator";
+import { CloudProvider } from "../types";
+
+export class CloudSessionContext {
+  @IsOptional()
+  @IsUUID()
+  allocationRequestId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  clientRequestId?: string;
+
+  @IsUUID()
+  cloudSessionId: string;
+
+  @IsOptional()
+  @IsUUID()
+  userId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  gameId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  ludeoId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  poolId?: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsOptional()
+  @IsUUID()
+  resourceId?: string;
+
+  @IsOptional()
+  @IsString()
+  streamGroupId?: string;
+
+  @IsOptional()
+  @IsString()
+  streamSessionId?: string;
+}

package/src/v3/contexts/getCloudContextType.spec.ts

@@ -0,0 +1,102 @@
+import { validate } from "class-validator";
+import { plainToInstance } from "class-transformer";
+
+import { ValidateNestedType } from "../../decorators";
+import { getCloudContextType } from "./getCloudContextType";
+import { CloudPoolContext } from "../contexts/cloud-pool-context";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { CloudResourceContext } from "../contexts/cloud-resource-context";
+
+describe("getContextType", () => {
+  it("should return cloud session context", () => {
+    const context = {
+      cloudSessionId: "cloudSessionId",
+    };
+    expect(getCloudContextType({ object: context } as any)).toBe(
+      CloudSessionContext
+    );
+  });
+
+  it("should return cloud resource context", () => {
+    const context = {
+      resourceId: "resourceId",
+    };
+    expect(getCloudContextType({ object: context } as any)).toBe(
+      CloudResourceContext
+    );
+  });
+
+  it("should return cloud pool context", () => {
+    const context = {
+      poolId: "poolId",
+    };
+    expect(getCloudContextType({ object: context } as any)).toBe(
+      CloudPoolContext
+    );
+  });
+
+  describe("class validator", () => {
+    class Context {
+      @ValidateNestedType(getCloudContextType)
+      context: CloudSessionContext | CloudPoolContext | CloudResourceContext;
+
+      constructor(context: Record<string, any>) {
+        this.context = context as any;
+      }
+    }
+
+    it("invalid cloud session context", async () => {
+      const invalidCloudSessionContext = {
+        cloudSessionId: "BA7C9AEE-955D-4155-9220-A4BCB0F0A106",
+        poolId: "E738D912-8D00-4E3B-9F0A-A448C9FEAA73",
+        cloudProvider: "invalid" as any,
+      };
+
+      const invalidEvent = plainToInstance(Context, {
+        context: invalidCloudSessionContext,
+      });
+      const validationErrors = await validate(invalidEvent);
+
+      expect(validationErrors).toHaveLength(1);
+      expect(validationErrors[0].children).toHaveLength(1);
+      expect(validationErrors[0].children[0].constraints).toEqual({
+        isEnum: "cloudProvider must be one of the following values: aws",
+      });
+    });
+
+    it("valid cloud session context", async () => {
+      const validCloudSessionContext = {
+        cloudSessionId: "BA7C9AEE-955D-4155-9220-A4BCB0F0A106",
+        poolId: "E738D912-8D00-4E3B-9F0A-A448C9FEAA73",
+        cloudProvider: "aws",
+      };
+
+      const validEvent = plainToInstance(Context, {
+        context: validCloudSessionContext,
+      });
+      const validationErrors = await validate(validEvent);
+
+      expect(validationErrors).toHaveLength(0);
+    });
+
+    it("invalid cloud resource context", async () => {
+      const invalidCloudResourceContext = {
+        resourceId: "BA7C9AEE-955D-4155-9220-A4BCB0F0A106",
+        poolId: "E738D912-8D00-4E3B-9F0A-A448C9FEAA73",
+        cloudProvider: "aws" as any,
+        streamGroupId: 123839289312, // should be a string
+      };
+
+      const invalidEvent = plainToInstance(Context, {
+        context: invalidCloudResourceContext,
+      });
+      const validationErrors = await validate(invalidEvent);
+
+      expect(validationErrors).toHaveLength(1);
+      expect(validationErrors[0].children).toHaveLength(1);
+      expect(validationErrors[0].children[0].constraints).toEqual({
+        isString: "streamGroupId must be a string",
+      });
+    });
+  });
+});

package/src/v3/contexts/getCloudContextType.ts

@@ -0,0 +1,16 @@
+import { TypeHelpOptions } from "class-transformer";
+import { CloudPoolContext } from "./cloud-pool-context";
+import { CloudResourceContext } from "./cloud-resource-context";
+import { CloudSessionContext } from "./cloud-session-context";
+
+export const getCloudContextType = ({ object }: TypeHelpOptions) => {
+  if ("cloudSessionId" in object) {
+    return CloudSessionContext;
+  }
+
+  if ("resourceId" in object) {
+    return CloudResourceContext;
+  }
+
+  return CloudPoolContext;
+};

package/src/v3/contexts/index.ts

@@ -1 +1,4 @@
+export * from "./cloud-pool-context";
 export * from "./cloud-resource-context";
+export * from "./cloud-session-context";
+export * from "./getCloudContextType";

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

@@ -0,0 +1,41 @@
+import { Type } from "class-transformer";
+import { IsUUID, ValidateNested } from "class-validator";
+
+import { CloudPoolContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudSessionContext } from "../../v2/contexts";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { getCloudContextType } from "../contexts/getCloudContextType";
+
+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
+  ) {
+    super(DeallocateMachineRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudPoolContext;
+
+  @ValidateNestedType(() => DeallocateMachineRequestPayload)
+  payload: DeallocateMachineRequestPayload;
+}

package/src/v3/events/{game-allocated-response.ts → game-resource-allocated-response.ts}

@@ -16,14 +16,15 @@ export class GameAllocatedResponsePayload {
   allocationData: CloudProviderAllocationData;
 }
 
-export class GameAllocatedResponse extends LudeoEvent {
-  static readonly EVENT_NAME = "cloud-resources.game-allocated-response";
+export class GameResourceAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-allocated-response";
 
   constructor(
     payload: GameAllocatedResponsePayload,
     context: CloudResourceContext
   ) {
-    super(GameAllocatedResponse.EVENT_NAME);
+    super(GameResourceAllocatedResponse.EVENT_NAME);
     this.payload = payload;
     this.context = context;
   }

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

@@ -0,0 +1,36 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { CloudResourceContext } 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;
+}
+
+export class GameResourceAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-allocation-failed-response";
+
+  constructor(
+    payload: GameResourceAllocationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(GameResourceAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceAllocationFailedResponsePayload)
+  payload: GameResourceAllocationFailedResponsePayload;
+}

package/src/v3/events/{game-created-response.ts → game-resource-created-response.ts}

@@ -23,14 +23,14 @@ export class GameCreatedResponsePayload {
   cloudProvider: CloudProvider;
 }
 
-export class GameCreatedResponse extends LudeoEvent {
-  static readonly EVENT_NAME = "cloud-resources.game-created-response";
+export class GameResourceCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.game-resource-created-response";
 
   constructor(
     payload: GameCreatedResponsePayload,
     context: CloudResourceContext
   ) {
-    super(GameCreatedResponse.EVENT_NAME);
+    super(GameResourceCreatedResponse.EVENT_NAME);
     this.payload = payload;
     this.context = context;
   }

package/src/v3/events/game-resource-creation-failed-response.ts

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

package/src/v3/events/{game-terminated-response.ts → game-resource-terminated-response.ts}

@@ -12,14 +12,15 @@ export class GameTerminatedResponsePayload {
   gamePoolId: string;
 }
 
-export class GameTerminatedResponse extends LudeoEvent {
-  static readonly EVENT_NAME = "cloud-resources.game-terminated-response";
+export class GameResourceTerminatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-terminated-response";
 
   constructor(
     payload: GameTerminatedResponsePayload,
     context: CloudResourceContext
   ) {
-    super(GameTerminatedResponse.EVENT_NAME);
+    super(GameResourceTerminatedResponse.EVENT_NAME);
     this.payload = payload;
     this.context = context;
   }

package/src/v3/events/game-resource-termination-failed-response.ts

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

package/src/v3/events/index.ts

@@ -5,11 +5,19 @@ 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 "./deallocate-machine-request";
+export * from "./game-resource-allocated-response";
+export * from "./game-resource-allocation-failed-response";
+export * from "./game-resource-created-response";
+export * from "./game-resource-creation-failed-response";
+export * from "./game-resource-terminated-response";
+export * from "./game-resource-termination-failed-response";
 export * from "./machine-allocated-response";
-export * from "./machine-created-response";
+export * from "./machine-allocation-failed-response";
+export * from "./machine-deallocated-response";
+export * from "./machine-deallocation-failed-response";
+export * from "./machine-resource-created-response";
+export * from "./machine-resource-creation-failed-response";
 export * from "./set-pool.event";
 export * from "./terminate-game-resource-request";
 export * from "./terminate-games-request";

package/src/v3/events/machine-allocation-failed-response.ts

@@ -0,0 +1,39 @@
+import { IsUUID, IsString } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineAllocatedFailedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.machine-allocation-failed-response";
+
+  constructor(
+    payload: MachineAllocatedFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineAllocatedFailedResponsePayload)
+  payload: MachineAllocatedFailedResponsePayload;
+}

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

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

package/src/v3/events/machine-deallocation-failed-response.ts

@@ -0,0 +1,43 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudSessionContext } from "../../v2/contexts";
+import { CloudPoolContext, getCloudContextType } from "../contexts";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineDeallocatedFailedResponsePayload {
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineDeallocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.machine-deallocation-failed-response";
+
+  constructor(
+    payload: MachineDeallocatedFailedResponsePayload,
+    context: CloudSessionContext
+  ) {
+    super(MachineDeallocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudPoolContext;
+
+  @ValidateNestedType(() => MachineDeallocatedFailedResponsePayload)
+  payload: MachineDeallocatedFailedResponsePayload;
+}

package/src/v3/events/{machine-created-response.ts → machine-resource-created-response.ts}

@@ -4,7 +4,7 @@ import { CloudResourceContext } from "../contexts";
 import { LudeoEvent } from "../../infra/ludeo-event";
 import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
 
-export class MachineCreatedResponsePayload {
+export class MachineResourceCreatedResponsePayload {
   @IsUUID()
   machineResourceId: string;
 
@@ -12,14 +12,15 @@ export class MachineCreatedResponsePayload {
   machinePoolId: string;
 }
 
-export class MachineCreatedResponse extends LudeoEvent {
-  static readonly EVENT_NAME = "cloud-resources.machine-created-response";
+export class MachineResourceCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.machine-resource-created-response";
 
   constructor(
-    payload: MachineCreatedResponsePayload,
+    payload: MachineResourceCreatedResponsePayload,
     context: CloudResourceContext
   ) {
-    super(MachineCreatedResponse.EVENT_NAME);
+    super(MachineResourceCreatedResponse.EVENT_NAME);
     this.payload = payload;
     this.context = context;
   }
@@ -27,6 +28,6 @@ export class MachineCreatedResponse extends LudeoEvent {
   @ValidateNestedType(() => CloudResourceContext)
   context: CloudResourceContext;
 
-  @ValidateNestedType(() => MachineCreatedResponsePayload)
-  payload: MachineCreatedResponsePayload;
+  @ValidateNestedType(() => MachineResourceCreatedResponsePayload)
+  payload: MachineResourceCreatedResponsePayload;
 }

package/src/v3/events/machine-resource-creation-failed-response.ts

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