MVP ok

Author: asmyasnikov

.github/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+      
+      - name: Build
+        run: |
+          go build -o sqlc-engine-ydb ./cmd/sqlc-engine-ydb
+      
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: sqlc-engine-ydb
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -0,0 +1,82 @@
+name: Test
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Если sqlc-engine-ydb в отдельном репозитории, checkout только его
+          # Если в монорепозитории, checkout весь репозиторий
+          path: .
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+      
+      - name: Install dependencies
+        run: go mod download
+      
+      - name: Run unit tests
+        run: go test ./internal/...
+      
+      - name: Build plugins
+        run: |
+          go build -o bin/sqlc-engine-ydb ./cmd/sqlc-engine-ydb
+          make build-plugins
+      
+      - name: Check if engine-plugin exists
+        id: check_engine_plugin
+        run: |
+          if [ -d "../engine-plugin" ]; then
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+      
+      - name: Build sqlc from engine-plugin
+        if: steps.check_engine_plugin.outputs.exists == 'true'
+        working-directory: ../engine-plugin
+        run: |
+          go mod download
+          mkdir -p bin
+          go build -o bin/sqlc ./cmd/sqlc
+      
+      - name: Run integration tests
+        if: steps.check_engine_plugin.outputs.exists == 'true'
+        working-directory: tests
+        env:
+          PATH: ${{ github.workspace }}/sqlc-engine-ydb/bin:${{ github.workspace }}/../engine-plugin/bin:${{ env.PATH }}
+        run: go test -v -run TestIntegration
+      
+      - name: Check git diff after code generation
+        if: steps.check_engine_plugin.outputs.exists == 'true'
+        run: |
+          # Настраиваем git для проверки diff
+          git config --global user.email "test@example.com"
+          git config --global user.name "Test User"
+          
+          # Добавляем все файлы в индекс для проверки изменений
+          git add -A
+          
+          # Проверяем, что нет изменений после генерации
+          if ! git diff --exit-code --quiet HEAD; then
+            echo "❌ Generated code differs from expected. Git diff:"
+            git diff HEAD
+            exit 1
+          else
+            echo "✅ Generated code matches expected files"
+          fi
+      
+      - name: Skip integration tests
+        if: steps.check_engine_plugin.outputs.exists == 'false'
+        run: |
+          echo "⚠️  engine-plugin not found, skipping integration tests"
+          echo "Integration tests require engine-plugin to be available in ../engine-plugin"

Makefile

