@solidxai/core 0.1.10-beta.10 → 0.1.10-beta.12

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

@@ -5932,6 +5932,214 @@
             "isSystem": true
           }
         ]
+      },
+      {
+        "singularName": "mcpAuditLog",
+        "pluralName": "mcpAuditLogs",
+        "displayName": "MCP Audit Log",
+        "description": "Audit trail of MCP requests handled by the server",
+        "dataSource": "default",
+        "dataSourceType": "postgres",
+        "tableName": "ss_mcp_audit_log",
+        "isChild": false,
+        "isLegacyTable": true,
+        "isLegacyTableWithId": true,
+        "enableAuditTracking": false,
+        "enableSoftDelete": false,
+        "draftPublishWorkflow": false,
+        "internationalisation": false,
+        "isSystem": true,
+        "userKeyFieldUserKey": "id",
+        "fields": [
+          {
+            "name": "userId",
+            "displayName": "User ID",
+            "type": "int",
+            "columnName": "user_id",
+            "required": false,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "apiKeyId",
+            "displayName": "API Key ID",
+            "type": "int",
+            "columnName": "api_key_id",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "username",
+            "displayName": "Username",
+            "type": "shortText",
+            "columnName": "username",
+            "length": 128,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "transport",
+            "displayName": "Transport",
+            "type": "shortText",
+            "columnName": "transport",
+            "length": 32,
+            "required": true,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "mcpSessionId",
+            "displayName": "MCP Session ID",
+            "type": "shortText",
+            "columnName": "mcp_session_id",
+            "length": 64,
+            "required": false,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "clientAddr",
+            "displayName": "Client Address",
+            "type": "shortText",
+            "columnName": "client_addr",
+            "length": 64,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "method",
+            "displayName": "Method",
+            "type": "shortText",
+            "columnName": "method",
+            "length": 64,
+            "required": true,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "requestId",
+            "displayName": "Request ID",
+            "type": "shortText",
+            "columnName": "request_id",
+            "length": 64,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "toolName",
+            "displayName": "Tool Name",
+            "type": "shortText",
+            "columnName": "tool_name",
+            "length": 128,
+            "required": false,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "requestParams",
+            "displayName": "Request Params",
+            "type": "longText",
+            "columnName": "request_params",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "status",
+            "displayName": "Status",
+            "type": "shortText",
+            "columnName": "status",
+            "length": 16,
+            "required": true,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "responseResult",
+            "displayName": "Response Result",
+            "type": "longText",
+            "columnName": "response_result",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "errorCode",
+            "displayName": "Error Code",
+            "type": "int",
+            "columnName": "error_code",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "errorMessage",
+            "displayName": "Error Message",
+            "type": "longText",
+            "columnName": "error_message",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "durationMs",
+            "displayName": "Duration (ms)",
+            "type": "decimal",
+            "columnName": "duration_ms",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          }
+        ]
       }
     ]
   },
@@ -5998,6 +6206,8 @@
         "AgentSessionController.findOne",
         "AgentEventController.findMany",
         "AgentEventController.findOne",
+        "McpAuditLogController.findMany",
+        "McpAuditLogController.findOne",
         "mcp:invoke",
         "agent:invoke"
       ]
@@ -6607,6 +6817,32 @@
       "viewUserKey": "agentEvent-form-view",
       "moduleUserKey": "solid-core",
       "modelUserKey": "agentEvent"
+    },
+    {
+      "displayName": "MCP Audit Log List Action",
+      "name": "mcpAuditLog-list-action",
+      "type": "solid",
+      "domain": "",
+      "context": "",
+      "customComponent": "",
+      "customIsModal": true,
+      "serverEndpoint": "",
+      "viewUserKey": "mcpAuditLog-list-view",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "mcpAuditLog"
+    },
+    {
+      "displayName": "MCP Audit Log Form Action",
+      "name": "mcpAuditLog-form-action",
+      "type": "solid",
+      "domain": "",
+      "context": "",
+      "customComponent": "",
+      "customIsModal": true,
+      "serverEndpoint": "",
+      "viewUserKey": "mcpAuditLog-form-view",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "mcpAuditLog"
     }
   ],
   "menus": [
@@ -6963,6 +7199,14 @@
       "actionUserKey": "agentEvent-list-action",
       "moduleUserKey": "solid-core",
       "parentMenuItemUserKey": "agent-menu-item"
+    },
+    {
+      "displayName": "MCP Audit Log",
+      "name": "mcpAuditLog-menu-item",
+      "sequenceNumber": 3,
+      "actionUserKey": "mcpAuditLog-list-action",
+      "moduleUserKey": "solid-core",
+      "parentMenuItemUserKey": "agent-menu-item"
     }
   ],
   "views": [
@@ -13894,6 +14138,108 @@
           }
         ]
       }
