@buley/dash 0.0.30

package/src/utilities/index.ts

@@ -0,0 +1,349 @@
+/**
+ * Common interfaces and utilities.
+ * @module utilities
+ */
+
+/**
+ * @typedef {Object} DashContext
+ * @property {Object} [db] - The IDBDatabase object.
+ * @property {Object} [transaction] - The IDBTransaction object.
+ * @property {DashObjectStore} [objectstore] - The IDBObjectStore object.
+ * @property {IDBKeyRange} [range] - The IDBKeyRange object.
+ * @property {IDBIndex} [idx] - The IDBIndex object.
+ * @property {any} [entry] - The entry.
+ * @property {IDBRequest} [request] - The IDBRequest object.
+ * @property {any} [error] - The error.
+ * @property {any} [key] - The key.
+ * @property {Event} [event] - The event.
+ * @property {any} [data] - The data.
+ * @property {number} [amount] - The amount.
+ * @property {string} [type] - The type.
+ * @property {Function} [on_success] - The on_success function.
+ * @property {Function} [on_error] - The on_error function.
+ */
+export interface DashContext {
+    [key: string]: any;
+    db?: IDBDatabase;
+    transaction?: IDBTransaction;
+    objectstore?: IDBObjectStore;
+    range?: IDBKeyRange;
+    idx?: IDBIndex;
+    entry?: any;
+    request?: IDBRequest;
+    error?: any;
+    key?: any;
+    event?: Event;
+    data?: any;
+    amount?: number;
+    type?: string;
+    on_success?: (ctx: DashContext) => void;
+    on_error?: (ctx: DashContext) => void;
+}
+
+/**
+ * @typedef {Object} DashEnvironment
+ * @property {Document} [document] - The document object.
+ * @property {IDBFactory} [indexedDB] - The indexedDB object.
+ * @property {typeof IDBKeyRange} [IDBKeyRange] - The IDBKeyRange object.
+ * @property {typeof DOMStringList} [DOMStringList] - The DOMStringList object.
+ * @property {typeof Worker} [Worker] - The Worker object.
+ * @property {Function} constructor - The constructor function.
+ * @property {typeof addEventListener} [addEventListener] - The addEventListener function.
+ */
+export interface DashEnvironment {
+    document?: Document;
+    indexedDB?: IDBFactory;
+    IDBKeyRange?: typeof IDBKeyRange;
+    DOMStringList?: typeof DOMStringList;
+    Worker?: typeof Worker;
+    constructor: Function;
+    addEventListener?: typeof addEventListener;
+}
+
+/**
+ * @typedef {Object} PublicAPI
+ * @property {Function} [add] - Add functions.
+ * @property {Function} [clear] - Clear functions.
+ * @property {Function} [count] - The count functions.
+ * @property {Function} [get] - The get functions.
+ * @property {Function} [remove] - The remove functions.
+ * @property {Function} [update] - The update functions.
+ */
+export interface PublicAPI {
+    add: (ctx: DashContext) => Promise<DashContext>;
+    clear: (ctx: DashContext) => Promise<DashContext>;
+    count: (ctx: DashContext) => Promise<DashContext>;
+    get: (ctx: DashContext) => Promise<DashContext>;
+    remove: (ctx: DashContext) => Promise<DashContext>;
+    update: (ctx: DashContext) => Promise<DashContext>;
+}
+
+/**
+ * @typedef {Object} DashBehaviorContext
+ * @property {Function} clone - The clone function.
+ * @property {Function} contains - The contains function.
+ * @property {Function} exists - The exists function.
+ * @property {Function} is - The is function.
+ * @property {Function} isEmpty - The isEmpty function.
+ * @property {Function} isnt - The isnt function.
+ * @property {Function} isArray - The isArray function.
+ * @property {Function} isBoolean - The isBoolean function.
+ * @property {Function} isRegEx - The isRegEx function.
+ * @property {Function} isFunction - The isFunction function.
+ * @property {Function} isObject - The isObject function.
+ * @property {Function} isNumber - The isNumber function.
+ * @property {Function} isString - The isString function.
+ * @property {Function} apply - The apply function.
+ * @property {Function} each - The each function.
+ * @property {Function} iterate - The iterate function.
+ * @property {Function} random - The random function.
+ * @property {PublicAPI} api - The public API object.
+ */
+
+export interface DashBehaviorContext {
+    clone: typeof clone;
+    contains: typeof contains;
+    exists: typeof exists;
+    is: typeof is;
+    isEmpty: typeof isEmpty;
+    isnt: typeof isnt;
+    isArray: typeof isArray;
+    isBoolean: typeof isBoolean;
+    isRegEx: typeof isRegEx;
+    isFunction: typeof isFunction;
+    isObject: typeof isObject;
+    isNumber: typeof isNumber;
+    isString: typeof isString;
+    apply: typeof safeApply;
+    each: typeof safeEach;
+    iterate: typeof safeIterate;
+    random: typeof randomId;
+    api: PublicAPI;
+}
+/**
+ * @typedef {Object} DashObjectStore
+ * @property {string | null} [keyPath] - The key path.
+ * @property {boolean} [autoIncrement] - Whether to auto-increment.
+ * @property {Function} [clear] - The clear function.
+ * @property {Function} [deleteObjectStore] - The deleteObjectStore function.
+ * @property {Function} [put] - The put function.
+ * @property {Function} [index] - The index function.
+ */
+export interface DashObjectStore {
+    keyPath?: string | null;
+    autoIncrement?: boolean;
+    clear?: () => void;
+    deleteObjectStore?: (store: string) => void;
+    put?: (data: any, key?: any) => IDBRequest;
+    index?: (name: string) => IDBIndex;
+}
+
+/**
+ * @typedef {Object} DashIndex
+ * @property {string} name - The name.
+ * @property {boolean} multiEntry - Whether it's a multi-entry index.
+ * @property {boolean} unique - Whether it's a unique index.
+ * @property {string} keyPath - The key path.
+ */
+export interface DashIndex {
+    name: string;
+    multiEntry: boolean;
+    unique: boolean;
+    keyPath: string;
+}
+
+/**
+ * @typedef {Object} DashProviderCacheObj
+ * @property {Object} [database] - The database object.
+ * @property {Object} [stores] - The stores object.
+ * @property {Object} [indexes] - The indexes object.
+ * @property {DashIndex} [data] - The data object.
+ */
+export interface DashProviderCacheObj {
+    [database: string]: {
+        stores: {
+            [store: string]: {
+                indexes: {
+                    [index: string]: {
+                        data: DashIndex;
+                    };
+                };
+                data: any;
+            };
+        };
+        data: any;
+    };
+}
+
+
+/**
+ * @param {DashContext} ctx - The context.
+ * @returns {Promise<DashContext>} The promise object.
+ * @private
+ */
+export const cloneError = (error: Error): Error => {
+    const clonedError = new Error(error.message);
+    
+    // Optionally, clone the stack trace if it's available
+    if (error.stack) {
+        clonedError.stack = error.stack;
+    }
+
+    // Clone custom properties
+    Object.keys(error).forEach((key) => {
+        (clonedError as any)[key] = (error as any)[key];
+    });
+
+    return clonedError;
+};
+
+// Clone function that performs a deep copy of an object, array, or function
+export const clone = (source: any): any => {
+    if (source === null || typeof source !== 'object') {
+        return source;
+    }
+
+    // Handle arrays
+    if (Array.isArray(source)) {
+        return source.map(item => clone(item));
+    }
+
+    // Handle functions (return the same function reference)
+    if (typeof source === 'function') {
+        return source;
+    }
+
+    // Handle objects
+    const copy: { [key: string]: any } = {};
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            copy[key] = clone(source[key]);  // Recursively clone properties
+        }
+    }
+    return copy;
+};
+
+// Checks if an item exists in an array or object
+export const contains = (str: string, substr: string): boolean => {
+    if (typeof str !== 'string' || typeof substr !== 'string') {
+        return false; // Ensure both inputs are strings
+    }
+
+    // An empty substring should always return true
+    if (substr === '') {
+        return true;
+    }
+
+    return str.includes(substr); // Use built-in includes method for substring checking
+};
+
+// Checks whether a value exists
+export const exists = (value: any): boolean => {
+    return value !== null && value !== undefined;
+};
+
+// Checks if a variable is empty
+export const isEmpty = (mixed_var: any): boolean => {
+    // Handle null and undefined cases
+    if (mixed_var === null || mixed_var === undefined) {
+        return true;
+    }
+
+    // Handle objects (including arrays)
+    if (typeof mixed_var === 'object') {
+        return Object.keys(mixed_var).length === 0;
+    }
+
+    // Handle strings (empty string should return true)
+    if (typeof mixed_var === 'string') {
+        return mixed_var.length === 0;
+    }
+
+    // For numbers and booleans, they are considered "not collections" and hence should return true
+    if (typeof mixed_var === 'number' || typeof mixed_var === 'boolean') {
+        return true;
+    }
+
+    return false;
+};
+
+export const is = (a: any, b: any): boolean => {
+    return Object.is(a, b);
+};
+
+export const isnt = (a: any, b: any): boolean => {
+    return a !== b;
+};
+export const isArray = Array.isArray;
+export const isBoolean = (mixed_var: any): boolean => typeof mixed_var === 'boolean';
+export const isRegEx = (mixed_var: any): boolean => mixed_var instanceof RegExp;
+export const isFunction = (value: any): boolean => {
+    if (typeof value !== 'function') {
+        return false;
+    }
+
+    // Check if it's a class constructor by examining the function's string representation
+    const isClass = /^class\s/.test(Function.prototype.toString.call(value));
+    return !isClass;
+};
+
+export const isObject = (value: any): boolean => {
+    return Object.prototype.toString.call(value) === '[object Object]';
+};
+export const isNumber = (mixed_var: any): boolean => typeof mixed_var === 'number';
+export const isString = (value: any): boolean => {
+    return typeof value === 'string' || value instanceof String;
+};
+
+// Applies a function if it's defined
+export const safeApply = (fn: Function | undefined, args: any[], context?: any, err?: Function): any => {
+    if (typeof fn === 'function') return fn.apply(context || {}, args || []);
+    if (typeof err === 'function') return safeApply(err, []);
+};
+
+// Iterates through an array and applies a callback function
+export const safeEach = (items: any[], callback: (item: any, index: number) => void, inc = 1): void => {
+    for (let x = 0; x < items.length; x += inc) {
+        safeApply(callback, [items[x], x]);
+    }
+};
+
+// Iterates through an object's properties and applies a callback function
+export const safeIterate = (item: any, callback: (key: string, value: any) => void): void => {
+    for (const attr in item) {
+        if (item.hasOwnProperty(attr)) {
+            callback(attr, item[attr]);
+        }
+    }
+};
+
+// Generates a random string ID
+export const randomId = (len = 16, charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"): string => {
+    let str = '';
+    for (let i = 0; i < len; i++) {
+        str += charset.charAt(Math.floor(Math.random() * charset.length));
+    }
+    return str;
+};
+
+
+export default {
+    cloneError,
+    clone,
+    contains,
+    exists,
+    isEmpty,
+    is,
+    isnt,
+    isArray,
+    isBoolean,
+    isRegEx,
+    isFunction,
+    isObject,
+    isNumber,
+    isString,
+    safeApply,
+    safeEach,
+    safeIterate,
+    randomId
+};

