@docknetwork/wallet-sdk-data-store-web 0.4.19

package/src/entities/document/get-all-documents.ts

@@ -0,0 +1,42 @@
+import {
+  WalletDocument,
+  DataStore,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {toWalletDocument} from './helpers';
+import {DocumentEntity} from './document.entity';
+import {localStorageJSON} from '../../localStorageJSON';
+
+function toWalletDocumentExpanded(entity: DocumentEntity): WalletDocument {
+  const result = toWalletDocument(entity);
+
+  if (result) {
+    result['_networkId'] = entity.networkId;
+  }
+
+  return result;
+}
+
+/**
+ * Get all documents
+ *
+ * @param dataStore
+ */
+export async function getAllDocuments({
+  dataStore,
+  allNetworks,
+}: {
+  dataStore: DataStore;
+  allNetworks?: boolean;
+}): Promise<WalletDocument[]> {
+  let entities = (await localStorageJSON.getItem('documents')) || [];
+
+  if (!allNetworks) {
+    entities = entities.filter(
+      (entity: DocumentEntity) => entity.networkId === dataStore.networkId,
+    );
+  }
+
+  const mapDocument = allNetworks ? toWalletDocumentExpanded : toWalletDocument;
+
+  return Promise.all(entities.map(mapDocument));
+}

package/src/entities/document/get-document-by-id.ts

@@ -0,0 +1,31 @@
+import {
+  ContextProps,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {getAllDocuments} from './get-all-documents';
+
+/**
+ * Get document by id
+ * @param dataStore
+ * @param id
+ */
+export async function getDocumentById({
+  dataStore,
+  id,
+}: ContextProps & {
+  id: string;
+}): Promise<WalletDocument> {
+  const allDocs = await getAllDocuments({dataStore, allNetworks: false});
+  return allDocs.find(doc => doc.id === id);
+}
+
+export async function getDocumentsById({
+  dataStore,
+  idList,
+}: ContextProps & {
+  idList: string[];
+}): Promise<WalletDocument> {
+  const allDocs = await getAllDocuments({dataStore, allNetworks: false});
+
+  return allDocs.filter(doc => idList.includes(doc.id));
+}

package/src/entities/document/get-document-correlations.ts

@@ -0,0 +1,22 @@
+import {
+  ContextProps,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {getAllDocuments} from './get-all-documents';
+
+/**
+ * Get related documents
+ * @param dataStore
+ * @param type
+ */
+export async function getDocumentCorrelations({
+  dataStore,
+  documentId,
+}: ContextProps & {
+  documentId: string;
+}): Promise<WalletDocument[]> {
+  const allDocs = await getAllDocuments({dataStore, allNetworks: false});
+  const entity = allDocs.find(doc => doc.id === documentId);
+
+  return allDocs.filter(doc => entity.correlation.includes(doc.id));
+}

package/src/entities/document/get-documents-by-type.ts

@@ -0,0 +1,21 @@
+import {
+  ContextProps,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {getAllDocuments} from './get-all-documents';
+
+/**
+ * Get documents by type
+ * @param dataStore
+ * @param type
+ */
+export async function getDocumentsByType({
+  dataStore,
+  type,
+}: ContextProps & {
+  type: string;
+}): Promise<WalletDocument[]> {
+  const allDocs = await getAllDocuments({dataStore, allNetworks: false});
+
+  return allDocs.filter(doc => doc.type === type || doc.type.includes(type));
+}

package/src/entities/document/helpers.ts

@@ -0,0 +1,50 @@
+import {ContextProps, WalletDocument} from '@docknetwork/wallet-sdk-data-store/src/types';
+import assert from 'assert';
+import {DocumentEntity} from './document.entity';
+
+
+
+/**
+ * Convert document entity to wallet document
+ * @param entity
+ */
+export function toWalletDocument(entity: DocumentEntity): WalletDocument {
+  if (!entity?.data) {
+    return entity;
+  }
+
+  const result: any = entity.data;
+
+  if (!result.id) {
+    result.id = entity.id;
+  }
+
+  return result;
+}
+
+/**
+ * Convert wallet document to document entity
+ * @param walletDocument
+ */
+export async function toDocumentEntity({
+  dataStore,
+  document,
+}: ContextProps & {
+  document: any;
+}): Promise<DocumentEntity> {
+  const type = document.type || [];
+
+  return {
+    id: document.id,
+    type: type,
+    data: document,
+    correlation: document.correlation || [],
+    networkId: dataStore.networkId,
+  } as DocumentEntity;
+}
+
+export const saveOptions = {
+  // Android is having issues when running multiple document saves in a short period of time
+  // We will disable transactions for now until we find a better solution
+  transaction: false,
+};

package/src/entities/document/index.ts

@@ -0,0 +1,9 @@
+export * from './document.entity';
+export * from './create-document';
+export * from './helpers';
+export * from './get-documents-by-type';
+export * from './get-document-by-id';
+export * from './get-all-documents';
+export * from './update-document';
+export * from './remove-document';
+export * from './get-document-correlations';

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

@@ -0,0 +1,43 @@
+import assert from 'assert';
+import {
+  ContextProps,
+  DataStoreEvents,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
+import {getAllDocuments} from './get-all-documents';
+import {localStorageJSON} from '../../localStorageJSON';
+
+/**
+ * Remove document
+ * @param dataStore
+ * @param id
+ */
+export async function removeDocument({
+  dataStore,
+  id,
+  options,
+}: ContextProps & {id: string; options?: any}): Promise<void> {
+  assert(!!id, 'Document id is required');
+
+  logger.debug(`Removing document with id ${id}`);
+  const allDocs = await getAllDocuments({dataStore, allNetworks: true});
+  const filteredDocs = allDocs.filter(
+    doc => doc.id !== id && doc.networkId !== dataStore.networkId,
+  );
+
+  localStorageJSON.setItem('documents', filteredDocs);
+
+  dataStore.events.emit(DataStoreEvents.DocumentDeleted, id);
+}
+
+/**
+ * Remove all documents
+ * @param dataStore
+ */
+export async function removeAllDocuments({
+  dataStore,
+}: ContextProps): Promise<void> {
+  localStorageJSON.setItem('documents', []);
+
+  dataStore.events.emit(DataStoreEvents.AllDocumentsDeleted);
+}

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

@@ -0,0 +1,36 @@
+import {
+  ContextProps,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {toDocumentEntity} from './helpers';
+import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
+import {localStorageJSON} from '../../localStorageJSON';
+
+/**
+ * Update document
+ * @param dataStore
+ * @param document
+ */
+export async function updateDocument({
+  dataStore,
+  document,
+}: ContextProps & {
+  document: WalletDocument;
+  options?: any;
+}): Promise<WalletDocument> {
+  logger.debug(`Updating document with id ${document.id}`);
+
+  const allDocs = (await localStorageJSON.getItem('documents')) || [];
+  const index = allDocs.findIndex(doc => doc.id === document.id);
+
+  allDocs[index] = await toDocumentEntity({
+    dataStore,
+    document,
+  });
+
+  await localStorageJSON.setItem('documents', allDocs);
+
+  dataStore.events.emit('DocumentUpdated', document);
+
+  return document;
+}

package/src/entities/log.entity.ts

@@ -0,0 +1,26 @@
+import {DataStore} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {localStorageJSON} from '../localStorageJSON';
+
+export interface LogEntity {
+  id: string;
+  level: string;
+  value: string;
+  createdAt: Date;
+}
+
+export async function getLogs(): Promise<LogEntity[]> {
+  return localStorageJSON.getItem('logs') || [];
+}
+
+export async function createLog({
+  log,
+}: {
+  dataStore: DataStore;
+  log: LogEntity;
+}): Promise<LogEntity> {
+  log.createdAt = new Date();
+
+  const logs = await getLogs();
+
+  return localStorageJSON.setItem('logs', [...logs, log]);
+}

package/src/entities/network.entity.ts

@@ -0,0 +1,5 @@
+export interface NetworkEntity {
+  id: string;
+  name: string;
+  configs: string;
+}

package/src/entities/wallet.entity.ts

@@ -0,0 +1,29 @@
+import {localStorageJSON} from '../localStorageJSON';
+import {ContextProps} from '@docknetwork/wallet-sdk-data-store/src/types';
+
+export interface WalletEntity {
+  id: string;
+  version?: string;
+  networkId: string;
+}
+
+export async function getWallet({
+  dataStore,
+}: ContextProps): Promise<WalletEntity> {
+  const result = await localStorageJSON.getItem('wallet');
+  return result;
+}
+
+export function createWallet({dataStore}: ContextProps): Promise<WalletEntity> {
+  return localStorageJSON.setItem('wallet', {
+    id: 'configs',
+    ...dataStore,
+  });
+}
+
+export function updateWallet({dataStore}: ContextProps): Promise<WalletEntity> {
+  return localStorageJSON.setItem('wallet', {
+    id: 'configs',
+    ...dataStore,
+  });
+}

package/src/index.ts

@@ -0,0 +1,134 @@
+import assert from 'assert';
+import {createWallet, getWallet, updateWallet} from './entities/wallet.entity';
+import {
+  createDocument,
+  getAllDocuments,
+  removeDocument,
+  getDocumentsById,
+  getDocumentsByType,
+  updateDocument,
+  getDocumentById,
+  removeAllDocuments,
+  getDocumentCorrelations,
+} from './entities/document';
+import {
+  createDataStore as createGenericDataStore,
+  parseConfigs,
+  setLocalStorage,
+} from '@docknetwork/wallet-sdk-data-store/src/index';
+
+import {
+  DataSource,
+  DataStore,
+  DataStoreConfigs,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import { logger } from '@docknetwork/wallet-sdk-data-store/src/logger';
+
+// setLocalStorage(global.localStorage);
+
+export async function createDataStore(
+  configs: DataStoreConfigs,
+): Promise<DataStore> {
+  const dataSource: DataSource = {
+    async destroy() {
+      return;
+    },
+    async initialize() {
+      return;
+    }
+  }
+
+  const dataStore = await createGenericDataStore({
+    configs: configs,
+    dataSource: dataSource as any,
+    documentStore: {
+      addDocument: async (json, options) => {
+        return createDocument({
+          dataStore,
+          json,
+          options,
+        });
+      },
+      removeDocument: async (id, options) => {
+        return removeDocument({
+          dataStore,
+          id,
+          options,
+        });
+      },
+      updateDocument: async (document, options) => {
+        return updateDocument({
+          dataStore,
+          document,
+          options,
+        });
+      },
+      getDocumentById: async id => {
+        return getDocumentById({
+          dataStore,
+          id,
+        });
+      },
+      getDocumentsByType: async type => {
+        return getDocumentsByType({
+          dataStore,
+          type,
+        });
+      },
+      getDocumentsById: async idList => {
+        return getDocumentsById({
+          dataStore,
+          idList,
+        });
+      },
+      getAllDocuments: async (allNetworks?: boolean) => {
+        return getAllDocuments({
+          allNetworks,
+          dataStore,
+        });
+      },
+      removeAllDocuments: async () => {
+        return removeAllDocuments({
+          dataStore,
+        });
+      },
+      getDocumentCorrelations: async documentId => {
+        return getDocumentCorrelations({
+          dataStore,
+          documentId,
+        });
+      },
+    },
+    localStorageImpl: global.localStorage,
+    walletStore: {
+      getWallet: async () => {
+        return getWallet({dataStore});
+      },
+      updateWallet: async () => {
+        return updateWallet({dataStore});
+      },
+    },
+  });
+
+  // await migrate({dataStore});
+
+  let wallet = await dataStore.wallet.getWallet();
+
+  if (!wallet) {
+    wallet = await createWallet({
+      dataStore,
+    });
+  }
+  
+  dataStore.networkId = wallet.networkId;
+  dataStore.network = dataStore.networks.find(
+    item => item.id === wallet.networkId,
+  );
+
+  dataStore.documents.getAllDocuments().then(documents => {
+    logger.debug(`Wallet loaded with ${documents.length} documents`);
+  });
+
+
+  return dataStore;
+}

package/src/localStorageJSON.ts

@@ -0,0 +1,24 @@
+let _localStorage;
+
+export const setLocalStorageImpl = (impl: any) => {
+  _localStorage = impl;
+};
+
+export const localStorageJSON = {
+  getItem: async (key: string) => {
+    const value = await _localStorage.getItem(key);
+    try {
+      return JSON.parse(value);
+    } catch (e) {
+      return value;
+    }
+  },
+  setItem: async (key: string, value: any) => {
+    const serializedValue = typeof value === "string" ? value : JSON.stringify(value);
+    await _localStorage.setItem(key, serializedValue);
+    return value;
+  },
+  removeItem: (key: string) => {
+    return _localStorage.removeItem(key);
+  },
+};

package/test/mock-local-storage.ts

@@ -0,0 +1,17 @@
+import {LocalStorage} from '../src/migration/migration1/v1-data-store';
+
+export const createMockLocalStorage = (): LocalStorage => {
+  let data: any = {};
+
+  return {
+    getItem: jest.fn(async key => {
+      return data[key];
+    }),
+    setItem: jest.fn(async (key, value) => {
+      data[key] = value;
+    }),
+    removeItem: jest.fn(async key => {
+      delete data[key];
+    }),
+  };
+};

package/test/test-utils.ts

@@ -0,0 +1,23 @@
+import {createMockLocalStorage} from './mock-local-storage';
+import walletJSON from './wallet.json';
+import {setV1LocalStorage} from '../src/migration/migration1/v1-data-store';
+import {createDataStore} from '../src';
+import {DataStore} from '../src/types';
+
+export async function setupV1MockDataStore(): Promise<void> {
+  const mockLocalStorage = createMockLocalStorage();
+  setV1LocalStorage(mockLocalStorage);
+  await mockLocalStorage.setItem('wallet', JSON.stringify(walletJSON));
+}
+
+export async function createV1EmptyDataStore() {
+  const mockLocalStorage = createMockLocalStorage();
+  setV1LocalStorage(mockLocalStorage);
+}
+
+export function createTestDataStore(): Promise<DataStore> {
+  return createDataStore({
+    dropSchema: true,
+    databasePath: ':memory:',
+  });
+}