@solidxai/core 0.1.9-beta.5 → 0.1.9-beta.7

package/src/services/menu-item-metadata.service.ts

@@ -9,7 +9,7 @@ import { MenuItemMetadata } from '../entities/menu-item-metadata.entity';
 import { UpdateMenuItemMetadataDto } from '../dtos/update-menu-item-metadata.dto';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
-import { dasherize } from '@angular-devkit/core/src/utils/strings';
+import { kebabCase } from 'lodash';
 import { MenuItemMetadataRepository } from 'src/repository/menu-item-metadata.repository';
 import { SavedFiltersRepository } from 'src/repository/saved-filters.repository';
 
@@ -191,7 +191,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
             // TODO: Here we are assuming that we will always take the user to collection view of a model. 
             // We can make provision to take them other views also in the future. 
             // path = `/admin/core/${rootItem.module.name}/${rootItem.action.model.singularName}/${rootItem.action.view.name}`;
-            path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}?menuItemId=${menuItemId}&menuItemName=${menuItemName}&actionId=${actionId}&actionName=${actionName}${savedFilterId ? `&savedQuery=${savedFilterId}` : ''}`;
+            path = `/admin/core/${rootItem.module.name}/${kebabCase(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}?menuItemId=${menuItemId}&menuItemName=${menuItemName}&actionId=${actionId}&actionName=${actionName}${savedFilterId ? `&savedQuery=${savedFilterId}` : ''}`;
 
           }
         }

package/src/services/model-metadata.service.ts

@@ -7,7 +7,8 @@ import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
-import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
+import { kebabCase } from 'lodash';
+import { classify } from '../helpers/string.helper';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
@@ -586,32 +587,32 @@ export class ModelMetadataService {
 
       const filesToDelete = [];
       // <singularName>.entity.ts | The TypeORM model that needs to be deleted. | Automatic
-      const entityFilePath = `${modulePath}/entities/${dasherize(modelEntity.singularName)}.entity.ts`;
+      const entityFilePath = `${modulePath}/entities/${kebabCase(modelEntity.singularName)}.entity.ts`;
       filesToDelete.push(entityFilePath);
       this.logger.log(`About to delete entity file path: ${entityFilePath}`);
 
       // <singularName>.create.dto.ts | The TypeORM model that needs to be deleted. | Automatic
-      const createDtoFilePath = `${modulePath}/dtos/create-${dasherize(modelEntity.singularName)}.dto.ts`;
+      const createDtoFilePath = `${modulePath}/dtos/create-${kebabCase(modelEntity.singularName)}.dto.ts`;
       filesToDelete.push(createDtoFilePath);
       this.logger.log(`About to delete create DTO file path: ${createDtoFilePath}`);
 
       // <singularName>.update.dto.ts | The TypeORM model that needs to be deleted. | Automatic
-      const updateDtoFilePath = `${modulePath}/dtos/update-${dasherize(modelEntity.singularName)}.dto.ts`;
+      const updateDtoFilePath = `${modulePath}/dtos/update-${kebabCase(modelEntity.singularName)}.dto.ts`;
       filesToDelete.push(updateDtoFilePath);
       this.logger.log(`About to delete update DTO file path: ${updateDtoFilePath}`);
 
       // <singularName>.repository.ts | The TypeORM model that needs to be deleted. | Automatic
-      const repositoryFilePath = `${modulePath}/repositories/${dasherize(modelEntity.singularName)}.repository.ts`;
+      const repositoryFilePath = `${modulePath}/repositories/${kebabCase(modelEntity.singularName)}.repository.ts`;
       filesToDelete.push(repositoryFilePath);
       this.logger.log(`About to delete repository file path: ${repositoryFilePath}`);
 
       // <singularName>.service.ts | The TypeORM model that needs to be deleted. | Automatic
-      const serviceFilePath = `${modulePath}/services/${dasherize(modelEntity.singularName)}.service.ts`;
+      const serviceFilePath = `${modulePath}/services/${kebabCase(modelEntity.singularName)}.service.ts`;
       filesToDelete.push(serviceFilePath);
       this.logger.log(`About to delete service file path: ${serviceFilePath}`);
 
       // <singularName>.controller.ts | The TypeORM model that needs to be deleted. | Automatic
-      const controllerFilePath = `${modulePath}/controllers/${dasherize(modelEntity.singularName)}.controller.ts`;
+      const controllerFilePath = `${modulePath}/controllers/${kebabCase(modelEntity.singularName)}.controller.ts`;
       filesToDelete.push(controllerFilePath);
       this.logger.log(`About to delete controller file path: ${controllerFilePath}`);
 
@@ -713,11 +714,11 @@ export class ModelMetadataService {
 
     // <moduleName>.module.ts | Remove all references and imports of the deleted model files. | Automatic
     if (modulePath) {
-      const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module?.name)}.module.ts`);
+      const moduleFilePath = path.resolve(modulePath, `${kebabCase(modelEntity.module?.name)}.module.ts`);
       this.logger.log(`Removing model '${modelEntity.singularName}' references from module file: ${moduleFilePath}`);
       try {
         this.solidTsMorphService.begin();
-        const modelPathSegment = `/${dasherize(modelEntity.singularName)}.`;
+        const modelPathSegment = `/${kebabCase(modelEntity.singularName)}.`;
         const { removedIdentifiers } = this.solidTsMorphService.removeImports(
           moduleFilePath,
           spec => spec.includes(modelPathSegment)
@@ -930,7 +931,6 @@ export class ModelMetadataService {
       }
     };
 
-
     const modelFormView = {
       name: formViewName,
       displayName: `${model.displayName}`,
@@ -1415,7 +1415,6 @@ export class ModelMetadataService {
     const currentOffset = (meta.currentPage - 1) * meta.perPage;
     const currentIndexGlobal = currentOffset + index + 1;
 
-
     let prev: { record: any; offset: number; limit: number } | null = null;
     let next: { record: any; offset: number; limit: number } | null = null;
 
@@ -1517,5 +1516,4 @@ export class ModelMetadataService {
     };
   }
 
-
 }

package/src/services/module-metadata.service.ts

@@ -6,7 +6,7 @@ import { DataSource, EntityManager, SelectQueryBuilder } from 'typeorm';
 import { CreateModuleMetadataDto } from '../dtos/create-module-metadata.dto';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify } from '../helpers/string.helper';
 import { ConfigService } from '@nestjs/config';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
