accio-orm 0.1.0 → 0.1.1

package/dist/logger/LogLevel.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log level definitions for the Accio logger
+ *
+ * Log levels control which messages are output. Higher levels are more severe.
+ * Setting a log level will output all messages at the level and above.
+ */
+/**
+ * Log severity levels
+ *
+ * @example
+ * ```typescript
+ * const dv = connect({
+ *   host: 'localhost',
+ *   database: 'mydb',
+ *   user: 'user',
+ *   password: 'password',
+ *   logger: {
+ *     level: Loglevel.DEBUG // show all log messages
+ *   }
+ * })
+ */
+export declare enum LogLevel {
+    /**
+     * Debug level - most verbose, includes all query details
+     */
+    DEBUG = 0,
+    /**
+     * Info level - general informational messages
+     */
+    INFO = 1,
+    /**
+     * Warning level - warnings that don't stop execution
+     */
+    WARN = 2,
+    /**
+     * Error level - errors that cause operation failures
+     */
+    ERROR = 3,
+    /**
+     * No logging - disables all log output
+     */
+    NONE = 4
+}
+/**
+ * Human-readable names for log levels
+ */
+export declare const LogLevelNames: Record<LogLevel, string>;

package/dist/logger/LogLevel.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Log level definitions for the Accio logger
+ *
+ * Log levels control which messages are output. Higher levels are more severe.
+ * Setting a log level will output all messages at the level and above.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelNames = exports.LogLevel = void 0;
+/**
+ * Log severity levels
+ *
+ * @example
+ * ```typescript
+ * const dv = connect({
+ *   host: 'localhost',
+ *   database: 'mydb',
+ *   user: 'user',
+ *   password: 'password',
+ *   logger: {
+ *     level: Loglevel.DEBUG // show all log messages
+ *   }
+ * })
+ */
+var LogLevel;
+(function (LogLevel) {
+    /**
+     * Debug level - most verbose, includes all query details
+     */
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    /**
+     * Info level - general informational messages
+     */
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    /**
+     * Warning level - warnings that don't stop execution
+     */
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    /**
+     * Error level - errors that cause operation failures
+     */
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    /**
+     * No logging - disables all log output
+     */
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Human-readable names for log levels
+ */
+exports.LogLevelNames = {
+    [LogLevel.DEBUG]: 'DEBUG',
+    [LogLevel.INFO]: 'INFO',
+    [LogLevel.WARN]: 'WARN',
+    [LogLevel.ERROR]: 'ERROR',
+    [LogLevel.NONE]: 'NONE'
+};

package/dist/logger/Logger.d.ts

@@ -0,0 +1,171 @@
+import { LogLevel } from './LogLevel';
+/**
+ * Structured log entity
+ */
+export interface LogEntry {
+    /**
+     * Timestamp when the log entry was created
+     */
+    timestamp: Date;
+    /**
+     * Log severity level
+     */
+    level: LogLevel;
+    /**
+     * Log message
+     */
+    message: string;
+    /**
+     * Additional context information
+     */
+    context?: Record<string, unknown>;
+    /**
+     * SQL query (for query logs)
+     */
+    sql?: string;
+    /**
+     * Query parameters (for query logs)
+     */
+    params?: unknown[];
+    /**
+     * Query execution duration in milliseconds (for query logs)
+     */
+    duration?: number;
+}
+/**
+ * Logger configuration options
+ *
+ * @example
+ * ```typescript
+ * const loggerConfig: LoggerConfig = {
+ *   level: LogLevel.DEBUG,
+ *   logQueries: true,
+ *   logErrors: true,
+ *   customLogger: (entry) => {
+ *     // Send to external logging service
+ *     winston.log(entry);
+ *   }
+ * };
+ * ```
+ */
+export interface LoggerConfig {
+    /**
+     * Minimum log level to output (default: INFO)
+     */
+    level: LogLevel;
+    /**
+     * Whether to log SQL queries (default: true)
+     */
+    logQueries?: boolean;
+    /**
+     * Whether to log errors (default: true)
+     */
+    logErrors?: boolean;
+    /**
+     * Custom logger function for integration with external logging services
+     */
+    customLogger?: (entry: LogEntry) => void;
+}
+/**
+ *
+ */
+export declare class Logger {
+    private config;
+    /**
+     * Creates a new Logger instance
+     *
+     * @param config - Logger configuration options
+     */
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Check if a log level should be output
+     */
+    private shouldLog;
+    /**
+     * Format a log entry as a string for console output
+     */
+    private formatMessage;
+    /**
+     * Internal log method that handle output
+     */
+    private log;
+    /**
+     * Log a debig message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Building query', { table: 'users', operation: 'SELECT' });
+     * ```
+     */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log an info message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.info('Connection established', { host: 'localhost', database: 'mydb' })
+     * ```
+     */
+    info(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.warn('Query slow', { duration: 5000, threshold: 1000 })
+     * ```
+     */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param error - The error object (optional)
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.error('Query failed', { query: 'SELECT * FROM users' })
+     * ```
+     */
+    error(message: string, error?: Error, context?: Record<string, unknown>): void;
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param error - The error object (optional)
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.error('Query failed', { query: 'SELECT * FROM users' })
+     * ```
+     */
+    query(sql: string, params?: unknown[], duration?: number): void;
+    /**
+     * Set the minimum log level
+     *
+     * @param level - The new log level
+     *
+     * @example
+     * ```typescript
+     * logger.setLevel(LogLevel.ERROR); // Only show errors
+     * ```
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Get the current log level
+     *
+     * @returns the current log level
+     */
+    getLevel(): LogLevel;
+}

package/dist/logger/Logger.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const LogLevel_1 = require("./LogLevel");
+const LogLevel_2 = require("./LogLevel");
+/**
+ *
+ */
+class Logger {
+    /**
+     * Creates a new Logger instance
+     *
+     * @param config - Logger configuration options
+     */
+    constructor(config = {}) {
+        this.config = {
+            level: config.level ?? LogLevel_1.LogLevel.INFO,
+            logQueries: config.logQueries ?? true,
+            logErrors: config.logErrors ?? true,
+            customLogger: config.customLogger
+        };
+    }
+    /**
+     * Check if a log level should be output
+     */
+    shouldLog(level) {
+        return level >= this.config.level;
+    }
+    /**
+     * Format a log entry as a string for console output
+     */
+    formatMessage(entry) {
+        const timestamp = entry.timestamp.toISOString();
+        const level = LogLevel_2.LogLevelNames[entry.level];
+        let message = `[${timestamp}] ${level}: ${entry.message}`;
+        if (entry.sql) {
+            message += `\n SQL: ${entry.sql}`;
+        }
+        if (entry.params && entry.params.length > 0) {
+            message += `\n Params: ${JSON.stringify(entry.params)}`;
+        }
+        if (entry.duration) {
+            message += `\n Duration: ${entry.duration}ms`;
+        }
+        if (entry.context) {
+            message += `\n Context: ${JSON.stringify(entry.context, null, 2)}`;
+        }
+        return message;
+    }
+    /**
+     * Internal log method that handle output
+     */
+    log(entry) {
+        if (!this.shouldLog(entry.level)) {
+            return;
+        }
+        if (this.config.customLogger) {
+            this.config.customLogger(entry);
+        }
+        else {
+            const message = this.formatMessage(entry);
+            switch (entry.level) {
+                case LogLevel_1.LogLevel.DEBUG:
+                case LogLevel_1.LogLevel.INFO:
+                    console.log(message);
+                    break;
+                case LogLevel_1.LogLevel.WARN:
+                    console.warn(message);
+                    break;
+                case LogLevel_1.LogLevel.ERROR:
+                    console.error(message);
+                    break;
+            }
+        }
+    }
+    /**
+     * Log a debig message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Building query', { table: 'users', operation: 'SELECT' });
+     * ```
+     */
+    debug(message, context) {
+        this.log({
+            timestamp: new Date(),
+            level: LogLevel_1.LogLevel.DEBUG,
+            message,
+            context
+        });
+    }
+    /**
+     * Log an info message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.info('Connection established', { host: 'localhost', database: 'mydb' })
+     * ```
+     */
+    info(message, context) {
+        this.log({
+            timestamp: new Date(),
+            level: LogLevel_1.LogLevel.INFO,
+            message,
+            context
+        });
+    }
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.warn('Query slow', { duration: 5000, threshold: 1000 })
+     * ```
+     */
+    warn(message, context) {
+        this.log({
+            timestamp: new Date(),
+            level: LogLevel_1.LogLevel.WARN,
+            message,
+            context
+        });
+    }
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param error - The error object (optional)
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.error('Query failed', { query: 'SELECT * FROM users' })
+     * ```
+     */
+    error(message, error, context) {
+        if (!this.config.logErrors) {
+            return;
+        }
+        this.log({
+            timestamp: new Date(),
+            level: LogLevel_1.LogLevel.ERROR,
+            message,
+            context: {
+                ...context,
+                error: error?.message,
+                stack: error?.stack
+            }
+        });
+    }
+    /**
+     * Log an warning message
+     *
+     * @param message - The message to log
+     * @param error - The error object (optional)
+     * @param context - Additional context information
+     *
+     * @example
+     * ```typescript
+     * logger.error('Query failed', { query: 'SELECT * FROM users' })
+     * ```
+     */
+    query(sql, params, duration) {
+        if (!this.config.logQueries) {
+            return;
+        }
+        this.log({
+            timestamp: new Date(),
+            level: LogLevel_1.LogLevel.DEBUG,
+            message: 'Query Executed',
+            sql,
+            params,
+            duration
+        });
+    }
+    /**
+     * Set the minimum log level
+     *
+     * @param level - The new log level
+     *
+     * @example
+     * ```typescript
+     * logger.setLevel(LogLevel.ERROR); // Only show errors
+     * ```
+     */
+    setLevel(level) {
+        this.config.level = level;
+    }
+    /**
+     * Get the current log level
+     *
+     * @returns the current log level
+     */
+    getLevel() {
+        return this.config.level;
+    }
+}
+exports.Logger = Logger;

package/dist/logger/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Logging system for Accio ORM
+ *
+ * Provides configurable logging with support for different log levels.
+ * query logging, and custom logger integration.
+ */
+export { type LogEntry, Logger, type LoggerConfig } from './Logger';
+export { LogLevel, LogLevelNames } from './LogLevel';

package/dist/logger/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Logging system for Accio ORM
+ *
+ * Provides configurable logging with support for different log levels.
+ * query logging, and custom logger integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelNames = exports.LogLevel = exports.Logger = void 0;
+var Logger_1 = require("./Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
+var LogLevel_1 = require("./LogLevel");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return LogLevel_1.LogLevel; } });
+Object.defineProperty(exports, "LogLevelNames", { enumerable: true, get: function () { return LogLevel_1.LogLevelNames; } });

