Emil
124 lines
3.3 KiB
TypeScript
124 lines
3.3 KiB
TypeScript
import type { SupabaseClient } from '@supabase/supabase-js'
|
|
import type { CoreEvent } from '@/lib/events/types'
|
|
import { eventBus } from '@/lib/events/bus'
|
|
import { ingestTransactions } from '@/lib/transactions/ingest'
|
|
import { createLogger } from '@/lib/logger'
|
|
import type {
|
|
ExtensionContext,
|
|
ExtensionLogger,
|
|
ExtensionSettings,
|
|
ExtensionStorage,
|
|
ExtensionServices,
|
|
} from './types'
|
|
|
|
/**
|
|
* Create a prefixed logger for an extension.
|
|
*/
|
|
function createExtLogger(extensionId: string): ExtensionLogger {
|
|
const logger = createLogger(`ext:${extensionId}`)
|
|
return {
|
|
info: (message: string, ...args: unknown[]) => logger.info(message, ...args),
|
|
warn: (message: string, ...args: unknown[]) => logger.warn(message, ...args),
|
|
error: (message: string, ...args: unknown[]) => logger.error(message, ...args),
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a settings accessor scoped to a specific extension.
|
|
*/
|
|
function createSettings(
|
|
supabase: SupabaseClient,
|
|
userId: string,
|
|
extensionId: string
|
|
): ExtensionSettings {
|
|
return {
|
|
async get<T>(key?: string): Promise<T | null> {
|
|
const lookupKey = key ?? 'settings'
|
|
const { data } = await supabase
|
|
.from('extension_data')
|
|
.select('value')
|
|
.eq('user_id', userId)
|
|
.eq('extension_id', extensionId)
|
|
.eq('key', lookupKey)
|
|
.single()
|
|
|
|
return (data?.value as T) ?? null
|
|
},
|
|
|
|
async set<T>(key: string, value: T): Promise<void> {
|
|
await supabase
|
|
.from('extension_data')
|
|
.upsert(
|
|
{
|
|
user_id: userId,
|
|
extension_id: extensionId,
|
|
key,
|
|
value,
|
|
},
|
|
{ onConflict: 'user_id,extension_id,key' }
|
|
)
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a storage accessor wrapping Supabase storage.
|
|
*/
|
|
function createStorage(supabase: SupabaseClient): ExtensionStorage {
|
|
return {
|
|
async download(bucket: string, path: string) {
|
|
const { data, error } = await supabase.storage
|
|
.from(bucket)
|
|
.download(path)
|
|
return { data, error: error?.message }
|
|
},
|
|
|
|
async upload(bucket: string, path: string, data: ArrayBuffer, options?: { contentType?: string }) {
|
|
const { error } = await supabase.storage
|
|
.from(bucket)
|
|
.upload(path, data, options ? { contentType: options.contentType } : undefined)
|
|
if (error) return { path: '', error: error.message }
|
|
return { path }
|
|
},
|
|
|
|
getPublicUrl(bucket: string, path: string): string {
|
|
const { data } = supabase.storage
|
|
.from(bucket)
|
|
.getPublicUrl(path)
|
|
return data.publicUrl
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create core services exposed to extensions.
|
|
*/
|
|
function createServices(): ExtensionServices {
|
|
return {
|
|
ingestTransactions,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build a fully populated ExtensionContext.
|
|
*
|
|
* The context gives extensions access to Supabase, event emission, settings,
|
|
* storage, logging, and core services — without importing from core modules.
|
|
*/
|
|
export function createExtensionContext(
|
|
supabase: SupabaseClient,
|
|
userId: string,
|
|
extensionId: string
|
|
): ExtensionContext {
|
|
return {
|
|
userId,
|
|
extensionId,
|
|
supabase,
|
|
emit: (event: CoreEvent) => eventBus.emit(event),
|
|
settings: createSettings(supabase, userId, extensionId),
|
|
storage: createStorage(supabase),
|
|
log: createExtLogger(extensionId),
|
|
services: createServices(),
|
|
}
|
|
}
|