@@ -278,7 +278,6 @@ export class ModuleMetadataService {
         };
       }
 
-
       metaData.moduleMetadata.name = module?.name;
       metaData.moduleMetadata.displayName = module?.displayName;
       metaData.moduleMetadata.description = module?.description;

package/src/services/queues/database-subscriber.service.ts

@@ -34,7 +34,7 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
         return this._loggerInstance;
     }
 
-    abstract subscribe(message: QueueMessage<T>);
+    abstract subscribe(message: QueueMessage<T>): Promise<any>;
 
     abstract options(): QueuesModuleOptions;
 

package/src/services/queues/publisher-factory.service.ts

@@ -2,10 +2,9 @@ import { forwardRef, Inject, Logger } from '@nestjs/common';
 import { Injectable } from '@nestjs/common';
 
 import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify } from '../../helpers/string.helper';
 import { SolidIntrospectService } from '../solid-introspect.service';
 
-
 @Injectable()
 export class PublisherFactory<T> {
     private readonly logger = new Logger(PublisherFactory.name);

package/src/services/queues/rabbitmq-subscriber.service.ts

@@ -52,7 +52,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         return this._loggerInstance;
     }
 
-    abstract subscribe(message: QueueMessage<T>);
+    abstract subscribe(message: QueueMessage<T>): Promise<any>;
 
     abstract options(): QueuesModuleOptions;
 
@@ -458,16 +458,18 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         // Main subscriber work promise.
         // If timeout has already fired, suppress rethrow to avoid unhandled rejection noise
         // (the timeout error is already the authoritative failure we track).
-        const subscribePromise = this.subscribe(message).catch((error) => {
-            if (timedOut) {
-                this.logger.error(
-                    `Subscriber promise rejected after timeout for queue ${queueName} and messageId ${messageId}: ${(error as Error)?.message || String(error)}`,
-                    (error as Error)?.stack,
-                );
-                return undefined;
-            }
-            throw error;
-        });
+        const subscribePromise = Promise.resolve()
+            .then(() => this.subscribe(message))
+            .catch((error) => {
+                if (timedOut) {
+                    this.logger.error(
+                        `Subscriber promise rejected after timeout for queue ${queueName} and messageId ${messageId}: ${(error as Error)?.message || String(error)}`,
+                        (error as Error)?.stack,
+                    );
+                    return undefined;
+                }
+                throw error;
+            });
 
         // Timeout promise rejects after timeoutMs with an explicit domain-specific error.
         const timeoutPromise = new Promise<never>((_, reject) => {

package/src/services/queues/redis-subscriber.service.ts

@@ -23,7 +23,7 @@ export abstract class RedisSubscriber<T> implements OnModuleInit, OnModuleDestro
         }
     }
 