package/dist/metadata/MetadataStorage.d.ts

@@ -20,7 +20,7 @@ export declare class MetadataStorage {
      * @param entityClass
      * @returns get the table name
      */
-    static getTableName(entityCLass: EntityConstructor): string;
+    static getTableName(entityClass: EntityConstructor): string;
     static getColumns(entityClass: EntityConstructor): ColumnMetadata[];
     static getPrimaryColumn(entityClass: EntityConstructor): ColumnMetadata;
     /**

package/dist/metadata/MetadataStorage.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataStorage = void 0;
 const Column_1 = require("@/decorators/Column");
 const Table_1 = require("@/decorators/Table");
+const errors_1 = require("@/errors");
 class MetadataStorage {
     /**
      * Extract all metadata from an entity class
@@ -16,24 +17,24 @@ class MetadataStorage {
         }
         const tableName = (0, Table_1.getTableName)(entityClass);
         if (!tableName) {
-            throw new Error(`Entity ${entityClass.name} is missing @Table decorator.
+            throw new errors_1.ValidationError(`Entity ${entityClass.name} is missing @Table decorator.
         Did you forget to add @Table('table_name') to the class?
-        `);
+        `, 'decorator', '@Table', { entityClass: entityClass.name });
         }
         const columns = (0, Column_1.getColumns)(entityClass);
         if (columns.length === 0) {
-            throw new Error(`Entity ${entityClass.name} has no columns defined.
-        Did you forget to add @Column() or @PrimaryColumn() decorators?`);
+            throw new errors_1.ValidationError(`Entity ${entityClass.name} has no columns defined.
+        Did you forget to add @Column() or @PrimaryColumn() decorators?`, 'decorator', '@Column', { entityClass: entityClass.name });
         }
         const primaryColumns = columns.filter((col) => col.isPrimary);
         if (primaryColumns.length === 0) {
-            throw new Error(`Entity ${entityClass.name} has no primary key defined.
-        Add @PrimaryColumn() to one of your properties.`);
+            throw new errors_1.ValidationError(`Entity ${entityClass.name} has no primary key defined.
+        Add @PrimaryColumn() to one of your properties.`, 'decorator', '@PrimaryColumn', { entityClass: entityClass.name });
         }
         if (primaryColumns.length > 1) {
-            throw new Error(`Entity ${entityClass.name} has multiple primary keys:
+            throw new errors_1.ValidationError(`Entity ${entityClass.name} has multiple primary keys:
         ${primaryColumns.map((c) => c.propertyKey).join(', ')}.
-        Only one primary key is supported.`);
+        Only one primary key is supported.`, 'primarykey', primaryColumns.map((c) => c.propertyKey), { entityClass: entityClass.name });
         }
         const primaryColumn = primaryColumns[0];
         const metadata = {
@@ -58,8 +59,8 @@ class MetadataStorage {
      * @param entityClass
      * @returns get the table name
      */
-    static getTableName(entityCLass) {
-        return this.getEntityMetadata(entityCLass).tableName;
+    static getTableName(entityClass) {
+        return this.getEntityMetadata(entityClass).tableName;
     }
     static getColumns(entityClass) {
         return this.getEntityMetadata(entityClass).columns;
@@ -67,7 +68,7 @@ class MetadataStorage {
     static getPrimaryColumn(entityClass) {
         const metadata = this.getEntityMetadata(entityClass);
         if (!metadata.primaryColumn) {
-            throw new Error(`Entity ${entityClass.name} has no primary key`);
+            throw new errors_1.ValidationError(`Entity ${entityClass.name} has no primary key ddefined`, 'primaryKey', undefined, { entityClass: entityClass.name });
         }
         return metadata.primaryColumn;
     }

package/dist/query/QueryBuilder.d.ts

@@ -11,11 +11,6 @@ export declare class QueryBuilder<T> {
     private orderByColumn?;
     private orderDirection;
     constructor(repository: Repository<T>, connection: Connection, metadata: EntityMetadata, initialConditions?: Partial<T>);
-    /**
-     * Map a database row to an entity instance
-     * @private
-     */
-    private mapRowToEntity;
     /**
      * Add WHERE conditions (can be chained multiple times)
      * Multiple calls to where() are combined with AND

package/dist/query/QueryBuilder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
+const validation_1 = require("@/validation");
 const entityMapper_1 = require("../utils/entityMapper");
 class QueryBuilder {
     constructor(repository, connection, metadata, initialConditions) {
@@ -13,21 +14,6 @@ class QueryBuilder {
             this.conditions.push(initialConditions);
         }
     }
-    /**
-     * Map a database row to an entity instance
-     * @private
-     */
-    mapRowToEntity(row) {
-        // Get the entity class from the repository
-        const entityClass = this.repository.getEntityClass();
-        const entity = new entityClass();
-        // Map each column from the database row to the entity property
-        this.metadata.columns.forEach((col) => {
-            const value = row[col.columnName];
-            entity[col.propertyKey] = value;
-        });
-        return entity;
-    }
     /**
      * Add WHERE conditions (can be chained multiple times)
      * Multiple calls to where() are combined with AND
@@ -40,9 +26,7 @@ class QueryBuilder {
      * Set the maximum number of results to return
      */
     limit(value) {
-        if (value < 0) {
-            throw new Error('Limit must be a positive number');
-        }
+        validation_1.QueryValidator.validateLimit(value);
         this.limitValue = value;
         return this;
     }
@@ -50,9 +34,7 @@ class QueryBuilder {
      * Set the number of results to skip
      */
     offset(value) {
-        if (value < 0) {
-            throw new Error('Offset must be a positive number');
-        }
+        validation_1.QueryValidator.validateOffset(value);
         this.offsetValue = value;
         return this;
     }
@@ -60,12 +42,11 @@ class QueryBuilder {
      * Order results by a column
      */
     orderBy(column, direction = 'ASC') {
-        // Validate that the column exists
+        // validate direction
+        validation_1.QueryValidator.validateOrderDirection(direction);
+        // validate that property exists in metadata
+        validation_1.identifierValidator.validatePropertyExists(column, this.metadata, 'ORDER BY');
         const columnMeta = this.metadata.columns.find((col) => col.propertyKey === column);
-        if (!columnMeta) {
-            throw new Error(`Column '${column}' does not exist on entity. ` +
-                `Available columns: ${this.metadata.columns.map((c) => c.propertyKey).join(', ')}`);
-        }
         this.orderByColumn = columnMeta.columnName;
         this.orderDirection = direction;
         return this;
@@ -119,13 +100,11 @@ class QueryBuilder {
             const whereClauses = [];
             this.conditions.forEach((condition) => {
                 Object.entries(condition).forEach(([key, value]) => {
+                    // validate that the property exists in metadata
+                    validation_1.identifierValidator.validatePropertyExists(key, this.metadata, 'WHERE clause');
                     // find column metadata for this property
                     const column = this.metadata.columns.find((col) => col.propertyKey === key);
-                    if (!column) {
-                        throw new Error(`Property '${key}' does not exist on entity ${this.metadata.tableName}. ` +
-                            `Available properties: ${this.metadata.columns.map((c) => c.propertyKey).join(', ')}`);
-                    }
-                    // Hanfle different value types
+                    // Handle different value types
                     if (value === null) {
                         whereClauses.push(`${column.columnName} IS NULL`);
                     }