@rimori/client 2.4.0 → 2.5.0-next.2

package/dist/plugin/RimoriClient.js

@@ -7,176 +7,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { generateText, streamChatGPT } from '../controller/AIController';
-import { generateObject } from '../controller/ObjectController';
-import { SettingsController } from '../controller/SettingsController';
 import { SharedContentController, } from '../controller/SharedContentController';
-import { getSTTResponse, getTTSResponse } from '../controller/VoiceController';
-import { ExerciseController } from '../controller/ExerciseController';
-import { EventBus } from '../fromRimori/EventBus';
-import { AccomplishmentController } from '../controller/AccomplishmentController';
 import { RimoriCommunicationHandler } from './CommunicationHandler';
-import { Translator } from '../controller/TranslationController';
 import { Logger } from './Logger';
+import { PluginModule } from './module/PluginModule';
+import { DbModule } from './module/DbModule';
+import { EventModule } from './module/EventModule';
+import { AIModule } from './module/AIModule';
+import { ExerciseModule } from './module/ExerciseModule';
 export class RimoriClient {
     constructor(controller, supabase, info) {
-        this.event = {
-            /**
-             * Emit an event to Rimori or a plugin.
-             * The topic schema is:
-             * {pluginId}.{eventId}
-             * Check out the event bus documentation for more information.
-             * For triggering events from Rimori like context menu actions use the "global" keyword.
-             * @param topic The topic to emit the event on.
-             * @param data The data to emit.
-             * @param eventId The event id.
-             */
-            emit: (topic, data, eventId) => {
-                const globalTopic = this.pluginController.getGlobalEventTopic(topic);
-                EventBus.emit(this.plugin.pluginId, globalTopic, data, eventId);
-            },
-            /**
-             * Request an event.
-             * @param topic The topic to request the event on.
-             * @param data The data to request.
-             * @returns The response from the event.
-             */
-            request: (topic, data) => {
-                const globalTopic = this.pluginController.getGlobalEventTopic(topic);
-                return EventBus.request(this.plugin.pluginId, globalTopic, data);
-            },
-            /**
-             * Subscribe to an event.
-             * @param topic The topic to subscribe to.
-             * @param callback The callback to call when the event is emitted.
-             * @returns An EventListener object containing an off() method to unsubscribe the listeners.
-             */
-            on: (topic, callback) => {
-                const topics = Array.isArray(topic) ? topic : [topic];
-                return EventBus.on(topics.map((t) => this.pluginController.getGlobalEventTopic(t)), callback);
-            },
-            /**
-             * Subscribe to an event once.
-             * @param topic The topic to subscribe to.
-             * @param callback The callback to call when the event is emitted.
-             */
-            once: (topic, callback) => {
-                EventBus.once(this.pluginController.getGlobalEventTopic(topic), callback);
-            },
-            /**
-             * Respond to an event.
-             * @param topic The topic to respond to.
-             * @param data The data to respond with.
-             */
-            respond: (topic, data) => {
-                const topics = Array.isArray(topic) ? topic : [topic];
-                EventBus.respond(this.plugin.pluginId, topics.map((t) => this.pluginController.getGlobalEventTopic(t)), data);
-            },
-            /**
-             * Emit an accomplishment.
-             * @param payload The payload to emit.
-             */
-            emitAccomplishment: (payload) => {
-                this.accomplishmentHandler.emitAccomplishment(payload);
-            },
-            /**
-             * Subscribe to an accomplishment.
-             * @param accomplishmentTopic The topic to subscribe to.
-             * @param callback The callback to call when the accomplishment is emitted.
-             */
-            onAccomplishment: (accomplishmentTopic, callback) => {
-                this.accomplishmentHandler.subscribe(accomplishmentTopic, callback);
-            },
-            /**
-             * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
-             * @param pluginId The id of the plugin to trigger the action for.
-             * @param actionKey The key of the action to trigger.
-             * @param text Optional text to be used for the action like for example text that the translator would look up.
-             */
-            emitSidebarAction: (pluginId, actionKey, text) => {
-                this.event.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
-            },
-            /**
-             * Subscribe to main panel actions triggered by the user from the dashboard.
-             * @param callback Handler function that receives the action data when a matching action is triggered.
-             * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
-             * @returns An EventListener object with an `off()` method for cleanup.
-             *
-             * @example
-             * ```ts
-             * const listener = client.event.onMainPanelAction((data) => {
-             *   console.log('Action received:', data.action_key);
-             * }, ['startSession', 'pauseSession']);
-             *
-             * // Clean up when component unmounts to prevent events from firing
-             * // when navigating away or returning to the page
-             * useEffect(() => {
-             *   return () => listener.off();
-             * }, []);
-             * ```
-             *
-             * **Important:** Always call `listener.off()` when your component unmounts or when you no longer need to listen.
-             * This prevents the event handler from firing when navigating away from or returning to the page, which could
-             * cause unexpected behavior or duplicate event handling.
-             */
-            onMainPanelAction: (callback, actionsToListen = []) => {
-                const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [actionsToListen];
-                // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
-                this.event.emit('action.requestMain');
-                return this.event.on('action.requestMain', ({ data }) => {
-                    // console.log('Received action for main panel ' + data.action_key);
-                    // console.log('Listening to actions', listeningActions);
-                    if (listeningActions.length === 0 || listeningActions.includes(data.action_key)) {
-                        callback(data);
-                    }
-                });
-            },
-            onSidePanelAction: (callback, actionsToListen = []) => {
-                const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [actionsToListen];
-                // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
-                this.event.emit('action.requestSidebar');
-                return this.event.on('action.requestSidebar', ({ data }) => {
-                    // console.log("eventHandler .onSidePanelAction", data);
-                    // console.log('Received action for sidebar ' + data.action);
-                    // console.log('Listening to actions', listeningActions);
-                    if (listeningActions.length === 0 || listeningActions.includes(data.action)) {
-                        callback(data);
-                    }
-                });
-            },
-        };
         this.navigation = {
             toDashboard: () => {
                 this.event.emit('global.navigation.triggerToDashboard');
             },
         };
-        this.ai = {
-            getText: (messages, tools) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                return generateText(this.pluginController.getBackendUrl(), messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
-            }),
-            getSteamedText: (messages, onMessage, tools) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                streamChatGPT(this.pluginController.getBackendUrl(), messages, tools || [], onMessage, token);
-            }),
-            getVoice: (text_1, ...args_1) => __awaiter(this, [text_1, ...args_1], void 0, function* (text, voice = 'alloy', speed = 1, language) {
-                const token = yield this.pluginController.getToken();
-                return getTTSResponse(this.pluginController.getBackendUrl(), { input: text, voice, speed, language }, token);
-            }),
-            getTextFromVoice: (file) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                return getSTTResponse(this.pluginController.getBackendUrl(), file, token);
-            }),
-            getObject: (request) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                return generateObject(this.pluginController.getBackendUrl(), request, token);
-            }),
-            // getSteamedObject: this.generateObjectStream,
-        };
         this.runtime = {
             fetchBackend: (url, options) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                return fetch(this.pluginController.getBackendUrl() + url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { Authorization: `Bearer ${token}` }) }));
