@solidstarters/solid-core 1.2.200 → 1.2.202

package/src/dtos/create-model-sequence.dto.ts

@@ -0,0 +1,51 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsInt } from 'class-validator';
+import { IsOptional } from 'class-validator';
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class CreateModelSequenceDto {
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    moduleId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    moduleUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    modelId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    modelUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    fieldId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    fieldUserKey: string;
+    @IsNotEmpty()
+    @IsString()
+    @ApiProperty()
+    sequenceName: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    currentValue: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    prefix: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    padding: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    separator: string;
+}

package/src/dtos/create-role-metadata.dto.ts

@@ -54,23 +54,29 @@ export class CreateRoleMetadataDto {
     @ApiProperty()
     menuItemsCommand: string;
 }
+
 export const ADMIN_ROLE_NAME = 'Admin';
+
 export const INTERNAL_ROLE_NAME = 'Internal User';
+
 export const PUBLIC_ROLE_NAME = 'Public';
+
 export const INTERNAL_ROLE_PERMISSIONS = [
     // User permissions
     'UserController.findMany', //Why do we need this?
     'UserController.checkIfPermissionExists',
     'UserController.findOne',
+
     // Menu permissions
     'MenuItemMetadataController.findMany',
     'MenuItemMetadataController.findUserMenus',
     'MenuItemMetadataController.findOne',
+
     // View metadata permissions
     'ViewMetadataController.getLayout',
     'ViewMetadataController.findMany',
     'ViewMetadataController.findOne',
-    
+
     // Action metadata permissions
     'ActionMetadataController.findMany',
     'ActionMetadataController.findOne',
@@ -79,14 +85,17 @@ export const INTERNAL_ROLE_PERMISSIONS = [
     'UserViewMetadataController.upsert',
     'UserViewMetadataController.findMany',
     'UserViewMetadataController.findOne',
+
     // IAM permissions
     'AuthenticationController.changePassword',
     'AuthenticationController.logout',
     'AuthenticationController.me',
+
     // Field Metadata permissions
     'FieldMetadataController.getSelectionDynamicValues',
     'FieldMetadataController.getSelectionDynamicValue',
     'FieldMetadataController.findFieldDefaultMetaData',
+
     // Saved Filters permissions
     'SavedFiltersController.delete',
     'SavedFiltersController.deleteMany',
@@ -98,12 +107,14 @@ export const INTERNAL_ROLE_PERMISSIONS = [
     'SavedFiltersController.update',
     'SavedFiltersController.insertMany',
     'SavedFiltersController.create',
+
     // Other permissions can be added here as required.
     // Chatter permissions
     'ChatterMessageController.create',
     'ChatterMessageController.getChatterMessages',
     'ChatterMessageController.postMessage',
-    // 'ChatterMessageController.postMessage', // Does not seem to be used from ui
+    'ChatterMessageController.findMany',
+
     // Import
     'ImportTransactionController.getImportTemplate',
     'ImportTransactionController.getImportInstructions',
@@ -111,11 +122,13 @@ export const INTERNAL_ROLE_PERMISSIONS = [
     'ImportTransactionController.startImportSync',
     'ImportTransactionController.startImportAsync',
     'ImportTransactionController.exportFailedImportedImports',
+
     // Export permissions
     'ExportTemplateController.startExportSync',
     'ExportTemplateController.startExportAsync',
+
     // List of values
     'ListOfValuesController.findMany',
     'ListOfValuesController.findOne',
     // Media // [Not required], since media is always populated as part of a model
-]
+]

package/src/dtos/get-mcp-url.dto.ts

@@ -0,0 +1,13 @@
+import { IsOptional, IsString } from "class-validator";
+
+export class GetMcpUrlDto {
+
+    @IsOptional()
+    @IsString()
+    showHeader?: string;
+
+    @IsOptional()
+    @IsString()
+    inListView?: string;
+
+}

package/src/dtos/navigation.dto.ts

@@ -0,0 +1,14 @@
+import { Type } from "class-transformer";
+import { IsNumber, IsOptional, IsString } from "class-validator";
+import { BasicFilterDto } from "./basic-filters.dto";
+
+export class NavigationDto extends BasicFilterDto {
+  
+  @IsString()
+  modelName: string;
+
+  @Type(() => Number)
+  @IsNumber()
+  @IsOptional()
+  recordId: number;
+}

package/src/dtos/resolve-s3-url.dto.ts

@@ -7,24 +7,22 @@ export class ResolveS3UrlDto {
     @IsNotEmpty()
     fieldName: string;
 
-    @IsNotEmpty()
-    s3KeyFieldName: string;
 
     @IsNotEmpty()
-    fieldValue: string;
+    fileType?: string;
 
     @IsNotEmpty()
-    fileType: string;
-    
-    @IsNotEmpty()
-    bucketName: string;
-
-    @IsNotEmpty()
-    isPrivate: string;
-}
+    s3Key?: string;
 
+    @IsOptional()
+    bucketName?: string;
 
+    @IsOptional()
+    mediaStorageProviderUserKey?: string;
 
+    @IsNotEmpty()
+    isPrivate?: string;
+}
 
 
 

package/src/dtos/sign-in.dto.ts

@@ -3,19 +3,19 @@ import { IsEmail, IsNotEmpty, IsOptional, IsString, MinLength } from 'class-vali
 
 export class SignInDto {
 
-    @ApiProperty({ default: 'admin@example.service.com' })
+    @ApiProperty({ default: 'sa@solidxai.com' })
     @IsEmail()
     // @IsNotEmpty()
     @IsOptional()
     email: string;
     
-    @ApiProperty({ default: 'admin@example.service.com' })
+    @ApiProperty({ default: 'sa' })
     @IsString()
     // @IsNotEmpty()
     @IsOptional()
     username: string;
 
-    @ApiProperty({ default: 'Admin@3214$' })
+    @ApiProperty({ default: '' })
     @IsOptional()
     password: string;
 }

package/src/dtos/update-model-sequence.dto.ts

@@ -0,0 +1,53 @@
+import { IsInt,IsOptional, IsString, IsNotEmpty } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UpdateModelSequenceDto {
+    @IsOptional()
+    @IsInt()
+    id: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    moduleId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    moduleUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    modelId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    modelUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    fieldId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    fieldUserKey: string;
+    @IsNotEmpty()
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    sequenceName: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    currentValue: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    prefix: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    padding: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    separator: string;
+}

package/src/entities/common.entity.ts

@@ -1,6 +1,6 @@
-import { Column, CreateDateColumn, DeleteDateColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
-import type { User } from "./user.entity";
-import { Exclude, Expose, Type } from "class-transformer";
+import { Column, CreateDateColumn, DeleteDateColumn, Index, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
+import { Exclude, Expose } from "class-transformer";
+import { LocalDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
 
 @Exclude()
 export abstract class CommonEntity {
@@ -8,20 +8,21 @@ export abstract class CommonEntity {
     @PrimaryGeneratedColumn({ type: 'integer' })
     id: number
 
-    @CreateDateColumn({ name: "created_at" })
+    @CreateDateColumn({ name: "created_at", transformer: LocalDateTimeTransformer })
     createdAt: Date;
 
-    @UpdateDateColumn({ name: "updated_at" })
+    @UpdateDateColumn({ name: "updated_at", transformer: LocalDateTimeTransformer })
     updatedAt: Date;
 
-    @DeleteDateColumn({ name: "deleted_at" })
+    @DeleteDateColumn({ name: "deleted_at", transformer: LocalDateTimeTransformer })
+    @Index()
     deletedAt: Date;
 
     @Column({ name: "deletedTracker", default: "not-deleted" })
     deletedTracker: string;
 
     @Expose()
-    @Column({ name: 'published_at', default: null, nullable: true })
+    @Column({ name: 'published_at', default: null, nullable: true, transformer: LocalDateTimeTransformer })
     publishedAt: Date;
 
     @Expose()
@@ -49,5 +50,4 @@ export abstract class CommonEntity {
     @Expose()
     @Column({ name: `updated_by_id`, nullable: true })
     updatedBy: number;
-    
 }

package/src/entities/field-metadata.entity.ts

@@ -159,7 +159,7 @@ export class FieldMetadata extends CommonEntity {
     relationJoinTableName: string;
 
     @Column({ name: 'enable_audit_tracking', default: false })
-    enableAuditTracking: boolean;
+    enableAuditTracking: boolean = false;
 
     @Column({ name: "is_multiSelect", default: false })
     isMultiSelect: boolean;

package/src/entities/legacy-common.entity.ts

@@ -1,6 +1,7 @@
 import { Exclude, Expose, Type } from "class-transformer";
-import { Column, CreateDateColumn, DeleteDateColumn, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
+import { Column, CreateDateColumn, DeleteDateColumn, Index, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
 import type { User } from "./user.entity";
+import { LocalDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
 
 export const LEGACY_TABLE_FIELDS_PREFIX = 'ss';
 
@@ -11,20 +12,21 @@ export abstract class LegacyCommonEntity {
     // @Generated("increment")
     // id: number
 
-    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at` })
+    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: LocalDateTimeTransformer })
     createdAt: Date;
 
-    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at` })
+    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: LocalDateTimeTransformer })
     updatedAt: Date;
 
-    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at` })
+    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: LocalDateTimeTransformer })
+    @Index()
     deletedAt: Date;
 
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_tracker`, default: "not-deleted" })
     deletedTracker: string;
 
     @Expose()
-    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null ,nullable: true})
+    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null, nullable: true, transformer: LocalDateTimeTransformer })
     publishedAt: Date;
 
     @Expose()
@@ -50,7 +52,7 @@ export abstract class LegacyCommonEntity {
     @Expose()
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_by_id`, nullable: true })
     createdBy: number;
-    
+
     @Expose()
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_by_id`, nullable: true })
     updatedBy: number;

