chishiki-sqlite 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Seo Jong Hak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# SQLite Package
+
+This package provides SQLite with OPFS (Origin Private File System) support for the Chrome extension.
+
+## Features
+
+- SQLite database with OPFS persistence
+- Worker-based implementation for OPFS VFS
+- React hooks for easy integration
+- Client API for database operations
+
+## Usage
+
+### In a React Component
+
+```tsx
+import { useSqliteOpfs } from '@extension/sqlite';
+
+const MyComponent = () => {
+  const {
+    isReady,
+    db,
+    exec,
+    openDatabase,
+    closeDatabase,
+  } = useSqliteOpfs();
+
+  const handleQuery = async () => {
+    const result = await exec('SELECT * FROM table;');
+    console.log(result);
+  };
+
+  return (
+    <div>
+      {isReady && <button onClick={handleQuery}>Run Query</button>}
+    </div>
+  );
+};
+```
+
+### Direct Client Usage
+
+```tsx
+import { SqliteWorkerClient } from '@extension/sqlite';
+
+const client = new SqliteWorkerClient();
+await client.init();
+await client.open('mydb.sqlite3');
+const result = await client.exec('SELECT * FROM table;');
+await client.close();
+```
+
+## Requirements
+
+- OPFS support (Chrome 109+, Edge 109+)
+- Background service worker (for worker context)
+- Storage permissions in manifest
+
+## API
+
+### useSqliteOpfs()
+
+React hook for SQLite operations.
+
+**Returns:**
+- `isReady`: boolean - WASM initialized
+- `db`: boolean - Database is open
+- `dbFilename`: string - Current database filename
+- `opfsFiles`: Array - List of OPFS files
+- `opfsSupported`: boolean - OPFS available
+- `persistent`: boolean - Using persistent storage
+- `storage`: 'opfs' | 'jsstorage' | 'memory' - Storage type
+- `openDatabase()`: Function - Open database
+- `closeDatabase()`: Function - Close database
+- `exec()`: Function - Execute SQL
+- `runSampleSchema()`: Function - Seed sample data
+- `listOpfsFiles()`: Function - List OPFS files
+- `deleteOpfsFile()`: Function - Delete file
+
+### SqliteWorkerClient
+
+Direct client for SQLite operations.
+
+**Methods:**
+- `init()`: Initialize SQLite
+- `open(filename)`: Open database
+- `close()`: Close database
+- `exec(sql)`: Execute SQL
+- `seed()`: Seed sample schema
+- `flush()`: Flush to disk
+- `listOpfs()`: List OPFS files
+- `deleteOpfs(filename)`: Delete file
+- `dispose()`: Cleanup
+

package/dist/index.mjs

@@ -0,0 +1 @@
+export * from './lib/index.js';

package/dist/lib/activities.js

