@rimori/client 2.4.0-next.5 → 2.4.0-next.7

package/src/controller/SettingsController.ts

@@ -1,186 +0,0 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { LanguageLevel } from '../utils/difficultyConverter';
-import { Guild } from '../plugin/CommunicationHandler';
-
-export interface Buddy {
-  id: string;
-  name: string;
-  description: string;
-  avatarUrl: string;
-  voiceId: string;
-  aiPersonality: string;
-}
-
-export interface Language {
-  code: string;
-  name: string;
-  native: string;
-  capitalized: string;
-  uppercase: string;
-}
-
-export type UserRole = 'user' | 'plugin_moderator' | 'lang_moderator' | 'admin';
-
-export interface UserInfo {
-  skill_level_reading: LanguageLevel;
-  skill_level_writing: LanguageLevel;
-  skill_level_grammar: LanguageLevel;
-  skill_level_speaking: LanguageLevel;
-  skill_level_listening: LanguageLevel;
-  skill_level_understanding: LanguageLevel;
-  goal_longterm: string;
-  goal_weekly: string;
-  study_buddy: Buddy;
-  story_genre: string;
-  study_duration: number;
-  /**
-   * The language the user speaks natively.
-   */
-  mother_tongue: Language;
-  /**
-   * The language the user targets to learn.
-   */
-  target_language: Language;
-  motivation_type: string;
-  onboarding_completed: boolean;
-  context_menu_on_select: boolean;
-  user_name?: string;
-  /**
-   * ISO 3166-1 alpha-2 country code of user's target location (exposed to plugins)
-   */
-  target_country: string;
-  /**
-   * Optional: nearest big city (>100,000) near user's location
-   */
-  target_city?: string;
-  /**
-   * The user's role: 'user', 'plugin_moderator', 'lang_moderator', or 'admin'
-   */
-  user_role: UserRole;
-}
-
-export class SettingsController {
-  private pluginId: string;
-  private supabase: SupabaseClient;
-  private guild: Guild;
-
-  constructor(supabase: SupabaseClient, pluginId: string, guild: Guild) {
-    this.supabase = supabase;
-    this.pluginId = pluginId;
-    this.guild = guild;
-  }
-
-  /**
-   * Fetches settings based on guild configuration.
-   * If guild doesn't allow user settings, fetches guild-level settings.
-   * Otherwise, fetches user-specific settings.
-   * @returns The settings object or null if not found.
-   */
-  private async fetchSettings(): Promise<any | null> {
-    const isGuildSetting = !this.guild.allowUserPluginSettings;
-
-    const { data } = await this.supabase
-      .from('plugin_settings')
-      .select('*')
-      .eq('plugin_id', this.pluginId)
-      .eq('guild_id', this.guild.id)
-      .eq('is_guild_setting', isGuildSetting)
-      .maybeSingle();
-
-    return data?.settings ?? null;
-  }
-
-  /**
-   * Sets settings for the plugin.
-   * Automatically saves as guild settings if guild doesn't allow user settings,
-   * otherwise saves as user-specific settings.
-   * @param settings - The settings object to save.
-   * @throws {Error} if RLS blocks the operation.
-   */
-  public async setSettings(settings: any): Promise<void> {
-    const isGuildSetting = !this.guild.allowUserPluginSettings;
-
-    const payload: any = {
-      plugin_id: this.pluginId,
-      settings,
-      guild_id: this.guild.id,
-      is_guild_setting: isGuildSetting,
-    };
-
-    if (isGuildSetting) {
-      payload.user_id = null;
-    }
-
-    // Try UPDATE first (safe with RLS). If nothing updated, INSERT.
-    const updateQuery = this.supabase
-      .from('plugin_settings')
-      .update({ settings })
-      .eq('plugin_id', this.pluginId)
-      .eq('guild_id', this.guild.id)
-      .eq('is_guild_setting', isGuildSetting);
-
-    const { data: updatedRows, error: updateError } = await (isGuildSetting
-      ? updateQuery.is('user_id', null).select('id')
-      : updateQuery.select('id'));
-
-    if (updateError) {
-      if (updateError.code === '42501' || updateError.message?.includes('policy')) {
-        throw new Error(`Cannot set ${isGuildSetting ? 'guild' : 'user'} settings: Permission denied.`);
-      }
-      // proceed to try insert in case of other issues
-    }
-
-    if (updatedRows && updatedRows.length > 0) {
-      return; // updated successfully
-    }
-
-    // No row updated -> INSERT
-    const { error: insertError } = await this.supabase.from('plugin_settings').insert(payload);
-
-    if (insertError) {
-      // In case of race condition (duplicate), try one more UPDATE
-      if (insertError.code === '23505' /* unique_violation */) {
-        const retry = this.supabase
-          .from('plugin_settings')
-          .update({ settings })
-          .eq('plugin_id', this.pluginId)
-          .eq('guild_id', this.guild.id)
-          .eq('is_guild_setting', isGuildSetting);
-        const { error: retryError } = await (isGuildSetting ? retry.is('user_id', null) : retry);
-        if (!retryError) return;
-      }
-
-      throw insertError;
-    }
-  }
-
-  /**
-   * 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.
-   * @returns The settings for the plugin.
-   */
-  public async getSettings<T extends object>(defaultSettings: T): Promise<T> {
-    const storedSettings = (await this.fetchSettings()) as T | null;
-
-    if (!storedSettings) {
-      await this.setSettings(defaultSettings);
-      return defaultSettings;
-    }
-
-    // Handle settings migration
-    const storedKeys = Object.keys(storedSettings);
-    const defaultKeys = Object.keys(defaultSettings);
-
-    if (storedKeys.length !== defaultKeys.length) {
-      const validStoredSettings = Object.fromEntries(
-        Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key)),
-      );
-      const mergedSettings = { ...defaultSettings, ...validStoredSettings } as T;
-
-      await this.setSettings(mergedSettings);
-      return mergedSettings;
-    }
-
-    return storedSettings;
-  }
-}