@@ -0,0 +1,98 @@
+# sqlc-ydb: engine plugin + ydb-go-sdk codegen plugin for sqlc (v2 config)
+#
+# Prerequisites:
+#   - Go 1.24+
+#   - protoc + protoc-gen-go (for proto). go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
+#   - go mod download (so SQLC_MOD_DIR is available for proto)
+#   - sqlc with plugin support (for examples), on PATH
+#
+# Overrides:
+#   BINDIR     where to install plugin binaries (default: bin)
+#   SQLC       sqlc binary for examples (default: bin/sqlc if build-sqlc was run, else sqlc)
+#
+# Default: show help. Run 'make build' then 'make build-sqlc' then 'make examples' to generate code.
+# build-sqlc builds sqlc from ../engine-plugin (required for plugin support).
+
+REPO_ROOT := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
+BINDIR    ?= bin
+# Prefer bin/sqlc from build-sqlc when present
+SQLC      ?= $(firstword $(wildcard $(REPO_ROOT)$(BINDIR)/sqlc) sqlc)
+ENGINE_PLUGIN_DIR := $(REPO_ROOT)../engine-plugin
+
+# Use codegen.proto from the sqlc module (via replace => ../engine-plugin or go get).
+SQLC_MOD_DIR := $(shell go list -m -f '{{.Dir}}' github.com/sqlc-dev/sqlc)
+SQLC_PROTOS  := $(SQLC_MOD_DIR)/protos
+PROTO_IN     := $(SQLC_PROTOS)/plugin/codegen.proto
+PROTO_OUT    = $(REPO_ROOT)internal/codegen/pb
+PBOUT        = $(PROTO_OUT)/codegen.pb.go
+ENGINE_BIN   = $(BINDIR)/sqlc-engine-ydb
+CODEGEN_BIN  = $(BINDIR)/sqlc-gen-ydb-go-sdk
+
+.PHONY: all proto build build-engine build-codegen build-sqlc examples clean help
+
+all: help
+
+help:
+	@echo "Targets:"
+	@echo "  proto         - generate codegen.pb.go from sqlc module's protos/plugin/codegen.proto (needs protoc, protoc-gen-go, go mod download)"
+	@echo "  build-engine  - build sqlc-engine-ydb into $(BINDIR)/"
+	@echo "  build-codegen - build sqlc-gen-ydb-go-sdk into $(BINDIR)/ (depends on proto)"
+	@echo "  build         - proto + build both plugins"
+	@echo "  build-sqlc    - build sqlc from ../engine-plugin into $(BINDIR)/sqlc (needed for examples)"
+	@echo "  examples      - run 'sqlc generate' in examples/authors (requires build + build-sqlc or sqlc on PATH)"
+	@echo "  clean         - remove $(BINDIR)/ and generated example output"
+	@echo ""
+	@echo "Overrides: BINDIR=$(BINDIR)  SQLC=$(SQLC)"
+
+# Generate plugin proto Go from the sqlc module's codegen.proto (via go get / replace).
+# Output goes to internal/codegen/pb with package pb.
+proto: $(PBOUT)
+	@echo "ok: $(PBOUT)"
+
+$(PBOUT): $(PROTO_IN)
+	@command -v protoc >/dev/null || (echo "error: protoc not found" >&2; exit 1)
+	@command -v protoc-gen-go >/dev/null || (echo "error: protoc-gen-go not found (run: go install google.golang.org/protobuf/cmd/protoc-gen-go@latest)" >&2; exit 1)
+	@mkdir -p $(PROTO_OUT)
+	cd $(REPO_ROOT) && protoc -I$(SQLC_PROTOS) \
+		--go_out=. --go_opt=module=github.com/sqlc-dev/sqlc-engine-ydb \
+		--go_opt=Mplugin/codegen.proto=github.com/sqlc-dev/sqlc-engine-ydb/internal/codegen/pb \
+		plugin/codegen.proto
+	@if [ ! -f "$(PBOUT)" ]; then \
+		echo "error: expected $(PBOUT) to be created; protoc may use different paths" >&2; \
+		exit 1; \
+	fi
+	@echo "ok: $(PBOUT)"
+
+# Build the YDB engine plugin (parses schema + queries).
+build-engine: $(BINDIR)
+	go build -o $(ENGINE_BIN) ./cmd/sqlc-engine-ydb/
+	@echo "ok: $(ENGINE_BIN)"
+
+# Build the ydb-go-sdk codegen plugin. Requires proto.
+build-codegen: proto $(BINDIR)
+	go build -o $(CODEGEN_BIN) ./cmd/sqlc-gen-ydb-go-sdk/
+	@echo "ok: $(CODEGEN_BIN)"
+
+# Build both plugins.
+build: build-engine build-codegen
+	@echo "Plugins ready in $(BINDIR)/"
+
+# Build sqlc from engine-plugin into BINDIR (so examples use plugin-aware sqlc).
+build-sqlc: $(BINDIR)
+	@if [ ! -d "$(ENGINE_PLUGIN_DIR)" ]; then echo "error: $(ENGINE_PLUGIN_DIR) not found (clone engine-plugin next to sqlc-ydb)" >&2; exit 1; fi
+	cd $(ENGINE_PLUGIN_DIR) && go build -o $(REPO_ROOT)$(BINDIR)/sqlc ./cmd/sqlc/
+	@echo "ok: $(BINDIR)/sqlc"
+
+$(BINDIR):
+	mkdir -p $(BINDIR)
+
+# Run sqlc generate in examples/authors. Uses BINDIR/sqlc if build-sqlc was run, else SQLC from PATH.
+examples: build
+	@which $(SQLC) >/dev/null 2>/dev/null || (echo "error: sqlc not found. Run 'make build-sqlc' or set SQLC to a plugin-aware sqlc binary" >&2; exit 1)
+	cd $(REPO_ROOT)examples/authors && PATH="$(REPO_ROOT)$(BINDIR):$$PATH" $(SQLC) generate
+	@echo "ok: examples/authors/db/ generated"
+
+clean:
+	rm -rf $(REPO_ROOT)$(BINDIR)
+	rm -rf $(REPO_ROOT)examples/authors/db
+	@echo "ok: cleaned"

