Convert Login Flow to Session

CHANGELOG.md

@@ -41,6 +41,21 @@
 - Athena.player.get.toolbar
 - Athena.player.get.water
 
+Sessions
+- Sessions are a common key value pair mapping that are used across Athena.
+- Creating this wrapper will allow session data to be stored in memory.
+- This allows for small things to be checked against a player easily.
+- Athena.session.player.set
+- Athena.session.player.get
+- Athena.session.player.has
+- Athena.session.player.clearKey
+- Athena.session.player.clearAll
+- Athena.session.vehicle.set
+- Athena.session.vehicle.get
+- Athena.session.vehicle.has
+- Athena.session.vehicle.clearKey
+- Athena.session.vehicle.clearAll
+
 - AthenaClient.utility.DirectionVector -> AthenaClient.utility.vector.DirectionVector
 - Athena.utility.vector.DirectionVector
 

src/core/server/api/index.ts

@@ -7,6 +7,7 @@ export * as events from '@AthenaServer/events/index';
 export * as extensions from './consts/constExtensions';
 export * as getters from '@AthenaServer/getters/index';
 export * as player from '@AthenaServer/player/index';
+export * as session from '@AthenaServer/session';
 export * as systems from '@AthenaServer/systems/index';
 export * as utility from '@AthenaServer/utility/index';
 export * as vehicle from '@AthenaServer/vehicle/index';
@@ -21,6 +22,7 @@ import * as events from '@AthenaServer/events/index';
 import * as extensions from './consts/constExtensions';
 import * as getters from '@AthenaServer/getters/index';
 import * as player from '@AthenaServer/player/index';
+import * as session from '@AthenaServer/session';
 import * as systems from '@AthenaServer/systems/index';
 import * as utility from '@AthenaServer/utility/index';
 import * as vehicle from '@AthenaServer/vehicle/index';

src/core/server/imports/session.ts

@@ -0,0 +1,2 @@
+import '@AthenaServer/session/player';
+import '@AthenaServer/session/vehicle';

src/core/server/session/index.ts

@@ -0,0 +1,2 @@
+export * as player from './player';
+export * as vehicle from './vehicle';

src/core/server/session/player.ts

@@ -0,0 +1,129 @@
+import * as alt from 'alt-server';
+
+const sessionStorage: { [id: string]: { [key: string]: any } } = {};
+
+declare global {
+    namespace AthenaSession {
+        export interface Player {
+            example: boolean;
+        }
+    }
+}
+
+/**
+ * Set data for a player's session
+ *
+ * This data is not persistent, and automatically clears on disconnect / player destroy
+ *
+ * #### Example
+ * ```ts
+ * declare global {
+ *     namespace AthenaSession {
+ *         export interface Player {
+ *             myCustomValue: boolean;
+ *         }
+ *     }
+ * }
+ *
+ * Athena.session.player.set(somePlayer, 'myCustomValue', true);
+ * ```
+ *
+ * @param {alt.Player} player
+ * @param {keyof AthenaSession.Player} key The key you want to put the value under
+ * @param {AthenaSession.Player[K]} value The value you want to set
+ */
+export function set<K extends keyof AthenaSession.Player>(
+    player: alt.Player,
+    key: keyof AthenaSession.Player,
+    value: AthenaSession.Player[K],
+) {
+    if (!player || !player.valid) {
+        return;
+    }
+
+    if (!sessionStorage[player.id]) {
+        sessionStorage[player.id] = {};
+    }
+
+    sessionStorage[player.id][key] = value;
+}
+
+/**
+ * Retrieve data from a player's session storage.
+ *
+ * @param {alt.Player} player
+ * @param {keyof AthenaSession.Player} key The value you want to get from the player.
+ * @returns {AthenaSession.Player[K]}
+ */
+export function get<K extends keyof AthenaSession.Player>(
+    player: alt.Player,
+    key: K,
+): AthenaSession.Player[K] | undefined {
+    if (!player || !player.valid) {
+        return undefined;
+    }
+
+    if (!sessionStorage[player.id]) {
+        return undefined;
+    }
+
+    return sessionStorage[player.id][key];
+}
+
+/**
+ * Returns true, if it has any value set for a given key.
+ *
+ * @export
+ * @param {alt.Player} player
+ * @param {keyof AthenaSession.Player} key
+ */
+export function has(player: alt.Player, key: keyof AthenaSession.Player) {
+    if (!player || !player.valid) {
+        return false;
+    }
+
+    if (!sessionStorage[player.id]) {
+        return false;
+    }
+
+    return typeof sessionStorage[player.id][key] ? true : false;
+}
+
+/**
+ * Clear a key from the player.
+ *
+ * @export
+ * @param {alt.Player} player
+ * @param {string} key
+ */
+export function clearKey(player: alt.Player, key: keyof AthenaSession.Player) {
+    if (!player || !player.valid) {
+        return;
+    }
+
+    if (!sessionStorage[player.id]) {
+        return;
+    }
+
+    delete sessionStorage[player.id][key];
+}
+
+/**
+ * Clear all keys, and remove all data for a session.
+ *
+ * @export
+ * @param {alt.Player} player
+ */
+export function clearAll(player: alt.Player) {
+    if (!player || !player.valid) {
+        return;
+    }
+
+    if (!sessionStorage[player.id]) {
+        return;
+    }
+
+    delete sessionStorage[player.id];
+}
+
+alt.on('playerDisconnect', clearAll);

