@gbl-uzh/platform 0.4.13 → 0.4.16

package/dist/index.js

@@ -1,2012 +1,11 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AccountService: () => AccountService_exports,
-  BaseGlobalNotificationType: () => BaseGlobalNotificationType,
-  BaseUserNotificationType: () => BaseUserNotificationType,
-  EventService: () => EventService_exports,
-  GameService: () => GameService_exports,
-  LearningElementState: () => LearningElementState,
-  PlayService: () => PlayService_exports,
-  UserRole: () => UserRole,
-  log: () => logger_default
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/lib/logger.ts
-var import_winston = __toESM(require("winston"));
-var logger = import_winston.default.createLogger({
-  level: process.env.NODE_ENV === "development" ? "debug" : "info",
-  format: import_winston.default.format.combine(
-    import_winston.default.format.timestamp(),
-    import_winston.default.format.json()
-  ),
-  defaultMeta: { service: "@gbl-uzh/platform" },
-  transports: [new import_winston.default.transports.Console()]
-});
-var logger_default = logger;
-
-// src/services/AccountService.ts
-var AccountService_exports = {};
-__export(AccountService_exports, {
-  createLoginToken: () => createLoginToken,
-  loginAsTeam: () => loginAsTeam,
-  logoutAsTeam: () => logoutAsTeam
-});
-var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
-var import_node_assert = require("assert");
-var import_nookies = require("nookies");
-
-// src/types.ts
-var UserRole = /* @__PURE__ */ ((UserRole2) => {
-  UserRole2["PLAYER"] = "PLAYER";
-  UserRole2["ADMIN"] = "ADMIN";
-  return UserRole2;
-})(UserRole || {});
-var LearningElementState = /* @__PURE__ */ ((LearningElementState2) => {
-  LearningElementState2["NEW"] = "NEW";
-  LearningElementState2["ATTEMPTED"] = "ATTEMPTED";
-  LearningElementState2["SOLVED"] = "SOLVED";
-  return LearningElementState2;
-})(LearningElementState || {});
-var BaseGlobalNotificationType = /* @__PURE__ */ ((BaseGlobalNotificationType2) => {
-  BaseGlobalNotificationType2["PERIOD_ACTIVATED"] = "PERIOD_ACTIVATED";
-  BaseGlobalNotificationType2["SEGMENT_ACTIVATED"] = "SEGMENT_ACTIVATED";
-  return BaseGlobalNotificationType2;
-})(BaseGlobalNotificationType || {});
-var BaseUserNotificationType = /* @__PURE__ */ ((BaseUserNotificationType2) => {
-  BaseUserNotificationType2["LEARNING_ELEMENT_SOLVED"] = "LEARNING_ELEMENT_SOLVED";
-  BaseUserNotificationType2["LEARNING_ELEMENT_INCORRECT"] = "LEARNING_ELEMENT_INCORRECT";
-  BaseUserNotificationType2["ACHIEVEMENT_RECEIVED"] = "ACHIEVEMENT_RECEIVED";
-  BaseUserNotificationType2["LEVEL_UP"] = "LEVEL_UP";
-  return BaseUserNotificationType2;
-})(BaseUserNotificationType || {});
-
-// src/services/AccountService.ts
-function createLoginToken({
-  sub,
-  role,
-  ...extra
-}) {
-  (0, import_node_assert.strict)(typeof process.env.NEXTAUTH_SECRET === "string");
-  return import_jsonwebtoken.default.sign({ sub, role, ...extra }, process.env.NEXTAUTH_SECRET, {
-    expiresIn: "1 week"
-  });
-}
-async function loginAsTeam({ token }, ctx) {
-  const matchingPlayer = await ctx.prisma.player.findUnique({
-    where: { token },
-    include: {
-      level: true,
-      achievements: {
-        include: {
-          achievement: true
-        }
-      }
-    }
-  });
-  if (!matchingPlayer) {
-    throw new Error("INVALID_TOKEN");
-  }
-  try {
-    const jwt = createLoginToken({
-      gameId: matchingPlayer.gameId,
-      sub: matchingPlayer.id,
-      role: "PLAYER" /* PLAYER */,
-      token: matchingPlayer.token
-    });
-    const cookieName = process.env.NODE_ENV === "production" ? "__Secure-next-auth.session-token" : "next-auth.session-token";
-    (0, import_nookies.setCookie)(ctx, cookieName, jwt, {
-      path: "/",
-      maxAge: 60 * 60 * 24 * 7,
-      httpOnly: process.env.NODE_ENV === "production",
-      secure: process.env.NODE_ENV === "production"
-    });
-  } catch (err) {
-    console.error(err);
-    return null;
-  }
-  return matchingPlayer;
-}
-async function logoutAsTeam(ctx) {
-  if (!ctx.user?.sub)
-    return false;
-  const matchingPlayer = await ctx.prisma.player.findUnique({
-    where: {
-      id: ctx.user.sub
-    }
-  });
-  if (matchingPlayer) {
-    const cookieName = process.env.NODE_ENV === "production" ? "__Secure-next-auth.session-token" : "next-auth.session-token";
-    (0, import_nookies.destroyCookie)(ctx, cookieName);
-    return true;
-  }
-  return false;
-}
-
-// src/services/EventService.ts
-var EventService_exports = {};
-__export(EventService_exports, {
-  publishGlobalNotification: () => publishGlobalNotification,
-  publishUserNotification: () => publishUserNotification,
-  receiveEvent: () => receiveEvent,
-  receiveEvents: () => receiveEvents
-});
-var DB = __toESM(require("@prisma/client"));
-
-// src/lib/pubsub.ts
-var import_graphql_yoga = require("graphql-yoga");
-var pubSub = (0, import_graphql_yoga.createPubSub)();
-
-// src/services/EventService.ts
-async function receiveEvents({ events, ctx, prisma }) {
-  if (!Array.isArray(events))
-    return;
-  const definedEvents = await prisma.event.findMany({
-    include: {
-      achievements: true
-    }
-  });
-  const definedLevels = await prisma.playerLevel.findMany();
-  const promises = await Promise.all(
-    events.map(
-      async (event) => receiveEvent({ ...event, ctx }, definedEvents, definedLevels, prisma)
-    )
-  );
-  const results = prisma.$transaction(promises.flat());
-  return results;
-}
-function prepareAchievementData({
-  achievementId,
-  gameId,
-  periodIx,
-  playerId,
-  count
-}) {
-  return {
-    count,
-    achievement: { connect: { id: achievementId } },
-    game: { connect: { id: gameId } },
-    period: { connect: { gameId_index: { gameId, index: periodIx } } },
-    player: { connect: { id: playerId } }
-  };
-}
-async function receiveEvent(event, definedEvents, definedLevels, prisma) {
-  const matchingEvent = definedEvents.find((item) => item.id === event.type);
-  if (matchingEvent && matchingEvent.achievements?.length > 0) {
-    const awardedAchievements = await matchingEvent.achievements.reduce(
-      async (acc, achievement) => {
-        if (achievement.when === DB.AchievementFrequency.FIRST && event.ctx.achievements.includes(achievement.id)) {
-          return acc;
-        }
-        const existingInstance = await prisma.achievementInstance.findFirst({
-          where: {
-            achievement: {
-              id: achievement.id
-            },
-            player: {
-              id: event.ctx.args.playerId
-            }
-          }
-        });
-        let achievementInstance;
-        if (existingInstance) {
-          achievementInstance = await prisma.achievementInstance.update({
-            where: {
-              id: existingInstance.id
-            },
-            data: prepareAchievementData({
-              count: existingInstance.count + 1,
-              achievementId: achievement.id,
-              gameId: event.ctx.args.gameId,
-              periodIx: event.ctx.args.periodIx,
-              playerId: event.ctx.args.playerId
-            })
-          });
-        } else {
-          achievementInstance = await prisma.achievementInstance.create({
-            data: prepareAchievementData({
-              count: 1,
-              achievementId: achievement.id,
-              gameId: event.ctx.args.gameId,
-              periodIx: event.ctx.args.periodIx,
-              playerId: event.ctx.args.playerId
-            })
-          });
-        }
-        return {
-          achievements: [
-            ...acc.achievements,
-            {
-              achievement,
-              achievementInstance
-            }
-          ],
-          achievementKeys: [...acc.achievementKeys, achievement.id],
-          rewards: {
-            ...acc.rewards,
-            xp: (acc.rewards.xp ?? 0) + (achievement.reward?.xp ?? 0)
-          }
-        };
-      },
-      {
-        achievements: [],
-        achievementKeys: [],
-        rewards: {}
-      }
-    );
-    const currentLevelPlus1 = definedLevels.find(
-      (level) => level.index === event.ctx.currentLevelIx + 1
-    );
-    const currentLevelPlus2 = definedLevels.find(
-      (level) => level.index === event.ctx.currentLevelIx + 2
-    );
-    if (awardedAchievements.achievements.length > 0) {
-      if (event.ctx.experience + awardedAchievements.rewards.xp >= currentLevelPlus1.requiredXP) {
-        publishUserNotification(
-          {
-            user: {
-              sub: event.ctx.args.playerId
-            }
-          },
-          [
-            {
-              type: "ACHIEVEMENT_RECEIVED" /* ACHIEVEMENT_RECEIVED */
-            }
-          ]
-        );
-        publishUserNotification(
-          {
-            user: {
-              sub: event.ctx.args.playerId
-            }
-          },
-          [
-            {
-              type: "LEVEL_UP" /* LEVEL_UP */
-            }
-          ]
-        );
-        return [
-          prisma.player.update({
-            where: {
-              id: event.ctx.args.playerId
-            },
-            data: {
-              experience: {
-                increment: awardedAchievements.rewards.xp
-              },
-              experienceToNext: currentLevelPlus2.requiredXP,
-              level: {
-                connect: {
-                  index: currentLevelPlus1.index
-                }
-              },
-              achievementKeys: {
-                push: awardedAchievements.achievementKeys
-              }
-            }
-          })
-        ];
-      } else {
-        publishUserNotification(
-          {
-            user: {
-              sub: event.ctx.args.playerId
-            }
-          },
-          [
-            {
-              type: "ACHIEVEMENT_RECEIVED" /* ACHIEVEMENT_RECEIVED */
-            }
-          ]
-        );
-        return [
-          prisma.player.update({
-            where: {
-              id: event.ctx.args.playerId
-            },
-            data: {
-              experience: {
-                increment: awardedAchievements.rewards.xp
-              },
-              achievementKeys: {
-                push: awardedAchievements.achievementKeys
-              }
-            }
-          })
-        ];
-      }
-    }
-    return [];
-  }
-  return [];
-}
-function publishGlobalNotification(event) {
-  pubSub.publish("global:events", event);
-}
-function publishUserNotification(ctx, events) {
-  if (events && events.length > 0) {
-    pubSub.publish("user:events", ctx.user.sub, events);
-  }
-}
-
-// src/services/GameService.ts
-var GameService_exports = {};
-__export(GameService_exports, {
-  activateNextPeriod: () => activateNextPeriod,
-  activateNextSegment: () => activateNextSegment,
-  addGamePeriod: () => addGamePeriod,
-  addPeriodSegment: () => addPeriodSegment,
-  computePeriodEndResults: () => computePeriodEndResults,
-  computePeriodStartResults: () => computePeriodStartResults,
-  computeSegmentEndResults: () => computeSegmentEndResults,
-  computeSegmentStartResults: () => computeSegmentStartResults,
-  createGame: () => createGame,
-  getGame: () => getGame,
-  getGameFromContext: () => getGameFromContext,
-  getGames: () => getGames,
-  getLearningElements: () => getLearningElements,
-  updatePlayerData: () => updatePlayerData
-});
-var DB2 = __toESM(require("@prisma/client"));
-var import_nanoid = require("nanoid");
-var import_ramda = require("ramda");
-var yup = __toESM(require("yup"));
-async function createGame({ name, playerCount }, ctx, { roleAssigner }) {
-  return ctx.prisma.game.create({
-    data: {
-      name,
-      owner: {
-        connect: {
-          id: ctx.user.sub
-        }
-      },
-      players: {
-        create: (0, import_ramda.repeat)(0, playerCount).map((_, ix) => {
-          return {
-            facts: {},
-            token: (0, import_nanoid.nanoid)(),
-            role: roleAssigner(ix),
-            number: playerCount - ix,
-            name: `Team ${playerCount - ix}`,
-            level: {
-              connect: {
-                index: 0
-              }
-            }
-          };
-        })
-      }
-    },
-    include: {
-      players: true,
-      periods: true
-    }
-  });
-}
-async function addGamePeriod({ gameId, facts }, ctx, { schema, reducers }) {
-  const validatedFacts = schema.validateSync(facts);
-  const game = await ctx.prisma.game.findUnique({
-    where: {
-      id: gameId
-    },
-    include: {
-      periods: {
-        orderBy: {
-          index: "desc"
-        },
-        take: 1,
-        include: {
-          segments: {
-            orderBy: {
-              index: "desc"
-            },
-            take: 1
-          }
-        }
-      }
-    }
-  });
-  if (!game)
-    return null;
-  const index = game.periods[0]?.index + 1 || 0;
-  const { result: initializedFacts } = reducers.Period.apply(validatedFacts, {
-    type: reducers.Period.ActionTypes.PERIOD_INITIALIZE,
-    payload: {
-      periodFacts: validatedFacts,
-      previousPeriodFacts: game.periods[0]?.facts,
-      previousSegmentFacts: game.periods[0]?.segments[0]?.facts,
-      periodIx: index
-    }
-  });
-  console.log(
-    game.periods[0]?.facts,
-    game.periods[0]?.segments[0]?.facts,
-    initializedFacts
-  );
-  return ctx.prisma.period.upsert({
-    where: {
-      gameId_index: {
-        gameId,
-        index
-      }
-    },
-    create: {
-      index,
-      facts: initializedFacts,
-      game: {
-        connect: {
-          id: gameId
-        }
-      },
-      previousPeriod: {
-        connect: index > 0 ? {
-          gameId_index: {
-            gameId,
-            index: index - 1
-          }
-        } : []
-      }
-    },
-    update: {
-      facts: initializedFacts
-    },
-    include: {
-      segments: {
-        include: {
-          learningElements: true,
-          storyElements: true
-        }
-      }
-    }
-  });
-}
-async function addPeriodSegment({
-  gameId,
-  periodIx,
-  facts,
-  learningElements,
-  storyElements
-}, ctx, { schema, reducers }) {
-  const validatedFacts = schema.validateSync(facts);
-  const period = await ctx.prisma.period.findUnique({
-    where: {
-      gameId_index: {
-        gameId,
-        index: periodIx
-      }
-    },
-    include: {
-      segments: {
-        orderBy: {
-          index: "desc"
-        },
-        take: 1
-      }
-    }
-  });
-  if (!period)
-    return null;
-  const index = period.segments[0]?.index + 1 || 0;
-  const { result: initializedFacts } = reducers.Segment.apply(validatedFacts, {
-    type: reducers.Segment.ActionTypes.SEGMENT_INITIALIZE,
-    payload: {
-      periodFacts: period.facts,
-      previousSegmentFacts: period.segments[0]?.facts,
-      segmentIx: index,
-      segmentCount: 4,
-      periodIx
-    }
-  });
-  return ctx.prisma.periodSegment.upsert({
-    where: {
-      gameId_periodIx_index: {
-        gameId,
-        periodIx,
-        index
-      }
-    },
-    create: {
-      index,
-      facts: initializedFacts,
-      learningElements: {
-        connect: learningElements ? learningElements.map((item) => ({ id: item })) : []
-      },
-      storyElements: {
-        connect: storyElements ? storyElements.map((item) => ({ id: item })) : []
-      },
-      game: {
-        connect: {
-          id: gameId
-        }
-      },
-      periodIx,
-      period: {
-        connect: {
-          gameId_index: {
-            gameId,
-            index: periodIx
-          }
-        }
-      },
-      previousSegment: {
-        connect: index > 0 ? {
-          gameId_periodIx_index: {
-            gameId,
-            periodIx,
-            index: index - 1
-          }
-        } : []
-      }
-    },
-    update: {
-      facts: initializedFacts,
-      learningElements: {
-        connect: learningElements ? learningElements.map((item) => ({ id: item })) : []
-      },
-      storyElements: {
-        connect: storyElements ? storyElements.map((item) => ({ id: item })) : []
-      }
-    },
-    include: {
-      learningElements: true,
-      storyElements: true
-    }
-  });
-}
-async function activateNextPeriod({ gameId }, ctx, { reducers }) {
-  logger_default.info("activating next period");
-  const game = await ctx.prisma.game.findUnique({
-    where: {
-      id: gameId
-    },
-    include: {
-      players: true,
-      periods: true,
-      activePeriod: {
-        include: {
-          results: {
-            include: {
-              player: true
-            }
-          },
-          nextPeriod: true,
-          previousPeriod: {
-            include: {
-              results: {
-                include: {
-                  player: true
-                }
-              }
-            }
-          },
-          activeSegment: {
-            include: {
-              results: {
-                include: {
-                  player: true
-                }
-              }
-            }
-          },
-          decisions: {
-            include: {
-              player: true
-            }
-          }
-        }
-      }
-    }
-  });
-  if (!game)
-    return null;
-  logger_default.info(`game found, status ${game.status}`);
-  const currentPeriodIx = game.activePeriodIx;
-  const currentSegmentIx = game.activePeriod?.activeSegmentIx;
-  const nextPeriodIx = currentPeriodIx + 1;
-  switch (game.status) {
-    case DB2.GameStatus.SCHEDULED: {
-      const { results, extras } = computePeriodStartResults(
-        {
-          results: void 0,
-          players: game.players,
-          activePeriodIx: currentPeriodIx,
-          gameId: game.id,
-          periodFacts: game.periods?.[0].facts
-        },
-        ctx,
-        { reducers }
-      );
-      const result = await ctx.prisma.$transaction([
-        ctx.prisma.game.update({
-          where: {
-            id: gameId
-          },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            }
-          },
-          data: {
-            status: DB2.GameStatus.PREPARATION,
-            activePeriodIx: nextPeriodIx,
-            activePeriod: {
-              connect: {
-                gameId_index: {
-                  gameId,
-                  index: nextPeriodIx
-                }
-              }
-            }
-          }
-        }),
-        ctx.prisma.period.update({
-          where: {
-            gameId_index: {
-              gameId,
-              index: nextPeriodIx
-            }
-          },
-          data: {
-            results: {
-              create: results
-            }
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    case DB2.GameStatus.RUNNING: {
-      if (!game.activePeriod?.activeSegment || !currentSegmentIx)
-        return null;
-      const { results, extras } = computeSegmentEndResults(game, ctx, {
-        reducers
-      });
-      const { result: consolidatedFacts } = reducers.Period.apply(
-        game.activePeriod.facts,
-        {
-          type: reducers.Period.ActionTypes.PERIOD_CONSOLIDATE,
-          payload: {
-            previousSegmentFacts: game.activePeriod.activeSegment.facts,
-            periodIx: currentPeriodIx
-          }
-        }
-      );
-      const result = await ctx.prisma.$transaction([
-        ctx.prisma.game.update({
-          data: {
-            status: DB2.GameStatus.CONSOLIDATION
-          },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            }
-          },
-          where: {
-            id: gameId
-          }
-        }),
-        ctx.prisma.period.update({
-          where: {
-            gameId_index: {
-              gameId,
-              index: currentPeriodIx
-            }
-          },
-          data: {
-            facts: consolidatedFacts
-          }
-        }),
-        ctx.prisma.periodSegment.update({
-          where: {
-            gameId_periodIx_index: {
-              gameId,
-              periodIx: currentPeriodIx,
-              index: currentSegmentIx
-            }
-          },
-          data: {
-            results: {
-              // compute SEGMENT_END results using model
-              update: results
-            }
-          },
-          include: {
-            results: {
-              include: {
-                player: true
-              }
-            }
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    case DB2.GameStatus.CONSOLIDATION: {
-      if (!game.activePeriod?.activeSegment)
-        return null;
-      const { results, extras, promises } = await computePeriodEndResults(
-        {
-          segmentResults: game.activePeriod.activeSegment.results,
-          segmentFacts: game.activePeriod.activeSegment.facts,
-          periodFacts: game.activePeriod.facts,
-          periodDecisions: game.activePeriod.decisions,
-          activePeriodIx: currentPeriodIx,
-          activeSegmentIx: currentSegmentIx,
-          gameId: game.id
-        },
-        ctx,
-        { reducers }
-      );
-      await Promise.all(promises);
-      const result = await ctx.prisma.$transaction([
-        // update the status and active period of the current game
-        ctx.prisma.game.update({
-          where: {
-            id: gameId
-          },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            }
-          },
-          data: {
-            status: DB2.GameStatus.RESULTS,
-            activePeriodIx: nextPeriodIx,
-            activePeriod: {
-              connect: {
-                gameId_index: {
-                  gameId,
-                  index: nextPeriodIx
-                }
-              }
-            }
-          }
-        }),
-        // create PERIOD_END results based on the previous SEGMENT_END results
-        ctx.prisma.period.update({
-          where: {
-            gameId_index: {
-              gameId,
-              index: currentPeriodIx
-            }
-          },
-          data: {
-            results: {
-              create: results
-            }
-          },
-          include: {
-            results: true
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    case DB2.GameStatus.RESULTS: {
-      if (!game.activePeriod) {
-        logger_default.warn("no next period available");
-        return null;
-      }
-      const { results, extras } = computePeriodStartResults(
-        {
-          results: game.activePeriod.previousPeriod[0].results,
-          players: game.players,
-          activePeriodIx: currentPeriodIx,
-          gameId: game.id,
-          periodFacts: game.activePeriod.facts
-        },
-        ctx,
-        { reducers }
-      );
-      const result = await ctx.prisma.$transaction([
-        // update the status and active period of the current game
-        ctx.prisma.game.update({
-          where: {
-            id: gameId
-          },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            }
-          },
-          data: {
-            status: DB2.GameStatus.PREPARATION
-          }
-        }),
-        // create PERIOD_START results based on the previous PERIOD_END results
-        ctx.prisma.period.update({
-          where: {
-            gameId_index: {
-              gameId,
-              index: currentPeriodIx
-            }
-          },
-          data: {
-            results: {
-              create: results
-            }
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    default:
-      return null;
-  }
-}
-async function activateNextSegment({ gameId }, ctx, { reducers }) {
-  const game = await ctx.prisma.game.findUnique({
-    where: {
-      id: gameId
-    },
-    include: {
-      players: true,
-      periods: true,
-      segments: true,
-      activePeriod: {
-        include: {
-          results: {
-            include: {
-              player: true
-            }
-          },
-          activeSegment: {
-            include: {
-              nextSegment: true,
-              results: {
-                include: {
-                  player: true
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  });
-  if (!game?.activePeriod)
-    return null;
-  const currentPeriodIx = game.activePeriodIx;
-  const currentSegmentIx = game.activePeriod.activeSegmentIx;
-  const nextSegmentIx = currentSegmentIx + 1;
-  switch (game.status) {
-    case DB2.GameStatus.PREPARATION:
-    case DB2.GameStatus.PAUSED: {
-      const { results, extras } = computeSegmentStartResults(game, ctx, {
-        reducers
-      });
-      const result = await ctx.prisma.$transaction([
-        ctx.prisma.game.update({
-          where: {
-            id: gameId
-          },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            },
-            players: true
-          },
-          data: {
-            status: DB2.GameStatus.RUNNING
-          }
-        }),
-        // update the active segment of the current period
-        ctx.prisma.period.update({
-          where: {
-            gameId_index: {
-              gameId,
-              index: currentPeriodIx
-            }
-          },
-          data: {
-            activeSegmentIx: nextSegmentIx,
-            activeSegment: {
-              connect: {
-                gameId_periodIx_index: {
-                  gameId,
-                  periodIx: currentPeriodIx,
-                  index: nextSegmentIx
-                }
-              }
-            }
-          }
-        }),
-        // SEGMENT INITIALIZATION
-        ctx.prisma.periodSegment.update({
-          where: {
-            gameId_periodIx_index: {
-              gameId,
-              periodIx: currentPeriodIx,
-              index: nextSegmentIx
-            }
-          },
-          data: {
-            results: {
-              create: results
-            }
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    case DB2.GameStatus.RUNNING: {
-      if (!game.activePeriod?.activeSegment?.nextSegment) {
-        return null;
-      }
-      const { results, extras } = computeSegmentEndResults(game, ctx, {
-        reducers
-      });
-      const result = await ctx.prisma.$transaction([
-        ctx.prisma.game.update({
-          where: { id: gameId },
-          include: {
-            periods: {
-              include: {
-                segments: true
-              }
-            },
-            players: true
-          },
-          data: {
-            status: DB2.GameStatus.PAUSED
-          }
-        }),
-        ctx.prisma.periodSegment.update({
-          where: {
-            gameId_periodIx_index: {
-              gameId,
-              periodIx: currentPeriodIx,
-              index: currentSegmentIx
-            }
-          },
-          data: {
-            results: {
-              update: results
-            }
-          },
-          include: {
-            results: true
-          }
-        }),
-        // reset player readiness
-        ctx.prisma.player.updateMany({
-          where: {
-            game: {
-              id: gameId
-            }
-          },
-          data: {
-            isReady: false
-          }
-        }),
-        ...extras
-      ]);
-      return result;
-    }
-    default:
-      return null;
-  }
-}
-var PlayerFactsSchema = yup.object({
-  location: yup.string().default("Zurich")
-});
-async function updatePlayerData({ name, avatar, color, facts }, ctx) {
-  if ((0, import_ramda.none)(Boolean, [name, avatar, color, facts])) {
-    return null;
-  }
-  let data = {};
-  if (name) {
-    data["name"] = name;
-  }
-  if (avatar) {
-    data["avatar"] = avatar;
-  }
-  if (color) {
-    data["color"] = color;
-  }
-  if (facts) {
-    data["facts"] = PlayerFactsSchema.validateSync(facts, {
-      stripUnknown: true
-    });
-  }
-  const player = await ctx.prisma.player.update({
-    where: {
-      id: ctx.user.sub
-    },
-    data,
-    include: {
-      level: true,
-      achievements: {
-        include: {
-          achievement: true
-        }
-      }
-    }
-  });
-  return player;
-}
-async function getGames(args, ctx) {
-  return ctx.prisma.game.findMany();
-}
-async function getGame(args, ctx) {
-  const gameId = args.id ?? ctx.user.gameId;
-  if (!gameId) {
-    return null;
-  }
-  return ctx.prisma.game.findUnique({
-    where: {
-      id: args.id
-    },
-    include: {
-      players: {
-        include: {
-          level: true,
-          achievements: true
-        },
-        orderBy: {
-          number: "asc"
-        }
-      },
-      periods: {
-        orderBy: {
-          index: "asc"
-        },
-        include: {
-          segments: {
-            orderBy: {
-              index: "asc"
-            },
-            include: {
-              learningElements: true,
-              storyElements: true
-            }
-          }
-        }
-      },
-      activePeriod: {
-        include: {
-          segments: true,
-          activeSegment: true
-        }
-      }
-    }
-  });
-}
-async function getGameFromContext(ctx) {
-  return ctx.prisma.game.findUnique({
-    where: {
-      id: ctx.user.gameId
-    },
-    include: {
-      activePeriod: true
-    }
-  });
-}
-async function getLearningElements(args, ctx) {
-  return ctx.prisma.learningElement.findMany({
-    include: {
-      options: true
-    }
-  });
-}
-function mapAction({ ctx, gameId, activePeriodIx, playerId }) {
-  return (action) => ctx.prisma.playerAction.create({
-    data: {
-      type: action.type,
-      facts: action.facts,
-      game: {
-        connect: { id: gameId }
-      },
-      player: {
-        connect: { id: playerId }
-      },
-      periodIx: activePeriodIx,
-      period: {
-        connect: {
-          gameId_index: {
-            gameId,
-            index: activePeriodIx
-          }
-        }
-      },
-      segmentIx: typeof action.segment === "number" ? action.segment : void 0,
-      segment: typeof action.segment === "number" ? {
-        connect: {
-          gameId_periodIx_index: {
-            gameId,
-            periodIx: activePeriodIx,
-            index: action.segment
-          }
-        }
-      } : void 0
-    }
-  });
-}
-function computePeriodStartResults({ results, players, activePeriodIx, gameId, periodFacts }, ctx, { reducers }) {
-  const currentPeriodIx = activePeriodIx;
-  const nextPeriodIx = currentPeriodIx + 1;
-  let extras = [];
-  if (currentPeriodIx >= 0) {
-    const result2 = results.filter((result3) => result3.type === DB2.PlayerResultType.PERIOD_END).map((result3, ix, allResults) => {
-      const { result: facts, actions } = reducers.PeriodResult.apply(result3, {
-        type: reducers.PeriodResult.ActionTypes.PERIOD_RESULTS_START,
-        payload: {
-          playerRole: result3.player.role ?? result3.player.connect.role,
-          periodFacts
-        }
-      });
-      const mapper = mapAction({
-        ctx,
-        gameId,
-        activePeriodIx: currentPeriodIx,
-        playerId: result3.player.id
-      });
-      if (actions && actions.length > 0) {
-        extras = [...extras, ...actions.map(mapper)];
-      }
-      return {
-        type: DB2.PlayerResultType.PERIOD_START,
-        periodIx: currentPeriodIx,
-        facts,
-        player: {
-          connect: {
-            id: result3.player.id ?? result3.player.connect.id
-          }
-        },
-        game: {
-          connect: {
-            id: gameId
-          }
-        }
-      };
-    });
-    return {
-      results: result2,
-      extras
-    };
-  }
-  const result = players.map((player, ix, allPlayers) => {
-    const { result: facts, actions } = reducers.PeriodResult.apply(
-      {},
-      {
-        type: reducers.PeriodResult.ActionTypes.PERIOD_RESULTS_INITIALIZE,
-        payload: {
-          playerRole: player.role,
-          periodFacts
-        }
-      }
-    );
-    const mapper = mapAction({
-      ctx,
-      gameId,
-      activePeriodIx: nextPeriodIx,
-      playerId: player.id
-    });
-    if (actions && actions.length > 0) {
-      extras = [...extras, ...actions.map(mapper)];
-    }
-    return {
-      type: DB2.PlayerResultType.PERIOD_START,
-      periodIx: nextPeriodIx,
-      facts,
-      player: {
-        connect: {
-          id: player.id
-        }
-      },
-      game: {
-        connect: {
-          id: gameId
-        }
-      }
-    };
-  });
-  return {
-    results: result,
-    extras
-  };
-}
-async function computePeriodEndResults({
-  segmentResults,
-  periodFacts,
-  periodDecisions,
-  segmentFacts,
-  activePeriodIx,
-  activeSegmentIx,
-  gameId
-}, ctx, { reducers }) {
-  let extras = [];
-  let promises = [];
-  const results = segmentResults.filter((result) => result.type === DB2.PlayerResultType.SEGMENT_END).map((result, ix, allResults) => {
-    const consolidationDecisions = periodDecisions.find(
-      (decision) => decision.playerId === result.playerId
-    );
-    const {
-      result: facts,
-      actions,
-      events
-    } = reducers.PeriodResult.apply(result.facts, {
-      type: reducers.PeriodResult.ActionTypes.PERIOD_RESULTS_END,
-      payload: {
-        periodFacts,
-        segmentFacts,
-        playerRole: result.player.role,
-        playerLevel: result.player.levelIx + 1,
-        playerExperience: result.player.experience,
-        consolidationDecisions,
-        periodIx: activePeriodIx,
-        segmentIx: activeSegmentIx
-      }
-    });
-    logger_default.debug(actions);
-    const mapper = mapAction({
-      ctx,
-      gameId,
-      activePeriodIx,
-      playerId: result.player.id
-    });
-    if (actions && actions.length > 0) {
-      extras = [...extras, ...actions.map(mapper)];
-    }
-    promises = [
-      ...promises,
-      receiveEvents({
-        events,
-        ctx: {
-          args: {
-            playerId: result.player.id,
-            periodIx: activePeriodIx,
-            gameId
-          },
-          user: ctx.user,
-          achievements: result.player.achievementKeys,
-          experience: result.player.experience,
-          currentLevelIx: result.player.levelIx
-        },
-        prisma: ctx.prisma
-      })
-    ];
-    return {
-      type: DB2.PlayerResultType.PERIOD_END,
-      periodIx: activePeriodIx,
-      facts,
-      player: {
-        connect: {
-          id: result.playerId
-        }
-      },
-      game: {
-        connect: {
-          id: gameId
-        }
-      }
-    };
-  });
-  return {
-    extras,
-    results,
-    promises
-  };
-}
-function computeSegmentStartResults(game, ctx, { reducers }) {
-  const currentSegmentIx = game.activePeriod.activeSegmentIx;
-  const nextSegmentIx = currentSegmentIx + 1;
-  let extras = [];
-  if (currentSegmentIx >= 0) {
-    const results2 = game.activePeriod.activeSegment.results.filter((result) => result.type === DB2.PlayerResultType.SEGMENT_END).reduce((acc, result, ix, allResults) => {
-      const { result: facts, actions } = reducers.SegmentResult.apply(
-        result.facts,
-        {
-          type: reducers.SegmentResult.ActionTypes.SEGMENT_RESULTS_START,
-          payload: {
-            playerRole: result.player.role,
-            periodFacts: game.activePeriod.facts,
-            segmentFacts: game.activePeriod.activeSegment.facts,
-            nextSegmentFacts: game.activePeriod.activeSegment.nextSegment?.facts,
-            segmentIx: nextSegmentIx
-          }
-        }
-      );
-      const mapper = mapAction({
-        ctx,
-        gameId: game.id,
-        activePeriodIx: game.activePeriodIx,
-        playerId: result.player.id
-      });
-      if (actions && actions.length > 0) {
-        extras = [...extras, ...actions.map(mapper)];
-      }
-      const common = {
-        facts,
-        periodIx: game.activePeriodIx,
-        segmentIx: nextSegmentIx,
-        player: {
-          connect: {
-            id: result.playerId
-          }
-        },
-        period: {
-          connect: {
-            id: game.activePeriodId
-          }
-        },
-        game: {
-          connect: {
-            id: game.id
-          }
-        }
-      };
-      return [
-        ...acc,
-        {
-          ...common,
-          type: DB2.PlayerResultType.SEGMENT_START
-        },
-        {
-          ...common,
-          type: DB2.PlayerResultType.SEGMENT_END
-        }
-      ];
-    }, []);
-    return {
-      results: results2,
-      extras
-    };
-  }
-  const results = game.activePeriod.results.filter((result) => result.type === DB2.PlayerResultType.PERIOD_START).reduce((acc, result, ix, allResults) => {
-    const { result: facts } = reducers.SegmentResult.apply(result.facts, {
-      type: reducers.SegmentResult.ActionTypes.SEGMENT_RESULTS_INITIALIZE,
-      payload: {
-        playerRole: result.player.role,
-        periodFacts: game.activePeriod.facts,
-        segmentFacts: game.activePeriod.activeSegment?.facts,
-        nextSegmentFacts: game.activePeriod.activeSegment?.nextSegment?.facts,
-        segmentIx: nextSegmentIx
-      }
-    });
-    const common = {
-      facts,
-      periodIx: game.activePeriodIx,
-      segmentIx: nextSegmentIx,
-      player: {
-        connect: {
-          id: result.playerId
-        }
-      },
-      period: {
-        connect: {
-          id: game.activePeriodId
-        }
-      },
-      game: {
-        connect: {
-          id: game.id
-        }
-      }
-    };
-    return [
-      ...acc,
-      {
-        ...common,
-        type: DB2.PlayerResultType.SEGMENT_START
-      },
-      {
-        ...common,
-        type: DB2.PlayerResultType.SEGMENT_END
-      }
-    ];
-  }, []);
-  return {
-    results,
-    extras
-  };
-}
-function computeSegmentEndResults(game, ctx, { reducers }) {
-  let extras = [];
-  const results = game.activePeriod.activeSegment.results.filter((result) => result.type === DB2.PlayerResultType.SEGMENT_END).map((result, ix, allResults) => {
-    const { result: facts, actions } = reducers.SegmentResult.apply(
-      result.facts,
-      {
-        type: reducers.SegmentResult.ActionTypes.SEGMENT_RESULTS_END,
-        payload: {
-          playerRole: result.player.role,
-          periodFacts: game.activePeriod.facts,
-          segmentFacts: game.activePeriod.activeSegment.facts,
-          segmentIx: game.activePeriod.activeSegmentIx
-        }
-      }
-    );
-    const mapper = mapAction({
-      ctx,
-      gameId: game.id,
-      activePeriodIx: game.activePeriodIx,
-      playerId: result.player.id
-    });
-    if (actions && actions.length > 0) {
-      extras = [...extras, ...actions.map(mapper)];
-    }
-    return {
-      where: {
-        periodIx_segmentIx_playerId_type: {
-          periodIx: game.activePeriodIx,
-          segmentIx: game.activePeriod.activeSegmentIx,
-          playerId: result.playerId,
-          type: DB2.PlayerResultType.SEGMENT_END
-        }
-      },
-      data: {
-        facts,
-        game: {
-          connect: {
-            id: game.id
-          }
-        }
-      }
-    };
-  });
-  return {
-    results,
-    extras
-  };
-}
-
-// src/services/PlayService.ts
-var PlayService_exports = {};
-__export(PlayService_exports, {
-  addCountdown: () => addCountdown,
-  attemptLearningElement: () => attemptLearningElement,
-  getLearningElement: () => getLearningElement,
-  getPastResults: () => getPastResults,
-  getPlayerData: () => getPlayerData,
-  getPlayerResult: () => getPlayerResult,
-  getPlayerResults: () => getPlayerResults,
-  getPlayerTransactions: () => getPlayerTransactions,
-  markStoryElement: () => markStoryElement,
-  performAction: () => performAction,
-  saveDecisions: () => saveDecisions,
-  updateReadyState: () => updateReadyState
-});
-var DB3 = __toESM(require("@prisma/client"));
-async function performAction(args, ctx, { reducers }) {
-  const periodIx_segmentIx_playerId_type = {
-    periodIx: args.periodIx,
-    segmentIx: args.segmentIx,
-    playerId: args.playerId,
-    type: DB3.PlayerResultType.SEGMENT_END
-  };
-  const previousResult = await ctx.prisma.playerResult.findUnique({
-    where: {
-      periodIx_segmentIx_playerId_type
-    },
-    include: {
-      game: true,
-      segment: true,
-      period: true,
-      player: true
-    }
-  });
-  if (!previousResult)
-    return null;
-  if (previousResult.game.status !== DB3.GameStatus.RUNNING) {
-    throw new Error("ACTIONS_NOT_ALLOWED");
-  }
-  const { result, events, notifications, isDirty, extras } = reducers.Actions.apply(previousResult.facts, {
-    type: args.actionType,
-    payload: {
-      playerArgs: args.facts,
-      segmentFacts: previousResult.segment?.facts,
-      periodFacts: previousResult.period.facts
-    }
-  });
-  publishUserNotification(ctx, notifications);
-  await receiveEvents({
-    events,
-    ctx: {
-      user: ctx.user,
-      args,
-      achievements: previousResult.player.achievementKeys,
-      experience: previousResult.player.experience,
-      currentLevelIx: previousResult.player.levelIx
-    },
-    prisma: ctx.prisma
-  });
-  if (!isDirty) {
-    return previousResult;
-  }
-  const [updatedResult, _] = await ctx.prisma.$transaction([
-    ctx.prisma.playerResult.update({
-      where: {
-        periodIx_segmentIx_playerId_type
-      },
-      data: {
-        facts: result
-      },
-      include: {
-        period: true
-      }
-    }),
-    ctx.prisma.playerAction.create({
-      data: {
-        periodIx: args.periodIx,
-        period: {
-          connect: {
-            gameId_index: {
-              gameId: args.gameId,
-              index: args.periodIx
-            }
-          }
-        },
-        segmentIx: args.segmentIx,
-        segment: {
-          connect: {
-            gameId_periodIx_index: {
-              gameId: args.gameId,
-              periodIx: args.periodIx,
-              index: args.segmentIx
-            }
-          }
-        },
-        game: {
-          connect: {
-            id: args.gameId
-          }
-        },
-        player: {
-          connect: {
-            id: args.playerId
-          }
-        },
-        type: args.actionType,
-        facts: {
-          ...args.facts,
-          ...extras
-        }
-      }
-    })
-  ]);
-  return updatedResult;
-}
-async function saveDecisions(args, ctx) {
-  const game = await ctx.prisma.game.findUnique({
-    where: {
-      id: ctx.user.gameId
-    },
-    include: {
-      activePeriod: {
-        include: {
-          activeSegment: true
-        }
-      }
-    }
-  });
-  if (!game?.activePeriod)
-    return null;
-  if (args.decisionType !== game.status) {
-    throw new Error("INVALID_DECISION");
-  }
-  const periodIx = game.activePeriod.index;
-  const savedDecision = ctx.prisma.playerDecision.upsert({
-    where: {
-      playerId_periodIx_type: {
-        periodIx,
-        playerId: ctx.user.sub,
-        type: args.decisionType
-      }
-    },
-    create: {
-      facts: args.facts,
-      type: args.decisionType,
-      periodIx,
-      period: {
-        connect: {
-          gameId_index: {
-            gameId: game.id,
-            index: periodIx
-          }
-        }
-      },
-      game: {
-        connect: {
-          id: game.id
-        }
-      },
-      player: {
-        connect: {
-          id: ctx.user.sub
-        }
-      }
-    },
-    update: {
-      facts: args.facts
-    }
-  });
-  return savedDecision;
-}
-async function getPlayerResult(args, ctx) {
-  const currentGame = await ctx.prisma.game.findUnique({
-    where: {
-      id: args.gameId
-    },
-    include: {
-      activePeriod: {
-        include: {
-          activeSegment: {
-            include: {
-              learningElements: true,
-              storyElements: true
-            }
-          },
-          segments: {
-            include: {
-              learningElements: true,
-              storyElements: true
-            }
-          }
-        }
-      },
-      periods: {
-        include: {
-          segments: {
-            include: {
-              learningElements: true,
-              storyElements: true
-            }
-          }
-        }
-      }
-    }
-  });
-  if (!currentGame?.activePeriod)
-    return null;
-  const previousResults = ctx.prisma.playerResult.findMany({
-    where: {
-      playerId: args.playerId,
-      periodIx: {
-        lte: currentGame.activePeriod.index
-      }
-    },
-    include: {
-      period: true,
-      segment: true
-    }
-  });
-  const playerResult = await ctx.prisma.playerResult.findUnique({
-    where: {
-      periodIx_segmentIx_playerId_type: {
-        periodIx: currentGame.activePeriodIx,
-        segmentIx: currentGame.activePeriod.activeSegmentIx,
-        playerId: args.playerId,
-        type: DB3.PlayerResultType.SEGMENT_END
-      }
-    },
-    include: {
-      period: true,
-      player: {
-        include: {
-          completedLearningElements: true,
-          visitedStoryElements: true
-        }
-      }
-    }
-  });
-  const transactions = ctx.prisma.playerAction.findMany({
-    where: {
-      player: {
-        id: args.playerId
-      }
-    },
-    orderBy: {
-      createdAt: "asc"
-    }
-  });
-  return {
-    currentGame,
-    playerResult,
-    previousResults,
-    transactions
-  };
-}
-async function getPlayerData(args, ctx) {
-  return ctx.prisma.player.findUnique({
-    where: {
-      id: args.playerId
-    },
-    include: {
-      level: true,
-      achievements: {
-        include: {
-          achievement: true
-        }
-      }
-    }
-  });
-}
-async function getLearningElement(args, ctx) {
-  const playerWithLearningElements = await ctx.prisma.player.findUnique({
-    where: {
-      id: ctx.user.sub
-    },
-    include: {
-      completedLearningElements: {
-        where: {
-          id: args.id
-        }
-      }
-    }
-  });
-  if (!playerWithLearningElements)
-    return null;
-  const elementSolved = playerWithLearningElements.completedLearningElements.length > 0;
-  const element = await ctx.prisma.learningElement.findUnique({
-    where: {
-      id: args.id
-    },
-    include: {
-      options: true
-    }
-  });
-  if (!element)
-    return null;
-  return {
-    id: args.id,
-    element: {
-      ...element,
-      feedback: elementSolved ? element.feedback : null
-    },
-    state: elementSolved ? "SOLVED" /* SOLVED */ : "NEW" /* NEW */,
-    solution: elementSolved ? JSON.stringify(
-      element.options.flatMap((option, ix) => option.correct ? [ix] : [])
-    ) : null
-  };
-}
-async function attemptLearningElement(args, ctx) {
-  const learningElement = await ctx.prisma.learningElement.findUnique({
-    where: { id: args.elementId },
-    include: { options: true }
-  });
-  if (!learningElement)
-    return null;
-  try {
-    const selectedOptions = JSON.parse(args.selection);
-    const pointsAchieved = learningElement.options.reduce((acc, option, ix) => {
-      if (option.correct && selectedOptions.includes(ix)) {
-        return acc + 1;
-      }
-      if (!option.correct && !selectedOptions.includes(ix)) {
-        return acc + 1;
-      }
-      return acc;
-    }, 0);
-    const pointsMax = learningElement.options.length;
-    let updatedPlayer;
-    if (pointsAchieved === pointsMax) {
-      updatedPlayer = await ctx.prisma.player.update({
-        where: {
-          id: ctx.user.sub
-        },
-        data: {
-          completedLearningElements: {
-            connect: {
-              id: args.elementId
-            }
-          },
-          completedLearningElementIds: {
-            push: args.elementId
-          }
-        },
-        include: {
-          game: {
-            select: {
-              activePeriodIx: true
-            }
-          }
-        }
-      });
-      await receiveEvents({
-        events: [
-          {
-            type: "LEARNING_ELEMENT_SOLVED" /* LEARNING_ELEMENT_SOLVED */,
-            facts: {
-              elementId: args.elementId
-            }
-          }
-        ],
-        ctx: {
-          user: ctx.user,
-          args: {
-            gameId: ctx.user.gameId,
-            periodIx: updatedPlayer.game.activePeriodIx,
-            playerId: ctx.user.sub
-          },
-          achievements: updatedPlayer.achievementKeys,
-          experience: updatedPlayer.experience,
-          currentLevelIx: updatedPlayer.levelIx
-        },
-        prisma: ctx.prisma
-      });
-    } else {
-      publishUserNotification(ctx, [
-        {
-          type: "LEARNING_ELEMENT_INCORRECT" /* LEARNING_ELEMENT_INCORRECT */
-        }
-      ]);
-    }
-    return {
-      id: args.elementId,
-      pointsAchieved,
-      pointsMax,
-      element: {
-        id: args.elementId,
-        feedback: learningElement.feedback
-      },
-      player: updatedPlayer
-    };
-  } catch (e) {
-    console.warn(e);
-    return null;
-  }
-}
-async function markStoryElement(args, ctx) {
-  const storyElement = await ctx.prisma.storyElement.findUnique({
-    where: { id: args.elementId }
-  });
-  if (!storyElement)
-    return null;
-  return ctx.prisma.player.update({
-    where: {
-      id: ctx.user.sub
-    },
-    data: {
-      visitedStoryElements: {
-        connect: {
-          id: args.elementId
-        }
-      },
-      visitedStoryElementIds: {
-        push: args.elementId
-      }
-    }
-  });
-}
-async function getPlayerTransactions(args, ctx) {
-  const playerActions = ctx.prisma.playerAction.findMany({
-    where: {
-      player: {
-        id: ctx.user.sub
-      }
-    },
-    orderBy: {
-      createdAt: "asc"
-    }
-  });
-  return playerActions;
-}
-async function getPlayerResults(args, ctx) {
-  const playerResults = await ctx.prisma.playerResult.findMany({
-    where: {
-      gameId: ctx.user.gameId
-    },
-    include: {
-      period: true,
-      player: true,
-      segment: true
-    }
-  });
-  return playerResults;
-}
-async function getPastResults(args, ctx) {
-  const currentGame = await ctx.prisma.game.findUnique({
-    where: { id: ctx.user.gameId }
-  });
-  if (!currentGame)
-    return null;
-  const playerResults = await ctx.prisma.playerResult.findMany({
-    where: {
-      gameId: ctx.user.gameId,
-      periodIx: {
-        lt: currentGame.activePeriodIx
-      },
-      type: "PERIOD_END"
-    },
-    include: {
-      period: true,
-      player: {
-        include: {
-          level: true
-        }
-      }
-    }
-  });
-  return playerResults;
-}
-async function updateReadyState(args, ctx) {
-  return ctx.prisma.player.update({
-    where: {
-      id: ctx.user.sub
-    },
-    data: {
-      isReady: args.isReady
-    }
-  });
-}
-async function addCountdown(args, ctx) {
-  const currentGame = await ctx.prisma.game.findUnique({
-    where: { id: args.gameId },
-    include: {
-      activePeriod: {
-        include: {
-          activeSegment: true
-        }
-      }
-    }
-  });
-  if (!currentGame?.activePeriod?.activeSegment)
-    return null;
-  await ctx.prisma.periodSegment.update({
-    where: {
-      id: currentGame.activePeriod.activeSegment.id
-    },
-    data: {
-      countdownExpiresAt: new Date(Date.now() + args.seconds * 1e3)
-    }
-  });
-  return true;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AccountService,
-  BaseGlobalNotificationType,
-  BaseUserNotificationType,
-  EventService,
-  GameService,
-  LearningElementState,
-  PlayService,
-  UserRole,
-  log
-});
+export { default as log } from './lib/logger.js';
+import * as AccountService from './services/AccountService.js';
+export { AccountService };
+import * as EventService from './services/EventService.js';
+export { EventService };
+import * as GameService from './services/GameService.js';
+export { GameService };
+import * as PlayService from './services/PlayService.js';
+export { PlayService };
+export { BaseGlobalNotificationType, BaseUserNotificationType, LearningElementState, UserRole } from './types.js';
+//# sourceMappingURL=index.js.map