@docknetwork/wallet-sdk-data-store 0.4.1

package/src/entities/document/remove-document.ts

@@ -0,0 +1,34 @@
+import assert from 'assert';
+import {ContextProps} from '../../types';
+import {DocumentEntity} from './document.entity';
+import { logger } from '../../logger';
+
+/**
+ * Remove document
+ * @param dataStore
+ * @param id
+ */
+export async function removeDocument({
+  dataStore,
+  id,
+}: ContextProps & {id: string}): Promise<void> {
+  assert(!!id, 'Document id is required');
+
+  logger.debug(`Removing document with id ${id}`);
+  const repository = dataStore.db.getRepository(DocumentEntity);
+  await repository.delete({
+    id,
+    networkId: dataStore.networkId,
+  });
+}
+
+/**
+ * Remove all documents
+ * @param dataStore
+ */
+export async function removeAllDocuments({
+  dataStore,
+}: ContextProps): Promise<void> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+  await repository.delete({});
+}

package/src/entities/document/update-document.ts

@@ -0,0 +1,25 @@
+import { ContextProps, WalletDocument } from '../../types';
+import { saveOptions, toDocumentEntity } from './helpers';
+import { DocumentEntity } from './document.entity';
+import { logger } from '../../logger';
+
+/**
+ * Update document
+ * @param dataStore
+ * @param document
+ */
+export async function updateDocument({
+  dataStore,
+  document,
+}: ContextProps & {document: WalletDocument}): Promise<WalletDocument> {
+  logger.debug(`Updating document with id ${document.id}`);
+
+  const repository = dataStore.db.getRepository(DocumentEntity);
+  const entity = await toDocumentEntity({
+    dataStore,
+    document,
+  });
+  await repository.save(entity, saveOptions);
+
+  return document;
+}

package/src/entities/document-type.entity.ts

@@ -0,0 +1,11 @@
+import {Entity, Column, PrimaryColumn, ManyToMany} from '../typeorm';
+import {DocumentEntity} from './document/document.entity';
+
+@Entity()
+export class DocumentTypeEntity {
+  @PrimaryColumn('text')
+  id: string;
+
+  @ManyToMany(() => DocumentEntity, document => document._typeRel)
+  documents: DocumentEntity[];
+}

package/src/entities/log.entity.ts

@@ -0,0 +1,46 @@
+import {Entity, Column, PrimaryColumn} from '../typeorm';
+import {ContextProps, DataStore} from '../types';
+
+@Entity()
+export class LogEntity {
+  @PrimaryColumn()
+  id: string;
+
+  @Column()
+  level: string;
+
+  @Column()
+  value: string;
+
+  @Column()
+  createdAt: Date;
+}
+
+export async function getLogs({
+  dataStore,
+}: {
+  dataStore: DataStore;
+}): Promise<LogEntity[]> {
+  const repository = dataStore.db.getRepository(LogEntity);
+  const entities = await repository.find({
+    order: {
+      createdAt: 'DESC',
+    },
+  });
+
+  return entities;
+}
+
+export async function createLog({
+  dataStore,
+  log,
+}: {
+  dataStore: DataStore;
+  log: LogEntity,
+}): Promise<LogEntity> {
+  const repository = dataStore.db.getRepository(LogEntity);
+
+  log.createdAt = new Date();
+
+  return repository.save(log);
+}

package/src/entities/network.entity.ts

@@ -0,0 +1,14 @@
+import {Entity, Column, PrimaryColumn} from '../typeorm';
+import {ContextProps} from '../types';
+
+@Entity()
+export class NetworkEntity {
+  @PrimaryColumn()
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  configs: string;
+}

package/src/entities/transaction.entity.ts

@@ -0,0 +1,67 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm';
+import { DataStore } from '../types';
+
+@Entity()
+export class TransactionEntity {
+  @PrimaryColumn()
+  id: string;
+
+  @Column({ nullable: true })
+  hash: string;
+
+  @Column({ default: 'transfer' })
+  type: string;
+
+  @Column({ nullable: true })
+  error: string;
+
+  @Column({ nullable: true })
+  metadata: string;
+
+  @Column()
+  date: Date;
+
+  @Column()
+  fromAddress: string;
+
+  @Column()
+  recipientAddress: string;
+
+  @Column({ nullable: true })
+  amount: string;
+
+  @Column()
+  feeAmount: string;
+
+  @Column({ default: 'testnet' })
+  network: string;
+
+  @Column()
+  status: string;
+
+  @Column({ default: false })
+  retrySucceeded: boolean;
+}
+
+export async function getLogs({
+  dataStore,
+}: {
+  dataStore: DataStore;
+}): Promise<TransactionEntity[]> {
+  const repository = dataStore.db.getRepository(TransactionEntity);
+  const entities = await repository.find({});
+
+  return entities;
+}
+
+export async function createTransaction({
+  dataStore,
+  transaction,
+}: {
+  dataStore: DataStore;
+  transaction: TransactionEntity,
+}): Promise<TransactionEntity> {
+  const repository = dataStore.db.getRepository(TransactionEntity);
+
+  return repository.save(transaction);
+}

