@solidstarters/solid-core 1.2.203 → 1.2.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.203",
+  "version": "1.2.206",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/info.command.ts

@@ -0,0 +1,101 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ISolidDatabaseModule } from 'src/interfaces';
+import { getDynamicModuleNames } from 'src/helpers/module.helper';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { SettingService } from 'src/services/setting.service';
+
+interface InfoCommandOptions {
+    detailed?: boolean;
+}
+
+@Command({ name: 'info', description: 'Prints information about the consuming project' })
+export class InfoCommand extends CommandRunner {
+    private readonly logger = new Logger(InfoCommand.name);
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry,
+        private readonly settingService: SettingService,
+    ) {
+        super();
+    }
+
+    async run(passedParam: string[], options?: InfoCommandOptions): Promise<void> {
+        const enabledModules = getDynamicModuleNames();
+        const dataSources = this.getDataSources();
+
+        const output: Record<string, any> = {
+            modules: {
+                count: enabledModules.length,
+                names: enabledModules,
+            },
+            dataSources: {
+                count: dataSources.length,
+                items: dataSources,
+            },
+        };
+
+        if (options?.detailed) {
+            output.registry = this.getRegistryDetails();
+        }
+
+        console.log(JSON.stringify(output, null, 2));
+    }
+
+    private getRegistryDetails(): Record<string, unknown> {
+        const info = {
+            settings: this.settingService.getAllSettings(),
+            seeders: this.getWrapperNames(this.solidRegistry.getSeeders()),
+            scheduledJobProviders: this.getWrapperNames(this.solidRegistry.getScheduledJobProviders()),
+            selectionProviders: this.getWrapperNames(this.solidRegistry.getSelectionProviders()),
+            computedFieldProviders: this.getWrapperNames(this.solidRegistry.getComputedFieldProviders()),
+            solidDatabaseModules: this.getWrapperNames(this.solidRegistry.getSolidDatabaseModules()),
+            dashboardVariableSelectionProviders: this.getWrapperNames(this.solidRegistry.getDashboardVariableSelectionProviders()),
+            dashboardQuestionDataProviders: this.getWrapperNames(this.solidRegistry.getDashboardQuestionDataProviders()),
+            mailProviders: this.getWrapperNames(this.solidRegistry.getMailProviders()),
+            whatsappProviders: this.getWrapperNames(this.solidRegistry.getWhatsappProviders()),
+            smsProviders: this.getWrapperNames(this.solidRegistry.getSmsProviders()),
+            securityRuleConfigProviders: this.getWrapperNames(this.solidRegistry.getSecurityRuleConfigProviders()),
+            errorCodeProviders: this.getWrapperNames(this.solidRegistry.getErrorCodeProviders()),
+            controllers: this.solidRegistry.getControllers().map((controller) => controller.name),
+            // modules: this.getWrapperNames(this.solidRegistry.getModules()),
+            // computedFieldMetadata: {
+            //     count: this.solidRegistry.getComputedFieldMetadata().length,
+            // },
+            // defaultLocale: this.solidRegistry.getDefaultLocale()?.locale ?? null,
+        };
+
+        return info;
+    }
+
+    private getWrapperNames(wrappers: Array<{ name?: string; instance?: any }>): string[] {
+        return wrappers
+            .map((wrapper) => wrapper.name || wrapper.instance?.constructor?.name)
+            .filter((name): name is string => !!name);
+    }
+
+    private getDataSources(): Array<{ name: string; type: string | null }> {
+        const fromRegistry = this.solidRegistry
+            .getSolidDatabaseModules()
+            .map((wrapper) => wrapper.instance as ISolidDatabaseModule)
+            .filter((module): module is ISolidDatabaseModule => !!module)
+            .map((module) => ({
+                name: module.name?.(),
+                type: module.type?.() ?? null,
+            }))
+            .filter((item) => !!item.name);
+
+
+        return fromRegistry;
+
+    }
+
+    // Flags
+    @Option({ flags: '-d, --detailed [boolean]', description: 'Print more details about the consuming project', required: false, defaultValue: false })
+    parseDetached(val: string): boolean {
+        if (val === undefined) return false;
+        return val === 'true' || val === '1';
+    }
+}