src/core/server/session/vehicle.ts

@@ -0,0 +1,130 @@
+import * as alt from 'alt-server';
+
+const sessionStorage: { [id: string]: { [key: string]: any } } = {};
+
+declare global {
+    namespace AthenaSession {
+        export interface Vehicle {
+            example: boolean;
+        }
+    }
+}
+
+/**
+ * Set data for a vehicle's session
+ *
+ * This data is not persistent, and automatically clears on disconnect / vehicle destroy
+ *
+ * #### Example
+ * ```ts
+ * declare global {
+ *     namespace AthenaSession {
+ *         export interface Vehicle {
+ *             myCustomValue: boolean;
+ *         }
+ *     }
+ * }
+ *
+ * Athena.session.vehicle.set(someVehicle, 'myCustomValue', true);
+ * ```
+ *
+ * @param {alt.Vehicle} vehicle
+ * @param {keyof AthenaSession.Vehicle} key The key you want to put the value under
+ * @param {AthenaSession.Vehicle[K]} value The value you want to set
+ * @returns {any} Any type of value, can be specified with a generic type.
+ */
+export function set<K extends keyof AthenaSession.Vehicle>(
+    vehicle: alt.Vehicle,
+    key: keyof AthenaSession.Vehicle,
+    value: AthenaSession.Vehicle[K],
+) {
+    if (!vehicle || !vehicle.valid) {
+        return;
+    }
+
+    if (!sessionStorage[vehicle.id]) {
+        sessionStorage[vehicle.id] = {};
+    }
+
+    sessionStorage[vehicle.id][key] = value;
+}
+
+/**
+ * Returns true, if it has any value set for a given key.
+ *
+ * @export
+ * @param {alt.Vehicle} vehicle
+ * @param {string} key
+ */
+export function has(vehicle: alt.Vehicle, key: string) {
+    if (!vehicle || !vehicle.valid) {
+        return false;
+    }
+
+    if (!sessionStorage[vehicle.id]) {
+        return false;
+    }
+
+    return typeof sessionStorage[vehicle.id][key] ? true : false;
+}
+
+/**
+ * Retrieve data from a vehicle's session storage.
+ *
+ * @param vehicle
+ * @param {keyof AthenaSession.Vehicle} key The value you want to get from the vehicle.
+ * @returns {AthenaSession.Vehicle[K]} Any type of value, can be specified with a generic type.
+ */
+export function get<K extends keyof AthenaSession.Vehicle>(
+    vehicle: alt.Vehicle,
+    key: K,
+): AthenaSession.Vehicle[K] | undefined {
+    if (!vehicle || !vehicle.valid) {
+        return undefined;
+    }
+
+    if (!sessionStorage[vehicle.id]) {
+        return undefined;
+    }
+
+    return sessionStorage[vehicle.id][key];
+}
+
+/**
+ * Clear a key from the vehicle.
+ *
+ * @export
+ * @param {alt.Vehicle} vehicle
+ * @param {string} key
+ */
+export function clearKey(vehicle: alt.Vehicle, key: keyof AthenaSession.Vehicle) {
+    if (!vehicle || !vehicle.valid) {
+        return;
+    }
+
+    if (!sessionStorage[vehicle.id]) {
+        return;
+    }
+
+    delete sessionStorage[vehicle.id][key];
+}
+
+/**
+ * Clear all keys, and remove all data for a session.
+ *
+ * @export
+ * @param {alt.Vehicle} vehicle
+ */
+export function clearAll(vehicle: alt.Vehicle) {
+    if (!vehicle || !vehicle.valid) {
+        return;
+    }
+
+    if (!sessionStorage[vehicle.id]) {
+        return;
+    }
+
+    delete sessionStorage[vehicle.id];
+}
+
+alt.on('vehicleDestroy', clearAll);