castle-web-sdk 0.4.4 → 0.4.6

package/src/time.ts

@@ -1,226 +0,0 @@
-import { CastleError } from "./errors";
-import { graphqlRequest } from "./graphql";
-import type { Json } from "./types";
-
-export type CastleClockZone = "player" | "Castle";
-
-export interface CastleDateParts {
-  sec: number;
-  min: number;
-  hour: number;
-  day: number;
-  month: number;
-  year: number;
-  wday: number;
-  yday: number;
-  daysSinceCastleEpoch: number;
-}
-
-export interface CastleTimeApi {
-  getServerTime(): Promise<number>;
-  getServerDate(timezone?: CastleClockZone): Promise<CastleDateParts>;
-}
-
-interface ServerTimeQueryData {
-  serverTime: {
-    timestamp: number;
-    timezoneOffset: number;
-    castleEpochData: Json;
-  };
-}
-
-interface ServerTimeSnapshot {
-  offsetSeconds: number;
-  castleTimezoneOffsetMinutes: number;
-  daysSinceCastleEpoch: Record<CastleClockZone, number>;
-}
-
-const SERVER_TIME_QUERY = `
-  query CastleServerTime {
-    serverTime {
-      timestamp
-      timezoneOffset
-      castleEpochData
-    }
-  }
-`;
-
-let serverTimeSnapshot: ServerTimeSnapshot | null = null;
-let serverTimePromise: Promise<ServerTimeSnapshot> | null = null;
-
-export const Time: CastleTimeApi = {
-  getServerTime,
-  getServerDate,
-};
-
-async function getServerTime(): Promise<number> {
-  const snapshot = await syncServerTime();
-  return clientUnixSeconds() + snapshot.offsetSeconds;
-}
-
-async function getServerDate(
-  timezone: string = "Castle",
-): Promise<CastleDateParts> {
-  const operation = "Time.getServerDate";
-  const zone = clockZone(timezone, operation);
-  const snapshot = await syncServerTime();
-  return dateParts(
-    clientUnixSeconds() + snapshot.offsetSeconds,
-    zone,
-    snapshot,
-  );
-}
-
-async function syncServerTime(): Promise<ServerTimeSnapshot> {
-  if (serverTimeSnapshot) return serverTimeSnapshot;
-  if (!serverTimePromise) {
-    serverTimePromise = fetchServerTime().then((snapshot) => {
-      serverTimeSnapshot = snapshot;
-      return snapshot;
-    });
-  }
-  return serverTimePromise;
-}
-
-async function fetchServerTime(): Promise<ServerTimeSnapshot> {
-  const operation = "Time.getServerTime";
-  const data = await graphqlRequest<ServerTimeQueryData>(
-    SERVER_TIME_QUERY,
-    undefined,
-    {
-      operation,
-    },
-  );
-  const timestamp = numberField(
-    data.serverTime.timestamp,
-    "serverTime.timestamp",
-    operation,
-  );
-  const timezoneOffset = numberField(
-    data.serverTime.timezoneOffset,
-    "serverTime.timezoneOffset",
-    operation,
-  );
-  const epochData = jsonObject(
-    data.serverTime.castleEpochData,
-    "serverTime.castleEpochData",
-    operation,
-  );
-  return {
-    offsetSeconds: snappedOffset(timestamp - clientUnixSeconds()),
-    castleTimezoneOffsetMinutes: timezoneOffset,
-    daysSinceCastleEpoch: {
-      Castle: numberField(
-        epochData.daysSinceServerTz,
-        "castleEpochData.daysSinceServerTz",
-        operation,
-      ),
-      player: numberField(
-        epochData.daysSinceUserTz,
-        "castleEpochData.daysSinceUserTz",
-        operation,
-      ),
-    },
-  };
-}
-
-function dateParts(
-  unixSeconds: number,
-  timezone: CastleClockZone,
-  snapshot: ServerTimeSnapshot,
-): CastleDateParts {
-  const shiftedSeconds =
-    timezone === "Castle"
-      ? unixSeconds + snapshot.castleTimezoneOffsetMinutes * 60
-      : unixSeconds;
-  const date = new Date(shiftedSeconds * 1000);
-  return timezone === "Castle"
-    ? utcDateParts(date, snapshot.daysSinceCastleEpoch.Castle)
-    : localDateParts(date, snapshot.daysSinceCastleEpoch.player);
-}
-
-function utcDateParts(
-  date: Date,
-  daysSinceCastleEpoch: number,
-): CastleDateParts {
-  return {
-    sec: date.getUTCSeconds(),
-    min: date.getUTCMinutes(),
-    hour: date.getUTCHours(),
-    day: date.getUTCDate(),
-    month: date.getUTCMonth() + 1,
-    year: date.getUTCFullYear(),
-    wday: date.getUTCDay() + 1,
-    yday: dayOfYear(
-      date.getUTCFullYear(),
-      date.getUTCMonth(),
-      date.getUTCDate(),
-    ),
-    daysSinceCastleEpoch,
-  };
-}
-
-function localDateParts(
-  date: Date,
-  daysSinceCastleEpoch: number,
-): CastleDateParts {
-  return {
-    sec: date.getSeconds(),
-    min: date.getMinutes(),
-    hour: date.getHours(),
-    day: date.getDate(),
-    month: date.getMonth() + 1,
-    year: date.getFullYear(),
-    wday: date.getDay() + 1,
-    yday: dayOfYear(date.getFullYear(), date.getMonth(), date.getDate()),
-    daysSinceCastleEpoch,
-  };
-}
-
-function dayOfYear(year: number, monthIndex: number, day: number): number {
-  const start = Date.UTC(year, 0, 1);
-  const current = Date.UTC(year, monthIndex, day);
-  return Math.floor((current - start) / 86400000) + 1;
-}
-
-function clockZone(timezone: string, operation: string): CastleClockZone {
-  const normalized = timezone.trim().toLowerCase();
-  if (normalized === "castle") return "Castle";
-  if (normalized === "player") return "player";
-  throw new CastleError({
-    code: "UNSUPPORTED_TIMEZONE",
-    message: 'Time.getServerDate timezone must be "Castle" or "player".',
-    operation,
-  });
-}
-
-function clientUnixSeconds(): number {
-  return Math.floor(Date.now() / 1000);
-}
-
-function snappedOffset(offsetSeconds: number): number {
-  return Math.abs(offsetSeconds) < 10 ? 0 : offsetSeconds;
-}
-
-function jsonObject(
-  value: Json,
-  field: string,
-  operation: string,
-): Record<string, Json> {
-  if (value !== null && typeof value === "object" && !Array.isArray(value))
-    return value;
-  throw new CastleError({
-    code: "GRAPHQL_BAD_DATA",
-    message: `Castle GraphQL field ${field} was not an object.`,
-    operation,
-  });
-}
-
-function numberField(value: Json, field: string, operation: string): number {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  throw new CastleError({
-    code: "GRAPHQL_BAD_DATA",
-    message: `Castle GraphQL field ${field} was not a number.`,
-    operation,
-  });
-}