-    abstract subscribe(message: QueueMessage<T>): void;
+    abstract subscribe(message: QueueMessage<T>): Promise<any>;
 
     abstract options(): QueuesModuleOptions;
 
@@ -205,4 +205,4 @@ export abstract class RedisSubscriber<T> implements OnModuleInit, OnModuleDestro
             this.logger.error(err.message, err.stack);
         }
     }
-}
+}

package/src/services/selection-providers/pseudo-foreign-key-selection-provider.service.ts

@@ -4,7 +4,7 @@ import { BadRequestException, Injectable } from "@nestjs/common";
 import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
 import { BasicFilterDto } from "src/dtos/basic-filters.dto";
 import { SolidIntrospectService } from "../solid-introspect.service";
-import { classify } from "@angular-devkit/core/src/utils/strings";
+import { classify } from '../../helpers/string.helper';
 import { CRUDService } from "../crud.service";
 
 interface PseudoForeignKeySelectionProviderContext extends ISelectionProviderContext {

package/src/services/solid-introspect.service.ts

@@ -1,4 +1,4 @@
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify } from '../helpers/string.helper';
 import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, ModuleRef, Reflector } from '@nestjs/core';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';

package/src/services/view-metadata.service.ts

@@ -4,8 +4,7 @@ import { InjectEntityManager } from '@nestjs/typeorm';
 import { CRUDService } from 'src/services/crud.service';
 import { EntityManager } from 'typeorm';
 
-
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify } from '../helpers/string.helper';
 import { Locale } from 'src/entities/locale.entity';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
@@ -111,7 +110,6 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
   async getLayout(query, activeUser) {
     let { modelName, moduleName, viewType, id, populate, menuItemId, menuItemName, actionId, actionName } = query;
 
-
     // 1. Fetch the action based on actionId.
     const solidRequestContext = {
       activeUser: activeUser
@@ -156,7 +154,6 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       }));
     }
 
-
     const viewId = action?.view?.id
     // 3. Fetch the view based on module, model & view name.
     const entity = await this.repo.findOne({
@@ -203,7 +200,6 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       entity.layout = JSON.parse(entity.layout);
     }
 
-
     // 6. We are resolving the create & edit actions if specified in the layout.
     if (entity?.layout?.attrs?.createAction) {
       const actionName: string = entity.layout.attrs.createAction;

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -1,4 +1,4 @@
-import { camelize } from "@angular-devkit/core/src/utils/strings";
+import { camelCase } from 'lodash';
 import { Delete } from "@aws-sdk/client-s3";
 import { forwardRef, Inject, Injectable, InternalServerErrorException, Logger, Scope } from "@nestjs/common";
 import { model } from "mongoose";
@@ -35,33 +35,33 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
     }
 
     async beforeInsert(event: InsertEvent<any>): Promise<any> {
-        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'beforeInsert');
         await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeInsert, modelName, eventContext);
     }
 
     async beforeUpdate(event: UpdateEvent<any>): Promise<any> {
-        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'beforeUpdate');
         // await this.handleComputedFieldEvaluation(event.databaseEntity, ComputedFieldTriggerOperation.beforeUpdate, modelName, eventContext);
         await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeUpdate, modelName, eventContext);
     }
 
     afterInsert(event: InsertEvent<any>) {
-        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'afterInsert');
         this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert, modelName, eventContext);
     }
 
     afterUpdate(event: UpdateEvent<any>) {
-        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
+        const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'afterUpdate');
         // this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterUpdate, modelName, eventContext);
         this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterUpdate, modelName, eventContext);
     }
 
     afterRemove(event: RemoveEvent<any>) {
-        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
+        const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'afterRemove');
         this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterRemove, modelName, eventContext);
     }

package/src/winston.logger.ts

@@ -7,7 +7,7 @@ import * as winston from 'winston';
 import { Environment } from './decorators/disallow-in-production.decorator';
 
 export const WinstonLoggerConfig = {
-    level: process.env.LOG_LEVEL || (process.env.ENV === Environment.Production ? 'warn' : 'debug'),
+    level: process.env.LOG_LEVEL || (process.env.ENV === Environment.Production ? 'info' : 'debug'),
     format: winston.format.combine(
         winston.format.timestamp(),
         winston.format.errors({ stack: true }),