@doist/twist-sdk 0.1.0-alpha.4 → 0.1.0-alpha.5

package/dist/batch-builder.d.ts

@@ -12,12 +12,28 @@ import type { BatchRequestDescriptor, BatchResponseArray } from './types/batch';
  * ```
  */
 export declare class BatchBuilder extends BaseClient {
+    private static readonly CHUNK_SIZE;
     /**
-     * Executes an array of batch request descriptors in a single API call.
+     * Splits an array of requests into chunks of the specified size.
+     */
+    private chunkRequests;
+    /**
+     * Flattens chunked results back into a single array while preserving the original order.
+     */
+    private flattenChunkedResults;
+    /**
+     * Executes a single chunk of batch requests (up to CHUNK_SIZE).
+     * This is the core batch execution logic extracted from the original execute method.
+     */
+    private executeSingleBatch;
+    /**
+     * Executes multiple API requests with automatic chunking and parallel execution.
+     * Transparently handles the 10-request API limitation by splitting large batches
+     * into smaller chunks and executing them concurrently.
      *
      * @param requests - Array of batch request descriptors
-     * @returns Array of BatchResponse objects with processed data
-     * @throws {TwistRequestError} If the batch request fails
+     * @returns Array of BatchResponse objects with processed data in original order
+     * @throws {TwistRequestError} If any batch chunk fails completely
      */
     execute<T extends readonly BatchRequestDescriptor<unknown>[]>(requests: T): Promise<BatchResponseArray<T>>;
 }

package/dist/batch-builder.js

@@ -50,6 +50,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchBuilder = void 0;
 var base_client_1 = require("./clients/base-client");
@@ -73,13 +82,29 @@ var BatchBuilder = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     /**
-     * Executes an array of batch request descriptors in a single API call.
-     *
-     * @param requests - Array of batch request descriptors
-     * @returns Array of BatchResponse objects with processed data
-     * @throws {TwistRequestError} If the batch request fails
+     * Splits an array of requests into chunks of the specified size.
      */
-    BatchBuilder.prototype.execute = function (requests) {
+    BatchBuilder.prototype.chunkRequests = function (requests, chunkSize) {
+        if (requests.length === 0) {
+            return [];
+        }
+        var chunks = [];
+        for (var i = 0; i < requests.length; i += chunkSize) {
+            chunks.push(requests.slice(i, i + chunkSize));
+        }
+        return chunks;
+    };
+    /**
+     * Flattens chunked results back into a single array while preserving the original order.
+     */
+    BatchBuilder.prototype.flattenChunkedResults = function (chunkedResults) {
+        return chunkedResults.flat();
+    };
+    /**
+     * Executes a single chunk of batch requests (up to CHUNK_SIZE).
+     * This is the core batch execution logic extracted from the original execute method.
+     */
+    BatchBuilder.prototype.executeSingleBatch = function (requests) {
         return __awaiter(this, void 0, void 0, function () {
             var batchRequests, allGets, formData, response, errorText, batchApiResponses;
             var _this = this;
@@ -199,6 +224,54 @@ var BatchBuilder = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Executes multiple API requests with automatic chunking and parallel execution.
+     * Transparently handles the 10-request API limitation by splitting large batches
+     * into smaller chunks and executing them concurrently.
+     *
+     * @param requests - Array of batch request descriptors
+     * @returns Array of BatchResponse objects with processed data in original order
+     * @throws {TwistRequestError} If any batch chunk fails completely
+     */
+    BatchBuilder.prototype.execute = function (requests) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunks, chunkPromises, chunkedResults;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requests.length === 0) {
+                            return [2 /*return*/, []];
+                        }
+                        // If requests fit within a single chunk, use the original single-batch execution
+                        if (requests.length <= BatchBuilder.CHUNK_SIZE) {
+                            return [2 /*return*/, this.executeSingleBatch(requests)];
+                        }
+                        chunks = this.chunkRequests(__spreadArray([], requests, true), BatchBuilder.CHUNK_SIZE);
+                        chunkPromises = chunks.map(function (chunk) {
+                            return _this.executeSingleBatch(chunk).catch(function (error) {
+                                // Collect errors but don't fail fast - allow other chunks to complete
+                                console.error('Batch chunk failed:', error);
+                                // Return error responses for all requests in this chunk
+                                return chunk.map(function () { return ({
+                                    code: 500,
+                                    headers: {},
+                                    data: null,
+                                }); });
+                            });
+                        });
+                        return [4 /*yield*/, Promise.all(chunkPromises)
+                            // Flatten results back to original order
+                        ];
+                    case 1:
+                        chunkedResults = _a.sent();
+                        // Flatten results back to original order
+                        return [2 /*return*/, this.flattenChunkedResults(chunkedResults)];
+                }
+            });
+        });
+    };
+    BatchBuilder.CHUNK_SIZE = 10;
     return BatchBuilder;
 }(base_client_1.BaseClient));
 exports.BatchBuilder = BatchBuilder;

package/dist/clients/base-client.d.ts

@@ -1,12 +1,12 @@
 import type { ApiVersion } from '../types/api-version';
-export interface ClientConfig {
+export type ClientConfig = {
     /** API token for authentication */
     apiToken: string;
     /** Optional custom base URL. If not provided, uses the default Twist API URL */
     baseUrl?: string;
     /** Optional API version. Defaults to 'v3' */
     version?: ApiVersion;
-}
+};
 /**
  * Base client class that provides centralized URL management and configuration
  * for all Twist API clients. Fixes the trailing slash bug and eliminates code duplication.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/twist-sdk",
-    "version": "0.1.0-alpha.4",
+    "version": "0.1.0-alpha.5",
     "description": "A TypeScript wrapper for the Twist REST API.",
     "author": "Doist developers",
     "homepage": "https://doist.github.io/twist-sdk-typescript/",