@gbl-uzh/platform 0.4.13 → 0.4.16

package/dist/nexus.js

@@ -1,2608 +1,25 @@
-"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/nexus.ts
-var nexus_exports = {};
-__export(nexus_exports, {
-  DateScalar: () => DateScalar,
-  Event: () => Event,
-  Game: () => Game,
-  GameStatus: () => GameStatus2,
-  JsonScalar: () => JsonScalar,
-  LearningAnswerOption: () => LearningAnswerOption,
-  LearningElement: () => LearningElement,
-  LearningElementAttempt: () => LearningElementAttempt,
-  LearningElementState: () => LearningElementState,
-  Mutation: () => Mutation,
-  Period: () => Period,
-  PeriodSegment: () => PeriodSegment,
-  Player: () => Player,
-  PlayerAction: () => PlayerAction,
-  PlayerDecision: () => PlayerDecision,
-  PlayerDecisionType: () => PlayerDecisionType2,
-  PlayerLevel: () => PlayerLevel,
-  PlayerResult: () => PlayerResult,
-  PlayerResultType: () => PlayerResultType2,
-  PlayerState: () => PlayerState,
-  Query: () => Query,
-  Subscription: () => Subscription,
-  UserRole: () => UserRole3,
-  generateBaseMutations: () => generateBaseMutations,
-  generateBaseQueries: () => generateBaseQueries,
-  generateBaseSubscriptions: () => generateBaseSubscriptions
-});
-module.exports = __toCommonJS(nexus_exports);
-var DB9 = __toESM(require("@prisma/client"));
-var import_graphql_scalars = require("graphql-scalars");
-var import_nexus10 = require("nexus");
-
-// src/types/Game.ts
-var DB4 = __toESM(require("@prisma/client"));
-var import_nexus5 = require("nexus");
-
-// src/types/LearningElement.ts
-var import_nexus4 = require("nexus");
-
-// src/types/Player.ts
-var DB3 = __toESM(require("@prisma/client"));
-var import_nexus3 = require("nexus");
-
-// src/types/Achievement.ts
-var DB = __toESM(require("@prisma/client"));
-var import_nexus = require("nexus");
-var AchievementFrequency2 = (0, import_nexus.enumType)({
-  name: "AchievementFrequency",
-  members: Object.values(DB.AchievementFrequency)
-});
-var Achievement = (0, import_nexus.objectType)({
-  name: "Achievement",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.string("name");
-    t.nonNull.string("description");
-    t.string("image");
-    t.nonNull.field("when", {
-      type: AchievementFrequency2
-    });
-    t.field("reward", {
-      type: "JSONObject"
-    });
-  }
-});
-var AchievementInstance = (0, import_nexus.objectType)({
-  name: "AchievementInstance",
-  definition(t) {
-    t.nonNull.int("id");
-    t.nonNull.int("count");
-    t.nonNull.field("achievement", {
-      type: Achievement
-    });
-  }
-});
-
-// src/types/StoryElement.ts
-var DB2 = __toESM(require("@prisma/client"));
-var import_nexus2 = require("nexus");
-var StoryElementType2 = (0, import_nexus2.enumType)({
-  name: "StoryElementType",
-  members: Object.values(DB2.StoryElementType)
-});
-var StoryElement = (0, import_nexus2.objectType)({
-  name: "StoryElement",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.field("type", {
-      type: StoryElementType2
-    });
-    t.nonNull.string("title");
-    t.string("content");
-    t.field("contentRole", {
-      type: "JSONObject"
-    });
-    t.field("reward", {
-      type: "JSONObject"
-    });
-  }
-});
-
-// src/types/Player.ts
-var PlayerDecisionType2 = (0, import_nexus3.enumType)({
-  name: "PlayerDecisionType",
-  members: Object.values(DB3.PlayerDecisionType)
-});
-var PlayerResultType2 = (0, import_nexus3.enumType)({
-  name: "PlayerResultType",
-  members: Object.values(DB3.PlayerResultType)
-});
-var PlayerLevel = (0, import_nexus3.objectType)({
-  name: "PlayerLevel",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.int("index");
-    t.nonNull.string("description");
-    t.nonNull.int("requiredXP");
-  }
-});
-var PlayerState = (0, import_nexus3.objectType)({
-  name: "PlayerState",
-  definition(t) {
-    t.field("playerResult", {
-      type: PlayerResult
-    });
-    t.field("currentGame", {
-      type: Game
-    });
-    t.list.nonNull.field("previousResults", {
-      type: PlayerResult
-    });
-    t.list.nonNull.field("transactions", {
-      type: PlayerAction
-    });
-  }
-});
-var Player = (0, import_nexus3.objectType)({
-  name: "Player",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.boolean("isReady");
-    t.nonNull.int("number");
-    t.nonNull.string("name");
-    t.nonNull.string("avatar");
-    t.nonNull.string("location");
-    t.nonNull.string("color");
-    t.nonNull.string("token");
-    t.nonNull.boolean("tutorialCompleted");
-    t.string("role");
-    t.nonNull.int("experience");
-    t.nonNull.int("experienceToNext");
-    t.nonNull.field("facts", {
-      type: "JSONObject"
-    });
-    t.nonNull.field("level", {
-      type: PlayerLevel
-    });
-    t.nonNull.int("levelIx");
-    t.nonNull.list.nonNull.string("achievementKeys");
-    t.nonNull.list.nonNull.string("achievementIds");
-    t.nonNull.list.nonNull.field("achievements", {
-      type: AchievementInstance
-    });
-    t.nonNull.list.nonNull.field("completedLearningElements", {
-      type: LearningElement
-    });
-    t.nonNull.list.nonNull.string("completedLearningElementIds");
-    t.nonNull.list.nonNull.field("visitedStoryElements", {
-      type: StoryElement
-    });
-    t.nonNull.list.nonNull.string("visitedStoryElementIds");
-  }
-});
-var PlayerResult = (0, import_nexus3.objectType)({
-  name: "PlayerResult",
-  definition(t) {
-    t.nonNull.id("id");
-    t.field("type", {
-      type: PlayerResultType2
-    });
-    t.field("facts", {
-      type: "JSONObject"
-    });
-    t.nonNull.field("player", {
-      type: Player
-    });
-    t.nonNull.field("period", {
-      type: Period
-    });
-    t.field("segment", {
-      type: PeriodSegment
-    });
-  }
-});
-var PlayerAction = (0, import_nexus3.objectType)({
-  name: "PlayerAction",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.string("type");
-    t.field("facts", {
-      type: "JSONObject"
-    });
-    t.nonNull.field("player", {
-      type: Player
-    });
-    t.nonNull.field("period", {
-      type: Period
-    });
-    t.nonNull.int("periodIx");
-    t.field("segment", {
-      type: PeriodSegment
-    });
-    t.int("segmentIx");
-  }
-});
-var PlayerDecision = (0, import_nexus3.objectType)({
-  name: "PlayerDecision",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.field("player", {
-      type: Player
-    });
-    t.nonNull.field("period", {
-      type: Period
-    });
-    t.nonNull.int("periodIx");
-    t.nonNull.field("type", {
-      type: PlayerDecisionType2
-    });
-    t.nonNull.field("facts", {
-      type: "JSONObject"
-    });
-  }
-});
-
-// src/types/LearningElement.ts
-var LearningAnswerOption = (0, import_nexus4.objectType)({
-  name: "LearningAnswerOption",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.string("content");
-    t.nonNull.boolean("correct");
-  }
-});
-var LearningElementState = (0, import_nexus4.objectType)({
-  name: "LearningElementState",
-  definition(t) {
-    t.id("id");
-    t.field("element", {
-      type: LearningElement
-    });
-    t.string("state");
-    t.string("solution");
-  }
-});
-var LearningElementAttempt = (0, import_nexus4.objectType)({
-  name: "LearningElementAttempt",
-  definition(t) {
-    t.id("id");
-    t.int("pointsAchieved");
-    t.int("pointsMax");
-    t.field("element", {
-      type: LearningElement
-    });
-    t.field("player", {
-      type: Player
-    });
-  }
-});
-var LearningElement = (0, import_nexus4.objectType)({
-  name: "LearningElement",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.string("title");
-    t.nonNull.string("question");
-    t.field("reward", {
-      type: "JSONObject"
-    });
-    t.string("motivation");
-    t.nonNull.list.nonNull.field("options", {
-      type: LearningAnswerOption
-    });
-    t.string("feedback");
-  }
-});
-
-// src/types/Game.ts
-var GameStatus2 = (0, import_nexus5.enumType)({
-  name: "GameStatus",
-  members: Object.values(DB4.GameStatus)
-});
-var Game = (0, import_nexus5.objectType)({
-  name: "Game",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.field("status", {
-      type: GameStatus2
-    });
-    t.nonNull.string("name");
-    t.int("activePeriodIx");
-    t.field("activePeriod", {
-      type: Period
-    });
-    t.nonNull.list.nonNull.field("players", {
-      type: Player
-    });
-    t.nonNull.list.nonNull.field("periods", {
-      type: Period
-    });
-  }
-});
-var Period = (0, import_nexus5.objectType)({
-  name: "Period",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.int("index");
-    t.int("activeSegmentIx");
-    t.field("activeSegment", {
-      type: PeriodSegment
-    });
-    t.nonNull.list.nonNull.field("actions", {
-      type: PlayerAction
-    });
-    t.nonNull.list.nonNull.field("results", {
-      type: PlayerResult
-    });
-    t.nonNull.list.nonNull.field("segments", {
-      type: PeriodSegment
-    });
-    t.nonNull.field("facts", {
-      type: "JSONObject"
-    });
-  }
-});
-var PeriodSegment = (0, import_nexus5.objectType)({
-  name: "PeriodSegment",
-  definition(t) {
-    t.nonNull.id("id");
-    t.nonNull.int("index");
-    t.nonNull.int("periodIx");
-    t.field("countdownExpiresAt", {
-      type: "DateTime"
-    });
-    t.nonNull.list.nonNull.field("actions", {
-      type: PlayerAction
-    });
-    t.nonNull.list.nonNull.field("results", {
-      type: PlayerResult
-    });
-    t.nonNull.list.nonNull.field("learningElements", {
-      type: LearningElement
-    });
-    t.nonNull.list.nonNull.field("storyElements", {
-      type: StoryElement
-    });
-    t.nonNull.field("facts", {
-      type: "JSONObject"
-    });
-  }
-});
-
-// src/types/Mutation.ts
-var DB8 = __toESM(require("@prisma/client"));
-var import_nexus6 = require("nexus");
-
-// src/services/AccountService.ts
-var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
-var import_node_assert = require("assert");
-var import_nookies = require("nookies");
-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/GameService.ts
-var DB6 = __toESM(require("@prisma/client"));
-var import_nanoid = require("nanoid");
-var import_ramda = require("ramda");
-var yup = __toESM(require("yup"));
-
-// 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/EventService.ts
-var DB5 = __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 === DB5.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 publishUserNotification(ctx, events) {
-  if (events && events.length > 0) {
-    pubSub.publish("user:events", ctx.user.sub, events);
-  }
-}
-
-// src/services/GameService.ts
-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 DB6.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: DB6.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 DB6.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: DB6.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 DB6.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: DB6.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 DB6.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: DB6.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
+import * as DB from '@prisma/client';
+import { JSONObjectResolver, DateTimeResolver } from 'graphql-scalars';
+import { asNexusMethod, enumType, objectType } from 'nexus';
+export { Game, GameStatus, Period, PeriodSegment } from './types/Game.js';
+export { LearningAnswerOption, LearningElement, LearningElementAttempt, LearningElementState } from './types/LearningElement.js';
+export { Mutation, generateBaseMutations } from './types/Mutation.js';
+export { Player, PlayerAction, PlayerDecision, PlayerDecisionType, PlayerLevel, PlayerResult, PlayerResultType, PlayerState } from './types/Player.js';
+export { Query, generateBaseQueries } from './types/Query.js';
+export { Subscription, generateBaseSubscriptions } from './types/Subscription.js';
+
+const JsonScalar = asNexusMethod(JSONObjectResolver, 'json');
+const DateScalar = asNexusMethod(DateTimeResolver, 'date');
+const UserRole = enumType({
+    name: 'UserRole',
+    members: Object.values(DB.UserRole),
+});
+const Event = objectType({
+    name: 'Event',
+    definition(t) {
+        t.string('type');
     },
-    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 DB6.GameStatus.PREPARATION:
-    case DB6.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: DB6.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 DB6.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: DB6.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 === DB6.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: DB6.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: DB6.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 === DB6.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: DB6.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 === DB6.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: DB6.PlayerResultType.SEGMENT_START
-        },
-        {
-          ...common,
-          type: DB6.PlayerResultType.SEGMENT_END
-        }
-      ];
-    }, []);
-    return {
-      results: results2,
-      extras
-    };
-  }
-  const results = game.activePeriod.results.filter((result) => result.type === DB6.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: DB6.PlayerResultType.SEGMENT_START
-      },
-      {
-        ...common,
-        type: DB6.PlayerResultType.SEGMENT_END
-      }
-    ];
-  }, []);
-  return {
-    results,
-    extras
-  };
-}
-function computeSegmentEndResults(game, ctx, { reducers }) {
-  let extras = [];
-  const results = game.activePeriod.activeSegment.results.filter((result) => result.type === DB6.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: DB6.PlayerResultType.SEGMENT_END
-        }
-      },
-      data: {
-        facts,
-        game: {
-          connect: {
-            id: game.id
-          }
-        }
-      }
-    };
-  });
-  return {
-    results,
-    extras
-  };
-}
 
