@ludeo/cloud-common 1.1.142 → 1.2.0

package/dist/v4/types/pools/status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPoolStatus = void 0;
+var CloudPoolStatus;
+(function (CloudPoolStatus) {
+    CloudPoolStatus["Active"] = "active";
+    CloudPoolStatus["Created"] = "created";
+    CloudPoolStatus["Scaling"] = "scaling";
+    CloudPoolStatus["Terminated"] = "terminated";
+})(CloudPoolStatus || (exports.CloudPoolStatus = CloudPoolStatus = {}));
+//# sourceMappingURL=status.js.map

package/dist/v4/types/pools/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../../src/v4/types/pools/status.ts"],"names":[],"mappings":";;;AAAA,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;IACnB,sCAAmB,CAAA;IACnB,4CAAyB,CAAA;AAC3B,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B"}

package/dist/v4/types/pools/type.d.ts

@@ -0,0 +1,5 @@
+export declare enum CloudPoolType {
+    GAME = "game",
+    MACHINE = "machine",
+    LUDEO = "ludeo"
+}

package/dist/v4/types/pools/type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPoolType = void 0;
+var CloudPoolType;
+(function (CloudPoolType) {
+    CloudPoolType["GAME"] = "game";
+    CloudPoolType["MACHINE"] = "machine";
+    CloudPoolType["LUDEO"] = "ludeo";
+})(CloudPoolType || (exports.CloudPoolType = CloudPoolType = {}));
+//# sourceMappingURL=type.js.map

package/dist/v4/types/pools/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../../../src/v4/types/pools/type.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,oCAAmB,CAAA;IACnB,gCAAe,CAAA;AACjB,CAAC,EAJW,aAAa,6BAAb,aAAa,QAIxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ludeo/cloud-common",
-  "version": "1.1.142",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Yahil Didi",

package/src/index.ts

@@ -2,3 +2,4 @@ export * as V2 from "./v2";
 export * as Decorators from "./decorators";
 export * from "./infra";
 export * as V3 from "./v3";
+export * as V4 from "./v4";

package/src/v3/types/cloud.ts

@@ -85,6 +85,10 @@ export class AllocationRequestData {
   @IsString()
   @IsOptional()
   clientIp?: string;
+
+  @IsString()
+  @IsOptional()
+  region?: string;
 }
 
 export enum CloudSessionStatus {

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

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

package/src/v4/contexts/cloud-resource-context.ts

@@ -0,0 +1,49 @@
+import { IsEnum, IsOptional, IsString, IsUUID } from "class-validator";
+import { CloudProvider } from "../types/cloud";
+
+export class CloudResourceContext {
+  @IsOptional()
+  @IsString()
+  streamGroupId?: string;
+
+  @IsOptional()
+  @IsString()
+  streamSessionId?: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  // Backwards compat
+  @IsOptional()
+  @IsString()
+  resourceId?: string;
+
+  // Backwards compat
+  @IsOptional()
+  @IsString()
+  poolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  gamePoolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  gameResourceId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  machinePoolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  machineResourceId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  poolMonitorRequestId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  platformStatusRequestId?: string;
+}

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

@@ -0,0 +1,71 @@
+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;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsOptional()
+  @IsUUID()
+  gamePoolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  gameResourceId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  machinePoolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  machineResourceId?: string;
+
+  @IsOptional()
+  @IsString()
+  streamGroupId?: string;
+
+  @IsOptional()
+  @IsString()
+  streamSessionId?: string;
+
+  // Backwards compatibility for V2 of cloud-sessions and cloud-session-allocator
+  @IsOptional()
+  @IsUUID()
+  poolId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  resourceId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  tabSessionId?: string;
+
+  @IsOptional()
+  @IsString()
+  region?: string;
+}

package/src/v4/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/v4/contexts/getCloudContextType.ts

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

package/src/v4/contexts/index.ts

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

package/src/v4/events/allocate-cloud-session-failed.ts

@@ -0,0 +1,28 @@
+import { IsString } from "class-validator";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+
+export class AllocateCloudSessionFailedPayload {
+  @IsString()
+  error: string;
+}
+export class AllocateCloudSessionFailed extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.allocate-cloud-session-failed";
+
+  constructor(
+    payload: AllocateCloudSessionFailedPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateCloudSessionFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => AllocateCloudSessionFailedPayload)
+  payload: AllocateCloudSessionFailedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/v4/events/allocate-cloud-session-request.ts

