@majikah/majik-message 0.3.6 → 0.3.8

package/dist/core/storage/contact-directory/groups/adapter-sql.js

@@ -0,0 +1,72 @@
+import { MAJIKAH_SQL_TABLES } from "../../sql-schema";
+export class SQLiteContactGroupAdapter {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(group) {
+        await this.db.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} 
+       (id, json, name, created_at, updated_at, is_system)
+       VALUES (?, ?, ?, ?, ?, ?)`, [
+            group.id,
+            JSON.stringify(group),
+            group.meta?.name ?? null,
+            group.meta?.createdAt ?? null,
+            group.meta?.updatedAt ?? null,
+            group.isSystem ? 1 : 0,
+        ]);
+    }
+    async getById(id) {
+        const row = await this.db.get(`SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} WHERE id = ?`, [id]);
+        return row ? JSON.parse(row.json) : null;
+    }
+    async list() {
+        const rows = await this.db.all(`SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS}`);
+        return rows.map((r) => JSON.parse(r.json));
+    }
+    async remove(id) {
+        const exists = await this.exists(id);
+        if (!exists)
+            return false;
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} WHERE id = ?`, [id]);
+        return true;
+    }
+    async clear() {
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS}`);
+    }
+    async count() {
+        const row = await this.db.get(`SELECT COUNT(*) as n FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS}`);
+        return row?.n ?? 0;
+    }
+    async exists(id) {
+        const row = await this.db.get(`SELECT 1 FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} WHERE id = ?`, [id]);
+        return !!row;
+    }
+    async bulkSave(groups) {
+        if (groups.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const g of groups) {
+                await tx.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} 
+           (id, json, name, created_at, updated_at, is_system)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+                    g.id,
+                    JSON.stringify(g),
+                    g.meta?.name ?? null,
+                    g.meta?.createdAt ?? null,
+                    g.meta?.updatedAt ?? null,
+                    g.isSystem ? 1 : 0,
+                ]);
+            }
+        });
+    }
+    async bulkRemove(ids) {
+        if (ids.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const id of ids) {
+                await tx.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} WHERE id = ?`, [id]);
+            }
+        });
+    }
+}

package/dist/core/storage/idb-adapter.d.ts

@@ -0,0 +1,21 @@
+import { MajikStorageAdapter } from "./storage-adapter";
+export declare class IDBGenericAdapter<T extends {
+    id: string;
+}> implements MajikStorageAdapter<T> {
+    private dbName;
+    private storeName;
+    private version;
+    constructor(dbName: string, storeName: string, version?: number);
+    private db;
+    private open;
+    private tx;
+    save(item: T): Promise<void>;
+    getById(id: string): Promise<T | null>;
+    list(): Promise<T[]>;
+    remove(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    bulkSave(items: T[]): Promise<void>;
+    bulkRemove(ids: string[]): Promise<void>;
+}

package/dist/core/storage/idb-adapter.js

@@ -0,0 +1,107 @@
+export class IDBGenericAdapter {
+    dbName;
+    storeName;
+    version;
+    constructor(dbName, storeName, version = 1) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+        this.version = version;
+    }
+    db = null;
+    async open() {
+        if (this.db)
+            return this.db;
+        return new Promise((resolve, reject) => {
+            const req = indexedDB.open(this.dbName, this.version);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                const stores = [this.storeName]; // or pass array if you want
+                for (const name of stores) {
+                    if (!db.objectStoreNames.contains(name)) {
+                        db.createObjectStore(name, { keyPath: "id" });
+                    }
+                }
+            };
+            req.onsuccess = () => {
+                this.db = req.result;
+                resolve(this.db);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async tx(mode, fn) {
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this.storeName, mode);
+            const store = tx.objectStore(this.storeName);
+            const req = fn(store);
+            if (req) {
+                req.onsuccess = () => resolve(req.result);
+                req.onerror = () => reject(req.error);
+                tx.onabort = () => reject(tx.error); // 👈 ADD THIS
+            }
+            else {
+                tx.oncomplete = () => resolve(undefined);
+                tx.onerror = () => reject(tx.error);
+                tx.onabort = () => reject(tx.error); // 👈 ADD THIS
+            }
+        });
+    }
+    async save(item) {
+        await this.tx("readwrite", (s) => s.put(item));
+    }
+    async getById(id) {
+        const result = await this.tx("readonly", (s) => s.get(id));
+        return result ?? null;
+    }
+    async list() {
+        return await this.tx("readonly", (s) => s.getAll());
+    }
+    async remove(id) {
+        const exists = await this.exists(id);
+        if (!exists)
+            return false;
+        await this.tx("readwrite", (s) => s.delete(id));
+        return true;
+    }
+    async clear() {
+        await this.tx("readwrite", (s) => s.clear());
+    }
+    async count() {
+        return await this.tx("readonly", (s) => s.count());
+    }
+    async exists(id) {
+        const key = await this.tx("readonly", (s) => s.getKey(id));
+        return key != null;
+    }
+    async bulkSave(items) {
+        if (items.length === 0)
+            return;
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this.storeName, "readwrite");
+            const store = tx.objectStore(this.storeName);
+            for (const item of items) {
+                store.put(item);
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error);
+        });
+    }
+    async bulkRemove(ids) {
+        if (ids.length === 0)
+            return;
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this.storeName, "readwrite");
+            const store = tx.objectStore(this.storeName);
+            for (const id of ids) {
+                store.delete(id);
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error);
+        });
+    }
+}

