V30.0 changes (#213)

* chore: update gen files based on api spec

* fix(conversational-model): update the response to expect a 201 on creation

* fix(synonyms): remove old synonyms from collection interface

* feat(synonyms): add synonym set interfaces

* feat(client): register synonym sets to root client

* chore: remove old synonym api interface

* fix(test): update utils for synonyms to match new api

* test(synonyms): test synonym sets api

* feat(generator): recursively extract sub-types for schemas on api spec

* feat(debug): add debug to client interface

* chore: udpate gen files based on api spec

* feat(analytics): migrate analytics to v30 refactor

* feat(test): add util function to skip v30 tests on older versions

* refactor(test): refactor synonym set tests to nested format

* fix(test): update analytic helper methods to match v30 analytics api

* fix(test): update analytics tests to v30 api

* fix(test): remove synonymsets from expected collections under v30

* chore: lint

* refactor(generator): improve code structure and fix deprecated usage

- replace deprecated strings.title with golang.org/x/text/cases
- extract complex nested logic into separate functions
- reduce cyclomatic complexity by breaking down large functions
- improve code readability and maintainability

* chore: update gen files based on api spec

* refactor(generator): break down main function to fix linter issues

* chore: remove old overrides from v30

* feat(curation): add new curation sets api

* feat: register curation sets to root level of the client object

* feat(test): add db helper methods for new curations and remove old ones

* test(curation): test new curation rules

* fix(test): also check for non prefixed v versions

* ci: upgrade typesense to v30

* chore: update generated client from api spec

* fix: correct http status codes and endpoint validation in convo tests

- add missing http.statuscreated header in conversation models test
- fix endpoint comparison logic for urls with query strings

* chore: lint

* chore: add go-releaser

Author: tharropoulos

.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          distribution: goreleaser
+          version: "~> v2"
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/tests.yml

@@ -11,22 +11,26 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
-    services:
-      typesense:
-        image: typesense/typesense:28.0.rc35
-        ports:
-          - 8108:8108/tcp
-        volumes:
-          - /tmp/typesense-server-data:/data
-        env:
-          TYPESENSE_DATA_DIR: '/data'
-          TYPESENSE_API_KEY: 'test_key'
-          TYPESENSE_ENABLE_CORS: true
-          TYPESENSE_URL: 'http://localhost:8108'
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Start Typesense
+        run: |
+          docker run -d \
+          -p 8108:8108 \
+          --name typesense \
+          -v /tmp/typesense-data:/data \
+          -v /tmp/typesense-analytics-data:/analytics-data \
+          typesense/typesense:30.0.alpha1 \
+          --api-key=test_key \
+          --data-dir=/data \
+          --enable-search-analytics=true \
+          --analytics-dir=/analytics-data \
+          --analytics-flush-interval=60 \
+          --analytics-minute-rate-limit=50 \
+          --enable-cors
+
       - name: Setup Go
         uses: actions/setup-go@v5
         with:

.gitignore

@@ -1 +1 @@
-.idea
+.ideadist/

.goreleaser.yaml

@@ -0,0 +1,48 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
+
+version: 2
+
+builds: []
+
+before:
+  hooks:
+    - go mod tidy
+    - go generate ./...
+
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+
+archives:
+  - formats: [tar.gz]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{ .ProjectName }}_
+      {{- title .Os }}_
+      {{- if eq .Arch "amd64" }}x86_64
+      {{- else if eq .Arch "386" }}i386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}v{{ .Arm }}{{ end }}
+    # use zip for windows archives
+    format_overrides:
+      - goos: windows
+        formats: [zip]
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+      - "^chore:"
+
+release:
+  github:
+    owner: typesense
+    name: typesense-go
+  mode: replace

typesense/analytics_events.go

@@ -7,20 +7,32 @@ import (
 )
 
 type AnalyticsEventsInterface interface {
-	Create(ctx context.Context, eventSchema *api.AnalyticsEventCreateSchema) (*api.AnalyticsEventCreateResponse, error)
+	Create(ctx context.Context, eventSchema *api.AnalyticsEvent) (*api.AnalyticsEventCreateResponse, error)
+	Retrieve(ctx context.Context, params *api.GetAnalyticsEventsParams) (*api.AnalyticsEventsResponse, error)
 }
 
 type analyticsEvents struct {
 	apiClient APIClientInterface
 }
 