+                return fetch(this.rimoriInfo.backendUrl + url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { Authorization: `Bearer ${this.rimoriInfo.token}` }) }));
             }),
         };
         this.community = {
@@ -263,156 +111,26 @@ export class RimoriClient {
                 }),
             },
         };
-        this.exercise = {
-            /**
-             * Fetches weekly exercises from the weekly_exercises view.
-             * Shows exercises for the current week that haven't expired.
-             * @returns Array of exercise objects.
-             */
-            view: () => __awaiter(this, void 0, void 0, function* () {
-                return this.exerciseController.viewWeeklyExercises();
-            }),
-            /**
-             * Creates a new exercise or multiple exercises via the backend API.
-             * When creating multiple exercises, all requests are made in parallel but only one event is emitted.
-             * @param params Exercise creation parameters (single or array).
-             * @returns Created exercise objects.
-             */
-            add: (params) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                const backendUrl = this.pluginController.getBackendUrl();
-                const exercises = Array.isArray(params) ? params : [params];
-                return this.exerciseController.addExercise(token, backendUrl, exercises);
-            }),
-            /**
-             * Deletes an exercise via the backend API.
-             * @param id The exercise ID to delete.
-             * @returns Success status.
-             */
-            delete: (id) => __awaiter(this, void 0, void 0, function* () {
-                const token = yield this.pluginController.getToken();
-                const backendUrl = this.pluginController.getBackendUrl();
-                return this.exerciseController.deleteExercise(token, backendUrl, id);
-            }),
-        };
         this.rimoriInfo = info;
-        this.superbase = supabase;
         this.pluginController = controller;
