obsidian-plugin/h-sphere_sql-seal
1
0
Fork 0
mirror of https://github.com/h-sphere/sql-seal.git synced 2026-07-22 10:10:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore: removing old event based code

Browse source
This commit is contained in:
Kacper Kula 2024-11-03 10:56:33 +00:00
parent f34f0476f2
commit 6fbcbd2157
6 changed files with 7 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/SealFileSync.ts
View file

@ -48,14 +48,12 @@ export class SealFileSync {
await this.sqlSeal.db.updateData('files', [fileData(file, frontmatter)])
await this.sqlSeal.db.deleteData('tags', [{ fileId: file.path }], 'fileId')
this.sqlSeal.observer.fireObservers('table:files')
this.tableManager.getTableSignal('files')(Date.now())
// Wait 1 second before updating tags table
await sleep(1000)
await this.sqlSeal.db.insertData('tags', await this.getFileTags(file))
this.sqlSeal.observer.fireObservers('table:tags')
this.tableManager.getTableSignal('tags')(Date.now())
}))
@ -77,13 +75,11 @@ export class SealFileSync {
// we need to update the row
await this.sqlSeal.db.insertData('files', [fileData(file, frontmatter)])
this.sqlSeal.observer.fireObservers('table:files')
this.tableManager.getTableSignal('files')(Date.now())
// Wait 1 second before updating tags table
await sleep(1000)
await this.sqlSeal.db.insertData('tags', await this.getFileTags(file))
this.sqlSeal.observer.fireObservers('table:tags')
this.tableManager.getTableSignal('tags')(Date.now())
}))
@ -94,12 +90,10 @@ export class SealFileSync {
}
await this.sqlSeal.db.deleteData('files', [{ id: file.path }])
this.sqlSeal.observer.fireObservers('table:files')
this.tableManager.getTableSignal('files')(Date.now())
await this.sqlSeal.db.deleteData('tags', [{ fileId: file.path }], 'fileId')
this.sqlSeal.observer.fireObservers('table:tags')
this.tableManager.getTableSignal('tags')(Date.now())
}))
@ -115,14 +109,12 @@ export class SealFileSync {
await this.sqlSeal.db.deleteData('tags', [{ fileId: oldPath }], 'fileId')
await this.sqlSeal.db.insertData('files', [fileData(file, await extractFrontmatterFromFile(file, this.plugin))])
this.sqlSeal.observer.fireObservers('table:files')
this.tableManager.getTableSignal('files')(Date.now())
// Wait 1 second before updating tags table
await sleep(1000)
await this.sqlSeal.db.insertData('tags', await this.getFileTags(file))
this.sqlSeal.observer.fireObservers('table:tags')
this.tableManager.getTableSignal('tags')(Date.now())
@ -170,8 +162,6 @@ export class SealFileSync {
'fileId': 'TEXT'
})
}
this.sqlSeal.observer.fireObservers('table:files')
this.sqlSeal.observer.fireObservers('table:tags')
this.tableManager.getTableSignal('files')(Date.now())
this.tableManager.getTableSignal('tags')(Date.now())

77
src/SealObserver.ts
View file

@ -1,77 +0,0 @@
import { Logger } from "./logger";
type Callback = () => void;
export class SealObserver {
private tables: Map<string, Set<Callback>>;
private tags: Map<string, Set<Callback>>;
private logger: Logger
constructor(verbose = false) {
this.tables = new Map();
this.tags = new Map();
this.logger = new Logger(verbose)
}
registerObserver(tableNames: string | string[], observer: Callback, tag?: string) {
if (typeof tableNames === 'string') {
tableNames = [tableNames];
}
tableNames.forEach(tableName => {
if (!this.tables.has(tableName)) {
this.tables.set(tableName, new Set<Callback>());
this.logger.log(`Table "${tableName}" registered.`);
}
const observers = this.tables.get(tableName);
if (observers !== undefined) {
observers.add(observer);
this.logger.log(`Observer registered for "${tableName}".`);
}
if (tag) {
if (!this.tags.has(tag)) {
this.tags.set(tag, new Set<Callback>());
}
const tags = this.tags.get(tag);
if (tags !== undefined) {
tags.add(observer);
}
}
});
}
hasAnyObserver(tableNames: string[]) {
return tableNames.reduce((acc, t) =>
acc || (this.tables.has(t) && this.tables.get(t)!.size > 0),
false)
}
unregisterObserversByTag(tag: string) {
if (this.tags.has(tag)) {
const observers = this.tags.get(tag);
if (observers) {
observers.forEach(observer => {
this.unregisterObserver(observer)
})
this.tags.delete(tag)
}
}
}
unregisterObserver(observer: Callback) {
this.tables.forEach(observers => {
observers.delete(observer);
});
this.logger.log(`Observer unregistered.`);
}
fireObservers(tableName: string) {
if (this.tables.has(tableName)) {
const observers = this.tables.get(tableName);
if (observers) {
observers.forEach(observer => observer());
this.logger.log(`Observers fired for table "${tableName}".`);
}
}
}
}

