@docknetwork/wallet-sdk-data-store 0.4.1

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@docknetwork/wallet-sdk-data-store",
+  "version": "0.4.1",
+  "license": "LICENSE",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/docknetwork/react-native-sdk",
+    "directory": "packages/data-store"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "peerDependencies": {
+    "typeorm": "^0.3.15"
+  },
+  "dependencies": {
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "jest": "29.1.0",
+    "ts-jest": "29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4",
+    "typeorm": "^0.3.15",
+    "sqlite3": "^5.0.2",
+    "reflect-metadata": "^0.1.13"
+  }
+}

package/scripts/publish.sh

@@ -0,0 +1,3 @@
+yarn build
+npm publish --access public
+

package/src/__tests__/index.test.ts

@@ -0,0 +1,56 @@
+import {
+  createTestDataStore,
+  createV1EmptyDataStore,
+  setupV1MockDataStore,
+} from '../../test/test-utils';
+import {getV1LocalStorage} from '../migration/migration1/v1-data-store';
+import {CURRENT_DATA_STORE_VERSION} from '../migration';
+import {DataStore} from '../types';
+import {WalletEntity, getWallet} from '../entities/wallet.entity';
+import {closeDataStore} from '../index';
+
+describe('Data store', () => {
+  describe('v2-data-store migration', () => {
+    let dataStore: DataStore;
+
+    beforeAll(async () => {
+      await setupV1MockDataStore();
+      dataStore = await createTestDataStore();
+    });
+
+    it('should remove wallet json from local storage', async () => {
+      const jsonData = await getV1LocalStorage().getItem('wallet');
+      expect(jsonData).toBeUndefined();
+    });
+
+    it('should create DataStoreConfigs', async () => {
+      const configs = await getWallet({dataStore});
+      expect(configs).toBeDefined();
+      expect(configs.networkId).toBe('mainnet');
+      expect(configs.version).toBe(CURRENT_DATA_STORE_VERSION);
+    });
+
+    afterAll(() => {
+      closeDataStore(dataStore);
+    });
+  });
+
+  describe('empty wallet migration', () => {
+    let dataStore: DataStore;
+
+    beforeAll(async () => {
+      await createV1EmptyDataStore();
+      dataStore = await createTestDataStore();
+    });
+
+    it('should create SDKConfigs', async () => {
+      const configs = await getWallet({dataStore});
+      expect(configs.networkId).toBe('mainnet');
+      expect(configs.version).toBe(CURRENT_DATA_STORE_VERSION);
+    });
+
+    afterAll(() => {
+      closeDataStore(dataStore);
+    });
+  });
+});

package/src/__tests__/v1-data-store.test.ts

@@ -0,0 +1,24 @@
+import {setupV1MockDataStore} from '../../test/test-utils';
+import {
+  getV1LocalStorage,
+  getWalletDocuments,
+} from '../migration/migration1/v1-data-store';
+import _walletJSON from '../../test/wallet.json';
+
+describe('v2-data-store', () => {
+  beforeAll(async () => {
+    await setupV1MockDataStore();
+  });
+
+  it('should have access to v2 localStorage', async () => {
+    const jsonData = await getV1LocalStorage().getItem('wallet');
+    expect(jsonData).toBeDefined();
+    const wallet = JSON.parse(jsonData as string);
+    expect(wallet).toStrictEqual(_walletJSON);
+  });
+
+  it('should be able to fetch v2 documents', async () => {
+    const documents = await getWalletDocuments();
+    expect(documents.length).toBeGreaterThan(1);
+  });
+});

package/src/configs.ts

@@ -0,0 +1,28 @@
+import {DataStoreConfigs} from './types';
+import {genericDocumentNetworkResolver} from './document-network-resolver';
+
+export const DEFAULT_CONFIGS: DataStoreConfigs = {
+  dbType: 'sqlite',
+  databasePath: 'dock-wallet-sdk.db',
+  documentNetworkResolver: genericDocumentNetworkResolver,
+  networks: [
+    {
+      name: 'Mainnet',
+      id: 'mainnet',
+      credentialHostnames: ['creds.dock.io'],
+      configs: {
+        substrateUrl: 'wss://mainnet-node.dock.io',
+        addressPrefix: 22,
+      },
+    },
+    {
+      name: 'Testnet',
+      id: 'testnet',
+      credentialHostnames: ['creds-testnet.dock.io', 'creds-staging.dock.io'],
+      configs: {
+        substrateUrl: 'wss://knox-1.dock.io',
+        addressPrefix: 21,
+      },
+    },
+  ],
+};

package/src/document-network-resolver.ts