package/src/commands/mcp.command.ts

@@ -167,12 +167,7 @@ export class McpCommand extends CommandRunner {
         return path.resolve(inputPath);
     }
 
-    private runDockerCommand(
-        cmd: string,
-        args: string[],
-        cwd: string,
-        env: NodeJS.ProcessEnv,
-    ): Promise<void> {
+    private runDockerCommand(cmd: string, args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<void> {
         return new Promise((resolve, reject) => {
             const child = spawn(cmd, args, {
                 cwd,
@@ -193,22 +188,13 @@ export class McpCommand extends CommandRunner {
     }
 
     // Flags
-
-    @Option({
-        flags: '-d, --detached [boolean]',
-        description: 'Run containers in detached mode (only for start, default: false)',
-        required: false,
-    })
+    @Option({ flags: '-d, --detached [boolean]', description: 'Run containers in detached mode (only for start, default: false)', required: false, })
     parseDetached(val: string): boolean {
         if (val === undefined) return false;
         return val === 'true' || val === '1';
     }
 
-    @Option({
-        flags: '-p, --repo-path [path]',
-        description: 'Path to the SolidX MCP Server repo containing docker-compose.yml',
-        required: false,
-    })
+    @Option({ flags: '-p, --repo-path [path]', description: 'Path to the SolidX MCP Server repo containing docker-compose.yml', required: false, })
     parseRepoPath(val: string): string {
         return val;
     }

package/src/commands/seed.command.ts

@@ -16,8 +16,8 @@ export class SeedCommand extends CommandRunner {
   }
 
   async run(passedParam: string[], options?: SeedCommandOptions): Promise<void> {
-    // TODO: check if options.conf is non empty and a valid json string only is -c flag is passed.
-    // TODO: convert to json object JSON.parse
+    // check if options.conf is non empty and a valid json string only is -c flag is passed.
+    // convert to json object JSON.parse
     let parsedConf: any = null;
 
     // Parse conf only if provided
@@ -33,8 +33,6 @@ export class SeedCommand extends CommandRunner {
       this.logger.log('No --conf flag provided. Running with default seeder behavior.');
     }
 
-
-
     const seeder = this.solidRegistry
       .getSeeders()
       .filter((seeder) => seeder.name === options.seeder)
@@ -48,26 +46,16 @@ export class SeedCommand extends CommandRunner {
     await seeder.seed(parsedConf);
   }
 
-  @Option({
-    flags: '-c, --conf [configuration json]',
-    description: 'A configuration json, pass a valid json string.',
-    required: false
-  })
   /**
-   * TODO
    * This parameter will be useful, to support seeders with the same name in different modules
    * Currently the seeder service won't support seeder with same classname within a module
    **/
+  @Option({ flags: '-c, --conf [configuration json]', description: 'A configuration json, pass a valid json string.', required: false })
   parseConf(val: string): string {
     return val;
   }
 
-  @Option({
-    flags: '-s, --seeder [seeder name]',
-    description: 'The seeder to run.',
-    required: true,
-    defaultValue: 'ModuleMetadataSeederService'
-  })
+  @Option({ flags: '-s, --seeder [seeder name]', description: 'The seeder to run.', required: true, defaultValue: 'ModuleMetadataSeederService' })
   parseString(val: string): string {
     return val;
   }

package/src/controllers/email-template.controller.ts

@@ -4,15 +4,20 @@ import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { CreateEmailTemplateDto } from '../dtos/create-email-template.dto';
 import { UpdateEmailTemplateDto } from '../dtos/update-email-template.dto';
 import { EmailTemplateService } from '../services/email-template.service';
+import { SettingService } from '../services/setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
-// TODO: esInterop not working somehow, defaulted to using the require syntax to import Mailgen. Figure a better way to do this. 
+// TODO: esInterop not working somehow, defaulted to using the require syntax to import Mailgen. Figure a better way to do this.
 import Mailgen = require('mailgen');
 
 
 @Controller('email-template')
 @ApiTags("Solid Core")
 export class EmailTemplateController {
-  constructor(private readonly service: EmailTemplateService) { }
+  constructor(
+    private readonly service: EmailTemplateService,
+    private readonly settingService: SettingService,
+  ) { }
 
   @ApiBearerAuth("jwt")
   @Post()
@@ -73,8 +78,8 @@ export class EmailTemplateController {
   @Get('mailgen-template/:templateType')
   @Header('content-type', 'text/html')
   generateMailgenTemplate(@Param('templateType') templateType: string) {
-    const appName = process.env.SOLID_APP_NAME;
-    const appUrl = process.env.SOLID_APP_WEBSITE_URL;
+    const appName = this.settingService.getConfigValue<SolidCoreSetting>('appTitle');
+    const appUrl = this.settingService.getConfigValue<SolidCoreSetting>('solidAppWebsiteUrl');
 
     // Configure mailgen by setting a theme and your product info
     var mailGenerator = new Mailgen({

package/src/controllers/google-authentication.controller.ts

@@ -2,14 +2,15 @@ import { Controller, Get, Inject, InternalServerErrorException, Query, Req, Res,
 import { ConfigType } from '@nestjs/config';
 import { ApiQuery, ApiTags } from '@nestjs/swagger';
 import { Request, Response } from 'express';
-import { isGoogleOAuthConfigured } from 'src/helpers/google-oauth.helper';
-import { iamConfig } from '../config/iam.config';
+import { GoogleAuthConfiguration, isGoogleOAuthConfigured } from 'src/helpers/google-oauth.helper';
 import { Auth } from '../decorators/auth.decorator';
 import { Public } from '../decorators/public.decorator';
 import { AuthType } from '../enums/auth-type.enum';
 import { GoogleOauthGuard } from '../passport-strategies/google-oauth.strategy';
 import { AuthenticationService } from '../services/authentication.service';
 import { UserService } from '../services/user.service';
+import { SettingService } from 'src/services/setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 
 
@@ -20,8 +21,8 @@ import { UserService } from '../services/user.service';
 // @SkipThrottle({ login: false, short: false, burst: true, sustained: true }) //Enable the login throttle only 
 export class GoogleAuthenticationController {
     constructor(
-        @Inject(iamConfig.KEY) private iamConfiguration: ConfigType<typeof iamConfig>,
         private readonly userService: UserService,
+        private readonly settingService: SettingService,
         private readonly authService: AuthenticationService,
     ) { }
 
@@ -29,11 +30,17 @@ export class GoogleAuthenticationController {
     @UseGuards(GoogleOauthGuard)
     @Get('connect')
     async connect() {
-        this.validateConfiguration();
+        await this.validateConfiguration();
     }
 
-    private validateConfiguration() {
-        if (!isGoogleOAuthConfigured(this.iamConfiguration)) {
+    private async validateConfiguration() {
+        const googleOauth: GoogleAuthConfiguration = {
+            clientID: this.settingService.getConfigValue<SolidCoreSetting>("clientID"),
+            clientSecret: this.settingService.getConfigValue<SolidCoreSetting>("clientSecret"),
+            callbackURL: this.settingService.getConfigValue<SolidCoreSetting>("callbackURL"),
+            redirectURL: this.settingService.getConfigValue<SolidCoreSetting>("redirectURL"),
+        }
+        if (!isGoogleOAuthConfigured(googleOauth)) {
             throw new InternalServerErrorException('Google OAuth is not configured');
         }
     }
@@ -41,10 +48,10 @@ export class GoogleAuthenticationController {
     @Public()
     @Get('connect/callback')
     @UseGuards(GoogleOauthGuard)
-    googleAuthCallback(@Req() req: Request, @Res() res: Response) {
-        this.validateConfiguration();
+    async googleAuthCallback(@Req() req: Request, @Res() res: Response) {
+        await this.validateConfiguration();
         const user = req.user;
-
+        const googleOauthRedirectURL = await this.settingService.getConfigValue<SolidCoreSetting>("redirectURL");
         // console.log(`Found user: ${JSON.stringify(user)}`);
         // const token = await this.authService.signIn(req.user);
         //   res.cookie('access_token', token, {
@@ -55,7 +62,7 @@ export class GoogleAuthenticationController {
         // return req.user;
         // return res;
 
-        return res.redirect(`${this.iamConfiguration.googleOauth.redirectURL}?accessCode=${user['accessCode']}`);
+        return res.redirect(`${googleOauthRedirectURL}?accessCode=${user['accessCode']}`);
     }
 
     /**
@@ -68,7 +75,7 @@ export class GoogleAuthenticationController {
     @Public()
     @Get('dummy-redirect')
     async dummyGoogleAuthRedirect(@Query('accessCode') accessCode) {
-        this.validateConfiguration();
+        await this.validateConfiguration();
         const user = await this.userService.findOneByAccessCode(accessCode);
 
         delete user['password'];
@@ -86,7 +93,7 @@ export class GoogleAuthenticationController {
     @Get('authenticate')
     @ApiQuery({ name: 'accessCode', required: true, type: String })
     async googleAuth(@Query('accessCode') accessCode) {
-        this.validateConfiguration();
+        await this.validateConfiguration();
         return this.authService.signInUsingGoogle(accessCode);
     }
 }

package/src/controllers/setting.controller.ts

@@ -1,32 +1,17 @@
-import { BadRequestException, Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, UploadedFiles, UseInterceptors } from '@nestjs/common';
+import { BadRequestException, Body, Controller, Get, Put, Query, UploadedFiles, UseInterceptors } from '@nestjs/common';
 import { AnyFilesInterceptor } from "@nestjs/platform-express";
 import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { Public } from 'src/decorators/public.decorator';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { CreateSettingDto } from '../dtos/create-setting.dto';
-import { UpdateSettingDto } from '../dtos/update-setting.dto';
 import { SettingService } from '../services/setting.service';
 
 @ApiTags('Solid Core')
-@Controller('setting') //FIXME: Change this to the model plural name 
+@Controller('setting')
 export class SettingController {
   constructor(private readonly service: SettingService) { }
 
-  @ApiBearerAuth("jwt")
-  @Post()
-  @UseInterceptors(AnyFilesInterceptor())
-  create(@Body() createDto: CreateSettingDto, @UploadedFiles() files: Array<Express.Multer.File>, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.create(createDto, files, solidRequestContext);
-  }
-
-  @ApiBearerAuth("jwt")
-  @Post('/bulk')
-  @UseInterceptors(AnyFilesInterceptor())
-  insertMany(@Body() createDtos: CreateSettingDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = [], @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.insertMany(createDtos, filesArray, solidRequestContext);
-  }
-
   /**
    * Important to keep this method just above the @Put(':id') definition that follows as otherwise it will conflict. 
    * 
@@ -48,30 +33,16 @@ export class SettingController {
     return this.service.updateSettings(settings, files);
   }
 
-  @ApiBearerAuth("jwt")
-  @Put(':id')
-  @UseInterceptors(AnyFilesInterceptor())
-  update(@Param('id') id: number, @Body() updateDto: UpdateSettingDto, @UploadedFiles() files: Array<Express.Multer.File>, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.update(id, updateDto, files, false, solidRequestContext);
-  }
-
-  @ApiBearerAuth("jwt")
-  @Patch(':id')
-  @UseInterceptors(AnyFilesInterceptor())
-  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateSettingDto, @UploadedFiles() files: Array<Express.Multer.File>, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.update(id, updateDto, files, true, solidRequestContext);
-  }
-
-  @ApiBearerAuth("jwt")
   @Get('/wrapped')
   @Public()
   async wrapSettings() {
-    return this.service.wrapSettings();
+    return this.service.getSystemAdminReadonlyAndAboveSettings();
   }
 
+  @ApiBearerAuth("jwt")
   @Get()
   async getAllSettings() {
-    return this.service.getAllSettings();
+    return this.service.getSystemAdminReadonlyAndAboveSettings();
   }
 
   @ApiBearerAuth("jwt")
@@ -83,50 +54,4 @@ export class SettingController {
 
   }
 
-  @ApiBearerAuth("jwt")
-  @ApiQuery({ name: 'showSoftDeleted', required: false, type: Boolean })
-  @ApiQuery({ name: 'showOnlySoftDeleted', required: false, type: Boolean })
-  @ApiQuery({ name: 'limit', required: false, type: Number })
-  @ApiQuery({ name: 'offset', required: false, type: Number })
-  @ApiQuery({ name: 'fields', required: false, type: Array })
-  @ApiQuery({ name: 'sort', required: false, type: Array })
-  @ApiQuery({ name: 'groupBy', required: false, type: Array })
-  @ApiQuery({ name: 'populate', required: false, type: Array })
-  @ApiQuery({ name: 'populateMedia', required: false, type: Array })
-  @ApiQuery({ name: 'filters', required: false, type: Array })
-  @Get()
-  async findMany(@Query() query: any, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.find(query, solidRequestContext);
-  }
-
-  @ApiBearerAuth("jwt")
-  @Get(':id')
-  async findOne(@Param('id') id: string, @Query() query: any, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.findOne(+id, query, solidRequestContext);
-  }
-
-  @Delete('/bulk')
-  async deleteMany(@Body() ids: number[], @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.deleteMany(ids, solidRequestContext);
-  }
-
-  @ApiBearerAuth("jwt")
-  @Delete(':id')
-  async delete(@Param('id') id: number, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
-    return this.service.delete(id, solidRequestContext);
-  }
-
-  // @ApiBearerAuth("jwt")
-  // @Post('/bulk/user')
-  // @UseInterceptors(AnyFilesInterceptor())
-  // async updateUserSettings(@Body() body: any, @UploadedFiles() files: Array<Express.Multer.File>) {
-  //   let settings: CreateSettingDto[] = [];
-  //   try {
-  //     settings = typeof body.settings === 'string' ? JSON.parse(body.settings) : body.settings;
-  //   } catch (e) {
-  //     throw new BadRequestException('Invalid settings payload');
-  //   }
-  //   return this.service.updateSettings(settings, files);
-  // }
-
-}
+}

package/src/decorators/settings-provider.decorator.ts

@@ -0,0 +1,7 @@
+import { SetMetadata } from "@nestjs/common";
+
+export const IS_SETTINGS_PROVIDER = 'IS_SETTINGS_PROVIDER';
+
+
+export const SettingsProvider = () => SetMetadata(IS_SETTINGS_PROVIDER, true);
+

package/src/decorators/solid-password.decorator.ts

@@ -1,59 +1,59 @@
 // solid-password.decorator.ts
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 import {
-    registerDecorator,
-    ValidationArguments,
-    ValidationOptions,
-    ValidatorConstraint,
-    ValidatorConstraintInterface,
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
 } from 'class-validator';
 import { Injectable } from '@nestjs/common';
-import { iamConfig } from '../config/iam.config';
 import { SettingService } from 'src/services/setting.service';
 
 interface SolidPasswordOptions extends ValidationOptions {
-    regex?: RegExp | string;
-    message?: string;
+  regex?: RegExp | string;
+  message?: string;
 }
 
-@ValidatorConstraint({ async: false })
+@ValidatorConstraint({ async: true })
 @Injectable()
 export class SolidPasswordConstraint implements ValidatorConstraintInterface {
-    private lastMessage = 'Password does not meet complexity requirements';
-  
-    constructor(private readonly settingService: SettingService) {}
-  
-    async validate(value: string, args: ValidationArguments) {
-      if (!value) return false;
-  
-      const opts = args.constraints[0] as SolidPasswordOptions;
-  
-      // Regex source
-      let regex = opts?.regex;
-      if (!regex) {
-        regex = await this.settingService.getConfigValue('authenticationPasswordRegex');
-      }
-  
-      // Message source
-      this.lastMessage =
-        opts?.message || await this.settingService.getConfigValue('authenticationPasswordRegexErrorMessage');
-  
-      return new RegExp(regex).test(value);
-    }
-  
-    defaultMessage(args?: ValidationArguments): string {
-      return this.lastMessage;
+  private lastMessage = 'Password does not meet complexity requirements';
+
+  constructor(private readonly settingService: SettingService) { }
+
+  async validate(value: string, args: ValidationArguments) {
+    if (!value) return false;
+
+    const opts = args.constraints[0] as SolidPasswordOptions;
+
+    // Regex source
+    let regex = opts?.regex;
+    if (!regex) {
+      regex = this.settingService.getConfigValue<SolidCoreSetting>('authenticationPasswordRegex');
     }
+
+    // Message source
+    this.lastMessage =
+      opts?.message || this.settingService.getConfigValue<SolidCoreSetting>('authenticationPasswordRegexErrorMessage');
+
+    return new RegExp(regex).test(value);
   }
+
+  defaultMessage(args?: ValidationArguments): string {
+    return this.lastMessage;
+  }
+}
 export function SolidPasswordRegex(
-    options?: SolidPasswordOptions,
+  options?: SolidPasswordOptions,
 ): PropertyDecorator {
-    return (object: Object, propertyName: string) => {
-        registerDecorator({
-            target: object.constructor,
-            propertyName,
-            options,
-            constraints: [options],
-            validator: SolidPasswordConstraint,
-        });
-    };
+  return (object: Object, propertyName: string) => {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options,
+      constraints: [options],
+      validator: SolidPasswordConstraint,
+    });
+  };
 }

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

@@ -6,6 +6,10 @@ import { UpdateUserDto } from 'src/dtos/update-user.dto';
 import { UpdateMenuItemMetadataDto } from 'src/dtos/update-menu-item-metadata.dto';
 import { ApiProperty } from '@nestjs/swagger';
 
+export const ADMIN_ROLE_NAME = 'Admin';
+export const INTERNAL_ROLE_NAME = 'Internal User';
+export const PUBLIC_ROLE_NAME = 'Public';
+
 export class CreateRoleMetadataDto {
     @IsNotEmpty()
     @IsString()
@@ -54,84 +58,3 @@ 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',
-
-    // User View metadata permissions
-    'UserViewMetadataController.upsert',
-    'UserViewMetadataController.findMany',
-    'UserViewMetadataController.findOne',
-
-    // IAM permissions
-    'AuthenticationController.changePassword',
-    'AuthenticationController.logout',
-    'AuthenticationController.me',
-
-    // Field Metadata permissions
-    'ModelMetadataController.navigation',
-
-    // Field Metadata permissions
-    'FieldMetadataController.getSelectionDynamicValues',
-    'FieldMetadataController.getSelectionDynamicValue',
-    'FieldMetadataController.findFieldDefaultMetaData',
-
-    // Saved Filters permissions
-    'SavedFiltersController.delete',
-    'SavedFiltersController.deleteMany',
-    'SavedFiltersController.findOne',
-    'SavedFiltersController.findMany',
-    'SavedFiltersController.recover',
-    'SavedFiltersController.recoverMany',
-    'SavedFiltersController.partialUpdate',
-    'SavedFiltersController.update',
-    'SavedFiltersController.insertMany',
-    'SavedFiltersController.create',
-
-    // Other permissions can be added here as required.
-    // Chatter permissions
-    'ChatterMessageController.create',
-    'ChatterMessageController.getChatterMessages',
-    'ChatterMessageController.postMessage',
-    'ChatterMessageController.findMany',
-
-    // Import
-    'ImportTransactionController.getImportTemplate',
-    'ImportTransactionController.getImportInstructions',
-    'ImportTransactionController.getImportMappingInfo',
-    '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
-]