@skyramp/skyramp 0.4.106 → 0.5.1

package/lib/dev-darwin-amd64.h

@@ -40,6 +40,11 @@ struct worker_info {
     char *error;
 };
 
+struct response_wrapper {
+    char *response;
+    char *error;
+};
+
 #line 1 "cgo-generated-wrapper"
 
 #line 7 "endpoint.go"
@@ -127,6 +132,18 @@ extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthTo
 extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
+extern struct response_wrapper sendRequestWrapper(char* address, char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* request);
+
+/* Return type for getJSONValueWrapper */
+struct getJSONValueWrapper_return {
+	char* r0;
+	char* r1;
+};
+extern struct getJSONValueWrapper_return getJSONValueWrapper(char* jsonS, char* path);
+extern char* checkStatusCodeWrapper(char* response, char* expectedStatus);
+extern char* deployDockerDashboardWrapper(char* networkName);
+extern char* deployK8sDashboardWrapper(char* networkName);
+extern struct response_wrapper checkSchemaWrapper(char* requestBody, char* sampleSchema);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);
 extern char* newRestEndpointWrapper(char* name, char* openApiTag, GoInt port, char* inputFile, char* restPath);
 extern char* getEndpointWrapper(char* service, GoInt port, char* restPath);

package/lib/dev-darwin-arm64.h

@@ -40,6 +40,11 @@ struct worker_info {
     char *error;
 };
 
+struct response_wrapper {
+    char *response;
+    char *error;
+};
+
 #line 1 "cgo-generated-wrapper"
 
 #line 7 "endpoint.go"
@@ -127,6 +132,18 @@ extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthTo
 extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
+extern struct response_wrapper sendRequestWrapper(char* address, char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* request);
+
+/* Return type for getJSONValueWrapper */
+struct getJSONValueWrapper_return {
+	char* r0;
+	char* r1;
+};
+extern struct getJSONValueWrapper_return getJSONValueWrapper(char* jsonS, char* path);
+extern char* checkStatusCodeWrapper(char* response, char* expectedStatus);
+extern char* deployDockerDashboardWrapper(char* networkName);
+extern char* deployK8sDashboardWrapper(char* networkName);
+extern struct response_wrapper checkSchemaWrapper(char* requestBody, char* sampleSchema);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);
 extern char* newRestEndpointWrapper(char* name, char* openApiTag, GoInt port, char* inputFile, char* restPath);
 extern char* getEndpointWrapper(char* service, GoInt port, char* restPath);

package/lib/dev-linux-386.h

@@ -40,6 +40,11 @@ struct worker_info {
     char *error;
 };
 
+struct response_wrapper {
+    char *response;
+    char *error;
+};
+
 #line 1 "cgo-generated-wrapper"
 
 #line 7 "endpoint.go"
@@ -127,6 +132,18 @@ extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthTo
 extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
+extern struct response_wrapper sendRequestWrapper(char* address, char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* request);
+
+/* Return type for getJSONValueWrapper */
+struct getJSONValueWrapper_return {
+	char* r0;
+	char* r1;
+};
+extern struct getJSONValueWrapper_return getJSONValueWrapper(char* jsonS, char* path);
+extern char* checkStatusCodeWrapper(char* response, char* expectedStatus);
+extern char* deployDockerDashboardWrapper(char* networkName);
+extern char* deployK8sDashboardWrapper(char* networkName);
+extern struct response_wrapper checkSchemaWrapper(char* requestBody, char* sampleSchema);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);
 extern char* newRestEndpointWrapper(char* name, char* openApiTag, GoInt port, char* inputFile, char* restPath);
 extern char* getEndpointWrapper(char* service, GoInt port, char* restPath);

package/lib/dev-linux-amd64.h

@@ -40,6 +40,11 @@ struct worker_info {
     char *error;
 };
 
+struct response_wrapper {
+    char *response;
+    char *error;
+};
+
 #line 1 "cgo-generated-wrapper"
 
 #line 7 "endpoint.go"
@@ -127,6 +132,18 @@ extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthTo
 extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