@@ -0,0 +1,210 @@
+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 activities table
+ */
+const initializeActivitiesTable = async () => {
+    const db = getDb();
+    if (!db)
+        return;
+    const tableExists = await db.introspection
+        .getTables()
+        .then((tables) => tables.some((table) => table.name === 'activities'));
+    if (!tableExists) {
+        await db.schema
+            .createTable('activities')
+            .ifNotExists()
+            .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+            .addColumn('activity_iri', 'text', col => col.notNull().unique())
+            .addColumn('name', 'text', col => col.notNull())
+            .addColumn('description', 'text')
+            .addColumn('activity_type', 'text', col => col.notNull())
+            .addColumn('content_id', 'integer')
+            .addColumn('created_at', 'text', col => col.notNull())
+            .execute();
+        // Create indexes
+        await db.schema.createIndex('idx_activities_iri').ifNotExists().on('activities').column('activity_iri').execute();
+        await db.schema.createIndex('idx_activities_content').ifNotExists().on('activities').column('content_id').execute();
+        await db.schema.createIndex('idx_activities_type').ifNotExists().on('activities').column('activity_type').execute();
+    }
+};
+/**
+ * Generate a unique activity IRI
+ */
+const generateActivityIri = (type, id) => {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    const suffix = id || `${timestamp}-${random}`;
+    return `https://chishiki.app/activities/${type}/${suffix}`;
+};
+/**
+ * Create a new activity
+ */
+const createActivity = async (activity) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const now = new Date().toISOString();
+    const iri = activity.activity_iri || generateActivityIri(activity.activity_type);
+    const insertValues = {
+        activity_iri: iri,
+        name: activity.name,
+        description: activity.description ?? null,
+        activity_type: activity.activity_type,
+        content_id: activity.content_id ?? null,
+        created_at: now,
+    };
+    const result = await db.insertInto('activities').values(insertValues).returningAll().executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Get activity by ID
+ */
+const getActivityById = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('activities').selectAll().where('id', '=', id).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get activity by IRI
+ */
+const getActivityByIri = async (iri) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('activities').selectAll().where('activity_iri', '=', iri).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get or create an activity by IRI
+ */
+const getOrCreateActivity = async (activity) => {
+    const existing = await getActivityByIri(activity.activity_iri);
+    if (existing) {
+        return existing;
+    }
+    return createActivity(activity);
+};
+/**
+ * Get activities for a content item
+ */
+const getActivitiesByContentId = async (contentId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('activities')
+        .selectAll()
+        .where('content_id', '=', contentId)
+        .orderBy('created_at', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get activities by type
+ */
+const getActivitiesByType = async (activityType) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('activities')
+        .selectAll()
+        .where('activity_type', '=', activityType)
+        .orderBy('created_at', 'desc')
+        .execute();
+    return results;
+};
+/**
+ * Get all activities with pagination
+ */
+const getActivities = async (page = 1, limit = 20) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db
+        .selectFrom('activities')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .offset((page - 1) * limit)
+        .limit(limit)
+        .execute();
+    return results;
+};
+/**
+ * Get activity count
+ */
+const getActivityCount = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return 0;
+    const result = await db.selectFrom('activities').select(db.fn.count('id').as('count')).executeTakeFirst();
+    return result?.count || 0;
+};
+/**
+ * Update an activity
+ */
+const updateActivity = async (id, updates) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    const updateValues = {};
+    if (updates.name !== undefined)
+        updateValues.name = updates.name;
+    if (updates.description !== undefined)
+        updateValues.description = updates.description;
+    if (Object.keys(updateValues).length > 0) {
+        await db.updateTable('activities').set(updateValues).where('id', '=', id).execute();
+    }
+};
+/**
+ * Delete an activity
+ */
+const deleteActivity = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('activities').where('id', '=', id).execute();
+};
+/**
+ * Delete activities by content ID
+ */
+const deleteActivitiesByContentId = async (contentId) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('activities').where('content_id', '=', contentId).execute();
+};
+/**
+ * Reset the activities table
+ */
+const resetActivitiesTable = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.schema.dropTable('activities').ifExists().execute();
+    await initializeActivitiesTable();
+};
+export { initializeActivitiesTable, generateActivityIri, createActivity, getActivityById, getActivityByIri, getOrCreateActivity, getActivitiesByContentId, getActivitiesByType, getActivities, getActivityCount, updateActivity, deleteActivity, deleteActivitiesByContentId, resetActivitiesTable, };

package/dist/lib/actors.js

@@ -0,0 +1,147 @@
+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 actors table
+ */
+const initializeActorsTable = async () => {
+    const db = getDb();
+    if (!db)
+        return;
+    const tableExists = await db.introspection
+        .getTables()
+        .then((tables) => tables.some((table) => table.name === 'actors'));
+    if (!tableExists) {
+        await db.schema
+            .createTable('actors')
+            .ifNotExists()
+            .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+            .addColumn('mbox', 'text', col => col.notNull().unique())
+            .addColumn('name', 'text', col => col.notNull())
+            .addColumn('created_at', 'text', col => col.notNull())
+            .execute();
+        // Create index on mbox for faster lookups
+        await db.schema.createIndex('idx_actors_mbox').ifNotExists().on('actors').column('mbox').execute();
+    }
+};
+/**
+ * Get or create the default local actor
+ */
+const getOrCreateDefaultActor = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const defaultMbox = 'mailto:local@chishiki.app';
+    const defaultName = 'Local User';
+    // Try to find existing default actor
+    const existing = await db.selectFrom('actors').selectAll().where('mbox', '=', defaultMbox).executeTakeFirst();
+    if (existing) {
+        return existing;
+    }
+    // Create default actor
+    const now = new Date().toISOString();
+    const result = await db
+        .insertInto('actors')
+        .values({
+        mbox: defaultMbox,
+        name: defaultName,
+        created_at: now,
+    })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Get actor by ID
+ */
+const getActorById = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('actors').selectAll().where('id', '=', id).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Get actor by mbox (email identifier)
+ */
+const getActorByMbox = async (mbox) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return null;
+    const result = await db.selectFrom('actors').selectAll().where('mbox', '=', mbox).executeTakeFirst();
+    return result || null;
+};
+/**
+ * Create a new actor
+ */
+const createActor = async (actor) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const now = new Date().toISOString();
+    const result = await db
+        .insertInto('actors')
+        .values({
+        ...actor,
+        created_at: now,
+    })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    return result;
+};
+/**
+ * Update an actor's name
+ */
+const updateActorName = async (id, name) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.updateTable('actors').set({ name }).where('id', '=', id).execute();
+};
+/**
+ * Get all actors
+ */
+const getAllActors = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return [];
+    const results = await db.selectFrom('actors').selectAll().orderBy('created_at', 'desc').execute();
+    return results;
+};
+/**
+ * Delete an actor (use with caution - will orphan statements)
+ */
+const deleteActor = async (id) => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.deleteFrom('actors').where('id', '=', id).execute();
+};
+/**
+ * Reset the actors table (for development/testing)
+ */
+const resetActorsTable = async () => {
+    await ensureDatabaseInitialized();
+    const db = getDb();
+    if (!db)
+        return;
+    await db.schema.dropTable('actors').ifExists().execute();
+    await initializeActorsTable();
+};
+export { initializeActorsTable, getOrCreateDefaultActor, getActorById, getActorByMbox, createActor, updateActorName, getAllActors, deleteActor, resetActorsTable, };