-        this.exerciseController = new ExerciseController(supabase, this);
-        this.accomplishmentHandler = new AccomplishmentController(info.pluginId);
-        this.settingsController = new SettingsController(supabase, info.pluginId, info.guild);
         this.sharedContentController = new SharedContentController(supabase, this);
-        const currentPlugin = info.installedPlugins.find((plugin) => plugin.id === info.pluginId);
-        this.translator = new Translator(info.interfaceLanguage, (currentPlugin === null || currentPlugin === void 0 ? void 0 : currentPlugin.endpoint) || '');
+        this.ai = new AIModule(controller, info);
+        this.event = new EventModule(info.pluginId);
+        this.db = new DbModule(supabase, controller, info);
+        this.plugin = new PluginModule(supabase, controller, info);
+        this.exercise = new ExerciseModule(supabase, controller, info, this.event);
+        controller.onUpdate((updatedInfo) => {
+            this.rimoriInfo = updatedInfo;
+        });
         //only init logger in workers and on main plugin pages
-        if (this.getQueryParam('applicationMode') !== 'sidebar') {
+        if (this.plugin.applicationMode !== 'sidebar') {
             Logger.getInstance(this);
         }
     }
-    get plugin() {
-        return {
-            pluginId: this.rimoriInfo.pluginId,
-            /**
-             * The release channel of this plugin installation.
-             * Determines which database schema is used for plugin tables.
-             */
-            releaseChannel: this.rimoriInfo.releaseChannel,
-            /**
-             * Set the settings for the plugin.
-             * @param settings The settings to set.
-             */
-            setSettings: (settings) => __awaiter(this, void 0, void 0, function* () {
-                yield this.settingsController.setSettings(settings);
-            }),
-            /**
-             * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
-             * @param defaultSettings The default settings to use if no settings are found.
-             * @param genericSettings The type of settings to get.
-             * @returns The settings for the plugin.
-             */
-            getSettings: (defaultSettings) => __awaiter(this, void 0, void 0, function* () {
-                return yield this.settingsController.getSettings(defaultSettings);
-            }),
-            getUserInfo: () => {
-                return this.rimoriInfo.profile;
-            },
-            /**
-             * Retrieves information about plugins, including:
-             * - All installed plugins
-             * - The currently active plugin in the main panel
-             * - The currently active plugin in the side panel
-             */
-            getPluginInfo: () => {
-                return {
-                    installedPlugins: this.rimoriInfo.installedPlugins,
-                    mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
-                    sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
-                };
-            },
-            /**
-             * Get the translator for the plugin.
-             * @returns The translator for the plugin.
-             */
-            getTranslator: () => __awaiter(this, void 0, void 0, function* () {
-                yield this.translator.initialize();
-                return this.translator;
-            }),
-        };
-    }
-    get db() {
-        return {
-            //     private from<
-            //   TableName extends string & keyof GenericSchema['Tables'],
-            //   Table extends GenericSchema['Tables'][TableName],
-            // >(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
-            // private from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(
-            //   relation: ViewName,
-            // ): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
-            from: (relation) => {
-                const tableName = this.db.getTableName(relation);
-                // Use the schema determined by rimori-main based on release channel
-                // Global tables (starting with 'global_') remain in public schema
-                // Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha)
-                if (relation.startsWith('global_')) {
-                    // Global tables stay in public schema
-                    return this.superbase.from(tableName);
-                }
-                // Plugin tables go to the schema provided by rimori-main
-                return this.superbase.schema(this.rimoriInfo.dbSchema).from(tableName);
-            },
-            // storage: this.superbase.storage,
-            // functions: this.superbase.functions,
-            /**
-             * The table prefix for of database tables of the plugin.
-             */
-            tablePrefix: this.rimoriInfo.tablePrefix,
-            /**
-             * The database schema used for plugin tables.
-             * Determined by rimori-main based on release channel:
-             * - 'plugins_alpha' for alpha release channel
-             * - 'plugins' for beta and stable release channels
-             */
-            schema: this.rimoriInfo.dbSchema,
-            /**
-             * Get the table name for a given plugin table.
-             * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
-             * @param table The plugin table name to get the full table name for.
-             * @returns The full table name.
-             */
-            getTableName: (table) => {
-                if (/[A-Z]/.test(table)) {
-                    throw new Error('Table name cannot include uppercase letters. Please use snake_case for table names.');
-                }
-                if (table.startsWith('global_')) {
-                    return table.replace('global_', '');
-                }
-                return this.db.tablePrefix + '_' + table;
-            },
-        };
-    }
     /**
      * Get a query parameter value that was passed via MessageChannel
      * @param key The query parameter key
+     * @deprecated Use the plugin.applicationMode and plugin.theme properties instead
      * @returns The query parameter value or null if not found
      */
     getQueryParam(key) {
@@ -436,3 +154,4 @@ export class RimoriClient {
         });
     }
 }