package/tests/behaviors/behaviors.spec.ts

@@ -0,0 +1,123 @@
+import behaviorMethods from './../../src/behaviors';
+import { DashContext } from './../../src/utilities';
+
+// Mock the behavior context functions
+jest.mock('./../../src/utilities', () => ({
+    cloneError: jest.fn(),
+    safeApply: jest.fn(),
+    safeEach: jest.fn((array, fn) => array.forEach(fn)),
+}));
+
+describe('behaviorMethods', () => {
+    let mockRequest: any;
+    
+    beforeEach(() => {
+        // Clear behavior actions and filters to avoid shared state between tests
+        behaviorMethods.behaviorFilters.length = 0;
+        behaviorMethods.behaviorActions.length = 0;
+
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+    });
+
+    beforeEach(() => {
+        mockRequest = {
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            result: 'testResult',
+            error: new Error('Test Error'),
+        };
+    });
+
+    describe('get', () => {
+        it('should retrieve all behaviors', async () => {
+            const get_ctx: DashContext = {
+                objectstore: {
+                    indexNames: ['behavior1', 'behavior2'],
+                } as unknown as IDBObjectStore,
+                on_success: jest.fn(),
+            };
+        
+            // Mock safeApply to call the on_success without using the spread operator
+            const safeApply = require('./../../src/utilities').safeApply;
+            safeApply.mockImplementation((callback: (arg0: any) => any, args: any[]) => callback(args[0]));
+        
+            const result = await behaviorMethods.get(get_ctx);
+        
+            expect(get_ctx.behaviors).toEqual(['behavior1', 'behavior2']);
+            expect(get_ctx.on_success).toHaveBeenCalledWith(get_ctx);  // Check if on_success is called correctly
+        });
+        
+
+        it('should handle errors during retrieval', async () => {
+            const get_ctx: DashContext = {
+                objectstore: {
+                    indexNames: null,  // Simulate an error
+                } as unknown as IDBObjectStore,
+                on_error: jest.fn(),
+            };
+        
+            // Mock cloneError to return a proper error object
+            const cloneError = require('./../../src/utilities').cloneError;
+            cloneError.mockImplementation((error: Error) => ({ message: 'Test Error' }));
+        
+            // Mock safeApply to call the on_error callback
+            const safeApply = require('./../../src/utilities').safeApply;
+            safeApply.mockImplementation((callback: (arg0: any) => any, args: any[]) => callback(args[0]));
+        
+            await expect(behaviorMethods.get(get_ctx)).rejects.toEqual(get_ctx);
+            expect(get_ctx.error).toBeDefined();  // Check if error is set
+            expect(get_ctx.error.message).toBe('Test Error');  // Check error message
+            expect(get_ctx.on_error).toHaveBeenCalledWith(get_ctx);  // Ensure on_error is called
+        });
+        
+        
+    });
+
+    describe('add', () => {
+        it('should add a behavior action', () => {
+            const mockFilter = jest.fn();
+            const mockAction = jest.fn();
+
+            behaviorMethods.add([mockFilter, mockAction]);
+
+            // Ensure the filter and action are added to the internal lists
+            expect(behaviorMethods.behaviorFilters).toContain(mockFilter);
+            expect(behaviorMethods.behaviorActions).toContain(mockAction);
+        });
+    });
+
+    describe('applyBehaviors', () => {
+        it('should apply all behavior actions', async () => {
+            const mockAction = jest.fn(() => ({ context: { objectstore: {} }, type: 'testSlug' }));  // Return the correct structure
+            const ctx: DashContext = { objectstore: {} } as DashContext;
+        
+            const safeApply = require('./../../src/utilities').safeApply;
+            safeApply.mockImplementation((action: (arg0: any) => any, args: any) => action(args[0]));  // Pass the context directly
+        
+            behaviorMethods.add(mockAction);
+        
+            const finalContext = await behaviorMethods.applyBehaviors(ctx, 'testSlug', 'testMethod', Promise.resolve(ctx));
+        
+            expect(mockAction).toHaveBeenCalled();
+            expect(finalContext).toStrictEqual(ctx);  // Use toStrictEqual for deep equality check
+        });
+
+        it('should handle errors during action application', async () => {
+            const mockAction = jest.fn(() => {
+                throw new Error('Test Error');
+            });
+            const ctx: DashContext = { objectstore: {} } as DashContext;
+        
+            const safeApply = require('./../../src/utilities').safeApply;
+            safeApply.mockImplementation(() => {
+                throw new Error('Test Error');
+            });
+        
+            behaviorMethods.add(mockAction);
+        
+            await expect(behaviorMethods.applyBehaviors(ctx, 'testSlug', 'testMethod', Promise.resolve(ctx))).rejects.toThrow('Test Error');
+        });
+        
+    });
+});

