@solidxai/core 0.1.9-beta.0 → 0.1.9-beta.2

package/src/repository/user-activity-history.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { UserActivityHistory } from 'src';
+import { UserActivityHistory } from '../entities/user-activity-history.entity';
 import { RequestContextService } from 'src/services/request-context.service';
 import { DataSource } from 'typeorm';
 import { SecurityRuleRepository } from './security-rule.repository';

package/src/repository/user-view-metadata.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { UserViewMetadata } from 'src';
+import { UserViewMetadata } from '../entities/user-view-metadata.entity';
 import { RequestContextService } from 'src/services/request-context.service';
 import { DataSource } from 'typeorm';
 import { SecurityRuleRepository } from './security-rule.repository';

package/src/seeders/module-metadata-seeder.service.ts

@@ -31,7 +31,13 @@ import { ViewMetadataService } from '../services/view-metadata.service';
 import solidCoreMetadata from './seed-data/solid-core-metadata.json';
 import { SystemFieldsSeederService } from './system-fields-seeder.service';
 // import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
-import { ActionMetadata, DEFAULT_SA_PASSWORD, MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL, MenuItemMetadata, ModuleMetadata, RoleMetadata, SignUpDto } from 'src';
+import { ActionMetadata } from '../entities/action-metadata.entity';
+import { MenuItemMetadata } from '../entities/menu-item-metadata.entity';
+import { ModuleMetadata } from '../entities/module-metadata.entity';
+import { RoleMetadata } from '../entities/role-metadata.entity';
+import { MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL } from '../dtos/create-menu-item-metadata.dto';
+import { DEFAULT_SA_PASSWORD } from '../dtos/create-user.dto';
+import { SignUpDto } from '../dtos/sign-up.dto';
 import { ADMIN_ROLE_NAME, CreateRoleMetadataDto } from 'src/dtos/create-role-metadata.dto';
 import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
 import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
