@rimori/client 2.5.5 → 2.5.6-next.0

package/dist/plugin/module/SharedContentController.js

@@ -0,0 +1,310 @@
+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());
+    });
+};
+export class SharedContentController {
+    constructor(supabase, rimoriClient) {
+        this.supabase = supabase;
+        this.rimoriClient = rimoriClient;
+    }
+    /**
+     * Get new shared content. First searches for existing content matching filters that hasn't been completed,
+     * then falls back to AI generation if nothing suitable is found.
+     * @param params - Parameters object
+     * @param params.table - Name of the shared content table (without plugin prefix)
+     * @param params.skillType - Type of skill this content is for (grammar, reading, writing, speaking, listening, understanding)
+     * @param params.placeholders - Placeholders for instructions template for AI generation (e.g., {topicAreas: "history"})
+     * @param params.filter - Filter to find existing content:
+     *   - `exact`: Match field value exactly (e.g., {topic_category: {filterType: "exact", value: "history"}})
+     *   - `exclude`: Exclude specific field value (e.g., {difficulty: {filterType: "exclude", value: "hard"}})
+     *   - `rag`: Use semantic similarity search (e.g., {topic: {filterType: "rag", value: "japanese culture"}})
+     * @param params.customFields - Custom field values for AI-generated content (e.g., {topic_category: "history"})
+     * @param params.skipDbSave - If true, don't save generated content to database
+     * @param params.isPrivate - If true, content is guild-specific
+     * @returns Existing or newly generated shared content item
+     */
+    getNew(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Generate new content via backend endpoint
+            const response = yield this.rimoriClient.runtime.fetchBackend('/shared-content/generate', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    tableName: params.table,
+                    skillType: params.skillType,
+                    placeholders: params.placeholders,
+                    filter: params.filter,
+                    customFields: params.customFields,
+                    tool: params.tool,
+                    options: {
+                        skipDbSave: params.skipDbSave,
+                        isPrivate: params.isPrivate,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to generate shared content: ${response.statusText}`);
+            }
+            return yield response.json();
+        });
+    }
+    /**
+     * Search for shared content by topic using RAG (semantic similarity).
+     * @param tableName - Name of the shared content table
+     * @param topic - Topic to search for
+     * @param limit - Maximum number of results
+     * @returns Array of similar shared content
+     */
+    searchByTopic(tableName_1, topic_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, topic, limit = 10) {
+            const fullTableName = this.getTableName(tableName);
+            const completedTableName = this.getCompletedTableName(tableName);
+            // Generate embedding for search topic
+            const response = yield this.rimoriClient.runtime.fetchBackend('/ai/embedding', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ text: topic }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to generate embedding: ${response.statusText}`);
+            }
+            const { embedding } = yield response.json();
+            // RPC call for vector similarity search with completion filtering
+            const { data, error } = yield this.supabase.rpc('search_shared_content', {
+                p_table_name: fullTableName,
+                p_completed_table_name: completedTableName,
+                p_embedding: JSON.stringify(embedding),
+                p_limit: limit,
+            });
+            if (error) {
+                console.error('Error searching shared content:', error);
+                throw new Error('Error searching shared content');
+            }
+            return data || [];
+        });
+    }
+    /**
+     * Get bookmarked shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of bookmarked content
+     */
+    getBookmarked(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, limit = 30) {
+            const fullTableName = this.getTableName(tableName);
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { data, error } = yield this.supabase
+                .from(fullTableName)
+                .select(`*, completed:${completedTableName}!inner(*)`)
+                .eq(`completed.bookmarked`, true)
+                .limit(limit);
+            if (error) {
+                console.error('Error fetching bookmarked content:', error);
+                throw new Error('Error fetching bookmarked content');
+            }
+            return (data || []);
+        });
+    }
+    /**
+     * Get ongoing shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of ongoing content
+     */
+    getOngoing(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, limit = 30) {
+            const fullTableName = this.getTableName(tableName);
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { data, error } = yield this.supabase
+                .from(fullTableName)
+                .select(`*, completed:${completedTableName}!inner(*)`)
+                .eq(`completed.state`, 'ongoing')
+                .limit(limit);
+            if (error) {
+                console.error('Error fetching ongoing content:', error);
+                throw new Error('Error fetching ongoing content');
+            }
+            return (data || []);
+        });
+    }
+    /**
+     * Get completed shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of completed content
+     */
+    getCompleted(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, limit = 30) {
+            const fullTableName = this.getTableName(tableName);
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { data, error } = yield this.supabase
+                .from(fullTableName)
+                .select(`*, completed:${completedTableName}!inner(*)`)
+                .eq(`completed.state`, 'completed')
+                .limit(limit);
+            if (error) {
+                console.error('Error fetching completed content:', error);
+                throw new Error('Error fetching completed content');
+            }
+            return (data || []);
+        });
+    }
+    /**
+     * Mark shared content as completed.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to mark as completed
+     */
+    complete(tableName, contentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { error } = yield this.supabase.from(completedTableName).upsert({
+                content_id: contentId,
+                state: 'completed',
+            }, { onConflict: 'content_id,user_id' });
+            if (error) {
+                console.error('Error completing shared content:', error);
+                throw new Error('Error completing shared content');
+            }
+        });
+    }
+    /**
+     * Update the state of shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param state - New state
+     */
+    updateState(tableName, contentId, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { error } = yield this.supabase.from(completedTableName).upsert({
+                content_id: contentId,
+                state,
+            }, { onConflict: 'content_id,user_id' });
+            if (error) {
+                console.error('Error updating content state:', error);
+                throw new Error('Error updating content state');
+            }
+        });
+    }
+    /**
+     * Bookmark or unbookmark shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param bookmarked - Whether to bookmark or unbookmark
+     */
+    bookmark(tableName, contentId, bookmarked) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { error } = yield this.supabase.from(completedTableName).upsert({
+                content_id: contentId,
+                bookmarked,
+            }, { onConflict: 'content_id,user_id' });
+            if (error) {
+                console.error('Error bookmarking content:', error);
+                throw new Error('Error bookmarking content');
+            }
+        });
+    }
+    /**
+     * React to shared content with like/dislike.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param reaction - Reaction type or null to remove reaction
+     */
+    react(tableName, contentId, reaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTableName = this.getCompletedTableName(tableName);
+            const { error } = yield this.supabase.from(completedTableName).upsert({
+                content_id: contentId,
+                reaction,
+            }, { onConflict: 'content_id,user_id' });
+            if (error) {
+                console.error('Error reacting to content:', error);
+                throw new Error('Error reacting to content');
+            }
+        });
+    }
+    /**
+     * Get a specific shared content item by ID.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @returns The shared content item
+     */
+    get(tableName, contentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullTableName = this.getTableName(tableName);
+            const { data, error } = yield this.supabase.from(fullTableName).select('*').eq('id', contentId).single();
+            if (error) {
+                console.error('Error fetching shared content:', error);
+                throw new Error('Error fetching shared content');
+            }
+            return data;
+        });
+    }
+    /**
+     * Create new shared content manually.
+     * @param tableName - Name of the shared content table
+     * @param content - Content to create
+     * @returns Created content
+     */
+    create(tableName, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullTableName = this.getTableName(tableName);
+            const { data, error } = yield this.supabase.from(fullTableName).insert(content).select().single();
+            if (error) {
+                console.error('Error creating shared content:', error);
+                throw new Error('Error creating shared content');
+            }
+            return data;
+        });
+    }
+    /**
+     * Update existing shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to update
+     * @param updates - Updates to apply
+     * @returns Updated content
+     */
+    update(tableName, contentId, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullTableName = this.getTableName(tableName);
+            const { data, error } = yield this.supabase
+                .from(fullTableName)
+                .update(updates)
+                .eq('id', contentId)
+                .select()
+                .single();
+            if (error) {
+                console.error('Error updating shared content:', error);
+                throw new Error('Error updating shared content');
+            }
+            return data;
+        });
+    }
+    /**
+     * Delete shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to delete
+     */
+    remove(tableName, contentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullTableName = this.getTableName(tableName);
+            const { error } = yield this.supabase.from(fullTableName).delete().eq('id', contentId);
+            if (error) {
+                console.error('Error deleting shared content:', error);
+                throw new Error('Error deleting shared content');
+            }
+        });
+    }
+    getCompletedTableName(tableName) {
+        return this.getTableName(tableName) + '_completed';
+    }
+    getTableName(tableName) {
+        return `${this.rimoriClient.plugin.pluginId}_sc_${tableName}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.5",
+  "version": "2.5.6-next.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {

package/dist/controller/SharedContentController.d.ts

@@ -1,106 +0,0 @@
-import { SupabaseClient } from '../plugin/CommunicationHandler';
-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 declare class SharedContentController {
-    private supabase;
-    private rimoriClient;
-    constructor(supabase: SupabaseClient, 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.
-     */
-    getNewSharedContent<T>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, options?: {
-        privateTopic?: boolean;
-        skipDbSave?: boolean;
-        alwaysGenerateNew?: boolean;
-        excludeIds?: string[];
-    }): Promise<SharedContent<T>>;
-    private generateNewAssignment;
-    private getGeneratorInstructions;
-    private getCompletedTopics;
-    getSharedContent<T>(contentType: string, id: string): Promise<SharedContent<T>>;
-    completeSharedContent(contentType: string, assignmentId: string): Promise<void>;
-    /**
-     * 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.
-     */
-    updateSharedContentState({ contentType, id, state, reaction, bookmarked, }: {
-        contentType: string;
-        id: string;
-        state?: 'completed' | 'ongoing' | 'hidden';
-        reaction?: 'liked' | 'disliked' | null;
-        bookmarked?: boolean;
-    }): Promise<void>;
-    /**
-     * 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.
-     */
-    getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<SharedContent<T>[]>;
-    /**
-     * 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.
-     */
-    createSharedContent<T>({ contentType, title, keywords, data, privateTopic, }: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>>;
-    /**
-     * 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.
-     */
-    updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<SharedContent<T>>;
-    /**
-     * 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.
-     */
-    removeSharedContent(id: string): Promise<SharedContent<any>>;
-}
-/**
- * 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;
-}