chishiki-sqlite 0.8.0

package/dist/lib/generated-activities.js

@@ -0,0 +1,240 @@
+import { getDatabaseManager } from './database-manager.js';
+import { ManualSqliteClient } from './manual.js';
+const getDb = () => {
+    const client = ManualSqliteClient.getInstance();
+    return client.getDb();
+};
+const ensureDatabaseInitialized = async () => {
+    const dbManager = getDatabaseManager();
+    await dbManager.ensureInitialized();
+};
+/**
+ * Initialize the generated_activities table
+ */
+const initializeGeneratedActivitiesTable = async () => {
+    const db = getDb();
+    if (!db)
+        return;
+    const tableExists = await db.introspection
+        .getTables()
+        .then((tables) => tables.some((table) => table.name === 'generated_activities'));
+    if (!tableExists) {
+        await db.schema
+            .createTable('generated_activities')
+            .ifNotExists()
+            .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+            .addColumn('content_id', 'integer', col => col.notNull())
+            .addColumn('activity_type', 'text', col => col.notNull())
+            .addColumn('activity_data', 'text', col => col.notNull())
+            .addColumn('generation_prompt', 'text')
+            .addColumn('created_at', 'text', col => col.notNull())
+            .execute();
+        // Create indexes
+        await db.schema
+            .createIndex('idx_generated_activities_content')
+            .ifNotExists()
+            .on('generated_activities')
+            .column('content_id')
+            .execute();
+        await db.schema
+            .createIndex('idx_generated_activities_type')
+            .ifNotExists()
+            .on('generated_activities')
+            .column('activity_type')
+            .execute();
+    }
+};
+/**
+ * Store a generated activity (flashcards, quiz, etc.)
+ */
+const storeGeneratedActivity = async (activity) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const now = new Date().toISOString();
+    const insertValues = {
+        content_id: activity.content_id,
+        activity_type: activity.activity_type,
+        activity_data: JSON.stringify(activity.activity_data),
+        generation_prompt: activity.generation_prompt ?? null,
+        created_at: now,
+    };
+    const result = await db
+        .insertInto('generated_activities')
+        .values(insertValues)
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Get generated activity by ID
+ */
+const getGeneratedActivityById = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('generated_activities').selectAll().where('id', '=', id).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get generated activities for a content item
+ */
+const getGeneratedActivitiesByContentId = async (contentId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('generated_activities')
+        .selectAll()
+        .where('content_id', '=', contentId)
+        .orderBy('created_at', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get generated activities by type
+ */
+const getGeneratedActivitiesByType = async (activityType) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('generated_activities')
+        .selectAll()
+        .where('activity_type', '=', activityType)
+        .orderBy('created_at', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get generated activities for content with specific type
+ */
+const getGeneratedActivityByContentAndType = async (contentId, activityType) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db
+        .selectFrom('generated_activities')
+        .selectAll()
+        .where('content_id', '=', contentId)
+        .where('activity_type', '=', activityType)
+        .orderBy('created_at', 'desc')
+        .executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get all generated activities with pagination
+ */
+const getGeneratedActivities = async (page = 1, limit = 20, filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    let query = db.selectFrom('generated_activities').selectAll().orderBy('created_at', 'desc');
+    if (filters?.activity_type) {
+        query = query.where('activity_type', '=', filters.activity_type);
+    }
+    const results = await query
+        .offset((page - 1) * limit)
+        .limit(limit)
+        .execute();
+    return results;
+};
+/**
+ * Get count of generated activities
+ */
+const getGeneratedActivityCount = async (filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return 0;
+    let query = db.selectFrom('generated_activities').select(db.fn.count('id').as('count'));
+    if (filters?.activity_type) {
+        query = query.where('activity_type', '=', filters.activity_type);
+    }
+    const result = await query.executeTakeFirst();
+    return result?.count || 0;
+};
+/**
+ * Update generated activity data
+ */
+const updateGeneratedActivityData = async (id, activityData) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db
+        .updateTable('generated_activities')
+        .set({ activity_data: JSON.stringify(activityData) })
+        .where('id', '=', id)
+        .execute();
+};
+/**
+ * Delete a generated activity
+ */
+const deleteGeneratedActivity = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('generated_activities').where('id', '=', id).execute();
+};
+/**
+ * Delete generated activities by content ID
+ */
+const deleteGeneratedActivitiesByContentId = async (contentId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('generated_activities').where('content_id', '=', contentId).execute();
+};
+/**
+ * Reset the generated activities table
+ */
+const resetGeneratedActivitiesTable = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.schema.dropTable('generated_activities').ifExists().execute();
+    await initializeGeneratedActivitiesTable();
+};
+/**
+ * Parse activity data from JSON string
+ */
+const parseActivityData = (jsonString) => JSON.parse(jsonString);
+/**
+ * Get flashcard activity data
+ */
+const getFlashcardData = async (id) => {
+    const activity = await getGeneratedActivityById(id);
+    if (!activity || activity.activity_type !== 'flashcard')
+        return null;
+    return parseActivityData(activity.activity_data);
+};
+/**
+ * Get multiple choice activity data
+ */
+const getMultipleChoiceData = async (id) => {
+    const activity = await getGeneratedActivityById(id);
+    if (!activity || activity.activity_type !== 'multiple_choice')
+        return null;
+    return parseActivityData(activity.activity_data);
+};
+/**
+ * Get fill-in-the-blank activity data
+ */
+const getFillBlankData = async (id) => {
+    const activity = await getGeneratedActivityById(id);
+    if (!activity || activity.activity_type !== 'fill_blank')
+        return null;
+    return parseActivityData(activity.activity_data);
+};
+export { initializeGeneratedActivitiesTable, storeGeneratedActivity, getGeneratedActivityById, getGeneratedActivitiesByContentId, getGeneratedActivitiesByType, getGeneratedActivityByContentAndType, getGeneratedActivities, getGeneratedActivityCount, updateGeneratedActivityData, deleteGeneratedActivity, deleteGeneratedActivitiesByContentId, resetGeneratedActivitiesTable, parseActivityData, getFlashcardData, getMultipleChoiceData, getFillBlankData, };

