@minesa-org/mini-interaction 0.1.2 → 0.1.3

package/dist/database/MiniDataBuilder.d.ts

@@ -0,0 +1,62 @@
+import type { JSONEncodable } from "../builders/shared.js";
+/**
+ * Represents a field in the data schema.
+ */
+export interface DataField {
+    name: string;
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+}
+/**
+ * Builder for defining data schemas in MiniDatabase.
+ * Provides a fluent API for developers to define their data structure.
+ *
+ * @example
+ * ```typescript
+ * const userSchema = new MiniDataBuilder()
+ *   .addField("userId", "string", { required: true })
+ *   .addField("username", "string", { required: true })
+ *   .addField("coins", "number", { default: 0 })
+ *   .addField("metadata", "object", { default: {} });
+ * ```
+ */
+export declare class MiniDataBuilder implements JSONEncodable<Record<string, DataField>> {
+    private fields;
+    /**
+     * Adds a field to the data schema.
+     */
+    addField(name: string, type: "string" | "number" | "boolean" | "object" | "array", options?: {
+        required?: boolean;
+        default?: unknown;
+        description?: string;
+    }): this;
+    /**
+     * Removes a field from the schema.
+     */
+    removeField(name: string): this;
+    /**
+     * Gets a specific field definition.
+     */
+    getField(name: string): DataField | undefined;
+    /**
+     * Gets all fields in the schema.
+     */
+    getFields(): DataField[];
+    /**
+     * Validates data against the schema.
+     */
+    validate(data: Record<string, unknown>): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Applies default values to data.
+     */
+    applyDefaults(data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Serializes the schema to JSON.
+     */
+    toJSON(): Record<string, DataField>;
+}

package/dist/database/MiniDataBuilder.js

@@ -0,0 +1,98 @@
+/**
+ * Builder for defining data schemas in MiniDatabase.
+ * Provides a fluent API for developers to define their data structure.
+ *
+ * @example
+ * ```typescript
+ * const userSchema = new MiniDataBuilder()
+ *   .addField("userId", "string", { required: true })
+ *   .addField("username", "string", { required: true })
+ *   .addField("coins", "number", { default: 0 })
+ *   .addField("metadata", "object", { default: {} });
+ * ```
+ */
+export class MiniDataBuilder {
+    fields = new Map();
+    /**
+     * Adds a field to the data schema.
+     */
+    addField(name, type, options) {
+        this.fields.set(name, {
+            name,
+            type,
+            required: options?.required ?? false,
+            default: options?.default,
+            description: options?.description,
+        });
+        return this;
+    }
+    /**
+     * Removes a field from the schema.
+     */
+    removeField(name) {
+        this.fields.delete(name);
+        return this;
+    }
+    /**
+     * Gets a specific field definition.
+     */
+    getField(name) {
+        return this.fields.get(name);
+    }
+    /**
+     * Gets all fields in the schema.
+     */
+    getFields() {
+        return Array.from(this.fields.values());
+    }
+    /**
+     * Validates data against the schema.
+     */
+    validate(data) {
+        const errors = [];
+        for (const field of this.fields.values()) {
+            const value = data[field.name];
+            // Check required fields
+            if (field.required && (value === undefined || value === null)) {
+                errors.push(`Field "${field.name}" is required`);
+                continue;
+            }
+            // Check type if value exists
+            if (value !== undefined && value !== null) {
+                const actualType = Array.isArray(value) ? "array" : typeof value;
+                if (actualType !== field.type) {
+                    errors.push(`Field "${field.name}" must be of type "${field.type}", got "${actualType}"`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Applies default values to data.
+     */
+    applyDefaults(data) {
+        const result = { ...data };
+        for (const field of this.fields.values()) {
+            if (result[field.name] === undefined && field.default !== undefined) {
+                result[field.name] =
+                    typeof field.default === "object"
+                        ? JSON.parse(JSON.stringify(field.default))
+                        : field.default;
+            }
+        }
+        return result;
+    }
+    /**
+     * Serializes the schema to JSON.
+     */
+    toJSON() {
+        const result = {};
+        for (const [key, field] of this.fields) {
+            result[key] = field;
+        }
+        return result;
+    }
+}

package/dist/database/MiniDatabase.d.ts

@@ -0,0 +1,61 @@
+import type { MiniDataBuilder } from "./MiniDataBuilder.js";
+import type { DatabaseConfig } from "./MiniDatabaseBuilder.js";
+/**
+ * MiniDatabase provides async data storage with support for JSON and MongoDB backends.
+ * Designed to work seamlessly with Vercel and serverless environments.
+ *
+ * @example
+ * ```typescript
+ * const db = new MiniDatabase(config, schema);
+ *
+ * // Get data
+ * const user = await db.get("user123");
+ *
+ * // Set data
+ * await db.set("user123", { username: "john", coins: 100 });
+ *
+ * // Update data
+ * await db.update("user123", { coins: 150 });
+ * ```
+ */
+export declare class MiniDatabase {
+    private config;
+    private schema?;
+    private mongoClient?;
+    private mongoDb?;
+    private mongoCollection?;
+    private initPromise?;
+    constructor(config: DatabaseConfig, schema?: MiniDataBuilder);
+    /**
+     * Initializes the database connection.
+     */
+    private initialize;
+    /**
+     * Initializes MongoDB connection.
+     */
+    private initializeMongoDB;
+    /**
+     * Initializes JSON file storage.
+     */
+    private initializeJSON;
+    /**
+     * Gets data by key.
+     */
+    get(key: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Sets data by key (overwrites existing data).
+     */
+    set(key: string, data: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Updates specific fields in data (merges with existing data).
+     */
+    update(key: string, updates: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Deletes data by key.
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Closes the database connection (for MongoDB).
+     */
+    close(): Promise<void>;
+}

package/dist/database/MiniDatabase.js

@@ -0,0 +1,233 @@
+import { promises as fs } from "fs";
+import path from "path";
+/**
+ * MiniDatabase provides async data storage with support for JSON and MongoDB backends.
+ * Designed to work seamlessly with Vercel and serverless environments.
+ *
+ * @example
+ * ```typescript
+ * const db = new MiniDatabase(config, schema);
+ *
+ * // Get data
+ * const user = await db.get("user123");
+ *
+ * // Set data
+ * await db.set("user123", { username: "john", coins: 100 });
+ *
+ * // Update data
+ * await db.update("user123", { coins: 150 });
+ * ```
+ */
+export class MiniDatabase {
+    config;
+    schema;
+    mongoClient;
+    mongoDb;
+    mongoCollection;
+    initPromise;
+    constructor(config, schema) {
+        this.config = config;
+        this.schema = schema;
+    }
+    /**
+     * Initializes the database connection.
+     */
+    async initialize() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            if (this.config.type === "mongodb") {
+                await this.initializeMongoDB();
+            }
+            else {
+                await this.initializeJSON();
+            }
+        })();
+        return this.initPromise;
+    }
+    /**
+     * Initializes MongoDB connection.
+     */
+    async initializeMongoDB() {
+        try {
+            let MongoClient;
+            try {
+                // @ts-ignore - MongoDB is optional
+                const mongoModule = await import("mongodb");
+                MongoClient = mongoModule.MongoClient;
+            }
+            catch {
+                throw new Error("MongoDB driver not installed. Install it with: npm install mongodb");
+            }
+            if (!this.config.mongoUri) {
+                throw new Error("MongoDB URI is required");
+            }
+            this.mongoClient = new MongoClient(this.config.mongoUri, {
+                maxPoolSize: 5,
+            });
+            await this.mongoClient.connect();
+            this.mongoDb = this.mongoClient.db(this.config.dbName || "minidb");
+            this.mongoCollection = this.mongoDb.collection(this.config.collectionName || "data");
+            console.log("✅ [MiniDatabase] Connected to MongoDB");
+        }
+        catch (err) {
+            console.error("❌ [MiniDatabase] Failed to connect to MongoDB:", err);
+            throw err;
+        }
+    }
+    /**
+     * Initializes JSON file storage.
+     */
+    async initializeJSON() {
+        try {
+            const dataPath = this.config.dataPath || "./data";
+            await fs.mkdir(dataPath, { recursive: true });
+            console.log("✅ [MiniDatabase] JSON storage initialized at", dataPath);
+        }
+        catch (err) {
+            console.error("❌ [MiniDatabase] Failed to initialize JSON storage:", err);
+            throw err;
+        }
+    }
+    /**
+     * Gets data by key.
+     */
+    async get(key) {
+        await this.initialize();
+        try {
+            if (this.config.type === "mongodb") {
+                const doc = await this.mongoCollection.findOne({ _id: key });
+                return doc ? { ...doc, _id: undefined } : null;
+            }
+            else {
+                const filePath = path.join(this.config.dataPath || "./data", `${key}.json`);
+                try {
+                    const data = await fs.readFile(filePath, "utf-8");
+                    return JSON.parse(data);
+                }
+                catch (err) {
+                    if (err.code === "ENOENT") {
+                        return null;
+                    }
+                    throw err;
+                }
+            }
+        }
+        catch (err) {
+            console.error(`❌ [MiniDatabase] Failed to get data for key "${key}":`, err);
+            return null;
+        }
+    }
+    /**
+     * Sets data by key (overwrites existing data).
+     */
+    async set(key, data) {
+        await this.initialize();
+        try {
+            // Validate against schema if provided
+            if (this.schema) {
+                const validation = this.schema.validate(data);
+                if (!validation.valid) {
+                    throw new Error(`Validation failed: ${validation.errors.join(", ")}`);
+                }
+            }
+            const dataWithDefaults = this.schema
+                ? this.schema.applyDefaults(data)
+                : data;
+            if (this.config.type === "mongodb") {
+                await this.mongoCollection.updateOne({ _id: key }, {
+                    $set: {
+                        ...dataWithDefaults,
+                        _id: key,
+                        updatedAt: new Date(),
+                    },
+                    $setOnInsert: {
+                        createdAt: new Date(),
+                    },
+                }, { upsert: true });
+            }
+            else {
+                const filePath = path.join(this.config.dataPath || "./data", `${key}.json`);
+                await fs.writeFile(filePath, JSON.stringify(dataWithDefaults, null, 2));
+            }
+            console.log(`✅ [MiniDatabase] Saved data for key "${key}"`);
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [MiniDatabase] Failed to set data for key "${key}":`, err);
+            return false;
+        }
+    }
+    /**
+     * Updates specific fields in data (merges with existing data).
+     */
+    async update(key, updates) {
+        await this.initialize();
+        try {
+            const existing = await this.get(key);
+            const merged = { ...existing, ...updates };
+            // Validate merged data against schema if provided
+            if (this.schema) {
+                const validation = this.schema.validate(merged);
+                if (!validation.valid) {
+                    throw new Error(`Validation failed: ${validation.errors.join(", ")}`);
+                }
+            }
+            const dataWithDefaults = this.schema
+                ? this.schema.applyDefaults(merged)
+                : merged;
+            if (this.config.type === "mongodb") {
+                await this.mongoCollection.updateOne({ _id: key }, {
+                    $set: {
+                        ...dataWithDefaults,
+                        updatedAt: new Date(),
+                    },
+                    $setOnInsert: {
+                        createdAt: new Date(),
+                    },
+                }, { upsert: true });
+            }
+            else {
+                const filePath = path.join(this.config.dataPath || "./data", `${key}.json`);
+                await fs.writeFile(filePath, JSON.stringify(dataWithDefaults, null, 2));
+            }
+            console.log(`✅ [MiniDatabase] Updated data for key "${key}"`);
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [MiniDatabase] Failed to update data for key "${key}":`, err);
+            return false;
+        }
+    }
+    /**
+     * Deletes data by key.
+     */
+    async delete(key) {
+        await this.initialize();
+        try {
+            if (this.config.type === "mongodb") {
+                await this.mongoCollection.deleteOne({ _id: key });
+            }
+            else {
+                const filePath = path.join(this.config.dataPath || "./data", `${key}.json`);
+                await fs.unlink(filePath);
+            }
+            console.log(`✅ [MiniDatabase] Deleted data for key "${key}"`);
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [MiniDatabase] Failed to delete data for key "${key}":`, err);
+            return false;
+        }
+    }
+    /**
+     * Closes the database connection (for MongoDB).
+     */
+    async close() {
+        if (this.mongoClient) {
+            await this.mongoClient.close();
+            console.log("✅ [MiniDatabase] MongoDB connection closed");
+        }
+    }
+}

package/dist/database/MiniDatabaseBuilder.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Configuration for MiniDatabase backend.
+ */
+export interface DatabaseConfig {
+    type: "json" | "mongodb";
+    dataPath?: string;
+    mongoUri?: string;
+    dbName?: string;
+    collectionName?: string;
+}
+/**
+ * Builder for configuring MiniDatabase.
+ * Provides a fluent API for easy database setup.
+ *
+ * @example
+ * ```typescript
+ * // Using JSON (default)
+ * const db = new MiniDatabaseBuilder()
+ *   .setType("json")
+ *   .setDataPath("./data")
+ *   .build();
+ *
+ * // Using MongoDB
+ * const db = new MiniDatabaseBuilder()
+ *   .setType("mongodb")
+ *   .setMongoUri(process.env.MONGO_URI)
+ *   .setDbName("myapp")
+ *   .setCollectionName("users")
+ *   .build();
+ * ```
+ */
+export declare class MiniDatabaseBuilder {
+    private config;
+    /**
+     * Sets the database type (json or mongodb).
+     */
+    setType(type: "json" | "mongodb"): this;
+    /**
+     * Sets the data path for JSON backend.
+     * Default: "./data"
+     */
+    setDataPath(path: string): this;
+    /**
+     * Sets the MongoDB connection URI.
+     */
+    setMongoUri(uri: string): this;
+    /**
+     * Sets the MongoDB database name.
+     * Default: "minidb"
+     */
+    setDbName(name: string): this;
+    /**
+     * Sets the MongoDB collection name.
+     * Default: "data"
+     */
+    setCollectionName(name: string): this;
+    /**
+     * Gets the current configuration.
+     */
+    getConfig(): DatabaseConfig;
+    /**
+     * Validates the configuration.
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Builds and returns the configuration.
+     */
+    build(): DatabaseConfig;
+}

package/dist/database/MiniDatabaseBuilder.js

@@ -0,0 +1,103 @@
+/**
+ * Builder for configuring MiniDatabase.
+ * Provides a fluent API for easy database setup.
+ *
+ * @example
+ * ```typescript
+ * // Using JSON (default)
+ * const db = new MiniDatabaseBuilder()
+ *   .setType("json")
+ *   .setDataPath("./data")
+ *   .build();
+ *
+ * // Using MongoDB
+ * const db = new MiniDatabaseBuilder()
+ *   .setType("mongodb")
+ *   .setMongoUri(process.env.MONGO_URI)
+ *   .setDbName("myapp")
+ *   .setCollectionName("users")
+ *   .build();
+ * ```
+ */
+export class MiniDatabaseBuilder {
+    config = {
+        type: "json",
+        dataPath: "./data",
+        dbName: "minidb",
+        collectionName: "data",
+    };
+    /**
+     * Sets the database type (json or mongodb).
+     */
+    setType(type) {
+        this.config.type = type;
+        return this;
+    }
+    /**
+     * Sets the data path for JSON backend.
+     * Default: "./data"
+     */
+    setDataPath(path) {
+        this.config.dataPath = path;
+        return this;
+    }
+    /**
+     * Sets the MongoDB connection URI.
+     */
+    setMongoUri(uri) {
+        this.config.mongoUri = uri;
+        return this;
+    }
+    /**
+     * Sets the MongoDB database name.
+     * Default: "minidb"
+     */
+    setDbName(name) {
+        this.config.dbName = name;
+        return this;
+    }
+    /**
+     * Sets the MongoDB collection name.
+     * Default: "data"
+     */
+    setCollectionName(name) {
+        this.config.collectionName = name;
+        return this;
+    }
+    /**
+     * Gets the current configuration.
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Validates the configuration.
+     */
+    validate() {
+        const errors = [];
+        if (this.config.type === "mongodb") {
+            if (!this.config.mongoUri) {
+                errors.push("MongoDB URI is required when using mongodb backend");
+            }
+        }
+        if (this.config.type === "json") {
+            if (!this.config.dataPath) {
+                errors.push("Data path is required when using json backend");
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Builds and returns the configuration.
+     */
+    build() {
+        const validation = this.validate();
+        if (!validation.valid) {
+            throw new Error(`Invalid database configuration: ${validation.errors.join(", ")}`);
+        }
+        return this.getConfig();
+    }
+}

package/dist/index.d.ts

@@ -21,3 +21,11 @@ export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export type { MiniComponentActionRow, MiniComponentMessageActionRow, } from "./types/ComponentTypes.js";
 export * from "./builders/index.js";
+export { MiniDataBuilder } from "./database/MiniDataBuilder.js";
+export type { DataField } from "./database/MiniDataBuilder.js";
+export { MiniDatabaseBuilder } from "./database/MiniDatabaseBuilder.js";
+export type { DatabaseConfig } from "./database/MiniDatabaseBuilder.js";
+export { MiniDatabase } from "./database/MiniDatabase.js";
+export { generateOAuthUrl, getOAuthTokens, refreshAccessToken, getDiscordUser, ensureValidToken, } from "./oauth/DiscordOAuth.js";
+export type { OAuthConfig, OAuthTokens, DiscordUser, } from "./oauth/DiscordOAuth.js";
+export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";

package/dist/index.js

@@ -11,3 +11,8 @@ export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export * from "./builders/index.js";
+export { MiniDataBuilder } from "./database/MiniDataBuilder.js";
+export { MiniDatabaseBuilder } from "./database/MiniDatabaseBuilder.js";
+export { MiniDatabase } from "./database/MiniDatabase.js";
+export { generateOAuthUrl, getOAuthTokens, refreshAccessToken, getDiscordUser, ensureValidToken, } from "./oauth/DiscordOAuth.js";
+export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";

package/dist/oauth/DiscordOAuth.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Discord OAuth utilities for handling the OAuth2 flow.
+ * Simplifies Discord authentication for mini-interaction apps.
+ */
+export interface OAuthConfig {
+    appId: string;
+    appSecret: string;
+    redirectUri: string;
+}
+export interface OAuthTokens {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type: string;
+    scope: string;
+}
+export interface DiscordUser {
+    id: string;
+    username: string;
+    discriminator: string;
+    avatar: string | null;
+    email?: string;
+    verified?: boolean;
+    locale?: string;
+    mfa_enabled?: boolean;
+}
+/**
+ * Generates an OAuth authorization URL for Discord.
+ */
+export declare function generateOAuthUrl(config: OAuthConfig, scopes?: string[]): {
+    url: string;
+    state: string;
+};
+/**
+ * Exchanges an OAuth code for access tokens.
+ */
+export declare function getOAuthTokens(code: string, config: OAuthConfig): Promise<OAuthTokens>;
+/**
+ * Refreshes an expired access token.
+ */
+export declare function refreshAccessToken(refreshToken: string, config: OAuthConfig): Promise<OAuthTokens>;
+/**
+ * Gets the current user's Discord profile.
+ */
+export declare function getDiscordUser(accessToken: string): Promise<DiscordUser>;
+/**
+ * Ensures the access token is valid, refreshing if necessary.
+ */
+export declare function ensureValidToken(tokens: OAuthTokens, config: OAuthConfig): Promise<OAuthTokens>;

package/dist/oauth/DiscordOAuth.js

@@ -0,0 +1,110 @@
+import crypto from "crypto";
+/**
+ * Generates an OAuth authorization URL for Discord.
+ */
+export function generateOAuthUrl(config, scopes = ["identify", "email"]) {
+    const state = crypto.randomUUID();
+    const url = new URL("https://discord.com/api/oauth2/authorize");
+    url.searchParams.set("client_id", config.appId);
+    url.searchParams.set("redirect_uri", config.redirectUri);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("state", state);
+    url.searchParams.set("scope", scopes.join(" "));
+    url.searchParams.set("prompt", "consent");
+    return { url: url.toString(), state };
+}
+/**
+ * Exchanges an OAuth code for access tokens.
+ */
+export async function getOAuthTokens(code, config) {
+    const url = "https://discord.com/api/v10/oauth2/token";
+    const body = new URLSearchParams({
+        client_id: config.appId,
+        client_secret: config.appSecret,
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: config.redirectUri,
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        body,
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get OAuth tokens: [${response.status}] ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Date.now() + data.expires_in * 1000,
+        token_type: data.token_type,
+        scope: data.scope,
+    };
+}
+/**
+ * Refreshes an expired access token.
+ */
+export async function refreshAccessToken(refreshToken, config) {
+    const url = "https://discord.com/api/v10/oauth2/token";
+    const body = new URLSearchParams({
+        client_id: config.appId,
+        client_secret: config.appSecret,
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        body,
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to refresh access token: [${response.status}] ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Date.now() + data.expires_in * 1000,
+        token_type: data.token_type,
+        scope: data.scope,
+    };
+}
+/**
+ * Gets the current user's Discord profile.
+ */
+export async function getDiscordUser(accessToken) {
+    const url = "https://discord.com/api/v10/oauth2/@me";
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get Discord user: [${response.status}] ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return {
+        id: data.user.id,
+        username: data.user.username,
+        discriminator: data.user.discriminator,
+        avatar: data.user.avatar,
+        email: data.user.email,
+        verified: data.user.verified,
+        locale: data.user.locale,
+        mfa_enabled: data.user.mfa_enabled,
+    };
+}
+/**
+ * Ensures the access token is valid, refreshing if necessary.
+ */
+export async function ensureValidToken(tokens, config) {
+    if (Date.now() > tokens.expires_at) {
+        return refreshAccessToken(tokens.refresh_token, config);
+    }
+    return tokens;
+}

package/dist/oauth/OAuthTokenStorage.d.ts

@@ -0,0 +1,31 @@
+import type { MiniDatabase } from "../database/MiniDatabase.js";
+import type { OAuthTokens } from "./DiscordOAuth.js";
+/**
+ * Manages OAuth token storage using MiniDatabase.
+ * Handles both in-memory and persistent storage.
+ */
+export declare class OAuthTokenStorage {
+    private db?;
+    private inMemoryStore;
+    constructor(db?: MiniDatabase);
+    /**
+     * Stores OAuth tokens for a user.
+     */
+    storeTokens(userId: string, tokens: OAuthTokens): Promise<boolean>;
+    /**
+     * Retrieves OAuth tokens for a user.
+     */
+    getTokens(userId: string): Promise<OAuthTokens | null>;
+    /**
+     * Updates OAuth tokens for a user.
+     */
+    updateTokens(userId: string, tokens: OAuthTokens): Promise<boolean>;
+    /**
+     * Deletes OAuth tokens for a user.
+     */
+    deleteTokens(userId: string): Promise<boolean>;
+    /**
+     * Clears all in-memory tokens (useful for testing).
+     */
+    clearMemory(): void;
+}

package/dist/oauth/OAuthTokenStorage.js

@@ -0,0 +1,109 @@
+/**
+ * Manages OAuth token storage using MiniDatabase.
+ * Handles both in-memory and persistent storage.
+ */
+export class OAuthTokenStorage {
+    db;
+    inMemoryStore = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Stores OAuth tokens for a user.
+     */
+    async storeTokens(userId, tokens) {
+        try {
+            // Always store in memory for fast access
+            this.inMemoryStore.set(`oauth-${userId}`, tokens);
+            // Also store in database if available
+            if (this.db) {
+                return await this.db.set(`oauth-${userId}`, {
+                    userId,
+                    ...tokens,
+                });
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [OAuthTokenStorage] Failed to store tokens for ${userId}:`, err);
+            return false;
+        }
+    }
+    /**
+     * Retrieves OAuth tokens for a user.
+     */
+    async getTokens(userId) {
+        try {
+            // Check in-memory store first
+            const cached = this.inMemoryStore.get(`oauth-${userId}`);
+            if (cached) {
+                return cached;
+            }
+            // Check database if available
+            if (this.db) {
+                const data = await this.db.get(`oauth-${userId}`);
+                if (data) {
+                    const tokens = {
+                        access_token: data.access_token,
+                        refresh_token: data.refresh_token,
+                        expires_at: data.expires_at,
+                        token_type: data.token_type,
+                        scope: data.scope,
+                    };
+                    // Cache in memory
+                    this.inMemoryStore.set(`oauth-${userId}`, tokens);
+                    return tokens;
+                }
+            }
+            return null;
+        }
+        catch (err) {
+            console.error(`❌ [OAuthTokenStorage] Failed to get tokens for ${userId}:`, err);
+            return null;
+        }
+    }
+    /**
+     * Updates OAuth tokens for a user.
+     */
+    async updateTokens(userId, tokens) {
+        try {
+            // Update in-memory store
+            this.inMemoryStore.set(`oauth-${userId}`, tokens);
+            // Update in database if available
+            if (this.db) {
+                return await this.db.update(`oauth-${userId}`, {
+                    ...tokens,
+                });
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [OAuthTokenStorage] Failed to update tokens for ${userId}:`, err);
+            return false;
+        }
+    }
+    /**
+     * Deletes OAuth tokens for a user.
+     */
+    async deleteTokens(userId) {
+        try {
+            // Remove from in-memory store
+            this.inMemoryStore.delete(`oauth-${userId}`);
+            // Remove from database if available
+            if (this.db) {
+                return await this.db.delete(`oauth-${userId}`);
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`❌ [OAuthTokenStorage] Failed to delete tokens for ${userId}:`, err);
+            return false;
+        }
+    }
+    /**
+     * Clears all in-memory tokens (useful for testing).
+     */
+    clearMemory() {
+        this.inMemoryStore.clear();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minesa-org/mini-interaction",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",