goreleaser

Author: walterwanderley

.gitignore

@@ -1,5 +1,9 @@
 *.so
+*.dll
+*.dylib
 *.db
 *.db-shm
 *.db-wal
 
+# Added by goreleaser init:
+dist/

.goreleaser.yaml

@@ -0,0 +1,133 @@
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
+
+version: 2
+
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+  - id: httpcache
+    binary: httpcache
+    buildmode: "c-shared"
+    ldflags:
+    - -s -w -X github.com/walterwanderley/sqlite-http-cache/extension.version={{.Version}} -X github.com/walterwanderley/sqlite-http-cache/extension.commit={{.Commit}} -X github.com/walterwanderley/sqlite-http-cache/extension.date={{.Date}}
+    goos:
+      - linux
+    goarch:
+      - amd64
+    env:
+      - CGO_ENABLED=1
+
+  - id: sqlite-http-proxy
+    main: ./cmd/sqlite-http-proxy
+    binary: sqlite-http-proxy
+    goos:
+      - linux
+    goarch:
+      - amd64
+    env:
+      - CGO_ENABLED=1
+
+  - id: sqlite-http-refresh
+    main: ./cmd/sqlite-http-refresh
+    binary: sqlite-http-refresh
+    goos:
+      - linux
+    goarch:
+      - amd64
+    env:
+      - CGO_ENABLED=1
+    
+  - id: libsql-http-proxy
+    main: ./cmd/libsql-http-proxy
+    binary: libsql-http-proxy    
+    goos:
+      - linux    
+    goarch:
+      - amd64
+    env:
+      - CGO_ENABLED=1
+
+archives:
+  - id: httpcache
+    formats: [tar.gz]
+    ids: [httpcache]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{- .Binary }}_
+      {{- 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]
+    files:
+      - none*
+  
+  - id: sqlite-http-proxy
+    formats: [tar.gz]
+    ids: [sqlite-http-proxy]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{- .Binary }}_
+      {{- 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]
+    files:
+      - none*
+
+  - id: sqlite-http-refresh
+    formats: [tar.gz]
+    ids: [sqlite-http-refresh]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{- .Binary }}_
+      {{- 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]
+    files:
+      - none*
+
+  - id: libsql-http-proxy
+    formats: [tar.gz]
+    ids: [libsql-http-proxy]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{- .Binary }}_
+      {{- 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]
+    files:
+      - none*
+
+changelog:
+  disable: true
+
+release:  
+  github:
+    owner: walterwanderley
+    name: sqlite-http-cache
+
+  draft: true

README.md

@@ -13,21 +13,27 @@ go build -ldflags="-s -w" -buildmode=c-shared -o httpcache.so
 sqlite3
 
 # Load the extension
-.load /path/to/httpcache.so
+.load ./httpcache
+
+# Check extension info
+SELECT cache_info();
 
 # Insert URL into the temp.http_request virtual table to trigger the HTTP Request 
 INSERT INTO temp.http_request VALUES('https://swapi.tech/api/films/1');
 
+# Set output mode (optional)
+.mode qbox
+
 # Fetch data from http_response table (created by the extension)
 SELECT JSON_EXTRACT(body, '$.result.properties.title') AS title,
   JSON_EXTRACT(body, '$.result.properties.release_date') AS release_date 
   FROM http_response;
 
-# Use cacheage, cachelifetime or cachexpired function to check cache validity based on RFC9111
-SELECT url, cacheage(header, request_time, response_time) AS age, 
-cachelifetime(header, response_time) AS lifetime, 
-cachexpired(header, request_time, response_time, false) AS expired, 
-cachexpiredttl(header, request_time, response_time, false, 3600) AS expiredTTLFallback 
+# Use cache_age, cache_lifetime or cache_expired function to check cache validity based on RFC9111
+SELECT url, cache_age(header, request_time, response_time) AS age, 
+cache_lifetime(header, response_time) AS lifetime, 
+cache_expired(header, request_time, response_time, false) AS expired, 
+cache_expired_ttl(header, request_time, response_time, false, 3600) AS expiredTTLFallback 
 FROM http_response; 
 ```
 
@@ -105,16 +111,17 @@ sqlite-http-refresh file:example.db?_journal=WAL&_sync=NORMAL&_timeout=5000&_txl
 
 ### Operating System Schedulers
 
-- **Cron (Linux/macOS):** You can set up cron jobs to execute a script at specified intervals (e.g., every minute, hour, or day). This script would then connect to your SQLite database and perform the desired INSERT operations.
+You can set up Cron Jobs (or Task Scheduler) to execute a script at specified intervals (e.g., every minute, hour, or day). This script would then connect to your SQLite database and perform the desired INSERT operations.
 
 Example:
 
 ```sql
-INSERT INTO temp.http_request SELECT url FROM http_response WHERE unixepoch() - unixepoch(response_time) > :ttl 
+INSERT INTO temp.http_request 
+SELECT url FROM http_response 
+WHERE unixepoch() - unixepoch(response_time) > :ttl ;
 ```
 *ttl is Time to Live in seconds*
 
-- **Task Scheduler (Windows):** Similar to cron, Windows Task Scheduler allows you to schedule tasks, including running scripts or programs that interact with SQLite.
 
 ### Programming Language Libraries
 

cmd/libsql-http-proxy/main.go

@@ -54,7 +54,7 @@ func main() {
 	}
 
 	if len(fs.GetArgs()) == 0 {
-		log.Fatalf("Usage: %s <FLAGS> [DatabasePath1] [DatabasePathN\n\nExample:\n\t%s example.db example2.db example3.db\n", os.Args[0], os.Args[0])
+		log.Fatalf("Usage: %s <FLAGS> [DatabaseDirectory] [local:DatabaseFile]\n\nExample:\n\t%s local:example.db /tmp/example2 \n", os.Args[0], os.Args[0])
 	}
 
 	if *verbose {
@@ -81,10 +81,14 @@ func main() {
 	}
 
 	fnRegisterResonseTables := func(sqlDB *sql.DB, dbPath string) {
+		err := sqlDB.Ping()
+		if err != nil {
+			log.Fatalf("failed to validade database connection: %v", err)
+		}
 		if responseTables == nil || len(*responseTables) == 0 {
 			tableList, err = db.ResponseTables(sqlDB)
 			if err != nil {
-				log.Fatalf("discovery response tables: %v", err)
+				log.Fatalf("discovery response tables: %v\n\tSet the response table name with --response-table flag. \n\n\tExample: --response-table=http_response", err)
 			}
 		} else {
 			tableList = *responseTables
@@ -105,13 +109,18 @@ func main() {
 			dbs = append(dbs, sqlDB)
 			continue
 		}
-		dir, err := os.MkdirTemp("", "libsql-*")
-		if err != nil {
-			log.Fatalf("creating database directory: %v", err)
+		if *dbPrimaryURL == "" {
+			log.Fatal("inform --db-primary-url to embbed replication or use local database path. Example: local:app.db")
+		}
+
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			err := os.MkdirAll(dbPath, 0750)
+			if err != nil {
+				log.Fatalf("creating directory %q: %v", dbPath, err)
+			}
 		}
-		defer os.RemoveAll(dir)
 
-		connector, err := libsql.NewEmbeddedReplicaConnector(filepath.Join(dir, dbPath), *dbPrimaryURL, dbOpts...)
+		connector, err := libsql.NewEmbeddedReplicaConnector(filepath.Join(dbPath, strings.TrimSuffix(filepath.Base(dbPath), ".db"))+".db", *dbPrimaryURL, dbOpts...)
 		if err != nil {
 			log.Fatalf("creating database connector: %v", err)
 		}

cmd/sqlite-http-proxy/main.go

@@ -36,7 +36,7 @@ func main() {
 	caCertKey := fs.StringLong("ca-cert-key", "", "Path to CA Certificate Key file (required to HTTPS proxy)")
 	readOnly := fs.BoolLong("ro", "Read Only mode. Do not store new HTTP responses")
 	rfc9111 := fs.BoolLong("rfc9111", "Use RFC9111 spec")
-	shared := fs.BoolLong("shared", "Enable shared cache mode")
+	shared := fs.BoolLong("shared", "Enable shared cache mode for RFC9111")
 	_ = fs.String('c', "config", "", "config file (optional)")
 
 	if err := ff.Parse(fs, os.Args[1:],
@@ -87,6 +87,9 @@ func main() {
 		}
 
 	}
+	if len(dsnList) == 0 {
+		log.Fatal("no database found")
+	}
 
 	for _, dsn := range dsnList {
 		sqlDB, err := sql.Open("sqlite3", dsn)
@@ -95,12 +98,17 @@ func main() {
 		}
 		defer sqlDB.Close()
 
+		err = sqlDB.Ping()
+		if err != nil {
+			log.Fatalf("failed to validade database connection: %v", err)
+		}
+
 		dbs = append(dbs, sqlDB)
 
 		if responseTables == nil || len(*responseTables) == 0 {
 			tableList, err = db.ResponseTables(sqlDB)
 			if err != nil {
-				log.Fatalf("discovery response tables: %v", err)
+				log.Fatalf("discovery response tables: %v\n\tSet the response table name with --response-table flag. \n\n\tExample: --response-table=http_response", err)
 			}
 		} else {
 			tableList = *responseTables

cmd/sqlite-http-refresh/main.go

@@ -48,7 +48,7 @@ func main() {
 	ttl = fs.IntLong("ttl", 30*60, "Time to Live in seconds. Fallback if not use RFC9111")
 	matchURL = fs.StringLong("match-url", "%", "Filter URLs (SQL syntax)")
 	rfc9111 = fs.BoolLong("rfc9111", "Refresh data based on RFC9111")
-	shared = fs.BoolLong("shared", "Enable shared cache mode to RFC9111")
+	shared = fs.BoolLong("shared", "Enable shared cache mode (RFC9111)")
 	// Request/Store config
 	timeout = fs.UintLong("timeout", 30*1000, "Timeout in milliseconds")
 	insecure = fs.BoolLong("insecure", "Disable TLS verification")
@@ -86,6 +86,11 @@ func main() {
 	}
 	defer sqlDB.Close()
 
+	err = sqlDB.Ping()
+	if err != nil {
+		log.Fatalf("failed to validade database connection: %v", err)
+	}
+
 	var tableList []string
 	if len(*responseTables) == 0 {
 		tableList, err = db.ResponseTables(sqlDB)
@@ -104,7 +109,7 @@ func main() {
 		fn = refreshDataRFC9111
 		queryTemplate = fmt.Sprintf(`INSERT INTO temp.%%s_refresh(url) 
 			SELECT url FROM %%s
-			WHERE url LIKE ? AND cachexpiredttl(header, request_time, response_time, %s, ?) = 'true'`, fmt.Sprint(*shared))
+			WHERE url LIKE ? AND cache_expired_ttl(header, request_time, response_time, %s, ?) = 1`, fmt.Sprint(*shared))
 	} else {
 		fn = refreshDataTTL
 		queryTemplate = `INSERT INTO temp.%s_refresh(url) 

extension/age.go

@@ -18,7 +18,10 @@ func (m *Age) Args() int {
 	return 3
 }
 
-func (m *Age) Deterministic() bool { return true }
+func (m *Age) Deterministic() bool {
+	return true
+}
+
 func (m *Age) Apply(ctx *sqlite.Context, values ...sqlite.Value) {
 	var header http.Header
 	if err := json.Unmarshal([]byte(values[0].Text()), &header); err != nil {

extension/entrypoint.go

@@ -12,34 +12,39 @@ import (
 //
 // #include "sqlite3.h"
 //
-// extern int sqlite3_extension_init(sqlite3*, char**, const sqlite3_api_routines*);
+// extern int sqlite3_extension_init(sqlite3*, char**, const sqlite3_api_routines);
 import "C"
 
 func init() {
-	sqlite.RegisterNamed("default", func(api *sqlite.ExtensionApi) (sqlite.ErrorCode, error) {
-		if err := api.CreateModule(config.DefaultVirtualTableName, &CacheModule{}, sqlite.ReadOnly(false)); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		if err := api.CreateFunction("cacheage", &Age{}); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		if err := api.CreateFunction("cachelifetime", &FreshnessLifetime{}); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		if err := api.CreateFunction("cachelifetimeshared", &FreshnessLifetime{
-			shared: true,
-		}); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		if err := api.CreateFunction("cachexpired", &Expired{}); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		if err := api.CreateFunction("cachexpiredttl", &Expired{
-			fallbackTTL: true,
-		}); err != nil {
-			return sqlite.SQLITE_ERROR, err
-		}
-		return sqlite.SQLITE_OK, nil
-	})
+	sqlite.Register(registerFunc)
 	C.sqlite3_auto_extension((*[0]byte)(C.sqlite3_extension_init))
 }
+
+func registerFunc(api *sqlite.ExtensionApi) (sqlite.ErrorCode, error) {
+	if err := api.CreateModule(config.DefaultVirtualTableName, &CacheModule{}, sqlite.ReadOnly(false)); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_info", &Info{}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_age", &Age{}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_lifetime", &FreshnessLifetime{}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_lifetime_shared", &FreshnessLifetime{
+		shared: true,
+	}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_expired", &Expired{}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	if err := api.CreateFunction("cache_expired_ttl", &Expired{
+		fallbackTTL: true,
+	}); err != nil {
+		return sqlite.SQLITE_ERROR, err
+	}
+	return sqlite.SQLITE_OK, nil
+}