package/src/entities/wallet.entity.ts

@@ -0,0 +1,37 @@
+import {Entity, Column, PrimaryGeneratedColumn, PrimaryColumn} from '../typeorm';
+import {ContextProps} from '../types';
+
+@Entity()
+export class WalletEntity {
+  @PrimaryColumn()
+  id: string;
+
+  @Column({
+    nullable: true,
+  })
+  version?: string;
+
+  @Column()
+  networkId: string;
+}
+
+export async function getWallet({
+  dataStore,
+}: ContextProps): Promise<WalletEntity> {
+  const result = await dataStore.db.getRepository(WalletEntity).find();
+  return result[0];
+}
+
+export function createWallet({dataStore}: ContextProps): Promise<WalletEntity> {
+  return dataStore.db.getRepository(WalletEntity).save({
+    id: 'configs',
+    ...dataStore,
+  });
+}
+
+export function updateWallet({dataStore}: ContextProps): Promise<WalletEntity> {
+  return dataStore.db.getRepository(WalletEntity).save({
+    id: 'configs',
+    ...dataStore,
+  });
+}

package/src/helpers.ts

@@ -0,0 +1,52 @@
+import {DataSource} from './typeorm';
+// import {SDKConfigsEntity} from './entities/data-store-configs.entity';
+import {logger} from './logger';
+import {DataStoreConfigs} from './types';
+import {NetworkEntity} from './entities/network.entity';
+import {DocumentEntity} from './entities/document/document.entity';
+import {DocumentTypeEntity} from './entities/document-type.entity';
+import {WalletEntity} from './entities/wallet.entity';
+import typeOrmMigrations from './migrations';
+import { LogEntity } from './entities/log.entity';
+import { TransactionEntity } from './entities/transaction.entity';
+
+export function documentHasType(document: any, type: string) {
+  if (Array.isArray(document.type)) {
+    return document.type.includes(type);
+  }
+
+  return document.type === type;
+}
+
+export function getDataSource(options: DataStoreConfigs) {
+  const dataSource = new DataSource({
+    type: (options.dbType as any) || 'sqlite',
+    database: options.databasePath,
+    entities: [WalletEntity, NetworkEntity, DocumentEntity, DocumentTypeEntity],
+    synchronize: process.env.NODE_ENV === 'test',
+    dropSchema: options.dropSchema,
+    driver: options.driver,
+    sqlJsConfig: options.sqlJsConfig,
+    migrationsRun: process.env.NODE_ENV !== 'test',
+    migrations: typeOrmMigrations,
+    ...(options.typeORMConfigs || {}),
+  });
+
+  return dataSource;
+}
+
+export async function initializeTypeORM(options: DataStoreConfigs) {
+  const dataSource = getDataSource(options);
+
+  await dataSource
+    .initialize()
+    .then(() => {
+      logger.debug('Data Source initialized successfully');
+    })
+    .catch(err => {
+      logger.error(`Error during Data Source initialization: ${err}`);
+      throw err;
+    });
+
+  return dataSource;
+}

package/src/index.ts

