refactor: query instead of tx

Author: dujardin09

client/client.go

@@ -98,45 +98,123 @@ func (c *Client) Run(gnoCode string) error {
 }
 
 func (c *Client) RunQuery(realmPath string, expression string) ([]byte, error) {
-	gnoCode := fmt.Sprintf(`package main
+	parts := strings.Split(realmPath, "/")
+	packageAlias := parts[len(parts)-1]
 
-import (
-	"%s"
-)
+	queryExpression := strings.Replace(expression, packageAlias+".", realmPath+".", 1)
+
+	if strings.Contains(expression, ".Repository.Pull(") {
+		return c.QueryFileInChunks(queryExpression)
+	}
 
-func main() {
-	result := %s
-	content := make([]byte, len(result))
-	copy(content, result)
-	println(string(content))
+	return c.QueryDirectInChunks(queryExpression)
 }
-`, realmPath, expression)
 
-	tmpFile := "/tmp/gnit_query.gno"
-	if err := os.WriteFile(tmpFile, []byte(gnoCode), 0644); err != nil {
-		return nil, fmt.Errorf("failed to create temp file: %w", err)
+func (c *Client) QueryFileInChunks(expression string) ([]byte, error) {
+	sizeQuery := strings.Replace(expression, "Repository.Pull(", "Repository.GetFileSize(", 1)
+	sizeOutput, err := c.QueryEval(sizeQuery)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get file size: %w", err)
 	}
-	defer os.Remove(tmpFile)
 
-	cmd := exec.Command("gnokey", "maketx", "run",
-		"-gas-fee", c.config.GasFee,
-		"-gas-wanted", c.config.GasWanted,
-		"-broadcast",
-		"-chainid", c.config.ChainID,
-		"-remote", c.config.Remote,
-		c.config.Account,
-		tmpFile)
+	sizeOutput = strings.TrimPrefix(sizeOutput, "data: ")
+	var size int
+	if _, err := fmt.Sscanf(sizeOutput, "(%d int)", &size); err != nil {
+		return nil, fmt.Errorf("failed to parse file size: %w", err)
+	}
 
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
+	if size < 0 {
+		return nil, fmt.Errorf("file not found")
+	}
+
+	if size == 0 {
+		return []byte{}, nil
+	}
+
+	var content []byte
+	chunkSize := 200
+	for offset := 0; offset < size; offset += chunkSize {
+		chunkQuery := strings.Replace(expression, "Repository.Pull(", "Repository.GetFileChunk(", 1)
+		chunkQuery = strings.Replace(chunkQuery, ")", fmt.Sprintf(", %d, %d)", offset, chunkSize), 1)
+
+		chunkOutput, err := c.QueryEval(chunkQuery)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get chunk at offset %d: %w", offset, err)
+		}
+
+		chunk := extractStringFromQuery(chunkOutput)
+		content = append(content, []byte(chunk)...)
+	}
+
+	return content, nil
+}
+
+func (c *Client) QueryEval(expression string) (string, error) {
+	cmd := exec.Command("gnokey", "query", "vm/qeval",
+		"-data", expression,
+		"-remote", c.config.Remote)
 
 	output, err := cmd.Output()
 	if err != nil {
-		return nil, fmt.Errorf("run query failed: %w", err)
+		return "", fmt.Errorf("query failed: %w", err)
+	}
+
+	return extractDataLine(string(output))
+}
+
+func extractStringFromQuery(output string) string {
+	output = strings.TrimPrefix(output, "data: ")
+
+	startIdx := strings.Index(output, `("`)
+	if startIdx == -1 {
+		return ""
+	}
+	startIdx += 2
+
+	endIdx := strings.LastIndex(output, `" string)`)
+	if endIdx == -1 {
+		return ""
+	}
+
+	content := output[startIdx:endIdx]
+
+	var result strings.Builder
+	for i := 0; i < len(content); i++ {
+		if content[i] == '\\' && i+1 < len(content) {
+			switch content[i+1] {
+			case 'n':
+				result.WriteByte('\n')
+				i++
+			case 't':
+				result.WriteByte('\t')
+				i++
+			case 'r':
+				result.WriteByte('\r')
+				i++
+			case '\\':
+				result.WriteByte('\\')
+				i++
+			case '"':
+				result.WriteByte('"')
+				i++
+			default:
+				result.WriteByte(content[i])
+			}
+		} else {
+			result.WriteByte(content[i])
+		}
+	}
+
+	return result.String()
+}
+
+func (c *Client) QueryDirectInChunks(expression string) ([]byte, error) {
+	output, err := c.QueryEval(expression)
+	if err != nil {
+		return nil, err
 	}
 
-	content := extractTransactionOutput(string(output))
-	return []byte(content), nil
+	return []byte(output), nil
 }
 
 func extractTransactionOutput(output string) string {

client/cmd/gnit/pull.go

@@ -58,28 +58,38 @@ func (p *Pull) ExecuteAll() error {
 	fmt.Println("Pulling all files from repository...")
 
 	packageAlias := config.PackageAlias(p.config.RealmPath)
-	query := fmt.Sprintf("%s.Repository.SerializePullAll()", packageAlias)
 
-	serializedData, err := p.client.RunQuery(p.config.RealmPath, query)
+	listQuery := fmt.Sprintf("%s.Repository.ListFiles()", packageAlias)
+	listData, err := p.client.RunQuery(p.config.RealmPath, listQuery)
 	if err != nil {
 		if p.sourceMode {
 			fmt.Println("Repository not found or empty, trying to pull realm source files...")
 			return p.pullRealmSource()
 		}
-		return fmt.Errorf("failed to pull files: %w", err)
+		return fmt.Errorf("failed to list files: %w", err)
 	}
 
-	if len(serializedData) == 0 {
+	filenames, err := parseFileList(string(listData))
+	if err != nil {
+		return fmt.Errorf("failed to parse file list: %w", err)
+	}
+
+	if len(filenames) == 0 {
 		fmt.Println("No files found in repository")
 		if p.sourceMode {
 			return p.pullRealmSource()
 		}
 		return nil
 	}
 
-	files, err := parseSerializedFiles(string(serializedData))
-	if err != nil {
-		return fmt.Errorf("failed to parse files: %w", err)
+	files := make(map[string][]byte)
+	for _, filename := range filenames {
+		pullQuery := fmt.Sprintf("%s.Repository.Pull(\"%s\")", packageAlias, filename)
+		content, err := p.client.RunQuery(p.config.RealmPath, pullQuery)
+		if err != nil {
+			return fmt.Errorf("failed to pull file %s: %w", filename, err)
+		}
+		files[filename] = content
 	}
 
 	if len(files) == 0 {

realms/src/api.gno

@@ -208,3 +208,45 @@ func escapeString(s string) string {
 	}
 	return result
 }
+
+func (r *Repository) Render(path string) string {
+	if path == "" {
+		files := r.ListFiles()
+		result := "# Repository Files\n\n"
+		for i := 0; i < len(files); i++ {
+			result += "- " + files[i] + "\n"
+		}
+		return result
+	}
+
+	content := r.Pull(path)
+	if content == nil {
+		return "File not found: " + path
+	}
+	return string(content)
+}
+
+func (r *Repository) GetFileChunk(filename string, offset, size int) string {
+	content := r.Pull(filename)
+	if content == nil {
+		return ""
+	}
+
+	end := offset + size
+	if end > len(content) {
+		end = len(content)
+	}
+	if offset >= len(content) {
+		return ""
+	}
+
+	return string(content[offset:end])
+}
+
+func (r *Repository) GetFileSize(filename string) int {
+	content := r.Pull(filename)
+	if content == nil {
+		return -1
+	}
+	return len(content)
+}