@@ -0,0 +1,19 @@
+import {
+  DataStore,
+  DocumentNetworkResolver,
+  DocumentResolverProps,
+  DocumentResolverResult,
+  WalletDocument,
+} from './types';
+
+type ResolverResult = string | null;
+
+export const genericDocumentNetworkResolver: DocumentNetworkResolver = async ({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<DocumentResolverResult> => {
+  return {
+    networkId: dataStore.networkId,
+    isFallback: true,
+  };
+};

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

@@ -0,0 +1,72 @@
+import {ContextProps, WalletDocument} from '../../types';
+import {v4 as uuid} from 'uuid';
+import {DocumentEntity} from './document.entity';
+import {getOrCreateDocumentTypes, saveOptions} from './helpers';
+import {getDocumentById} from './get-document-by-id';
+import {logger} from '../../logger';
+
+/**
+ * Create document
+ * @param dataStore
+ * @param json
+ */
+export async function createDocument({
+  dataStore,
+  json,
+}: ContextProps & {
+  json: any;
+}): Promise<WalletDocument> {
+  logger.debug(`Creating document with id ${json.id}...`);
+
+  if (json.id) {
+    const existingDocument = await getDocumentById({
+      dataStore,
+      id: json.id,
+    });
+
+    if (existingDocument) {
+      logger.debug(`Document with id ${json.id} already exists`);
+      throw new Error(`Document with id ${json.id} already exists`);
+    }
+  }
+
+  const _typeRel = await getOrCreateDocumentTypes({
+    dataStore,
+    types: json.type,
+  });
+
+  if (!json.id) {
+    json.id = uuid();
+  }
+
+  let networkId;
+
+  if (json._networkId) {
+    networkId = json._networkId;
+    delete json._networkId;
+  } else {
+    const resolution = await dataStore.resolveDocumentNetwork({
+      document: json,
+      dataStore,
+    });
+
+    networkId = resolution.networkId;
+  }
+
+  const entity: DocumentEntity = {
+    networkId,
+    id: json.id,
+    type: json.type,
+    _typeRel,
+    correlation: json.correlation || [],
+    data: JSON.stringify(json),
+  };
+
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const result = await repository.save(entity, saveOptions);
+
+  logger.debug(`Document added to the wallet`);
+
+  return result;
+}

package/src/entities/document/decument.entity.test.ts

@@ -0,0 +1,135 @@
+import {DocumentEntity} from './document.entity';
+import {createTestDataStore} from '../../../test/test-utils';
+import {DataStore} from '../../types';
+import {createDocument} from './create-document';
+import {getDocumentsByType} from './get-documens-by-type';
+import {getDocumentById} from './get-document-by-id';
+import {getDocumentCorrelations} from './get-document-correlations';
+
+const mockDocuments = [
+  {
+    '@context': [
+      'https://www.w3.org/2018/credentials/v1',
+      'https://www.w3.org/2018/credentials/examples/v1',
+    ],
+    id: 'http://example.gov/credentials/test',
+    type: ['VerifiableCredential', 'UniversityDegreeCredential'],
+    issuer: {
+      id: 'did:example:123456789abcdefghi',
+    },
+    issuanceDate: '2020-03-10T04:24:12.164Z',
+    credentialSubject: {
+      id: 'did:example:ebfeb1f712ebc6f1c276e12ec21',
+      degree: {
+        type: 'BachelorDegree',
+        name: 'Bachelor of Science and Arts',
+      },
+    },
+  },
+  {
+    '@context': [
+      'https://www.w3.org/2018/credentials/v1',
+      'https://www.w3.org/2018/credentials/examples/v1',
+    ],
+    id: 'http://example.gov/credentials/test2',
+    type: ['VerifiableCredential', 'BasicCredential'],
+    issuer: {
+      id: 'did:example:123456789abcdefghi',
+    },
+    issuanceDate: '2020-03-10T04:24:12.164Z',
+    credentialSubject: {
+      id: 'did:example:ebfeb1f712ebc6f1c276e12ec21',
+      name: 'Testing',
+    },
+  },
+  {
+    '@context': ['https://w3id.org/wallet/v1'],
+    id: 'urn:uuid:c410e44a-9525-11ea-bb37-0242ac130002',
+    name: 'My Ropsten Mnemonic 1',
+    image: 'https://via.placeholder.com/150',
+    description: 'For testing only, totally compromised.',
+    tags: ['professional', 'organization', 'compromised'],
+    correlation: [],
+    type: 'Mnemonic',
+    value:
+      'humble piece toy mimic miss hurdle smile awkward patch drama hurry mixture',
+  },
+  {
+    '@context': ['https://w3id.org/wallet/v1'],
+    id: 'c47f3ed0-b4b5-4983-8962-759196fd3ece',
+    type: 'Currency',
+    value: 0,
+    symbol: 'DOCK',
+  },
+  {
+    '@context': ['https://w3id.org/wallet/v1'],
+    id: '37NKEP14n9omsAgxJ3sn14XtHo2vs5a34UcpCyybXQJoUQ92',
+    type: 'Address',
+    value: '37NKEP14n9omsAgxJ3sn14XtHo2vs5a34UcpCyybXQJoUQ92',
+    address: '37NKEP14n9omsAgxJ3sn14XtHo2vs5a34UcpCyybXQJoUQ92',
+    name: 'Test',
+    correlation: [
+      'urn:uuid:c410e44a-9525-11ea-bb37-0242ac130002',
+      'c47f3ed0-b4b5-4983-8962-759196fd3ece',
+    ],
+  },
+];
+
+describe('DocumentEntity', () => {
+  let dataStore: DataStore;
+
+  beforeAll(async () => {
+    dataStore = await createTestDataStore();
+
+    for (const document of mockDocuments) {
+      await createDocument({
+        dataStore,
+        json: document,
+      });
+    }
+  });
+
+  it('should be able to find a document by id', async () => {
+    const mockData = mockDocuments[0];
+    const document = await getDocumentById({
+      dataStore,
+      id: mockData.id,
+    });
+    expect(document).toBeDefined();
+    expect(document.type).toEqual(mockData.type);
+  });
+
+  describe('getDocumentsByType', () => {
+    it('should be able to query all VerifiableCredential', async () => {
+      const documents = await getDocumentsByType({
+        dataStore,
+        type: 'VerifiableCredential',
+      });
+
+      expect(documents).toBeDefined();
+      expect(documents.length).toEqual(2);
+    });
+
+    it('should be able query only BasicCredential', async () => {
+      const documents = await getDocumentsByType({
+        dataStore,
+        type: 'BasicCredential',
+      });
+
+      expect(documents).toBeDefined();
+      expect(documents.length).toEqual(1);
+    });
+  });
+
+  describe('getDocumentCorrelations', () => {
+    it('expect to query all correlations', async () => {
+      const documents = await getDocumentCorrelations({
+        dataStore,
+        documentId: '37NKEP14n9omsAgxJ3sn14XtHo2vs5a34UcpCyybXQJoUQ92',
+      });
+
+      expect(documents).toBeDefined();
+      expect(documents.length).toEqual(2);
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import {
+  Column,
+  Entity,
+  JoinTable,
+  ManyToMany,
+  PrimaryColumn,
+  Relation,
+} from '../../typeorm';
+import {DocumentTypeEntity} from '../document-type.entity';
+
+@Entity()
+export class DocumentEntity {
+  @PrimaryColumn('text')
+  id: string;
+
+  @Column('text', {
+    nullable: true,
+  })
+  networkId: string;
+
+  @Column('simple-array')
+  type: string[];
+
+  @ManyToMany(() => DocumentTypeEntity, type => type?.documents, {
+    cascade: ['insert'],
+    eager: true,
+    nullable: true,
+  })
+  @JoinTable()
+  _typeRel: Relation<DocumentTypeEntity[]>;
+
+  // Add the ManyToMany self-referencing relationship to track document correlations
+  // @ManyToMany(() => DocumentEntity, {cascade: true, nullable: true})
+  // @JoinTable()
+  @Column('simple-array')
+  correlation: string[];
+
+  @Column('blob')
+  data: string;
+}

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

@@ -0,0 +1,39 @@
+import {WalletDocument, DataStore} from '../../types';
+import {toWalletDocument} from './helpers';
+import {DocumentEntity} from './document.entity';
+
+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[]> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+  const entities = await repository.find({
+    where: allNetworks
+      ? {}
+      : {
+          networkId: dataStore.networkId,
+        },
+  });
+
+  const mapDocument = allNetworks ? toWalletDocumentExpanded : toWalletDocument;
+
+  return Promise.all(entities.map(mapDocument));
+}

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

@@ -0,0 +1,30 @@
+import {ContextProps, WalletDocument} from '../../types';
+import {DocumentEntity} from './document.entity';
+import {createQueryBuilder} from '../../typeorm';
+import {toWalletDocument} from './helpers';
+
+/**
+ * Get documents by type
+ * @param dataStore
+ * @param type
+ */
+export async function getDocumentsByType({
+  dataStore,
+  type,
+}: ContextProps & {
+  type: string;
+}): Promise<WalletDocument[]> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const documents = repository
+    .createQueryBuilder('document')
+    .leftJoinAndSelect('document._typeRel', 'documentType')
+    .where('documentType.id = :type', {type})
+    .andWhere('document.networkId = :networkId', {
+      networkId: dataStore.networkId,
+    });
+
+  const result = await documents.getMany();
+
+  return result.map(toWalletDocument);
+}

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

@@ -0,0 +1,45 @@
+import {ContextProps, WalletDocument} from '../../types';
+import {toWalletDocument} from './helpers';
+import {DocumentEntity} from './document.entity';
+import {In} from 'typeorm';
+
+/**
+ * Get document by id
+ * @param dataStore
+ * @param id
+ */
+export async function getDocumentById({
+  dataStore,
+  id,
+}: ContextProps & {
+  id: string;
+}): Promise<WalletDocument> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const entity = await repository.findOne({
+    where: {
+      id: id,
+      networkId: dataStore.networkId,
+    },
+  });
+
+  return toWalletDocument(entity);
+}
+
+export async function getDocumentsById({
+  dataStore,
+  idList,
+}: ContextProps & {
+  idList: string[];
+}): Promise<WalletDocument> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const entities = await repository.find({
+    where: {
+      id: In(idList),
+      networkId: dataStore.networkId,
+    },
+  });
+
+  return entities.map(toWalletDocument);
+}

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

@@ -0,0 +1,34 @@
+import {ContextProps, WalletDocument} from '../../types';
+import {DocumentEntity} from './document.entity';
+import {In} from '../../typeorm';
+import {toWalletDocument} from './helpers';
+
+/**
+ * Get related documents
+ * @param dataStore
+ * @param type
+ */
+export async function getDocumentCorrelations({
+  dataStore,
+  documentId,
+}: ContextProps & {
+  documentId: string;
+}): Promise<WalletDocument[]> {
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const entity = await repository.findOne({
+    where: {
+      id: documentId,
+      networkId: dataStore.networkId,
+    },
+  });
+
+  const data = await repository.find({
+    where: {
+      id: In(entity.correlation),
+      networkId: dataStore.networkId,
+    },
+  });
+
+  return data.map(toWalletDocument);
+}

package/src/entities/document/helpers.ts

@@ -0,0 +1,115 @@
+import {ContextProps, WalletDocument} from '../../types';
+import {DocumentTypeEntity} from '../document-type.entity';
+import assert from 'assert';
+import {logger} from '../../logger';
+import {DocumentEntity} from './document.entity';
+import {In} from '../../typeorm';
+
+/**
+ * Get document by id
+ * @param dataStore
+ * @param types
+ */
+export async function getOrCreateDocumentTypes({
+  dataStore,
+  types,
+}: ContextProps & {
+  types: string | string[];
+}): Promise<DocumentTypeEntity[]> {
+  assert(!!types, 'Document type must be provided');
+
+  logger.debug(`getOrCreateDocumentTypes: ${JSON.stringify(types)}`);
+
+  if (!Array.isArray(types)) {
+    types = [types];
+  }
+ 
+  const typeRepository = dataStore.db.getRepository(DocumentTypeEntity);
+  const typeEntityList = [];
+
+  for (const type of types) {
+    let typeEntity = await typeRepository.findOne({
+      where: {
+        id: type,
+      },
+    });
+
+    if (!typeEntity) {
+      typeEntity = typeRepository.create({
+        id: type,
+      });
+
+      await typeRepository.save(typeEntity);
+    }
+
+    typeEntityList.push(typeEntity);
+  }
+
+  return typeEntityList;
+}
+
+export async function findDocumentEntitiesById({
+  dataStore,
+  entityIds,
+}: ContextProps & {
+  entityIds: string[];
+}): Promise<DocumentEntity[]> {
+  assert(!!entityIds, 'Document ids must be provided');
+  const repository = dataStore.db.getRepository(DocumentEntity);
+
+  const entities = await repository.findBy({
+    id: In(entityIds),
+  });
+
+  return entities;
+}
+
+/**
+ * Convert document entity to wallet document
+ * @param entity
+ */
+export function toWalletDocument(entity: DocumentEntity): WalletDocument {
+  if (!entity) {
+    return entity;
+  }
+
+  const result = JSON.parse(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 || [];
+  const _typeRel = await getOrCreateDocumentTypes({
+    dataStore,
+    types: document.type,
+  });
+
+  return {
+    id: document.id,
+    type: type,
+    data: JSON.stringify(document),
+    _typeRel,
+    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-documens-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';