@@ -0,0 +1,83 @@
+import {initializeTypeORM} from './helpers';
+import {DataStore, DataStoreConfigs} from './types';
+import {migrate} from './migration';
+import {DEFAULT_CONFIGS} from './configs';
+import {logger} from './logger';
+import {DataSource} from './typeorm';
+import assert from 'assert';
+import {getWallet, updateWallet} from './entities/wallet.entity';
+import { getV1LocalStorage } from './migration/migration1/v1-data-store';
+import { getAllDocuments } from './entities/document';
+
+
+export const getLocalStorage = getV1LocalStorage;
+
+export async function updateNetwork({
+  dataStore,
+  networkId,
+}: {
+  dataStore: DataStore;
+  networkId: string;
+}): Promise<void> {
+  const network = dataStore.networks.find(item => item.id === networkId);
+
+  assert(!!network, `Invalid network id ${networkId}`);
+
+  dataStore.network = network;
+  dataStore.networkId = networkId;
+
+  await updateWallet({dataStore});
+}
+
+export async function createDataStore(
+  _options: DataStoreConfigs,
+): Promise<DataStore> {
+  const options: DataStoreConfigs = {
+    ...DEFAULT_CONFIGS,
+    ..._options,
+  };
+
+  if (!options.defaultNetwork) {
+    options.defaultNetwork = options.networks[0].id;
+  }
+
+  const dataSource: DataSource = await initializeTypeORM(options);
+  const dataStore: DataStore = {
+    db: dataSource,
+    networkId: options.defaultNetwork,
+    network: options.networks.find(item => item.id === options.defaultNetwork),
+    testNetworkId: options.testNetworkId,
+    mainNetworkId: options.mainNetworkId,
+    version: null,
+    networks: options.networks,
+    resolveDocumentNetwork: options.documentNetworkResolver,
+    setNetwork: (networkId: string) => {
+      logger.debug(`Setting network to ${networkId}`);
+      return updateNetwork({dataStore, networkId});
+    },
+  };
+
+  logger.debug('Data store initialized');
+
+  await migrate({dataStore});
+
+  const wallet = await getWallet({dataStore});
+  dataStore.networkId = wallet.networkId;
+  dataStore.network = options.networks.find(
+    item => item.id === wallet.networkId,
+  );
+
+  getAllDocuments({dataStore}).then(documents => {
+    logger.debug(`Wallet loaded with ${documents.length} documents`);
+  });
+
+  return dataStore;
+}
+
+/**
+ * Close the data store connection with the database
+ *
+ */
+export async function closeDataStore(dataStore: DataStore) {
+  await dataStore.db.destroy();
+}

package/src/logger.ts

@@ -0,0 +1,37 @@
+const ConsoleTransport = {
+  log: (message: string) => {
+    console.log(message);
+  },
+  error: (message: string) => {
+    console.error(message);
+  },
+  debug: (message: string) => {
+    console.debug(message);
+  },
+  warn: (message: string) => {
+    console.warn(message);
+  },
+};
+
+export let logger = ConsoleTransport;
+
+export function setLogger(impl: any) {
+  logger = impl;
+}
+
+export const createLogger = (prefix: string) => {
+  return {
+    log: (message: string) => {
+      logger.log(`[${prefix}] ${message}`);
+    },
+    error: (message: string) => {
+      logger.error(`[${prefix}] ${message}`);
+    },
+    debug: (message: string) => {
+      logger.debug(`[${prefix}] ${message}`);
+    },
+    warn: (message: string) => {
+      logger.warn(`[${prefix}] ${message}`);
+    },
+  };
+};

package/src/migration/bootstrap-tables.ts

@@ -0,0 +1,5 @@
+import {DataSource} from '../typeorm';
+
+export function bootstrapTables(dataSource: DataSource) {
+  // will be generated from typeorm once the schema is defined
+}

package/src/migration/index.ts

@@ -0,0 +1,53 @@
+import {isRunningOnV1DataStore, migration1} from './migration1';
+import {ContextProps} from '../types';
+import {logger} from '../logger';
+import {createWallet, getWallet, updateWallet} from '../entities/wallet.entity';
+import {bootstrapTables} from './bootstrap-tables';
+
+export const CURRENT_DATA_STORE_VERSION = 'v2';
+
+export type MigrationResult = {
+  migrated: boolean;
+  version: string;
+};
+
+const migrations = [
+  migration1,
+  // add new migrations here
+];
+
+export async function migrate({dataStore}: ContextProps) {
+  // bootstrap v2 data
+  await bootstrapTables(dataStore.db);
+
+  // Fetch existing configs from the database
+  let existingConfigs = await getWallet({dataStore});
+
+  // Force v1 migration
+  // dataStore.version = 'v1';
+  // If no configs exist, create a new one
+  if (!existingConfigs) {
+    logger.debug('Wallet not found in the database, creating a new wallet...');
+    const isV1DataStore = await isRunningOnV1DataStore({dataStore});
+    logger.debug(`Is v1 data store: ${isV1DataStore}`);
+    dataStore.version = isV1DataStore ? 'v1' : CURRENT_DATA_STORE_VERSION;
+    await createWallet({
+      dataStore,
+    });
+    logger.debug('universal wallet created');
+  }
+
+  for (const migrate of migrations) {
+    const results = await migrate({dataStore});
+
+    if (results.migrated) {
+      logger.debug('Migration completed');
+      dataStore.version = results.version;
+      await updateWallet({dataStore});
+    } else {
+      logger.debug('Migration not required');
+    }
+  }
+
+  logger.debug(`DataStore version: ${dataStore.version}`);
+}

