@learncard/core 9.4.24 → 9.4.25

package/src/wallet/plugins/index.ts

@@ -0,0 +1,3 @@
+export * from './test-cache';
+export * from './test-index';
+export * from './test-storage';

package/src/wallet/plugins/test-cache/index.ts

@@ -0,0 +1,67 @@
+import { CredentialRecord, StoredCredentialEnvelope, VC, VP } from '@learncard/types';
+import { TestCachePlugin } from './types';
+
+export const getTestCache = (): TestCachePlugin => {
+    let index: Record<string, CredentialRecord[]> = {};
+    let paginatedIndex: Record<
+        string,
+        { records: CredentialRecord[]; hasMore: boolean; cursor?: string }
+    > = {};
+    let vcs: Record<string, VC | VP | StoredCredentialEnvelope | undefined> = {};
+
+    return {
+        name: 'Test Cache',
+        displayName: 'Test Cache',
+        description: '[Testing] Tests Caching Implementation',
+        cache: {
+            getIndex: async (_learnCard, name, query) => {
+                _learnCard.debug?.('Test Cache, getIndex', { name, query, value: index });
+                return index[name];
+            },
+            setIndex: async (_learnCard, name, query, value) => {
+                _learnCard.debug?.('Test Cache, setIndex', { name, query, value });
+                index[name] = value as any;
+                return true;
+            },
+            getIndexPage: async (_learnCard, name, query, paginationOptions) => {
+                _learnCard.debug?.('Test Cache, getIndex', {
+                    name,
+                    query,
+                    paginationOptions,
+                    value: index,
+                });
+                return paginatedIndex[name];
+            },
+            setIndexPage: async (_learnCard, name, query, value, paginationOptions) => {
+                _learnCard.debug?.('Test Cache, setIndex', {
+                    name,
+                    query,
+                    paginationOptions,
+                    value,
+                });
+                paginatedIndex[name] = value as any;
+                return true;
+            },
+            flushIndex: async _learnCard => {
+                _learnCard.debug?.('Test Cache, flushIndex');
+                index = {};
+                return true;
+            },
+            getVc: async (_learnCard, uri) => {
+                _learnCard.debug?.('Test Cache, getVc', { uri, value: vcs[uri] });
+                return vcs[uri];
+            },
+            setVc: async (_learnCard, uri, vc) => {
+                _learnCard.debug?.('Test Cache, setVc', { uri, value: vc });
+                vcs[uri] = vc;
+                return true;
+            },
+            flushVc: async _learnCard => {
+                _learnCard.debug?.('Test Cache, flushVc');
+                vcs = {};
+                return true;
+            },
+        },
+        methods: {},
+    };
+};

package/src/wallet/plugins/test-cache/types.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../../../types/wallet';
+
+export type TestCachePlugin = Plugin<'Test Cache', 'cache'>;

package/src/wallet/plugins/test-index/index.ts

@@ -0,0 +1,37 @@
+import { CredentialRecord, VC } from '@learncard/types';
+import { TestIndexPlugin } from './types';
+
+export const getTestIndex = (): TestIndexPlugin => {
+    let index: CredentialRecord[] = [];
+
+    return {
+        name: 'Test Index',
+        displayName: 'Test Index',
+        description: '[Testing] Tests Index Implementations',
+        index: {
+            get: async (_learnCard, query) => {
+                _learnCard.debug?.('Test Storage, index, get', { query });
+
+                return index;
+            },
+            add: async (_learnCard, record) => {
+                _learnCard.debug?.('Test Storage, index, add', { record });
+
+                index.push(record);
+
+                return true;
+            },
+            update: async () => false, // TODO: Implement
+            remove: async (_learnCard, id) => {
+                _learnCard.debug?.('Test Storage, index, remove', { id });
+
+                let recordIndex = index.findIndex(record => record.id === id);
+
+                index.splice(recordIndex, 1);
+
+                return true;
+            },
+        },
+        methods: {},
+    };
+};

package/src/wallet/plugins/test-index/types.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../../../types/wallet';
+
+export type TestIndexPlugin = Plugin<'Test Index', 'index'>;

package/src/wallet/plugins/test-storage/index.ts

@@ -0,0 +1,82 @@
+import { CredentialRecord, StoredCredentialEnvelope, VC, VP } from '@learncard/types';
+import { TestStoragePlugin } from './types';
+
+type StoredItem = VC | VP | StoredCredentialEnvelope;
+
+export const getTestStorage = (): TestStoragePlugin => {
+    const index: CredentialRecord[] = [];
+    const vcs: StoredItem[] = [];
+
+    return {
+        name: 'Test Storage',
+        displayName: 'Test Storage',
+        description: '[Testing] Tests Storage Implementations',
+        read: {
+            get: async (_learnCard, uri) => {
+                _learnCard.debug?.('Test Storage, read, get', { uri });
+
+                if (!uri) return undefined;
+
+                const [_lc, method, vcIndex] = uri.split(':');
+
+                if (method !== 'test') return undefined;
+
+                return vcs[Number.parseInt(vcIndex)];
+            },
+        },
+        store: {
+            upload: async (_learnCard, vc) => {
+                _learnCard.debug?.('Test Storage, store, upload', { vc });
+
+                const vcIndex = vcs.length;
+
+                vcs.push(vc);
+
+                return `lc:test:${vcIndex}`;
+            },
+            delete: async (_learnCard, uri) => {
+                _learnCard.debug?.('Test Storage, store, delete', { uri });
+
+                if (!uri) return false;
+
+                const [_lc, method, vcIndex] = uri.split(':');
+
+                if (method !== 'test') return false;
+
+                const vcIdx = Number.parseInt(vcIndex);
+
+                if (vcIdx >= 0 && vcIdx < vcs.length) {
+                    vcs[vcIdx] = undefined as unknown as StoredItem;
+                    return true;
+                }
+
+                return false;
+            },
+        },
+        index: {
+            get: async (_learnCard, query) => {
+                _learnCard.debug?.('Test Storage, index, get', { query });
+
+                return index;
+            },
+            add: async (_learnCard, record) => {
+                _learnCard.debug?.('Test Storage, index, add', { record });
+
+                index.push(record);
+
+                return true;
+            },
+            update: async () => false, // TODO: Implement
+            remove: async (_learnCard, id) => {
+                _learnCard.debug?.('Test Storage, index, remove', { id });
+
+                const recordIndex = index.findIndex(record => record.id === id);
+
+                index.splice(recordIndex, 1);
+
+                return true;
+            },
+        },
+        methods: {},
+    };
+};

package/src/wallet/plugins/test-storage/types.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../../../types/wallet';
+
+export type TestStoragePlugin = Plugin<'Test Storage', 'read' | 'store' | 'index'>;