favalib 0.0.1

package/build/Command/BaseCommand.d.mts

@@ -0,0 +1,65 @@
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+import { CommandData } from '../interfaces/CommandTypes.mjs';
+/**
+ * Abstract base class for commands that interact with the vault.
+ * @template T - The type of command data, extending CommandData.
+ */
+declare abstract class BaseCommand<T extends CommandData = CommandData> {
+    readonly id: string;
+    readonly type: string;
+    readonly timestamp: number;
+    readonly version: string;
+    readonly data: T;
+    readonly fromRemote: boolean;
+    /**
+     * Creates a new BaseCommand instance.
+     * @param type - The type of the command.
+     * @param data - The data associated with the command.
+     * @param id - The unique identifier for the command. If not provided, a new UUID will be generated.
+     * @param timestamp - The timestamp of when the command was created. If not provided, the current timestamp will be used.
+     * @param version - The version of the command. Defaults to '1.0'.
+     * @param fromRemote - Indicates if the command originated from a remote source. Defaults to false.
+     */
+    constructor(type: string, data: T, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    /**
+     * Executes the command using the provided mediator, which can be used to access the other classes.
+     * @param VaultDataManager - The TwoFaLibMediator instance to use for execution.
+     * @returns A Promise that resolves when the execution is complete.
+     */
+    abstract execute(twoFaLibMediator: TwoFaLibMediator): Promise<void>;
+    /**
+     * Creates an undo command that, when executed, reverses the effects of this command.
+     * @param VaultDataManager - The TwoFaLibMediator instance to use for creating the undo command.
+     * @returns A BaseCommand instance that undoes this command.
+     */
+    abstract createUndoCommand(TwoFaLibMediator: TwoFaLibMediator): BaseCommand;
+    /**
+     * Creates a new instance of the command with the provided data.
+     * @param data - The data to use for creating the new command instance.
+     * @returns A new instance of the command.
+     */
+    static create<T extends CommandData, C extends BaseCommand<T>>(this: new (data: T, id?: string, timestamp?: number, version?: string, fromRemote?: boolean) => C, data: T): C;
+    /**
+     * Creates a new instance of the command from JSON data.
+     * @param input - The JSON input containing the command data.
+     * @returns A new instance of the command created from the JSON data.
+     */
+    static fromJSON<T extends CommandData, C extends BaseCommand<T>>(this: new (data: T, id: string, timestamp: number, version: string, fromRemote: boolean) => C, input: {
+        data: T;
+        id: string;
+        timestamp: number;
+        version: string;
+    }): C;
+    /**
+     * Converts the command instance to a JSON-serializable object.
+     * @returns An object representation of the command.
+     */
+    toJSON(): {
+        id: string;
+        type: string;
+        data: T;
+        timestamp: number;
+        version: string;
+    };
+}
+export default BaseCommand;

package/build/Command/BaseCommand.mjs

@@ -0,0 +1,54 @@
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Abstract base class for commands that interact with the vault.
+ * @template T - The type of command data, extending CommandData.
+ */
+class BaseCommand {
+    /**
+     * Creates a new BaseCommand instance.
+     * @param type - The type of the command.
+     * @param data - The data associated with the command.
+     * @param id - The unique identifier for the command. If not provided, a new UUID will be generated.
+     * @param timestamp - The timestamp of when the command was created. If not provided, the current timestamp will be used.
+     * @param version - The version of the command. Defaults to '1.0'.
+     * @param fromRemote - Indicates if the command originated from a remote source. Defaults to false.
+     */
+    constructor(type, data, id = uuidv4(), timestamp = Date.now(), version = '1.0', fromRemote = false) {
+        this.id = id;
+        this.type = type;
+        this.timestamp = timestamp;
+        this.version = version;
+        this.data = data;
+        this.fromRemote = fromRemote;
+    }
+    /**
+     * Creates a new instance of the command with the provided data.
+     * @param data - The data to use for creating the new command instance.
+     * @returns A new instance of the command.
+     */
+    static create(data) {
+        return new this(data);
+    }
+    /**
+     * Creates a new instance of the command from JSON data.
+     * @param input - The JSON input containing the command data.
+     * @returns A new instance of the command created from the JSON data.
+     */
+    static fromJSON(input) {
+        return new this(input.data, input.id, input.timestamp, input.version, true);
+    }
+    /**
+     * Converts the command instance to a JSON-serializable object.
+     * @returns An object representation of the command.
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            type: this.type,
+            data: this.data,
+            timestamp: this.timestamp,
+            version: this.version,
+        };
+    }
+}
+export default BaseCommand;

package/build/Command/CommandQueue.d.mts

@@ -0,0 +1,28 @@
+import Command from './BaseCommand.mjs';
+/**
+ * Represents a queue of commands with timestamp-based sorting.
+ */
+declare class CommandQueue {
+    private queue;
+    /**
+     * @returns The number of commands in the queue.
+     */
+    get size(): number;
+    /**
+     * Adds a command to the queue and sorts it based on timestamp.
+     * @param command - The command to be added to the queue.
+     */
+    enqueue(command: Command): void;
+    /**
+     * Removes and returns the first command from the queue.
+     * @returns The first command in the queue, or undefined if the queue is empty.
+     * @throws {TwoFALibError} If the queue is empty.
+     */
+    dequeue(): Command | undefined;
+    /**
+     * Checks if the queue is empty.
+     * @returns True if the queue is empty, false otherwise.
+     */
+    isEmpty(): boolean;
+}
+export default CommandQueue;

package/build/Command/CommandQueue.mjs

@@ -0,0 +1,43 @@
+import { TwoFALibError } from '../TwoFALibError.mjs';
+/**
+ * Represents a queue of commands with timestamp-based sorting.
+ */
+class CommandQueue {
+    constructor() {
+        this.queue = [];
+    }
+    /**
+     * @returns The number of commands in the queue.
+     */
+    get size() {
+        return this.queue.length;
+    }
+    /**
+     * Adds a command to the queue and sorts it based on timestamp.
+     * @param command - The command to be added to the queue.
+     */
+    enqueue(command) {
+        // command queue shouldn't be very large, so this simple implementation should be fine
+        this.queue.push(command);
+        this.queue.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Removes and returns the first command from the queue.
+     * @returns The first command in the queue, or undefined if the queue is empty.
+     * @throws {TwoFALibError} If the queue is empty.
+     */
+    dequeue() {
+        if (this.isEmpty()) {
+            throw new TwoFALibError('Command queue is empty');
+        }
+        return this.queue.shift();
+    }
+    /**
+     * Checks if the queue is empty.
+     * @returns True if the queue is empty, false otherwise.
+     */
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+}
+export default CommandQueue;

package/build/Command/commandConstructors.d.mts

@@ -0,0 +1,11 @@
+import AddEntryCommand from './commands/AddEntryCommand.mjs';
+import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
+import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
+import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
+declare const commandConstructors: {
+    AddEntry: typeof AddEntryCommand;
+    DeleteEntry: typeof DeleteEntryCommand;
+    UpdateEntry: typeof UpdateEntryCommand;
+    AddSyncDevice: typeof AddSyncDeviceCommand;
+};
+export default commandConstructors;

package/build/Command/commandConstructors.mjs

@@ -0,0 +1,11 @@
+import AddEntryCommand from './commands/AddEntryCommand.mjs';
+import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
+import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
+import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
+const commandConstructors = {
+    AddEntry: AddEntryCommand,
+    DeleteEntry: DeleteEntryCommand,
+    UpdateEntry: UpdateEntryCommand,
+    AddSyncDevice: AddSyncDeviceCommand,
+};
+export default commandConstructors;

package/build/Command/commands/AddEntryCommand.d.mts

@@ -0,0 +1,31 @@
+import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
+import Command from '../BaseCommand.mjs';
+import type Entry from '../../interfaces/Entry.mjs';
+export type AddEntryData = Entry;
+/**
+ * Represents a command that when executed add an entry to the vault.
+ */
+declare class AddEntryCommand extends Command<AddEntryData> {
+    /**
+     * Creates a new AddEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be added.
+     */
+    constructor(data: AddEntryData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    /**
+     * Executes the command to add the entry to the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    execute(mediator: TwoFaLibMediator): Promise<void>;
+    /**
+     * @inheritdoc
+     */
+    createUndoCommand(): Command;
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate(): boolean;
+}
+export default AddEntryCommand;

package/build/Command/commands/AddEntryCommand.mjs

@@ -0,0 +1,43 @@
+import { InvalidCommandError } from '../../TwoFALibError.mjs';
+import Command from '../BaseCommand.mjs';
+import DeleteEntryCommand from './DeleteEntryCommand.mjs';
+/**
+ * Represents a command that when executed add an entry to the vault.
+ */
+class AddEntryCommand extends Command {
+    /**
+     * Creates a new AddEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be added.
+     */
+    constructor(data, id, timestamp, version, fromRemote = false) {
+        super('AddEntry', data, id, timestamp, version, fromRemote);
+    }
+    /**
+     * Executes the command to add the entry to the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    async execute(mediator) {
+        const vault = mediator.getComponent('vaultDataManager');
+        if (!this.validate()) {
+            throw new InvalidCommandError('Invalid AddEntry command');
+        }
+        await vault.addEntry(this.data);
+    }
+    /**
+     * @inheritdoc
+     */
+    createUndoCommand() {
+        return DeleteEntryCommand.create({ entryId: this.data.id });
+    }
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate() {
+        // TODO: actually validate
+        return this.data.id !== undefined;
+    }
+}
+export default AddEntryCommand;

package/build/Command/commands/AddSyncDeviceCommand.d.mts

@@ -0,0 +1,36 @@
+import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
+import Command from '../BaseCommand.mjs';
+import type { DeviceId, DeviceType } from '../../interfaces/SyncTypes.mjs';
+import type { PublicKey } from '../../interfaces/CryptoLib.mjs';
+export interface AddSyncDeviceData {
+    deviceId: DeviceId;
+    deviceType: DeviceType;
+    publicKey: PublicKey;
+}
+/**
+ * Represents a command that when executed add an entry to the vault.
+ */
+declare class AddSyncDeviceCommand extends Command<AddSyncDeviceData> {
+    /**
+     * Creates a new AddEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be added.
+     */
+    constructor(data: AddSyncDeviceData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    /**
+     * Executes the command to add the entry to the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    execute(mediator: TwoFaLibMediator): Promise<void>;
+    /**
+     * @inheritdoc
+     */
+    createUndoCommand(): Command;
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate(): boolean;
+}
+export default AddSyncDeviceCommand;

package/build/Command/commands/AddSyncDeviceCommand.mjs

@@ -0,0 +1,42 @@
+import { InvalidCommandError, TwoFALibError } from '../../TwoFALibError.mjs';
+import Command from '../BaseCommand.mjs';
+/**
+ * Represents a command that when executed add an entry to the vault.
+ */
+class AddSyncDeviceCommand extends Command {
+    /**
+     * Creates a new AddEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be added.
+     */
+    constructor(data, id, timestamp, version, fromRemote = false) {
+        super('AddSyncDevice', data, id, timestamp, version, fromRemote);
+    }
+    /**
+     * Executes the command to add the entry to the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    async execute(mediator) {
+        const syncManager = mediator.getComponent('syncManager');
+        if (!this.validate()) {
+            throw new InvalidCommandError('Invalid AddEntry command');
+        }
+        await syncManager.addSyncDevice(this.data);
+    }
+    /**
+     * @inheritdoc
+     */
+    createUndoCommand() {
+        throw new TwoFALibError('Not implemented yet');
+    }
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate() {
+        // TODO: actually validate
+        return true;
+    }
+}
+export default AddSyncDeviceCommand;

package/build/Command/commands/DeleteEntryCommand.d.mts

@@ -0,0 +1,35 @@
+import Command from '../BaseCommand.mjs';
+import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
+import type { EntryId } from '../../interfaces/Entry.mjs';
+export interface DeleteEntryData {
+    entryId: EntryId;
+}
+/**
+ * Represents a command that when executed deletes an entry from the vault.
+ */
+declare class DeleteEntryCommand extends Command<DeleteEntryData> {
+    private deletedEntry?;
+    /**
+     * Creates a new DeleteEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be deleted.
+     */
+    constructor(data: DeleteEntryData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    /**
+     * Executes the command to delete the entry from the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid or the entry doesn't exist.
+     */
+    execute(mediator: TwoFaLibMediator): Promise<void>;
+    /**
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the deleted entry content is not available.
+     */
+    createUndoCommand(): Command;
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate(): boolean;
+}
+export default DeleteEntryCommand;

package/build/Command/commands/DeleteEntryCommand.mjs

@@ -0,0 +1,50 @@
+import { InvalidCommandError } from '../../TwoFALibError.mjs';
+import Command from '../BaseCommand.mjs';
+import AddEntryCommand from './AddEntryCommand.mjs';
+/**
+ * Represents a command that when executed deletes an entry from the vault.
+ */
+class DeleteEntryCommand extends Command {
+    /**
+     * Creates a new DeleteEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data of the entry to be deleted.
+     */
+    constructor(data, id, timestamp, version, fromRemote = false) {
+        super('DeleteEntry', data, id, timestamp, version, fromRemote);
+    }
+    /**
+     * Executes the command to delete the entry from the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid or the entry doesn't exist.
+     */
+    async execute(mediator) {
+        if (!this.validate()) {
+            throw new InvalidCommandError('Invalid DeleteEntry command');
+        }
+        const vault = mediator.getComponent('vaultDataManager');
+        this.deletedEntry = vault.getFullEntry(this.data.entryId);
+        if (this.deletedEntry === undefined) {
+            throw new InvalidCommandError(`Entry with id ${this.data.entryId} does not exist`);
+        }
+        await vault.deleteEntry(this.data.entryId);
+    }
+    /**
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the deleted entry content is not available.
+     */
+    createUndoCommand() {
+        if (this.deletedEntry === undefined) {
+            throw new InvalidCommandError('Cannot create undo command, content not available');
+        }
+        return AddEntryCommand.create(this.deletedEntry);
+    }
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate() {
+        return this.data.entryId !== undefined;
+    }
+}
+export default DeleteEntryCommand;

package/build/Command/commands/UpdateEntryCommand.d.mts

@@ -0,0 +1,38 @@
+import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
+import Command from '../BaseCommand.mjs';
+import type Entry from '../../interfaces/Entry.mjs';
+import { EntryId } from '../../interfaces/Entry.mjs';
+export interface UpdateEntryData {
+    entryId: EntryId;
+    oldEntry: Entry;
+    updatedEntry: Entry;
+}
+/**
+ * Represents a command that when executed updates an entry in the vault.
+ */
+declare class UpdateEntryCommand extends Command<UpdateEntryData> {
+    private originalEntry?;
+    /**
+     * Creates a new UpdateEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data containing the entry to be updated.
+     */
+    constructor(data: UpdateEntryData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    /**
+     * Executes the command to update the entry in the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    execute(mediator: TwoFaLibMediator): Promise<void>;
+    /**
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the original entry is not available.
+     */
+    createUndoCommand(): Command;
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate(): boolean;
+}
+export default UpdateEntryCommand;

package/build/Command/commands/UpdateEntryCommand.mjs

@@ -0,0 +1,51 @@
+import { InvalidCommandError } from '../../TwoFALibError.mjs';
+import Command from '../BaseCommand.mjs';
+/**
+ * Represents a command that when executed updates an entry in the vault.
+ */
+class UpdateEntryCommand extends Command {
+    /**
+     * Creates a new UpdateEntryCommand instance.
+     * @inheritdoc
+     * @param data - The data containing the entry to be updated.
+     */
+    constructor(data, id, timestamp, version, fromRemote = false) {
+        super('UpdateEntry', data, id, timestamp, version, fromRemote);
+    }
+    /**
+     * Executes the command to update the entry in the vault.
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the command data is invalid.
+     */
+    async execute(mediator) {
+        if (!this.validate()) {
+            throw new InvalidCommandError('Invalid UpdateEntry command');
+        }
+        const vault = mediator.getComponent('vaultDataManager');
+        this.originalEntry = vault.getFullEntry(this.data.entryId);
+        await vault.updateEntry(this.data.updatedEntry);
+    }
+    /**
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the original entry is not available.
+     */
+    createUndoCommand() {
+        if (!this.originalEntry) {
+            throw new InvalidCommandError('Cannot create undo command, original entry not available');
+        }
+        return new UpdateEntryCommand({
+            entryId: this.data.entryId,
+            oldEntry: this.data.updatedEntry,
+            updatedEntry: this.data.oldEntry,
+        });
+    }
+    /**
+     * Validates the command data.
+     * @returns True if the command data is valid, false otherwise.
+     */
+    validate() {
+        // TODO: write a complete validate function
+        return Boolean(this.data.entryId);
+    }
+}
+export default UpdateEntryCommand;

package/build/CryptoProviders/browser/index.d.mts

@@ -0,0 +1,73 @@
+import type CryptoLib from '../../interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PassphraseHash, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
+/**
+ * Create a password hash
+ * @param salt - The salt to use
+ * @param passphrase - The passphrase to hash
+ * @returns The calculated password hash
+ */
+export declare const generatePassphraseHash: (salt: Salt, passphrase: string) => Promise<PassphraseHash>;
+/**
+ * @inheritdoc
+ */
+declare class BrowserCryptoLib implements CryptoLib {
+    /**
+     * @inheritdoc
+     */
+    getRandomBytes(count: number): Promise<Uint8Array>;
+    /**
+     * @inheritdoc
+     */
+    createKeys(passphrase: Passphrase): Promise<{
+        privateKey: PrivateKey;
+        symmetricKey: SymmetricKey;
+        encryptedPrivateKey: EncryptedPrivateKey;
+        encryptedSymmetricKey: EncryptedSymmetricKey;
+        salt: Salt;
+        publicKey: PublicKey;
+    }>;
+    /**
+     * @inheritdoc
+     */
+    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+        encryptedPrivateKey: EncryptedPrivateKey;
+        encryptedSymmetricKey: EncryptedSymmetricKey;
+    }>;
+    /**
+     * @inheritdoc
+     */
+    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+        privateKey: PrivateKey;
+        publicKey: PublicKey;
+        symmetricKey: SymmetricKey;
+    }>;
+    /**
+     * @inheritdoc
+     */
+    encrypt<T extends string>(publicKey: PublicKey, plainText: T): Promise<Encrypted<T>>;
+    /**
+     * @inheritdoc
+     */
+    decrypt<T extends string>(privateKey: PrivateKey, encryptedText: Encrypted<T>): Promise<T>;
+    /**
+     * @inheritdoc
+     */
+    encryptSymmetric<T extends string>(symmetricKey: SymmetricKey, plainText: T): Promise<Encrypted<T>>;
+    /**
+     * @inheritdoc
+     */
+    decryptSymmetric<T extends string>(symmetricKey: SymmetricKey, encryptedText: Encrypted<T>): Promise<T>;
+    /**
+     * @inheritdoc
+     */
+    createSymmetricKey(): Promise<SymmetricKey>;
+    /**
+     * @inheritdoc
+     */
+    createSyncKey(sharedKey: Uint8Array, salt: string): Promise<SyncKey>;
+    private encryptPrivateKey;
+    private decryptPrivateKey;
+    private createKeyPair;
+    private getPublicKeyFromPrivateKey;
+}
+export default BrowserCryptoLib;