+extern struct response_wrapper sendRequestWrapper(char* address, char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* request);
+
+/* Return type for getJSONValueWrapper */
+struct getJSONValueWrapper_return {
+	char* r0;
+	char* r1;
+};
+extern struct getJSONValueWrapper_return getJSONValueWrapper(char* jsonS, char* path);
+extern char* checkStatusCodeWrapper(char* response, char* expectedStatus);
+extern char* deployDockerDashboardWrapper(char* networkName);
+extern char* deployK8sDashboardWrapper(char* networkName);
+extern struct response_wrapper checkSchemaWrapper(char* requestBody, char* sampleSchema);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);
 extern char* newRestEndpointWrapper(char* name, char* openApiTag, GoInt port, char* inputFile, char* restPath);
 extern char* getEndpointWrapper(char* service, GoInt port, char* restPath);

package/lib/dev-windows-amd64.h

@@ -40,6 +40,11 @@ struct worker_info {
     char *error;
 };
 
+struct response_wrapper {
+    char *response;
+    char *error;
+};
+
 #line 1 "cgo-generated-wrapper"
 
 #line 7 "endpoint.go"
@@ -127,6 +132,18 @@ extern __declspec(dllexport) char* generateUserTokenWrapper(char* provider, char
 extern __declspec(dllexport) struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern __declspec(dllexport) char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern __declspec(dllexport) char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
+extern __declspec(dllexport) struct response_wrapper sendRequestWrapper(char* address, char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* request);
+
+/* Return type for getJSONValueWrapper */
+struct getJSONValueWrapper_return {
+	char* r0;
+	char* r1;
+};
+extern __declspec(dllexport) struct getJSONValueWrapper_return getJSONValueWrapper(char* jsonS, char* path);
+extern __declspec(dllexport) char* checkStatusCodeWrapper(char* response, char* expectedStatus);
+extern __declspec(dllexport) char* deployDockerDashboardWrapper(char* networkName);
+extern __declspec(dllexport) char* deployK8sDashboardWrapper(char* networkName);
+extern __declspec(dllexport) struct response_wrapper checkSchemaWrapper(char* requestBody, char* sampleSchema);
 extern __declspec(dllexport) char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);
 extern __declspec(dllexport) char* newRestEndpointWrapper(char* name, char* openApiTag, GoInt port, char* inputFile, char* restPath);
 extern __declspec(dllexport) char* getEndpointWrapper(char* service, GoInt port, char* restPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/skyramp",
-  "version": "0.4.106",
+  "version": "0.5.1",
   "description": "module for leveraging skyramp cli functionality",
   "scripts": {
     "lint": "eslint 'src/**/*.js' 'src/**/*.ts' --fix",

package/src/classes/RequestV2.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Represents a REST request.
+ */
+interface RequestV2Options {
+  url: string;
+  path: string;
+  method: string;
+  body?: string;
+  headers?: {[headerName: string]: string};
+  cookies?: {[cookieName: string]: string};
+  dataOverride?: {[dataName: string]: string | number | boolean | object};
+  pathParams?: {[pathName: string]: string | number | boolean | object};
+  queryParams?: {[queryName: string]: string | number | boolean | object};
+  formParams?: {[formParamName: string]: string | number | boolean | object};
+  expectedCode?: string;
+  funcHandler?: string;
+  funcHandlerType?: string;
+}
+export declare class RequestV2 {
+  /**
+   * Creates a new instance of RequestV2.
+   * @param options - The options for creating the request.
+   */
+  constructor(options: RequestV2Options);
+  toYaml(): string;
+}

package/src/classes/RequestV2.js

@@ -0,0 +1,109 @@
+const yaml = require('js-yaml');
+
+/**
+ * Represents a REST request.
+ */
+class RequestV2 {
+  /**
+   * Creates a new instance of RequestV2.
+   * @param {Object} [options={}] - The options for creating the request.
+   * @param {string} [options.url=''] - The URL of the request.
+   * @param {string} [options.path=''] - The REST path of the request.
+   * @param {string} [options.method=''] - The HTTP method of the request.
+   * @param {string} [options.body=''] - The request body in JSON format.
+   * @param {Object.<string, string>} [options.headers={}] - The HTTP headers of the request.
+   * @param {Object.<string, string>} [options.cookies={}] - The HTTP cookies of the request.
+   * @param {Object.<string, *>} [options.dataOverride={}] - The data override for the request.
+   * @param {Object.<string, *>} [options.pathParams={}] - The path parameters for the request.
+   * @param {Object.<string, *>} [options.queryParams={}] - The query parameters for the request.
+   * @param {Object.<string, *>} [options.formParams={}] - The form parameters of the request.
+   * @param {string} [options.expectedCode=''] - The expected HTTP status code of the response.
+   * @param {string} [options.funcHandler=''] - The dynamic handler function for the request.
+   * @param {string} [options.funcHandlerType=''] - The type of the dynamic handler (e.g., 'python', 'javascript').
+   */
+  constructor(options = {}) {
+    this.url = options.url || '';
+    this.path = options.path || '';
+    this.method = options.method || '';
+    this.body = options.body || '';
+    this.headers = options.headers || {};
+    this.cookies = options.cookies || {};
+    this.dataOverride = options.dataOverride || {};
+    this.pathParams = options.pathParams || {};
+    this.queryParams = options.queryParams || {};
+    this.formParams = options.formParams || {};
+    this.expectedCode = options.expectedCode || '';
+    this.funcHandler = options.funcHandler || '';
+    this.funcHandlerType = options.funcHandlerType || '';
+  }
+
+  toYaml() {
+    // Map of camelCase to snake_case field names
+    const fieldMappings = {
+      url: 'url',
+      path: 'path',
+      method: 'method',
+      body: 'body',
+      headers: 'headers',
+      cookies: 'cookies',
+      dataOverride: 'data_override',
+      pathParams: 'path_params',
+      queryParams: 'query_params',
+      formParams: 'form_params',
+      expectedCode: 'expected_code',
+      funcHandler: 'func_handler',
+      funcHandlerType: 'func_handler_type'
+    };
+
+    const { body, ...rest } = this;
+    // Create object with non-empty values and convert to snake_case
+    const yamlObject = Object.entries(rest).reduce((acc, [key, value]) => {
+      // Include field only if it's not empty (empty string, empty object, or empty array)
+      if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+        // Use snake_case key if mapping exists, otherwise use original key
+        const snakeKey = fieldMappings[key] || key;
+        acc[snakeKey] = value;
+      }
+      return acc;
+    }, {});
+
+    // Add body if it exists
+    if (body) {
+      yamlObject.body = JSON.stringify(body, null, 2);
+    }
+
+    return yaml.dump(yamlObject);
+  }
+
+  toJson() {
+    // Use the same field mappings as toYaml for consistency
+    const fieldMappings = {
+      url: 'url',
+      path: 'path',
+      method: 'method',
+      body: 'body',
+      headers: 'headers',
+      cookies: 'cookies',
+      dataOverride: 'data_override',
+      pathParams: 'path_params',
+      queryParams: 'query_params',
+      formParams: 'form_params',
+      expectedCode: 'expected_code',
+      funcHandler: 'func_handler',
+      funcHandlerType: 'func_handler_type'
+    };
+
+    const { ...rest } = this;
+    // Create object with non-empty values and convert to snake_case
+    const jsonObject = Object.entries(rest).reduce((acc, [key, value]) => {
+      if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+        const snakeKey = fieldMappings[key] || key;
+        acc[snakeKey] = value;
+      }
+      return acc;
+    }, {});
+    return JSON.stringify(jsonObject, null, 2);
+  }
+}
+
+module.exports = RequestV2;