README.md

@@ -1,2 +1,21 @@
 # sqlc-engine-ydb
-sqlc-engine-ydb is an external engine of SQLC with support YDB
+sqlc-engine-ydb is an external engine of SQLC with support YDB.
+
+## Generating Go code (examples/authors)
+
+The `examples/authors` project uses the v2 config with the **sqlc-engine-ydb** engine plugin and **sqlc-gen-ydb-go-sdk** codegen plugin. To generate Go code:
+
+1. **Build the plugins** (from the sqlc-ydb repo root):
+   ```bash
+   make build
+   ```
+2. **Build sqlc from engine-plugin** (requires [engine-plugin](https://github.com/sqlc-dev/sqlc) cloned next to sqlc-ydb, e.g. in `../engine-plugin`):
+   ```bash
+   make build-sqlc
+   ```
+3. **Run code generation**:
+   ```bash
+   make examples
+   ```
+
+Generated files appear in `examples/authors/db/` (`models.go`, `db.go`, `queries.sql.go`). The Makefile uses `bin/sqlc` from `make build-sqlc` by default when running `make examples`; you can override with `make examples SQLC=/path/to/sqlc`.

cmd/sqlc-engine-ydb/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/sqlc-dev/sqlc/pkg/engine"
+
+	"github.com/sqlc-dev/sqlc-engine-ydb/internal/handler"
+)
+
+func main() {
+	engine.Run(engine.Handler{
+		PluginName:        "ydb",
+		PluginVersion:     "1.0.0",
+		Parse:             handler.Parse,
+	})
+}

cmd/sqlc-gen-ydb-go-sdk/main.go

@@ -0,0 +1,47 @@
+// sqlc-gen-ydb-go-sdk is a process-based codegen plugin for sqlc (v2 config).
+// It reads a binary GenerateRequest from stdin and writes a binary GenerateResponse to stdout.
+// See docs/guides/plugins.md (process plugins).
+package main
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/sqlc-dev/sqlc-engine-ydb/internal/codegen/pb"
+	"github.com/sqlc-dev/sqlc-engine-ydb/internal/codegen/ydb"
+	"google.golang.org/protobuf/proto"
+)
+
+func main() {
+	if err := run(context.Background()); err != nil {
+		fmt.Fprintf(os.Stderr, "sqlc-gen-ydb-go-sdk: %v\n", err)
+		os.Exit(2)
+	}
+}
+
+func run(ctx context.Context) error {
+	reqBlob, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		return err
+	}
+	var req pb.GenerateRequest
+	if err := proto.Unmarshal(reqBlob, &req); err != nil {
+		return fmt.Errorf("unmarshal request: %w", err)
+	}
+	resp, err := ydb.Generate(ctx, &req)
+	if err != nil {
+		return err
+	}
+	respBlob, err := proto.Marshal(resp)
+	if err != nil {
+		return fmt.Errorf("marshal response: %w", err)
+	}
+	w := bufio.NewWriter(os.Stdout)
+	if _, err := w.Write(respBlob); err != nil {
+		return err
+	}
+	return w.Flush()
+}