@@ -151,6 +157,11 @@ export class ModuleMetadataSeederService {
                 const moduleModelFieldCounts = await this.seedModuleModelFields(moduleMetadata);
                 console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
 
+                currentStep = 'seedPermissions';
+                this.logger.log(`Seeding Permissions`);
+                const permissionCounts = await this.seedPermissions(overallMetadata);
+                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Permissions', permissionCounts)}`);
+
                 currentStep = 'seedRoles';
                 this.logger.log(`Seeding Roles`);
                 const roleCounts = await this.seedRoles(overallMetadata);
@@ -282,6 +293,7 @@ export class ModuleMetadataSeederService {
         this.logger.debug(`About to add all permissions to the Admin role`);
         await this.roleService.addAllPermissionsToRole(ADMIN_ROLE_NAME);
 
+        // The below code is commented out for now as we are including permissions for these roles from the seeder json for the Internal and Public role. 
         // 2. Give  permissions to the Internal / Public role.
         // this.logger.debug(`About to add all permissions to the Internal role`);
         // await this.roleService.addPermissionToRole(INTERNAL_ROLE_NAME, INTERNAL_ROLE_PERMISSIONS);
@@ -379,6 +391,14 @@ export class ModuleMetadataSeederService {
         return { pruned: 0, upserted: overallMetadata.roles?.length ?? 0 };
     }
 
+    private async seedPermissions(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
+        this.logger.debug(`[Start] Processing permissions`);
+        const permissions = overallMetadata.permissions ?? [];
+        await this.handleSeedPermissions(permissions);
+        this.logger.debug(`[End] Processing permissions`);
+        return { pruned: 0, upserted: permissions?.length ?? 0 };
+    }
+
     // OK
     private get seedDataFiles(): any[] {
         const typedSolidCoreMetadata = structuredClone(solidCoreMetadata);
@@ -401,7 +421,7 @@ export class ModuleMetadataSeederService {
     // OK
     private async seedGlobalMetadata() {
         this.logger.log(`Seeding Permissions`);
-        await this.seedPermissions();
+        await this.seedControllerPermissions();
 
         // this.logger.log(`Seeding Default Media Storage Providers`);
         // await this.seedDefaultMediaStorageProviders();
@@ -422,7 +442,7 @@ export class ModuleMetadataSeederService {
     }
 
     // OK
-    private async seedPermissions() {
+    private async seedControllerPermissions() {
 
         const controllers = this.solidRegistry.getControllers();
         const permissionNames: string[] = [];
@@ -440,28 +460,7 @@ export class ModuleMetadataSeederService {
                     const permissionName = `${controller.name}.${methodName}`;
                     permissionNames.push(permissionName);
 
-                    const existingPermission = await this.permissionRepo.findOne({
-                        where: {
-                            name: permissionName
-                        }
-                    });
-
-                    // if (existingPermission) {
-                    //     this.logger.log(`Permission ${permissionName} already exists.`);
-                    // }
-                    // else { }
-
-                    if (!existingPermission) {
-
-                        this.logger.log(`Permission ${permissionName} does not exist, creating new.`);
-
-                        const newPermission = this.permissionRepo.create({
-                            name: permissionName
-                        });
-                        await this.permissionRepo.save(newPermission);
-
-
-                    }
+                    await this.createPermissionIfNotExists(permissionName);
                 }
 
             } catch (error) {
@@ -474,6 +473,32 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private async createPermissionIfNotExists(permissionName: string): Promise<void> {
+        const existingPermission = await this.permissionRepo.findOne({
+            where: {
+                name: permissionName
+            }
+        });
+
+        if (!existingPermission) {
+            this.logger.log(`Permission ${permissionName} does not exist, creating new.`);
+
+            const newPermission = this.permissionRepo.create({
+                name: permissionName
+            });
+            await this.permissionRepo.save(newPermission);
+        }
+    }
+
+    private async handleSeedPermissions(permissions: any[]): Promise<void> {
+        for (const permission of permissions) {
+            const permissionName = typeof permission === 'string' ? permission : permission?.name;
+            if (permissionName) {
+                await this.createPermissionIfNotExists(permissionName);
+            }
+        }
+    }
+
     // OK
     // private async seedDefaultMediaStorageProviders() {
     //     await this.mediaStorageProviderSeederService.seed();

package/src/seeders/module-test-data.service.ts

@@ -391,14 +391,7 @@ export class ModuleTestDataService {
         continue;
       }
 
-      await authService.signUp({
-        username: user.username,
-        email: user.email,
-        password: user.password,
-        fullName: user.fullName,
-        mobile: user.mobile,
-        roles: user.roles,
-      });
+      await authService.signUp({ ...user });
       this.logger.log(`Created test user "${user.username}"${user.roles?.length ? ` with roles [${user.roles.join(', ')}]` : ''}`);
     }
   }

package/src/seeders/seed-data/solid-core-metadata.json

@@ -5819,7 +5819,7 @@
           {
             "name": "toolOutput",
             "displayName": "Tool Output",
-            "type": "longText",
+            "type": "json",
             "columnName": "tool_output",
             "required": false,
             "unique": false,
@@ -5905,6 +5905,10 @@
       }
     ]
   },
+  "permissions": [
+    "mcp:invoke",
+    "agent:invoke"
+  ],
   "roles": [
     {
       "name": "Admin"
@@ -5961,7 +5965,9 @@
         "AgentSessionController.findMany",
         "AgentSessionController.findOne",
         "AgentEventController.findMany",
-        "AgentEventController.findOne"
+        "AgentEventController.findOne",
+        "mcp:invoke",
+        "agent:invoke"
       ]
     },
     {
@@ -13900,9 +13906,9 @@
                     "attrs": { "name": "col-content", "label": "", "className": "col-12" },
                     "children": [
                       { "type": "field", "attrs": { "name": "content" } },
-                      { "type": "field", "attrs": { "name": "toolArguments" } },
-                      { "type": "field", "attrs": { "name": "toolOutput" } },
-                      { "type": "field", "attrs": { "name": "eventData" } }
+                      { "type": "field", "attrs": { "name": "toolArguments", "viewWidget": "SolidJsonFormViewWidget" } },
+                      { "type": "field", "attrs": { "name": "toolOutput", "viewWidget": "SolidJsonFormViewWidget" } },
+                      { "type": "field", "attrs": { "name": "eventData", "viewWidget": "SolidJsonFormViewWidget" } }
                     ]
                   }
                 ]

package/src/services/authentication.service.ts

@@ -47,6 +47,7 @@ import { SettingService } from './setting.service';
 import { UserActivityHistoryService } from './user-activity-history.service';
 import { UserService } from './user.service';
 import { SmsFactory } from 'src/factories/sms.factory';
+import { SolidRegistry } from 'src/helpers/solid-registry';
 
 enum LoginProvider {
     LOCAL = 'local',
@@ -83,6 +84,7 @@ export class AuthenticationService {
 
         @InjectDataSource()
         private readonly dataSource: DataSource,
+        private readonly solidRegistry: SolidRegistry,
     ) {
         // this.mailService = this.mailServiceFactory.getMailService();
     }
@@ -142,62 +144,57 @@ export class AuthenticationService {
         }
     }
 
-    async signUp(signUpDto: SignUpDto, activeUser: ActiveUserData = null): Promise<User> {
-        // If public registrations are disabled and no activeUser is present when invoking signUp then we throw an exception.
-        // if (!(this.settingService.getConfigValue<SolidCoreSetting>('allowPublicRegistration')) && !activeUser) {
-        //     throw new BadRequestException(ERROR_MESSAGES.PUBLIC_REGISTRATION_DISABLED);
-        // }
+    private static readonly SIGNUP_DTO_KEYS = new Set(['username', 'email', 'password', 'fullName', 'mobile', 'roles', 'forcePasswordChange']);
 
+    async signUp(signUpDto: SignUpDto & Record<string, any>, activeUser: ActiveUserData = null): Promise<User> {
+        const hasExtensionFields = Object.keys(signUpDto).some(k => !AuthenticationService.SIGNUP_DTO_KEYS.has(k));
+        if (hasExtensionFields) {
+            const provider = this.solidRegistry.getExtensionUserCreationProvider();
+            if (!provider) {
+                throw new InternalServerErrorException(
+                    'No ExtensionUserCreationProvider registered. Register one to handle extension user creation.',
+                );
+            }
+            const entity = await provider.buildExtensionEntity(signUpDto);
+            const effectiveDto = { ...signUpDto, roles: provider.roles(signUpDto) };
+            return this.performSignUp(effectiveDto, entity, provider.repo as Repository<User>);
+        }
+        return this.performSignUp(signUpDto, new User(), this.userRepository);
+    }
+
+    private async performSignUp<T extends User>(signUpDto: SignUpDto, entity: T, repo: Repository<T>): Promise<T> {
         try {
             const onForcePasswordChange = this.settingService.getConfigValue<SolidCoreSetting>('forceChangePasswordOnFirstLogin');
             const activateUserOnRegistration = this.settingService.getConfigValue<SolidCoreSetting>('activateUserOnRegistration');
             const defaultRole = this.settingService.getConfigValue<SolidCoreSetting>('defaultRole');
 
-            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup(new User(), signUpDto, activateUserOnRegistration, onForcePasswordChange);
+            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup<T>(entity, signUpDto, activateUserOnRegistration, onForcePasswordChange);
             const privateDto = signUpDto as { isAllowedToGenerateApiKeys?: boolean };
             if (privateDto.isAllowedToGenerateApiKeys !== undefined) {
                 user.isAllowedToGenerateApiKeys = privateDto.isAllowedToGenerateApiKeys;
             }
-            const savedUser = await this.userRepository.save(user);
-            // Also assign a default role to the newly created user. 
+            const savedUser = await repo.save(user);
             const userRoles = signUpDto.roles ?? [];
-            if (signUpDto.username !== 'sa' && defaultRole) {
+            if ((signUpDto.roles?.length ?? 0) === 0 && signUpDto.username !== 'sa' && defaultRole) {
                 userRoles.push(defaultRole);
             }
             await this.handlePostSignup(savedUser, userRoles, pwd, autoGeneratedPwd);
 
-            // TODO: make provision to trigger a welcome email also.
-
             return savedUser;
         } catch (err) {
             const pgUniqueViolationErrorCode = '23505';
             if (err.code === pgUniqueViolationErrorCode) {
-                throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
+                throw new ConflictException(parseUniqueConstraintError(err.detail || ERROR_MESSAGES.UNIQUE_CONSTRAINT_VIOLATION));
             }
             throw err;
         }
     }
 
+    /** @deprecated Use IExtensionUserCreationProvider instead. Kept for backward compatibility. */
     async signupForExtensionUser<T extends User, U extends CreateUserDto>(signUpDto: SignUpDto, extensionUserDto: U, extensionUserRepo: Repository<T>): Promise<T> {
-        try {
-            const onForcePasswordChange = this.settingService.getConfigValue<SolidCoreSetting>('forceChangePasswordOnFirstLogin');
-            // Merge the extended signUpDto attributes into the user entity 
-            //@ts-ignore 
-            const extensionUser = extensionUserRepo.merge(extensionUserRepo.create() as T, extensionUserDto);
-            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup<T>(extensionUser, signUpDto, extensionUserDto.active ?? true, onForcePasswordChange);
-            const savedUser = await extensionUserRepo.save(user);
-
-            await this.handlePostSignup(savedUser, signUpDto.roles, pwd, autoGeneratedPwd);
-
-            return savedUser;
-        }
-        catch (err) {
-            const pgUniqueViolationErrorCode = '23505';
-            if (err.code === pgUniqueViolationErrorCode) {
-                throw new ConflictException(parseUniqueConstraintError(err.detail || ERROR_MESSAGES.UNIQUE_CONSTRAINT_VIOLATION));
-            }
-            throw err;
-        }
+        // @ts-ignore
+        const entity = extensionUserRepo.merge(extensionUserRepo.create() as T, extensionUserDto);
+        return this.performSignUp(signUpDto, entity, extensionUserRepo);
     }
 
 

package/src/services/crud.service.ts

@@ -1,7 +1,10 @@
-import { BadRequestException, NotFoundException } from "@nestjs/common";
+import { BadRequestException, InternalServerErrorException, NotFoundException } from "@nestjs/common";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { isArray } from "class-validator";
-import { CommonEntity, SettingService, SolidBaseRepository, User } from "src";
+import { CommonEntity } from "../entities/common.entity";
+import { User } from "../entities/user.entity";
+import { SolidBaseRepository } from "../repository/solid-base.repository";
+import { SettingService } from "./setting.service";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { EntityManager, FindOptionsWhere, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -34,6 +37,7 @@ import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCr
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
 import { CrudHelperService, FilterCombinator, UserIdFields } from "./crud-helper.service";
 import { HashingService } from "./hashing.service";
+import { SolidRegistry } from "src/helpers/solid-registry";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { RequestContextService } from "./request-context.service";
@@ -72,7 +76,23 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return this._settingService ??= this.moduleRef.get(SettingService, { strict: false });
     }
 
+    private async tryCreateAsExtensionUser(createDto: any): Promise<T | null> {
+        if (this.repo.metadata?.parentEntityMetadata?.target !== User) return null;
+        const registry = this.moduleRef.get(SolidRegistry, { strict: false });
+        if (!registry?.getExtensionUserCreationProvider()) {
+            throw new InternalServerErrorException(
+                `No ExtensionUserCreationProvider registered. Register one to create ${this.repo.metadata.name} entities.`,
+            );
+        }
+        const { AuthenticationService } = await import('./authentication.service');
+        const authService = this.moduleRef.get(AuthenticationService, { strict: false });
+        return authService.signUp(createDto) as unknown as T;
+    }
+
     async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<T> {
+        const asExtensionUser = await this.tryCreateAsExtensionUser(createDto);
+        if (asExtensionUser !== null) return asExtensionUser;
+
         // This class will be extended by the generated service class i.e PersonService
         // The data required to identify the model and module name will be passed from the generate CrudService subclass
         //TODO: Algorithm to create the entity

package/src/services/dashboard-question.service.ts

@@ -11,7 +11,7 @@ import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DashboardQuestion } from '../entities/dashboard-question.entity';
 import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
 import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
-import { QuestionSqlDataProviderContext } from 'src';
+import { QuestionSqlDataProviderContext } from '../interfaces';
 
 enum SOURCE_TYPE {
   SQL = 'sql',

package/src/services/security-rule.service.ts

@@ -8,7 +8,7 @@ import { CRUDService } from 'src/services/crud.service';
 
 import { SecurityRule } from '../entities/security-rule.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
-import { SecurityRuleRepository } from 'src';
+import { SecurityRuleRepository } from '../repository/security-rule.repository';
 
 @Injectable()
 export class SecurityRuleService extends CRUDService<SecurityRule> implements OnApplicationBootstrap {

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

@@ -13,6 +13,7 @@ import { IS_MAIL_PROVIDER } from 'src/decorators/mail-provider.decorator';
 import { IS_SCHEDULED_JOB_PROVIDER } from 'src/decorators/scheduled-job-provider.decorator';
 import { IS_SECURITY_RULE_CONFIG_PROVIDER } from 'src/decorators/security-rule-config-provider.decorator';
 import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorator';
+import { IS_EXTENSION_USER_CREATION_PROVIDER } from 'src/decorators/extension-user-creation-provider.decorator';
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
 import { IS_WA_PROVIDER } from 'src/decorators/whatsapp-provider.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
@@ -144,6 +145,12 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       this.solidRegistry.registerSecurityRuleConfigProvider(securityRuleConfigProvider);
     });
 
+    // Register IExtensionUserCreationProvider implementation (at most one per project)
+    const extensionUserCreationProviders = this.discoveryService.getProviders().filter((provider) => this.isExtensionUserCreationProvider(provider));
+    extensionUserCreationProviders.forEach((provider) => {
+      this.solidRegistry.registerExtensionUserCreationProvider(provider);
+    });
+
     // Register the core subscribers against all the configured database modules / datasources
     await this.bootstrapCoreTypeOrmSubscribers(solidDatabaseModules);
     await this.cacheAuditableModels();
@@ -287,6 +294,12 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSelectionProvider;
   }
 
+  private isExtensionUserCreationProvider(provider: InstanceWrapper): boolean {
+    const { instance } = provider;
+    if (!instance) return false;
+    return !!this.reflector.get<boolean>(IS_EXTENSION_USER_CREATION_PROVIDER, instance.constructor);
+  }
+
   private isSettingsProvider(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

package/src/testing/contracts/testing-metadata.types.ts

@@ -18,6 +18,7 @@ export interface TestingUserSpec {
   fullName?: string;
   mobile?: string;
   roles?: string[];
+  [key: string]: any;
 }
 
 export interface TestingMetadata {

package/src/testing/steps/ui/assertions.step.ts

@@ -22,6 +22,15 @@ export function registerAssertionSteps(registry: StepRegistry): void {
     await page.waitForSelector(input.selector, { state: "visible" });
   });
 
+  registry.register("ui.expectHidden", async (ctx: TestContext, step: OpStep) => {
+    const page = requirePage(ctx, "ui.expectHidden");
+    const input = (step.with ?? {}) as VisibleInput;
+    if (!input.selector) {
+      throw new Error('Missing "selector" in step.with for op "ui.expectHidden"');
+    }
+    await page.waitForSelector(input.selector, { state: "hidden" });
+  });
+
   registry.register("ui.expectText", async (ctx: TestContext, step: OpStep) => {
     const page = requirePage(ctx, "ui.expectText");
     const input = (step.with ?? {}) as ExpectTextInput;

package/src/testing/steps/ui/form.step.ts

@@ -1,9 +1,12 @@
+import * as path from "path";
+
 import type { TestContext } from "../../contracts/runtime-context.types";
 import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
 type FillInput = { selector: string; value: string };
 type SelectInput = { selector: string; value: string };
+type UploadFileInput = { selector: string; filePath: string | string[] };
 
 function requirePage(ctx: TestContext, op: string) {
   if (!ctx.ui || !ctx.ui.page) {
@@ -36,4 +39,20 @@ export function registerFormSteps(registry: StepRegistry): void {
     }
     await page.selectOption(input.selector, String(input.value));
   });
+
+  registry.register("ui.uploadFile", async (ctx: TestContext, step: OpStep) => {
+    const page = requirePage(ctx, "ui.uploadFile");
+    const input = (step.with ?? {}) as UploadFileInput;
+    if (!input.selector) {
+      throw new Error('Missing "selector" in step.with for op "ui.uploadFile"');
+    }
+    if (input.filePath === undefined || input.filePath === null) {
+      throw new Error('Missing "filePath" in step.with for op "ui.uploadFile"');
+    }
+    const cwd = process.cwd();
+    const resolved = Array.isArray(input.filePath)
+      ? input.filePath.map((p) => path.resolve(cwd, String(p)))
+      : path.resolve(cwd, String(input.filePath));
+    await page.setInputFiles(input.selector, resolved);
+  });
 }

package/tsconfig.json

@@ -12,6 +12,9 @@
     "outDir": "./dist",
     "rootDir": "./src",
     "baseUrl": "./",
+    "paths": {
+      "src/*": ["./src/*"]
+    },
     "incremental": false,
     "skipLibCheck": true,
     "strictNullChecks": false,