package/src/entities/model-metadata.entity.ts

@@ -34,7 +34,7 @@ export class ModelMetadata extends CommonEntity {
     enableSoftDelete: boolean;
 
     @Column({ name: "enable_audit_tracking", default: false })
-    enableAuditTracking: boolean;
+    enableAuditTracking: boolean = false;
 
     @Column({ name: "internationalisation", default: false })
     internationalisation: boolean;

package/src/entities/model-sequence.entity.ts

@@ -0,0 +1,32 @@
+import { CommonEntity } from "src/entities/common.entity"
+import { Entity, JoinColumn, ManyToOne, Index, Column } from 'typeorm';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity'
+
+@Entity('ss_model_sequence')
+export class ModelSequence extends CommonEntity {
+    @Index()
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
+    @JoinColumn()
+    module: ModuleMetadata;
+    @Index()
+    @ManyToOne(() => ModelMetadata, { nullable: false })
+    @JoinColumn()
+    model: ModelMetadata;
+    @Index()
+    @ManyToOne(() => FieldMetadata, { nullable: false })
+    @JoinColumn()
+    field: FieldMetadata;
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    sequenceName: string;
+    @Column({ type: "integer", default: 1 })
+    currentValue: number;
+    @Column({ type: "varchar", nullable: true })
+    prefix: string;
+    @Column({ type: "integer", default: 5 })
+    padding: number;
+    @Column({ type: "varchar", default: "" })
+    separator: string;
+}

package/src/factories/mail.factory.ts

@@ -20,7 +20,6 @@ export class MailFactory {
         private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     ) { }
 
-
     getMailService(): IMail {
         const mailServiceName = this.commonConfiguration.emailProvider;
         const mailProviders = this.solidRegistry.getMailProviders();

package/src/factories/sms.factory.ts

@@ -0,0 +1,43 @@
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import { ModuleRef } from "@nestjs/core";
+import commonConfig from "src/config/common.config";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { ISMS } from "src/interfaces";
+
+function norm(s?: string) {
+    return s?.trim().toLowerCase();
+}
+
+// This factory will be use to return a mail service instance, using the configured environment variables
+@Injectable()
+export class SmsFactory {
+    private readonly logger = new Logger(this.constructor.name);
+
+    constructor(
+        private readonly moduleRef: ModuleRef,
+        private readonly solidRegistry: SolidRegistry,
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+    ) { }
+
+    getSmsService(name: string = null): ISMS {
+        // This is the default provider
+        const smsServiceName = name || this.commonConfiguration.smsProvider;
+        if (!smsServiceName) {
+            throw new Error("Unable to resolve sms provider")
+        }
+        const smsProviders = this.solidRegistry.getSmsProviders();
+
+        // Return the instance which matches the smsServicename
+        if (!smsProviders.length) {
+            // throw new Error("No mail providers are registered.");
+            this.logger.error("No sms providers are registered.");
+        }
+
+        const smsServiceProvider = smsProviders.find(provider => provider.name === smsServiceName);
+
+        return smsServiceProvider.instance as ISMS;
+    }
+
+}

package/src/helpers/date.helper.ts

@@ -1,34 +1,63 @@
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat';
+
 dayjs.extend(customParseFormat);
 
 export function parseFlexibleDate(value: any): Date | null {
   if (!value) return null;
+
+  // Already a valid Date (ExcelJS often gives this)
   if (value instanceof Date && !isNaN(value.getTime())) {
     return value;
   }
+
+  // Excel serial number
   if (typeof value === 'number') {
     const excelEpoch = new Date(Date.UTC(1899, 11, 30));
     const d = new Date(excelEpoch.getTime() + value * 86400000);
     return isNaN(d.getTime()) ? null : d;
   }
-  const str = value.toString().trim();
+
+  let str = value.toString().trim();
+
+  // STRIP "(British Summer Time)" or any "(...)" suffix
+  str = str.replace(/\s*\(.*\)$/, '');
+
   const formats = [
+    // strict business formats
     'DD-MM-YYYY',
+
+    // common alternates
     'YYYY-MM-DD',
     'DD/MM/YYYY',
     'MM/DD/YYYY',
     'D-M-YYYY',
     'YYYY/MM/DD',
+
+    // JS Date.toString() (without timezone name)
+    // (handle single-digit day + different offset shapes)
+    'ddd MMM D YYYY HH:mm:ss [GMT]ZZ', // GMT+0100
+    'ddd MMM DD YYYY HH:mm:ss [GMT]ZZ',
+    'ddd MMM D YYYY HH:mm:ss [GMT]Z',  // GMT+01:00
+    'ddd MMM DD YYYY HH:mm:ss [GMT]Z',
+
+    // ISO variants
     'YYYY-MM-DD HH:mm:ss',
-    'YYYY-MM-DDTHH:mm:ss',       // ISO without Z
-    'YYYY-MM-DDTHH:mm:ss.SSS',   // ISO with millis
-    'YYYY-MM-DDTHH:mm:ssZ',      // ISO with timezone
+    'YYYY-MM-DDTHH:mm:ss',
+    'YYYY-MM-DDTHH:mm:ss.SSS',
+    'YYYY-MM-DDTHH:mm:ssZ',
   ];
-  const parsed = dayjs(str, formats, true); // true = strict parsing
-  if (!parsed.isValid()) {
-    return null;
+
+  const parsed = dayjs(str, formats, true); // strict
+  if (parsed.isValid()) {
+    return parsed.toDate();
+  }
+
+  // Fallback: native Date can parse this JS format very reliably
+  const native = new Date(str);
+  if (!isNaN(native.getTime())) {
+    return native;
   }
-  return parsed.toDate();
-}
 
+  return null;
+}

package/src/helpers/field-crud-managers/BigIntFieldCrudManager.ts

@@ -14,13 +14,22 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     }
 
     validate(createDto: any): ValidationError[] {
-        const fieldValue: any = createDto[this.options.fieldName];
+        let fieldValue: any = createDto[this.options.fieldName];
+        if (fieldValue !== undefined && fieldValue !== null) {
+            try {
+                if (typeof fieldValue === 'string' || typeof fieldValue === 'number') {
+                    fieldValue = BigInt(fieldValue);
+                }
+            } catch (err) {
+                return [{ field: this.options.fieldName, error: 'Invalid numeric value' }];
+            }
+        }
         return this.applyValidations(fieldValue);
     }
 
     private applyValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
-        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";
         if (isNotEmpty(fieldValue)) {
             errors.push(...this.applyFormatValidations(fieldValue));
         }
@@ -29,7 +38,7 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
 
     private applyFormatValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
-        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }): "no errors";
+        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }) : "no errors";
         this.isApplyMinValidation() && !min(fieldValue, this.options.min) ? errors.push({ field: this.options.fieldName, error: 'Field value is lesser than minimum required' }) : "no errors"; //FIXME min length to be handled
         this.isApplyMaxValidation() && !max(fieldValue, this.options.max) ? errors.push({ field: this.options.fieldName, error: 'Field value is greater than maximum required' }) : "no errors";
         return errors;
@@ -43,13 +52,17 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     private isApplyMinValidation(): boolean {
         return this.options.min > 0;
     }
+
     private isApplyMaxValidation(): boolean {
         return this.options.max > 0;
     }
+
     private isApplyRequiredValidation(): boolean {
         return this.options.required;
     }
+
     private isBigInt(value: any): boolean {
-        return typeof value === 'bigint';
-      }
+        const valueType = typeof value;
+        return valueType === 'bigint' || (valueType === 'number' && Number.isFinite(value));
+    }
 }

package/src/helpers/field-crud-managers/ManyToManyRelationFieldCrudManager.ts

@@ -68,11 +68,11 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
     }
 
     async transformForCreate(dto: any): Promise<any> {
-        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
-        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+        const currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName)
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -192,9 +192,9 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // Returns the entity target class from the entity name
-    private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const entityMetadata = entityMetadatas.find(em => em.name === entityName);
-        return entityMetadata.target;
-    }
+    // private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const entityMetadata = entityMetadatas.find(em => em.name === entityName);
+    //     return entityMetadata.target;
+    // }
 }