@@ -0,0 +1,28 @@
+import { LudeoEvent } from "../../infra";
+import { CloudSessionContext } from "../contexts";
+import { ValidateNestedType } from "../../decorators";
+import { AllocationRequestData } from "../types";
+
+export class AllocateCloudSessionRequestData {
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+}
+
+export class AllocateCloudSessionRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.allocate-cloud-session-request";
+
+  constructor(
+    payload: AllocateCloudSessionRequestData,
+    context: CloudSessionContext,
+  ) {
+    super(AllocateCloudSessionRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => AllocateCloudSessionRequestData)
+  payload: AllocateCloudSessionRequestData;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/v4/events/allocate-game-request.ts

@@ -0,0 +1,33 @@
+import { IsEnum, IsUUID } from "class-validator";
+
+import { AllocationRequestData, CloudProvider } from "../types";
+import { CloudSessionContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class AllocateGameRequestPayload {
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+}
+
+export class AllocateGameRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-session-allocator.allocate-game-request";
+
+  constructor(
+    payload: AllocateGameRequestPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateGameRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => AllocateGameRequestPayload)
+  payload: AllocateGameRequestPayload;
+}

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

@@ -0,0 +1,52 @@
+import { IsUUID, IsEnum } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudSessionContext } from "../contexts";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProviderSettings,
+  CloudProvider,
+  AllocationRequestData,
+  AWSResourceProviderSettings,
+  CloudResourceProviderSettings,
+} from "../types";
+
+export class AllocateGameResourceRequestPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  resourceProviderSettings: CloudResourceProviderSettings;
+}
+
+export class AllocateGameResourceRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.allocate-game-resource-request";
+
+  constructor(
+    payload: AllocateGameResourceRequestPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateGameResourceRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => AllocateGameResourceRequestPayload)
+  payload: AllocateGameResourceRequestPayload;
+}

package/src/v4/events/allocate-ludeo-resource-request.ts

@@ -0,0 +1,28 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class AllocateLudeoResourcePayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class AllocateLudeoResource extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.allocate-ludeo-resource";
+
+  constructor(
+    payload: AllocateLudeoResourcePayload,
+    context: CloudResourceContext
+  ) {
+    super(AllocateLudeoResource.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => AllocateLudeoResourcePayload)
+  payload: AllocateLudeoResourcePayload;
+}

package/src/v4/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/v4/events/aws-poll-stream-session-task.ts

@@ -0,0 +1,33 @@
+import { LudeoEvent } from "../../infra";
+import { ValidateNestedType } from "../../decorators";
+import { CloudResourceContext } from "../contexts";
+import { IsNumber, IsString } from "class-validator";
+import { CreateGameResourceRequestPayload } from "./create-game-resource-request";
+
+export class AwsPollStreamSessionTaskPayload {
+  @ValidateNestedType(() => CloudResourceContext)
+  resourceContext: CloudResourceContext;
+
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  creationPayload: CreateGameResourceRequestPayload;
+
+  @IsString()
+  streamSessionId: string;
+
+  @IsNumber()
+  timeStarted: number;
+}
+
+export class AwsPollStreamSessionTask extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.aws-poll-stream-session-task";
+
+  constructor(payload: AwsPollStreamSessionTaskPayload) {
+    super(AwsPollStreamSessionTask.EVENT_NAME);
+    this.payload = payload;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => AwsPollStreamSessionTaskPayload)
+  payload: AwsPollStreamSessionTaskPayload;
+}

package/src/v4/events/aws-reactivate-stream-session-task.ts

@@ -0,0 +1,31 @@
+import { IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra";
+import { ValidateNestedType } from "../../decorators";
+import { AWSResourceProviderSettings } from "../types";
+
+export class AwsReactivateStreamSessionTaskPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: AWSResourceProviderSettings;
+}
+
+export class AwsReactivateStreamSessionTask extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.aws-reactivate-stream-session-task";
+
+  constructor(payload: AwsReactivateStreamSessionTaskPayload) {
+    super(AwsReactivateStreamSessionTask.EVENT_NAME);
+    this.payload = payload;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => AwsReactivateStreamSessionTaskPayload)
+  payload: AwsReactivateStreamSessionTaskPayload;
+}

package/src/v4/events/aws-stream-session-active.ts

@@ -0,0 +1,36 @@
+import { LudeoEvent } from "../../infra";
+import { ValidateNestedType } from "../../decorators";
+import { CreateGameResourceRequestPayload } from "./create-game-resource-request";
+import { IsString } from "class-validator";
+import { CloudResourceContext } from "../contexts";
+import { AWSResourceProviderSettings } from "../types";
+
+export class AwsStreamSessionActivePayload {
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  creationPayload: CreateGameResourceRequestPayload;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: AWSResourceProviderSettings;
+
+  @IsString()
+  streamSessionId: string;
+}
+
+export class AwsStreamSessionActive extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.aws-stream-session-active";
+
+  constructor(
+    payload: AwsStreamSessionActivePayload,
+    context: CloudResourceContext,
+  ) {
+    super(AwsStreamSessionActive.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => AwsStreamSessionActivePayload)
+  payload: AwsStreamSessionActivePayload;
+}