99
src/SqlSealCodeblockHandler.ts
View file

@ -3,10 +3,9 @@ import { displayData, displayError, displayInfo, displayLoader } from "./ui"
import { resolveFrontmatter } from "./frontmatter"
import { hashString } from "./hash"
import { prefixedIfNotGlobal, updateTables } from "./sqlReparseTables"
import { SealObserver } from "./SealObserver"
import { SqlSealDatabase } from "./database"
import { Logger } from "./logger"
import { ParsedLanguage, parseLanguage, TableStatement } from "./grammar/parser"
import { parseLanguage, TableStatement } from "./grammar/parser"
import { SyncModel } from "./models/sync"
import { TablesManager } from "./dataLoader/collections/tablesManager"
import { QueryManager } from "./dataLoader/collections/queryManager"
@ -20,7 +19,6 @@ export class SqlSealCodeblockHandler {
constructor(
private readonly app: App,
private readonly db: SqlSealDatabase,
private readonly observer: SealObserver,
private logger: Logger,
private tableManager: TablesManager,
private queryManager: QueryManager
@ -28,100 +26,6 @@ export class SqlSealCodeblockHandler {
this.syncModel = new SyncModel(db)
}
setupTables(tables: ParsedLanguage['tables'], ctx: MarkdownPostProcessorContext) {
tables.forEach(table => {
this.setupTable(table, ctx)
})
}
setupTable({ url, name }: TableStatement, ctx: MarkdownPostProcessorContext) {
// UPDATING TABLES IF THEY CHANGED SINCE LAST REGISTER
const prefix = hashString(ctx.sourcePath)
const prefixedName = prefixedIfNotGlobal(name, this.globalTables, prefix)
const existing = this.syncModel.getSync(ctx.sourcePath, prefixedName)
this.observer.registerObserver(`file:${url}`, async () => {
// Update table
await this.db.loadDataForDatabaseFromUrl(prefixedName, url, true)
// update when it was updated.
this.syncModel.removeSync(ctx.sourcePath, prefixedName)
this.syncModel.registerSync(ctx.sourcePath, url, prefixedName)
// Fire observers for the table
this.observer.fireObservers(`table:${prefixedName}`)
}, ctx.docId)
if (existing) {
if (existing.url === url) {
// Already synced
// TODO: Check if the file was updated after we synced, if so, we should update it.
requestAnimationFrame(() => {
this.observer.fireObservers(`table:${prefixedName}`)
})
return
} else {
// Old database is no-no. We need to update it.
this.db.db.prepare('DROP TABLE :tablename').run({
tablename: prefixedName
})
this.syncModel.removeSync(ctx.sourcePath, prefixedName)
}
}
this.observer.fireObservers(`file:${url}`)
}
setupSelect(selectStmt: string, el: HTMLElement, ctx: MarkdownPostProcessorContext) {
try {
const prefix = hashString(ctx.sourcePath)
const { statement, tables } = updateTables(selectStmt, this.globalTables, prefix)
const frontmatter = resolveFrontmatter(ctx, this.app)
const renderSelect = async () => {
try {
const stmt = this.db.db.prepare(statement)
const columns = stmt.columns().map(column => column.name);
const data = stmt.all(frontmatter ?? {})
displayData(el, columns, data, this.app)
} catch (e) {
displayError(el, e)
}
}
// Register observer for each table
tables.forEach(table => {
const observer = async () => {
if (!el.isConnected) {
// Unregistering using the context id
this.observer.unregisterObserversByTag(ctx.docId)
}
displayLoader(el)
await renderSelect()
}
this.observer.registerObserver(`table:${table}`, observer, ctx.docId)
})
this.globalTables.forEach(t => this.observer.fireObservers(`table:${t}`))
if (!this.observer.hasAnyObserver(this.globalTables.map(t => `table:${t}`))) {
renderSelect()
}
// Triggering the ones which exist
tables.forEach(t => {
if (this.syncModel.getSync(ctx.sourcePath, t)) {
this.observer.fireObservers(`table:${t}`)
}
})
} catch (e) {
if (e instanceof RangeError && ctx && Object.keys(ctx.frontmatter).length === 0) {
displayInfo(el, 'Cannot access frontmatter properties in Live Preview Mode. Switch to Reading Mode to see the results.')
} else {
displayError(el, e)
}
}
}
setupTableSignals(tables: Array<TableStatement>) {
tables.forEach(t => {
this.logger.log(`Registering table ${t.name} -> ${t.url}`)
@ -155,7 +59,6 @@ export class SqlSealCodeblockHandler {
displayLoader(el)
await this.db.connect()
// this.observer.unregisterObserversByTag(ctx.docId) // Unregister all previous observers.
try {
const results = parseLanguage(source)

2
src/dataLoader/collections/queryManager.ts
View file

@ -10,7 +10,7 @@ export class QueryManager {
this.registeredQueries.get(fileId)!()
this.registeredQueries.delete(fileId)
}
const tableSignals = tables.map(t => this.tablesManager.getTableSignal(t))
const tableSignals = tables.map(t => this.tablesManager.getTableSignal(t, true))
const quertySignal = createSignal<number>()
const unregister = withSignals(...tableSignals)(() => {
quertySignal(Date.now())

5
src/dataLoader/collections/tablesManager.ts
View file

@ -38,8 +38,11 @@ export class TablesManager {
})
}
getTableSignal(tableName: string) {
getTableSignal(tableName: string, failOnUndefined: boolean = false) {
if (!this.tableSignals.has(tableName)) {
if (failOnUndefined) {
throw new Error(`${tableName} does not exist`)
}
this.tableSignals.set(tableName, createSignal<number>())
}
return this.tableSignals.get(tableName)!

13
src/sqlSeal.ts
View file

@ -1,6 +1,5 @@
import { SqlSealDatabase } from "./database";
import { App } from "obsidian";
import { SealObserver } from "./SealObserver";
import { SqlSealCodeblockHandler } from "./SqlSealCodeblockHandler";
import { Logger } from "./logger";
import { TablesManager } from "./dataLoader/collections/tablesManager";
@ -9,31 +8,21 @@ import { FilesManager } from "./dataLoader/collections/filesManager";
export class SqlSeal {
public db: SqlSealDatabase
public observer: SealObserver
public codeBlockHandler: SqlSealCodeblockHandler
public tablesManager: TablesManager
constructor(private readonly app: App, verbose = false) {
this.db = new SqlSealDatabase(app, verbose)
this.observer = new SealObserver(verbose)
this.observeAllFileChanges()
const logger = new Logger(verbose)
const fileManager = new FilesManager(this.app.vault)
this.tablesManager = new TablesManager(fileManager, this.db)
const queryManager = new QueryManager(this.tablesManager)
this.codeBlockHandler = new SqlSealCodeblockHandler(app, this.db, this.observer, logger, this.tablesManager, queryManager)
this.codeBlockHandler = new SqlSealCodeblockHandler(app, this.db, logger, this.tablesManager, queryManager)
// FIXME: handle here changes to files and tags?
}
getHandler() {
return this.codeBlockHandler.getHandler()
}
private observeAllFileChanges() {
// Use fs to observe file changes
this.app.vault.on('modify', async (file) => {
this.observer.fireObservers('file:' + file.path)
})
}
}