package/dist/lib/database-manager.js

@@ -0,0 +1,70 @@
+// Database Manager - Singleton for centralized database initialization and management
+import { initializeActivitiesTable } from './activities.js';
+import { initializeActorsTable } from './actors.js';
+import { initializeGeneratedActivitiesTable } from './generated-activities.js';
+import { initializeLearningContentTable } from './learning-content.js';
+import { ManualSqliteClient } from './manual.js';
+import { initializeStatementsTable } from './statements.js';
+export class DatabaseManager {
+    static instance = null;
+    initializationPromise = null;
+    isInitialized = false;
+    constructor() { }
+    static getInstance() {
+        if (!DatabaseManager.instance) {
+            DatabaseManager.instance = new DatabaseManager();
+        }
+        return DatabaseManager.instance;
+    }
+    /**
+     * Ensures the database is initialized. Returns a promise that resolves when initialization is complete.
+     * This method is idempotent - multiple calls will return the same promise.
+     */
+    async ensureInitialized() {
+        if (this.isInitialized) {
+            return;
+        }
+        if (!this.initializationPromise) {
+            this.initializationPromise = this.initialize();
+        }
+        await this.initializationPromise;
+        this.isInitialized = true;
+    }
+    /**
+     * Performs the actual database initialization
+     */
+    async initialize() {
+        try {
+            console.log('Initializing database...');
+            // Initialize all LRS database tables in parallel
+            await Promise.all([
+                initializeActorsTable(),
+                initializeLearningContentTable(),
+                initializeActivitiesTable(),
+                initializeStatementsTable(),
+                initializeGeneratedActivitiesTable(),
+            ]);
+            console.log('Database initialization completed');
+        }
+        catch (error) {
+            console.error('Database initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Resets the initialization state (useful for testing or reinitialization)
+     */
+    reset() {
+        this.isInitialized = false;
+        this.initializationPromise = null;
+        ManualSqliteClient.resetInstance();
+    }
+    /**
+     * Checks if the database is currently initialized
+     */
+    get initialized() {
+        return this.isInitialized;
+    }
+}
+// Export a convenience function for easy access
+export const getDatabaseManager = () => DatabaseManager.getInstance();

package/dist/lib/database-reset.js

@@ -0,0 +1,29 @@
+import { resetActivitiesTable } from './activities.js';
+import { resetActorsTable } from './actors.js';
+import { getDatabaseManager } from './database-manager.js';
+import { resetGeneratedActivitiesTable } from './generated-activities.js';
+import { resetLearningContentTable } from './learning-content.js';
+import { resetStatementsTable } from './statements.js';
+/**
+ * Completely resets the entire database by dropping and recreating all tables
+ * This will delete ALL data in the database
+ */
+export const resetEntireDatabase = async () => {
+    console.log('Resetting entire database...');
+    try {
+        // Reset all LRS tables in order (statements first due to foreign keys)
+        await resetStatementsTable();
+        await resetGeneratedActivitiesTable();
+        await resetActivitiesTable();
+        await resetLearningContentTable();
+        await resetActorsTable();
+        // Reset the database manager singleton state
+        const dbManager = getDatabaseManager();
+        dbManager.reset();
+        console.log('Database reset completed successfully');
+    }
+    catch (error) {
+        console.error('Error resetting database:', error);
+        throw error;
+    }
+};