+// test

package/dist/plugin/StandaloneClient.d.ts

@@ -1,4 +1,4 @@
-import { SupabaseClient } from '@supabase/supabase-js';
+import { SupabaseClient } from './CommunicationHandler';
 export interface StandaloneConfig {
     url: string;
     key: string;

package/dist/plugin/StandaloneClient.js

@@ -7,12 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createClient } from '@supabase/supabase-js';
 import { EventBus } from '../fromRimori/EventBus';
 import { DEFAULT_ANON_KEY, DEFAULT_ENDPOINT } from '../utils/endpoint';
 export class StandaloneClient {
     constructor(config) {
-        this.supabase = createClient(config.url, config.key);
+        throw new Error('Authentication is disabled until new developer platform is released.');
+        // this.supabase = createClient(config.url, config.key);
+        this.supabase = {};
         this.config = config;
     }
     static getInstance() {

package/dist/plugin/module/AIModule.d.ts

@@ -0,0 +1,49 @@
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { Message, OnLLMResponse } from '../../controller/AIController';
+import { ObjectRequest } from '../../controller/ObjectController';
+import { Tool } from '../../fromRimori/PluginTypes';
+/**
+ * Controller for AI-related operations.
+ * Provides access to text generation, voice synthesis, and object generation.
+ */
+export declare class AIModule {
+    private communicationHandler;
+    private backendUrl;
+    private token;
+    constructor(communicationHandler: RimoriCommunicationHandler, info: RimoriInfo);
+    /**
+     * Generate text from messages using AI.
+     * @param messages The messages to generate text from.
+     * @param tools Optional tools to use for generation.
+     * @returns The generated text.
+     */
+    getText(messages: Message[], tools?: Tool[]): Promise<string>;
+    /**
+     * Stream text generation from messages using AI.
+     * @param messages The messages to generate text from.
+     * @param onMessage Callback for each message chunk.
+     * @param tools Optional tools to use for generation.
+     */
+    getSteamedText(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]): Promise<void>;
+    /**
+     * Generate voice audio from text using AI.
+     * @param text The text to convert to voice.
+     * @param voice The voice to use (default: 'alloy').
+     * @param speed The speed of the voice (default: 1).
+     * @param language Optional language for the voice.
+     * @returns The generated audio as a Blob.
+     */
+    getVoice(text: string, voice?: string, speed?: number, language?: string): Promise<Blob>;
+    /**
+     * Convert voice audio to text using AI.
+     * @param file The audio file to convert.
+     * @returns The transcribed text.
+     */
+    getTextFromVoice(file: Blob): Promise<string>;
+    /**
+     * Generate a structured object from a request using AI.
+     * @param request The object generation request.
+     * @returns The generated object.
+     */
+    getObject<T = any>(request: ObjectRequest): Promise<T>;
+}

package/dist/plugin/module/AIModule.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { generateText, streamChatGPT } from '../../controller/AIController';
+import { generateObject } from '../../controller/ObjectController';
+import { getSTTResponse, getTTSResponse } from '../../controller/VoiceController';
+/**
+ * Controller for AI-related operations.
+ * Provides access to text generation, voice synthesis, and object generation.
+ */
+export class AIModule {
+    constructor(communicationHandler, info) {
+        this.token = info.token;
+        this.backendUrl = info.backendUrl;
+        this.communicationHandler = communicationHandler;
+        this.communicationHandler.onUpdate((updatedInfo) => {
+            this.token = updatedInfo.token;
+        });
+    }
+    /**
+     * Generate text from messages using AI.
+     * @param messages The messages to generate text from.
+     * @param tools Optional tools to use for generation.
+     * @returns The generated text.
+     */
+    getText(messages, tools) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return generateText(this.backendUrl, messages, tools || [], this.token).then(({ messages }) => messages[0].content[0].text);
+        });
+    }
+    /**
+     * Stream text generation from messages using AI.
+     * @param messages The messages to generate text from.
+     * @param onMessage Callback for each message chunk.
+     * @param tools Optional tools to use for generation.
+     */
+    getSteamedText(messages, onMessage, tools) {
+        return __awaiter(this, void 0, void 0, function* () {
+            streamChatGPT(this.backendUrl, messages, tools || [], onMessage, this.token);
+        });
+    }
+    /**
+     * Generate voice audio from text using AI.
+     * @param text The text to convert to voice.
+     * @param voice The voice to use (default: 'alloy').
+     * @param speed The speed of the voice (default: 1).
+     * @param language Optional language for the voice.
+     * @returns The generated audio as a Blob.
+     */
+    getVoice(text_1) {
+        return __awaiter(this, arguments, void 0, function* (text, voice = 'alloy', speed = 1, language) {
+            return getTTSResponse(this.backendUrl, { input: text, voice, speed, language }, this.token);
+        });
+    }
+    /**
+     * Convert voice audio to text using AI.
+     * @param file The audio file to convert.
+     * @returns The transcribed text.
+     */
+    getTextFromVoice(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return getSTTResponse(this.backendUrl, file, this.token);
+        });
+    }
+    /**
+     * Generate a structured object from a request using AI.
+     * @param request The object generation request.
+     * @returns The generated object.
+     */
+    getObject(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return generateObject(this.backendUrl, request, this.token);
+        });
+    }
+}