package/src/controller/SharedContentController.ts

@@ -1,365 +0,0 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from '../plugin/RimoriClient';
-import { ObjectRequest } from './ObjectController';
-
-export interface SharedContentObjectRequest extends ObjectRequest {
-  fixedProperties?: Record<string, string | number | boolean>;
-}
-
-export type SharedContentFilter = Record<string, string | number | boolean>;
-
-export class SharedContentController {
-  private supabase: SupabaseClient;
-  private rimoriClient: RimoriClient;
-
-  constructor(supabase: SupabaseClient, rimoriClient: RimoriClient) {
-    this.supabase = supabase;
-    this.rimoriClient = rimoriClient;
-  }
-
-  /**
-   * Fetch new shared content for a given content type.
-   * @param contentType - The type of content to fetch.
-   * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
-   * @param filter - An optional filter to apply to the query.
-   * @param options - Optional options.
-   * @param options.privateTopic - If the topic should be private and only be visible to the user.
-   * @param options.skipDbSave - If true, do not persist a newly generated content to the DB (default false).
-   * @param options.alwaysGenerateNew - If true, always generate a new content even if there is already a content with the same filter.
-   * @param options.excludeIds - Optional list of shared_content ids to exclude from selection.
-   * @returns The new shared content.
-   */
-  public async getNewSharedContent<T>(
-    contentType: string,
-    generatorInstructions: SharedContentObjectRequest,
-    //this filter is there if the content should be filtered additionally by a column and value
-    filter?: SharedContentFilter,
-    options?: { privateTopic?: boolean; skipDbSave?: boolean; alwaysGenerateNew?: boolean; excludeIds?: string[] },
-  ): Promise<SharedContent<T>> {
-    // The db cache of the shared content is temporary disabled until the new shared content implementation is completed
-    // if (false) {
-    //   let query = this.supabase
-    //     .from('shared_content')
-    //     .select('*, scc:shared_content_completed(id, state)')
-    //     .eq('content_type', contentType)
-    //     .not('scc.state', 'in', '("completed","ongoing","hidden")')
-    //     .is('deleted_at', null);
-
-    //   if (options?.excludeIds?.length ?? 0 > 0) {
-    //     const excludeIds = options.excludeIds.filter((id) => !id.startsWith('internal-temp-id-'));
-    //     // Supabase expects raw PostgREST syntax like '("id1","id2")'.
-    //     const excludeList = `(${excludeIds.map((id) => `"${id}"`).join(',')})`;
-    //     query = query.not('id', 'in', excludeList);
-    //   }
-
-    //   if (filter) {
-    //     query.contains('data', filter);
-    //   }
-
-    //   const { data: newAssignments, error } = await query.limit(30);
-
-    //   if (error) {
-    //     console.error('error fetching new assignments:', error);
-    //     throw new Error('error fetching new assignments');
-    //   }
-
-    //   // console.log('newAssignments:', newAssignments);
-
-    //   if (!options?.alwaysGenerateNew && newAssignments.length > 0) {
-    //     const index = Math.floor(Math.random() * newAssignments.length);
-    //     return newAssignments[index];
-    //   }
-    // }
-    const instructions = await this.generateNewAssignment(contentType, generatorInstructions, filter);
-
-    console.log('instructions:', instructions);
-
-    //create the shared content object
-    const data: SharedContent<T> = {
-      id: 'internal-temp-id-' + Math.random().toString(36).substring(2, 15),
-      contentType,
-      title: instructions.title,
-      keywords: instructions.keywords.map(({ text }: { text: string }) => text),
-      data: { ...instructions, title: undefined, keywords: undefined, ...generatorInstructions.fixedProperties },
-      privateTopic: options?.privateTopic,
-    };
-
-    if (options?.skipDbSave) {
-      return data;
-    }
-
-    return await this.createSharedContent(data);
-  }
-
-  private async generateNewAssignment(
-    contentType: string,
-    generatorInstructions: SharedContentObjectRequest,
-    filter?: SharedContentFilter,
-  ): Promise<any> {
-    const fullInstructions = await this.getGeneratorInstructions(contentType, generatorInstructions, filter);
-
-    console.log('fullInstructions:', fullInstructions);
-
-    return await this.rimoriClient.ai.getObject(fullInstructions);
-  }
-
-  private async getGeneratorInstructions(
-    contentType: string,
-    generatorInstructions: ObjectRequest,
-    filter?: SharedContentFilter,
-  ): Promise<ObjectRequest> {
-    const completedTopics = await this.getCompletedTopics(contentType, filter);
-
-    generatorInstructions.instructions += `
-    The following topics are already taken: ${completedTopics.join(', ')}`;
-
-    generatorInstructions.tool.title = {
-      type: 'string',
-      description: 'What the topic is about. Short. ',
-    };
-    generatorInstructions.tool.keywords = {
-      type: [{ text: { type: 'string' } }],
-      description: 'Keywords around the topic of the assignment.',
-    };
-    return generatorInstructions;
-  }
-
-  private async getCompletedTopics(contentType: string, filter?: SharedContentFilter): Promise<string[]> {
-    const query = this.supabase
-      .from('shared_content')
-      .select('title, keywords, scc:shared_content_completed(id)')
-      .eq('content_type', contentType)
-      .not('scc.id', 'is', null)
-      .is('deleted_at', null);
-
-    if (filter) {
-      query.contains('data', filter);
-    }
-
-    const { data: oldAssignments, error } = await query;
-
-    if (error) {
-      console.error('error fetching old assignments:', error);
-      return [];
-    }
-    return oldAssignments.map(({ title, keywords }) => `${title}(${keywords.join(',')})`);
-  }
-
-  public async getSharedContent<T>(contentType: string, id: string): Promise<SharedContent<T>> {
-    const { data, error } = await this.supabase
-      .from('shared_content')
-      .select()
-      .eq('content_type', contentType)
-      .eq('id', id)
-      .is('deleted_at', null)
-      .single();
-    if (error) {
-      console.error('error fetching shared content:', error);
-      throw new Error('error fetching shared content');
-    }
-    return data;
-  }
-
-  public async completeSharedContent(contentType: string, assignmentId: string) {
-    // Idempotent completion: upsert on (id, user_id) so repeated calls don't fail
-    const { error } = await this.supabase
-      .from('shared_content_completed')
-      .upsert({ content_type: contentType, id: assignmentId } as any, { onConflict: 'id' });
-
-    if (error) {
-      console.error('error completing shared content:', error);
-      throw new Error('error completing shared content');
-    }
-  }
-
-  /**
-   * Update state details for a shared content entry in shared_content_completed.
-   * Assumes table has columns: state ('completed'|'ongoing'|'hidden'), reaction ('liked'|'disliked'|null), bookmarked boolean.
-   * Upserts per (id, content_type, user).
-   * @param param
-   * @param param.contentType - The content type.
-   * @param param.id - The shared content id.
-   * @param param.state - The state to set.
-   * @param param.reaction - Optional reaction.
-   * @param param.bookmarked - Optional bookmark flag.
-   */
-  public async updateSharedContentState({
-    contentType,
-    id,
-    state,
-    reaction,
-    bookmarked,
-  }: {
-    contentType: string;
-    id: string;
-    state?: 'completed' | 'ongoing' | 'hidden';
-    reaction?: 'liked' | 'disliked' | null;
-    bookmarked?: boolean;
-  }): Promise<void> {
-    const payload: Record<string, unknown> = { content_type: contentType, id };
-    if (state !== undefined) payload.state = state;
-    if (reaction !== undefined) payload.reaction = reaction;
-    if (bookmarked !== undefined) payload.bookmarked = bookmarked;
-
-    // Prefer upsert, fall back to insert/update if upsert not allowed
-    const { error } = await this.supabase.from('shared_content_completed').upsert(payload as any, { onConflict: 'id' });
-
-    if (error) {
-      console.error('error updating shared content state:', error);
-      throw new Error('error updating shared content state');
-    }
-  }
-
-  /**
-   * Fetch shared content from the database based on optional filters.
-   * @param contentType - The type of content to fetch.
-   * @param filter - Optional filter to apply to the query.
-   * @param limit - Optional limit for the number of results.
-   * @returns Array of shared content matching the criteria.
-   */
-  public async getSharedContentList<T>(
-    contentType: string,
-    filter?: SharedContentFilter,
-    limit?: number,
-  ): Promise<SharedContent<T>[]> {
-    const query = this.supabase
-      .from('shared_content')
-      .select('*')
-      .eq('content_type', contentType)
-      .is('deleted_at', null)
-      .limit(limit ?? 30);
-
-    if (filter) {
-      query.contains('data', filter);
-    }
-
-    const { data, error } = await query;
-
-    if (error) {
-      console.error('error fetching shared content:', error);
-      throw new Error('error fetching shared content');
-    }
-
-    return data;
-  }
-
-  /**
-   * Insert new shared content into the database.
-   * @param param
-   * @param param.contentType - The type of content to insert.
-   * @param param.title - The title of the content.
-   * @param param.keywords - Keywords associated with the content.
-   * @param param.data - The content data to store.
-   * @param param.privateTopic - Optional flag to indicate if the topic should be private.
-   * @returns The inserted shared content.
-   * @throws {Error} if insertion fails.
-   */
-  public async createSharedContent<T>({
-    contentType,
-    title,
-    keywords,
-    data,
-    privateTopic,
-  }: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>> {
-    const { data: newContent, error } = await this.supabase
-      .from('shared_content')
-      .insert({
-        private: privateTopic,
-        content_type: contentType,
-        title,
-        keywords,
-        data,
-      })
-      .select();
-
-    if (error) {
-      console.error('error inserting shared content:', error);
-      throw new Error('error inserting shared content');
-    }
-
-    return newContent[0];
-  }
-
-  /**
-   * Update existing shared content in the database.
-   * @param id - The ID of the content to update.
-   * @param updates - The updates to apply to the shared content.
-   * @returns The updated shared content.
-   * @throws {Error} if update fails.
-   */
-  public async updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<SharedContent<T>> {
-    const updateData: any = {};
-
-    if (updates.contentType) updateData.content_type = updates.contentType;
-    if (updates.title) updateData.title = updates.title;
-    if (updates.keywords) updateData.keywords = updates.keywords;
-    if (updates.data) updateData.data = updates.data;
-    if (updates.privateTopic !== undefined) updateData.private = updates.privateTopic;
-
-    const { data: updatedContent, error } = await this.supabase
-      .from('shared_content')
-      .update(updateData)
-      .eq('id', id)
-      .select();
-
-    if (error) {
-      console.error('error updating shared content:', error);
-      throw new Error('error updating shared content');
-    }
-
-    if (!updatedContent || updatedContent.length === 0) {
-      throw new Error('shared content not found');
-    }
-
-    return updatedContent[0];
-  }
-
-  /**
-   * Soft delete shared content by setting the deleted_at timestamp.
-   * @param id - The ID of the content to delete.
-   * @returns The deleted shared content record.
-   * @throws {Error} if deletion fails or content not found.
-   */
-  public async removeSharedContent(id: string): Promise<SharedContent<any>> {
-    const { data: deletedContent, error } = await this.supabase
-      .from('shared_content')
-      .update({ deleted_at: new Date().toISOString() })
-      .eq('id', id)
-      .select();
-
-    if (error) {
-      console.error('error deleting shared content:', error);
-      throw new Error('error deleting shared content');
-    }
-
-    if (!deletedContent || deletedContent.length === 0) {
-      throw new Error('shared content not found or already deleted');
-    }
-
-    return deletedContent[0];
-  }
-}
-
-/**
- * Interface representing shared content in the system.
- * @template T The type of data stored in the content
- */
-export interface SharedContent<T> {
-  /** The id of the content */
-  id: string;
-
-  /** The type/category of the content (e.g. 'grammar_exercises', 'flashcards', etc.) */
-  contentType: string;
-
-  /** The human readable title of the content */
-  title: string;
-
-  /** Array of keywords/tags associated with the content for search and categorization */
-  keywords: string[];
-
-  /** The actual content data of type T */
-  data: T;
-
-  /** Whether this content should only be visible to the creator. Defaults to false if not specified */
-  privateTopic?: boolean;
-}

package/src/controller/TranslationController.ts

@@ -1,136 +0,0 @@
-import { createInstance, ThirdPartyModule, TOptions, i18n as i18nType } from 'i18next';
-
-type InitializationState = 'not-inited' | 'initing' | 'finished';
-
-/**
- * Translator class for handling internationalization
- */
-export class Translator {
-  private currentLanguage: string;
-  private initializationState: InitializationState;
-  private initializationPromise: Promise<void> | null;
-  private i18n: i18nType | undefined;
-  private translationUrl: string;
-
-  constructor(initialLanguage: string, translationUrl: string) {
-    this.currentLanguage = initialLanguage;
-    this.initializationState = 'not-inited';
-    this.initializationPromise = null;
-    this.translationUrl = translationUrl;
-  }
-
-  /**
-   * Initialize translator with user's language
-   * @param userLanguage - Language code from user info
-   */
-  async initialize(): Promise<void> {
-    // If already finished, return immediately
-    if (this.initializationState === 'finished') {
-      return;
-    }
-
-    // If currently initializing, wait for the existing initialization to complete
-    if (this.initializationState === 'initing' && this.initializationPromise) {
-      return this.initializationPromise;
-    }
-
-    // Start initialization
-    this.initializationState = 'initing';
-
-    // Create a promise that will be resolved when initialization completes
-    this.initializationPromise = (async (): Promise<void> => {
-      try {
-        const translations = await this.fetchTranslations(this.currentLanguage);
-
-        const instance = createInstance({
-          lng: this.currentLanguage,
-          resources: {
-            [this.currentLanguage]: {
-              translation: translations,
-            },
-          },
-          debug: window.location.hostname === 'localhost',
-        });
-
-        await instance.init();
-        this.i18n = instance;
-        this.initializationState = 'finished';
-      } catch (error) {
-        // Reset state on error so it can be retried
-        this.initializationState = 'not-inited';
-        this.initializationPromise = null;
-        throw error;
-      }
-    })();
-
-    return this.initializationPromise;
-  }
-
-  private getTranslationUrl(language: string): string {
-    // For localhost development, use local- prefix for non-English languages
-    if (window.location.hostname === 'localhost') {
-      const filename = language !== 'en' ? `local-${language}` : language;
-
-      return `${window.location.origin}/locales/${filename}.json`;
-    }
-
-    return `${this.translationUrl}/locales/${language}.json`;
-  }
-
-  public usePlugin(plugin: ThirdPartyModule): void {
-    if (!this.i18n) {
-      throw new Error('Translator is not initialized');
-    }
-    this.i18n.use(plugin);
-  }
-  /**
-   * Fetch translations manually from the current domain
-   * @param language - Language code to fetch
-   * @returns Promise with translation data
-   */
-  private async fetchTranslations(language: string): Promise<Record<string, string>> {
-    try {
-      const response = await fetch(this.getTranslationUrl(language));
-      if (!response.ok) {
-        throw new Error(`Failed to fetch translations for ${language}`);
-      }
-      return (await response.json()) as Record<string, string>;
-    } catch (error) {
-      console.warn(`Failed to fetch translations for ${language}:`, error);
-      if (language === 'en') return {};
-
-      // Fallback to English
-      return this.fetchTranslations('en').catch((error) => {
-        console.error('Failed to fetch fallback translations:', error);
-        return {};
-      });
-    }
-  }
-
-  /**
-   * Get translation for a key
-   * @param key - Translation key
-   * @param options - Translation options
-   * @returns Translated string
-   */
-  t(key: string, options?: TOptions): string {
-    if (!this.i18n) {
-      throw new Error('Translator is not initialized');
-    }
-    return this.i18n.t(key, options) as string;
-  }
-
-  /**
-   * Get current language
-   */
-  getCurrentLanguage(): string {
-    return this.currentLanguage;
-  }
-
-  /**
-   * Check if translator is initialized
-   */
-  isReady(): boolean {
-    return this.initializationState === 'finished';
-  }
-}