@pompidup/kingdomino-engine 2.0.3 → 2.1.2

package/dist/index.js

@@ -658,6 +658,57 @@ var jsonRules = () => {
 };
 var jsonRules_default = jsonRules;
 
+// src/adapterServerside/shuffle.ts
+var shuffleMethod = (array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+};
+
+// src/adapterServerside/uuid.ts
+import { randomUUID } from "crypto";
+var uuidMethod = () => {
+  return randomUUID();
+};
+
+// src/adapterServerside/winstonLogger.ts
+import winston from "winston";
+var winstonLogger = (isLoggingEnabled) => {
+  const myFormat = winston.format.printf(
+    ({ level, message, label, timestamp }) => {
+      return `${timestamp} [${label}] ${level}: ${message}`;
+    }
+  );
+  const logger = winston.createLogger({
+    level: "info",
+    format: winston.format.combine(
+      winston.format.label({ label: "KDomino_Engine" }),
+      winston.format.timestamp(),
+      winston.format.simple(),
+      winston.format.json(),
+      winston.format.colorize(),
+      myFormat
+    ),
+    transports: [new winston.transports.Console()]
+  });
+  return {
+    info: (message) => {
+      if (isLoggingEnabled) {
+        logger.info(message);
+      }
+      return void 0;
+    },
+    error: (message) => {
+      if (isLoggingEnabled) {
+        logger.error(message);
+      }
+      return void 0;
+    }
+  };
+};
+
 // src/core/domain/errors/domainErrors.ts
 var InvalidStepError = class extends Error {
   constructor(message) {
@@ -684,6 +735,20 @@ var NotFoundError = class extends Error {
   }
 };
 
+// src/core/domain/types/game.ts
+var gameSteps = {
+  addPlayers: "addPlayers",
+  options: "options",
+  start: "start",
+  result: "result"
+};
+var isGameWithNextAction = (game) => {
+  return game.nextAction.type === "action";
+};
+var isGameWithNextStep = (game) => {
+  return game.nextAction.type === "step";
+};
+
 // src/utils/result.ts
 var ok = (value) => ({ tag: "Ok", value });
 var err = (error) => ({ tag: "Err", error });
@@ -691,140 +756,235 @@ var isOk = (result) => result.tag === "Ok";
 var isErr = (result) => result.tag === "Err";
 
 // src/application/handlers/addExtraRulesHandler.ts
-var addExtraRulesHandler = (useCase) => (command) => {
+var addExtraRulesHandler = (logger, useCase) => (command) => {
   const { game, extraRules } = command;
+  logger.info(`Adding extra rules to game: ${game.id}`);
+  logger.info(`Extra rules: ${extraRules}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error("Invalid game with nextAction type: 'step'");
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "options") {
+    logger.error(
+      `Required game with options step but got: ${game.nextAction.step}`
+    );
     throw new InvalidStepError("Required game with options step");
   }
   const result = useCase(game, extraRules);
   if (isErr(result)) {
+    logger.error(`Error adding extra rules: ${result.error}`);
     throw new StepExecutionError(result.error);
   }
+  logger.info(`Extra rules added to game: ${game.id}`);
   return result.value;
 };
 
 // src/application/handlers/addPlayersHandler.ts
-var addPlayersHandler = (useCase) => (command) => {
+var addPlayersHandler = (logger, useCase) => (command) => {
   const { game, players } = command;
+  logger.info(`Adding players to game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error("Invalid game with nextAction type: 'step'");
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "addPlayers") {
+    logger.error(
+      `Required game with addPlayers step but got: ${game.nextAction.step}`
+    );
     throw new InvalidStepError("Required game with addPlayers step");
   }
   const result = useCase(game, players);
   if (isErr(result)) {
+    logger.error(`Error adding players: ${result.error}`);
     throw new StepExecutionError(result.error);
   }
+  logger.info(`Players added to game: ${game.id}`);
   return result.value;
 };
 
 // src/application/handlers/chooseDominoHandler.ts
-var chooseDominoHandler = (useCase) => (command) => {
+var chooseDominoHandler = (logger, useCase) => (command) => {
   const { game, lordId, dominoPick } = command;
+  logger.info(
+    `Choosing domino: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error("Invalid game with nextAction type: 'action'");
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "pickDomino") {
+    logger.error(
+      `Required game with pickDomino action but got: ${game.nextAction.nextAction}`
+    );
     throw new InvalidStepError("Required game with pickDomino action");
   }
   const result = useCase(game, lordId, dominoPick);
   if (isErr(result)) {
+    logger.error(`Error choosing domino: ${result.error}`);
     throw new ActionExecutionError(result.error);
   }
+  logger.info(
+    `Domino chosen: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
+  );
   return result.value;
 };
 
 // src/application/handlers/createGameHandler.ts
-var createGameHandler = (useCase) => (command) => {
+var createGameHandler = (logger, useCase) => (command) => {
+  logger.info(`Creating game with mode: ${command.mode}`);
   const result = useCase(command.mode);
   if (isErr(result)) {
+    logger.error(`Error creating game: ${result.error}`);
     throw new StepExecutionError(result.error);
   }
+  logger.info(`Game created: ${result.value.id}`);
   return result.value;
 };
 
-// src/core/domain/types/game.ts
-var gameSteps = {
-  addPlayers: "addPlayers",
-  options: "options",
-  start: "start",
-  result: "result"
-};
-var isGameWithNextAction = (game) => {
-  return game.nextAction.type === "action";
-};
-
 // src/application/handlers/discardDominoHandler.ts
-var discardDominoHandler = (useCase) => (command) => {
+var discardDominoHandler = (logger, useCase) => (command) => {
   const { game, lordId } = command;
+  logger.info(`Discarding domino for lord: ${lordId} in game: ${game.id}`);
+  if (!isGameWithNextAction(game)) {
+    logger.error("Invalid game with nextAction type: 'action'");
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "placeDomino") {
+    logger.error(
+      `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
+    );
     throw new InvalidStepError("Required game with placeDomino action");
   }
   const result = useCase(game, lordId);
   if (isErr(result)) {
+    logger.error(`Error discarding domino: ${result.error}`);
     throw new ActionExecutionError(result.error);
   }
   if (isGameWithNextAction(result.value)) {
+    logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
     return result.value;
   }
+  logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
   return result.value;
 };
 
 // src/application/handlers/getExtraRulesHandler.ts
-var getExtraRulesHandler = (getExtraRulesUseCase2) => (command) => {
+var getExtraRulesHandler = (logger, useCase) => (command) => {
   const { mode, players } = command;
-  const result = getExtraRulesUseCase2(mode, players);
+  logger.info(
+    `Getting extra rules for mode: ${mode} and players: ${players}`
+  );
+  const result = useCase(mode, players);
   if (isErr(result)) {
+    logger.error(`Error getting extra rules: ${result.error}`);
     throw new NotFoundError(result.error);
   }
+  logger.info(`Extra rules retrieved: ${result.value}`);
   return result.value;
 };
 
 // src/application/handlers/getModesHandler.ts
-var getModesHandler = (getModeUseCase) => (_command) => {
-  const result = getModeUseCase();
+var getModesHandler = (logger, useCase) => (_command) => {
+  logger.info("Getting modes");
+  const result = useCase();
   if (isErr(result)) {
+    logger.error(`Error getting modes: ${result.error}`);
     throw new NotFoundError(result.error);
   }
+  logger.info(`Modes retrieved: ${result.value}`);
   return result.value;
 };
 
 // src/application/handlers/getResultHandler.ts
-var getResultHandler = (useCase) => (command) => {
+var getResultHandler = (logger, useCase) => (command) => {
   const { game } = command;
+  logger.info(`Getting result for game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error("Invalid game with nextAction type: 'step'");
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "result") {
+    logger.error(
+      `Required game with result step but got: ${game.nextAction.step}`
+    );
     throw new InvalidStepError("Required game with result step");
   }
   const result = useCase(game);
   if (isErr(result)) {
+    logger.error(`Error getting result: ${result.error}`);
     throw new NotFoundError(result.error);
   }
+  logger.info(`Result retrieved for game: ${game.id}`);
   return result.value;
 };
 
 // src/application/handlers/placeDominoHandler.ts
-var placeDominoHandler = (useCase) => (command) => {
+var placeDominoHandler = (logger, useCase) => (command) => {
   const { game, lordId, position, orientation, rotation } = command;
+  logger.info(
+    `Placing domino: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error("Invalid game with nextAction type: 'action'");
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "placeDomino") {
+    logger.error(
+      `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
+    );
     throw new InvalidStepError("Required game with placeDomino step");
   }
   const result = useCase(game, lordId, position, orientation, rotation);
   if (isErr(result)) {
+    logger.error(`Error placing domino: ${result.error}`);
     throw new ActionExecutionError(result.error);
   }
   if (isGameWithNextAction(result.value)) {
+    logger.info(
+      `Domino placed: ${lordId} in position: ${JSON.stringify(
+        position
+      )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+    );
     return result.value;
   }
+  logger.info(
+    `Domino placed: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+  );
   return result.value;
 };
 
 // src/application/handlers/startGameHandler.ts
-var startGameHandler = (useCase) => (command) => {
+var startGameHandler = (logger, useCase) => (command) => {
   const { game } = command;
+  logger.info(`Starting game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error("Invalid game with nextAction type: 'step'");
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
+    logger.error(
+      `Required game with start step or options step but got: ${game.nextAction.step}`
+    );
     throw new InvalidStepError(
       "Required game with start step or options step"
     );
   }
   const result = useCase(game);
   if (isErr(result)) {
+    logger.error(`Error starting game: ${result.error}`);
     throw new StepExecutionError(result.error);
   }
+  logger.info(`Game started: ${game.id}`);
   return result.value;
 };
 
@@ -1727,41 +1887,33 @@ var startGameUseCase = (deps) => (game) => {
   return ok(newState);
 };
 
-// src/adapterServerside/shuffle.ts
-var shuffleMethod = (array) => {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
-  }
-  return array;
-};
-
-// src/adapterServerside/uuid.ts
-import { randomUUID } from "crypto";
-var uuidMethod = () => {
-  return randomUUID();
-};
-
 // src/config.ts
 var configureEngine = (config) => {
-  const modeRepository = config.modeRepository || jsonModes_default();
-  const dominoesRepository = config.dominoesRepository || jsonDominoes_default();
-  const ruleRepository = config.ruleRepository || jsonRules_default();
+  const modeRepository = jsonModes_default();
+  const dominoesRepository = jsonDominoes_default();
+  const ruleRepository = jsonRules_default();
   const uuid = config.uuidMethod || uuidMethod;
   const shuffle = config.shuffleMethod || shuffleMethod;
+  const logger = config.logging ? winstonLogger(true) : winstonLogger(false);
   return {
     createGameHandler: createGameHandler(
+      logger,
       createGameUseCase({
         modeRepository,
         dominoesRepository,
         uuidMethod: uuid
       })
     ),
-    getModesHandler: getModesHandler(getModesUseCase({ modeRepository })),
+    getModesHandler: getModesHandler(
+      logger,
+      getModesUseCase({ modeRepository })
+    ),
     getExtraRulesHandler: getExtraRulesHandler(
+      logger,
       getExtraRulesUseCase({ ruleRepository })
     ),
     addPlayersHandler: addPlayersHandler(
+      logger,
       addPlayersUseCase({
         uuidMethod: uuid,
         shuffleMethod: shuffle,
@@ -1769,15 +1921,17 @@ var configureEngine = (config) => {
       })
     ),
     addExtraRulesHandler: addExtraRulesHandler(
+      logger,
       addExtraRulesUseCase({ ruleRepository })
     ),
     startGameHandler: startGameHandler(
+      logger,
       startGameUseCase({ uuidMethod: uuid, shuffleMethod: shuffle })
     ),
-    chooseDominoHandler: chooseDominoHandler(chooseDominoUseCase),
-    placeDominoHandler: placeDominoHandler(placeDominoUseCase),
-    discardDominoHandler: discardDominoHandler(discardDominoUseCase),
-    getResultHandler: getResultHandler(getResultUseCase)
+    chooseDominoHandler: chooseDominoHandler(logger, chooseDominoUseCase),
+    placeDominoHandler: placeDominoHandler(logger, placeDominoUseCase),
+    discardDominoHandler: discardDominoHandler(logger, discardDominoUseCase),
+    getResultHandler: getResultHandler(logger, getResultUseCase)
   };
 };