@drmxrcy/tcg-shared 0.0.0-202602060544

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@drmxrcy/tcg-shared",
+  "version": "0.0.0-202602060544",
+  "private": false,
+  "main": "./src/index.ts",
+  "types": "./src/index.d.ts",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "format": "bun x @biomejs/biome check --fix --max-diagnostics=none --diagnostic-level=error --linter-enabled=false ./src",
+    "lint": "bun x @biomejs/biome lint --write ./src",
+    "check-types": "tsc --noEmit",
+    "test": "echo 'No tests'"
+  },
+  "dependencies": {
+    "pino": "9.7.0",
+    "pino-pretty": "13.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.11",
+    "@drmxrcy/tcg-typescript-config": "workspace:*"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.ts",
+    "./auth": "./src/auth/index.ts"
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Auth module exports
+ */
+export type { AuthSession, AuthUser, SessionResult } from "./types";

package/src/auth/types.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared authentication types
+ *
+ * These types are used across the API, web app, and any other packages
+ * that need to work with Better Auth session data.
+ */
+
+/**
+ * User type from Better Auth session
+ */
+export interface AuthUser {
+  id: string;
+  email: string;
+  name: string;
+  image?: string | null;
+  username?: string | null;
+  displayUsername?: string | null;
+  emailVerified: boolean;
+  subscriptionTier: string;
+  subscriptionExpiresAt?: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Session type from Better Auth
+ */
+export interface AuthSession {
+  id: string;
+  userId: string;
+  token: string;
+  expiresAt: Date;
+  ipAddress?: string | null;
+  userAgent?: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Session result type for server responses
+ * This matches the structure returned by auth.api.getSession()
+ */
+export interface SessionResult {
+  user: AuthUser | null;
+  session: AuthSession | null;
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Re-export types from types.ts
+ * This maintains compatibility with existing imports while
+ * allowing the package.json to correctly define specific exports
+ */
+
+export * from "./auth";
+export * from "./types";
+export * from "./utils";

package/src/libs/logger.ts

@@ -0,0 +1,51 @@
+import pino, { type Logger } from "pino";
+
+const isDevelopment = process.env.NODE_ENV !== "production";
+const isTest = process.env.NODE_ENV === "test";
+
+// https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity
+const _PinoLevelToSeverityLookup = {
+  trace: "TRACE",
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARNING",
+  error: "ERROR",
+  fatal: "CRITICAL",
+};
+
+let internalLogger = pino({
+  level: process.env.LOG_LEVEL || isDevelopment ? "debug" : "info",
+  formatters: {
+    level: (label) => {
+      return { level: label.toUpperCase() };
+    },
+  },
+  timestamp: pino.stdTimeFunctions.isoTime,
+});
+
+// if (isDevelopment) {
+//   internalLogger = pino({
+//     transport: {
+//       target: "pino-pretty",
+//       options: {
+//         colorize: true,
+//       },
+//     },
+//   });
+// }
+
+if (isTest || isDevelopment) {
+  // @ts-expect-error TODO: find a better way to disable pino
+  internalLogger = {
+    trace: console.trace,
+    warn: console.log,
+    info: console.info,
+    debug: console.debug,
+    error: console.error,
+    silent: console.log,
+    fatal: console.error,
+    level: "debug",
+  };
+}
+
+export const logger: Logger = internalLogger;

package/src/object-hash.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Declaration file for object-hash module
+ */
+
+declare module "object-hash" {
+  interface ObjectHashOptions {
+    algorithm?: string;
+    encoding?: string;
+    excludeValues?: boolean;
+    ignoreUnknown?: boolean;
+    replacer?: (value: unknown) => unknown;
+    respectFunctionProperties?: boolean;
+    respectFunctionNames?: boolean;
+    respectType?: boolean;
+    unorderedArrays?: boolean;
+    unorderedObjects?: boolean;
+    unorderedSets?: boolean;
+  }
+
+  interface ObjectHash {
+    (obj: unknown, options?: ObjectHashOptions): string;
+    MD5(data: unknown): string;
+    keys(obj: object): string;
+    keysMD5(obj: object): string;
+    sha1(obj: unknown): string;
+  }
+
+  const objectHash: ObjectHash;
+  export default objectHash;
+}

package/src/types.ts

@@ -0,0 +1,302 @@
+export type Zones = "hand" | "play" | "discard" | "inkwell" | "deck";
+
+export type MatchMove =
+  | ChangeGameModeMove
+  | AlterHandMove
+  | RequestMove
+  | GenerateOnDemandLayerMove
+  | ConcedeMatchMove
+  | ConcedeGameMove
+  | ShiftMove
+  | ResolveLayerMove
+  | SkipLayerMove
+  | AcceptOptionalLayerMove
+  | DrawCardMove
+  | RevealCardMove
+  | UpdateLoreMove
+  | ShuffleDeckMove
+  | ScryMove
+  | UndoMove
+  | UndoTurnMove
+  | UndoLastTurnMove
+  | ActivateAbilityMove
+  | UpdateCardDamageMove
+  | ChooseWhoGoesFirstMove
+  | QuestMove
+  | QuestWithAllMove
+  | TapCardMove
+  | MoveCardMove
+  | TutorCardMove
+  | SingTogetherMove
+  | SingMove
+  | PassTurnMove
+  | PutCardIntoInkwellMove
+  | EnterLocationMove
+  | MoveToLocationMove
+  | AnswerPlayerRequest
+  | CancelPlayerRequest
+  | ChallengeMove
+  | PlayerJoinedMove
+  | PlayerLeftMove
+  | PlayCardMove
+  | DropPlayerMove;
+
+interface BaseMove {
+  type: MatchMove["type"];
+  number?: number;
+  id?: string;
+}
+
+export interface AnswerPlayerRequest extends BaseMove {
+  type: "ANSWER_PLAYER_REQUEST";
+  accepted: boolean;
+}
+
+export interface PlayerJoinedMove extends BaseMove {
+  type: "PLAYER_JOINED";
+  playerId: string;
+}
+
+export interface PlayerLeftMove extends BaseMove {
+  type: "PLAYER_LEFT";
+  playerId: string;
+}
+
+export interface DropPlayerMove extends BaseMove {
+  type: "DROP_PLAYER";
+  playerId: string;
+  dropped?: boolean;
+  timeLeft?: number;
+}
+
+export interface CancelPlayerRequest extends BaseMove {
+  type: "CANCEL_PLAYER_REQUEST";
+  cancelled: boolean;
+}
+
+export interface ChangeGameModeMove extends BaseMove {
+  type: "CHANGE_GAME_MODE";
+  manual: boolean;
+}
+
+export interface UndoMoveBase extends BaseMove {
+  type: "UNDO";
+}
+
+export interface UndoMoveWithTurn extends UndoMoveBase {
+  turn: number;
+  move?: never;
+}
+
+export interface UndoMoveWithMove extends UndoMoveBase {
+  turn?: never;
+  move: number;
+}
+
+export type UndoMove = UndoMoveWithTurn | UndoMoveWithMove;
+
+export interface UndoTurnMove extends BaseMove {
+  type: "UNDO_TURN";
+}
+
+export interface UndoLastTurnMove extends BaseMove {
+  type: "UNDO_LAST_TURN";
+}
+
+export interface ChooseWhoGoesFirstMove extends BaseMove {
+  type: "CHOOSE_FIRST_PLAYER";
+  player: string;
+}
+
+export interface AlterHandMove extends BaseMove {
+  type: "ALTER_HAND";
+  player: string;
+  cards: string[];
+}
+
+export interface RequestMove extends BaseMove {
+  type: "REQUEST";
+  payload:
+    | {
+        type: "ENABLE_CHAT";
+        mode: "free_text" | "predefined";
+      }
+    | {
+        type: "CONCEDE_GAME";
+      };
+}
+
+export interface PassTurnMove extends BaseMove {
+  type: "PASS_TURN";
+  player: string;
+  forced?: boolean;
+}
+
+export interface ActivateAbilityMove extends BaseMove {
+  type: "ACTIVATE_ABILITY";
+  instanceId: string;
+  ability?: string;
+  costs?: string[];
+}
+
+export interface UpdateCardDamageMove extends BaseMove {
+  type: "UPDATE_CARD_DAMAGE";
+  instanceId: string;
+  damage: number;
+  operation: "add" | "remove" | "set";
+}
+
+export interface QuestMove extends BaseMove {
+  type: "QUEST";
+  instanceId: string;
+}
+
+export interface QuestWithAllMove extends BaseMove {
+  type: "QUEST_WITH_ALL";
+  playerId: string;
+}
+
+export interface TapCardMove extends BaseMove {
+  type: "TAP_CARD";
+  instanceId: string;
+  exerted?: boolean;
+  toggle?: boolean;
+}
+
+export interface MoveCardMove extends BaseMove {
+  type: "MOVE_CARD";
+  instanceId: string;
+  to: Zones;
+  position: "first" | "last";
+}
+
+export interface TutorCardMove extends BaseMove {
+  type: "TUTOR_CARD";
+  instanceId: string;
+}
+
+export interface RevealCardMove extends BaseMove {
+  type: "REVEAL_CARD";
+  instanceId: string;
+}
+
+export interface UpdateLoreMove extends BaseMove {
+  type: "UPDATE_LORE";
+  player: string;
+  lore: number;
+}
+
+export interface DrawCardMove extends BaseMove {
+  type: "DRAW_CARD";
+  player: string;
+}
+
+export interface ShuffleDeckMove extends BaseMove {
+  type: "SHUFFLE_DECK";
+  player: string;
+}
+
+export interface ConcedeMatchMove extends BaseMove {
+  type: "CONCEDE_MATCH";
+}
+
+export interface ConcedeGameMove extends BaseMove {
+  type: "CONCEDE_GAME";
+}
+
+export interface PutCardIntoInkwellMove extends BaseMove {
+  type: "PUT_CARD_INTO_INKWELL";
+  instanceId: string;
+}
+
+export interface SingTogetherMove extends BaseMove {
+  type: "SING_TOGETHER";
+  song: string;
+  singers: string[];
+}
+
+export interface SingMove extends BaseMove {
+  type: "SING";
+  song: string;
+  singer: string;
+}
+
+export interface EnterLocationMove extends BaseMove {
+  type: "ENTER_LOCATION";
+  character: string;
+  location: string;
+}
+
+export interface MoveToLocationMove extends BaseMove {
+  type: "MOVE_TO_LOCATION";
+  character: string;
+  location: string;
+}
+
+export interface ChallengeMove extends BaseMove {
+  type: "CHALLENGE";
+  attacker: string;
+  defender: string;
+}
+
+export interface ShiftMove extends BaseMove {
+  type: "SHIFT";
+  shifter: string;
+  shifted: string;
+  costs?: string[];
+}
+
+export interface ScryParams {
+  top?: string[];
+  bottom?: string[];
+  hand?: string[];
+  inkwell?: string[];
+  discard?: string[];
+  play?: string[];
+}
+
+export interface ScryMove extends BaseMove, ScryParams {
+  type: "SCRY";
+  playerId: string;
+}
+
+export interface ResolverLayerParams {
+  layerId: string;
+  targets?: string[];
+  mode?: string;
+  nameACard?: string;
+  skip?: boolean;
+  scry?: ScryParams;
+  targetPlayer?: string;
+}
+
+export interface ResolveLayerMove extends BaseMove, ResolverLayerParams {
+  type: "RESOLVE_LAYER";
+  activePlayer: string;
+}
+
+export interface SkipLayerMove extends BaseMove {
+  type: "SKIP_LAYER";
+  layerId: string;
+  activePlayer: string;
+}
+
+export interface AcceptOptionalLayerMove extends BaseMove {
+  type: "ACCEPT_OPTIONAL_LAYER";
+  layerId: string;
+  activePlayer: string;
+}
+
+export interface PlayCardMove extends BaseMove {
+  type: "PLAY_CARD";
+  instanceId: string;
+  bodyguard?: boolean;
+  alternativeCosts?: string[];
+}
+
+export interface GenerateOnDemandLayerMove extends BaseMove {
+  type: "GENERATE_ON_DEMAND_LAYER";
+  instanceId: string;
+  ability: Record<string, unknown>; // ActivatedAbility
+  costs?: string[];
+}

package/src/utils.ts

@@ -0,0 +1,48 @@
+/**
+ * Utility types for handling null/undefined checks
+ */
+
+/**
+ * Ensures a value is non-null (useful for TypeScript strict null checks)
+ * @param value The value to check
+ * @throws Error if value is null or undefined
+ */
+export function assertNonNull<T>(
+  value: T | null | undefined,
+  message = "Value cannot be null or undefined",
+): asserts value is T {
+  if (value === null || value === undefined) {
+    throw new Error(message);
+  }
+}
+
+/**
+ * Returns a default value if the input is null/undefined
+ * @param value The value to check
+ * @param defaultVal The default value to return if value is null/undefined
+ */
+export function withDefault<T>(value: T | null | undefined, defaultVal: T): T {
+  return value === null || value === undefined ? defaultVal : value;
+}
+
+/**
+ * Type guard to check if a value is not null or undefined
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Type utility that removes null from a type
+ */
+export type NonNull<T> = T extends null ? never : T;
+
+/**
+ * Type utility that removes undefined from a type
+ */
+export type NonUndefined<T> = T extends undefined ? never : T;
+
+/**
+ * Type utility that ensures a type is not null or undefined
+ */
+export type NonNullable<T> = T extends null | undefined ? never : T;