package/dist/lib/index.js

@@ -0,0 +1,13 @@
+export * from './manual.js';
+export * from './database-reset.js';
+export * from './database-manager.js';
+// xAPI LRS exports
+export * from './actors.js';
+export * from './learning-content.js';
+export * from './activities.js';
+export * from './statements.js';
+export * from './generated-activities.js';
+// Content importers
+export * from './syllst-importer.js';
+// SYLLST content importer
+export * from './syllst-importer.js';

package/dist/lib/learning-content.js

@@ -0,0 +1,230 @@
+import { getDatabaseManager } from './database-manager.js';
+import { ManualSqliteClient } from './manual.js';
+const getDb = () => {
+    const client = ManualSqliteClient.getInstance();
+    return client.getDb();
+};
+const ensureDatabaseInitialized = async () => {
+    const dbManager = getDatabaseManager();
+    await dbManager.ensureInitialized();
+};
+/**
+ * Initialize the learning_content table
+ */
+const initializeLearningContentTable = async () => {
+    const db = getDb();
+    if (!db)
+        return;
+    const tableExists = await db.introspection
+        .getTables()
+        .then((tables) => tables.some((table) => table.name === 'learning_content'));
+    if (!tableExists) {
+        await db.schema
+            .createTable('learning_content')
+            .ifNotExists()
+            .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+            .addColumn('content_type', 'text', col => col.notNull())
+            .addColumn('raw_content', 'text', col => col.notNull())
+            .addColumn('metadata', 'text', col => col.notNull().defaultTo('{}'))
+            .addColumn('title', 'text', col => col.notNull())
+            .addColumn('source_url', 'text')
+            .addColumn('language', 'text')
+            .addColumn('created_at', 'text', col => col.notNull())
+            .addColumn('updated_at', 'text', col => col.notNull())
+            .execute();
+        // Create indexes
+        await db.schema
+            .createIndex('idx_learning_content_type')
+            .ifNotExists()
+            .on('learning_content')
+            .column('content_type')
+            .execute();
+        await db.schema
+            .createIndex('idx_learning_content_created')
+            .ifNotExists()
+            .on('learning_content')
+            .column('created_at')
+            .execute();
+        await db.schema
+            .createIndex('idx_learning_content_language')
+            .ifNotExists()
+            .on('learning_content')
+            .column('language')
+            .execute();
+    }
+};
+/**
+ * Add new learning content
+ */
+const addLearningContent = async (content) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const now = new Date().toISOString();
+    const insertValues = {
+        content_type: content.content_type,
+        raw_content: content.raw_content,
+        title: content.title,
+        metadata: JSON.stringify(content.metadata || {}),
+        source_url: content.source_url ?? null,
+        language: content.language ?? null,
+        created_at: now,
+        updated_at: now,
+    };
+    const result = await db.insertInto('learning_content').values(insertValues).returningAll().executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Get learning content by ID
+ */
+const getLearningContentById = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('learning_content').selectAll().where('id', '=', id).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get all learning content with pagination
+ */
+const getLearningContent = async (page = 1, limit = 20, filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    let query = db.selectFrom('learning_content').selectAll().orderBy('created_at', 'desc');
+    if (filters?.content_type) {
+        query = query.where('content_type', '=', filters.content_type);
+    }
+    if (filters?.language) {
+        query = query.where('language', '=', filters.language);
+    }
+    if (filters?.search) {
+        query = query.where(eb => eb.or([eb('title', 'like', `%${filters.search}%`), eb('raw_content', 'like', `%${filters.search}%`)]));
+    }
+    const results = await query
+        .offset((page - 1) * limit)
+        .limit(limit)
+        .execute();
+    return results;
+};
+/**
+ * Get total count of learning content
+ */
+const getLearningContentCount = async (filters) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return 0;
+    let query = db.selectFrom('learning_content').select(db.fn.count('id').as('count'));
+    if (filters?.content_type) {
+        query = query.where('content_type', '=', filters.content_type);
+    }
+    if (filters?.language) {
+        query = query.where('language', '=', filters.language);
+    }
+    if (filters?.search) {
+        query = query.where(eb => eb.or([eb('title', 'like', `%${filters.search}%`), eb('raw_content', 'like', `%${filters.search}%`)]));
+    }
+    const result = await query.executeTakeFirst();
+    return result?.count || 0;
+};
+/**
+ * Update learning content
+ */
+const updateLearningContent = async (id, updates) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    const now = new Date().toISOString();
+    const updateValues = { updated_at: now };
+    if (updates.title !== undefined)
+        updateValues.title = updates.title;
+    if (updates.raw_content !== undefined)
+        updateValues.raw_content = updates.raw_content;
+    if (updates.metadata !== undefined)
+        updateValues.metadata = JSON.stringify(updates.metadata);
+    if (updates.language !== undefined)
+        updateValues.language = updates.language;
+    await db.updateTable('learning_content').set(updateValues).where('id', '=', id).execute();
+};
+/**
+ * Delete learning content
+ */
+const deleteLearningContent = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('learning_content').where('id', '=', id).execute();
+};
+/**
+ * Delete multiple learning content items
+ */
+const deleteLearningContentItems = async (ids) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('learning_content').where('id', 'in', ids).execute();
+};
+/**
+ * Get recent learning content
+ */
+const getRecentLearningContent = async (days = 7) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+    const cutoffISO = cutoffDate.toISOString();
+    const results = await db
+        .selectFrom('learning_content')
+        .selectAll()
+        .where('created_at', '>=', cutoffISO)
+        .orderBy('created_at', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get learning content by source URL (useful for checking duplicates)
+ */
+const getLearningContentBySourceUrl = async (sourceUrl) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db
+        .selectFrom('learning_content')
+        .selectAll()
+        .where('source_url', '=', sourceUrl)
+        .executeTakeFirst();
+    return result || null;
+};
+/**
+ * Reset the learning content table
+ */
+const resetLearningContentTable = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.schema.dropTable('learning_content').ifExists().execute();
+    await initializeLearningContentTable();
+};
+/**
+ * Clear all learning content
+ */
+const clearAllLearningContent = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('learning_content').execute();
+};
+export { initializeLearningContentTable, addLearningContent, getLearningContentById, getLearningContent, getLearningContentCount, updateLearningContent, deleteLearningContent, deleteLearningContentItems, getRecentLearningContent, getLearningContentBySourceUrl, resetLearningContentTable, clearAllLearningContent, };

package/dist/lib/manual.js

@@ -0,0 +1,30 @@
+import { Kysely } from 'kysely';
+import { SQLocalKysely } from 'sqlocal/kysely';
+export class ManualSqliteClient {
+    static instance = null;
+    db = null;
+    filename;
+    constructor() {
+        this.filename = 'database.sqlite3';
+        this.initializeDatabase();
+    }
+    static getInstance() {
+        if (!ManualSqliteClient.instance) {
+            ManualSqliteClient.instance = new ManualSqliteClient();
+        }
+        return ManualSqliteClient.instance;
+    }
+    initializeDatabase() {
+        const { dialect } = new SQLocalKysely(this.filename);
+        this.db = new Kysely({ dialect });
+    }
+    getDb() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        return this.db;
+    }
+    static resetInstance() {
+        ManualSqliteClient.instance = null;
+    }
+}