package/src/classes/ResponseV2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents a REST response.
+ */
+interface ResponseV2Options {
+    path?: string;
+    method?: string;
+    statusCode?: string;
+    responseHeaders?:  {[headerName: string]: string};
+    responseBody?: string;
+    requestHeaders?:  {[headerName: string]: string};
+    requestBody?: string;
+    duration?: string;
+}
+
+export declare class ResponseV2 {
+    /**
+     * Creates a new instance of ResponseV2.
+     * @param options - The options for creating the response.
+     */
+    constructor(options?: ResponseV2Options);
+    toYaml(): string;
+}

package/src/classes/ResponseV2.js

@@ -0,0 +1,90 @@
+const yaml = require('js-yaml');
+/**
+ * Represents a REST response.
+ */
+class ResponseV2 {
+
+    /**
+     * Creates a new ResponseV2 instance
+     * @param {Object} options - The options for creating the response
+     * @param {string} [options.path=''] - The request path
+     * @param {string} [options.method=''] - The HTTP method used
+     * @param {string} [options.status_code=''] - The HTTP status code of the response
+     * @param {Object} [options.response_headers={}] - Headers included in the response
+     * @param {string} [options.response_body=''] - Body of the response
+     * @param {Object} [options.request_headers={}] - Headers included in the request
+     * @param {string} [options.request_body=''] - Body of the request
+     * @param {string} [options.duration=''] - Duration of the request/response cycle
+     */
+    constructor(options = {}) {
+        this.path = options.path || '';
+        this.method = options.method || '';
+        this.statusCode = options.status_code || '';
+        this.responseHeaders = options.response_headers || {};
+        this.responseBody = options.response_body || '';
+        this.requestHeaders = options.request_headers || {};
+        this.requestBody = options.request_body || '';
+        this.duration = options.duration || '';
+    }
+
+    toYaml() {
+        // Map of camelCase to snake_case field names
+        const fieldMappings = {
+          path: 'path',
+          method: 'method',
+          statusCode: 'status_code',
+          responseHeaders: 'response_headers',
+          responseBody: 'response_body',
+          requestHeaders: 'request_headers',
+          requestBody: 'request_body',
+          duration: 'duration'
+        };
+
+        const { body, ...rest } = this;
+        // Create object with non-empty values and convert to snake_case
+        const yamlObject = Object.entries(rest).reduce((acc, [key, value]) => {
+          // Include field only if it's not empty (empty string, empty object, or empty array)
+          if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+            // Use snake_case key if mapping exists, otherwise use original key
+            const snakeKey = fieldMappings[key] || key;
+            acc[snakeKey] = value;
+          }
+          return acc;
+        }, {});
+
+        // Add body if it exists
+        if (body) {
+          yamlObject.body = JSON.stringify(body, null, 2);
+        }
+
+        return yaml.dump(yamlObject);
+    }
+
+    toJson() {
+      // Use the same field mappings as toYaml for consistency
+      const fieldMappings = {
+        path: 'path',
+        method: 'method',
+        statusCode: 'status_code',
+        responseHeaders: 'response_headers',
+        responseBody: 'response_body',
+        requestHeaders: 'request_headers',
+        requestBody: 'request_body',
+        duration: 'duration'
+      };
+
+      const { ...rest } = this;
+      // Create object with non-empty values and convert to snake_case
+      const jsonObject = Object.entries(rest).reduce((acc, [key, value]) => {
+        if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+          const snakeKey = fieldMappings[key] || key;
+          acc[snakeKey] = value;
+        }
+        return acc;
+      }, {});
+      return JSON.stringify(jsonObject, null, 2);
+    }
+}
+
+
+module.exports = ResponseV2;