+    },
+    {
+      "name": "mcpAuditLog-list-view",
+      "displayName": "MCP Audit Logs",
+      "type": "list",
+      "context": "{}",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "mcpAuditLog",
+      "layout": {
+        "type": "list",
+        "attrs": {
+          "pagination": true,
+          "pageSizeOptions": [10, 25, 50],
+          "enableGlobalSearch": true,
+          "create": true,
+          "edit": true,
+          "delete": false
+        },
+        "children": [
+          { "type": "field", "attrs": { "name": "id" } },
+          { "type": "field", "attrs": { "name": "createdAt" } },
+          { "type": "field", "attrs": { "name": "method", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "toolName", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "status", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "username", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "userId" } },
+          { "type": "field", "attrs": { "name": "transport", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "mcpSessionId", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "clientAddr", "isSearchable": true } },
+          { "type": "field", "attrs": { "name": "durationMs" } },
+          { "type": "field", "attrs": { "name": "errorCode" } }
+        ]
+      }
+    },
+    {
+      "name": "mcpAuditLog-form-view",
+      "displayName": "MCP Audit Log",
+      "type": "form",
+      "context": "{}",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "mcpAuditLog",
+      "layout": {
+        "type": "form",
+        "attrs": {
+          "name": "form-1",
+          "label": "MCP Audit Log",
+          "className": "grid"
+        },
+        "children": [
+          {
+            "type": "sheet",
+            "attrs": { "name": "sheet-1" },
+            "children": [
+              {
+                "type": "row",
+                "attrs": { "name": "row-1" },
+                "children": [
+                  {
+                    "type": "column",
+                    "attrs": { "name": "col-1", "label": "", "className": "col-12 sm:col-12 md:col-6 lg:col-6" },
+                    "children": [
+                      { "type": "field", "attrs": { "name": "method" } },
+                      { "type": "field", "attrs": { "name": "toolName" } },
+                      { "type": "field", "attrs": { "name": "status" } },
+                      { "type": "field", "attrs": { "name": "transport" } },
+                      { "type": "field", "attrs": { "name": "mcpSessionId" } },
+                      { "type": "field", "attrs": { "name": "requestId" } }
+                    ]
+                  },
+                  {
+                    "type": "column",
+                    "attrs": { "name": "col-2", "label": "", "className": "col-12 sm:col-12 md:col-6 lg:col-6" },
+                    "children": [
+                      { "type": "field", "attrs": { "name": "userId" } },
+                      { "type": "field", "attrs": { "name": "apiKeyId" } },
+                      { "type": "field", "attrs": { "name": "username" } },
+                      { "type": "field", "attrs": { "name": "clientAddr" } },
+                      { "type": "field", "attrs": { "name": "durationMs" } },
+                      { "type": "field", "attrs": { "name": "errorCode" } }
+                    ]
+                  }
+                ]
+              },
+              {
+                "type": "row",
+                "attrs": { "name": "row-2" },
+                "children": [
+                  {
+                    "type": "column",
+                    "attrs": { "name": "col-payload", "label": "", "className": "col-12" },
+                    "children": [
+                      { "type": "field", "attrs": { "name": "requestParams", "viewWidget": "SolidJsonFormViewWidget" } },
+                      { "type": "field", "attrs": { "name": "responseResult", "viewWidget": "SolidJsonFormViewWidget" } },
+                      { "type": "field", "attrs": { "name": "errorMessage" } }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
     }
   ],
   "emailTemplates": [

package/src/services/1.js

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

package/src/services/mcp-audit-log.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { McpAuditLog } from 'src/entities/mcp-audit-log.entity';
+import { McpAuditLogRepository } from 'src/repository/mcp-audit-log.repository';
+import { EntityManager } from 'typeorm';
+import { CRUDService } from './crud.service';
+
+@Injectable()
+export class McpAuditLogService extends CRUDService<McpAuditLog> {
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: McpAuditLogRepository,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'mcpAuditLog', 'solid-core', moduleRef);
+  }
+}

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

@@ -27,6 +27,7 @@ import {
   REMOVE_FIELDS_COMMAND,
   SchematicService
 } from '../helpers/schematic.service';
+import { CommandService } from '../helpers/command.service';
 import { CodeGenerationOptions } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { FieldMetadataService } from './field-metadata.service';
@@ -49,6 +50,7 @@ export class ModelMetadataService {
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly fieldMetadataRepo: FieldMetadataRepository,
     private readonly schematicService: SchematicService,
+    private readonly commandService: CommandService,
     @InjectDataSource()
     private readonly dataSource: DataSource,
     private readonly crudHelperService: CrudHelperService,
@@ -735,6 +737,16 @@ export class ModelMetadataService {
 
   }
 
+  @DisallowInProduction()
+  async generateCodeViaCtl(modelId: number): Promise<string> {
+    const model = await this.findOne(modelId);
+    return this.commandService.executeCommandWithArgs({
+      command: 'npx',
+      args: ['@solixai/solidctl@latest', 'generate', 'model', `--name=${model.singularName}`],
+      cwd: path.join(process.cwd(), '..'),
+    });
+  }
+
   @DisallowInProduction()
   async handleGenerateCode(options: CodeGenerationOptions): Promise<any> {
     const affectedModelIds = [], refreshModelCodeOutputLines = [], removeFieldCodeOutputLines = [];
@@ -1275,24 +1287,13 @@ export class ModelMetadataService {
     };
     const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
 
-    let fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
-
-    // If a list of field ids or field names is passed for refresh, use these fields only
-    if (options.fieldIdsForRefresh && options.fieldIdsForRefresh.length > 0) {
-      fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldIdsForRefresh.includes(+field.id));
-    } else if (options.fieldNamesForRefresh && options.fieldNamesForRefresh.length > 0) {
-      fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldNamesForRefresh.includes(field.name));
-    }
-    // const fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
-
     //Execute the schematic command to refresh the model
-    const refreshOuput = await this.executeRefreshModelCommand(model, fieldsForRefresh, options.dryRun);
+    const refreshOuput = await this.executeRefreshModelCommand(model, options.dryRun);
 
     return `${refreshOuput}`;
   }
 
-  private async executeRefreshModelCommand(model: ModelMetadata, fieldsForRefresh: FieldMetadata[], dryRun: boolean = false): Promise<string> {
-    // const fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
+  private async executeRefreshModelCommand(model: ModelMetadata, dryRun: boolean = false): Promise<string> {
     const output = await this.schematicService.executeSchematicCommand(
       REFRESH_MODEL_COMMAND,
       {

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

@@ -22,6 +22,7 @@ import {
   ADD_MODULE_COMMAND,
   SchematicService,
 } from '../helpers/schematic.service';
+import { CommandService } from '../helpers/command.service';
 import { SolidRegistry } from '../helpers/solid-registry';
 import { CodeGenerationOptions, ModuleMetadataConfiguration } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
@@ -40,6 +41,7 @@ export class ModuleMetadataService {
     private readonly moduleMetadataRepo: ModuleMetadataRepository,
     private readonly crudHelperService: CrudHelperService,
     private readonly schematicService: SchematicService,
+    private readonly commandService: CommandService,
     private readonly fileService: DiskFileService,
     private readonly settingService: SettingService,
 
@@ -403,6 +405,16 @@ export class ModuleMetadataService {
     return true
   }
 
+  @DisallowInProduction()
+  async generateCodeViaCtl(moduleId: number): Promise<string> {
+    const module = await this.findOne(moduleId);
+    return this.commandService.executeCommandWithArgs({
+      command: 'npx',
+      args: ['@solixai/solidctl@latest', 'generate', 'module', `--name=${module.name}`],
+      cwd: path.join(process.cwd(), '..'),
+    });
+  }
+
   @DisallowInProduction()
   async generateCode(options: CodeGenerationOptions): Promise<string> {
     if (!options.moduleId && !options.moduleUserKey) {

package/src/solid-core.module.ts

@@ -191,6 +191,7 @@ import { SavedFiltersController } from './controllers/saved-filters.controller';
 import { ScheduledJobController } from './controllers/scheduled-job.controller';
 import { AgentSessionController } from './controllers/agent-session.controller';
 import { AgentEventController } from './controllers/agent-event.controller';
+import { McpAuditLogController } from './controllers/mcp-audit-log.controller';
 import { SecurityRuleController } from './controllers/security-rule.controller';
 import { SettingController } from './controllers/setting.controller';
 import { InfoController } from './controllers/info.controller';
@@ -217,6 +218,7 @@ import { SavedFilters } from './entities/saved-filters.entity';
 import { ScheduledJob } from './entities/scheduled-job.entity';
 import { AgentSession } from './entities/agent-session.entity';
 import { AgentEvent } from './entities/agent-event.entity';
+import { McpAuditLog } from './entities/mcp-audit-log.entity';
 import { SecurityRule } from './entities/security-rule.entity';
 import { Setting } from './entities/setting.entity';
 import { UserActivityHistory } from './entities/user-activity-history.entity';
@@ -295,6 +297,7 @@ import { SavedFiltersRepository } from './repository/saved-filters.repository';
 import { ScheduledJobRepository } from './repository/scheduled-job.repository';
 import { AgentSessionRepository } from './repository/agent-session.repository';
 import { AgentEventRepository } from './repository/agent-event.repository';
+import { McpAuditLogRepository } from './repository/mcp-audit-log.repository';
 import { SecurityRuleRepository } from './repository/security-rule.repository';
 import { SettingRepository } from './repository/setting.repository';
 import { SmsTemplateRepository } from './repository/sms-template.repository';
@@ -344,6 +347,7 @@ import { SavedFiltersService } from './services/saved-filters.service';
 import { ScheduledJobService } from './services/scheduled-job.service';
 import { AgentSessionService } from './services/agent-session.service';
 import { AgentEventService } from './services/agent-event.service';
+import { McpAuditLogService } from './services/mcp-audit-log.service';
 import { SchedulerServiceImpl } from './services/scheduled-jobs/scheduler.service';
 import { SecurityRuleService } from './services/security-rule.service';
 import { ListOfDashboardQuestionProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-question-providers-selection-provider.service';
@@ -427,6 +431,7 @@ import { Entity } from 'typeorm';
       ScheduledJob,
       AgentSession,
       AgentEvent,
+      McpAuditLog,
       SecurityRule,
       Setting,
       SmsTemplate,
@@ -505,6 +510,7 @@ import { Entity } from 'typeorm';
     ScheduledJobController,
     AgentSessionController,
     AgentEventController,
+    McpAuditLogController,
     SecurityRuleController,
     ServiceController,
     SettingController,
@@ -774,8 +780,10 @@ import { Entity } from 'typeorm';
     ScheduledJobRepository,
     AgentSessionRepository,
     AgentEventRepository,
+    McpAuditLogRepository,
     AgentSessionService,
     AgentEventService,
+    McpAuditLogService,
     ScheduledJobSubscriber,
     AlphaNumExternalIdComputationProvider,
     ListOfValuesSubscriber,

package/dist-tests/api/authenticate.spec.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_1 = require("@playwright/test");
-const env_1 = require("../helpers/env");
-const baseURL = process.env.API_BASE_URL ?? "http://localhost:3000";
-const TEST_USER_EMAIL = (0, env_1.getRequiredEnv)("TEST_USER_EMAIL");
-const TEST_USER_PASSWORD = (0, env_1.getRequiredEnv)("TEST_USER_PASSWORD");
-function base64UrlDecode(input) {
-    const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = normalized.length % 4 === 0
-        ? normalized
-        : normalized.padEnd(normalized.length + (4 - (normalized.length % 4)), "=");
-    return Buffer.from(padded, "base64").toString("utf-8");
-}
-function validateJwt(token) {
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-        throw new Error("JWT must have three dot-separated parts.");
-    }
-    const headerJson = JSON.parse(base64UrlDecode(parts[0]));
-    const payloadJson = JSON.parse(base64UrlDecode(parts[1]));
-    if (!headerJson || typeof headerJson !== "object") {
-        throw new Error("JWT header must be a JSON object.");
-    }
-    if (!payloadJson || typeof payloadJson !== "object") {
-        throw new Error("JWT payload must be a JSON object.");
-    }
-    if (typeof payloadJson.exp !== "number") {
-        throw new Error("JWT payload.exp must be a number.");
-    }
-    return payloadJson;
-}
-(0, test_1.test)("API: authenticate succeeds with valid credentials", async () => {
-    const api = await test_1.request.newContext({
-        baseURL,
-        extraHTTPHeaders: {
-            accept: "*/*",
-            "content-type": "application/json",
-        },
-    });
-    try {
-        const res = await api.post("/api/iam/authenticate", {
-            data: {
-                email: TEST_USER_EMAIL,
-                username: "",
-                password: TEST_USER_PASSWORD,
-            },
-        });
-        (0, test_1.expect)(res.status()).toBe(200);
-        const json = await res.json();
-        (0, test_1.expect)(json.statusCode).toBe(200);
-        (0, test_1.expect)(Array.isArray(json.message)).toBe(true);
-        (0, test_1.expect)(json.message.length).toBe(0);
-        (0, test_1.expect)(json.error).toBe("");
-        const user = json.data?.user;
-        (0, test_1.expect)(user, "Expected data.user to be an object.").toBeTruthy();
-        (0, test_1.expect)(typeof user).toBe("object");
-        const email = user?.email;
-        (0, test_1.expect)(typeof email).toBe("string");
-        if (email === TEST_USER_EMAIL) {
-            (0, test_1.expect)(email).toBe(TEST_USER_EMAIL);
-        }
-        else {
-            (0, test_1.expect)(email.length).toBeGreaterThan(0);
-        }
-        (0, test_1.expect)(typeof user?.mobile).toBe("string");
-        (0, test_1.expect)(typeof user?.username).toBe("string");
-        (0, test_1.expect)(typeof user?.forcePasswordChange).toBe("boolean");
-        (0, test_1.expect)(typeof user?.id).toBe("number");
-        const roles = user?.roles;
-        (0, test_1.expect)(Array.isArray(roles)).toBe(true);
-        if (Array.isArray(roles)) {
-            (0, test_1.expect)(roles.every((role) => typeof role === "string")).toBe(true);
-            (0, test_1.expect)(roles).toContain("Admin");
-        }
-        const accessToken = json.data?.accessToken;
-        const refreshToken = json.data?.refreshToken;
-        (0, test_1.expect)(typeof accessToken).toBe("string");
-        (0, test_1.expect)(typeof refreshToken).toBe("string");
-        const accessPayload = validateJwt(accessToken);
-        const refreshPayload = validateJwt(refreshToken);
-        (0, test_1.expect)(typeof accessPayload.exp).toBe("number");
-        (0, test_1.expect)(typeof refreshPayload.exp).toBe("number");
-    }
-    finally {
-        await api.dispose();
-    }
-});
-(0, test_1.test)("API: authenticate fails with wrong password", async () => {
-    const api = await test_1.request.newContext({
-        baseURL,
-        extraHTTPHeaders: {
-            accept: "*/*",
-            "content-type": "application/json",
-        },
-    });
-    try {
-        const res = await api.post("/api/iam/authenticate", {
-            data: {
-                email: TEST_USER_EMAIL,
-                username: "",
-                password: `${TEST_USER_PASSWORD}__wrong`,
-            },
-        });
-        (0, test_1.expect)(res.status()).toBe(401);
-        const json = await res.json();
-        (0, test_1.expect)(json.statusCode).toBe(401);
-        (0, test_1.expect)(json.statusCodeMessage).toBe("Unauthorized");
-        (0, test_1.expect)(json.message).toBe("Invalid credentials");
-        (0, test_1.expect)(json.error).toBe("Invalid credentials");
-        (0, test_1.expect)(json.data?.statusCode).toBe(401);
-        (0, test_1.expect)(json.data?.error).toBe("Unauthorized");
-        (0, test_1.expect)(json.data?.message).toBe("Invalid credentials");
-    }
-    finally {
-        await api.dispose();
-    }
-});
-//# sourceMappingURL=authenticate.spec.js.map