clean up and refactor open graph

2023-08-14 09:03:58 +07:00
parent 33fd7512e7
commit c42c78fc98
12 changed files with 256 additions and 654 deletions
--- a/src/libs/storage.ts
+++ b/src/libs/storage.ts
@@ -0,0 +1,441 @@
+import Database from '@tauri-apps/plugin-sql';
+import destr from 'destr';
+
+import { parser } from '@utils/parser';
+import { getParentID } from '@utils/transform';
+import {
+  Account,
+  Chats,
+  LumeEvent,
+  Profile,
+  Relays,
+  Settings,
+  Widget,
+} from '@utils/types';
+
+let db: null | Database = null;
+
+// connect database (sqlite)
+// path: tauri::api::path::BaseDirectory::App
+export async function connect(): Promise<Database> {
+  if (db) {
+    return db;
+  }
+  try {
+    db = await Database.load('sqlite:lume.db');
+  } catch (e) {
+    throw new Error('Failed to connect to database, error: ', e);
+  }
+  return db;
+}
+
+// get active account
+export async function getActiveAccount() {
+  const db = await connect();
+  const result: Array<Account> = await db.select(
+    'SELECT * FROM accounts WHERE is_active = 1;'
+  );
+  if (result.length > 0) {
+    result[0]['follows'] = result[0].follows
+      ? JSON.parse(result[0].follows as unknown as string)
+      : null;
+    result[0]['network'] = result[0].network
+      ? JSON.parse(result[0].network as unknown as string)
+      : null;
+    return result[0];
+  } else {
+    return null;
+  }
+}
+
+// create account
+export async function createAccount(npub: string, pubkey: string, follows?: string[][]) {
+  const db = await connect();
+  const res = await db.execute(
+    'INSERT OR IGNORE INTO accounts (npub, pubkey, privkey, follows, is_active) VALUES (?, ?, ?, ?, ?);',
+    [npub, pubkey, 'privkey is stored in secure storage', follows || '', 1]
+  );
+  if (res) {
+    await createWidget(
+      0,
+      'Have fun together!',
+      'https://void.cat/d/N5KUHEQCVg7SywXUPiJ7yq.jpg'
+    );
+  }
+  const getAccount = await getActiveAccount();
+  return getAccount;
+}
+
+// update account
+export async function updateAccount(column: string, value: string | string[]) {
+  const db = await connect();
+  const account = await getActiveAccount();
+  return await db.execute(`UPDATE accounts SET ${column} = ? WHERE id = ?;`, [
+    value,
+    account.id,
+  ]);
+}
+
+// count total notes
+export async function countTotalNotes() {
+  const db = await connect();
+  const result: Array<{ total: string }> = await db.select(
+    'SELECT COUNT(*) AS "total" FROM notes WHERE kind IN (1, 6);'
+  );
+  return parseInt(result[0].total);
+}
+
+// get all notes
+export async function getNotes(limit: number, offset: number) {
+  const db = await connect();
+  const totalNotes = await countTotalNotes();
+  const nextCursor = offset + limit;
+
+  const notes: { data: LumeEvent[] | null; nextCursor: number } = {
+    data: null,
+    nextCursor: 0,
+  };
+
+  const query: LumeEvent[] = await db.select(
+    `SELECT * FROM notes WHERE kind IN (1, 6, 1063) GROUP BY parent_id ORDER BY created_at DESC LIMIT "${limit}" OFFSET "${offset}";`
+  );
+
+  query.forEach(
+    (el) => (el.tags = typeof el.tags === 'string' ? destr(el.tags) : el.tags)
+  );
+
+  notes['data'] = query;
+  notes['nextCursor'] = Math.round(totalNotes / nextCursor) > 1 ? nextCursor : undefined;
+
+  return notes;
+}
+
+// get all notes by authors
+export async function getNotesByAuthors(authors: string, limit: number, offset: number) {
+  const db = await connect();
+  const totalNotes = await countTotalNotes();
+  const nextCursor = offset + limit;
+  const array = JSON.parse(authors);
+  const finalArray = `'${array.join("','")}'`;
+
+  const notes: { data: LumeEvent[] | null; nextCursor: number } = {
+    data: null,
+    nextCursor: 0,
+  };
+
+  const query: LumeEvent[] = await db.select(
+    `SELECT * FROM notes WHERE pubkey IN (${finalArray}) AND kind IN (1, 6, 1063) GROUP BY parent_id ORDER BY created_at DESC LIMIT "${limit}" OFFSET "${offset}";`
+  );
+
+  query.forEach(
+    (el) => (el.tags = typeof el.tags === 'string' ? destr(el.tags) : el.tags)
+  );
+
+  notes['data'] = query;
+  notes['nextCursor'] = Math.round(totalNotes / nextCursor) > 1 ? nextCursor : undefined;
+
+  return notes;
+}
+
+// get note by id
+export async function getNoteByID(event_id: string) {
+  const db = await connect();
+  const result: LumeEvent[] = await db.select(
+    `SELECT * FROM notes WHERE event_id = "${event_id}";`
+  );
+  if (result[0]) {
+    if (result[0].kind === 1) result[0]['content'] = parser(result[0]);
+    return result[0];
+  } else {
+    return null;
+  }
+}
+
+// create note
+export async function createNote(
+  event_id: string,
+  pubkey: string,
+  kind: number,
+  tags: string[][],
+  content: string,
+  created_at: number
+) {
+  const db = await connect();
+  const account = await getActiveAccount();
+  const parentID = getParentID(tags, event_id);
+
+  return await db.execute(
+    'INSERT OR IGNORE INTO notes (event_id, account_id, pubkey, kind, tags, content, created_at, parent_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?);',
+    [event_id, account.id, pubkey, kind, tags, content, created_at, parentID]
+  );
+}
+
+// get note replies
+export async function getReplies(parent_id: string) {
+  const db = await connect();
+  const result: Array<LumeEvent> = await db.select(
+    `SELECT * FROM replies WHERE parent_id = "${parent_id}" ORDER BY created_at DESC;`
+  );
+  return result;
+}
+
+// create reply note
+export async function createReplyNote(
+  parent_id: string,
+  event_id: string,
+  pubkey: string,
+  kind: number,
+  tags: string[][],
+  content: string,
+  created_at: number
+) {
+  const db = await connect();
+  return await db.execute(
+    'INSERT OR IGNORE INTO replies (event_id, parent_id, pubkey, kind, tags, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?);',
+    [event_id, parent_id, pubkey, kind, tags, content, created_at]
+  );
+}
+
+// get all chats by pubkey
+export async function getChats() {
+  const db = await connect();
+  const account = await getActiveAccount();
+
+  const chats: { follows: Array<Chats> | null; unknowns: Array<Chats> | null } = {
+    follows: [],
+    unknowns: [],
+  };
+
+  let result: Array<Chats> = await db.select(
+    `SELECT DISTINCT sender_pubkey FROM chats WHERE receiver_pubkey = "${account.pubkey}" ORDER BY created_at DESC;`
+  );
+
+  result = result.map((v) => ({ ...v, new_messages: 0 }));
+  result = result.sort((a, b) => a.new_messages - b.new_messages);
+
+  chats.follows = result.filter((el) => {
+    return account.follows.some((i) => {
+      return i === el.sender_pubkey;
+    });
+  });
+
+  chats.unknowns = result.filter(
+    (el) => !chats.follows.includes(el) && el.sender_pubkey !== account.pubkey
+  );
+
+  return chats;
+}
+
+// get chat messages
+export async function getChatMessages(receiver_pubkey: string, sender_pubkey: string) {
+  const db = await connect();
+  let receiver = [];
+
+  const sender: Array<Chats> = await db.select(
+    `SELECT * FROM chats WHERE sender_pubkey = "${sender_pubkey}" AND receiver_pubkey = "${receiver_pubkey}";`
+  );
+
+  if (receiver_pubkey !== sender_pubkey) {
+    receiver = await db.select(
+      `SELECT * FROM chats WHERE sender_pubkey = "${receiver_pubkey}" AND receiver_pubkey = "${sender_pubkey}";`
+    );
+  }
+
+  const result = [...sender, ...receiver].sort(
+    (x: { created_at: number }, y: { created_at: number }) => x.created_at - y.created_at
+  );
+
+  return result;
+}
+
+// create chat
+export async function createChat(
+  event_id: string,
+  receiver_pubkey: string,
+  sender_pubkey: string,
+  content: string,
+  tags: string[][],
+  created_at: number
+) {
+  const db = await connect();
+  await db.execute(
+    'INSERT OR IGNORE INTO chats (event_id, receiver_pubkey, sender_pubkey, content, tags, created_at) VALUES (?, ?, ?, ?, ?, ?);',
+    [event_id, receiver_pubkey, sender_pubkey, content, tags, created_at]
+  );
+  return sender_pubkey;
+}
+
+// get setting
+export async function getSetting(key: string) {
+  const db = await connect();
+  const result: Array<Settings> = await db.select(
+    `SELECT value FROM settings WHERE key = "${key}";`
+  );
+  return result[0]?.value;
+}
+
+// update setting
+export async function updateSetting(key: string, value: string | number) {
+  const db = await connect();
+  return await db.execute(`UPDATE settings SET value = "${value}" WHERE key = "${key}";`);
+}
+
+// get last login
+export async function getLastLogin() {
+  const db = await connect();
+  const result: Array<Settings> = await db.select(
+    `SELECT value FROM settings WHERE key = "last_login";`
+  );
+  if (result[0]) {
+    return parseInt(result[0].value);
+  } else {
+    return 0;
+  }
+}
+
+// update last login
+export async function updateLastLogin(value: number) {
+  const db = await connect();
+  return await db.execute(
+    `UPDATE settings SET value = ${value} WHERE key = "last_login";`
+  );
+}
+
+// get all widgets
+export async function getWidgets() {
+  const db = await connect();
+  const account = await getActiveAccount();
+  const result: Array<Widget> = await db.select(
+    `SELECT * FROM widgets WHERE account_id = "${account.id}" ORDER BY created_at DESC;`
+  );
+  return result;
+}
+
+// create block
+export async function createWidget(
+  kind: number,
+  title: string,
+  content: string | string[]
+) {
+  const db = await connect();
+  const activeAccount = await getActiveAccount();
+  const insert = await db.execute(
+    'INSERT OR IGNORE INTO widgets (account_id, kind, title, content) VALUES (?, ?, ?, ?);',
+    [activeAccount.id, kind, title, content]
+  );
+
+  if (insert) {
+    const record: Widget = await db.select(
+      'SELECT * FROM widgets ORDER BY id DESC LIMIT 1;'
+    );
+    return record[0];
+  } else {
+    return null;
+  }
+}
+
+// remove block
+export async function removeWidget(id: string) {
+  const db = await connect();
+  return await db.execute(`DELETE FROM widgets WHERE id = "${id}";`);
+}
+
+// logout
+export async function removeAll() {
+  const db = await connect();
+  await db.execute(`UPDATE settings SET value = "0" WHERE key = "last_login";`);
+  await db.execute('DELETE FROM replies;');
+  await db.execute('DELETE FROM notes;');
+  await db.execute('DELETE FROM widgets;');
+  await db.execute('DELETE FROM chats;');
+  await db.execute('DELETE FROM accounts;');
+  return true;
+}
+
+// create metadata
+export async function createMetadata(id: string, pubkey: string, content: string) {
+  const db = await connect();
+  const now = Math.floor(Date.now() / 1000);
+  return await db.execute(
+    'INSERT OR REPLACE INTO metadata (id, pubkey, content, created_at) VALUES (?, ?, ?, ?);',
+    [id, pubkey, content, now]
+  );
+}
+
+export async function getAllMetadata() {
+  const db = await connect();
+  const result: LumeEvent[] = await db.select(`SELECT * FROM metadata;`);
+  const users: Profile[] = result.map((el) => {
+    const profile: Profile = destr(el.content);
+    return {
+      pubkey: el.pubkey,
+      ident: profile.name || profile.display_name || profile.username || 'anon',
+      picture:
+        profile.picture ||
+        profile.image ||
+        'https://void.cat/d/5VKmKyuHyxrNMf9bWSVPih.jpg',
+    };
+  });
+  return users;
+}
+
+// get user metadata
+export async function getUserMetadata(pubkey: string) {
+  const db = await connect();
+  const result = await db.select(`SELECT * FROM metadata WHERE pubkey = "${pubkey}";`);
+  if (result[0]) {
+    return { ...result[0], ...JSON.parse(result[0].content) } as Profile;
+  } else {
+    return null;
+  }
+}
+
+// delete privkey
+export async function removePrivkey() {
+  const db = await connect();
+  const activeAccount = await getActiveAccount();
+  return await db.execute(
+    `UPDATE accounts SET privkey = "privkey is stored in secure storage" WHERE id = "${activeAccount.id}";`
+  );
+}
+
+// get relays
+export async function getRelays() {
+  const db = await connect();
+  const activeAccount = await getActiveAccount();
+  return (await db.select(
+    `SELECT * FROM relays WHERE account_id = "${activeAccount.id}";`
+  )) as Relays[];
+}
+
+// get relays
+export async function getExplicitRelayUrls() {
+  const db = await connect();
+  const activeAccount = await getActiveAccount();
+
+  if (!activeAccount) return null;
+
+  const result: Relays[] = await db.select(
+    `SELECT * FROM relays WHERE account_id = "${activeAccount.id}";`
+  );
+
+  if (result.length > 0) return result.map((el) => el.relay);
+
+  return null;
+}
+
+// create relay
+export async function createRelay(relay: string, purpose?: string) {
+  const db = await connect();
+  const activeAccount = await getActiveAccount();
+  return await db.execute(
+    'INSERT OR IGNORE INTO relays (account_id, relay, purpose) VALUES (?, ?, ?);',
+    [activeAccount.id, relay, purpose || '']
+  );
+}
+
+// remove relay
+export async function removeRelay(relay: string) {
+  const db = await connect();
+  return await db.execute(`DELETE FROM relays WHERE relay = "${relay}";`);
+}