feat: maybe go idk

Author: shortcuts

templates/go/search_helpers.mustache

@@ -592,6 +592,101 @@ func (c *APIClient) PartialUpdateObjects(indexName string, objects []map[string]
   return c.ChunkedBatch(indexName, objects, action, partialUpdateObjectsToChunkedBatchOptions(opts)...)
 }
 
+/*
+ChunkedPush Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `push` requests by leveraging the Transformation pipeline setup in the Push connector (https://www.algolia.com/doc/guides/sending-and-managing-data/send-and-update-your-data/connectors/push/).
+
+	@param indexName string - the index name to save objects into.
+	@param objects []map[string]any - List of objects to save.
+	@param action Action - The action to perform on the objects.
+	@param referenceIndexName *string - This is required when targeting an index that does not have a push connector setup (e.g. a tmp index), but you wish to attach another index's transformation to it (e.g. the source index name).
+	@param opts ...ChunkedBatchOption - Optional parameters for the request.
+	@return []ingestion.WatchResponse - List of push responses.
+	@return error - Error if any.
+*/
+func (c *APIClient) ChunkedPush(indexName string, objects []map[string]any, action Action, referenceIndexName *string, opts ...ChunkedBatchOption) ([]ingestion.WatchResponse, error) {
+	if c.ingestionTransporter == nil {
+		return nil, reportError("`region` must be provided at client instantiation before calling this method.")
+	}
+
+	conf := config{
+		headerParams: map[string]string{},
+		waitForTasks: false,
+		batchSize:    1000,
+	}
+
+	for _, opt := range opts {
+		opt.apply(&conf)
+	}
+
+	records := make([]map[string]any, 0, len(objects)%conf.batchSize)
+	responses := make([]ingestion.WatchResponse, 0, len(objects)%conf.batchSize)
+
+	for i, obj := range objects {
+		records = append(records, obj)
+
+		if len(records) == conf.batchSize || i == len(objects)-1 {
+			pushRecords := make([]ingestion.PushTaskRecords, 0, len(records))
+
+			rawRecords, err := json.Marshal(records)
+			if err != nil {
+				return nil, reportError("unable to marshal the given `objects`: %w", err)
+			}
+
+			err = json.Unmarshal(rawRecords, &pushRecords)
+			if err != nil {
+				return nil, reportError("unable to unmarshal the given `objects` to an `[]ingestion.PushTaskRecords` payload: %w", err)
+			}
+
+      request := c.ingestionTransporter.NewApiPushRequest(
+					indexName,
+					ingestion.NewEmptyPushTaskPayload().
+						SetAction(ingestion.Action(action)).
+						SetRecords(pushRecords),
+				)
+
+      if referenceIndexName != nil {
+        request = request.WithReferenceIndexName(*referenceIndexName)
+      }
+
+			resp, err := c.ingestionTransporter.Push(request)
+			if err != nil {
+				return nil, err //nolint: wrapcheck
+			}
+
+			responses = append(responses, *resp)
+			records = make([]map[string]any, 0, len(objects)%conf.batchSize)
+		}
+	}
+
+	if conf.waitForTasks {
+		for _, resp := range responses {
+      _, err := CreateIterable( //nolint:wrapcheck
+				func(*ingestion.Event, error) (*ingestion.Event, error) {
+          if resp.EventID == nil {
+				    return nil, reportError("received unexpected response from the push endpoint, eventID must not be undefined")
+          }
+
+					return c.ingestionTransporter.GetEvent(c.ingestionTransporter.NewApiGetEventRequest(resp.RunID, *resp.EventID))
+				},
+				func(response *ingestion.Event, err error) (bool, error) {
+					var apiErr *APIError
+					if errors.As(err, &apiErr) {
+						return apiErr.Status != 404, nil
+					}
+
+					return true, err
+				},
+				WithTimeout(func(count int) time.Duration { return time.Duration(min(200*count, 5000)) * time.Millisecond }), WithMaxRetries(50),
+			)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return responses, nil
+}
+
 /*
 ChunkedBatch chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests.
 
@@ -747,30 +842,7 @@ Helper: Similar to the `SaveObjects` method but requires a Push connector (https
 	@return error - Error if any.
 */
 func (c *APIClient) SaveObjectsWithTransformation(indexName string, objects []map[string]any, opts ...ChunkedBatchOption) ([]ingestion.WatchResponse, error) {
-  if c.ingestionTransporter == nil {
-		return nil, reportError("`region` must be provided at client instantiation before calling this method.")
-  }
-
-  var records []ingestion.PushTaskRecords
-
-  rawObjects, err := json.Marshal(objects)
-  if err != nil {
-    return nil, reportError("unable to marshal the given `objects`: %w", err)
-  }
-
-  err = json.Unmarshal(rawObjects, &records)
-  if err != nil {
-    return nil, reportError("unable to unmarshal the given `objects` to an `[]ingestion.PushTaskRecords` payload: %w", err)
-  }
-
-  return c.ingestionTransporter.Push( //nolint:wrapcheck
-    c.ingestionTransporter.NewApiPushRequest(
-      indexName,
-      ingestion.NewEmptyPushTaskPayload().
-        SetAction(ingestion.ACTION_ADD_OBJECT).
-        SetRecords(records),
-      ),
-    )
+  return c.ChunkedPush(indexName, objects, ACTION_ADD_OBJECT, nil, opts...)
 }
 
 /*
@@ -783,46 +855,22 @@ Helper: Similar to the `PartialUpdateObjects` method but requires a Push connect
 	@return error - Error if any.
 */
 func (c *APIClient) PartialUpdateObjectsWithTransformation(indexName string, objects []map[string]any, opts ...PartialUpdateObjectsOption) ([]ingestion.WatchResponse, error) {
-  if c.ingestionTransporter == nil {
-		return nil, reportError("`region` must be provided at client instantiation before calling this method.")
+  conf := config{
+    headerParams: map[string]string{},
+    createIfNotExists: true,
   }
 
-
-	conf := config{
-		headerParams:      map[string]string{},
-		createIfNotExists: true,
-	}
-
-	for _, opt := range opts {
-		opt.apply(&conf)
-	}
-
-	var action ingestion.Action
-
-	if conf.createIfNotExists {
-		action = ingestion.ACTION_PARTIAL_UPDATE_OBJECT
-	} else {
-		action = ingestion.ACTION_PARTIAL_UPDATE_OBJECT_NO_CREATE
-	}
-
-  var records []ingestion.PushTaskRecords
-
-  rawObjects, err := json.Marshal(objects)
-  if err != nil {
-    return nil, reportError("unable to marshal the given `objects`: %w", err)
+  for _, opt := range opts {
+    opt.apply(&conf)
   }
 
-  err = json.Unmarshal(rawObjects, &records)
-  if err != nil {
-    return nil, reportError("unable to unmarshal the given `objects` to an `[]ingestion.PushTaskRecords` payload: %w", err)
+  var action Action
+
+  if conf.createIfNotExists {
+    action = ACTION_PARTIAL_UPDATE_OBJECT
+  } else {
+    action = ACTION_PARTIAL_UPDATE_OBJECT_NO_CREATE
   }
 
-  return c.ingestionTransporter.Push( //nolint:wrapcheck
-    c.ingestionTransporter.NewApiPushRequest(
-      indexName,
-      ingestion.NewEmptyPushTaskPayload().
-        SetAction(action).
-        SetRecords(records),
-      ),
-    )
+  return c.ChunkedPush(indexName, objects, action, nil, partialUpdateObjectsToChunkedBatchOptions(opts)...)
 }

templates/javascript/clients/algoliasearch/builds/definition.mustache

@@ -199,10 +199,6 @@ export function algoliasearch(
 
       if (waitForTasks) {
         for (const resp of responses) {
-          if (resp.eventID === undefined || !resp.eventID) {
-            throw new Error('received unexpected response from the push endpoint, eventID must not be undefined');
-          }
-
           await createIterablePromise({
             func: async () => {
               if (resp.eventID === undefined || !resp.eventID) {