package/tests/database/database.spec.ts

@@ -0,0 +1,177 @@
+import { databaseMethods } from '../../src/database';
+import { DashContext } from '../../src/utilities';
+
+describe('databaseMethods', () => {
+    let mockObjectStore: {
+        get: jest.Mock;
+        put: jest.Mock;
+        delete: jest.Mock;
+    };
+
+    beforeEach(() => {
+        mockObjectStore = {
+            get: jest.fn(),
+            put: jest.fn(),
+            delete: jest.fn(),
+        };
+    });
+
+    describe('get', () => {
+        it('should retrieve an entry from the database', async () => {
+            const get_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                result: 'testData',
+            };
+
+            mockObjectStore.get.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.get(get_ctx);
+            mockRequest.onsuccess({ target: { result: 'testData' } } as any);
+
+            const result = await resultPromise;
+            expect(result.entry).toBe('testData');
+        });
+
+        it('should handle errors when retrieving an entry', async () => {
+            const get_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                error: new Error('Get Error'),
+            };
+
+            mockObjectStore.get.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.get(get_ctx);
+            mockRequest.onerror({ target: { error: new Error('Get Error') } } as any);
+
+            await expect(resultPromise).rejects.toMatchObject({
+                error: { message: 'Get Error' },
+            });
+        });
+
+        it('should reject if the entry is missing', async () => {
+            const get_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                result: undefined,
+            };
+
+            mockObjectStore.get.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.get(get_ctx);
+            mockRequest.onsuccess({ target: { result: undefined } } as any);
+
+            await expect(resultPromise).rejects.toMatchObject({
+                error: { message: 'missing', name: 'DashNoEntry' },
+            });
+        });
+    });
+
+    describe('put', () => {
+        it('should put an entry in the database', async () => {
+            const put_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                data: 'testData',
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                result: 'testKey',
+            };
+
+            mockObjectStore.put.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.put(put_ctx);
+            mockRequest.onsuccess({ target: { result: 'testKey' } } as any);
+
+            const result = await resultPromise;
+            expect(result.key).toBe('testKey');
+            expect(result.entry).toBe('testData');
+        });
+
+        it('should handle errors during put', async () => {
+            const put_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                data: 'testData',
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                error: new Error('Put Error'),
+            };
+
+            mockObjectStore.put.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.put(put_ctx);
+            mockRequest.onerror({ target: { error: new Error('Put Error') } } as any);
+
+            await expect(resultPromise).rejects.toMatchObject({
+                error: { message: 'Put Error' },
+            });
+        });
+    });
+
+    describe('remove', () => {
+        it('should remove an entry from the database', async () => {
+            const remove_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+            };
+
+            mockObjectStore.delete.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.remove(remove_ctx);
+            mockRequest.onsuccess({} as any);
+
+            const result = await resultPromise;
+            expect(result).toEqual(remove_ctx);
+        });
+
+        it('should handle errors during remove', async () => {
+            const remove_ctx: DashContext = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+
+            const mockRequest = {
+                onsuccess: null as any,
+                onerror: null as any,
+                error: new Error('Remove Error'),
+            };
+
+            mockObjectStore.delete.mockReturnValue(mockRequest);
+
+            const resultPromise = databaseMethods.remove(remove_ctx);
+            mockRequest.onerror({ target: { error: new Error('Remove Error') } } as any);
+
+            await expect(resultPromise).rejects.toMatchObject({
+                error: { message: 'Remove Error' },
+            });
+        });
+    });
+});