package/dist/core/storage/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./sql-schema";
+export * from "./sql-db-manager";
+export * from "./storage-adapter";
+export * from "./idb-adapter";
+export * from "./client-state/adapter-idb";
+export * from "./client-state/adapter-sql";
+export * from "./client-state/adapter-memory";
+export type * from "./client-state/_types";
+export * from "./contact-directory/contacts/adapter-idb";
+export * from "./contact-directory/contacts/adapter-sql";
+export * from "./contact-directory/contacts/adapter-memory";
+export type * from "./contact-directory/contacts/_types";
+export * from "./contact-directory/groups/adapter-idb";
+export * from "./contact-directory/groups/adapter-sql";
+export * from "./contact-directory/groups/adapter-memory";
+export type * from "./contact-directory/groups/_types";
+export * from "./chats/adapter-idb";
+export * from "./chats/adapter-sql";
+export * from "./chats/adapter-memory";
+export type * from "./chats/_types";
+export * from "./keystore/adapter-idb";
+export * from "./keystore/adapter-sql";
+export * from "./keystore/adapter-memory";
+export type * from "./keystore/_types";

package/dist/core/storage/index.js

@@ -0,0 +1,19 @@
+export * from "./sql-schema";
+export * from "./sql-db-manager";
+export * from "./storage-adapter";
+export * from "./idb-adapter";
+export * from "./client-state/adapter-idb";
+export * from "./client-state/adapter-sql";
+export * from "./client-state/adapter-memory";
+export * from "./contact-directory/contacts/adapter-idb";
+export * from "./contact-directory/contacts/adapter-sql";
+export * from "./contact-directory/contacts/adapter-memory";
+export * from "./contact-directory/groups/adapter-idb";
+export * from "./contact-directory/groups/adapter-sql";
+export * from "./contact-directory/groups/adapter-memory";
+export * from "./chats/adapter-idb";
+export * from "./chats/adapter-sql";
+export * from "./chats/adapter-memory";
+export * from "./keystore/adapter-idb";
+export * from "./keystore/adapter-sql";
+export * from "./keystore/adapter-memory";

package/dist/core/storage/keystore/_types.d.ts

@@ -0,0 +1,3 @@
+import { MajikKeyJSON } from "@majikah/majik-key";
+import { MajikStorageAdapter } from "../storage-adapter";
+export type MajikKeyStorageAdapter = MajikStorageAdapter<MajikKeyJSON>;

package/dist/core/storage/keystore/_types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/storage/keystore/adapter-idb.d.ts

@@ -0,0 +1,3 @@
+import { MajikKeyJSON } from "@majikah/majik-key";
+import { IDBGenericAdapter } from "../idb-adapter";
+export declare const IDB_ADAPTER_KEYSTORE: IDBGenericAdapter<MajikKeyJSON>;

package/dist/core/storage/keystore/adapter-idb.js

@@ -0,0 +1,5 @@
+import { IDBGenericAdapter } from "../idb-adapter";
+const IDB_DB_NAME = "majik-keys";
+const IDB_STORE_NAME = "identities";
+const IDB_VERSION = 1;
+export const IDB_ADAPTER_KEYSTORE = new IDBGenericAdapter(IDB_DB_NAME, IDB_STORE_NAME, IDB_VERSION);

package/dist/core/storage/keystore/adapter-memory.d.ts

