add ddo crud

jest.config.js

@@ -1,4 +1,17 @@
 export default {
   preset: 'ts-jest',
-  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    // '^.+\\.[tj]sx?$' to process js/ts with `ts-jest`
+    // '^.+\\.m?[tj]sx?$' to process js/ts/mjs/mts with `ts-jest`
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
 };

package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "jest --detectOpenHandles",
+    "test": "jest --runInBand",
     "build": "npm run clean && npm run build:tsc",
     "build:swagger": "tsoa spec",
     "build:tsc": "tsc --sourceMap",

src/@types/OceanNode.ts

@@ -3,13 +3,11 @@
 import { OceanIndexer } from '../components/Indexer/index'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import { Stream } from 'stream'
+import { TypesenseConfigOptions } from './Typesense'
 import { Blockchain } from '../utils/blockchain'
 
 export interface OceanNodeDBConfig {
-  host: string
-  user: string
-  pwd: string
-  dbname: string
+  url: string
 }
 
 export interface OceanNodeKeys {

src/@types/Typesense.ts

@@ -1,5 +1,3 @@
-import { Logger } from 'winston'
-
 export interface TypesenseAbstractLogger {
   error?: any
   warn?: any
@@ -10,7 +8,7 @@ export interface TypesenseAbstractLogger {
 
 export interface TypesenseNode {
   host: string
-  port: number
+  port: string
   protocol: string
 }
 
@@ -21,7 +19,7 @@ export interface TypesenseConfigOptions {
   retryIntervalSeconds?: number
   connectionTimeoutSeconds?: number
   logLevel?: string
-  logger?: Logger
+  logger?: TypesenseAbstractLogger
 }
 
 export type TypesenseFieldType =

src/components/database/index.ts

@@ -1,5 +1,226 @@
 import { OceanNodeDBConfig } from '../../@types/OceanNode'
+import { convertTypesenseConfig, Typesense, TypesenseError } from './typesense.js'
+import { Schema, schemas } from './schemas.js'
+
+export class DdoDatabase {
+  private provider: Typesense
+
+  constructor(
+    private config: OceanNodeDBConfig,
+    private schemas: Schema[]
+  ) {
+    return (async (): Promise<DdoDatabase> => {
+      this.provider = new Typesense(convertTypesenseConfig(this.config.url))
+      for (const ddoSchema of this.schemas) {
+        try {
+          await this.provider.collections(ddoSchema.name).retrieve()
+        } catch (error) {
+          if (error instanceof TypesenseError && error.httpStatus === 404) {
+            await this.provider.collections().create(ddoSchema)
+          }
+        }
+      }
+      return this
+    })() as unknown as DdoDatabase
+  }
+
+  async create(ddo: Record<string, any>) {
+    try {
+      return await this.provider.collections(this.schemas[0].name).documents().create(ddo)
+    } catch (error) {
+      return null
+    }
+  }
+
+  async retrieve(id: string) {
+    try {
+      return await this.provider
+        .collections(this.schemas[0].name)
+        .documents()
+        .retrieve(id)
+    } catch (error) {
+      return null
+    }
+  }
+
+  async update(id: string, fields: Record<string, any>) {
+    try {
+      return await this.provider
+        .collections(this.schemas[0].name)
+        .documents()
+        .update(id, fields)
+    } catch (error) {
+      if (error instanceof TypesenseError && error.httpStatus === 404) {
+        return await this.provider
+          .collections(this.schemas[0].name)
+          .documents()
+          .create({ id, ...fields })
+      }
+      return null
+    }
+  }
+
+  async delete(id: string) {
+    try {
+      return await this.provider.collections(this.schemas[0].name).documents().delete(id)
+    } catch (error) {
+      return null
+    }
+  }
+}
+
+export class NonceDatabase {
+  private provider: Typesense
+
+  constructor(
+    private config: OceanNodeDBConfig,
+    private schema: Schema
+  ) {
+    return (async (): Promise<NonceDatabase> => {
+      this.provider = new Typesense(convertTypesenseConfig(this.config.url))
+      try {
+        await this.provider.collections(this.schema.name).retrieve()
+      } catch (error) {
+        if (error instanceof TypesenseError && error.httpStatus === 404) {
+          await this.provider.collections().create(this.schema)
+        }
+      }
+      return this
+    })() as unknown as NonceDatabase
+  }
+
+  async create(address: string, nonce: number) {
+    try {
+      return await this.provider
+        .collections(this.schema.name)
+        .documents()
+        .create({ id: address, nonce })
+    } catch (error) {
+      return null
+    }
+  }
+
+  async retrieve(address: string) {
+    try {
+      return await this.provider
+        .collections(this.schema.name)
+        .documents()
+        .retrieve(address)
+    } catch (error) {
+      return null
+    }
+  }
+
+  async update(address: string, nonce: number) {
+    try {
+      return await this.provider
+        .collections(this.schema.name)
+        .documents()
+        .update(address, { nonce })
+    } catch (error) {
+      if (error instanceof TypesenseError && error.httpStatus === 404) {
+        return await this.provider
+          .collections(this.schema.name)
+          .documents()
+          .create({ id: address, nonce })
+      }
+      return null
+    }
+  }
+
+  async delete(address: string) {
+    try {
+      return await this.provider.collections(this.schema.name).documents().delete(address)
+    } catch (error) {
+      return null
+    }
+  }
+}
+
+export class IndexerDatabase {
+  private provider: Typesense
+
+  constructor(
+    private config: OceanNodeDBConfig,
+    private schema: Schema
+  ) {
+    return (async (): Promise<IndexerDatabase> => {
+      this.provider = new Typesense(convertTypesenseConfig(this.config.url))
+      try {
+        await this.provider.collections(this.schema.name).retrieve()
+      } catch (error) {
+        if (error instanceof TypesenseError && error.httpStatus === 404) {
+          await this.provider.collections().create(this.schema)
+        }
+      }
+      return this
+    })() as unknown as IndexerDatabase
+  }
+
+  async create(id: string, fields: Record<string, any>) {
+    try {
+      return await this.provider
+        .collections(this.schema.name)
+        .documents()
+        .create({ id, ...fields })
+    } catch (error) {
+      return null
+    }
+  }
+
+  async retrieve(id: string) {
+    try {
+      return await this.provider.collections(this.schema.name).documents().retrieve(id)
+    } catch (error) {
+      return null
+    }
+  }
+
+  async update(id: string, fields: Record<string, any>) {
+    try {
+      return await this.provider
+        .collections(this.schema.name)
+        .documents()
+        .update(id, fields)
+    } catch (error) {
+      if (error instanceof TypesenseError && error.httpStatus === 404) {
+        return await this.provider
+          .collections(this.schema.name)
+          .documents()
+          .create({ id, ...fields })
+      }
+      return null
+    }
+  }
+
+  async delete(id: string) {
+    try {
+      return await this.provider.collections(this.schema.name).documents().delete(id)
+    } catch (error) {
+      return null
+    }
+  }
+}
 
 export class Database {
-  constructor(config: OceanNodeDBConfig) {}
+  ddo: DdoDatabase
+  nonce: NonceDatabase
+  indexer: IndexerDatabase
+
+  constructor(private config: OceanNodeDBConfig) {
+    return (async (): Promise<Database> => {
+      this.ddo = await new DdoDatabase(config, schemas.ddoSchemas)
+      this.nonce = await new NonceDatabase(config, schemas.nonceSchemas)
+      this.indexer = await new IndexerDatabase(config, schemas.indexerSchemas)
+      return this
+    })() as unknown as Database
+  }
 }
+
+// Example
+//
+// db.nonce.create('0x123', 1234567) return -> { id:'0x123', nonce:1234567 } or null or throw error
+// db.nonce.update('0x123', 1234568) return -> { id:'0x123', nonce:1234568 } or null or throw error
+// db.nonce.retrieve('0x123') return -> 1234568 or throw error
+//
+// db.indexer.create('Network_A', { last_indexed_block: 1234567 }) return -> { id:'Network_A', last_indexed_block:1234567 } or null or throw error

src/components/database/schemas.ts

@@ -0,0 +1,27 @@
+import { TypesenseCollectionCreateSchema } from '../../@types'
+
+export type Schema = TypesenseCollectionCreateSchema
+export type Schemas = {
+  ddoSchemas: Schema[]
+  nonceSchemas: Schema
+  indexerSchemas: Schema
+}
+export const schemas: Schemas = {
+  ddoSchemas: [
+    {
+      name: 'ddo_v0.1',
+      enable_nested_fields: true,
+      fields: [{ name: '.*', type: 'auto' }]
+    }
+  ],
+  nonceSchemas: {
+    name: 'nonce',
+    enable_nested_fields: true,
+    fields: [{ name: 'nonce', type: 'int64' }]
+  },
+  indexerSchemas: {
+    name: 'indexer',
+    enable_nested_fields: true,
+    fields: [{ name: '.*', type: 'auto' }]
+  }
+}

src/components/database/typesense.ts

@@ -7,8 +7,31 @@ import {
   TypesenseDocumentSchema,
   TypesenseSearchResponse
 } from '../../@types'
-import { TypesenseApi } from './typesenseApi'
-import { TypesenseConfig } from './typesenseConfig'
+import { TypesenseApi } from './typesenseApi.js'
+import { TypesenseConfig } from './typesenseConfig.js'
+
+export const convertTypesenseConfig = (url: string) => {
+  const urlObject = new URL(url)
+  const { protocol } = urlObject
+  const host = urlObject.hostname
+  const { port } = urlObject
+  const apiKey = urlObject.searchParams.get('apiKey')
+  const config: TypesenseConfigOptions = {
+    apiKey,
+    nodes: [{ host, port, protocol }]
+  }
+  return config
+}
+
+export class TypesenseError extends Error {
+  httpStatus?: number
+
+  constructor(message?: string) {
+    super(message)
+    this.name = new.target.name
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
 
 /**
  * TypesenseDocuments class implements CRUD methods
@@ -120,7 +143,7 @@ export class TypesenseCollections {
  * It initiates classes that provides access to methods of collections
  * or an individual collection
  */
-export default class Typesense {
+export class Typesense {
   config: TypesenseConfig
   api: TypesenseApi
   collectionsRecords: Record<string, TypesenseCollection> = {}