-func (a *analyticsEvents) Create(ctx context.Context, eventSchema *api.AnalyticsEventCreateSchema) (*api.AnalyticsEventCreateResponse, error) {
+func (a *analyticsEvents) Create(ctx context.Context, eventSchema *api.AnalyticsEvent) (*api.AnalyticsEventCreateResponse, error) {
 	response, err := a.apiClient.CreateAnalyticsEventWithResponse(ctx, api.CreateAnalyticsEventJSONRequestBody(*eventSchema))
 	if err != nil {
 		return nil, err
 	}
-	if response.JSON201 == nil {
+	if response.JSON200 == nil {
 		return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
 	}
-	return response.JSON201, nil
+	return response.JSON200, nil
+}
+
+func (a *analyticsEvents) Retrieve(ctx context.Context, params *api.GetAnalyticsEventsParams) (*api.AnalyticsEventsResponse, error) {
+	response, err := a.apiClient.GetAnalyticsEventsWithResponse(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	if response.JSON200 == nil {
+		return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
+	}
+	return response.JSON200, nil
 }

typesense/analytics_events_test.go

@@ -11,45 +11,117 @@ import (
 )
 
 func TestAnalyticsEventsCreate(t *testing.T) {
-	expectedData := &api.AnalyticsEventCreateSchema{
-		Name: "products_click_event",
-		Type: "click",
-		Data: map[string]interface{}{
-			"hello": "hi",
+	eventData := &api.AnalyticsEvent{
+		Name:      "test_rule",
+		EventType: "click",
+		Data: struct {
+			AnalyticsTag *string   `json:"analytics_tag,omitempty"`
+			DocId        *string   `json:"doc_id,omitempty"`
+			DocIds       *[]string `json:"doc_ids,omitempty"` //nolint:revive // matches API type
+			Q            *string   `json:"q,omitempty"`
+			UserId       *string   `json:"user_id,omitempty"`
+		}{
+			DocId:  stringPtr("123"),
+			UserId: stringPtr("user_123"),
 		},
 	}
 
+	expectedResponse := &api.AnalyticsEventCreateResponse{
+		Ok: true,
+	}
+
 	server, client := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
 		validateRequestMetadata(t, r, "/analytics/events", http.MethodPost)
 
-		var reqBody api.AnalyticsEventCreateSchema
+		var reqBody api.AnalyticsEvent
 		err := json.NewDecoder(r.Body).Decode(&reqBody)
-
 		assert.NoError(t, err)
-		assert.Equal(t, *expectedData, reqBody)
+		assert.Equal(t, eventData.Name, reqBody.Name)
+		assert.Equal(t, eventData.EventType, reqBody.EventType)
+
+		data := jsonEncode(t, expectedResponse)
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(data)
+	})
+	defer server.Close()
+
+	res, err := client.Analytics().Events().Create(context.Background(), eventData)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedResponse, res)
+}
+
+func TestAnalyticsEventsRetrieve(t *testing.T) {
+	params := &api.GetAnalyticsEventsParams{
+		Name:   "test_rule",
+		UserId: "user_123",
+		N:      10,
+	}
 
-		data := jsonEncode(t, api.AnalyticsEventCreateResponse{
-			Ok: true,
-		})
+	expectedResponse := &api.AnalyticsEventsResponse{
+		Events: []struct {
+			Collection *string   `json:"collection,omitempty"`
+			DocId      *string   `json:"doc_id,omitempty"`
+			DocIds     *[]string `json:"doc_ids,omitempty"` //nolint:revive // matches API type
+			EventType  *string   `json:"event_type,omitempty"`
+			Name       *string   `json:"name,omitempty"`
+			Query      *string   `json:"query,omitempty"`
+			Timestamp  *int64    `json:"timestamp,omitempty"`
+			UserId     *string   `json:"user_id,omitempty"`
+		}{
+			{
+				Name:      stringPtr("test_rule"),
+				EventType: stringPtr("click"),
+				DocId:     stringPtr("123"),
+				UserId:    stringPtr("user_123"),
+			},
+		},
+	}
+
+	server, client := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
+		validateRequestMetadata(t, r, "/analytics/events", http.MethodGet)
+
+		// Check query parameters
+		assert.Equal(t, "test_rule", r.URL.Query().Get("name"))
+		assert.Equal(t, "user_123", r.URL.Query().Get("user_id"))
+		assert.Equal(t, "10", r.URL.Query().Get("n"))
+
+		data := jsonEncode(t, expectedResponse)
 
 		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusCreated)
 		w.Write(data)
 	})
 	defer server.Close()
 
-	res, err := client.Analytics().Events().Create(context.Background(), expectedData)
+	res, err := client.Analytics().Events().Retrieve(context.Background(), params)
 	assert.NoError(t, err)
-	assert.True(t, res.Ok)
+	assert.Equal(t, expectedResponse, res)
 }
 
 func TestAnalyticsEventsCreateOnHttpStatusErrorCodeReturnsError(t *testing.T) {
 	server, client := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
 		validateRequestMetadata(t, r, "/analytics/events", http.MethodPost)
-		w.WriteHeader(http.StatusConflict)
+		w.WriteHeader(http.StatusBadRequest)
+	})
+	defer server.Close()
+
+	_, err := client.Analytics().Events().Create(context.Background(), &api.AnalyticsEvent{})
+	assert.ErrorContains(t, err, "status: 400")
+}
+
+func TestAnalyticsEventsRetrieveOnHttpStatusErrorCodeReturnsError(t *testing.T) {
+	server, client := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
+		validateRequestMetadata(t, r, "/analytics/events", http.MethodGet)
+		w.WriteHeader(http.StatusInternalServerError)
 	})
 	defer server.Close()
 
