noormme 1.1.0 → 1.2.0

package/dist/esm/repository/repository-factory.js

@@ -1,5 +1,5 @@
 /// <reference types="./repository-factory.d.ts" />
-import { RelationshipNotFoundError, ColumnNotFoundError } from '../errors/NoormError.js';
+import { RelationshipNotFoundError, ColumnNotFoundError, } from '../errors/NoormError.js';
 import { RelationshipEngine } from '../relationships/relationship-engine.js';
 import { CognitiveRepository } from '../agentic/CognitiveRepository.js';
 /**
@@ -16,7 +16,9 @@ class DjangoManagerImpl {
         this.table = table;
         this.primaryKey = primaryKey;
         this.transformer = transformer;
-        this.query = initialQuery || this.db.selectFrom(this.table.name).selectAll();
+        this.query =
+            initialQuery ||
+                this.db.selectFrom(this.table.name).selectAll();
     }
     async all() {
         return this.execute();
@@ -34,33 +36,53 @@ class DjangoManagerImpl {
         const result = await q.executeTakeFirst();
         return result ? this.transformer(result) : null;
     }
-    filter(filter) {
+    filter(filterOrColumn, operator, value) {
         let q = this.query;
-        for (const [key, value] of Object.entries(filter)) {
-            if (value !== undefined) {
-                q = q.where(key, '=', value);
+        if (typeof filterOrColumn === 'object') {
+            for (const [key, val] of Object.entries(filterOrColumn)) {
+                if (val !== undefined) {
+                    q = q.where(key, '=', val);
+                }
             }
         }
+        else if (operator && value !== undefined) {
+            q = q.where(filterOrColumn, operator, value);
+        }
         return new DjangoManagerImpl(this.db, this.table, this.primaryKey, this.transformer, q);
     }
-    exclude(filter) {
+    exclude(filterOrColumn, operator, value) {
         let q = this.query;
-        for (const [key, value] of Object.entries(filter)) {
-            if (value !== undefined) {
-                q = q.where(key, '!=', value);
+        if (typeof filterOrColumn === 'object') {
+            for (const [key, val] of Object.entries(filterOrColumn)) {
+                if (val !== undefined) {
+                    q = q.where(key, '!=', val);
+                }
             }
         }
+        else if (operator && value !== undefined) {
+            // For simple exclude with operator, we invert the operator if possible or use !=
+            const negOperator = operator === '=' ? '!=' : operator === '!=' ? '=' : '!=';
+            q = q.where(filterOrColumn, negOperator, value);
+        }
         return new DjangoManagerImpl(this.db, this.table, this.primaryKey, this.transformer, q);
     }
     order_by(...columns) {
         let q = this.query;
         for (const col of columns) {
             const direction = String(col).startsWith('-') ? 'desc' : 'asc';
-            const actualCol = String(col).startsWith('-') ? String(col).substring(1) : String(col);
+            const actualCol = String(col).startsWith('-')
+                ? String(col).substring(1)
+                : String(col);
             q = q.orderBy(actualCol, direction);
         }
         return new DjangoManagerImpl(this.db, this.table, this.primaryKey, this.transformer, q);
     }
+    limit(count) {
+        return new DjangoManagerImpl(this.db, this.table, this.primaryKey, this.transformer, this.query.limit(count));
+    }
+    offset(count) {
+        return new DjangoManagerImpl(this.db, this.table, this.primaryKey, this.transformer, this.query.offset(count));
+    }
     async count() {
         const result = await this.query
             .clearSelect()
@@ -69,7 +91,9 @@ class DjangoManagerImpl {
         return Number(result?.count || 0);
     }
     async exists() {
-        const result = await this.query.select(this.primaryKey).executeTakeFirst();
+        const result = await this.query
+            .select(this.primaryKey)
+            .executeTakeFirst();
         return result !== undefined;
     }
     async first() {
@@ -77,7 +101,10 @@ class DjangoManagerImpl {
         return result ? this.transformer(result) : null;
     }
     async last() {
-        const result = await this.query.orderBy(this.primaryKey, 'desc').limit(1).executeTakeFirst();
+        const result = await this.query
+            .orderBy(this.primaryKey, 'desc')
+            .limit(1)
+            .executeTakeFirst();
         return result ? this.transformer(result) : null;
     }
     async create(data) {
@@ -136,14 +163,17 @@ export class RepositoryFactory {
      */
     transformData(data, table) {
         const booleanColumns = table.columns
-            .filter(col => col.type.toLowerCase() === 'boolean' || col.type.toLowerCase() === 'bool')
-            .map(col => col.name);
+            .filter((col) => col.type.toLowerCase() === 'boolean' ||
+            col.type.toLowerCase() === 'bool')
+            .map((col) => col.name);
         const dateColumns = table.columns
-            .filter(col => {
+            .filter((col) => {
             const type = col.type.toLowerCase();
-            return type.includes('date') || type.includes('timestamp') || type.includes('time');
+            return (type.includes('date') ||
+                type.includes('timestamp') ||
+                type.includes('time'));
         })
-            .map(col => col.name);
+            .map((col) => col.name);
         if (booleanColumns.length === 0 && dateColumns.length === 0)
             return data;
         const transformRecord = (record) => {
@@ -164,7 +194,8 @@ export class RepositoryFactory {
             // Transform dates
             for (const col of dateColumns) {
                 if (col in transformed && transformed[col]) {
-                    if (typeof transformed[col] === 'string' || typeof transformed[col] === 'number') {
+                    if (typeof transformed[col] === 'string' ||
+                        typeof transformed[col] === 'number') {
                         const date = new Date(transformed[col]);
                         if (!isNaN(date.getTime()))
                             transformed[col] = date;
@@ -173,14 +204,16 @@ export class RepositoryFactory {
             }
             return transformed;
         };
-        return Array.isArray(data) ? data.map(transformRecord) : transformRecord(data);
+        return Array.isArray(data)
+            ? data.map(transformRecord)
+            : transformRecord(data);
     }
     /**
      * Create a repository for the specified table
      */
     createRepository(table, relationships) {
         this.setRelationships(relationships);
-        const primaryKey = table.columns.find(c => c.isPrimaryKey)?.name || 'id';
+        const primaryKey = table.columns.find((c) => c.isPrimaryKey)?.name || 'id';
         const transformer = (data) => this.transformData(data, table);
         const baseRepository = {
             objects: new DjangoManagerImpl(this.db, table, primaryKey, transformer),
@@ -193,7 +226,10 @@ export class RepositoryFactory {
                 return result ? transformer(result) : null;
             },
             findAll: async () => {
-                const results = await this.db.selectFrom(table.name).selectAll().execute();
+                const results = await this.db
+                    .selectFrom(table.name)
+                    .selectAll()
+                    .execute();
                 return transformer(results);
             },
             create: async (data) => {
@@ -217,20 +253,32 @@ export class RepositoryFactory {
                 return transformer(result);
             },
             delete: async (id) => {
-                const result = await this.db.deleteFrom(table.name).where(primaryKey, '=', id).executeTakeFirst();
+                const result = await this.db
+                    .deleteFrom(table.name)
+                    .where(primaryKey, '=', id)
+                    .executeTakeFirst();
                 return Number(result.numDeletedRows || 0) > 0;
             },
             count: async () => {
-                const result = await this.db.selectFrom(table.name).select((eb) => eb.fn.countAll().as('count')).executeTakeFirst();
+                const result = await this.db
+                    .selectFrom(table.name)
+                    .select((eb) => eb.fn.countAll().as('count'))
+                    .executeTakeFirst();
                 return Number(result?.count || 0);
             },
             exists: async (id) => {
-                const result = await this.db.selectFrom(table.name).select(primaryKey).where(primaryKey, '=', id).executeTakeFirst();
+                const result = await this.db
+                    .selectFrom(table.name)
+                    .select(primaryKey)
+                    .where(primaryKey, '=', id)
+                    .executeTakeFirst();
                 return result !== undefined;
             },
             paginate: async (options) => {
                 let query = this.db.selectFrom(table.name).selectAll();
-                let countQuery = this.db.selectFrom(table.name).select((eb) => eb.fn.countAll().as('count'));
+                let countQuery = this.db
+                    .selectFrom(table.name)
+                    .select((eb) => eb.fn.countAll().as('count'));
                 if (options.where) {
                     for (const [key, value] of Object.entries(options.where)) {
                         if (value !== undefined) {
@@ -254,8 +302,8 @@ export class RepositoryFactory {
                         total,
                         totalPages,
                         hasNext: options.page < totalPages,
-                        hasPrev: options.page > 1
-                    }
+                        hasPrev: options.page > 1,
+                    },
                 };
             },
             findWithRelations: async (id, relations) => {
@@ -271,23 +319,27 @@ export class RepositoryFactory {
                 await this.relationshipEngine.loadRelationships(entities, relations);
             },
             withCount: async (id, relationshipNames) => {
-                const entity = await baseRepository.findById(id);
+                const entity = (await baseRepository.findById(id));
                 if (!entity)
                     throw new Error(`Entity ${id} not found`);
-                const tableRelationships = relationships.filter(r => r.fromTable === table.name);
+                const tableRelationships = relationships.filter((r) => r.fromTable === table.name);
                 const counts = {};
                 for (const name of relationshipNames) {
-                    const rel = tableRelationships.find(r => r.name === name);
+                    const rel = tableRelationships.find((r) => r.name === name);
                     if (!rel)
-                        throw new RelationshipNotFoundError(name, table.name, tableRelationships.map(r => r.name));
+                        throw new RelationshipNotFoundError(name, table.name, tableRelationships.map((r) => r.name));
                     const val = entity[rel.fromColumn];
                     if (val !== undefined) {
-                        const res = await this.db.selectFrom(rel.toTable).select((eb) => eb.fn.countAll().as('count')).where(rel.toColumn, '=', val).executeTakeFirst();
+                        const res = await this.db
+                            .selectFrom(rel.toTable)
+                            .select((eb) => eb.fn.countAll().as('count'))
+                            .where(rel.toColumn, '=', val)
+                            .executeTakeFirst();
                         counts[`${name}Count`] = Number(res?.count || 0);
                     }
                 }
                 return { ...entity, ...counts };
-            }
+            },
         };
         let repository = this.wrapWithDynamicMethods(baseRepository, table);
         if (this.cortex)
@@ -295,7 +347,7 @@ export class RepositoryFactory {
         return repository;
     }
     wrapWithDynamicMethods(repository, table) {
-        const availableColumns = table.columns.map(c => c.name);
+        const availableColumns = table.columns.map((c) => c.name);
         const db = this.db;
         const transformer = (data) => this.transformData(data, table);
         return new Proxy(repository, {
@@ -304,16 +356,23 @@ export class RepositoryFactory {
                     return Reflect.get(target, prop, receiver);
                 if (typeof prop === 'string' && prop.startsWith('findBy')) {
                     return async (value) => {
-                        const columnName = prop.substring(6).replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-                        const actualColumn = availableColumns.find(col => col.toLowerCase() === columnName.toLowerCase());
+                        const columnName = prop
+                            .substring(6)
+                            .replace(/([a-z])([A-Z])/g, '$1_$2')
+                            .toLowerCase();
+                        const actualColumn = availableColumns.find((col) => col.toLowerCase() === columnName.toLowerCase());
                         if (!actualColumn)
                             throw new ColumnNotFoundError(columnName, table.name, availableColumns);
-                        const result = await db.selectFrom(table.name).selectAll().where(actualColumn, '=', value).executeTakeFirst();
+                        const result = await db
+                            .selectFrom(table.name)
+                            .selectAll()
+                            .where(actualColumn, '=', value)
+                            .executeTakeFirst();
                         return transformer(result || null);
                     };
                 }
                 return undefined;
-            }
+            },
         });
     }
 }

package/dist/esm/schema/builders/alter-table-add-index-builder.js

@@ -1,7 +1,7 @@
 /// <reference types="./alter-table-add-index-builder.d.ts" />
 import { AddIndexNode } from '../../operation-node/add-index-node.js';
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
-import { IndexTypeNode } from '../../operation-node/index-type-node.js';
+import { IndexTypeNode, } from '../../operation-node/index-type-node.js';
 import { parseOrderedColumnName, } from '../../parser/reference-parser.js';
 import { freeze } from '../../util/object-utils.js';
 export class AlterTableAddIndexBuilder {

package/dist/esm/schema/builders/create-index-builder.js

@@ -1,6 +1,6 @@
 /// <reference types="./create-index-builder.d.ts" />
-import { CreateIndexNode, } from '../../operation-node/create-index-node.js';
-import { IndexTypeNode } from '../../operation-node/index-type-node.js';
+import { CreateIndexNode } from '../../operation-node/create-index-node.js';
+import { IndexTypeNode, } from '../../operation-node/index-type-node.js';
 import { parseOrderedColumnName, } from '../../parser/reference-parser.js';
 import { parseTable } from '../../parser/table-parser.js';
 import { freeze } from '../../util/object-utils.js';

package/dist/esm/schema/core/coordinators/schema-discovery.coordinator.js

@@ -22,9 +22,7 @@ export class SchemaDiscoveryCoordinator {
      */
     async discoverSchema(db, config = {}, dialect) {
         // Determine the dialect - handle both string and dialect objects
-        const dialectName = typeof dialect === 'string'
-            ? dialect
-            : dialect?.name || 'sqlite';
+        const dialectName = typeof dialect === 'string' ? dialect : dialect?.name || 'sqlite';
         this.currentDialect = dialectName;
         // Check if dialect is supported
         if (!this.factory.isDialectSupported(dialectName)) {

package/dist/esm/schema/core/discovery/relationship-discovery.js

@@ -20,7 +20,7 @@ export class RelationshipDiscovery {
         for (const table of tables) {
             for (const fk of table.foreignKeys) {
                 // Find the referenced table
-                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                const referencedTable = tables.find((t) => t.name === fk.referencedTable);
                 if (!referencedTable)
                     continue;
                 // Create relationship name based on column name
@@ -34,7 +34,7 @@ export class RelationshipDiscovery {
                     fromTable: table.name,
                     fromColumn: fk.column,
                     toTable: fk.referencedTable,
-                    toColumn: fk.referencedColumn
+                    toColumn: fk.referencedColumn,
                 });
                 // Add reverse relationship
                 const reverseName = NameGenerator.generateReverseRelationshipName(table.name, fk.column);
@@ -44,7 +44,7 @@ export class RelationshipDiscovery {
                     fromTable: fk.referencedTable,
                     fromColumn: fk.referencedColumn,
                     toTable: table.name,
-                    toColumn: fk.column
+                    toColumn: fk.column,
                 });
             }
         }
@@ -64,7 +64,7 @@ export class RelationshipDiscovery {
                         toColumn: fk2.referencedColumn,
                         throughTable: table.name,
                         throughFromColumn: fk1.column,
-                        throughToColumn: fk2.column
+                        throughToColumn: fk2.column,
                     });
                     // B -> A via Table
                     relationships.push({
@@ -76,7 +76,7 @@ export class RelationshipDiscovery {
                         toColumn: fk1.referencedColumn,
                         throughTable: table.name,
                         throughFromColumn: fk2.column,
-                        throughToColumn: fk1.column
+                        throughToColumn: fk1.column,
                     });
                 }
             }
@@ -91,7 +91,7 @@ export class RelationshipDiscovery {
             oneToMany: 0,
             manyToMany: 0,
             selfReferencing: 0,
-            circularReferences: []
+            circularReferences: [],
         };
         for (const table of tables) {
             for (const fk of table.foreignKeys) {
@@ -100,7 +100,7 @@ export class RelationshipDiscovery {
                     patterns.selfReferencing++;
                 }
                 // Check for many-to-many (junction tables)
-                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                const referencedTable = tables.find((t) => t.name === fk.referencedTable);
                 if (referencedTable && this.isJunctionTable(table)) {
                     patterns.manyToMany++;
                 }
@@ -122,10 +122,10 @@ export class RelationshipDiscovery {
         if (table.foreignKeys.length !== 2)
             return false;
         // 2. Mostly columns that are either PK or part of FKs
-        const fkColumns = new Set(table.foreignKeys.map(fk => fk.column));
+        const fkColumns = new Set(table.foreignKeys.map((fk) => fk.column));
         const pkColumns = new Set(table.primaryKey || []);
-        const otherColumns = table.columns.filter(col => !fkColumns.has(col.name) && !pkColumns.has(col.name));
-        // If it has too many "data" columns, it might not be a pure junction table, 
+        const otherColumns = table.columns.filter((col) => !fkColumns.has(col.name) && !pkColumns.has(col.name));
+        // If it has too many "data" columns, it might not be a pure junction table,
         // but we can still treat it as one for M2M navigation if it has 2 FKs.
         // Pure junction tables usually have 0-1 extra columns (like 'created_at').
         return otherColumns.length <= 2;
@@ -148,7 +148,7 @@ export class RelationshipDiscovery {
                 return;
             visited.add(tableName);
             recursionStack.add(tableName);
-            const table = tables.find(t => t.name === tableName);
+            const table = tables.find((t) => t.name === tableName);
             if (table) {
                 for (const fk of table.foreignKeys) {
                     dfs(fk.referencedTable, [...path, tableName]);
@@ -168,7 +168,7 @@ export class RelationshipDiscovery {
      */
     validateRelationships(tables) {
         const issues = [];
-        const tableNames = new Set(tables.map(t => t.name));
+        const tableNames = new Set(tables.map((t) => t.name));
         for (const table of tables) {
             for (const fk of table.foreignKeys) {
                 // Check if referenced table exists
@@ -176,15 +176,15 @@ export class RelationshipDiscovery {
                     issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent table '${fk.referencedTable}'`);
                 }
                 // Check if referenced column exists in referenced table
-                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                const referencedTable = tables.find((t) => t.name === fk.referencedTable);
                 if (referencedTable) {
-                    const referencedColumnExists = referencedTable.columns.some(col => col.name === fk.referencedColumn);
+                    const referencedColumnExists = referencedTable.columns.some((col) => col.name === fk.referencedColumn);
                     if (!referencedColumnExists) {
                         issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent column '${fk.referencedColumn}' in table '${fk.referencedTable}'`);
                     }
                 }
                 // Check if foreign key column exists
-                const fkColumnExists = table.columns.some(col => col.name === fk.column);
+                const fkColumnExists = table.columns.some((col) => col.name === fk.column);
                 if (!fkColumnExists) {
                     issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent column '${fk.column}'`);
                 }
@@ -192,7 +192,7 @@ export class RelationshipDiscovery {
         }
         return {
             isValid: issues.length === 0,
-            issues
+            issues,
         };
     }
 }

package/dist/esm/schema/core/discovery/table-metadata-discovery.js

@@ -38,7 +38,7 @@ export class TableMetadataDiscovery {
             const [columns, indexes, foreignKeys] = await Promise.all([
                 introspector.getColumns(table.name).catch(() => []),
                 introspector.getIndexes(table.name).catch(() => []),
-                introspector.getForeignKeys(table.name).catch(() => [])
+                introspector.getForeignKeys(table.name).catch(() => []),
             ]);
             // Find primary key columns
             const primaryKeyColumns = columns
@@ -52,7 +52,7 @@ export class TableMetadataDiscovery {
                 indexes: indexes.map((idx) => ({
                     name: idx.name,
                     columns: idx.columns,
-                    unique: idx.unique
+                    unique: idx.unique,
                 })),
                 foreignKeys: foreignKeys.map((fk) => ({
                     name: fk.name,
@@ -60,8 +60,8 @@ export class TableMetadataDiscovery {
                     referencedTable: fk.referencedTable,
                     referencedColumn: fk.referencedColumn,
                     onDelete: fk.onDelete,
-                    onUpdate: fk.onUpdate
-                }))
+                    onUpdate: fk.onUpdate,
+                })),
             };
         }
         catch (error) {
@@ -84,8 +84,8 @@ export class TableMetadataDiscovery {
                 indexCount: indexes.length,
                 foreignKeyCount: foreignKeys.length,
                 lastModified: new Date(), // Fallback
-                indexes: indexes.map(idx => idx.name),
-                constraints: foreignKeys.map(fk => fk.name)
+                indexes: indexes.map((idx) => idx.name),
+                constraints: foreignKeys.map((fk) => fk.name),
             };
         }
         catch (error) {
@@ -106,7 +106,7 @@ export class TableMetadataDiscovery {
             issues.push('Table must have at least one column');
         }
         // Check for duplicate column names
-        const columnNames = table.columns.map(col => col.name);
+        const columnNames = table.columns.map((col) => col.name);
         const duplicates = columnNames.filter((name, index) => columnNames.indexOf(name) !== index);
         if (duplicates.length > 0) {
             issues.push(`Duplicate column names found: ${duplicates.join(', ')}`);
@@ -114,14 +114,14 @@ export class TableMetadataDiscovery {
         // Check for valid primary key
         if (table.primaryKey && table.primaryKey.length > 0) {
             const primaryKeyColumns = table.primaryKey;
-            const invalidPkColumns = primaryKeyColumns.filter(pkCol => !table.columns.some(col => col.name === pkCol));
+            const invalidPkColumns = primaryKeyColumns.filter((pkCol) => !table.columns.some((col) => col.name === pkCol));
             if (invalidPkColumns.length > 0) {
                 issues.push(`Primary key references non-existent columns: ${invalidPkColumns.join(', ')}`);
             }
         }
         return {
             isValid: issues.length === 0,
-            issues
+            issues,
         };
     }
 }

package/dist/esm/schema/core/discovery/view-discovery.js

@@ -25,8 +25,9 @@ export class ViewDiscovery {
                     views.push({
                         name: table.name,
                         schema: table.schema,
-                        definition: (await this.getViewDefinition(introspector, table.name)) ?? undefined,
-                        columns: [] // Views don't have explicit columns in this context
+                        definition: (await this.getViewDefinition(introspector, table.name)) ??
+                            undefined,
+                        columns: [], // Views don't have explicit columns in this context
                     });
                 }
             }
@@ -81,7 +82,7 @@ export class ViewDiscovery {
             /UPDATE\s+SET/i,
             /INSERT\s+INTO/i,
             /TRUNCATE/i,
-            /ALTER\s+TABLE/i
+            /ALTER\s+TABLE/i,
         ];
         if (view.definition) {
             for (const pattern of dangerousPatterns) {
@@ -92,7 +93,7 @@ export class ViewDiscovery {
         }
         return {
             isValid: issues.length === 0,
-            issues
+            issues,
         };
     }
     /**

package/dist/esm/schema/core/factories/discovery-factory.js

@@ -88,7 +88,7 @@ export class DiscoveryFactory {
             relationshipDiscovery: this.createRelationshipDiscovery(),
             viewDiscovery: this.createViewDiscovery(),
             indexDiscovery: this.createIndexDiscovery(dialect),
-            constraintDiscovery: this.createConstraintDiscovery(dialect)
+            constraintDiscovery: this.createConstraintDiscovery(dialect),
         };
     }
     /**
@@ -115,7 +115,7 @@ export class DiscoveryFactory {
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 };
             case 'postgres':
             case 'postgresql':
@@ -125,7 +125,7 @@ export class DiscoveryFactory {
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: true
+                    supportsDeferredConstraints: true,
                 };
             default:
                 return {
@@ -134,7 +134,7 @@ export class DiscoveryFactory {
                     supportsConstraints: false,
                     supportsForeignKeys: false,
                     supportsCheckConstraints: false,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 };
         }
     }

package/dist/esm/schema/core/utils/name-generator.js

@@ -56,9 +56,13 @@ export class NameGenerator {
         }
         // Handle words that are already plural
         // Common plural endings that shouldn't be pluralized further
-        if (str.endsWith('ses') || str.endsWith('xes') || str.endsWith('zes') ||
-            str.endsWith('ches') || str.endsWith('shes') ||
-            str.endsWith('ies') || str.endsWith('ves')) {
+        if (str.endsWith('ses') ||
+            str.endsWith('xes') ||
+            str.endsWith('zes') ||
+            str.endsWith('ches') ||
+            str.endsWith('shes') ||
+            str.endsWith('ies') ||
+            str.endsWith('ves')) {
             return str;
         }
         // Handle words ending in 's' - likely already plural
@@ -71,11 +75,16 @@ export class NameGenerator {
             return str;
         }
         // Handle words ending in 'y' preceded by a consonant
-        if (str.endsWith('y') && str.length > 1 && !'aeiou'.includes(str[str.length - 2])) {
+        if (str.endsWith('y') &&
+            str.length > 1 &&
+            !'aeiou'.includes(str[str.length - 2])) {
             return str.slice(0, -1) + 'ies';
         }
         // Handle words ending in sh, ch, x, z
-        if (str.endsWith('sh') || str.endsWith('ch') || str.endsWith('x') || str.endsWith('z')) {
+        if (str.endsWith('sh') ||
+            str.endsWith('ch') ||
+            str.endsWith('x') ||
+            str.endsWith('z')) {
             return str + 'es';
         }
         // Default: add 's'