@orion-js/helpers 3.11.6 → 3.11.15

package/lib/Errors/OrionError.d.ts

@@ -1,13 +1,39 @@
+/**
+ * Interface representing the standardized error information structure for Orion errors.
+ * This is used by the getInfo method to provide consistent error reporting.
+ */
 export interface OrionErrorInformation {
+    /** The error code or identifier */
     error: string;
+    /** Human-readable error message */
     message: string;
+    /** Additional error metadata or context */
     extra: any;
+    /** The sub-type of error. For example for permissions errors it could be 'read', 'write', 'admin' */
+    type?: string;
 }
+/**
+ * Base error class for all Orion-specific errors.
+ *
+ * This abstract class provides common properties and methods for all error types
+ * used in the Orion framework. It's extended by more specific error classes
+ * like UserError and PermissionsError.
+ *
+ * @property isOrionError - Flag indicating this is an Orion error (always true)
+ * @property isUserError - Flag indicating if this is a user-facing error
+ * @property isPermissionsError - Flag indicating if this is a permissions-related error
+ * @property code - Error code for identifying the error type
+ * @property extra - Additional error context or metadata
+ */
 export declare class OrionError extends Error {
     isOrionError: boolean;
     isUserError: boolean;
     isPermissionsError: boolean;
     code: string;
     extra: any;
+    /**
+     * Returns a standardized representation of the error information.
+     * @returns An object containing error details in a consistent format
+     */
     getInfo: () => OrionErrorInformation;
 }

