contracts

Author: omermorad

jest.config.js

@@ -11,7 +11,8 @@ module.exports = {
     '^.+\\.tsx?$': [
       'ts-jest',
       {
-        tsconfig: 'tsconfig.json'
+        tsconfig: 'tsconfig.json',
+        isolatedModules: true  // Speeds up tests & ignores TS errors
       }
     ]
   },

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "@tadata/node-sdk",
+  "name": "@tadata/sdk",
   "version": "0.1.0",
-  "description": "A fluent SDK for working with Tadata's API",
+  "description": "Tadata Node SDK",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -17,15 +17,13 @@
     "LICENSE",
     "README.md"
   ],
-  "sideEffects": false,
   "scripts": {
-    "clean": "rimraf dist",
+    "clean": "npx rimraf dist",
     "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build:types": "tsc -p tsconfig.types.json",
-    "dev": "ts-node src/dev.ts",
-    "test": "jest",
+    "build:cjs": "npx tsc -p tsconfig.cjs.json",
+    "build:esm": "npx tsc -p tsconfig.esm.json",
+    "build:types": "npx tsc -p tsconfig.types.json",
+    "test": "npx jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "lint": "eslint . --ext .ts",
@@ -47,6 +45,8 @@
     "@apidevtools/swagger-parser": "^10.1.0",
     "@ts-rest/core": "^3.30.5",
     "axios": "^1.6.2",
+    "http-status-codes": "^2.3.0",
+    "openapi-typescript": "^7.8.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {

pnpm-lock.yaml

@@ -1,34 +1,39 @@
-import { initClient, ApiFetcherArgs } from '@ts-rest/core';
+import { initClient } from '@ts-rest/core';
 import axios, { AxiosError } from 'axios';
 import { tadataContract } from './tadata-contract';
 import { AuthError, NetworkError, ApiError } from '../errors';
 import { Logger } from '../core/logger';
 
 interface ClientOptions {
-  baseUrl?: string;
-  version?: string;
+  baseUrl: string;
+  version: string;
   timeout?: number;
   logger?: Logger;
+  isDev: boolean;
+}
+
+// Custom type for the fetcher args that includes query
+interface CustomApiFetcherArgs {
+  path: string;
+  method: string;
+  body?: any;
+  headers: Record<string, string>;
+  query?: Record<string, string>;
 }
 
 /**
  * Creates a configured ts-rest client for the Tadata API
  */
-export function createApiClient(apiKey: string, options: ClientOptions = {}) {
-  const {
-    baseUrl = 'https://api.tadata.com',
-    version = 'latest',
-    timeout = 30000,
-    logger,
-  } = options;
+export function createApiClient(apiKey: string, options: ClientOptions) {
+  const { baseUrl, version, timeout = 30000, logger } = options;
 
   // Create axios instance with defaults
   const axiosInstance = axios.create({
     baseURL: baseUrl,
     timeout,
     headers: {
       'Authorization': `Bearer ${apiKey}`,
-      'x-tadata-version': version,
+      'x-api-version': version,
       'Content-Type': 'application/json',
     },
   });
@@ -41,7 +46,12 @@ export function createApiClient(apiKey: string, options: ClientOptions = {}) {
         return config;
       },
       error => {
-        logger.error('Request error:', error);
+        // Format error for cleaner logs
+        const errorInfo = {
+          message: error.message,
+          code: error.code
+        };
+        logger.error('Request error', errorInfo);
         return Promise.reject(error);
       }
     );
@@ -52,7 +62,29 @@ export function createApiClient(apiKey: string, options: ClientOptions = {}) {
         return response;
       },
       error => {
-        logger.error('Response error:', error);
+        // Format error for cleaner logs
+        let errorInfo: Record<string, any> = {
+          message: error.message,
+          code: error.code
+        };
+        
+        if (error.response) {
+          errorInfo.status = error.response.status;
+          
+          // Extract specific error details
+          if (error.response.data && error.response.data.error) {
+            errorInfo.errorCode = error.response.data.error.code;
+            errorInfo.errorMessage = error.response.data.error.message;
+            
+            // Include first validation error if present
+            if (error.response.data.error.errors && 
+                error.response.data.error.errors.length > 0) {
+              errorInfo.validation = error.response.data.error.errors[0];
+            }
+          }
+        }
+        
+        logger.error('Response error', errorInfo);
         return Promise.reject(error);
       }
     );
@@ -63,23 +95,33 @@ export function createApiClient(apiKey: string, options: ClientOptions = {}) {
     baseUrl,
     baseHeaders: {
       'Authorization': `Bearer ${apiKey}`,
-      'x-tadata-version': version,
+      'x-api-version': version,
     },
-/* <<<<<<<<<<<<<<  ✨ Windsurf Command ⭐ >>>>>>>>>>>>>>>> */
+
     /**
      * Adapter for `ts-rest` to perform API requests to the Tadata API.
      *
-     * @param {ApiFetcherArgs<any>} args - Request arguments with path, method, body, and headers.
+     * @param {CustomApiFetcherArgs} args - Request arguments with path, method, body, headers, and query params.
      * @returns {Promise<ApiResponse<any>>} - Response with status, body, and headers.
      * @throws {AuthError} - If authentication fails.
      * @throws {ApiError} - If the API returns an error response.
      * @throws {NetworkError} - If a network error occurs.
      */
-/* <<<<<<<<<<  5f3418b3-bf5f-4f26-b9b9-206215461c08  >>>>>>>>>>> */
-    api: async ({ path, method, body, headers }: ApiFetcherArgs<any>) => {
+    api: async ({ path, method, body, headers, query = {} }: CustomApiFetcherArgs) => {
       try {
+        // Add the apiKey to query parameters for every request
+        // This avoids having to manually add it in each method call
+        const augmentedQuery = {
+          ...query,
+          apiKey,
+        };
+
+        // Create query string
+        const queryString = new URLSearchParams(augmentedQuery).toString();
+        const urlWithQuery = queryString ? `${path}?${queryString}` : path;
+
         const config: any = {
-          url: path,
+          url: urlWithQuery,
           method,
           headers,
         };
@@ -105,7 +147,8 @@ export function createApiClient(apiKey: string, options: ClientOptions = {}) {
           }
 
           const { status, data } = axiosError.response;
-          const errorMessage = typeof data === 'object' && data !== null ? (data as any).message : undefined;
+          const errorMessage =
+            typeof data === 'object' && data !== null ? (data as any).message : undefined;
 
           if (status === 401 || status === 403) {
             throw new AuthError(errorMessage || 'Authentication failed', axiosError);

src/contract/client.ts

@@ -1,2 +1,2 @@
-export { tadataContract, type McpDeploymentResult, type TadataContract } from './tadata-contract';
+export { tadataContract, type TadataContract } from './tadata-contract';
 export { createApiClient } from './client';

src/contract/index.ts

@@ -1,40 +1,14 @@
-
 // Schema definitions
 import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-
-const McpDeploymentSchema = z.object({
-  id: z.string(),
-  url: z.string(),
-  specVersion: z.string(),
-  createdAt: z.string().transform(str => new Date(str)),
-});
+// Import the deploymentsContract from the shared location
+import { deploymentsContract } from '../http/contracts'; // relies on index.js in that dir
 
 const c = initContract();
 
-// API contract
+// Create the contract containing only the REST API endpoints
 export const tadataContract = c.router({
-  // MCP endpoints
-  mcpDeploy: {
-    method: 'POST',
-    path: '/v1/mcp',
-    responses: {
-      201: McpDeploymentSchema,
-      400: z.object({ message: z.string(), details: z.any().optional() }),
-      401: z.object({ message: z.string() }),
-      403: z.object({ message: z.string() }),
-      500: z.object({ message: z.string() }),
-    },
-    body: z.object({
-      spec: z.any(),
-      baseUrl: z.string(),
-      name: z.string().optional(),
-      dev: z.boolean().optional(),
-    }),
-    summary: 'Deploy an MCP server from an OpenAPI specification',
-  },
+  deployments: deploymentsContract,
 });
 
 // Type exports
-export type McpDeploymentResult = z.infer<typeof McpDeploymentSchema>;
 export type TadataContract = typeof tadataContract;

src/contract/tadata-contract.ts

@@ -13,19 +13,19 @@ export interface Logger {
  */
 export class ConsoleLogger implements Logger {
   debug(msg: string, ...meta: unknown[]): void {
-    console.debug(`[debug] ${msg}`, ...meta);
+    console.debug(msg, ...meta);
   }
 
   info(msg: string, ...meta: unknown[]): void {
-    console.info(`[info] ${msg}`, ...meta);
+    console.info(msg, ...meta);
   }
 
   warn(msg: string, ...meta: unknown[]): void {
-    console.warn(`[warn] ${msg}`, ...meta);
+    console.warn(msg, ...meta);
   }
 
   error(msg: string, ...meta: unknown[]): void {
-    console.error(`[error] ${msg}`, ...meta);
+    console.error(msg, ...meta);
   }
 }
 

src/core/logger.ts

@@ -1,5 +1,5 @@
 import { createApiClient } from '../contract';
-import { McpResource } from '../mcp';
+import { McpResource } from '../resources/mcp';
 import { Logger, createDefaultLogger } from './logger';
 
 /**
@@ -28,12 +28,6 @@ export interface TadataOptions {
    * @default ConsoleLogger
    */
   logger?: Logger;
-
-  /**
-   * Custom base URL for the API
-   * @default https://api.tadata.com
-   */
-  baseUrl?: string;
 }
 
 /**
@@ -66,24 +60,22 @@ export class TadataNodeSDK {
   /**
    * MCP resource for deploying and managing Multi-Channel Proxies
    */
-  readonly mcp: McpResource;
-
+  public readonly mcp: McpResource;
   /**
    * Create a new Tadata Node SDK instance
    */
   constructor(options: TadataOptions) {
-    // Initialize dependencies
     const logger = options.logger || createDefaultLogger();
     const isDev = options.dev || false;
+    const baseUrl = isDev ? 'https://api.stage.tadata.com' : 'https://api.tadata.com';
 
-    // Create API client
     const client = createApiClient(options.apiKey, {
-      baseUrl: options.baseUrl,
-      version: options.version,
+      baseUrl,
+      version: options.version || 'latest',
       logger,
+      isDev,
     });
 
-    // Initialize resources
-    this.mcp = new McpResource(client, logger, isDev);
+    this.mcp = new McpResource(client.deployments, logger);
   }
 }

src/core/sdk.ts

@@ -1,3 +1,5 @@
+import { StatusCodes } from 'http-status-codes';
+
 /**
  * All possible error codes returned by the Tadata API
  */
@@ -13,23 +15,25 @@ export type TadataErrorCode =
 
 /**
  * Maps HTTP status codes to Tadata error codes
+ * NOTE: This mapping is currently not being used in the codebase.
+ * Consider removing it if not needed or implementing proper usage.
  */
-export const HTTP_STATUS_TO_ERROR_CODE: Record<number, TadataErrorCode> = {
-  400: 'TADATA/INVALID_SPEC',
-  401: 'TADATA/AUTH',
-  404: 'TADATA/NOT_FOUND',
-  409: 'TADATA/HASH_EXISTS',
-  422: 'TADATA/INVALID_SPEC',
-  429: 'TADATA/RATE_LIMIT',
-  500: 'TADATA/SERVER_ERROR',
-  502: 'TADATA/SERVER_ERROR',
-  503: 'TADATA/SERVER_ERROR',
-  504: 'TADATA/SERVER_ERROR',
-};
+// export const HTTP_STATUS_TO_ERROR_CODE: Record<number, TadataErrorCode> = {
+//   [StatusCodes.BAD_REQUEST]: 'TADATA/INVALID_SPEC',
+//   [StatusCodes.UNAUTHORIZED]: 'TADATA/AUTH',
+//   [StatusCodes.NOT_FOUND]: 'TADATA/NOT_FOUND',
+//   [StatusCodes.CONFLICT]: 'TADATA/HASH_EXISTS',
+//   [StatusCodes.UNPROCESSABLE_ENTITY]: 'TADATA/INVALID_SPEC',
+//   [StatusCodes.TOO_MANY_REQUESTS]: 'TADATA/RATE_LIMIT',
+//   [StatusCodes.INTERNAL_SERVER_ERROR]: 'TADATA/SERVER_ERROR',
+//   [StatusCodes.BAD_GATEWAY]: 'TADATA/SERVER_ERROR',
+//   [StatusCodes.SERVICE_UNAVAILABLE]: 'TADATA/SERVER_ERROR',
+//   [StatusCodes.GATEWAY_TIMEOUT]: 'TADATA/SERVER_ERROR',
+// };
 
 /**
  * Check if an error is retryable based on its status code
  */
 export function isRetryableError(status: number): boolean {
-  return status >= 500 && status < 600;
+  return status >= StatusCodes.INTERNAL_SERVER_ERROR && status < 600;
 }