package/src/types.ts

@@ -1,7 +0,0 @@
-export type Json =
-  | null
-  | boolean
-  | number
-  | string
-  | Json[]
-  | { [key: string]: Json };

package/src/user.ts

@@ -1,91 +0,0 @@
-import { requireAuthToken } from "./auth";
-import { CastleError } from "./errors";
-import { graphqlRequest } from "./graphql";
-
-export interface CastleUser {
-  userId: string;
-  username: string;
-  isActive: boolean;
-}
-
-export interface CastleUserApi {
-  getCurrent(): Promise<CastleUser>;
-}
-
-interface CurrentUserQueryData {
-  me: {
-    userId?: string | null;
-    username?: string | null;
-  } | null;
-}
-
-const CURRENT_USER_QUERY = `
-  query CastleCurrentUser {
-    me {
-      userId
-      username
-    }
-  }
-`;
-
-let currentUser: CastleUser | null = null;
-let currentUserPromise: Promise<CastleUser> | null = null;
-
-export const User: CastleUserApi = {
-  getCurrent,
-};
-
-async function getCurrent(): Promise<CastleUser> {
-  if (currentUser) return currentUser;
-  currentUserPromise ??= fetchCurrentUser().then((user) => {
-    currentUser = user;
-    return user;
-  });
-  return currentUserPromise;
-}
-
-async function fetchCurrentUser(): Promise<CastleUser> {
-  const operation = "User.getCurrent";
-  const token = await requireAuthToken(operation);
-  const data = await graphqlRequest<CurrentUserQueryData>(
-    CURRENT_USER_QUERY,
-    undefined,
-    {
-      operation,
-      requireAuth: true,
-      token,
-    },
-  );
-  if (!data.me) {
-    throw new CastleError({
-      code: "LOGIN_REQUIRED",
-      message: "Log in to Castle before using User.getCurrent().",
-      operation,
-    });
-  }
-  return normalizeCurrentUser(data.me, operation);
-}
-
-function normalizeCurrentUser(
-  user: NonNullable<CurrentUserQueryData["me"]>,
-  operation: string,
-): CastleUser {
-  return {
-    userId: requiredString(user.userId, "me.userId", operation),
-    username: requiredString(user.username, "me.username", operation),
-    isActive: true,
-  };
-}
-
-function requiredString(
-  value: string | null | undefined,
-  field: string,
-  operation: string,
-): string {
-  if (typeof value === "string" && value.length > 0) return value;
-  throw new CastleError({
-    code: "GRAPHQL_BAD_DATA",
-    message: `Castle GraphQL response did not include ${field}.`,
-    operation,
-  });
-}