noormme 1.1.0 → 1.2.0

package/dist/cjs/sqlite-migration/sqlite-migration-provider.js

@@ -53,7 +53,7 @@ class SQLiteMigrationProvider {
             migrationDirectory: './migrations',
             fileExtensions: ['.sql', '.ts', '.js'],
             encoding: 'utf8',
-            ...config
+            ...config,
         };
     }
     static getInstance(config, logger) {
@@ -105,11 +105,11 @@ class SQLiteMigrationProvider {
                     name: fileName,
                     content,
                     checksum: this.calculateChecksum(content),
-                    timestamp
+                    timestamp,
                 });
             }
             // Cache the migrations
-            migrations.forEach(migration => {
+            migrations.forEach((migration) => {
                 this.migrationCache.set(migration.name, migration);
             });
             this.logger.info(`✅ Discovered ${migrations.length} migration files`);
@@ -129,7 +129,7 @@ class SQLiteMigrationProvider {
             return this.migrationCache.get(name);
         }
         const migrations = await this.discoverMigrations();
-        return migrations.find(m => m.name === name) || null;
+        return migrations.find((m) => m.name === name) || null;
     }
     /**
      * Validate migration file
@@ -155,16 +155,16 @@ class SQLiteMigrationProvider {
         const dangerousPatterns = [
             /DROP\s+TABLE\s+(?!IF\s+EXISTS)/i,
             /DROP\s+INDEX\s+(?!IF\s+EXISTS)/i,
-            /DELETE\s+FROM\s+\w+\s+(?!WHERE)/i
+            /DELETE\s+FROM\s+\w+\s+(?!WHERE)/i,
         ];
-        dangerousPatterns.forEach(pattern => {
+        dangerousPatterns.forEach((pattern) => {
             if (pattern.test(migration.content)) {
                 errors.push('Dangerous operation detected - consider using IF EXISTS or WHERE clauses');
             }
         });
         return {
             valid: errors.length === 0,
-            errors
+            errors,
         };
     }
     /**
@@ -192,7 +192,8 @@ class SQLiteMigrationProvider {
         let sql = `-- Create table ${tableName} with SQLite optimizations\n`;
         sql += `CREATE TABLE IF NOT EXISTS ${tableName} (\n`;
         // Add columns with SQLite-specific types
-        const columnDefs = columns.map((col) => {
+        const columnDefs = columns
+            .map((col) => {
             let def = `  ${col.name} ${this.mapToSQLiteType(col.type)}`;
             if (col.primaryKey) {
                 def += ' PRIMARY KEY';
@@ -210,11 +211,14 @@ class SQLiteMigrationProvider {
                 def += ' UNIQUE';
             }
             return def;
-        }).join(',\n');
+        })
+            .join(',\n');
         sql += columnDefs;
         // Add constraints
         if (constraints.length > 0) {
-            sql += ',\n' + constraints.map((constraint) => `  ${constraint}`).join(',\n');
+            sql +=
+                ',\n' +
+                    constraints.map((constraint) => `  ${constraint}`).join(',\n');
         }
         sql += '\n);\n\n';
         // Add indexes with SQLite optimizations
@@ -284,29 +288,29 @@ class SQLiteMigrationProvider {
      */
     mapToSQLiteType(type) {
         const typeMap = {
-            'varchar': 'TEXT',
-            'char': 'TEXT',
-            'text': 'TEXT',
-            'string': 'TEXT',
-            'int': 'INTEGER',
-            'integer': 'INTEGER',
-            'bigint': 'INTEGER',
-            'smallint': 'INTEGER',
-            'tinyint': 'INTEGER',
-            'float': 'REAL',
-            'double': 'REAL',
-            'decimal': 'REAL',
-            'numeric': 'REAL',
-            'boolean': 'INTEGER',
-            'bool': 'INTEGER',
-            'date': 'TEXT',
-            'datetime': 'TEXT',
-            'timestamp': 'TEXT',
-            'time': 'TEXT',
-            'json': 'TEXT',
-            'jsonb': 'TEXT',
-            'uuid': 'TEXT',
-            'blob': 'BLOB'
+            varchar: 'TEXT',
+            char: 'TEXT',
+            text: 'TEXT',
+            string: 'TEXT',
+            int: 'INTEGER',
+            integer: 'INTEGER',
+            bigint: 'INTEGER',
+            smallint: 'INTEGER',
+            tinyint: 'INTEGER',
+            float: 'REAL',
+            double: 'REAL',
+            decimal: 'REAL',
+            numeric: 'REAL',
+            boolean: 'INTEGER',
+            bool: 'INTEGER',
+            date: 'TEXT',
+            datetime: 'TEXT',
+            timestamp: 'TEXT',
+            time: 'TEXT',
+            json: 'TEXT',
+            jsonb: 'TEXT',
+            uuid: 'TEXT',
+            blob: 'BLOB',
         };
         return typeMap[type.toLowerCase()] || 'TEXT';
     }
@@ -335,7 +339,7 @@ class SQLiteMigrationProvider {
         let hash = 0;
         for (let i = 0; i < content.length; i++) {
             const char = content.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
+            hash = (hash << 5) - hash + char;
             hash = hash & hash; // Convert to 32-bit integer
         }
         return hash.toString(16);

package/dist/cjs/testing/test-utils.js

@@ -9,7 +9,7 @@ const noormme_js_1 = require("../noormme.js");
  * Create an in-memory SQLite database for testing
  */
 async function createTestDatabase(config = {}) {
-    const { dialect = 'sqlite', database = ':memory:', cleanup = true, seed = false } = config;
+    const { dialect = 'sqlite', database = ':memory:', cleanup = true, seed = false, } = config;
     let dbConfig;
     switch (dialect) {
         case 'sqlite':
@@ -20,11 +20,11 @@ async function createTestDatabase(config = {}) {
                     host: '',
                     port: 0,
                     username: '',
-                    password: ''
+                    password: '',
                 },
                 logging: {
-                    enabled: process.env.TEST_DEBUG === 'true' // Enable with TEST_DEBUG=true
-                }
+                    enabled: process.env.TEST_DEBUG === 'true', // Enable with TEST_DEBUG=true
+                },
             };
             break;
         default:
@@ -45,35 +45,35 @@ async function setupTestSchema(db) {
     await kysely.schema
         .createTable('users')
         .ifNotExists()
-        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
-        .addColumn('name', 'varchar(255)', col => col.notNull())
-        .addColumn('email', 'varchar(255)', col => col.notNull().unique())
+        .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
+        .addColumn('name', 'varchar(255)', (col) => col.notNull())
+        .addColumn('email', 'varchar(255)', (col) => col.notNull().unique())
         .addColumn('age', 'integer')
-        .addColumn('active', 'boolean', col => col.defaultTo(true))
-        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
-        .addColumn('updated_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .addColumn('active', 'boolean', (col) => col.defaultTo(true))
+        .addColumn('created_at', 'timestamp', (col) => col.defaultTo('now()').notNull())
+        .addColumn('updated_at', 'timestamp', (col) => col.defaultTo('now()').notNull())
         .execute();
     // Create posts table
     await kysely.schema
         .createTable('posts')
         .ifNotExists()
-        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
-        .addColumn('title', 'varchar(255)', col => col.notNull())
+        .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
+        .addColumn('title', 'varchar(255)', (col) => col.notNull())
         .addColumn('content', 'text')
-        .addColumn('user_id', 'integer', col => col.references('users.id').onDelete('cascade'))
-        .addColumn('published', 'boolean', col => col.defaultTo(false))
-        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
-        .addColumn('updated_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .addColumn('user_id', 'integer', (col) => col.references('users.id').onDelete('cascade'))
+        .addColumn('published', 'boolean', (col) => col.defaultTo(false))
+        .addColumn('created_at', 'timestamp', (col) => col.defaultTo('now()').notNull())
+        .addColumn('updated_at', 'timestamp', (col) => col.defaultTo('now()').notNull())
         .execute();
     // Create comments table
     await kysely.schema
         .createTable('comments')
         .ifNotExists()
-        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
-        .addColumn('content', 'text', col => col.notNull())
-        .addColumn('post_id', 'integer', col => col.references('posts.id').onDelete('cascade'))
-        .addColumn('user_id', 'integer', col => col.references('users.id').onDelete('cascade'))
-        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
+        .addColumn('content', 'text', (col) => col.notNull())
+        .addColumn('post_id', 'integer', (col) => col.references('posts.id').onDelete('cascade'))
+        .addColumn('user_id', 'integer', (col) => col.references('users.id').onDelete('cascade'))
+        .addColumn('created_at', 'timestamp', (col) => col.defaultTo('now()').notNull())
         .execute();
     // Create indexes for better performance
     await kysely.schema
@@ -121,7 +121,8 @@ async function setupTestSchema(db) {
         // Try to manually check if tables exist
         let actualTables = [];
         try {
-            actualTables = await kysely.selectFrom('sqlite_master')
+            actualTables = await kysely
+                .selectFrom('sqlite_master')
                 .select(['name', 'type'])
                 .where('type', '=', 'table')
                 .where('name', 'not like', 'sqlite_%')
@@ -134,9 +135,9 @@ async function setupTestSchema(db) {
             `Discovery error: ${discoveryError ? discoveryError.join(' ') : 'Unknown'}`);
     }
     // Verify expected tables exist
-    const tableNames = schemaInfo.tables.map(t => t.name);
+    const tableNames = schemaInfo.tables.map((t) => t.name);
     const expectedTables = ['users', 'posts', 'comments'];
-    const missingTables = expectedTables.filter(t => !tableNames.includes(t));
+    const missingTables = expectedTables.filter((t) => !tableNames.includes(t));
     if (missingTables.length > 0) {
         throw new Error(`Test setup failed: Missing tables: ${missingTables.join(', ')}. ` +
             `Found tables: ${tableNames.join(', ')}. ` +
@@ -192,7 +193,7 @@ class TestDataFactory {
             email: this.generateUniqueEmail(),
             age: 25,
             active: true,
-            ...overrides
+            ...overrides,
         };
         return await userRepo.create(userData);
     }
@@ -204,7 +205,7 @@ class TestDataFactory {
         for (let i = 0; i < count; i++) {
             const user = await this.createUser({
                 name: `Test User ${i + 1}`,
-                ...overrides
+                ...overrides,
             });
             users.push(user);
         }
@@ -220,7 +221,7 @@ class TestDataFactory {
             content: 'This is a test post content',
             user_id: userId,
             published: false,
-            ...overrides
+            ...overrides,
         };
         return await postRepo.create(postData);
     }
@@ -232,7 +233,7 @@ class TestDataFactory {
         for (let i = 0; i < count; i++) {
             const post = await this.createPost(userId, {
                 title: `Test Post ${i + 1}`,
-                ...overrides
+                ...overrides,
             });
             posts.push(post);
         }
@@ -247,7 +248,7 @@ class TestDataFactory {
             content: 'This is a test comment',
             post_id: postId,
             user_id: userId,
-            ...overrides
+            ...overrides,
         };
         return await commentRepo.create(commentData);
     }
@@ -259,7 +260,7 @@ class TestDataFactory {
         for (let i = 0; i < count; i++) {
             const comment = await this.createComment(postId, userId, {
                 content: `Test comment ${i + 1}`,
-                ...overrides
+                ...overrides,
             });
             comments.push(comment);
         }
@@ -313,7 +314,8 @@ class TestUtils {
             throw new Error('Expected promise to reject, but it resolved');
         }
         catch (error) {
-            if (expectedErrorMessage && !String(error).includes(expectedErrorMessage)) {
+            if (expectedErrorMessage &&
+                !String(error).includes(expectedErrorMessage)) {
                 throw new Error(`Expected error message to contain "${expectedErrorMessage}", but got: ${error}`);
             }
             return error;
@@ -337,10 +339,10 @@ class TestUtils {
             calls.push(args);
         });
         Object.defineProperty(spy, 'calls', {
-            get: () => calls
+            get: () => calls,
         });
         Object.defineProperty(spy, 'callCount', {
-            get: () => calls.length
+            get: () => calls.length,
         });
         return spy;
     }
@@ -348,7 +350,7 @@ class TestUtils {
      * Delay execution for testing timing-sensitive operations
      */
     static delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
 }
 exports.TestUtils = TestUtils;

package/dist/cjs/types/index.d.ts

@@ -197,11 +197,14 @@ export interface EntityType {
 }
 export interface DjangoManager<T> {
     all(): Promise<T[]>;
-    get(id: string | number): Promise<T | null>;
-    get(filter: Partial<T>): Promise<T | null>;
+    get(idOrFilter: string | number | Partial<T>): Promise<T | null>;
     filter(filter: Partial<T>): DjangoManager<T>;
+    filter(column: string, operator: string, value: any): DjangoManager<T>;
     exclude(filter: Partial<T>): DjangoManager<T>;
+    exclude(column: string, operator: string, value: any): DjangoManager<T>;
     order_by(...columns: (keyof T | string)[]): DjangoManager<T>;
+    limit(count: number): DjangoManager<T>;
+    offset(count: number): DjangoManager<T>;
     count(): Promise<number>;
     exists(): Promise<boolean>;
     first(): Promise<T | null>;

package/dist/cjs/types/index.js

@@ -14,15 +14,18 @@ function validateNOORMConfig(config) {
     }
     // Validate dialect-specific requirements
     if (config.dialect === 'sqlite') {
-        if (!config.connection.database.endsWith('.db') && !config.connection.database.endsWith('.sqlite')) {
+        if (!config.connection.database.endsWith('.db') &&
+            !config.connection.database.endsWith('.sqlite')) {
             console.warn('SQLite database path should typically end with .db or .sqlite');
         }
     }
     // Validate performance settings
-    if (config.performance?.maxBatchSize && config.performance.maxBatchSize <= 0) {
+    if (config.performance?.maxBatchSize &&
+        config.performance.maxBatchSize <= 0) {
         throw new Error('maxBatchSize must be greater than 0');
     }
-    if (config.performance?.maxCacheSize && config.performance.maxCacheSize <= 0) {
+    if (config.performance?.maxCacheSize &&
+        config.performance.maxCacheSize <= 0) {
         throw new Error('maxCacheSize must be greater than 0');
     }
 }

package/dist/cjs/types/type-generator.js

@@ -30,7 +30,7 @@ class TypeGenerator {
         return {
             entities,
             interfaces,
-            types
+            types,
         };
     }
     /**
@@ -53,7 +53,7 @@ class TypeGenerator {
             interface: interfaceCode,
             insertType,
             updateType,
-            selectType
+            selectType,
         };
     }
     /**
@@ -175,54 +175,58 @@ class TypeGenerator {
         // Handle PostgreSQL array types
         if (column.type.endsWith('[]')) {
             const baseType = column.type.slice(0, -2);
-            const elementType = this.mapColumnToTypeScript({ ...column, type: baseType, nullable: false });
+            const elementType = this.mapColumnToTypeScript({
+                ...column,
+                type: baseType,
+                nullable: false,
+            });
             const arrayType = `Array<${elementType}>`;
             return column.nullable ? `${arrayType} | null` : arrayType;
         }
         const typeMapping = {
             // PostgreSQL types
-            'varchar': 'string',
-            'text': 'string',
-            'char': 'string',
-            'integer': 'number',
-            'bigint': 'number',
-            'smallint': 'number',
-            'decimal': 'number',
-            'numeric': 'number',
-            'real': 'number',
+            varchar: 'string',
+            text: 'string',
+            char: 'string',
+            integer: 'number',
+            bigint: 'number',
+            smallint: 'number',
+            decimal: 'number',
+            numeric: 'number',
+            real: 'number',
             'double precision': 'number',
-            'boolean': 'boolean',
-            'date': 'Date',
-            'timestamp': 'Date',
-            'timestamptz': 'Date',
-            'time': 'Date',
-            'json': 'Record<string, unknown>',
-            'jsonb': 'Record<string, unknown>',
-            'uuid': 'string',
-            'tsvector': 'string',
-            'tsquery': 'string',
+            boolean: 'boolean',
+            date: 'Date',
+            timestamp: 'Date',
+            timestamptz: 'Date',
+            time: 'Date',
+            json: 'Record<string, unknown>',
+            jsonb: 'Record<string, unknown>',
+            uuid: 'string',
+            tsvector: 'string',
+            tsquery: 'string',
             // MySQL specific types
-            'longtext': 'string',
-            'mediumtext': 'string',
-            'tinytext': 'string',
-            'int': 'number',
-            'tinyint': 'number',
-            'float': 'number',
-            'double': 'number',
-            'bool': 'boolean',
-            'datetime': 'Date',
+            longtext: 'string',
+            mediumtext: 'string',
+            tinytext: 'string',
+            int: 'number',
+            tinyint: 'number',
+            float: 'number',
+            double: 'number',
+            bool: 'boolean',
+            datetime: 'Date',
             // SQLite specific types (enhanced)
-            'blob': 'Buffer',
-            'int2': 'number',
-            'int8': 'number',
-            'clob': 'string',
+            blob: 'Buffer',
+            int2: 'number',
+            int8: 'number',
+            clob: 'string',
             // MSSQL specific types
-            'nvarchar': 'string',
-            'nchar': 'string',
-            'ntext': 'string',
-            'bit': 'boolean',
-            'datetime2': 'Date',
-            'smalldatetime': 'Date'
+            nvarchar: 'string',
+            nchar: 'string',
+            ntext: 'string',
+            bit: 'boolean',
+            datetime2: 'Date',
+            smalldatetime: 'Date',
         };
         // Try exact match first
         if (typeMapping[column.type.toLowerCase()]) {
@@ -250,7 +254,7 @@ class TypeGenerator {
      * Get relationships for a specific table
      */
     getRelationshipsForTable(tableName, relationships) {
-        return relationships.filter(rel => rel.fromTable === tableName);
+        return relationships.filter((rel) => rel.fromTable === tableName);
     }
     /**
      * Convert string to camelCase

package/dist/cjs/util/safe-sql-helpers.js

@@ -55,7 +55,7 @@ function safeOffset(offset) {
  */
 function safeKeyword(keyword, allowedKeywords) {
     const normalized = keyword.toUpperCase().trim();
-    const allowedNormalized = allowedKeywords.map(k => k.toUpperCase().trim());
+    const allowedNormalized = allowedKeywords.map((k) => k.toUpperCase().trim());
     if (!allowedNormalized.includes(normalized)) {
         throw new Error(`Invalid keyword: "${keyword}". Allowed keywords: ${allowedKeywords.join(', ')}`);
     }

package/dist/cjs/util/security-validator.js

@@ -62,7 +62,12 @@ function validateIdentifier(identifier, context = 'identifier') {
     }
     // Additional check: prevent reserved SQLite keywords that could be dangerous
     const reservedKeywords = [
-        'PRAGMA', 'ATTACH', 'DETACH', 'VACUUM', 'ANALYZE', 'REINDEX'
+        'PRAGMA',
+        'ATTACH',
+        'DETACH',
+        'VACUUM',
+        'ANALYZE',
+        'REINDEX',
     ];
     for (const keyword of reservedKeywords) {
         if (identifier.toUpperCase() === keyword) {
@@ -83,7 +88,11 @@ function validateTableReference(tableRef) {
     }
     // Validate each part
     parts.forEach((part, index) => {
-        const context = index === 0 ? (parts.length === 2 ? 'schema name' : 'table name') : 'table name';
+        const context = index === 0
+            ? parts.length === 2
+                ? 'schema name'
+                : 'table name'
+            : 'table name';
         validateIdentifier(part, context);
     });
 }
@@ -108,7 +117,8 @@ function validateColumnReference(columnRef) {
             context = index === 0 ? 'table name' : 'column name';
         }
         else {
-            context = index === 0 ? 'schema name' : (index === 1 ? 'table name' : 'column name');
+            context =
+                index === 0 ? 'schema name' : index === 1 ? 'table name' : 'column name';
         }
         validateIdentifier(part, context);
     });
@@ -140,7 +150,7 @@ function validateFilePath(filePath, allowedExtensions) {
     }
     // Validate file extension if specified
     if (allowedExtensions && allowedExtensions.length > 0) {
-        const hasValidExtension = allowedExtensions.some(ext => filePath.toLowerCase().endsWith(ext.toLowerCase()));
+        const hasValidExtension = allowedExtensions.some((ext) => filePath.toLowerCase().endsWith(ext.toLowerCase()));
         if (!hasValidExtension) {
             throw new Error(`Invalid file extension for "${filePath}". ` +
                 `Allowed extensions: ${allowedExtensions.join(', ')}`);
@@ -164,7 +174,9 @@ function validateFilePath(filePath, allowedExtensions) {
 function sanitizeDatabasePath(dbPath) {
     validateFilePath(dbPath, ['.db', '.sqlite', '.sqlite3', '.db3']);
     // Ensure the path doesn't escape current directory
-    if (dbPath.includes('..') || dbPath.startsWith('/') || /^[a-zA-Z]:/.test(dbPath)) {
+    if (dbPath.includes('..') ||
+        dbPath.startsWith('/') ||
+        /^[a-zA-Z]:/.test(dbPath)) {
         throw new Error(`Database path "${dbPath}" must be a relative path within the current directory`);
     }
     return dbPath;
@@ -221,8 +233,7 @@ class RateLimiter {
     maxAttempts;
     windowMs;
     attempts = new Map();
-    constructor(maxAttempts = 10, windowMs = 60000 // 1 minute
-    ) {
+    constructor(maxAttempts = 10, windowMs = 60000) {
         this.maxAttempts = maxAttempts;
         this.windowMs = windowMs;
     }
@@ -230,7 +241,7 @@ class RateLimiter {
         const now = Date.now();
         const attempts = this.attempts.get(key) || [];
         // Remove old attempts outside the window
-        const recentAttempts = attempts.filter(time => now - time < this.windowMs);
+        const recentAttempts = attempts.filter((time) => now - time < this.windowMs);
         if (recentAttempts.length >= this.maxAttempts) {
             throw new Error(`Rate limit exceeded for ${key}. Please wait before trying again.`);
         }
@@ -243,7 +254,7 @@ class RateLimiter {
     }
     cleanup(now) {
         for (const [key, attempts] of this.attempts.entries()) {
-            const recentAttempts = attempts.filter(time => now - time < this.windowMs);
+            const recentAttempts = attempts.filter((time) => now - time < this.windowMs);
             if (recentAttempts.length === 0) {
                 this.attempts.delete(key);
             }

package/dist/cjs/utils/errorHelpers.js

@@ -26,11 +26,15 @@ function wrapKyselyError(error, context) {
         }
     }
     // Handle connection errors
-    if (message.includes('connect') || message.includes('ECONNREFUSED') || message.includes('ENOTFOUND')) {
+    if (message.includes('connect') ||
+        message.includes('ECONNREFUSED') ||
+        message.includes('ENOTFOUND')) {
         return new NoormError_js_1.ConnectionError(message, error);
     }
     // Handle authentication errors
-    if (message.includes('authentication') || message.includes('password') || message.includes('SASL')) {
+    if (message.includes('authentication') ||
+        message.includes('password') ||
+        message.includes('SASL')) {
         return new NoormError_js_1.ConnectionError('Authentication failed. Check your username and password.', error);
     }
     // Handle syntax errors
@@ -38,17 +42,19 @@ function wrapKyselyError(error, context) {
         return new NoormError_js_1.NoormError(`SQL syntax error: ${message}`, {
             table: context.table,
             operation: context.operation,
-            suggestion: 'Check your query syntax or report this as a bug if you\'re using NOORMME methods',
-            originalError: error
+            suggestion: "Check your query syntax or report this as a bug if you're using NOORMME methods",
+            originalError: error,
         });
     }
     // Handle constraint violations
-    if (message.includes('constraint') || message.includes('duplicate') || message.includes('unique')) {
+    if (message.includes('constraint') ||
+        message.includes('duplicate') ||
+        message.includes('unique')) {
         return new NoormError_js_1.NoormError(`Database constraint violation: ${extractConstraintMessage(message)}`, {
             table: context.table,
             operation: context.operation,
             suggestion: 'Check for duplicate values or foreign key violations',
-            originalError: error
+            originalError: error,
         });
     }
     // Generic wrapper for other errors
@@ -56,7 +62,7 @@ function wrapKyselyError(error, context) {
         table: context.table,
         operation: context.operation,
         suggestion: 'Check the database connection and query parameters',
-        originalError: error
+        originalError: error,
     });
 }
 /**
@@ -121,14 +127,15 @@ function suggestCorrections(input, available, maxSuggestions = 3) {
     const suggestions = [];
     for (const option of available) {
         const score = calculateSimilarity(input.toLowerCase(), option.toLowerCase());
-        if (score > 0.3) { // Only suggest if similarity > 30%
+        if (score > 0.3) {
+            // Only suggest if similarity > 30%
             suggestions.push({ name: option, score });
         }
     }
     return suggestions
         .sort((a, b) => b.score - a.score)
         .slice(0, maxSuggestions)
-        .map(s => s.name);
+        .map((s) => s.name);
 }
 /**
  * Calculate string similarity using Jaro-Winkler algorithm (simplified)
@@ -173,7 +180,10 @@ function calculateSimilarity(str1, str2) {
             transpositions++;
         k++;
     }
-    const jaro = (matches / len1 + matches / len2 + (matches - transpositions / 2) / matches) / 3;
+    const jaro = (matches / len1 +
+        matches / len2 +
+        (matches - transpositions / 2) / matches) /
+        3;
     // Jaro-Winkler bonus for common prefix
     let prefix = 0;
     for (let i = 0; i < Math.min(len1, len2, 4); i++) {