-	_, err := client.Analytics().Events().Create(context.Background(), &api.AnalyticsEventCreateSchema{})
-	assert.ErrorContains(t, err, "status: 409")
+	_, err := client.Analytics().Events().Retrieve(context.Background(), &api.GetAnalyticsEventsParams{})
+	assert.ErrorContains(t, err, "status: 500")
+}
+
+// Helper function to create string pointers
+func stringPtr(s string) *string {
+	return &s
 }

typesense/analytics_rule.go

@@ -7,16 +7,17 @@ import (
 )
 
 type AnalyticsRuleInterface interface {
-	Delete(ctx context.Context) (*api.AnalyticsRuleDeleteResponse, error)
-	Retrieve(ctx context.Context) (*api.AnalyticsRuleSchema, error)
+	Delete(ctx context.Context) (*api.AnalyticsRule, error)
+	Retrieve(ctx context.Context) (*api.AnalyticsRule, error)
+	Update(ctx context.Context, ruleSchema *api.AnalyticsRuleUpdate) (*api.AnalyticsRule, error)
 }
 
 type analyticsRule struct {
 	apiClient APIClientInterface
 	ruleName  string
 }
 
-func (a *analyticsRule) Delete(ctx context.Context) (*api.AnalyticsRuleDeleteResponse, error) {
+func (a *analyticsRule) Delete(ctx context.Context) (*api.AnalyticsRule, error) {
 	response, err := a.apiClient.DeleteAnalyticsRuleWithResponse(ctx, a.ruleName)
 	if err != nil {
 		return nil, err
@@ -27,7 +28,7 @@ func (a *analyticsRule) Delete(ctx context.Context) (*api.AnalyticsRuleDeleteRes
 	return response.JSON200, nil
 }
 
-func (a *analyticsRule) Retrieve(ctx context.Context) (*api.AnalyticsRuleSchema, error) {
+func (a *analyticsRule) Retrieve(ctx context.Context) (*api.AnalyticsRule, error) {
 	response, err := a.apiClient.RetrieveAnalyticsRuleWithResponse(ctx, a.ruleName)
 	if err != nil {
 		return nil, err
@@ -37,3 +38,14 @@ func (a *analyticsRule) Retrieve(ctx context.Context) (*api.AnalyticsRuleSchema,
 	}
 	return response.JSON200, nil
 }
+
+func (a *analyticsRule) Update(ctx context.Context, ruleSchema *api.AnalyticsRuleUpdate) (*api.AnalyticsRule, error) {
+	response, err := a.apiClient.UpsertAnalyticsRuleWithResponse(ctx, a.ruleName, api.UpsertAnalyticsRuleJSONRequestBody(*ruleSchema))
+	if err != nil {
+		return nil, err
+	}
+	if response.JSON200 == nil {
+		return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
+	}
+	return response.JSON200, nil
+}

typesense/analytics_rule_test.go

@@ -11,11 +11,14 @@ import (
 )
 
 func TestAnalyticsRuleRetrieve(t *testing.T) {
-	expectedData := &api.AnalyticsRuleSchema{
-		Name: "test_rule",
-		Type: "test_type",
-		Params: api.AnalyticsRuleParameters{
-			Limit: pointer.Int(10),
+	expectedData := &api.AnalyticsRule{
+		Name:       "test_rule",
+		Type:       api.AnalyticsRuleTypeCounter,
+		Collection: "test_collection",
+		EventType:  "click",
+		Params: &api.AnalyticsRuleCreateParams{
+			CounterField: pointer.String("popularity"),
+			Weight:       pointer.Int(10),
 		},
 	}
 
@@ -45,7 +48,7 @@ func TestAnalyticsRuleRetrieveOnHttpStatusErrorCodeReturnsError(t *testing.T) {
 }
 
 func TestAnalyticsRuleDelete(t *testing.T) {
-	expectedData := &api.AnalyticsRuleDeleteResponse{
+	expectedData := &api.AnalyticsRule{
 		Name: "test_rule",
 	}
 
@@ -63,7 +66,7 @@ func TestAnalyticsRuleDelete(t *testing.T) {
 	assert.Equal(t, expectedData, res)
 }
 
-func TestAnalyticsRuleUpsertOnHttpStatusErrorCodeReturnsError(t *testing.T) {
+func TestAnalyticsRuleDeleteOnHttpStatusErrorCodeReturnsError(t *testing.T) {
 	server, client := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
 		validateRequestMetadata(t, r, "/analytics/rules/test_rule", http.MethodDelete)
 		w.WriteHeader(http.StatusConflict)