package/lib/Errors/OrionError.js

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrionError = void 0;
+/**
+ * Base error class for all Orion-specific errors.
+ *
+ * This abstract class provides common properties and methods for all error types
+ * used in the Orion framework. It's extended by more specific error classes
+ * like UserError and PermissionsError.
+ *
+ * @property isOrionError - Flag indicating this is an Orion error (always true)
+ * @property isUserError - Flag indicating if this is a user-facing error
+ * @property isPermissionsError - Flag indicating if this is a permissions-related error
+ * @property code - Error code for identifying the error type
+ * @property extra - Additional error context or metadata
+ */
 class OrionError extends Error {
     constructor() {
         super(...arguments);

package/lib/Errors/OrionError.test.d.ts

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

package/lib/Errors/OrionError.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OrionError_1 = require("./OrionError");
+// Since OrionError is an abstract class with unimplemented methods,
+// we'll create a concrete implementation for testing
+class TestOrionError extends OrionError_1.OrionError {
+    constructor(message, code = 'test_error', extra = {}) {
+        super(message);
+        this.code = code;
+        this.extra = extra;
+        this.isUserError = false;
+        this.isPermissionsError = false;
+        this.getInfo = () => {
+            return {
+                error: this.code,
+                message: this.message,
+                extra: this.extra
+            };
+        };
+    }
+}
+describe('OrionError', () => {
+    it('should be an instance of Error', () => {
+        const error = new TestOrionError('Test error message');
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have OrionError properties', () => {
+        const error = new TestOrionError('Test error message');
+        expect(error.isOrionError).toBe(true);
+        expect(error.isUserError).toBe(false);
+        expect(error.isPermissionsError).toBe(false);
+        expect(error.code).toBe('test_error');
+        expect(error.message).toBe('Test error message');
+    });
+    it('should have a getInfo method that returns the correct structure', () => {
+        const extraData = { userId: '123', context: 'testing' };
+        const error = new TestOrionError('Test error message', 'custom_code', extraData);
+        const info = error.getInfo();
+        expect(info).toEqual({
+            error: 'custom_code',
+            message: 'Test error message',
+            extra: extraData
+        });
+    });
+    it('should be extendable with custom properties', () => {
+        const error = new TestOrionError('Test error message');
+        error.customProp = 'custom value';
+        expect(error.customProp).toBe('custom value');
+        expect(error.message).toBe('Test error message');
+        expect(error.isOrionError).toBe(true);
+    });
+});

package/lib/Errors/PermissionsError.d.ts

@@ -1,4 +1,37 @@
 import { OrionError } from './OrionError';
+/**
+ * Error class for permission-related errors in the Orion framework.
+ *
+ * PermissionsError represents authorization failures where a user or client
+ * attempts to perform an action they don't have permission to execute.
+ * This is used to distinguish security/permissions errors from other types
+ * of errors for proper error handling and user feedback.
+ *
+ * @extends OrionError
+ */
 export default class PermissionsError extends OrionError {
+    /**
+     * Creates a new PermissionsError instance.
+     *
+     * @param permissionErrorType - Identifies the specific permission that was violated
+     *                              (e.g., 'read', 'write', 'admin')
+     * @param extra - Additional error context or metadata. Can include a custom message
+     *                via the message property.
+     *
+     * @example
+     * // Basic usage
+     * throw new PermissionsError('delete_document')
+     *
+     * @example
+     * // With custom message
+     * throw new PermissionsError('access_admin', { message: 'Admin access required' })
+     *
+     * @example
+     * // With additional context
+     * throw new PermissionsError('edit_user', {
+     *   userId: 'user123',
+     *   requiredRole: 'admin'
+     * })
+     */
     constructor(permissionErrorType: any, extra?: any);
 }

package/lib/Errors/PermissionsError.js

@@ -1,7 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const OrionError_1 = require("./OrionError");
+/**
+ * Error class for permission-related errors in the Orion framework.
+ *
+ * PermissionsError represents authorization failures where a user or client
+ * attempts to perform an action they don't have permission to execute.
+ * This is used to distinguish security/permissions errors from other types
+ * of errors for proper error handling and user feedback.
+ *
+ * @extends OrionError
+ */
 class PermissionsError extends OrionError_1.OrionError {
+    /**
+     * Creates a new PermissionsError instance.
+     *
+     * @param permissionErrorType - Identifies the specific permission that was violated
+     *                              (e.g., 'read', 'write', 'admin')
+     * @param extra - Additional error context or metadata. Can include a custom message
+     *                via the message property.
+     *
+     * @example
+     * // Basic usage
+     * throw new PermissionsError('delete_document')
+     *
+     * @example
+     * // With custom message
+     * throw new PermissionsError('access_admin', { message: 'Admin access required' })
+     *
+     * @example
+     * // With additional context
+     * throw new PermissionsError('edit_user', {
+     *   userId: 'user123',
+     *   requiredRole: 'admin'
+     * })
+     */
     constructor(permissionErrorType, extra = {}) {
         // Calling parent constructor of base Error class.
         const message = extra.message || `Client is not allowed to perform this action [${permissionErrorType}]`;

package/lib/Errors/PermissionsError.test.d.ts

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

package/lib/Errors/PermissionsError.test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PermissionsError_1 = __importDefault(require("./PermissionsError"));
+const OrionError_1 = require("./OrionError");
+describe('PermissionsError', () => {
+    it('should extend OrionError', () => {
+        const error = new PermissionsError_1.default('read_document');
+        expect(error).toBeInstanceOf(OrionError_1.OrionError);
+    });
+    it('should set isPermissionsError to true', () => {
+        const error = new PermissionsError_1.default('read_document');
+        expect(error.isPermissionsError).toBe(true);
+        expect(error.isOrionError).toBe(true);
+        expect(error.isUserError).toBeUndefined();
+    });
+    it('should set code to "PermissionsError"', () => {
+        const error = new PermissionsError_1.default('read_document');
+        expect(error.code).toBe('PermissionsError');
+    });
+    it('should generate a default message with permissionErrorType', () => {
+        const error = new PermissionsError_1.default('update_user');
+        expect(error.message).toBe('Client is not allowed to perform this action [update_user]');
+    });
+    it('should support custom message in extra', () => {
+        const error = new PermissionsError_1.default('delete_document', {
+            message: 'You need admin rights to delete this document'
+        });
+        expect(error.message).toBe('You need admin rights to delete this document');
+    });
+    it('should store extra data', () => {
+        const extraData = {
+            documentId: '123',
+            requiredRole: 'admin'
+        };
+        const error = new PermissionsError_1.default('read_document', extraData);
+        expect(error.extra).toEqual(extraData);
+    });
+    it('should have a getInfo method that returns the correct structure', () => {
+        const extraData = { documentId: '123', requiredRole: 'admin' };
+        const error = new PermissionsError_1.default('read_document', extraData);
+        const info = error.getInfo();
+        expect(info).toEqual({
+            ...extraData,
+            error: 'PermissionsError',
+            message: 'Client is not allowed to perform this action [read_document]',
+            type: 'read_document'
+        });
+    });
+    it('should include the permission type in getInfo', () => {
+        const error = new PermissionsError_1.default('admin_action');
+        const info = error.getInfo();
+        expect(info.type).toBe('admin_action');
+    });
+    it('should have proper stack trace', () => {
+        const error = new PermissionsError_1.default('read_document');
+        expect(error.stack).toBeDefined();
+        expect(error.stack.includes('PermissionsError.test.ts')).toBe(true);
+    });
+});

package/lib/Errors/UserError.d.ts

@@ -1,4 +1,33 @@
 import { OrionError } from './OrionError';
+/**
+ * Error class for user-facing errors in the Orion framework.
+ *
+ * UserError is designed to represent errors that should be displayed to end users,
+ * as opposed to system errors or unexpected failures. These errors typically represent
+ * validation issues, business rule violations, or other expected error conditions.
+ *
+ * @extends OrionError
+ */
 export default class UserError extends OrionError {
+    /**
+     * Creates a new UserError instance.
+     *
+     * @param code - Error code identifier. If only one parameter is provided,
+     *               this will be used as the message and code will default to 'error'.
+     * @param message - Human-readable error message. Optional if code is provided.
+     * @param extra - Additional error context or metadata.
+     *
+     * @example
+     * // Basic usage
+     * throw new UserError('invalid_input', 'The provided email is invalid')
+     *
+     * @example
+     * // Using only a message (code will be 'error')
+     * throw new UserError('Input validation failed')
+     *
+     * @example
+     * // With extra metadata
+     * throw new UserError('rate_limit', 'Too many requests', { maxRequests: 100 })
+     */
     constructor(code: string, message?: string, extra?: any);
 }

package/lib/Errors/UserError.js

@@ -1,7 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const OrionError_1 = require("./OrionError");
+/**
+ * Error class for user-facing errors in the Orion framework.
+ *
+ * UserError is designed to represent errors that should be displayed to end users,
+ * as opposed to system errors or unexpected failures. These errors typically represent
+ * validation issues, business rule violations, or other expected error conditions.
+ *
+ * @extends OrionError
+ */
 class UserError extends OrionError_1.OrionError {
+    /**
+     * Creates a new UserError instance.
+     *
+     * @param code - Error code identifier. If only one parameter is provided,
+     *               this will be used as the message and code will default to 'error'.
+     * @param message - Human-readable error message. Optional if code is provided.
+     * @param extra - Additional error context or metadata.
+     *
+     * @example
+     * // Basic usage
+     * throw new UserError('invalid_input', 'The provided email is invalid')
+     *
+     * @example
+     * // Using only a message (code will be 'error')
+     * throw new UserError('Input validation failed')
+     *
+     * @example
+     * // With extra metadata
+     * throw new UserError('rate_limit', 'Too many requests', { maxRequests: 100 })
+     */
     constructor(code, message, extra) {
         if (!message && code) {
             message = code;

package/lib/Errors/UserError.test.d.ts

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

package/lib/Errors/UserError.test.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const UserError_1 = __importDefault(require("./UserError"));
+const OrionError_1 = require("./OrionError");
+describe('UserError', () => {
+    it('should extend OrionError', () => {
+        const error = new UserError_1.default('test_code', 'Test error message');
+        expect(error).toBeInstanceOf(OrionError_1.OrionError);
+    });
+    it('should set isUserError to true', () => {
+        const error = new UserError_1.default('test_code', 'Test error message');
+        expect(error.isUserError).toBe(true);
+        expect(error.isOrionError).toBe(true);
+        expect(error.isPermissionsError).toBeUndefined();
+    });
+    it('should set code and message correctly', () => {
+        const error = new UserError_1.default('test_code', 'Test error message');
+        expect(error.code).toBe('test_code');
+        expect(error.message).toBe('Test error message');
+    });
+    it('should support providing only a message (code defaults to "error")', () => {
+        const error = new UserError_1.default('Test error message');
+        expect(error.code).toBe('error');
+        expect(error.message).toBe('Test error message');
+    });
+    it('should support extra data', () => {
+        const extraData = { field: 'username', constraint: 'required' };
+        const error = new UserError_1.default('validation_error', 'Validation failed', extraData);
+        expect(error.extra).toEqual(extraData);
+    });
+    it('should have a getInfo method that returns the correct structure', () => {
+        const extraData = { field: 'email', constraint: 'format' };
+        const error = new UserError_1.default('invalid_email', 'Invalid email format', extraData);
+        const info = error.getInfo();
+        expect(info).toEqual({
+            error: 'invalid_email',
+            message: 'Invalid email format',
+            extra: extraData
+        });
+    });
+    it('should have proper stack trace', () => {
+        const error = new UserError_1.default('test_code', 'Test error message');
+        expect(error.stack).toBeDefined();
+        expect(error.stack.includes('UserError.test.ts')).toBe(true);
+    });
+});

package/lib/Errors/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Exports all error classes used in the Orion framework
+ */
+import { OrionError, OrionErrorInformation } from './OrionError';
+import PermissionsError from './PermissionsError';
+import UserError from './UserError';
+/**
+ * Re-export all error types for convenient importing
+ */
+export { OrionError, OrionErrorInformation, PermissionsError, UserError };
+/**
+ * Type guard to check if an error is an OrionError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is an OrionError instance
+ *
+ * @example
+ * try {
+ *   // some code that might throw
+ * } catch (error) {
+ *   if (isOrionError(error)) {
+ *     // Handle Orion-specific error
+ *     console.log(error.code, error.getInfo())
+ *   } else {
+ *     // Handle general error
+ *   }
+ * }
+ */
+export declare function isOrionError(error: any): error is OrionError;
+/**
+ * Type guard to check if an error is a UserError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is a UserError instance
+ */
+export declare function isUserError(error: any): error is UserError;
+/**
+ * Type guard to check if an error is a PermissionsError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is a PermissionsError instance
+ */
+export declare function isPermissionsError(error: any): error is PermissionsError;

package/lib/Errors/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * @file Exports all error classes used in the Orion framework
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPermissionsError = exports.isUserError = exports.isOrionError = exports.UserError = exports.PermissionsError = exports.OrionError = void 0;
+const OrionError_1 = require("./OrionError");
+Object.defineProperty(exports, "OrionError", { enumerable: true, get: function () { return OrionError_1.OrionError; } });
+const PermissionsError_1 = __importDefault(require("./PermissionsError"));
+exports.PermissionsError = PermissionsError_1.default;
+const UserError_1 = __importDefault(require("./UserError"));
+exports.UserError = UserError_1.default;
+/**
+ * Type guard to check if an error is an OrionError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is an OrionError instance
+ *
+ * @example
+ * try {
+ *   // some code that might throw
+ * } catch (error) {
+ *   if (isOrionError(error)) {
+ *     // Handle Orion-specific error
+ *     console.log(error.code, error.getInfo())
+ *   } else {
+ *     // Handle general error
+ *   }
+ * }
+ */
+function isOrionError(error) {
+    return Boolean(error && typeof error === 'object' && error.isOrionError === true);
+}
+exports.isOrionError = isOrionError;
+/**
+ * Type guard to check if an error is a UserError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is a UserError instance
+ */
+function isUserError(error) {
+    return Boolean(error && typeof error === 'object' && error.isOrionError === true && error.isUserError === true);
+}
+exports.isUserError = isUserError;
+/**
+ * Type guard to check if an error is a PermissionsError
+ *
+ * @param error - Any error object to test
+ * @returns True if the error is a PermissionsError instance
+ */
+function isPermissionsError(error) {
+    return Boolean(error && typeof error === 'object' && error.isOrionError === true && error.isPermissionsError === true);
+}
+exports.isPermissionsError = isPermissionsError;

package/lib/Errors/index.test.d.ts

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

package/lib/Errors/index.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe('Error type guards', () => {
+    // Mock concrete implementation of OrionError for testing
+    class TestOrionError extends index_1.OrionError {
+        constructor() {
+            super('Test error');
+            this.code = 'test_error';
+            this.extra = {};
+            this.isOrionError = true;
+            this.isUserError = false;
+            this.isPermissionsError = false;
+            this.getInfo = () => ({
+                error: this.code,
+                message: this.message,
+                extra: this.extra
+            });
+        }
+    }
+    describe('isOrionError', () => {
+        it('should return true for OrionError instances', () => {
+            expect((0, index_1.isOrionError)(new TestOrionError())).toBe(true);
+            expect((0, index_1.isOrionError)(new index_1.UserError('test'))).toBe(true);
+            expect((0, index_1.isOrionError)(new index_1.PermissionsError('test'))).toBe(true);
+        });
+        it('should return false for non-OrionError objects', () => {
+            expect((0, index_1.isOrionError)(new Error('Regular error'))).toBe(false);
+            expect((0, index_1.isOrionError)({ message: 'Not an error' })).toBe(false);
+            expect((0, index_1.isOrionError)(null)).toBe(false);
+            expect((0, index_1.isOrionError)(undefined)).toBe(false);
+        });
+    });
+    describe('isUserError', () => {
+        it('should return true for UserError instances', () => {
+            expect((0, index_1.isUserError)(new index_1.UserError('test'))).toBe(true);
+        });
+        it('should return false for other error types', () => {
+            expect((0, index_1.isUserError)(new TestOrionError())).toBe(false);
+            expect((0, index_1.isUserError)(new index_1.PermissionsError('test'))).toBe(false);
+            expect((0, index_1.isUserError)(new Error('Regular error'))).toBe(false);
+            expect((0, index_1.isUserError)(null)).toBe(false);
+        });
+    });
+    describe('isPermissionsError', () => {
+        it('should return true for PermissionsError instances', () => {
+            expect((0, index_1.isPermissionsError)(new index_1.PermissionsError('test'))).toBe(true);
+        });
+        it('should return false for other error types', () => {
+            expect((0, index_1.isPermissionsError)(new TestOrionError())).toBe(false);
+            expect((0, index_1.isPermissionsError)(new index_1.UserError('test'))).toBe(false);
+            expect((0, index_1.isPermissionsError)(new Error('Regular error'))).toBe(false);
+            expect((0, index_1.isPermissionsError)(null)).toBe(false);
+        });
+    });
+});

package/lib/createMap.d.ts

@@ -1 +1,17 @@
+/**
+ * Creates a map (object) from an array of items, using a specified property as the key.
+ *
+ * This utility transforms an array of objects into a lookup object/dictionary where
+ * each item in the array becomes a value in the map, indexed by the specified property.
+ * If multiple items have the same key value, only the last one will be preserved.
+ *
+ * @template T The type of items in the input array
+ * @param array - The input array of items to transform into a map
+ * @param key - The property name to use as keys in the resulting map (defaults to '_id')
+ * @returns A record object where keys are values of the specified property and values are the original items
+ *
+ * @example
+ * // Returns { '1': { id: 1, name: 'Item 1' }, '2': { id: 2, name: 'Item 2' } }
+ * createMap([{ id: 1, name: 'Item 1' }, { id: 2, name: 'Item 2' }], 'id')
+ */
 export default function createMap<T>(array: Array<T>, key?: string): Record<string, T>;

package/lib/createMap.js

@@ -1,5 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Creates a map (object) from an array of items, using a specified property as the key.
+ *
+ * This utility transforms an array of objects into a lookup object/dictionary where
+ * each item in the array becomes a value in the map, indexed by the specified property.
+ * If multiple items have the same key value, only the last one will be preserved.
+ *
+ * @template T The type of items in the input array
+ * @param array - The input array of items to transform into a map
+ * @param key - The property name to use as keys in the resulting map (defaults to '_id')
+ * @returns A record object where keys are values of the specified property and values are the original items
+ *
+ * @example
+ * // Returns { '1': { id: 1, name: 'Item 1' }, '2': { id: 2, name: 'Item 2' } }
+ * createMap([{ id: 1, name: 'Item 1' }, { id: 2, name: 'Item 2' }], 'id')
+ */
 function createMap(array, key = '_id') {
     const map = {};
     for (const item of array) {

package/lib/createMap.test.d.ts

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

package/lib/createMap.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createMap_1 = __importDefault(require("./createMap"));
+describe('createMap', () => {
+    it('should create a map using the default _id key', () => {
+        const array = [
+            { _id: '1', name: 'Item 1' },
+            { _id: '2', name: 'Item 2' },
+            { _id: '3', name: 'Item 3' }
+        ];
+        const result = (0, createMap_1.default)(array);
+        expect(result).toEqual({
+            '1': { _id: '1', name: 'Item 1' },
+            '2': { _id: '2', name: 'Item 2' },
+            '3': { _id: '3', name: 'Item 3' }
+        });
+    });
+    it('should create a map using a custom key', () => {
+        const array = [
+            { id: 'a', name: 'Item A' },
+            { id: 'b', name: 'Item B' },
+            { id: 'c', name: 'Item C' }
+        ];
+        const result = (0, createMap_1.default)(array, 'id');
+        expect(result).toEqual({
+            'a': { id: 'a', name: 'Item A' },
+            'b': { id: 'b', name: 'Item B' },
+            'c': { id: 'c', name: 'Item C' }
+        });
+    });
+    it('should handle empty arrays', () => {
+        const result = (0, createMap_1.default)([]);
+        expect(result).toEqual({});
+    });
+    it('should handle objects with property references', () => {
+        const array = [
+            { id: 'u1', message: 'Hello' },
+            { id: 'u2', message: 'World' }
+        ];
+        const result = (0, createMap_1.default)(array, 'id');
+        expect(result).toEqual({
+            'u1': { id: 'u1', message: 'Hello' },
+            'u2': { id: 'u2', message: 'World' }
+        });
+    });
+    it('should overwrite items with duplicate keys', () => {
+        const array = [
+            { id: 'dup', value: 'First' },
+            { id: 'dup', value: 'Second' },
+            { id: 'dup', value: 'Third' }
+        ];
+        const result = (0, createMap_1.default)(array, 'id');
+        // Only the last item with a given key should be preserved
+        expect(result).toEqual({
+            'dup': { id: 'dup', value: 'Third' }
+        });
+    });
+    it('should handle various key types', () => {
+        const array = [
+            { key: 1, value: 'Number key' },
+            { key: 'string', value: 'String key' },
+            { key: true, value: 'Boolean key' }
+        ];
+        const result = (0, createMap_1.default)(array, 'key');
+        expect(result).toEqual({
+            '1': { key: 1, value: 'Number key' },
+            'string': { key: 'string', value: 'String key' },
+            'true': { key: true, value: 'Boolean key' }
+        });
+    });
+});