-// src/services/PlayService.ts
-var DB7 = __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: DB7.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 !== DB7.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: DB7.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 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;
-}
-
-// src/types/Mutation.ts
-var defaultReducers = {};
-var defaultSchemas = {};
-var defaultInputTypes = {};
-function generateBaseMutations({
-  reducers = defaultReducers,
-  roleAssigner = () => "UNSET",
-  schemas = defaultSchemas,
-  inputTypes = defaultInputTypes
-} = {}) {
-  return (0, import_nexus6.objectType)({
-    name: "Mutation",
-    definition(t) {
-      t.field("updateReadyState", {
-        type: Player,
-        args: {
-          isReady: (0, import_nexus6.nonNull)((0, import_nexus6.booleanArg)())
-        },
-        async resolve(_, args, ctx) {
-          return updateReadyState(args, ctx);
-        }
-      });
-      t.field("loginAsTeam", {
-        type: Player,
-        args: {
-          token: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)())
-        },
-        async resolve(_, args, ctx) {
-          return loginAsTeam(args, ctx);
-        }
-      });
-      t.boolean("logoutAsTeam", {
-        async resolve(_, __, ctx) {
-          return logoutAsTeam(ctx);
-        }
-      });
-      t.field("createGame", {
-        type: Game,
-        args: {
-          name: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)()),
-          playerCount: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)())
-        },
-        async resolve(_, args, ctx) {
-          return createGame(args, ctx, {
-            roleAssigner
-          });
-        }
-      });
-      t.field("addGamePeriod", {
-        type: Period,
-        args: {
-          gameId: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)()),
-          facts: (0, import_nexus6.arg)({
-            type: (0, import_nexus6.nonNull)(inputTypes.PeriodFactsInput)
-          })
-        },
-        async resolve(_, args, ctx) {
-          return addGamePeriod(args, ctx, {
-            schema: schemas.PeriodFactsSchema,
-            reducers
-          });
-        }
-      });
-      t.field("addPeriodSegment", {
-        type: PeriodSegment,
-        args: {
-          gameId: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)()),
-          periodIx: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)()),
-          facts: (0, import_nexus6.arg)({
-            type: (0, import_nexus6.nonNull)(inputTypes.PeriodSegmentFactsInput)
-          }),
-          storyElements: (0, import_nexus6.list)((0, import_nexus6.stringArg)()),
-          learningElements: (0, import_nexus6.list)((0, import_nexus6.stringArg)())
-        },
-        async resolve(_, args, ctx) {
-          return addPeriodSegment(args, ctx, {
-            schema: schemas.PeriodSegmentFactsSchema,
-            reducers
-          });
-        }
-      });
-      t.field("activateNextPeriod", {
-        type: Game,
-        args: {
-          gameId: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)())
-        },
-        async resolve(_, args, ctx) {
-          const results = await activateNextPeriod(args, ctx, {
-            reducers
-          });
-          if (!results)
-            return;
-          return results[0];
-        }
-      });
-      t.field("activateNextSegment", {
-        type: Game,
-        args: {
-          gameId: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)())
-        },
-        async resolve(_, args, ctx) {
-          const results = await activateNextSegment(args, ctx, {
-            reducers
-          });
-          if (!results)
-            return;
-          return results[0];
-        }
-      });
-      t.field("performAction", {
-        type: PlayerResult,
-        args: {
-          type: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)()),
-          payload: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)())
-        },
-        async resolve(_, args, ctx) {
-          const currentGame = await getGameFromContext(ctx);
-          if (!currentGame?.activePeriod)
-            return null;
-          const facts = JSON.parse(args.payload);
-          const result = await performAction(
-            {
-              gameId: currentGame.id,
-              actionType: args.type,
-              playerId: ctx.user.sub,
-              periodIx: currentGame.activePeriodIx,
-              segmentIx: currentGame.activePeriod.activeSegmentIx,
-              facts
-            },
-            ctx,
-            { reducers }
-          );
-          return result;
-        }
-      });
-      t.field("attemptLearningElement", {
-        type: LearningElementAttempt,
-        args: {
-          elementId: (0, import_nexus6.nonNull)((0, import_nexus6.idArg)()),
-          selection: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)())
-        },
-        async resolve(_, args, ctx) {
-          return attemptLearningElement(args, ctx);
-        }
-      });
-      t.field("markStoryElement", {
-        type: Player,
-        args: {
-          elementId: (0, import_nexus6.nonNull)((0, import_nexus6.idArg)())
-        },
-        async resolve(_, args, ctx) {
-          return markStoryElement(args, ctx);
-        }
-      });
-      t.field("updatePlayerData", {
-        type: Player,
-        args: {
-          name: (0, import_nexus6.stringArg)(),
-          avatar: (0, import_nexus6.stringArg)(),
-          color: (0, import_nexus6.stringArg)(),
-          facts: (0, import_nexus6.stringArg)()
-        },
-        async resolve(_, args, ctx) {
-          const facts = args.facts ? JSON.parse(args.facts) : {};
-          return updatePlayerData({ ...args, facts }, ctx);
-        }
-      });
-      t.field("saveConsolidationDecision", {
-        type: PlayerDecision,
-        args: {
-          payload: (0, import_nexus6.nonNull)((0, import_nexus6.stringArg)())
-        },
-        async resolve(_, args, ctx) {
-          const facts = JSON.parse(args.payload);
-          return saveDecisions(
-            {
-              decisionType: DB8.PlayerDecisionType.CONSOLIDATION,
-              facts
-            },
-            ctx
-          );
-        }
-      });
-      t.boolean("addCountdown", {
-        args: {
-          gameId: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)()),
-          seconds: (0, import_nexus6.nonNull)((0, import_nexus6.intArg)())
-        },
-        async resolve(_, args, ctx) {
-          return addCountdown(args, ctx);
-        }
-      });
-    }
-  });
-}
-var Mutation = generateBaseMutations();
-
-// src/types/Query.ts
-var import_nexus7 = require("nexus");
-function generateBaseQueries() {
-  return (0, import_nexus7.objectType)({
-    name: "Query",
-    definition(t) {
-      t.list.nonNull.field("games", {
-        type: Game,
-        async resolve(_, args, ctx) {
-          return getGames(args, ctx);
-        }
-      });
-      t.field("game", {
-        type: Game,
-        args: {
-          id: (0, import_nexus7.intArg)()
-        },
-        async resolve(_, args, ctx) {
-          return getGame(args, ctx);
-        }
-      });
-      t.field("result", {
-        type: PlayerState,
-        async resolve(_, args, ctx) {
-          return getPlayerResult(
-            { gameId: ctx.user.gameId, playerId: ctx.user.sub },
-            ctx
-          );
-        }
-      });
-      t.field("self", {
-        type: Player,
-        async resolve(_, args, ctx) {
-          if (!ctx.user)
-            return null;
-          return getPlayerData({ playerId: ctx.user.sub }, ctx);
-        }
-      });
-      t.list.nonNull.field("learningElements", {
-        type: LearningElement,
-        async resolve(_, args, ctx) {
-          return getLearningElements(args, ctx);
-        }
-      });
-      t.field("learningElement", {
-        type: LearningElementState,
-        args: {
-          id: (0, import_nexus7.nonNull)((0, import_nexus7.idArg)())
-        },
-        async resolve(_, args, ctx) {
-          return getLearningElement(args, ctx);
-        }
-      });
-      t.list.nonNull.field("results", {
-        type: PlayerResult,
-        async resolve(_, args, ctx) {
-          return getPlayerResults(args, ctx);
-        }
-      });
-      t.list.nonNull.field("pastResults", {
-        type: PlayerResult,
-        async resolve(_, args, ctx) {
-          return getPastResults(args, ctx);
-        }
-      });
-    }
-  });
-}
-var Query = generateBaseQueries();
-
-// src/types/Subscription.ts
-var import_nexus8 = require("nexus");
-function generateBaseSubscriptions() {
-  return (0, import_nexus8.subscriptionType)({
-    definition(t) {
-      t.list.nonNull.field("eventsGlobal", {
-        type: Event,
-        async subscribe(_, args, ctx) {
-          return pubSub.subscribe("global:events");
-        },
-        async resolve(payload) {
-          return payload;
-        }
-      });
-      t.list.nonNull.field("eventsUser", {
-        type: Event,
-        async subscribe(_, args, ctx) {
-          if (ctx.user) {
-            return pubSub.subscribe("user:events", String(ctx.user.sub));
-          }
-          return pubSub.subscribe("user:events", "anonymous");
-        },
-        async resolve(payload) {
-          return payload;
-        }
-      });
-    }
-  });
-}
-var Subscription = generateBaseSubscriptions();
-
-// src/nexus.ts
-var JsonScalar = (0, import_nexus10.asNexusMethod)(import_graphql_scalars.JSONObjectResolver, "json");
-var DateScalar = (0, import_nexus10.asNexusMethod)(import_graphql_scalars.DateTimeResolver, "date");
-var UserRole3 = (0, import_nexus10.enumType)({
-  name: "UserRole",
-  members: Object.values(DB9.UserRole)
-});
-var Event = (0, import_nexus10.objectType)({
-  name: "Event",
-  definition(t) {
-    t.string("type");
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DateScalar,
-  Event,
-  Game,
-  GameStatus,
-  JsonScalar,
-  LearningAnswerOption,
-  LearningElement,
-  LearningElementAttempt,
-  LearningElementState,
-  Mutation,
-  Period,
-  PeriodSegment,
-  Player,
-  PlayerAction,
-  PlayerDecision,
-  PlayerDecisionType,
-  PlayerLevel,
-  PlayerResult,
-  PlayerResultType,
-  PlayerState,
-  Query,
-  Subscription,
-  UserRole,
-  generateBaseMutations,
-  generateBaseQueries,
-  generateBaseSubscriptions
-});
+export { DateScalar, Event, JsonScalar, UserRole };
+//# sourceMappingURL=nexus.js.map