@@ -0,0 +1,14 @@
+import { MajikKeyJSON } from "@majikah/majik-key";
+import { MajikKeyStorageAdapter } from "./_types";
+export declare class InMemoryKeystoreAdapter implements MajikKeyStorageAdapter {
+    private _store;
+    save(invoice: MajikKeyJSON): Promise<void>;
+    getById(id: string): Promise<MajikKeyJSON | null>;
+    list(): Promise<MajikKeyJSON[]>;
+    remove(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    bulkSave(invoices: MajikKeyJSON[]): Promise<void>;
+    bulkRemove(ids: string[]): Promise<void>;
+}

package/dist/core/storage/keystore/adapter-memory.js

@@ -0,0 +1,32 @@
+export class InMemoryKeystoreAdapter {
+    _store = new Map();
+    async save(invoice) {
+        this._store.set(invoice.id, invoice);
+    }
+    async getById(id) {
+        return this._store.get(id) ?? null;
+    }
+    async list() {
+        return Array.from(this._store.values());
+    }
+    async remove(id) {
+        return this._store.delete(id);
+    }
+    async clear() {
+        this._store.clear();
+    }
+    async count() {
+        return this._store.size;
+    }
+    async exists(id) {
+        return this._store.has(id);
+    }
+    async bulkSave(invoices) {
+        for (const inv of invoices)
+            this._store.set(inv.id, inv);
+    }
+    async bulkRemove(ids) {
+        for (const id of ids)
+            this._store.delete(id);
+    }
+}

package/dist/core/storage/keystore/adapter-sql.d.ts

@@ -0,0 +1,18 @@
+import { MajikKeyJSON } from "@majikah/majik-key";
+import { MajikKeyStorageAdapter } from "./_types";
+import { SQLiteDatabase } from "../sql-db-manager";
+import { StorageQuery } from "../storage-adapter";
+export declare class SQLiteKeystoreAdapter implements MajikKeyStorageAdapter {
+    private db;
+    constructor(db: SQLiteDatabase);
+    save(key: MajikKeyJSON): Promise<void>;
+    getById(id: string): Promise<MajikKeyJSON | null>;
+    list(): Promise<MajikKeyJSON[]>;
+    remove(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    bulkSave(keys: MajikKeyJSON[]): Promise<void>;
+    bulkRemove(ids: string[]): Promise<void>;
+    query(query: StorageQuery<MajikKeyJSON>): Promise<MajikKeyJSON[]>;
+}

package/dist/core/storage/keystore/adapter-sql.js

@@ -0,0 +1,93 @@
+import { MAJIKAH_SQL_TABLES } from "../sql-schema";
+export class SQLiteKeystoreAdapter {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(key) {
+        await this.db.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} 
+       (id, json, timestamp, public_key)
+       VALUES (?, ?, ?, ?)`, [
+            key.id,
+            JSON.stringify(key),
+            key.timestamp ?? new Date().toISOString(),
+            key.publicKey,
+        ]);
+    }
+    async getById(id) {
+        const row = await this.db.get("SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} WHERE id = ?", [id]);
+        return row ? JSON.parse(row.json) : null;
+    }
+    async list() {
+        const rows = await this.db.all(`SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}`);
+        return rows.map((r) => JSON.parse(r.json));
+    }
+    async remove(id) {
+        const exists = await this.exists(id);
+        if (!exists)
+            return false;
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} WHERE id = ?`, [id]);
+        return true;
+    }
+    async clear() {
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}`);
+    }
+    async count() {
+        const row = await this.db.get(`SELECT COUNT(*) as n FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}`);
+        return row?.n ?? 0;
+    }
+    async exists(id) {
+        const row = await this.db.get(`SELECT 1 FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} WHERE id = ?`, [id]);
+        return !!row;
+    }
+    async bulkSave(keys) {
+        if (keys.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const g of keys) {
+                await tx.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} 
+           (id, json, timestamp, public_key)
+           VALUES (?, ?, ?, ?)`, [
+                    g.id,
+                    JSON.stringify(g),
+                    g.timestamp ?? new Date().toISOString(),
+                    g.publicKey,
+                ]);
+            }
+        });
+    }
+    async bulkRemove(ids) {
+        if (ids.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const id of ids) {
+                await tx.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} WHERE id = ?`, [id]);
+            }
+        });
+    }
+    async query(query) {
+        const clauses = [];
+        const values = [];
+        if (query.where) {
+            for (const [key, value] of Object.entries(query.where)) {
+                clauses.push(`${key} = ?`);
+                values.push(value);
+            }
+        }
+        let sql = `SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}`;
+        if (clauses.length > 0) {
+            sql += ` WHERE ${clauses.join(" AND ")}`;
+        }
+        if (query.orderBy) {
+            sql += ` ORDER BY ${String(query.orderBy)} ${query.orderDirection ?? "asc"}`;
+        }
+        if (query.limit) {
+            sql += ` LIMIT ${query.limit}`;
+        }
+        if (query.offset) {
+            sql += ` OFFSET ${query.offset}`;
+        }
+        const rows = await this.db.all(sql, values);
+        return rows.map((r) => JSON.parse(r.json));
+    }
+}

package/dist/core/storage/sql-db-manager.d.ts

@@ -0,0 +1,13 @@
+export declare class SQLiteDatabase {
+    private worker;
+    constructor(worker: Worker);
+    private call;
+    run(sql: string, params?: any[]): Promise<void>;
+    get<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    all<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    exec(sql: string): Promise<void>;
+    optimize(): Promise<void>;
+    vacuum(): Promise<void>;
+    checkpoint(mode?: "PASSIVE" | "FULL"): Promise<void>;
+    transaction(fn: (tx: SQLiteDatabase) => Promise<void>): Promise<void>;
+}

package/dist/core/storage/sql-db-manager.js

@@ -0,0 +1,59 @@
+export class SQLiteDatabase {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    call(message) {
+        const id = crypto.randomUUID();
+        return new Promise((resolve, reject) => {
+            const handler = (e) => {
+                if (e.data.id !== id)
+                    return;
+                this.worker.removeEventListener("message", handler);
+                if (e.data.ok)
+                    resolve(e.data.result);
+                else
+                    reject(new Error(e.data.error));
+            };
+            this.worker.addEventListener("message", handler);
+            this.worker.postMessage({
+                ...message,
+                id,
+            });
+        });
+    }
+    async run(sql, params = []) {
+        await this.call({ type: "run", sql, params });
+    }
+    async get(sql, params = []) {
+        return this.call({ type: "get", sql, params });
+    }
+    async all(sql, params = []) {
+        return this.call({ type: "all", sql, params });
+    }
+    async exec(sql) {
+        await this.call({ type: "exec", sql });
+    }
+    async optimize() {
+        await this.run("PRAGMA optimize;");
+        await this.run("ANALYZE;");
+        await this.run("PRAGMA wal_checkpoint(FULL);");
+    }
+    async vacuum() {
+        await this.exec("VACUUM;");
+    }
+    async checkpoint(mode = "PASSIVE") {
+        await this.run(`PRAGMA wal_checkpoint(${mode});`);
+    }
+    async transaction(fn) {
+        await this.run("BEGIN");
+        try {
+            await fn(this);
+            await this.run("COMMIT");
+        }
+        catch (err) {
+            await this.run("ROLLBACK");
+            throw err;
+        }
+    }
+}

package/dist/core/storage/sql-schema.d.ts

@@ -0,0 +1,25 @@
+type MajikahSQLSchema = string;
+/**
+ * Centralized SQLite table registry.
+ * - `as const` keeps literal types
+ * - `MajikahSQLTable` becomes a strict union type
+ */
+export declare const MAJIKAH_SQL_TABLES: {
+    readonly MAJIK_CLIENT_STATE: "majik_client_state";
+    readonly MAJIK_KEYS: "majik_keys";
+    readonly MAJIK_MESSAGE_CHATS: "majik_message_chats";
+    readonly MAJIK_MESSAGE_FILES: "majik_message_files";
+    readonly MAJIK_MESSAGE_THREAD_MAILS: "majik_message_thread_mails";
+    readonly MAJIK_CONTACTS: "majik_contacts";
+    readonly MAJIK_CONTACT_GROUPS: "majik_contact_groups";
+};
+export type MajikahSQLTable = (typeof MAJIKAH_SQL_TABLES)[keyof typeof MAJIKAH_SQL_TABLES];
+export declare function buildSchemaSQL(schemas: MajikahSQLSchema[]): MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CLIENT_STATE: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_KEYS: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_CHATS: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_FILES: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACTS: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACT_GROUPS: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_FULL: MajikahSQLSchema;
+export {};

package/dist/core/storage/sql-schema.js

@@ -0,0 +1,122 @@
+/**
+ * Centralized SQLite table registry.
+ * - `as const` keeps literal types
+ * - `MajikahSQLTable` becomes a strict union type
+ */
+export const MAJIKAH_SQL_TABLES = {
+    MAJIK_CLIENT_STATE: "majik_client_state",
+    MAJIK_KEYS: "majik_keys",
+    MAJIK_MESSAGE_CHATS: "majik_message_chats",
+    MAJIK_MESSAGE_FILES: "majik_message_files",
+    MAJIK_MESSAGE_THREAD_MAILS: "majik_message_thread_mails",
+    MAJIK_CONTACTS: "majik_contacts",
+    MAJIK_CONTACT_GROUPS: "majik_contact_groups",
+};
+function normalizeSQL(sql) {
+    return sql
+        .trim()
+        .replace(/\s+/g, " ") // collapse all whitespace
+        .toLowerCase();
+}
+export function buildSchemaSQL(schemas) {
+    const seen = new Set();
+    return schemas
+        .map((schema) => schema.trim())
+        .filter(Boolean)
+        .filter((schema) => {
+        const normalized = normalizeSQL(schema);
+        if (seen.has(normalized))
+            return false; // silently skip
+        seen.add(normalized);
+        return true;
+    })
+        .join("\n\n");
+}
+export const MAJIKAH_SQL_SCHEMA_MAJIK_CLIENT_STATE = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_CLIENT_STATE} (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+`;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_KEYS = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_KEYS} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  public_key TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_keys_timestamp
+ON ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}(timestamp);
+
+CREATE INDEX IF NOT EXISTS idx_majik_keys_public_key
+ON ${MAJIKAH_SQL_TABLES.MAJIK_KEYS}(public_key);
+`;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_CHATS = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_CHATS} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  source TEXT NOT NULL DEFAULT 'local' 
+    CHECK(source IN ('local', 'cloud'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_message_chats_created_at 
+ON ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_CHATS}(created_at);
+
+
+CREATE INDEX IF NOT EXISTS idx_majik_message_chats_source 
+ON ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_CHATS}(source);
+`;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_FILES = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_FILES} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  binary BLOB,
+  source TEXT NOT NULL DEFAULT 'local' 
+    CHECK(source IN ('local', 'cloud'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_message_files_created_at 
+ON ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_FILES}(created_at);
+
+
+CREATE INDEX IF NOT EXISTS idx_majik_message_files_source 
+ON ${MAJIKAH_SQL_TABLES.MAJIK_MESSAGE_FILES}(source);
+`;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACTS = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_CONTACTS} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  fingerprint TEXT,
+  label TEXT,
+  created_at TEXT,
+  updated_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_contacts_created_at
+ON ${MAJIKAH_SQL_TABLES.MAJIK_CONTACTS}(created_at);
+`;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACT_GROUPS = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  name TEXT,
+  created_at TEXT,
+  updated_at TEXT,
+  is_system INTEGER DEFAULT 0 CHECK(is_system IN (0,1))
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_contact_groups_created_at
+ON ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS}(created_at);
+`;
+export const MAJIKAH_SQL_SCHEMA_FULL = buildSchemaSQL([
+    MAJIKAH_SQL_SCHEMA_MAJIK_CLIENT_STATE,
+    MAJIKAH_SQL_SCHEMA_MAJIK_KEYS,
+    MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_CHATS,
+    MAJIKAH_SQL_SCHEMA_MAJIK_CONTACTS,
+    MAJIKAH_SQL_SCHEMA_MAJIK_CONTACT_GROUPS,
+    MAJIKAH_SQL_SCHEMA_MAJIK_MESSAGE_FILES,
+]);

package/dist/core/storage/storage-adapter.d.ts

@@ -0,0 +1,22 @@
+export type StorageSource = "local" | "cloud";
+export interface StorageQuery<T> {
+    where?: Partial<T>;
+    limit?: number;
+    offset?: number;
+    orderBy?: keyof T;
+    orderDirection?: "asc" | "desc";
+}
+export interface MajikStorageAdapter<T extends {
+    id: string;
+}> {
+    save(item: T, source?: StorageSource): Promise<void>;
+    getById(id: string, source?: StorageSource): Promise<T | null>;
+    list(source?: StorageSource): Promise<T[]>;
+    remove(id: string, source?: StorageSource): Promise<boolean>;
+    clear(source?: StorageSource): Promise<void>;
+    count(source?: StorageSource): Promise<number>;
+    exists(id: string, source?: StorageSource): Promise<boolean>;
+    bulkSave(items: T[], source?: StorageSource): Promise<void>;
+    bulkRemove(ids: string[], source?: StorageSource): Promise<void>;
+    query?(query: StorageQuery<T>, source?: StorageSource): Promise<T[]>;
+}

package/dist/core/storage/storage-adapter.js

@@ -0,0 +1 @@
+export {};