@solidstarters/solid-core 1.2.192 → 1.2.200

package/src/helpers/model-metadata-helper.service.ts

@@ -3,6 +3,8 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
 import { SolidRegistry } from "./solid-registry";
+import {_ } from "lodash";
+import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 
 @Injectable()
 export class ModelMetadataHelperService {
@@ -15,97 +17,126 @@ export class ModelMetadataHelperService {
     ) {
     }
 
-    getSystemFieldsMetadata(): any[] {
-        const systemFieldsMetadata = [
+    getSystemFieldsMetadata(isLegacyTable: boolean=false, isLegacyTableWithId: boolean=false): any[] {
+        let systemFieldsMetadata: any[];
+        if (isLegacyTableWithId) {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMappingForLegacyTable(true);
+        }
+        else if (isLegacyTable) {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMappingForLegacyTable(false);
+        }
+        else {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        }
+
+        this.checkWithRegistry(systemFieldsMetadata);
+
+        return systemFieldsMetadata;
+    }
+
+    // TODO: Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
+    // Ideally this should be reflection based code
+    private checkWithRegistry(systemFieldsMetadata: ({ name: string; displayName: string; type: string; ormType: string; isSystem: boolean; relationType?: undefined; relationCoModelSingularName?: undefined; relationCreateInverse?: undefined; relationCascade?: undefined; relationModelModuleName?: undefined; } | { name: string; displayName: string; type: string; isSystem: boolean; ormType?: undefined; relationType?: undefined; relationCoModelSingularName?: undefined; relationCreateInverse?: undefined; relationCascade?: undefined; relationModelModuleName?: undefined; } | { name: string; displayName: string; type: string; ormType: string; isSystem: boolean; relationType: string; relationCoModelSingularName: string; relationCreateInverse: boolean; relationCascade: string; relationModelModuleName: string; })[]) {
+        const commonEntityKeys = this.registry.getCommonEntityKeys();
+        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
+        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
+        if (missingKeys.length > 0) {
+            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+        }
+    }
+
+    private getSystemFieldsMetadataMapping() {
+        return [
             {
                 name: "id",
                 displayName: "Id",
                 type: "int",
-                ormType: "bigint",
                 isSystem: true,
             },
             {
                 name: "createdAt",
                 displayName: "Created At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "updatedAt",
                 displayName: "Updated At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "deletedAt",
                 displayName: "Deleted At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "deletedTracker",
                 displayName: "Deleted Tracker",
                 type: "shortText",
-                ormType: "varchar",
                 isSystem: true,
             },
             {
                 name: "publishedAt",
                 displayName: "Published At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
+                enableAuditTracking:true
             },
             {
                 name: "localeName",
                 displayName: "Locale",
                 type: "shortText",
-                ormType: "varchar",
                 isSystem: true,
             },
             {
                 name: "defaultEntityLocaleId",
                 displayName: "Default Entity Locale Id",
                 type: "int",
-                ormType: "integer",
                 isSystem: true,
             },
             {
                 name: "createdBy",
                 displayName: "Created By",
-                type: "relation",
-                ormType: "integer",
+                type: "int",
                 isSystem: true,
-                relationType: "many-to-one",
-                relationCoModelSingularName: "user",
-                relationCreateInverse: false,
-                relationCascade: "restrict",
-                relationModelModuleName: "solid-core"
+                columnName: "created_by_id",
             },
             {
                 name: "updatedBy",
                 displayName: "Updated By",
-                type: "relation",
-                ormType: "integer",
+                type: "int",
                 isSystem: true,
-                relationType: "many-to-one",
-                relationCoModelSingularName: "user",
-                relationCreateInverse: false,
-                relationCascade: "restrict",
-                relationModelModuleName: "solid-core"
-            },
-        ]
+                columnName: "updated_by_id",
+            }
+        ];
+    }
 
-        // Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
-        const commonEntityKeys = this.registry.getCommonEntityKeys();
-        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
-        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
-        if (missingKeys.length > 0) {
-            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+    private getSystemFieldsMetadataMappingForLegacyTable(withId: boolean=true) {
+        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        if (!withId) {
+            // Remove the id field metadata
+            const index = systemFieldsMetadata.findIndex(field => field.name === 'id');
+            if (index !== -1) {
+                systemFieldsMetadata.splice(index, 1);
+            }
         }
+
+        // For legacy table, system fields, remove the ormType atribute from the metadata
+        // systemFieldsMetadata.forEach(field => {
+        //     delete field.ormType;
+        // });
+
+        // Except for createdBy and updatedBy fields, for which we need to keep the columnName as created_by_id and updated_by_id respectively,
+        // we need to add a columnName attribute with legacy prefix concatenated with the kebab cased field name of the system field
+        systemFieldsMetadata.forEach(field => {
+            if (field.name === 'createdBy' || field.name === 'updatedBy') {
+                field['columnName'] = `${LEGACY_TABLE_FIELDS_PREFIX}_${_.snakeCase(field.name)}_id`;
+            } else {
+                field['columnName'] = `${LEGACY_TABLE_FIELDS_PREFIX}_${_.snakeCase(field.name)}`;
+            }
+        });
         return systemFieldsMetadata;
     }
 

package/src/helpers/module.helper.ts

@@ -21,10 +21,11 @@ export const getDynamicModuleNames = (): string[] => {
 
       if (!isValidDirectory) return false;
 
-      const fullPath = path.join(srcPath, dirent.name);
-      const files = fs.readdirSync(fullPath);
+      return true
+      // const fullPath = path.join(srcPath, dirent.name);
+      // const files = fs.readdirSync(fullPath);
       // skip if empty directory
-      return files.length > 0;
+      // return files.length > 0;
     })
     .map(dirent => dirent.name);
 

package/src/helpers/schematic.service.ts

@@ -1,24 +1,29 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { CommandService } from './command.service';
 import { snakeCase } from "lodash";
-import { CommonEntity } from 'src/entities/common.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { CommandService } from './command.service';
 import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
 export type GenerateModuleOptions = {
   module: string;
 };
-type FieldOptions = {
+type ModelGenerationOptions = Omit<ModelAndFieldGenerationOptions, 'fields'>;
+
+type ModelAndFieldGenerationOptions = {
   module: string;
   model: string;
   moduleDisplayName: string;
   table?: string;
   dataSource: string;
-  fields: any[]; //FIXME This type can be improved
   modelEnableSoftDelete?: boolean;
   parentModel?: string; 
   parentModule?: string;
   draftPublishWorkflowEnabled?: boolean;
+  isLegacyTable?: boolean;
+  isLegacyTableWithId?: boolean;
+  dataSourceType?: string;
+  fields: FieldMetadata[]; //FIXME This type can be improved
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
@@ -32,7 +37,7 @@ export class SchematicService {
 
   async executeSchematicCommand(
     command: string,
-    options: GenerateModuleOptions | FieldOptions,
+    options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug = false,
   ): Promise<string> {
     return await this.commandService.executeCommand(
@@ -42,7 +47,7 @@ export class SchematicService {
 
   private generateSchematicCommand(
     command: string,
-    options: GenerateModuleOptions | FieldOptions,
+    options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug: boolean,
   ): string {
     const baseCommand = `schematics ${this.SCHEMATIC_PROJECT}:${command} --debug=${debug}`;
@@ -50,55 +55,76 @@ export class SchematicService {
       command === REMOVE_FIELDS_COMMAND ||
       command === REFRESH_MODEL_COMMAND
     ) {
-      const fieldOptions = options as FieldOptions;
-      let modelCommand = `${baseCommand} --module=${fieldOptions.module} --model=${fieldOptions.model}`;
-      if (fieldOptions.moduleDisplayName) {
-        modelCommand += ` --module-display-name=${snakeCase(fieldOptions.moduleDisplayName)}`;
-      }
-
-      if (fieldOptions.table) {
-        modelCommand += ` --table=${fieldOptions.table}`;
-      }
-
-      if (fieldOptions.dataSource) {
-        modelCommand += ` --data-source=${fieldOptions.dataSource}`;
-      }
-
-      if (fieldOptions.modelEnableSoftDelete) {
-        modelCommand += ` --model-enable-soft-delete=${fieldOptions.modelEnableSoftDelete}`;
-      }
-
-      if (fieldOptions.parentModel) {
-        modelCommand += ` --parent-model=${fieldOptions.parentModel}`;
-      }
-      if (fieldOptions.parentModule) {
-        modelCommand += ` --parent-module=${fieldOptions.parentModule}`;
-      }
-
-      if (fieldOptions.draftPublishWorkflowEnabled) {
-        modelCommand += ` --draft-publish-workflow-enabled=${fieldOptions.draftPublishWorkflowEnabled}`;
-      }
-      
-      let fieldCommand = fieldOptions.fields
-        .filter((field) => {
-          return !this.solidRegistry.getCommonEntityKeys().includes(field.name);
-        })
-        .map((field) => {
-          return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
-        })
-        .join(' ');
+      const {fields, ...modelSpecificOptions} = options as ModelAndFieldGenerationOptions;
+      const modelCommand = this.buildModelGenerationCommand(baseCommand, modelSpecificOptions);
+      const fieldCommand = this.buildFieldGenerationCommand(fields);
       const schematicCommand = modelCommand + ' ' + fieldCommand;
-      // console.log('schematicCommand', schematicCommand);
+      this.logger.debug('schematicCommand', schematicCommand);
       return schematicCommand;
     } else if (command === ADD_MODULE_COMMAND) {
       const moduleOptions = options as GenerateModuleOptions;
-      // console.log('moduleOptions', moduleOptions);
       const schematicCommand = ` ${baseCommand} --module=${moduleOptions.module}`;
-      // console.log('schematicCommand', schematicCommand);
       this.logger.debug('schematicCommand', schematicCommand);
       return schematicCommand;
     } else {
       throw new Error('Schematic command not supported.');
     }
   }
+
+  private buildFieldGenerationCommand(fields: FieldMetadata[]) {
+    return fields
+      .filter((field) => {
+        return !this.solidRegistry.getCommonEntityKeys().map(key => key.toString()).includes(field.name);
+      })
+      .map((field) => {
+        return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
+      })
+      .join(' ');
+  }
+
+  private buildModelGenerationCommand(baseCommand: string, modelSpecificOptions: ModelGenerationOptions): string {
+    let modelCommand = `${baseCommand} --module=${modelSpecificOptions.module} --model=${modelSpecificOptions.model}`;
+
+    // Make below options code generate i.e if option exists then add to command with proper casing
+    if (modelSpecificOptions.moduleDisplayName) {
+      modelCommand += ` --module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`;
+    }
+
+    if (modelSpecificOptions.table) {
+      modelCommand += ` --table=${modelSpecificOptions.table}`;
+    }
+
+    if (modelSpecificOptions.dataSource) {
+      modelCommand += ` --data-source=${modelSpecificOptions.dataSource}`;
+    }
+
+    if (modelSpecificOptions.modelEnableSoftDelete) {
+      modelCommand += ` --model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`;
+    }
+
+    if (modelSpecificOptions.parentModel) {
+      modelCommand += ` --parent-model=${modelSpecificOptions.parentModel}`;
+    }
+    if (modelSpecificOptions.parentModule) {
+      modelCommand += ` --parent-module=${modelSpecificOptions.parentModule}`;
+    }
+
+    if (modelSpecificOptions.draftPublishWorkflowEnabled) {
+      modelCommand += ` --draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`;
+    }
+
+    if (modelSpecificOptions.isLegacyTable) {
+      modelCommand += ` --is-legacy-table=${modelSpecificOptions.isLegacyTable}`;
+    }
+
+    if (modelSpecificOptions.isLegacyTableWithId) {
+      modelCommand += ` --is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`;
+    }
+
+    if (modelSpecificOptions.dataSourceType) {
+      modelCommand += ` --data-source-type=${modelSpecificOptions.dataSourceType}`;
+    }
+    
+    return modelCommand;
+  }
 }

package/src/helpers/solid-registry.ts

@@ -5,7 +5,8 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
+import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
 
 type ControllerMetadata = {
   name: string;
@@ -247,6 +248,17 @@ export class SolidRegistry {
     return Array.from(this.solidDatabaseModules);
   }
 
+  getDefaultSolidDatabaseModule(): ISolidDatabaseModule {
+    const solidDatabaseModulesAsArray = Array.from(this.solidDatabaseModules);
+    for (let i = 0; i < solidDatabaseModulesAsArray.length; i++) {
+      const solidDatabaseModule = solidDatabaseModulesAsArray[i];
+      const solidDatabaseModuleInstance: ISolidDatabaseModule = solidDatabaseModule.instance;
+      if (solidDatabaseModuleInstance.name() === 'default') {
+        return solidDatabaseModuleInstance;
+      }
+    }
+  }
+
   getModules(): Array<InstanceWrapper> {
     return Array.from(this.modules);
   }
@@ -288,7 +300,7 @@ export class SolidRegistry {
     });
   }
 
-  getCommonEntityKeys(): (keyof CommonEntity)[] {
+  getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
     return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
   }

package/src/helpers/typeorm-db-helper.ts

@@ -0,0 +1,26 @@
+import { ColumnOptions } from "typeorm";
+import { DatasourceType } from "src/dtos/create-model-metadata.dto";
+
+const LONG_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: { type: "text" },
+    [DatasourceType.mssql]: { type: "nvarchar", length: "max" },
+    [DatasourceType.mysql]: { type: "longtext" },
+    [DatasourceType.mariadb]: { type: "longtext" },
+    [DatasourceType.oracle]: { type: "clob" },
+};
+
+const solidCoreDbType: DatasourceType =
+    Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
+        ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
+        : DatasourceType.postgres;
+
+export function getColumnType(solidType: string): ColumnOptions {
+    switch (solidType) {
+        case "longText":
+        case "richText":
+            return LONG_TEXT_MAP[solidCoreDbType];
+
+        default:
+            return {};
+    }
+}

package/src/index.ts

@@ -23,8 +23,10 @@ export * from './decorators/error-codes-provider.decorator'
 export * from './decorators/solid-database-module.decorator'
 export * from './decorators/solid-service.decorator'
 export * from './decorators/mail-provider.decorator'
+export * from './decorators/security-rule-config-provider.decorator'
 
 export * from './dtos/post-chatter-message.dto'
+export * from './dtos/security-rule-config.dto'
 export * from './dtos/basic-filters.dto'
 export * from './dtos/solid-request-context.dto'
 export * from './dtos/change-password.dto'
@@ -98,6 +100,8 @@ export * from './dtos/update-user-activity-history.dto'
 
 export * from './entities/action-metadata.entity'
 export * from './entities/common.entity'
+export * from './entities/legacy-common.entity'
+export * from './entities/legacy-common-with-id.entity'
 export * from './entities/email-attachment.entity'
 export * from './entities/email-template.entity'
 export * from './entities/field-metadata.entity'
@@ -204,7 +208,7 @@ export * from './listeners/user-registration.listener'
 export * from './passport-strategies/google-oauth.strategy'
 export * from './passport-strategies/local.strategy'
 
-export * from './providers/list-of-values-selection-providers.service'
+export * from './services/selection-providers/list-of-values-selection-providers.service'
 
 // seed-data
 export * from './seeders/email-template-seeder.service'

package/src/interfaces.ts

@@ -64,7 +64,10 @@ export interface CodeGenerationOptions {
   modelId?: number;
   modelUserKey?: string;
   fieldIdsForRemoval?: number[];
+  fieldNamesForRemoval?: string[];
   dryRun?: boolean;
+  fieldIdsForRefresh?: number[];
+  fieldNamesForRefresh?: string[];
 }
 
 export interface TriggerMcpClientOptions {

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -144,7 +144,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
 
         const existingControllerAndTheirMethods = this.solidRegistry.getControllers();
 
-        
+
 
         // Build markdown sections using template interpolation
         const modulesSection = (existingModules ?? [])
@@ -170,7 +170,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
                 `- name: ${d.name}`,
                 `- description: ${d.description ?? ""}`,
             ].join('\n'))
-            .join('\n\n');    
+            .join('\n\n');
 
         const computationProvidersSection = (existingComputationProviders ?? [])
             .map(m => [
@@ -183,7 +183,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
         const controllersAndTheirMethods = (existingControllerAndTheirMethods ?? [])
             .map(m => [
                 `### ${m.name}`,
-                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n'): '- No methods found'}`,
+                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n') : '- No methods found'}`,
             ].join('\n'))
             .join('\n\n');
 
@@ -224,11 +224,10 @@ Use the below list of computed field providers to infer which provider the user
 ${computationProvidersSection}
 `.trim();
 
+        // ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
+        // Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
 
-// ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
-// Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
-
-// ${controllersAndTheirMethods}
+        // ${controllersAndTheirMethods}
 
         const aiResponse = await this.aiInteractionService.runMcpPrompt(finalPrompt);
         this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
@@ -247,7 +246,7 @@ ${computationProvidersSection}
             //     role: 'gen-ai',
             //     message: '-',
             //     contentType: aiResponse.content_type,
-            //     errorMessage: errorsStr,
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
             //     modelUsed: aiResponse.model,
             //     responseTimeMs: aiResponse.duration_ms,
             //     metadata: JSON.stringify(aiResponse, null, 2),
@@ -257,7 +256,7 @@ ${computationProvidersSection}
 
             // TODO: Update the previously created genAiInteraction record with the respective error fields and save to DB
             await this.aiInteractionService.update(genAiInteraction.id, {
-                // contentType: aiResponse.content_type,
+                contentType: aiResponse.content_type,
                 errorMessage: `${errorsStr}\n\n${errorTrace}`,
                 modelUsed: aiResponse.model,
                 responseTimeMs: aiResponse.duration_ms,
@@ -271,6 +270,10 @@ ${computationProvidersSection}
         else {
             let nestedResponse = this.cleanNestedResponse(aiResponse);
 
+            // TODO: Update the previously created genAiInteraction record with the respective success fields and save to DB
+            const errorsStr = nestedResponse?.status == "error" && nestedResponse?.errors.join('\n ');
+            const errorTrace = nestedResponse?.status == "error" && nestedResponse?.error_trace?.join('\n');
+
             // const genAiInteraction = await this.aiInteractionService.create({
             //     userId: aiInteraction.user.id,
             //     threadId: aiInteraction.threadId,
@@ -278,7 +281,7 @@ ${computationProvidersSection}
             //     role: 'gen-ai',
             //     message: nestedResponse,
             //     contentType: aiResponse.content_type,
-            //     errorMessage: '',
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
             //     modelUsed: aiResponse.model,
             //     responseTimeMs: aiResponse.duration_ms,
             //     metadata: JSON.stringify(aiResponse, null, 2),
@@ -286,21 +289,14 @@ ${computationProvidersSection}
             //     status: aiResponse.success ? 'succeeded' : 'failed'
             // });
 
-            // TODO: Update the previously created genAiInteraction record with the respective success fields and save to DB
-            const errorsStr = nestedResponse?.status == "error" && nestedResponse?.errors.join('\n ');
-            // const errorTrace = nestedResponse?.status == "error" && nestedResponse?.error_trace?.join('\n');
-
-
             await this.aiInteractionService.update(genAiInteraction.id, {
-                errorMessage: nestedResponse.status == "error" ? `${errorsStr}` : "",
-                // errorMessage:"",
-                // contentType: aiResponse.content_type,
-                // message: nestedResponse,
+                errorMessage: nestedResponse.status == "error" ? `${errorsStr}\n\n${errorTrace}` : "",
+                contentType: aiResponse.content_type,
+                message: JSON.stringify(nestedResponse),
                 modelUsed: aiResponse.model,
                 responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse, null, 2),
                 isApplied: aiInteraction.isApplied,
-
-                // status: aiResponse.success ? 'succeeded' : 'failed'
                 status: aiResponse.success && nestedResponse.status == "success" ? 'succeeded' : 'failed'
             }, [], true);