@learncard/lca-api-plugin 1.2.16 → 1.2.18

package/src/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/test/index.test.ts

@@ -0,0 +1,38 @@
+import {
+    UnsignedVCValidator,
+    VC,
+    VCValidator,
+    UnsignedVPValidator,
+    VPValidator,
+} from '@learncard/types';
+
+import { initLCALearnCard, LCALearnCard } from '../';
+
+let learnCards: Record<
+    string,
+    {
+        learnCard: LCALearnCard;
+    }
+> = {};
+
+const getLearnCard = async (seed = 'a'.repeat(64)) => {
+    if (!learnCards[seed]) {
+
+        const learnCard = await initLCALearnCard({ seed });
+        learnCards[seed] = { learnCard: learnCard };
+    }
+
+    return {
+        ...learnCards[seed].learnCard,
+    };
+};
+
+// Skipping until LCA is up.
+describe.skip('LCA Plugin', () => {
+    describe('LCALearnCard', () => {
+        it('should work', async () => {
+            await expect(getLearnCard()).resolves.toBeDefined();
+        });
+    });
+});
+

package/src/types.ts

@@ -0,0 +1,396 @@
+import { z } from 'zod';
+import {
+    JWE,
+    DidDocument,
+    JWKWithPrivateKey,
+    VP,
+    LCNNotificationTypeEnumValidator,
+    LCNNotificationValidator,
+    LCNProfile,
+    LCNVisibleProfile,
+} from '@learncard/types';
+import { Plugin } from '@learncard/core';
+import { ProofOptions } from '@learncard/didkit-plugin';
+
+export type BoostSkills = {
+    category: string;
+    skill: string;
+    subskills: string[];
+};
+
+export const ScoutsSSOResponseSchema = z.object({
+    access_token: z.string(),
+    expires_in: z.number(),
+    'not-before-policy': z.number(),
+    refresh_expires_in: z.number(),
+    refresh_token: z.string(),
+    scope: z.string(),
+    session_state: z.string(),
+    token_type: z.string(),
+    error: z.string().optional(),
+    error_description: z.string().optional(),
+});
+export type ScoutSSOResponseType = z.infer<typeof ScoutsSSOResponseSchema>;
+
+const UserRecordSchema = z.object({
+    uid: z.string(),
+    email: z.string().nullable(),
+    emailVerified: z.boolean(),
+    displayName: z.string().nullable(),
+    phoneNumber: z.string().nullable(),
+    photoURL: z.string().nullable(),
+    disabled: z.boolean(),
+    providerData: z.array(
+        z.object({
+            uid: z.string(),
+            displayName: z.string().nullable(),
+            email: z.string().nullable(),
+            phoneNumber: z.string().nullable(),
+            photoURL: z.string().nullable(),
+            providerId: z.string(),
+        })
+    ),
+    metadata: z.object({
+        creationTime: z.string(),
+        lastSignInTime: z.string().nullable(),
+    }),
+    customClaims: z.record(z.string(), z.any()).optional(),
+});
+
+export type UserRecordType = z.infer<typeof UserRecordSchema>;
+
+// Zod Schema for Firebase Custom Token Response
+const FirebaseCustomAuthResponseSchema = z.object({
+    firebaseToken: z.string(),
+});
+
+export type FirebaseCustomAuthResponse = z.infer<typeof FirebaseCustomAuthResponseSchema>;
+
+// Zod Schema for Preferences
+export enum ThemeEnum {
+    Colorful = 'colorful',
+    Formal = 'formal',
+}
+
+export const PreferencesValidator = z.object({
+    theme: z.enum([ThemeEnum.Colorful, ThemeEnum.Formal]).optional(),
+    aiEnabled: z.boolean().optional(),
+    aiAutoDisabled: z.boolean().optional(),
+    analyticsEnabled: z.boolean().optional(),
+    analyticsAutoDisabled: z.boolean().optional(),
+    bugReportsEnabled: z.boolean().optional(),
+    isMinor: z.boolean().optional(),
+});
+
+export type PreferencesType = z.infer<typeof PreferencesValidator>;
+export type CreatePreferencesType = {
+    theme: ThemeEnum;
+};
+
+/** @group LCA API Plugin */
+export const SigningAuthorityValidator = z.object({
+    _id: z.string().optional(),
+    ownerDid: z.string(),
+    name: z.string(),
+    did: z.string().optional(),
+    endpoint: z.string().optional(),
+});
+
+/** @group LCA API Plugin */
+export type SigningAuthorityType = z.infer<typeof SigningAuthorityValidator>;
+
+/** @group LCA API Plugin */
+export type SigningAuthorityAuthorization = {
+    type: string;
+    boostUri: string;
+};
+
+/** These Types are Kept in Sync with LCA-API Service.
+ * TODO: Move into shared package
+ */
+
+/** @group LCA API Plugin */
+export const NotificationActionStatusEnumValidator = z.enum(['PENDING', 'COMPLETED', 'REJECTED']);
+
+export type NotificationActionStatusEnumType = z.infer<
+    typeof NotificationActionStatusEnumValidator
+>;
+
+/** @group LCA API Plugin */
+export const NotificationMetaValidator = z.object({
+    archived: z.boolean().optional(),
+    read: z.boolean().optional(),
+    actionStatus: NotificationActionStatusEnumValidator.optional(),
+});
+
+/** @group LCA API Plugin */
+export type NotificationMetaType = z.infer<typeof NotificationMetaValidator>;
+
+/** @group LCA API Plugin */
+export const NotificationQueryFiltersValidator = NotificationMetaValidator.extend({
+    type: LCNNotificationTypeEnumValidator.optional(),
+});
+
+/** @group LCA API Plugin */
+export type NotificationQueryFiltersType = z.infer<typeof NotificationQueryFiltersValidator>;
+
+// Paginated Notifications
+/** @group LCA API Plugin */
+export const NotificationsSortEnumValidator = z.enum(['CHRONOLOGICAL', 'REVERSE_CHRONOLOGICAL']);
+
+/** @group LCA API Plugin */
+export type NotificationsSortEnum = z.infer<typeof NotificationsSortEnumValidator>;
+
+/** @group LCA API Plugin */
+export const PaginatedNotificationsOptionsValidator = z.object({
+    limit: z.number(),
+    cursor: z.string().optional(),
+    sort: NotificationsSortEnumValidator.default(
+        NotificationsSortEnumValidator.enum.REVERSE_CHRONOLOGICAL
+    ),
+});
+
+/** @group LCA API Plugin */
+export type PaginatedNotificationsOptionsType = z.infer<
+    typeof PaginatedNotificationsOptionsValidator
+>;
+
+/** @group LCA API Plugin */
+export const NotificationValidator = LCNNotificationValidator.extend({
+    _id: z.string().optional(),
+    read: z.boolean(),
+    archived: z.boolean(),
+    actionStatus: NotificationActionStatusEnumValidator.optional(),
+});
+/** @group LCA API Plugin */
+export type NotificationType = z.infer<typeof NotificationValidator>;
+
+export const PaginatedNotificationsValidator = z.object({
+    cursor: z.string().optional(),
+    hasMore: z.boolean(),
+    notifications: NotificationValidator.array(),
+});
+
+export type PaginatedNotificationsType = z.infer<typeof PaginatedNotificationsValidator>;
+
+/** @group LCA API Plugin */
+export const NotificationQueryInputValidator = z
+    .object({
+        type: LCNNotificationTypeEnumValidator.optional(),
+        'from.did': z.string().optional(),
+        'from.profileId': z.string().optional(),
+        'data.vcUris': z.union([z.string(), z.array(z.string())]).optional(),
+        'data.vpUris': z.union([z.string(), z.array(z.string())]).optional(),
+        'data.metadata.listingId': z.string().optional(),
+        read: z.boolean().optional(),
+        archived: z.boolean().optional(),
+        actionStatus: NotificationActionStatusEnumValidator.optional(),
+    })
+    .strict();
+
+/** @group LCA API Plugin */
+export type NotificationQueryInputType = z.infer<typeof NotificationQueryInputValidator>;
+/** END Synced Types**/
+
+/** @group LCA API Plugin - SSS Key Management */
+export const AuthProviderTypeValidator = z.enum(['firebase', 'supertokens', 'keycloak', 'oidc']);
+export type AuthProviderType = z.infer<typeof AuthProviderTypeValidator>;
+
+export const ServerEncryptedShareValidator = z.object({
+    encryptedData: z.string(),
+    encryptedDek: z.string(),
+    iv: z.string(),
+});
+export type ServerEncryptedShare = z.infer<typeof ServerEncryptedShareValidator>;
+
+export const EncryptedShareValidator = z.object({
+    encryptedData: z.string(),
+    iv: z.string(),
+    salt: z.string().optional(),
+});
+export type EncryptedShare = z.infer<typeof EncryptedShareValidator>;
+
+export const RecoveryMethodTypeValidator = z.enum(['passkey', 'backup', 'phrase', 'email']);
+export type RecoveryMethodType = z.infer<typeof RecoveryMethodTypeValidator>;
+
+export const SecurityLevelValidator = z.enum(['basic', 'enhanced', 'advanced']);
+export type SecurityLevel = z.infer<typeof SecurityLevelValidator>;
+
+export const KeyProviderValidator = z.enum(['web3auth', 'sss']);
+export type KeyProvider = z.infer<typeof KeyProviderValidator>;
+
+export const RecoveryMethodInfoValidator = z.object({
+    type: RecoveryMethodTypeValidator,
+    createdAt: z.string(),
+    credentialId: z.string().optional(),
+    shareVersion: z.number().optional(),
+});
+export type RecoveryMethodInfo = z.infer<typeof RecoveryMethodInfoValidator>;
+
+export const GetAuthShareResponseValidator = z
+    .object({
+        authShare: ServerEncryptedShareValidator.nullable(),
+        primaryDid: z.string().nullable(),
+        securityLevel: SecurityLevelValidator,
+        recoveryMethods: z.array(RecoveryMethodInfoValidator),
+        keyProvider: KeyProviderValidator,
+        shareVersion: z.number(),
+        maskedRecoveryEmail: z.string().nullable(),
+    })
+    .nullable();
+export type GetAuthShareResponse = z.infer<typeof GetAuthShareResponseValidator>;
+
+/** @group LCA API Plugin */
+export type LCAPluginDependentMethods = {
+    getDidAuthVp: (options?: ProofOptions) => Promise<VP | string>;
+    getProfile: () => Promise<LCNVisibleProfile | undefined>;
+    generateEd25519KeyFromBytes: (bytes: Uint8Array) => JWKWithPrivateKey;
+    keyToDid: (type: 'key', keypair: JWKWithPrivateKey) => string;
+    resolveDid: (did: string) => Promise<DidDocument>;
+    addDidMetadata: (metadata: Partial<DidDocument>) => Promise<boolean>;
+    decryptDagJwe: <T>(jwe: JWE, jwks?: JWKWithPrivateKey[]) => Promise<T>;
+    crypto: () => Crypto;
+};
+
+export enum DASHBOARD_TYPE {
+    NSO,
+    GLOBAL,
+    TROOP,
+}
+
+export type AnalyticsPayload = {
+    resource: {
+        dashboardType: DASHBOARD_TYPE;
+    };
+    params: {
+        nso_id?: string[];
+        troop_id?: string[];
+    };
+    exp: number;
+};
+
+/** @group LCA API Plugin */
+export type LCAPluginMethods = {
+    registerDeviceForPushNotifications: (token: string) => Promise<boolean>;
+    unregisterDeviceForPushNotifications: (token: string) => Promise<boolean>;
+    getNotifications: (
+        options: PaginatedNotificationsOptionsType,
+        filter?: NotificationQueryFiltersType
+    ) => Promise<PaginatedNotificationsType | false>;
+    queryNotifications: (
+        query: NotificationQueryInputType,
+        options?: Partial<PaginatedNotificationsOptionsType>
+    ) => Promise<PaginatedNotificationsType | false>;
+    updateNotificationMeta: (_id: string, meta: NotificationMetaType) => Promise<boolean>;
+    markAllNotificationsRead: () => Promise<boolean>;
+    createSigningAuthority: (
+        name: string,
+        ownerDid?: string
+    ) => Promise<SigningAuthorityType | false>;
+    getSigningAuthorities: () => Promise<SigningAuthorityType[] | false>;
+    authorizeSigningAuthority: (
+        name: string,
+        authorization: SigningAuthorityAuthorization
+    ) => Promise<boolean>;
+    resetLCAClient: () => Promise<void>;
+    generateBoostInfo: (description: string) => Promise<{
+        title: string;
+        description: string;
+        category: string;
+        type: string;
+        skills: BoostSkills[];
+        narrative: string;
+    }>;
+    generateImage: (prompt: string) => Promise<string>;
+    generateBoostSkills: (description: string) => Promise<BoostSkills[]>;
+    generateSkillIcons: (names: string[]) => Promise<Record<string, string>>;
+    createPin: (pin: string) => Promise<boolean>;
+    hasPin: (did?: string) => Promise<boolean>;
+    verifyPin: (pin: string, did?: string) => Promise<boolean>;
+    updatePin: (currentPin: string, newPin: string) => Promise<boolean>;
+    generatePinUpdateToken: () => Promise<{ token: string; tokenExpire: Date } | null>;
+    validatePinUpdateToken: (token: string) => Promise<boolean>;
+    updatePinWithToken: (token: string, newPin: string) => Promise<boolean>;
+    generateAnalyticsAccessToken: (payload: AnalyticsPayload) => Promise<string | null>;
+    decryptDagJwe: <T>(jwe: JWE, jwks?: JWKWithPrivateKey[]) => Promise<T>;
+    hash: (message: string, algorithm?: string) => Promise<string | undefined>;
+    getFirebaseUserByEmail: (email: string) => Promise<UserRecordType | null>;
+    authenticateWithKeycloak: (token: string) => Promise<FirebaseCustomAuthResponse>;
+    authenticateWithScoutsSSO: (
+        username: string,
+        password: string
+    ) => Promise<ScoutSSOResponseType | null>;
+    sendLoginVerificationCode: (email: string) => Promise<{ success: boolean; message?: string }>;
+    verifyLoginCode: (
+        email: string,
+        code: string
+    ) => Promise<{ success: boolean; message?: string; token?: string }>;
+    verifyNetworkHandoffToken: (
+        token: string
+    ) => Promise<{ success: boolean; message?: string; token?: string }>;
+    getProofOfLoginVp: (
+        token: string
+    ) => Promise<{ success: boolean; error?: string; vp?: string }>;
+    updatePreferences: (preferences: PreferencesType) => Promise<boolean>;
+    createPreferences: (preferences: CreatePreferencesType) => Promise<boolean>;
+    getPreferencesForDid: () => Promise<PreferencesType>;
+    sendEndorsementShareLink: (
+        email: string,
+        shareLink: string,
+        issuer: {
+            name: string;
+        },
+        credential: {
+            name: string;
+        },
+        message: string
+    ) => Promise<boolean>;
+
+    // SSS Key Management Methods
+    getAuthShare: (
+        authToken: string,
+        providerType: AuthProviderType
+    ) => Promise<GetAuthShareResponse>;
+
+    storeAuthShare: (
+        authToken: string,
+        providerType: AuthProviderType,
+        authShare: ServerEncryptedShare,
+        primaryDid: string,
+        securityLevel?: SecurityLevel
+    ) => Promise<{ success: boolean }>;
+
+    addRecoveryMethod: (
+        authToken: string,
+        providerType: AuthProviderType,
+        type: RecoveryMethodType,
+        encryptedShare?: EncryptedShare,
+        credentialId?: string
+    ) => Promise<{ success: boolean }>;
+
+    getRecoveryShare: (
+        authToken: string,
+        providerType: AuthProviderType,
+        type: RecoveryMethodType,
+        credentialId?: string
+    ) => Promise<{ encryptedShare?: EncryptedShare; shareVersion?: number } | null>;
+
+    markMigrated: (
+        authToken: string,
+        providerType: AuthProviderType
+    ) => Promise<{ success: boolean }>;
+
+    deleteUserKey: (
+        authToken: string,
+        providerType: AuthProviderType
+    ) => Promise<{ success: boolean }>;
+};
+
+/** @group LearnCardNetwork Plugin */
+export type LCAPlugin = Plugin<
+    'LearnCard App',
+    never,
+    LCAPluginMethods,
+    'id',
+    LCAPluginDependentMethods
+>;