package/dist/plugin/module/DbModule.d.ts

@@ -0,0 +1,30 @@
+import { PostgrestClientOptions, PostgrestQueryBuilder } from '@supabase/postgrest-js';
+import { SupabaseClient } from '../CommunicationHandler';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { GenericSchema, GenericTable } from '@supabase/postgrest-js/dist/cjs/types/common/common';
+/**
+ * Database module for plugin database operations.
+ * Provides access to plugin tables with automatic prefixing and schema management.
+ */
+export declare class DbModule {
+    private supabase;
+    private rimoriInfo;
+    tablePrefix: string;
+    schema: string;
+    constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo);
+    /**
+     * Query a database table.
+     * Global tables (starting with 'global_') remain in public schema.
+     * Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha).
+     * @param relation The table name (without prefix for plugin tables, with 'global_' for global tables).
+     * @returns A Postgrest query builder for the table.
+     */
+    from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: string): PostgrestQueryBuilder<PostgrestClientOptions, GenericSchema, GenericTable, ViewName, View>;
+    /**
+     * Get the table name for a given plugin table.
+     * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
+     * @param table The plugin table name to get the full table name for.
+     * @returns The full table name.
+     */
+    getTableName(table: string): string;
+}

package/dist/plugin/module/DbModule.js

@@ -0,0 +1,51 @@
+/**
+ * Database module for plugin database operations.
+ * Provides access to plugin tables with automatic prefixing and schema management.
+ */
+export class DbModule {
+    constructor(supabase, communicationHandler, info) {
+        this.supabase = supabase;
+        this.rimoriInfo = info;
+        this.tablePrefix = info.tablePrefix;
+        this.schema = info.dbSchema;
+        communicationHandler.onUpdate((updatedInfo) => {
+            this.rimoriInfo = updatedInfo;
+            this.tablePrefix = updatedInfo.tablePrefix;
+            this.schema = updatedInfo.dbSchema;
+        });
+    }
+    /**
+     * Query a database table.
+     * Global tables (starting with 'global_') remain in public schema.
+     * Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha).
+     * @param relation The table name (without prefix for plugin tables, with 'global_' for global tables).
+     * @returns A Postgrest query builder for the table.
+     */
+    from(relation) {
+        const tableName = this.getTableName(relation);
+        // Use the schema determined by rimori-main based on release channel
+        // Global tables (starting with 'global_') remain in public schema
+        // Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha)
+        if (relation.startsWith('global_')) {
+            // Global tables stay in public schema
+            return this.supabase.from(tableName);
+        }
+        // Plugin tables go to the schema provided by rimori-main
+        return this.supabase.schema(this.rimoriInfo.dbSchema).from(tableName);
+    }
+    /**
+     * Get the table name for a given plugin table.
+     * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
+     * @param table The plugin table name to get the full table name for.
+     * @returns The full table name.
+     */
+    getTableName(table) {
+        if (/[A-Z]/.test(table)) {
+            throw new Error('Table name cannot include uppercase letters. Please use snake_case for table names.');
+        }
+        if (table.startsWith('global_')) {
+            return table.replace('global_', '');
+        }
+        return this.tablePrefix + '_' + table;
+    }
+}