package/src/classes/SkyrampClient.d.ts

@@ -2,7 +2,7 @@ import { ResponseValue } from '..';
 import { Endpoint } from './Endpoint';
 import { Scenario } from './Scenario';
 import {TrafficConfig} from './TrafficConfig';
-
+import {oauthResponseType} from './SkyrampClient';
 interface testerStartV1Options {
   namespace?: string;
   kubePath?: string;
@@ -25,8 +25,35 @@ interface MockerApplyV1Options {
   response: ResponseValue | ResponseValue[];
   trafficConfig: TrafficConfig;
 }
+interface SendRequestV2Options {
+  url: string;
+  path: string;
+  method: string;
+  body?: string;
+  headers?: {[headerName: string]: string};
+  cookies?: {[cookieName: string]: string};
+  dataOverride?: {[dataName: string]: string | number | boolean | object};
+  pathParams?: {[pathName: string]: string | number | boolean | object};
+  queryParams?: {[queryName: string]: string | number | boolean | object};
+  formParams?: {[formParamName: string]: string | number | boolean | object};
+  expectedCode?: string;
+  funcHandler?: string;
+  funcHandlerType?: string;
+}
+
+interface SkyrampClientOptions {
+  docker_network?: string;
+  docker_skyramp_port?: number;
+  kubeconfigPath?: string;
+  clusterName?: string;
+  context?: string;
+  userToken?: string;
+  address?: string;
+}
+
 export declare class SkyrampClient {
   constructor(kubeconfigPath?: string, clusterName?: string, context?: string, userToken?: string);
+  constructor(options: SkyrampClientOptions);
   applyLocal(): Promise<void>;
   addKubeconfig(context: string, clusterName: string, kubeconfigPath: string): Promise<void>;
   removeLocal(): Promise<void>;
@@ -58,4 +85,5 @@ export declare class SkyrampClient {
   getOAuthURL(provider: string, port: number): string;
   runOAuthLoopback(provider: string, port: number): Promise<oauthResponseType>;
   registerUser(provider: string, email: string, oauthToken: string): Promise<string>;
+  sendRequest(options: SendRequestV2Options): Promise<void>;
 }

package/src/classes/SkyrampClient.js

@@ -1,7 +1,8 @@
 const lib = require('../lib');
 const koffi = require('koffi');
 const TrafficConfig = require('./TrafficConfig');
-
+const RequestV2 = require('./RequestV2');
+const ResponseV2 = require('./ResponseV2');
 const oauthResponseType = koffi.struct({
   emails: koffi.array('char*', 10),
   num_emails: 'int',
@@ -26,6 +27,11 @@ const testerInfoType = koffi.struct({
   error: 'char*',
 });
 
+const contractResponseType = koffi.struct({
+  response: 'char*',
+  error: 'char*',
+});
+
 const WORKER_URL = "public.ecr.aws/j1n2c2p2/rampup/worker";
 const WORKER_TAG = "latest";
 const CONTAINER_PORT = 35142;
@@ -59,6 +65,9 @@ const registerUserWrapper = lib.func('registerUserWrapper', 'string', ['string',
 const getOAuthURL = lib.func('getOAuthURLWrapper', 'string', ['string', 'int']);
 const runOAuthLoopback = lib.func('runOAuthLoopback', oauthResponseType, ['string', 'int']);
 
+// contract test
+// func sendRequestWrapper(address, namespace, kubePath, kubeContext, clusterName, request *C.char) *C.char {
+const sendRequestWrapper = lib.func('sendRequestWrapper', contractResponseType, ['string', 'string', 'string', 'string', 'string', 'string']);
 /**
  * The `SkyrampClient` class is the main client that provides methods for interacting with the Skyramp service.
  * It allows users to manage Kubernetes clusters, deploy and delete workers and targets, apply mock descriptions, and start tests.
@@ -70,18 +79,36 @@ class SkyrampClient {
   /**
    * Initializes a new instance of the SkyrampClient class.
    * @constructor
-   * @param {string} kubeconfigPath - The path to the kubeconfig file.
-   * @param {string} clusterName - The name of the cluster.
-   * @param {string} context - The context of the cluster.
-   * @param {string} userToken - The user token for authentication.
+   * @param {string|Object} kubeconfigPathOrOptions - Either the path to kubeconfig file or an options object
+   * @param {string} [kubeconfigPathOrOptions.kubeconfigPath] - The path to the kubeconfig file
+   * @param {string} [kubeconfigPathOrOptions.clusterName] - The name of the cluster
+   * @param {string} [kubeconfigPathOrOptions.context] - The context of the cluster
+   * @param {string} [kubeconfigPathOrOptions.userToken] - The user token for authentication
+   * @param {string} [kubeconfigPathOrOptions.address] - The address of the service
+   * @param {string} [clusterName] - The name of the cluster (when using individual parameters)
+   * @param {string} [context] - The context of the cluster (when using individual parameters)
+   * @param {string} [userToken] - The user token for authentication (when using individual parameters)
    */
-  constructor(kubeconfigPath, clusterName, context, userToken) {
-    if (kubeconfigPath || clusterName || context) {
-      this.addKubeconfig(clusterName, context, kubeconfigPath);
+  constructor(kubeconfigPathOrOptions, clusterName, context, userToken) {
+    if (typeof kubeconfigPathOrOptions === 'object') {
+      const options = kubeconfigPathOrOptions;
+      if (options.kubeconfigPath || options.clusterName || options.context) {
+        this.addKubeconfig(options.clusterName, options.context, options.kubeconfigPath);
+      }
+      this.workerNamespaces = [];
+      this.userToken = options.userToken;
+      this.address = options.address;
+      if (options.docker_skyramp_port) {
+        this.address = `localhost:${options.docker_skyramp_port}`;
+      }
+    } else {
+      if (kubeconfigPathOrOptions || clusterName || context) {
+        this.addKubeconfig(clusterName, context, kubeconfigPathOrOptions);
     }
     this.workerNamespaces = [];
     this.userToken = userToken;
   }
+  }
 
   setUserToken(userToken) {
     this.userToken = userToken;
@@ -168,7 +195,7 @@ class SkyrampClient {
 
   /**
    * Applies local changes to the Kubernetes cluster configuration.
-   * 
+   *
    * @returns {Promise} A promise that resolves when the local changes are successfully applied, or rejects with an error if any error occurs.
    */
   async applyLocal() {
@@ -192,7 +219,7 @@ class SkyrampClient {
 
   /**
    * Adds a Kubernetes configuration to the SkyrampClient object.
-   * 
+   *
    * @param {string} context - The context of the Kubernetes configuration.
    * @param {string} clusterName - The name of the Kubernetes cluster.
    * @param {string} kubeConfigPath - The path to the kubeconfig file.
@@ -215,7 +242,7 @@ class SkyrampClient {
 
   /**
    * Removes the local configuration of the SkyrampClient.
-   * 
+   *
    * @returns {Promise<void>} A promise that resolves when the removal is successful, or rejects with an error if an error occurs during the removal process.
    */
   async removeLocal() {
@@ -234,7 +261,7 @@ class SkyrampClient {
 
   /**
    * Asynchronously removes a cluster from the configuration.
-   * 
+   *
    * @param {string} clusterName - The name of the cluster to be removed from the configuration.
    * @returns {Promise} A Promise that resolves if the cluster is successfully removed, or rejects with an error if the removal fails.
    */
@@ -278,7 +305,7 @@ class SkyrampClient {
 
   /**
    * Deletes a worker from a specified namespace in the SkyrampClient class.
-   * 
+   *
    * @param {string} namespace - The namespace from which the worker should be deleted.
    * @returns {Promise} - A promise that resolves with no value upon successful deletion.
    * @throws {Error} - If there is no cluster to delete the worker from or if there is no worker to delete from the specified namespace.
@@ -307,7 +334,7 @@ class SkyrampClient {
 
   /**
    * Asynchronous method that runs a Docker worker using the provided image, tag, port, and network name.
-   * 
+   *
    * @param {string} [workerImage=WORKER_URL] - The URL of the Docker worker image.
    * @param {string} [workerTag=WORKER_TAG] - The tag of the Docker worker image.
    * @param {number} [hostPort=CONTAINER_PORT] - The port on the host machine to expose for the Docker worker.
@@ -330,7 +357,7 @@ class SkyrampClient {
 
   /**
    * Asynchronous method that removes a Docker container running the Skyramp worker.
-   * 
+   *
    * @param {string} containerName - The name of the Docker container to be removed.
    * @returns {Promise} A promise that resolves when the container is successfully removed.
    * @throws {Error} If an error occurs during the removal process.
@@ -357,13 +384,13 @@ class SkyrampClient {
 
   /**
    * Applies a mock description to a specified namespace and address.
-   * 
+   *
    * @param {string} namespace - The namespace where the mock description will be applied.
    * @param {string} address - The address to which the mock description will be applied.
    * @param {object} response - The details of the mock response.
    * @param {object} trafficConfig - The traffic configuration parameters.
    * @returns {Promise} A Promise that resolves when the mock description is successfully applied.
-   * 
+   *
    */
   async mockerApplyV1(...args) {
     let namespace, kubeConfig, kubeContext, clusterName, address, response, trafficConfig;
@@ -385,7 +412,7 @@ class SkyrampClient {
     if (trafficConfig instanceof TrafficConfig) {
       mockDescription.mock = { ...mockDescription.mock, ...trafficConfig.toJson() }
     }
-    
+
     const yamlContent = getYamlBytes(mockDescription);
     return this.applyMockDescription(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent);
   }
@@ -419,7 +446,7 @@ class SkyrampClient {
 
   /**
   * Starts a test scenario in a specified namespace.
-  * 
+  *
   * @param {string|object} namespaceOrOptions - The namespace in which to start the test scenario or an options object.
   * @param {string} [address] - The address of the target service to test.
   * @param {object} [scenario] - The scenario object that defines the test steps and assertions.
@@ -427,7 +454,7 @@ class SkyrampClient {
   * @param {object} [globalHeaders] - Optional global headers to be included in the test requests.
   * @param {boolean} [generateTestReport] - Optional flag to generate a test report. Default is false.
   * @param {boolean} [isDockerenv] - Optional flag to indicate if the test is running in a Docker environment. Default is false.
-  * 
+  *
   * @returns {Promise} - A promise that resolves when the test scenario is started.
   */
   async testerStartV1(options = {}) {
@@ -596,6 +623,33 @@ class SkyrampClient {
 
     return mockDescription;
   }
+
+  /**
+   * Sends a request to a Skyramp worker using the V2 API
+   * @param {Object} options - The options for sending the request
+   * @param {string} [options.address=""] - The address of the worker to send the request to
+   * @param {string} [options.namespace=""] - The namespace where the worker is deployed
+   * @param {string} [options.kubePath=""] - The path to the kubeconfig file
+   * @param {string} [options.kubeContext=""] - The kubernetes context to use
+   * @param {string} [options.clusterName=""] - The name of the kubernetes cluster
+   * @returns {Promise<string>} A promise that resolves with the response from the worker
+   */
+  async sendRequest(options) {
+    // FIXME: should be sendRequest
+    const req = new RequestV2(options);
+    return new Promise((resolve, reject) => {
+      const jsonRequest = req.toJson();
+      sendRequestWrapper.async(this.address, this.namespace, this.kubePath, this.kubeContext, this.clusterName, jsonRequest, (err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          const jsonResponse = JSON.parse(res.response);
+          const response = new ResponseV2(jsonResponse);
+          resolve(response);
+        }
+      });
+    });
+  }
 }
 
 module.exports = SkyrampClient;

package/src/function.js

@@ -0,0 +1,58 @@
+const ResponseV2 = require('./classes/ResponseV2');
+const lib = require('./lib');
+
+// func checkStatusCodeWrapper(response *C.char, expectedStatus *C.char) (*C.char, *C.char) {
+const checkStatusCodeWrapper = lib.func('checkStatusCodeWrapper', 'string', ['string', 'string']);
+
+
+ /**
+  * Checks if the response's status code matches the expected status code (with support for wildcards).
+  *
+  * The expected status can include 'x' as a wildcard for a single digit.
+  * Examples:
+  *   - "200" matches exactly 200
+  *   - "20x" matches any status code in the range 200 to 209
+  *   - "2xx" matches any status code in the range 200 to 299
+  *
+  * @param {ResponseV2} response - The response object containing a `status_code` attribute.
+  * @param {string} expectedStatus - The expected status code as a string with optional 'x' wildcards.
+  * @returns {boolean} True if the status code matches, false otherwise.
+  * @throws {Error} If the response object lacks a 'status_code' attribute.
+  */
+ function checkStatusCode(response, expectedStatus) {
+    if (!(response instanceof ResponseV2)) {
+      throw new Error('Response must be an instance of ResponseV2');
+    }
+
+    if (!expectedStatus || typeof expectedStatus !== 'string') {
+      throw new Error('Expected status must be a string');
+    }
+
+    try {
+      const responseJson = response.toJson();
+      const result = checkStatusCodeWrapper(responseJson, expectedStatus);
+      const parsed = JSON.parse(result);
+
+      if (!parsed || typeof parsed !== 'object') {
+        throw new Error('Invalid response format from wrapper');
+      }
+
+      if (Object.prototype.hasOwnProperty.call(parsed, 'error')) {
+        throw new Error(parsed.error);
+      }
+
+      if (Object.prototype.hasOwnProperty.call(parsed, 'result')) {
+        return parsed.result;
+      }
+
+      throw new Error('Response missing both result and error fields');
+
+    } catch (err) {
+      console.error(`Error in checkStatusCode: ${err.message}`);
+      throw err; // Re-throw to allow caller to handle errors
+    }
+  }
+
+  module.exports = {
+    checkStatusCode
+  };

package/src/index.d.ts

@@ -8,4 +8,8 @@ export * from './classes/ResponseValue';
 export * from './classes/RestParam';
 export * from './classes/TrafficConfig';
 export * from './classes/DelayConfig';
-export * from './classes/Protocol';
+export * from './classes/Protocol';
+export * from './classes/RequestV2';
+export * from './classes/ResponseV2';
+export * from './utils';
+export * from './function';

package/src/index.js

@@ -10,9 +10,15 @@ const DelayConfig = require('./classes/DelayConfig');
 const Protocol = require('./classes/Protocol');
 const Asserts= require('./classes/Asserts');
 const Step = require('./classes/Step');
+const RequestV2 = require('./classes/RequestV2');
+const ResponseV2 = require('./classes/ResponseV2');
+const { getValue, checkSchema } = require('./utils');
+const { checkStatusCode } = require('./function');
 
 module.exports = {
   SkyrampClient,
+  RequestV2,
+  ResponseV2,
   GrpcEndpoint,
   RestEndpoint,
   Scenario,
@@ -23,5 +29,8 @@ module.exports = {
   DelayConfig,
   Protocol,
   Asserts,
-  Step
+  Step,
+  getValue,
+  checkStatusCode,
+  checkSchema,
 }

package/src/utils.js

@@ -1,11 +1,21 @@
 const fs = require('fs');
+const koffi = require('koffi');
 const path = require('path');
 const yaml = require('js-yaml');
+const lib = require('./lib');
 const SKYRAMP_YAML_VERSION = "v1"
 
+const responseType = koffi.struct({
+  response: 'char*',
+  error: 'char*',
+});
+
+const getJSONValueWrapper = lib.func('getJSONValueWrapper', responseType, ['string', 'string']);
+const checkSchemaWrapper = lib.func('checkSchemaWrapper', responseType, ['string', 'string']);
+
 function getYamlBytes(jsonObject) {
   try {
-    const yamlContent = yaml.dump(jsonObject, {lineWidth: 100});
+    const yamlContent = yaml.dump(jsonObject, { lineWidth: 100 });
     return yamlContent;
   } catch (error) {
     throw new Error('Error converting to YAML bytes:', error);
@@ -25,7 +35,7 @@ function createTestDescriptionFromScenario({ scenario, globalVars }) {
     },
     services: services,
     endpoints: endpoints,
-    scenarios: scenarios, 
+    scenarios: scenarios,
     requests: requests
   };
 
@@ -48,14 +58,112 @@ function readDataFromFile(filename) {
       throw new Error('Unsupported file format. Only .json, .yaml, and .js files are supported.');
     }
     return [jsonData, false];
-  } catch(error) {
+  } catch (error) {
     throw new Error('Error reading or parsing file: ', error);
   }
 }
 
+/**
+ * Extracts and parses a value from a JSON response using a JSON path expression
+ * @param {Object} response - The response object containing a body property with JSON data
+ * @param {string} path - The JSON path expression to extract the value (e.g. "$.data.id")
+ * @returns {*} The extracted value converted to the appropriate JavaScript type:
+ *   - For primitive types (string, number, boolean), returns the converted value
+ *   - For null values, returns null
+ *   - For complex types (arrays, objects) or errors, returns null
+ * @example
+ * const response = {
+ *   body: '{"type": "string", "value": "hello"}'
+ * };
+ * etResponseValue(response, "$.value"); // Returns "hello"
+ */
+function getValue(response, path) {
+  const result = getJSONValueWrapper(response.responseBody, path);
+
+  // 1. If result is null/undefined, return null.
+  if (!result || result.error !== null) {
+    return null;
+  }
+
+  try {
+    // 2. Parse the returned JSON string.
+    const parsed = JSON.parse(result.response);
+
+    // 3. If parsed is an object of the shape { type, value }, handle typed values:
+    //    e.g., { "type": "string", "value": "hello" }
+    if (
+      parsed &&
+      typeof parsed === 'object' &&
+      !Array.isArray(parsed) &&
+      Object.prototype.hasOwnProperty.call(parsed, 'type') &&
+      Object.prototype.hasOwnProperty.call(parsed, 'value')
+    ) {
+      const { type: valueType, value } = parsed;
+
+      // Return null for complex types (arrays and objects)
+      if (['array', 'object', '[]interface {}'].includes(valueType)) {
+        return null;
+      }
+
+      // Convert to the appropriate JavaScript type
+      switch (valueType) {
+        case 'string':
+          return String(value);
+        case "float64", "float32", "int64", "int32", "int16", "int8", "uint64", "uint32", "uint16", "uint8":
+          return value;
+        case 'boolean':
+          return Boolean(value);
+        case 'null':
+          return null;
+        default:
+          // For unrecognized or fallback:
+          return value;
+      }
+    }
+
+    // 4. If the result is not of the form { type, value }, return it directly.
+    return parsed;
+  } catch (err) {
+    // 5. If JSON.parse fails or something else goes wrong, log the error and return null.
+    console.error(`Error processing JSONValue: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Validates the response body against the expected schema.
+ *
+ * @param {Object} response - An object containing a `body` property (JSON string).
+ * @param {Object|string} expectedSchema - The JSON schema (object or JSON string) to validate against.
+ * @returns {boolean} True if validation succeeds, false otherwise.
+ */
+/**
+ * Validates the response body against the expected schema.
+ *
+ * @param {Object} response - The response object containing the body to validate
+ * @param {string} response.body - The response body as a JSON string
+ * @param {Object|string} expectedSchema - The JSON schema to validate against. Can be either:
+ *   - A JSON schema object with type definitions and validation rules
+ *   - A JSON string containing a schema definition
+ * @returns {boolean} True if validation succeeds, false otherwise.
+ */
+function checkSchema(response, expectedSchema) {
+  const result = checkSchemaWrapper(response.responseBody, expectedSchema);
+  if (result.error) {
+    return false;
+  }
+  if (!result.response) {
+    return false;
+  }
+  const parsed = JSON.parse(result.response);
+  return parsed.result;
+}
+
 module.exports = {
   createTestDescriptionFromScenario,
   getYamlBytes,
   readDataFromFile,
+  getValue,
+  checkSchema,
   SKYRAMP_YAML_VERSION
 }