package/src/migration/migration1/index.ts

@@ -0,0 +1,64 @@
+import {getV1LocalStorage, getWalletDocuments} from './v1-data-store';
+import {logger} from '../../logger';
+import {migrateV1Data} from './migrate-v1-data';
+import {MigrationResult} from '../index';
+import {ContextProps} from '../../types';
+
+/**
+ * Migrate from v1 to v2
+ *
+ * v1 data store is stored in local storage
+ * v2 will store on typeorm
+ *
+ */
+export async function migration1({
+  dataStore,
+}: ContextProps): Promise<MigrationResult> {
+  logger.debug('Checking if v1 migration is required');
+
+  if (dataStore.version !== 'v1') {
+    logger.debug('v1 data migration NOT required');
+    return {
+      migrated: false,
+      version: dataStore.version,
+    };
+  }
+
+  logger.debug('v1 data Migration required');
+
+  await migrateV1Data({dataStore});
+
+  return {
+    migrated: true,
+    version: 'v2',
+  };
+}
+
+/**
+ * Check if a migration from v2 is required
+ * Once v2 is migrated, the local storage entry will be removed
+ */
+export async function isRunningOnV1DataStore({
+  dataStore,
+}: ContextProps): Promise<boolean> {
+  // If sdk version is defined, can skip migration
+  if (dataStore.version) {
+    return false;
+  }
+
+  const v1LocalStorage = getV1LocalStorage();
+
+  if (!v1LocalStorage) {
+    logger.debug('v1 local storage not found');
+    return false;
+  }
+
+  const documents = await getWalletDocuments();
+
+  if (documents.length === 0) {
+    logger.debug('no documents found on v1 data store');
+    return false;
+  }
+
+  return true;
+}

package/src/migration/migration1/migrate-v1-data.ts

@@ -0,0 +1,57 @@
+import {getV1LocalStorage} from './v1-data-store';
+import {createDocument} from '../../entities/document';
+import {documentHasType} from '../../helpers';
+
+export async function importUniversalWalletDocuments({documents, dataStore}) {
+  for (const _document of documents) {
+    let document = _document;
+    if (documentHasType(document, 'VerifiableCredential') && document.value) {
+      document = document.value;
+    }
+
+    try {
+      await createDocument({
+        dataStore,
+        json: document,
+      });
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+async function migrateDocuments({v1Storage, dataStore}) {
+  const walletJSON = await v1Storage.getItem('wallet');
+  const wallet = JSON.parse(walletJSON);
+
+  const documents = Object.keys(wallet).map(key => wallet[key]);
+
+  await importUniversalWalletDocuments({documents, dataStore});
+}
+
+function migrateNotificaions() {}
+
+function migrateDevSettings() {}
+
+function migrateTransactions() {
+  // Will skip this migration for performance improvements
+  // That would require Realm db as dependency
+  // We can drop the realm.db dependency from the wallet-sdk
+  // Transactions will be pulled from subscan into in the new data-store automatically
+}
+
+export async function migrateV1Data({dataStore}) {
+  const v1Storage = getV1LocalStorage();
+
+  await migrateDocuments({
+    v1Storage,
+    dataStore,
+  });
+  await migrateNotificaions();
+  await migrateDevSettings();
+  await migrateTransactions();
+
+  // remove localStorage entries
+  const walletJSON = await v1Storage.getItem('wallet');
+  await v1Storage.setItem('wallet-backup', walletJSON);
+  await v1Storage.removeItem('wallet');
+}

package/src/migration/migration1/v1-data-store.ts

@@ -0,0 +1,39 @@
+import assert from 'assert';
+
+export type LocalStorage = {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+};
+
+let _localStorage: LocalStorage;
+
+/**
+ * Legacy data-store was based on AsyncLocalStorage
+ * The wallet will inject its implementation here, so that the migration scripts can use it
+ *
+ * @param _impl
+ */
+export function setV1LocalStorage(_impl: LocalStorage) {
+  assert(!!_impl, 'LocalStorage implementation is required');
+
+  _localStorage = _impl;
+}
+
+export function getV1LocalStorage(): LocalStorage {
+  return _localStorage;
+}
+
+export async function getWalletDocuments() {
+  const jsonData = await _localStorage.getItem('wallet');
+
+  if (!jsonData) {
+    return [];
+  }
+
+  const wallet = JSON.parse(jsonData as string);
+
+  return Object.keys(wallet).map(key => {
+    return wallet[key];
+  });
+}