Dynamic Configs

seeds/initial-configs.js

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { Category } from '../@types/category'
+
+const SettingsFileTypes = {
+  yaml: 'yaml',
+  json: 'json',
+}
+const NAMESPACE = 'c646b451-db73-47fb-9a70-ea24ce8a225a'
+exports.seed = async function (knex) {
+  await knex('events').del()
+
+  const { v5: uuidv5 } = require('uuid')
+
+  const rawConfigs = getConfigs()
+
+  const categories = Object.keys(Category)
+
+  // TODO: Finish logic
+  // Do we want to flatten settings so that we can look them up by key more easily
+  // Or do we organize by category? If by category
+  const configsByCategory = categories.map(category => {
+    return {
+      id: uuidv5(event.id, NAMESPACE),
+      value: rawConfigs[category],
+      category,
+    }
+  })
+
+  await knex.batchInsert('configs', configsByCategory, 10)
+}
+
+const getConfigs = () => {
+  const settingsFilePath = process.env.NOSTR_CONFIG_DIR ?? join(process.cwd(), '.nostr')
+
+  const files = fs.readdirSync(settingsFilePath)
+  const filteredFile = files.find(fn => fn.startsWith('settings'))
+
+  let settingsFile
+  if (filteredFile) {
+    const extension = extname(filteredFile).substring(1)
+    if (SettingsFileTypes[extension]) {
+      const extension = SettingsFileTypes[extension]
+      settingsFileNamePath = `${settingsFilePath}/settings.${extension}`
+      if (extension === SettingsFileTypes.json) {
+        settingsFile = loadAndParseJsonFile(settingsFileNamePath)
+      } else {
+        settingsFile = loadAndParseYamlFile(settingsFileNamePath)
+      }
+    }
+  } else {
+    settingsFile = loadAndParseYamlFile('')
+  }
+}
+
+const loadAndParseJsonFile = path => {
+  return JSON.parse(
+    fs.readFileSync(
+      path,
+      { encoding: 'utf-8' }
+    )
+  )
+}
+
+const loadAndParseYamlFile = path => {
+  const defaultSettingsFileContent = fs.readFileSync(path, { encoding: 'utf-8' })
+  const defaults = yaml.load(defaultSettingsFileContent)
+  return defaults
+}

src/@types/config.ts

@@ -0,0 +1,30 @@
+export interface Config {
+  key: string,
+  value: object,
+  category: Category,
+  createdAt: Date,
+  updatedAt: Date,
+}
+
+enum Category {
+  info = 'info',
+  payments = 'payments',
+  paymentsProcessors = 'paymentsProcessors',
+  network = 'network',
+  workers = 'workers',
+  mirroring = 'mirroring',
+  limits = 'limits',
+    // invoice
+    // connection
+    // event
+    // client
+    // message
+}
+
+export interface DBConfig {
+  key: string,
+  value: object,
+  category: Category,
+  created_at: Date,
+  updated_at: Date,
+}

src/@types/repositories.ts

@@ -2,6 +2,7 @@ import { PassThrough } from 'stream'
 
 import { DatabaseClient, EventId, Pubkey } from './base'
 import { DBEvent, Event } from './event'
+import { Config } from './config'
 import { Invoice } from './invoice'
 import { SubscriptionFilter } from './subscription'
 import { User } from './user'
@@ -41,3 +42,8 @@ export interface IUserRepository {
   upsert(user: Partial<User>, client?: DatabaseClient): Promise<number>
   getBalanceByPubkey(pubkey: Pubkey, client?: DatabaseClient): Promise<bigint>
 }
+
+export interface IConfigRepository {
+  getConfig(key: string, client?: DatabaseClient): Promise<Config | undefined>
+  upsert(config: Partial<Config>, client?: DatabaseClient): Promise<number>
+}

src/repositories/config-repository.ts

@@ -0,0 +1,63 @@
+import { always, applySpec, omit, prop } from 'ramda'
+
+import { Config, DBConfig } from '../@types/config'
+import { createLogger } from '../factories/logger-factory'
+import { DatabaseClient } from '../@types/base'
+import { fromDBConfig } from '../utils/transform'
+import { IConfigRepository } from '../@types/repositories'
+
+const debug = createLogger('config-repository')
+
+export class ConfigRepository implements IConfigRepository {
+  public constructor(private readonly dbClient: DatabaseClient) { }
+
+  public async getConfig(
+    key: string,
+    client: DatabaseClient = this.dbClient
+  ): Promise<Config | undefined> {
+    debug('find config by key: %s', key)
+    const [dbconfig] = await client<DBConfig>('configs')
+      .where('key', key)
+      .select()
+
+    if (!dbconfig) {
+      return
+    }
+
+    return fromDBConfig(dbconfig)
+  }
+
+  public async upsert(
+    config: Config,
+    client: DatabaseClient = this.dbClient,
+  ): Promise<number> {
+    debug('upsert: %o', config)
+
+    const date = new Date()
+
+    const row = applySpec<DBConfig>({
+      key: prop('key'),
+      value: prop('value'),
+      category: prop('category'),
+      updated_at: always(date),
+      created_at: always(date),
+    })(config)
+
+    const query = client<DBConfig>('configs')
+      .insert(row)
+      .onConflict('key')
+      .merge(
+        omit([
+          'value',
+          'category',
+          'created_at',
+        ])(row)
+      )
+
+    return {
+      then: <T1, T2>(onfulfilled: (value: number) => T1 | PromiseLike<T1>, onrejected: (reason: any) => T2 | PromiseLike<T2>) => query.then(prop('rowCount') as () => number).then(onfulfilled, onrejected),
+      catch: <T>(onrejected: (reason: any) => T | PromiseLike<T>) => query.catch(onrejected),
+      toString: (): string => query.toString(),
+    } as Promise<number>
+  }
+}

src/utils/transform.ts

@@ -1,6 +1,7 @@
 import { always, applySpec, ifElse, is, isNil, path, pipe, prop, propSatisfies } from 'ramda'
 import { bech32 } from 'bech32'
 
+import { Config } from '../@types/config'
 import { Invoice } from '../@types/invoice'
 import { User } from '../@types/user'
 
@@ -41,6 +42,14 @@ export const fromDBUser = applySpec<User>({
   updatedAt: prop('updated_at'),
 })
 
+export const fromDBConfig = applySpec<Config>({
+  key: prop('key'),
+  value: prop('value'),
+  category: prop('category'),
+  createdAt: prop('created_at'),
+  updatedAt: prop('updated_at'),
+})
+
 export const fromBech32 = (input: string) => {
   const { prefix, words } = bech32.decode(input)
   if (!input.startsWith(prefix)) {