dkelly/go-nkode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: dkelly:DoDImplementation
Branches Tags
dkelly:main dkelly:DoDImplementation dkelly:NKodeCoreRefactor dkelly:Task120924
dkelly:v1.0.1
..
compare: dkelly:v1.0.1
Branches Tags
dkelly:DoDImplementation dkelly:NKodeCoreRefactor dkelly:main dkelly:Task120924
dkelly:v1.0.1

2 Commits
DoDImpleme ... v1.0.1

Author SHA1 Message Date
Donovan
c23adb0150 stuff 2024-12-17 16:38:24 -06:00
Donovan
4f69a3ad45 add instructions 2024-12-09 17:25:27 -06:00
44 changed files with 436 additions and 790 deletions
Expand all files Collapse all files

6
.air.toml
View File

@@ -1,11 +1,11 @@
root = "." root = "."
testdata_dir = "testdata" testdata_dir = "testdata"
tmp_dir = "bin" tmp_dir = "tmp"
[build] [build]
args_bin = [] args_bin = []
bin = "./bin/restapi" bin = "./tmp/main"
cmd = "go build -o ./bin/restapi ./cmd/restapi" cmd = "go build -o ./tmp/main ."
delay = 1000 delay = 1000
exclude_dir = ["assets", "tmp", "vendor", "testdata"] exclude_dir = ["assets", "tmp", "vendor", "testdata"]
exclude_file = [] exclude_file = []

1
.gitignore vendored
View File

@@ -10,4 +10,3 @@ secrets.json
flaticon_svgs flaticon_svgs
flaticon_colored_svgs flaticon_colored_svgs
icons icons
bin

9
Dockerfile
View File

@@ -6,6 +6,7 @@ WORKDIR /app
# volume for nkode.db # volume for nkode.db
VOLUME /app/data/sqlite VOLUME /app/data/sqlite
VOLUME /app/data/icons
# Copy go.mod and go.sum files # Copy go.mod and go.sum files
COPY go.mod go.sum ./ COPY go.mod go.sum ./
@@ -18,7 +19,7 @@ RUN go mod download
COPY . . COPY . .
# Build the application # Build the application
RUN go build -o go-nkode ./cmd/restapi RUN go build -o go-nkode ./cmd
# Stage 2: Runtime # Stage 2: Runtime
FROM debian:bookworm-slim FROM debian:bookworm-slim
@@ -31,7 +32,9 @@ RUN apt-get update && \
#ENV FRONTEND_HOST=https://app.nkode.tech #ENV FRONTEND_HOST=https://app.nkode.tech
#ENV FRONTEND_HOST=http://localhost:8090 #ENV FRONTEND_HOST=http://localhost:8090
ENV SQLITE_DB=/app/data/sqlite/demo.db ENV SVG_DIR=/app/data/icons
ENV DB_PATH=/app/data/sqlite/nkode.db
ENV SQLITE_DB=/app/data/sqlite/nkode.db
# Set the working directory inside the runtime container # Set the working directory inside the runtime container
WORKDIR /app WORKDIR /app
@@ -40,7 +43,7 @@ WORKDIR /app
COPY --from=builder /app/go-nkode . COPY --from=builder /app/go-nkode .
# Expose the port the application will run on # Expose the port the application will run on
EXPOSE 8090 EXPOSE 8080
# Command to run the application # Command to run the application
CMD ["./go-nkode"] CMD ["./go-nkode"]

11
Taskfile.yaml
View File

@@ -4,17 +4,8 @@ vars:
compose_file: "./compose/local-compose.yaml" compose_file: "./compose/local-compose.yaml"
cache_bust: cache_bust:
sh: "date +%s" sh: "date +%s"
test_db: "~/databases/demo.db"
schema_db: "./sqlite/schema.sql"
svg_path: "~/svgs/flaticon_colored_svgs"
session_secret: "c3fca773c8889eb3352745c4fe503df0"
frontend: "http://localhost:8080"
tasks: tasks:
demo_run:
cmds:
- sh -c "SQLITE_DB={{.test_db}} JWT_SECRET={{.session_secret}} FRONTEND_HOST={{.frontend}} air"
build: build:
cmds: cmds:
- docker compose -f {{.compose_file}} build --no-cache - docker compose -f {{.compose_file}} build --no-cache
@@ -29,7 +20,7 @@ tasks:
- docker system prune -f - docker system prune -f
push: push:
cmds: cmds:
- docker buildx build --platform linux/amd64,linux/arm64 -t registry.infra.nkode.tech/go-nkode:dod --push . - docker buildx build --platform linux/amd64,linux/arm64 -t registry.infra.nkode.tech/go-nkode:latest --push .
exec: exec:
cmds: cmds:
- docker exec -it cron-nkode bash - docker exec -it cron-nkode bash

273
cmd/cli/main.go
View File

@@ -1,273 +0,0 @@
package main
import (
"context"
"database/sql"
_ "embed"
"flag"
"fmt"
"go-nkode/internal/entities"
"go-nkode/internal/models"
"go-nkode/internal/repository"
sqlite_queue "go-nkode/internal/sqlc"
"go-nkode/sqlite"
"log"
"os"
"path/filepath"
"strings"
_ "github.com/mattn/go-sqlite3"
)
func main() {
if len(os.Args) < 2 {
log.Fatal("Please provide a command: build-db")
}
switch os.Args[1] {
case "build-db":
BuildDB()
case "create-customer":
CreateCustomer()
case "add-user":
AddUser()
default:
log.Fatalf("Unknown command: %s", os.Args[1])
}
}
func CreateCustomer() {
cliCmd := flag.NewFlagSet("create-customer", flag.ExitOnError)
customerIDStr := cliCmd.String("customer-id", "", "Customer UUID")
dbPath := cliCmd.String("db-path", "", "Path to sqlite database")
if err := cliCmd.Parse(os.Args[2:]); err != nil {
log.Fatalf("Failed to parse flags: %v", err)
}
customerID, err := models.CustomerIDFromString(*customerIDStr)
if err != nil {
log.Fatalf("Failed to parse flags: %v", err)
}
ctx := context.Background()
sqliteDb, err := sqlite_queue.OpenSqliteDb(*dbPath)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb)
queue.Start()
defer queue.Stop()
sqliteRepo := repository.NewSqliteRepository(ctx, queue)
if err != nil {
log.Fatal("error starting sqlite repo: ", err)
}
nkodePolicy := models.NewDefaultNKodePolicy()
customer, err := entities.NewCustomer(nkodePolicy)
customer.ID = customerID
if err != nil {
log.Fatal(err)
}
if err = sqliteRepo.CreateCustomer(*customer); err != nil {
log.Fatal(err)
}
}
func AddUser() {
cliCmd := flag.NewFlagSet("add-user", flag.ExitOnError)
imgPath := cliCmd.String("img-path", "", "Path to directory with image files to add to database. The total must number must equal attrs-per-key X numb-of-keys")
imgType := cliCmd.String("img-type", "webp", "Image types webp, svg, png, jpeg, default webp")
customerIDStr := cliCmd.String("customer-id", "", "Customer ID")
dbPath := cliCmd.String("db-path", "", "Path to the database")
userEmailStr := cliCmd.String("user-email", "", "User email")
attrsPerKey := cliCmd.Int("attrs-per-key", -1, "Attributes per key")
numbOfKeys := cliCmd.Int("numb-of-keys", -1, "Number of keys")
nkodeIcons := cliCmd.String("nkode-icons", "", "common separated file names of the users nKode icons with no space. filename order sets the nkode passcode order")
if err := cliCmd.Parse(os.Args[2:]); err != nil {
log.Fatalf("Failed to parse flags: %v", err)
}
fmt.Println("os args: ", os.Args)
ctx := context.Background()
sqliteDb, err := sqlite_queue.OpenSqliteDb(*dbPath)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb)
queue.Start()
defer queue.Stop()
sqliteRepo := repository.NewSqliteRepository(ctx, queue)
if err != nil {
log.Fatal("error starting sqlite repo: ", err)
}
customer, err := validCustomerID(*customerIDStr, &sqliteRepo)
if err != nil {
log.Println("db path: ", *dbPath)
log.Fatal("invalid customer id: ", err)
}
validateUserEmail(*userEmailStr, customer.ID, &sqliteRepo)
kp := entities.KeypadDimension{
AttrsPerKey: *attrsPerKey,
NumbOfKeys: *numbOfKeys,
}
if *attrsPerKey < entities.KeypadMin.AttrsPerKey || entities.KeypadMax.AttrsPerKey < *attrsPerKey {
log.Fatalf("invalid attributes per key valid range is %d-%d", entities.KeypadMin.AttrsPerKey, entities.KeypadMax.AttrsPerKey)
}
if *numbOfKeys < entities.KeypadMin.NumbOfKeys || entities.KeypadMax.NumbOfKeys < *numbOfKeys {
log.Fatalf("invalid number of keys. valid range is %d-%d", entities.KeypadMin.NumbOfKeys, entities.KeypadMax.NumbOfKeys)
}
if kp.IsDispersable() {
log.Fatal("Keypad can't be dispersable")
}
imgs := getImgs(*imgPath, *imgType)
if len(imgs) != kp.TotalAttrs() {
log.Fatal("svgs in directory not equal to keypad size")
}
imgIDs := make([]int, len(imgs))
for idx, img := range imgs {
id, err := sqliteRepo.AddSVGIcon(img)
if err != nil {
log.Fatal(err)
}
imgIDs[idx] = int(id)
}
iconNames := strings.Split(*nkodeIcons, ",")
passcodeIdxs := getPasscodeSvgIdx(iconNames, *imgPath)
if err = customer.IsValidNKode(kp, passcodeIdxs); err != nil {
log.Fatal("invalid nkode: ", err)
}
userInterface, err := entities.NewUserInterface(&kp, models.SvgIdInterface(imgIDs))
if err != nil {
log.Fatal("error creating user interface: ", err)
}
user, err := entities.NewUser(customer, *userEmailStr, passcodeIdxs, *userInterface, kp)
if err != nil {
log.Fatal("error creating user: ", err)
}
if err = sqliteRepo.WriteNewUser(*user); err != nil {
log.Fatal("error storing user: ", err)
}
}
func getPasscodeSvgIdx(nkodeSvgFileNames []string, svgDir string) []int {
files, err := os.ReadDir(svgDir)
if err != nil {
log.Fatal(err)
}
fileNames := make([]string, 0)
for _, file := range files {
if file.IsDir() || filepath.Ext(file.Name()) != ".svg" {
continue
}
fileNames = append(fileNames, file.Name())
}
passcode := make([]int, 0)
for _, fileName := range nkodeSvgFileNames {
idx := indexOf(fileNames, fileName)
if idx == -1 {
log.Fatal("file does not exist in svg dir: ", fileName)
}
passcode = append(passcode, idx)
}
return passcode
}
func indexOf(slice []string, value string) int {
for i, v := range slice {
if v == value {
return i
}
}
return -1 // not found
}
func getImgs(imgDir, imgType string) []string {
files, err := os.ReadDir(imgDir)
if err != nil {
log.Fatalf("error opening dir: %s with err: %v", imgDir, err)
}
imgs := make([]string, 0)
for _, file := range files {
if file.IsDir() || filepath.Ext(file.Name()) != "."+imgType {
continue
}
filePath := filepath.Join(imgDir, file.Name())
content, err := os.ReadFile(filePath)
if err != nil {
log.Println("Error reading file:", filePath, err)
continue
}
imgs = append(imgs, string(content))
}
return imgs
}
func validCustomerID(id string, repo *repository.SqliteRepository) (entities.Customer, error) {
cID, err := models.CustomerIDFromString(id)
if err != nil {
return entities.Customer{}, err
}
customer, err := repo.GetCustomer(cID)
if err != nil {
return entities.Customer{}, err
}
return *customer, nil
}
func validateUserEmail(email string, customerID models.CustomerID, repo *repository.SqliteRepository) {
userEmail, err := models.ParseEmail(email)
if err != nil {
log.Fatal("user email error: ", err)
}
_, err = repo.GetUser(userEmail, customerID)
if err == nil {
log.Fatal("user already exists")
}
fmt.Println("user email is valid:", userEmail)
}
func BuildDB() {
sqliteSchema, err := sqlite.FS.ReadFile("schema.sql")
if err != nil {
log.Fatal(err)
}
cliCmd := flag.NewFlagSet("build-db", flag.ExitOnError)
dbPath := cliCmd.String("db-path", "", "Path to the database")
imgPath := cliCmd.String("img-path", "", "Path to the directory with images")
imgType := cliCmd.String("img-type", "svg", "Image types webp, svg, png, jpeg, default webp")
if err = cliCmd.Parse(os.Args[2:]); err != nil {
log.Fatalf("Failed to parse flags: %v", err)
}
if err = MakeTables(*dbPath, string(sqliteSchema)); err != nil {
log.Fatal(err)
}
ctx := context.Background()
sqliteDb, err := sqlite_queue.OpenSqliteDb(*dbPath)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb)
queue.Start()
defer queue.Stop()
sqliteRepo := repository.NewSqliteRepository(ctx, queue)
if err != nil {
log.Fatal("error starting sqlite repo: ", err)
}
numbImgs := IconImgToSqlite(&sqliteRepo, *imgPath, *imgType)
log.Printf("Successfully added %d Images in %s to the database at %s\n", numbImgs, *imgPath, *dbPath)
}
func IconImgToSqlite(repo *repository.SqliteRepository, imgDir, imgType string) int {
imgs := getImgs(imgDir, imgType)
for _, img := range imgs {
if _, err := repo.AddSVGIcon(img); err != nil {
log.Fatal(err)
}
}
return len(imgs)
}
func MakeTables(dbPath string, schema string) error {
if _, err := os.Stat(dbPath); os.IsNotExist(err) {
if err = os.MkdirAll(filepath.Dir(dbPath), 0755); err != nil {
return err
}
if _, err = os.Create(dbPath); err != nil {
return err
}
}
db, err := sql.Open("sqlite3", dbPath)
if err != nil {
return err
}
if _, err = db.Exec(schema); err != nil {
return err
}
return db.Close()
}

43
cmd/restapi/main.go → cmd/main.go
View File

@@ -1,17 +1,14 @@
package main package main
import ( import (
"context"
"database/sql"
"fmt" "fmt"
"github.com/google/uuid" "github.com/google/uuid"
httpSwagger "github.com/swaggo/http-swagger" httpSwagger "github.com/swaggo/http-swagger"
_ "go-nkode/docs" _ "go-nkode/docs"
"go-nkode/internal/api" "go-nkode/internal/api"
"go-nkode/internal/db"
"go-nkode/internal/email" "go-nkode/internal/email"
"go-nkode/internal/models" "go-nkode/internal/models"
"go-nkode/internal/repository"
sqliteQueue "go-nkode/internal/sqlc"
"log" "log"
"net/http" "net/http"
"os" "os"
@@ -40,41 +37,27 @@ const (
// @securityDefinitions.apiKey ApiKeyAuth // @securityDefinitions.apiKey ApiKeyAuth
// @in header // @in header
// @name Authorization // @name Authorization
func main() { func main() {
dbPath := os.Getenv("SQLITE_DB") dbPath := os.Getenv("SQLITE_DB")
if dbPath == "" { if dbPath == "" {
log.Fatal("SQLITE_DB=/path/to/nkode.db not set") log.Fatalf("SQLITE_DB=/path/to/nkode.db not set")
} }
sqlitedb, err := db.NewSqliteDB(dbPath)
sqliteDb, err := sql.Open("sqlite3", dbPath)
if err != nil { if err != nil {
log.Fatalf("failed to open database: %v", err) log.Fatalf("%v", err)
} }
defer sqlitedb.Close()
if err := sqliteDb.Ping(); err != nil {
log.Fatalf("failed to connect to database: %v", err)
}
ctx := context.Background()
queue, err := sqliteQueue.NewQueue(ctx, sqliteDb)
if err != nil {
log.Fatal(err)
}
queue.Start()
defer func(queue *sqliteQueue.Queue) {
if err := queue.Stop(); err != nil {
log.Fatal(err)
}
}(queue)
sesClient := email.NewSESClient() sesClient := email.NewSESClient()
emailQueue := email.NewEmailQueue(emailQueueBufferSize, maxEmailsPerSecond, &sesClient) emailQueue := email.NewEmailQueue(emailQueueBufferSize, maxEmailsPerSecond, &sesClient)
emailQueue.Start() emailQueue.Start()
defer emailQueue.Stop() defer emailQueue.Stop()
sqlitedb := repository.NewSqliteRepository(ctx, queue)
nkodeApi := api.NewNKodeAPI(&sqlitedb, emailQueue) nkodeApi := api.NewNKodeAPI(sqlitedb, emailQueue)
AddDefaultCustomer(nkodeApi) AddDefaultCustomer(nkodeApi)
handler := api.NKodeHandler{Api: nkodeApi} handler := api.NKodeHandler{Api: nkodeApi}
mux := http.NewServeMux() mux := http.NewServeMux()
mux.Handle(api.CreateNewCustomer, &handler) mux.Handle(api.CreateNewCustomer, &handler)
mux.Handle(api.GenerateSignupResetInterface, &handler) mux.Handle(api.GenerateSignupResetInterface, &handler)
@@ -86,10 +69,12 @@ func main() {
mux.Handle(api.RandomSvgInterface, &handler) mux.Handle(api.RandomSvgInterface, &handler)
mux.Handle(api.RefreshToken, &handler) mux.Handle(api.RefreshToken, &handler)
mux.Handle(api.ResetNKode, &handler) mux.Handle(api.ResetNKode, &handler)
// Serve Swagger UI // Serve Swagger UI
mux.Handle("/swagger/", httpSwagger.WrapHandler) mux.Handle("/swagger/", httpSwagger.WrapHandler)
fmt.Println("Running on localhost:8090...")
log.Fatal(http.ListenAndServe(":8090", corsMiddleware(mux))) fmt.Println("Running on localhost:8080...")
log.Fatal(http.ListenAndServe(":8080", corsMiddleware(mux)))
} }
func corsMiddleware(next http.Handler) http.Handler { func corsMiddleware(next http.Handler) http.Handler {
@@ -115,7 +100,7 @@ func AddDefaultCustomer(nkodeApi api.NKodeAPI) {
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
customerId := models.CustomerID(newId) customerId := models.CustomerId(newId)
nkodePolicy := models.NewDefaultNKodePolicy() nkodePolicy := models.NewDefaultNKodePolicy()
_, err = nkodeApi.CreateNewCustomer(nkodePolicy, &customerId) _, err = nkodeApi.CreateNewCustomer(nkodePolicy, &customerId)
if err != nil { if err != nil {

0
cmd/restapi/main_test.go → cmd/main_test.go
View File

3
compose/coolify-compose.yaml
View File

@@ -1,9 +1,10 @@
services: services:
go-nkode: go-nkode:
container_name: go-nkode container_name: go-nkode
image: registry.infra.nkode.tech/go-nkode:dod image: registry.infra.nkode.tech/go-nkode
volumes: volumes:
- /var/go-nkode/sqlite:/app/data/sqlite - /var/go-nkode/sqlite:/app/data/sqlite
- /var/go-nkode/icons:/app/data/icons
environment: environment:
- JWT_SECRET=${JWT_SECRET} - JWT_SECRET=${JWT_SECRET}

7
go.mod
View File

@@ -1,6 +1,8 @@
module go-nkode module go-nkode
go 1.23.0 go 1.22.0
toolchain go1.23.0
require ( require (
github.com/aws/aws-sdk-go-v2 v1.31.0 github.com/aws/aws-sdk-go-v2 v1.31.0
@@ -10,7 +12,7 @@ require (
github.com/google/uuid v1.6.0 github.com/google/uuid v1.6.0
github.com/mattn/go-sqlite3 v1.14.22 github.com/mattn/go-sqlite3 v1.14.22
github.com/patrickmn/go-cache v2.1.0+incompatible github.com/patrickmn/go-cache v2.1.0+incompatible
github.com/stretchr/testify v1.10.0 github.com/stretchr/testify v1.9.0
github.com/swaggo/http-swagger v1.3.4 github.com/swaggo/http-swagger v1.3.4
github.com/swaggo/swag v1.16.4 github.com/swaggo/swag v1.16.4
github.com/swaggo/swag/example/celler v0.0.0-20241025062444-99698582709d github.com/swaggo/swag/example/celler v0.0.0-20241025062444-99698582709d
@@ -18,7 +20,6 @@ require (
) )
require ( require (
github.com/DonovanKelly/sugar-n-spice v1.0.1 // indirect
github.com/KyleBanks/depth v1.2.1 // indirect github.com/KyleBanks/depth v1.2.1 // indirect
github.com/aws/aws-sdk-go-v2/credentials v1.17.35 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.17.35 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 // indirect

4
go.sum
View File

@@ -1,5 +1,3 @@
github.com/DonovanKelly/sugar-n-spice v1.0.1 h1:VsybiCHSziAqyPtbYF6GtkiJYYECWMHKN+EyEa6UVpA=
github.com/DonovanKelly/sugar-n-spice v1.0.1/go.mod h1:/HQWoablLFCwsa4gwfzVBu80cI5A3dyO1uCiB11sup0=
github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc= github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE= github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
github.com/aws/aws-sdk-go-v2 v1.31.0 h1:3V05LbxTSItI5kUqNwhJrrrY1BAXxXt0sN0l72QmG5U= github.com/aws/aws-sdk-go-v2 v1.31.0 h1:3V05LbxTSItI5kUqNwhJrrrY1BAXxXt0sN0l72QmG5U=
@@ -118,8 +116,6 @@ github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE= github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE=
github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg= github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg=
github.com/swaggo/http-swagger v1.3.4 h1:q7t/XLx0n15H1Q9/tk3Y9L4n210XzJF5WtnDX64a5ww= github.com/swaggo/http-swagger v1.3.4 h1:q7t/XLx0n15H1Q9/tk3Y9L4n210XzJF5WtnDX64a5ww=

29
instructions/task_120924.md Normal file
View File

@@ -0,0 +1,29 @@
# Task: Get nKode running on you system and document the process for setting up in the Readme.md
Prereq:
1. sign into gitea
2. clone go-nkode
3. install docker
4. install sqlite3
Do this stuff later
- install flutter
- clone flutter-nkode
## Install Swaggo
Install [swaggo](https://github.com/swaggo/swag)
you'll know you're successful when you see this in the cli:
```
➜ go-nkode git:(main) ✗ swag --version
swag version v1.16.4
```
## Setup Sqlite DB
Follow this [video](https://1drv.ms/v/s!Agm1aJyS_E11lPVCt_uoJFEn9HPFrA?e=mvntuY)
Download flaticon zip [here](https://1drv.ms/u/s!Agm1aJyS_E11lPVAI9Af279oZGnC2w?e=WbY1Xd)
Add this to your environment variables in your Goland config for sqlite_init.go
`DB_PATH=/path/to/databases/nkode.db;SVG_DIR=/path/to/flaticon_colored_svgs;TEST_DB_PATH=/path/to/databases/test.db`

19
internal/api/handler.go
View File

@@ -103,10 +103,12 @@ func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter
methodNotAllowed(w) methodNotAllowed(w)
return return
} }
var signupResetPost models.GenerateSignupRestInterfacePost var signupResetPost models.GenerateSignupRestInterfacePost
if err := decodeJson(w, r, &signupResetPost); err != nil { if err := decodeJson(w, r, &signupResetPost); err != nil {
return return
} }
kp := entities.KeypadDimension{ kp := entities.KeypadDimension{
AttrsPerKey: signupResetPost.AttrsPerKey, AttrsPerKey: signupResetPost.AttrsPerKey,
NumbOfKeys: signupResetPost.NumbOfKeys, NumbOfKeys: signupResetPost.NumbOfKeys,
@@ -125,11 +127,12 @@ func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter
badRequest(w, malformedUserEmail) badRequest(w, malformedUserEmail)
return return
} }
resp, err := h.Api.GenerateSignupResetInterface(userEmail, models.CustomerID(customerId), kp, signupResetPost.Reset) resp, err := h.Api.GenerateSignupResetInterface(userEmail, models.CustomerId(customerId), kp, signupResetPost.Reset)
if err != nil { if err != nil {
handleError(w, err) handleError(w, err)
return return
} }
marshalAndWriteBytes(w, resp) marshalAndWriteBytes(w, resp)
} }
@@ -153,7 +156,7 @@ func (h *NKodeHandler) SetNKodeHandler(w http.ResponseWriter, r *http.Request) {
badRequest(w, malformedSessionId) badRequest(w, malformedSessionId)
return return
} }
confirmInterface, err := h.Api.SetNKode(models.CustomerID(customerId), models.SessionId(sessionId), setNKodePost.KeySelection) confirmInterface, err := h.Api.SetNKode(models.CustomerId(customerId), models.SessionId(sessionId), setNKodePost.KeySelection)
if err != nil { if err != nil {
handleError(w, err) handleError(w, err)
return return
@@ -183,7 +186,7 @@ func (h *NKodeHandler) ConfirmNKodeHandler(w http.ResponseWriter, r *http.Reques
badRequest(w, malformedSessionId) badRequest(w, malformedSessionId)
return return
} }
if err = h.Api.ConfirmNKode(models.CustomerID(customerId), models.SessionId(sessionId), confirmNKodePost.KeySelection); err != nil { if err = h.Api.ConfirmNKode(models.CustomerId(customerId), models.SessionId(sessionId), confirmNKodePost.KeySelection); err != nil {
handleError(w, err) handleError(w, err)
return return
} }
@@ -209,7 +212,7 @@ func (h *NKodeHandler) GetLoginInterfaceHandler(w http.ResponseWriter, r *http.R
if err != nil { if err != nil {
badRequest(w, malformedUserEmail) badRequest(w, malformedUserEmail)
} }
loginInterface, err := h.Api.GetLoginInterface(userEmail, models.CustomerID(customerId)) loginInterface, err := h.Api.GetLoginInterface(userEmail, models.CustomerId(customerId))
if err != nil { if err != nil {
handleError(w, err) handleError(w, err)
return return
@@ -238,7 +241,7 @@ func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
badRequest(w, malformedUserEmail) badRequest(w, malformedUserEmail)
return return
} }
jwtTokens, err := h.Api.Login(models.CustomerID(customerId), userEmail, loginPost.KeySelection) jwtTokens, err := h.Api.Login(models.CustomerId(customerId), userEmail, loginPost.KeySelection)
if err != nil { if err != nil {
handleError(w, err) handleError(w, err)
return return
@@ -262,7 +265,7 @@ func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Req
badRequest(w, malformedCustomerId) badRequest(w, malformedCustomerId)
return return
} }
if err = h.Api.RenewAttributes(models.CustomerID(customerId)); err != nil { if err = h.Api.RenewAttributes(models.CustomerId(customerId)); err != nil {
handleError(w, err) handleError(w, err)
return return
} }
@@ -311,7 +314,7 @@ func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Reques
log.Println(err) log.Println(err)
return return
} }
accessToken, err := h.Api.RefreshToken(userEmail, models.CustomerID(customerId), refreshToken) accessToken, err := h.Api.RefreshToken(userEmail, models.CustomerId(customerId), refreshToken)
if err != nil { if err != nil {
handleError(w, err) handleError(w, err)
@@ -343,7 +346,7 @@ func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
return return
} }
if err = h.Api.ResetNKode(userEmail, models.CustomerID(customerId)); err != nil { if err = h.Api.ResetNKode(userEmail, models.CustomerId(customerId)); err != nil {
internalServerError(w) internalServerError(w)
log.Println(err) log.Println(err)
return return

85
internal/api/nkode_api.go
View File

@@ -5,10 +5,10 @@ import (
"github.com/google/uuid" "github.com/google/uuid"
"github.com/patrickmn/go-cache" "github.com/patrickmn/go-cache"
"go-nkode/config" "go-nkode/config"
"go-nkode/internal/db"
"go-nkode/internal/email" "go-nkode/internal/email"
"go-nkode/internal/entities" "go-nkode/internal/entities"
"go-nkode/internal/models" "go-nkode/internal/models"
"go-nkode/internal/repository"
"go-nkode/internal/security" "go-nkode/internal/security"
"log" "log"
"os" "os"
@@ -21,12 +21,12 @@ const (
) )
type NKodeAPI struct { type NKodeAPI struct {
Db repository.CustomerUserRepository Db db.CustomerUserRepository
SignupSessionCache *cache.Cache SignupSessionCache *cache.Cache
EmailQueue *email.Queue EmailQueue *email.Queue
} }
func NewNKodeAPI(db repository.CustomerUserRepository, queue *email.Queue) NKodeAPI { func NewNKodeAPI(db db.CustomerUserRepository, queue *email.Queue) NKodeAPI {
return NKodeAPI{ return NKodeAPI{
Db: db, Db: db,
EmailQueue: queue, EmailQueue: queue,
@@ -34,22 +34,23 @@ func NewNKodeAPI(db repository.CustomerUserRepository, queue *email.Queue) NKode
} }
} }
func (n *NKodeAPI) CreateNewCustomer(nkodePolicy models.NKodePolicy, id *models.CustomerID) (*models.CustomerID, error) { func (n *NKodeAPI) CreateNewCustomer(nkodePolicy models.NKodePolicy, id *models.CustomerId) (*models.CustomerId, error) {
newCustomer, err := entities.NewCustomer(nkodePolicy) newCustomer, err := entities.NewCustomer(nkodePolicy)
if id != nil { if id != nil {
newCustomer.ID = *id newCustomer.Id = *id
} }
if err != nil { if err != nil {
return nil, err return nil, err
} }
err = n.Db.CreateCustomer(*newCustomer) err = n.Db.CreateCustomer(*newCustomer)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &newCustomer.ID, nil return &newCustomer.Id, nil
} }
func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, customerId models.CustomerID, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) { func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, customerId models.CustomerId, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) {
user, err := n.Db.GetUser(userEmail, customerId) user, err := n.Db.GetUser(userEmail, customerId)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -58,23 +59,20 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, cust
log.Printf("user %s already exists", string(userEmail)) log.Printf("user %s already exists", string(userEmail))
return nil, config.ErrUserAlreadyExists return nil, config.ErrUserAlreadyExists
} }
//svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp) svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
//if err != nil { if err != nil {
// return nil, err return nil, err
//}
svgIdxInterface := make(models.SvgIdInterface, 54)
for idx := range 54 {
svgIdxInterface[idx] = idx + 1
} }
signupSession, err := entities.NewSignupResetSession(userEmail, kp, customerId, svgIdxInterface, reset) signupSession, err := entities.NewSignupResetSession(userEmail, kp, customerId, svgIdxInterface, reset)
if err != nil { if err != nil {
return nil, err return nil, err
} }
//n.SignupSessions[signupSession.ID] = *signupSession //n.SignupSessions[signupSession.Id] = *signupSession
if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil { if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
return nil, err return nil, err
} }
svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId) svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -87,41 +85,9 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, cust
return &resp, nil return &resp, nil
} }
func (n *NKodeAPI) GenerateSignupResetInterfaceRigged(userEmail models.UserEmail, customerId models.CustomerID, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) { func (n *NKodeAPI) SetNKode(customerId models.CustomerId, sessionId models.SessionId, keySelection models.KeySelection) (models.IdxInterface, error) {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return nil, err
}
if user != nil && !reset {
log.Printf("user %s already exists", string(userEmail))
return nil, config.ErrUserAlreadyExists
}
svgIdxInterface := make(models.SvgIdInterface, kp.TotalAttrs())
for idx := range kp.TotalAttrs() {
svgIdxInterface[idx] = idx
}
signupSession, err := entities.NewSignupResetSessionRigged(userEmail, kp, customerId, svgIdxInterface, reset)
if err != nil {
return nil, err
}
if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
return nil, err
}
svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
if err != nil {
return nil, err
}
resp := models.GenerateSignupResetInterfaceResp{
UserIdxInterface: signupSession.SetIdxInterface,
SvgInterface: svgInterface,
SessionId: uuid.UUID(signupSession.Id).String(),
Colors: signupSession.Colors,
}
return &resp, nil
}
func (n *NKodeAPI) SetNKode(customerId models.CustomerID, sessionId models.SessionId, keySelection models.KeySelection) (models.IdxInterface, error) {
_, err := n.Db.GetCustomer(customerId) _, err := n.Db.GetCustomer(customerId)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -143,7 +109,7 @@ func (n *NKodeAPI) SetNKode(customerId models.CustomerID, sessionId models.Sessi
return confirmInterface, nil return confirmInterface, nil
} }
func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerID, sessionId models.SessionId, keySelection models.KeySelection) error { func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerId, sessionId models.SessionId, keySelection models.KeySelection) error {
session, exists := n.SignupSessionCache.Get(sessionId.String()) session, exists := n.SignupSessionCache.Get(sessionId.String())
if !exists { if !exists {
log.Printf("session id does not exist %s", sessionId) log.Printf("session id does not exist %s", sessionId)
@@ -178,7 +144,7 @@ func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerID, sessionId models.S
return err return err
} }
func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId models.CustomerID) (*models.GetLoginInterfaceResp, error) { func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId models.CustomerId) (*models.GetLoginInterfaceResp, error) {
user, err := n.Db.GetUser(userEmail, customerId) user, err := n.Db.GetUser(userEmail, customerId)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -201,7 +167,7 @@ func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId mode
return &resp, nil return &resp, nil
} }
func (n *NKodeAPI) Login(customerId models.CustomerID, userEmail models.UserEmail, keySelection models.KeySelection) (*security.AuthenticationTokens, error) { func (n *NKodeAPI) Login(customerId models.CustomerId, userEmail models.UserEmail, keySelection models.KeySelection) (*security.AuthenticationTokens, error) {
customer, err := n.Db.GetCustomer(customerId) customer, err := n.Db.GetCustomer(customerId)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -218,6 +184,7 @@ func (n *NKodeAPI) Login(customerId models.CustomerID, userEmail models.UserEmai
if err != nil { if err != nil {
return nil, err return nil, err
} }
if user.Renew { if user.Renew {
err = n.Db.RefreshUserPasscode(*user, passcode, customer.Attributes) err = n.Db.RefreshUserPasscode(*user, passcode, customer.Attributes)
if err != nil { if err != nil {
@@ -240,15 +207,15 @@ func (n *NKodeAPI) Login(customerId models.CustomerID, userEmail models.UserEmai
return &jwtToken, nil return &jwtToken, nil
} }
func (n *NKodeAPI) RenewAttributes(customerId models.CustomerID) error { func (n *NKodeAPI) RenewAttributes(customerId models.CustomerId) error {
return n.Db.Renew(customerId) return n.Db.Renew(customerId)
} }
func (n *NKodeAPI) RandomSvgInterface() ([]string, error) { func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
return n.Db.RandomSvgInterface(entities.KeypadDefault) return n.Db.RandomSvgInterface(entities.KeypadMax)
} }
func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.CustomerID, refreshToken string) (string, error) { func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.CustomerId, refreshToken string) (string, error) {
user, err := n.Db.GetUser(userEmail, customerId) user, err := n.Db.GetUser(userEmail, customerId)
if err != nil { if err != nil {
return "", err return "", err
@@ -271,14 +238,16 @@ func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.Cu
return security.EncodeAndSignClaims(newAccessClaims) return security.EncodeAndSignClaims(newAccessClaims)
} }
func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.CustomerID) error { func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.CustomerId) error {
user, err := n.Db.GetUser(userEmail, customerId) user, err := n.Db.GetUser(userEmail, customerId)
if err != nil { if err != nil {
return fmt.Errorf("error getting user in rest nkode %v", err) return fmt.Errorf("error getting user in rest nkode %v", err)
} }
if user == nil { if user == nil {
return nil return nil
} }
nkodeResetJwt, err := security.ResetNKodeToken(string(userEmail), uuid.UUID(customerId)) nkodeResetJwt, err := security.ResetNKodeToken(string(userEmail), uuid.UUID(customerId))
if err != nil { if err != nil {
return err return err
@@ -288,12 +257,12 @@ func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.Cust
frontendHost = config.FrontendHost frontendHost = config.FrontendHost
} }
htmlBody := fmt.Sprintf("<h1>Hello!</h1><p>Click the link to reset your nKode.</p><a href=\"%s?token=%s\">Reset nKode</a>", frontendHost, nkodeResetJwt) htmlBody := fmt.Sprintf("<h1>Hello!</h1><p>Click the link to reset your nKode.</p><a href=\"%s?token=%s\">Reset nKode</a>", frontendHost, nkodeResetJwt)
emailData := email.Email{ email := email.Email{
Sender: "no-reply@nkode.tech", Sender: "no-reply@nkode.tech",
Recipient: string(userEmail), Recipient: string(userEmail),
Subject: "nKode Reset", Subject: "nKode Reset",
Content: htmlBody, Content: htmlBody,
} }
n.EmailQueue.AddEmail(emailData) n.EmailQueue.AddEmail(email)
return nil return nil
} }

28
internal/api/nkode_api_test.go
View File

@@ -1,15 +1,12 @@
package api package api
import ( import (
"context"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go-nkode/internal/db"
"go-nkode/internal/email" "go-nkode/internal/email"
"go-nkode/internal/entities" "go-nkode/internal/entities"
"go-nkode/internal/models" "go-nkode/internal/models"
"go-nkode/internal/repository"
"go-nkode/internal/security" "go-nkode/internal/security"
sqlite_queue "go-nkode/internal/sqlc"
"log"
"os" "os"
"testing" "testing"
) )
@@ -18,31 +15,22 @@ func TestNKodeAPI(t *testing.T) {
//db1 := NewInMemoryDb() //db1 := NewInMemoryDb()
//testNKodeAPI(t, &db1) //testNKodeAPI(t, &db1)
dbPath := os.Getenv("TEST_DB") dbFile := os.Getenv("TEST_DB")
ctx := context.Background()
sqliteDb, err := sqlite_queue.OpenSqliteDb(dbPath)
assert.NoError(t, err)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb) db2, err := db.NewSqliteDB(dbFile)
assert.NoError(t, err) assert.NoError(t, err)
queue.Start() defer db2.Close()
defer func(queue *sqlite_queue.Queue) { testNKodeAPI(t, db2)
if err := queue.Stop(); err != nil {
log.Fatal(err)
}
}(queue)
sqlitedb := repository.NewSqliteRepository(ctx, queue)
testNKodeAPI(t, &sqlitedb)
//if _, err := os.Stat(dbPath); err == nil { //if _, err := os.Stat(dbFile); err == nil {
// err = os.Remove(dbPath) // err = os.Remove(dbFile)
// assert.NoError(t, err) // assert.NoError(t, err)
//} else { //} else {
// assert.NoError(t, err) // assert.NoError(t, err)
//} //}
} }
func testNKodeAPI(t *testing.T, db repository.CustomerUserRepository) { func testNKodeAPI(t *testing.T, db db.CustomerUserRepository) {
bufferSize := 100 bufferSize := 100
emailsPerSec := 14 emailsPerSec := 14
testClient := email.TestEmailClient{} testClient := email.TestEmailClient{}

9
internal/repository/customer_user_repository.go → internal/db/customer_user_repository.go
View File

@@ -1,4 +1,4 @@
package repository package db
import ( import (
"go-nkode/internal/entities" "go-nkode/internal/entities"
@@ -6,17 +6,16 @@ import (
) )
type CustomerUserRepository interface { type CustomerUserRepository interface {
GetCustomer(models.CustomerID) (*entities.Customer, error) GetCustomer(models.CustomerId) (*entities.Customer, error)
GetUser(models.UserEmail, models.CustomerID) (*entities.User, error) GetUser(models.UserEmail, models.CustomerId) (*entities.User, error)
CreateCustomer(entities.Customer) error CreateCustomer(entities.Customer) error
WriteNewUser(entities.User) error WriteNewUser(entities.User) error
UpdateUserNKode(entities.User) error UpdateUserNKode(entities.User) error
UpdateUserInterface(models.UserId, entities.UserInterface) error UpdateUserInterface(models.UserId, entities.UserInterface) error
UpdateUserRefreshToken(models.UserId, string) error UpdateUserRefreshToken(models.UserId, string) error
Renew(models.CustomerID) error Renew(models.CustomerId) error
RefreshUserPasscode(entities.User, []int, entities.CustomerAttributes) error RefreshUserPasscode(entities.User, []int, entities.CustomerAttributes) error
RandomSvgInterface(entities.KeypadDimension) ([]string, error) RandomSvgInterface(entities.KeypadDimension) ([]string, error)
RandomSvgIdxInterface(entities.KeypadDimension) (models.SvgIdInterface, error) RandomSvgIdxInterface(entities.KeypadDimension) (models.SvgIdInterface, error)
GetSvgStringInterface(models.SvgIdInterface) ([]string, error) GetSvgStringInterface(models.SvgIdInterface) ([]string, error)
AddSVGIcon(svgStr string) (int64, error)
} }

22
internal/repository/in_memory_db.go → internal/db/in_memory_db.go
View File

@@ -1,4 +1,4 @@
package repository package db
import ( import (
"errors" "errors"
@@ -8,28 +8,28 @@ import (
) )
type InMemoryDb struct { type InMemoryDb struct {
Customers map[models.CustomerID]entities.Customer Customers map[models.CustomerId]entities.Customer
Users map[models.UserId]entities.User Users map[models.UserId]entities.User
userIdMap map[string]models.UserId userIdMap map[string]models.UserId
} }
func NewInMemoryDb() InMemoryDb { func NewInMemoryDb() InMemoryDb {
return InMemoryDb{ return InMemoryDb{
Customers: make(map[models.CustomerID]entities.Customer), Customers: make(map[models.CustomerId]entities.Customer),
Users: make(map[models.UserId]entities.User), Users: make(map[models.UserId]entities.User),
userIdMap: make(map[string]models.UserId), userIdMap: make(map[string]models.UserId),
} }
} }
func (db *InMemoryDb) GetCustomer(id models.CustomerID) (*entities.Customer, error) { func (db *InMemoryDb) GetCustomer(id models.CustomerId) (*entities.Customer, error) {
customer, exists := db.Customers[id] customer, exists := db.Customers[id]
if !exists { if !exists {
return nil, errors.New(fmt.Sprintf("customer %s dne", customer.ID)) return nil, errors.New(fmt.Sprintf("customer %s dne", customer.Id))
} }
return &customer, nil return &customer, nil
} }
func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.CustomerID) (*entities.User, error) { func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.CustomerId) (*entities.User, error) {
key := userIdKey(customerId, username) key := userIdKey(customerId, username)
userId, exists := db.userIdMap[key] userId, exists := db.userIdMap[key]
if !exists { if !exists {
@@ -43,12 +43,12 @@ func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.Custo
} }
func (db *InMemoryDb) CreateCustomer(customer entities.Customer) error { func (db *InMemoryDb) CreateCustomer(customer entities.Customer) error {
_, exists := db.Customers[customer.ID] _, exists := db.Customers[customer.Id]
if exists { if exists {
return errors.New(fmt.Sprintf("can write customer %s; already exists", customer.ID)) return errors.New(fmt.Sprintf("can write customer %s; already exists", customer.Id))
} }
db.Customers[customer.ID] = customer db.Customers[customer.Id] = customer
return nil return nil
} }
@@ -86,7 +86,7 @@ func (db *InMemoryDb) UpdateUserRefreshToken(userId models.UserId, refreshToken
return nil return nil
} }
func (db *InMemoryDb) Renew(id models.CustomerID) error { func (db *InMemoryDb) Renew(id models.CustomerId) error {
customer, exists := db.Customers[id] customer, exists := db.Customers[id]
if !exists { if !exists {
return errors.New(fmt.Sprintf("customer %s does not exist", id)) return errors.New(fmt.Sprintf("customer %s does not exist", id))
@@ -133,7 +133,7 @@ func (db *InMemoryDb) GetSvgStringInterface(idxs models.SvgIdInterface) ([]strin
return make([]string, len(idxs)), nil return make([]string, len(idxs)), nil
} }
func userIdKey(customerId models.CustomerID, username models.UserEmail) string { func userIdKey(customerId models.CustomerId, username models.UserEmail) string {
key := fmt.Sprintf("%s:%s", customerId, username) key := fmt.Sprintf("%s:%s", customerId, username)
return key return key
} }

0
internal/repository/sqlite-init/json/academicons.json → internal/db/sqlite-init/json/academicons.json
View File

0
internal/repository/sqlite-init/json/akar-icons.json → internal/db/sqlite-init/json/akar-icons.json
View File

0
internal/repository/sqlite-init/json/ant-design.json → internal/db/sqlite-init/json/ant-design.json
View File

0
internal/repository/sqlite-init/json/arcticons.json → internal/db/sqlite-init/json/arcticons.json
View File

0
internal/repository/sqlite-init/json/basil.json → internal/db/sqlite-init/json/basil.json
View File

0
internal/repository/sqlite-init/json/bitcoin-icons.json → internal/db/sqlite-init/json/bitcoin-icons.json
View File

2
internal/repository/sqlite-init/sqlite_init.go → internal/db/sqlite-init/sqlite_init.go
View File

@@ -26,7 +26,7 @@ type Root struct {
func main() { func main() {
testDbPath := os.Getenv("TEST_DB_PATH") testDbPath := os.Getenv("TEST_DB_PATH")
dbPath := os.Getenv("SQLITE_PATH") dbPath := os.Getenv("DB_PATH")
dbPaths := []string{testDbPath, dbPath} dbPaths := []string{testDbPath, dbPath}
flaticonSvgDir := os.Getenv("SVG_DIR") flaticonSvgDir := os.Getenv("SVG_DIR")
//dbPath := "/Users/donov/Desktop/nkode.db" //dbPath := "/Users/donov/Desktop/nkode.db"

250
internal/repository/sqlite_repository.go → internal/db/sqlite_db.go
View File

@@ -1,4 +1,4 @@
package repository package db
import ( import (
"context" "context"
@@ -14,42 +14,103 @@ import (
"go-nkode/internal/sqlc" "go-nkode/internal/sqlc"
"go-nkode/internal/utils" "go-nkode/internal/utils"
"log" "log"
"sync"
) )
type SqliteRepository struct { const writeBufferSize = 100
Queue *sqlc.Queue
type sqlcGeneric func(*sqlc.Queries, context.Context, any) error
// WriteTx represents a write transaction
type WriteTx struct {
ErrChan chan error
Query sqlcGeneric
Args interface{}
}
// SqliteDB represents the SQLite database connection and write queue
type SqliteDB struct {
queries *sqlc.Queries
db *sql.DB
writeQueue chan WriteTx
wg sync.WaitGroup
ctx context.Context ctx context.Context
cancel context.CancelFunc
} }
func NewSqliteRepository(ctx context.Context, queue *sqlc.Queue) SqliteRepository { // NewSqliteDB initializes a new SqliteDB instance
return SqliteRepository{ func NewSqliteDB(path string) (*SqliteDB, error) {
Queue: queue, if path == "" {
return nil, errors.New("database path is required")
}
db, err := sql.Open("sqlite3", path)
if err != nil {
return nil, fmt.Errorf("failed to open database: %w", err)
}
if err := db.Ping(); err != nil {
return nil, fmt.Errorf("failed to connect to database: %w", err)
}
ctx, cancel := context.WithCancel(context.Background())
sqldb := &SqliteDB{
queries: sqlc.New(db),
db: db,
writeQueue: make(chan WriteTx, writeBufferSize),
ctx: ctx, ctx: ctx,
cancel: cancel,
}
sqldb.wg.Add(1)
go sqldb.processWriteQueue()
return sqldb, nil
}
// processWriteQueue handles write transactions from the queue
func (d *SqliteDB) processWriteQueue() {
defer d.wg.Done()
for {
select {
case <-d.ctx.Done():
return
case writeTx := <-d.writeQueue:
err := writeTx.Query(d.queries, d.ctx, writeTx.Args)
writeTx.ErrChan <- err
}
} }
} }
func (d *SqliteRepository) CreateCustomer(c entities.Customer) error { func (d *SqliteDB) Close() error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { d.cancel()
d.wg.Wait()
close(d.writeQueue)
return d.db.Close()
}
func (d *SqliteDB) CreateCustomer(c entities.Customer) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.CreateCustomerParams) params, ok := args.(sqlc.CreateCustomerParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected CreateCustomerParams") return fmt.Errorf("invalid argument type: expected CreateCustomerParams")
} }
return nil, q.CreateCustomer(ctx, params) return q.CreateCustomer(ctx, params)
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, c.ToSqlcCreateCustomerParams()) return d.enqueueWriteTx(queryFunc, c.ToSqlcCreateCustomerParams())
return err
} }
func (d *SqliteRepository) WriteNewUser(u entities.User) error { func (d *SqliteDB) WriteNewUser(u entities.User) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.CreateUserParams) params, ok := args.(sqlc.CreateUserParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected CreateUserParams") return fmt.Errorf("invalid argument type: expected CreateUserParams")
} }
return nil, q.CreateUser(ctx, params) return q.CreateUser(ctx, params)
} }
// Use the wrapped function in EnqueueWriteTx // Use the wrapped function in enqueueWriteTx
renew := 0 renew := 0
if u.Renew { if u.Renew {
renew = 1 renew = 1
@@ -75,19 +136,18 @@ func (d *SqliteRepository) WriteNewUser(u entities.User) error {
SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId), SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId),
CreatedAt: sql.NullString{String: utils.TimeStamp(), Valid: true}, CreatedAt: sql.NullString{String: utils.TimeStamp(), Valid: true},
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, params) return d.enqueueWriteTx(queryFunc, params)
return err
} }
func (d *SqliteRepository) UpdateUserNKode(u entities.User) error { func (d *SqliteDB) UpdateUserNKode(u entities.User) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.UpdateUserParams) params, ok := args.(sqlc.UpdateUserParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected UpdateUserParams") return fmt.Errorf("invalid argument type: expected UpdateUserParams")
} }
return nil, q.UpdateUser(ctx, params) return q.UpdateUser(ctx, params)
} }
// Use the wrapped function in EnqueueWriteTx // Use the wrapped function in enqueueWriteTx
renew := 0 renew := 0
if u.Renew { if u.Renew {
renew = 1 renew = 1
@@ -110,34 +170,33 @@ func (d *SqliteRepository) UpdateUserNKode(u entities.User) error {
IdxInterface: security.IntArrToByteArr(u.Interface.IdxInterface), IdxInterface: security.IntArrToByteArr(u.Interface.IdxInterface),
SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId), SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId),
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, params) return d.enqueueWriteTx(queryFunc, params)
return err
} }
func (d *SqliteRepository) UpdateUserInterface(id models.UserId, ui entities.UserInterface) error { func (d *SqliteDB) UpdateUserInterface(id models.UserId, ui entities.UserInterface) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.UpdateUserInterfaceParams) params, ok := args.(sqlc.UpdateUserInterfaceParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected UpdateUserInterfaceParams") return fmt.Errorf("invalid argument type: expected UpdateUserInterfaceParams")
} }
return nil, q.UpdateUserInterface(ctx, params) return q.UpdateUserInterface(ctx, params)
} }
params := sqlc.UpdateUserInterfaceParams{ params := sqlc.UpdateUserInterfaceParams{
IdxInterface: security.IntArrToByteArr(ui.IdxInterface), IdxInterface: security.IntArrToByteArr(ui.IdxInterface),
LastLogin: utils.TimeStamp(), LastLogin: utils.TimeStamp(),
ID: uuid.UUID(id).String(), ID: uuid.UUID(id).String(),
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err return d.enqueueWriteTx(queryFunc, params)
} }
func (d *SqliteRepository) UpdateUserRefreshToken(id models.UserId, refreshToken string) error { func (d *SqliteDB) UpdateUserRefreshToken(id models.UserId, refreshToken string) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.UpdateUserRefreshTokenParams) params, ok := args.(sqlc.UpdateUserRefreshTokenParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected UpdateUserRefreshToken") return fmt.Errorf("invalid argument type: expected UpdateUserRefreshToken")
} }
return nil, q.UpdateUserRefreshToken(ctx, params) return q.UpdateUserRefreshToken(ctx, params)
} }
params := sqlc.UpdateUserRefreshTokenParams{ params := sqlc.UpdateUserRefreshTokenParams{
RefreshToken: sql.NullString{ RefreshToken: sql.NullString{
@@ -146,43 +205,43 @@ func (d *SqliteRepository) UpdateUserRefreshToken(id models.UserId, refreshToken
}, },
ID: uuid.UUID(id).String(), ID: uuid.UUID(id).String(),
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, params) return d.enqueueWriteTx(queryFunc, params)
return err
} }
func (d *SqliteRepository) RenewCustomer(renewParams sqlc.RenewCustomerParams) error { func (d *SqliteDB) RenewCustomer(renewParams sqlc.RenewCustomerParams) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.RenewCustomerParams) params, ok := args.(sqlc.RenewCustomerParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected RenewCustomerParams")
} }
return nil, q.RenewCustomer(ctx, params) return q.RenewCustomer(ctx, params)
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, renewParams) return d.enqueueWriteTx(queryFunc, renewParams)
return err
} }
func (d *SqliteRepository) Renew(id models.CustomerID) error { func (d *SqliteDB) Renew(id models.CustomerId) error {
setXor, attrXor, err := d.renewCustomer(id) setXor, attrXor, err := d.renewCustomer(id)
if err != nil { if err != nil {
return err return err
} }
customerId := models.CustomerIdToString(id) customerId := models.CustomerIdToString(id)
userRenewRows, err := d.Queue.Queries.GetUserRenew(d.ctx, customerId) userRenewRows, err := d.queries.GetUserRenew(d.ctx, customerId)
if err != nil { if err != nil {
return err return err
} }
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.RenewUserParams) params, ok := args.(sqlc.RenewUserParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected RenewUserParams") return fmt.Errorf("invalid argument type: expected RenewUserParams")
} }
return nil, q.RenewUser(ctx, params) return q.RenewUser(ctx, params)
} }
for _, row := range userRenewRows { for _, row := range userRenewRows {
user := entities.User{ user := entities.User{
Id: models.UserIdFromString(row.ID), Id: models.UserIdFromString(row.ID),
CustomerId: models.CustomerID{}, CustomerId: models.CustomerId{},
Email: "", Email: "",
EncipheredPasscode: models.EncipheredNKode{}, EncipheredPasscode: models.EncipheredNKode{},
Kp: entities.KeypadDimension{ Kp: entities.KeypadDimension{
@@ -196,6 +255,7 @@ func (d *SqliteRepository) Renew(id models.CustomerID) error {
Interface: entities.UserInterface{}, Interface: entities.UserInterface{},
Renew: false, Renew: false,
} }
if err = user.RenewKeys(setXor, attrXor); err != nil { if err = user.RenewKeys(setXor, attrXor); err != nil {
return err return err
} }
@@ -205,14 +265,14 @@ func (d *SqliteRepository) Renew(id models.CustomerID) error {
Renew: 1, Renew: 1,
ID: uuid.UUID(user.Id).String(), ID: uuid.UUID(user.Id).String(),
} }
if _, err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil { if err = d.enqueueWriteTx(queryFunc, params); err != nil {
return err return err
} }
} }
return nil return nil
} }
func (d *SqliteRepository) renewCustomer(id models.CustomerID) ([]uint64, []uint64, error) { func (d *SqliteDB) renewCustomer(id models.CustomerId) ([]uint64, []uint64, error) {
customer, err := d.GetCustomer(id) customer, err := d.GetCustomer(id)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
@@ -221,34 +281,36 @@ func (d *SqliteRepository) renewCustomer(id models.CustomerID) ([]uint64, []uint
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.RenewCustomerParams) params, ok := args.(sqlc.RenewCustomerParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected RenewCustomerParams") return fmt.Errorf("invalid argument type: expected RenewCustomerParams")
} }
return nil, q.RenewCustomer(ctx, params) return q.RenewCustomer(ctx, params)
} }
params := sqlc.RenewCustomerParams{ params := sqlc.RenewCustomerParams{
AttributeValues: security.Uint64ArrToByteArr(customer.Attributes.AttrVals), AttributeValues: security.Uint64ArrToByteArr(customer.Attributes.AttrVals),
SetValues: security.Uint64ArrToByteArr(customer.Attributes.SetVals), SetValues: security.Uint64ArrToByteArr(customer.Attributes.SetVals),
ID: uuid.UUID(customer.ID).String(), ID: uuid.UUID(customer.Id).String(),
} }
if _, err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
if err = d.enqueueWriteTx(queryFunc, params); err != nil {
return nil, nil, err return nil, nil, err
} }
return setXor, attrXor, nil return setXor, attrXor, nil
} }
func (d *SqliteRepository) RefreshUserPasscode(user entities.User, passcodeIdx []int, customerAttr entities.CustomerAttributes) error { func (d *SqliteDB) RefreshUserPasscode(user entities.User, passcodeIdx []int, customerAttr entities.CustomerAttributes) error {
if err := user.RefreshPasscode(passcodeIdx, customerAttr); err != nil { if err := user.RefreshPasscode(passcodeIdx, customerAttr); err != nil {
return err return err
} }
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) { queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
params, ok := args.(sqlc.RefreshUserPasscodeParams) params, ok := args.(sqlc.RefreshUserPasscodeParams)
if !ok { if !ok {
return nil, fmt.Errorf("invalid argument type: expected RefreshUserPasscodeParams") return fmt.Errorf("invalid argument type: expected RefreshUserPasscodeParams")
} }
return nil, q.RefreshUserPasscode(ctx, params) return q.RefreshUserPasscode(ctx, params)
} }
params := sqlc.RefreshUserPasscodeParams{ params := sqlc.RefreshUserPasscodeParams{
Renew: 0, Renew: 0,
@@ -261,17 +323,17 @@ func (d *SqliteRepository) RefreshUserPasscode(user entities.User, passcodeIdx [
Salt: user.CipherKeys.Salt, Salt: user.CipherKeys.Salt,
ID: uuid.UUID(user.Id).String(), ID: uuid.UUID(user.Id).String(),
} }
_, err := d.Queue.EnqueueWriteTx(queryFunc, params) return d.enqueueWriteTx(queryFunc, params)
return err
} }
func (d *SqliteRepository) GetCustomer(id models.CustomerID) (*entities.Customer, error) { func (d *SqliteDB) GetCustomer(id models.CustomerId) (*entities.Customer, error) {
customer, err := d.Queue.Queries.GetCustomer(d.ctx, uuid.UUID(id).String()) customer, err := d.queries.GetCustomer(d.ctx, uuid.UUID(id).String())
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &entities.Customer{ return &entities.Customer{
ID: id, Id: id,
NKodePolicy: models.NKodePolicy{ NKodePolicy: models.NKodePolicy{
MaxNkodeLen: int(customer.MaxNkodeLen), MaxNkodeLen: int(customer.MaxNkodeLen),
MinNkodeLen: int(customer.MinNkodeLen), MinNkodeLen: int(customer.MinNkodeLen),
@@ -284,8 +346,8 @@ func (d *SqliteRepository) GetCustomer(id models.CustomerID) (*entities.Customer
}, nil }, nil
} }
func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.CustomerID) (*entities.User, error) { func (d *SqliteDB) GetUser(email models.UserEmail, customerId models.CustomerId) (*entities.User, error) {
userRow, err := d.Queue.Queries.GetUser(d.ctx, sqlc.GetUserParams{ userRow, err := d.queries.GetUser(d.ctx, sqlc.GetUserParams{
Email: string(email), Email: string(email),
CustomerID: uuid.UUID(customerId).String(), CustomerID: uuid.UUID(customerId).String(),
}) })
@@ -295,10 +357,12 @@ func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.Cus
} }
return nil, fmt.Errorf("failed to get user: %w", err) return nil, fmt.Errorf("failed to get user: %w", err)
} }
kp := entities.KeypadDimension{ kp := entities.KeypadDimension{
AttrsPerKey: int(userRow.AttributesPerKey), AttrsPerKey: int(userRow.AttributesPerKey),
NumbOfKeys: int(userRow.NumberOfKeys), NumbOfKeys: int(userRow.NumberOfKeys),
} }
renew := false renew := false
if userRow.Renew == 1 { if userRow.Renew == 1 {
renew = true renew = true
@@ -332,7 +396,7 @@ func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.Cus
return &user, nil return &user, nil
} }
func (d *SqliteRepository) RandomSvgInterface(kp entities.KeypadDimension) ([]string, error) { func (d *SqliteDB) RandomSvgInterface(kp entities.KeypadDimension) ([]string, error) {
ids, err := d.getRandomIds(kp.TotalAttrs()) ids, err := d.getRandomIds(kp.TotalAttrs())
if err != nil { if err != nil {
return nil, err return nil, err
@@ -340,37 +404,18 @@ func (d *SqliteRepository) RandomSvgInterface(kp entities.KeypadDimension) ([]st
return d.getSvgsById(ids) return d.getSvgsById(ids)
} }
func (d *SqliteRepository) RandomSvgIdxInterface(kp entities.KeypadDimension) (models.SvgIdInterface, error) { func (d *SqliteDB) RandomSvgIdxInterface(kp entities.KeypadDimension) (models.SvgIdInterface, error) {
return d.getRandomIds(kp.TotalAttrs()) return d.getRandomIds(kp.TotalAttrs())
} }
func (d *SqliteRepository) GetSvgStringInterface(idxs models.SvgIdInterface) ([]string, error) { func (d *SqliteDB) GetSvgStringInterface(idxs models.SvgIdInterface) ([]string, error) {
return d.getSvgsById(idxs) return d.getSvgsById(idxs)
} }
func (d *SqliteRepository) AddSVGIcon(svgStr string) (int64, error) { func (d *SqliteDB) getSvgsById(ids []int) ([]string, error) {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(string)
if !ok {
return nil, fmt.Errorf("invalid argument type: expected string")
}
return q.AddSVGIcon(ctx, params)
}
svgID, err := d.Queue.EnqueueWriteTx(queryFunc, svgStr)
if err != nil {
return -1, err
}
svgIDInt64, ok := svgID.(int64)
if !ok {
return -1, errors.New("svgID in DB isn't int64")
}
return svgIDInt64, nil
}
func (d *SqliteRepository) getSvgsById(ids []int) ([]string, error) {
svgs := make([]string, len(ids)) svgs := make([]string, len(ids))
for idx, id := range ids { for idx, id := range ids {
svg, err := d.Queue.Queries.GetSvgId(d.ctx, int64(id)) svg, err := d.queries.GetSvgId(d.ctx, int64(id))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -379,8 +424,25 @@ func (d *SqliteRepository) getSvgsById(ids []int) ([]string, error) {
return svgs, nil return svgs, nil
} }
func (d *SqliteRepository) getRandomIds(count int) ([]int, error) { func (d *SqliteDB) enqueueWriteTx(queryFunc sqlcGeneric, args any) error {
tx, err := d.Queue.Db.Begin() select {
case <-d.ctx.Done():
return errors.New("database is shutting down")
default:
}
errChan := make(chan error, 1)
writeTx := WriteTx{
Query: queryFunc,
Args: args,
ErrChan: errChan,
}
d.writeQueue <- writeTx
return <-errChan
}
func (d *SqliteDB) getRandomIds(count int) ([]int, error) {
tx, err := d.db.Begin()
if err != nil { if err != nil {
log.Print(err) log.Print(err)
return nil, config.ErrSqliteTx return nil, config.ErrSqliteTx

33
internal/repository/sqlite_repository_test.go → internal/db/sqlite_db_test.go
View File

@@ -1,31 +1,28 @@
package repository package db
import ( import (
"context"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go-nkode/internal/entities" "go-nkode/internal/entities"
"go-nkode/internal/models" "go-nkode/internal/models"
sqlite_queue "go-nkode/internal/sqlc"
"os" "os"
"testing" "testing"
) )
func TestNewSqliteDB(t *testing.T) { func TestNewSqliteDB(t *testing.T) {
dbPath := os.Getenv("TEST_DB") dbFile := os.Getenv("TEST_DB")
// sql_driver.MakeTables(dbFile) // sql_driver.MakeTables(dbFile)
ctx := context.Background() db, err := NewSqliteDB(dbFile)
sqliteDb, err := sqlite_queue.OpenSqliteDb(dbPath)
assert.NoError(t, err) assert.NoError(t, err)
defer db.Close()
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb) testSignupLoginRenew(t, db)
assert.NoError(t, err) testSqliteDBRandomSvgInterface(t, db)
// if _, err := os.Stat(dbFile); err == nil {
queue.Start() // err = os.Remove(dbFile)
defer queue.Stop() // assert.NoError(t, err)
db := NewSqliteRepository(ctx, queue) // } else {
assert.NoError(t, err) // assert.NoError(t, err)
testSignupLoginRenew(t, &db) // }
testSqliteDBRandomSvgInterface(t, &db)
} }
func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) { func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
@@ -34,7 +31,7 @@ func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
assert.NoError(t, err) assert.NoError(t, err)
err = db.CreateCustomer(*customerOrig) err = db.CreateCustomer(*customerOrig)
assert.NoError(t, err) assert.NoError(t, err)
customer, err := db.GetCustomer(customerOrig.ID) customer, err := db.GetCustomer(customerOrig.Id)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, customerOrig, customer) assert.Equal(t, customerOrig, customer)
username := "test_user@example.com" username := "test_user@example.com"
@@ -47,11 +44,11 @@ func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
assert.NoError(t, err) assert.NoError(t, err)
err = db.WriteNewUser(*userOrig) err = db.WriteNewUser(*userOrig)
assert.NoError(t, err) assert.NoError(t, err)
user, err := db.GetUser(models.UserEmail(username), customer.ID) user, err := db.GetUser(models.UserEmail(username), customer.Id)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, userOrig, user) assert.Equal(t, userOrig, user)
err = db.Renew(customer.ID) err = db.Renew(customer.Id)
assert.NoError(t, err) assert.NoError(t, err)
} }

2
internal/email/queue.go
View File

@@ -163,6 +163,6 @@ func (q *Queue) Stop() {
q.stop = true q.stop = true
// Wait for all emails to be processed // Wait for all emails to be processed
q.wg.Wait() q.wg.Wait()
// Stop the email queue // Close the email queue
close(q.emailQueue) close(q.emailQueue)
} }

2
internal/email/queue_test.go
View File

@@ -22,7 +22,7 @@ func TestEmailQueue(t *testing.T) {
} }
queue.AddEmail(email) queue.AddEmail(email)
} }
// Stop the queue after all emails are processed // Close the queue after all emails are processed
queue.Stop() queue.Stop()
assert.Equal(t, queue.FailedSendCount, 0) assert.Equal(t, queue.FailedSendCount, 0)

11
internal/entities/customer.go
View File

@@ -1,7 +1,6 @@
package entities package entities
import ( import (
"github.com/DonovanKelly/sugar-n-spice/set"
"github.com/google/uuid" "github.com/google/uuid"
"go-nkode/config" "go-nkode/config"
"go-nkode/internal/models" "go-nkode/internal/models"
@@ -11,7 +10,7 @@ import (
) )
type Customer struct { type Customer struct {
ID models.CustomerID Id models.CustomerId
NKodePolicy models.NKodePolicy NKodePolicy models.NKodePolicy
Attributes CustomerAttributes Attributes CustomerAttributes
} }
@@ -22,7 +21,7 @@ func NewCustomer(nkodePolicy models.NKodePolicy) (*Customer, error) {
return nil, err return nil, err
} }
customer := Customer{ customer := Customer{
ID: models.CustomerID(uuid.New()), Id: models.CustomerId(uuid.New()),
NKodePolicy: nkodePolicy, NKodePolicy: nkodePolicy,
Attributes: *customerAttrs, Attributes: *customerAttrs,
} }
@@ -39,8 +38,8 @@ func (c *Customer) IsValidNKode(kp KeypadDimension, passcodeAttrIdx []int) error
if validIdx := kp.ValidateAttributeIndices(passcodeAttrIdx); !validIdx { if validIdx := kp.ValidateAttributeIndices(passcodeAttrIdx); !validIdx {
return config.ErrInvalidNKodeIdx return config.ErrInvalidNKodeIdx
} }
passcodeSetVals := make(set.Set[uint64]) passcodeSetVals := make(utils.Set[uint64])
passcodeAttrVals := make(set.Set[uint64]) passcodeAttrVals := make(utils.Set[uint64])
attrVals, err := c.Attributes.AttrValsForKp(kp) attrVals, err := c.Attributes.AttrValsForKp(kp)
if err != nil { if err != nil {
return err return err
@@ -88,7 +87,7 @@ func (c *Customer) RenewKeys() ([]uint64, []uint64, error) {
func (c *Customer) ToSqlcCreateCustomerParams() sqlc.CreateCustomerParams { func (c *Customer) ToSqlcCreateCustomerParams() sqlc.CreateCustomerParams {
return sqlc.CreateCustomerParams{ return sqlc.CreateCustomerParams{
ID: uuid.UUID(c.ID).String(), ID: uuid.UUID(c.Id).String(),
MaxNkodeLen: int64(c.NKodePolicy.MaxNkodeLen), MaxNkodeLen: int64(c.NKodePolicy.MaxNkodeLen),
MinNkodeLen: int64(c.NKodePolicy.MinNkodeLen), MinNkodeLen: int64(c.NKodePolicy.MinNkodeLen),
DistinctSets: int64(c.NKodePolicy.DistinctSets), DistinctSets: int64(c.NKodePolicy.DistinctSets),

6
internal/entities/keypad_dimension.go
View File

@@ -1,8 +1,8 @@
package entities package entities
import ( import (
"github.com/DonovanKelly/sugar-n-spice/all"
"go-nkode/config" "go-nkode/config"
py "go-nkode/internal/utils"
) )
type KeypadDimension struct { type KeypadDimension struct {
@@ -26,13 +26,13 @@ func (kp *KeypadDimension) IsValidKeypadDimension() error {
} }
func (kp *KeypadDimension) ValidKeySelections(selectedKeys []int) bool { func (kp *KeypadDimension) ValidKeySelections(selectedKeys []int) bool {
return all.All[int](selectedKeys, func(idx int) bool { return py.All[int](selectedKeys, func(idx int) bool {
return 0 <= idx && idx < kp.NumbOfKeys return 0 <= idx && idx < kp.NumbOfKeys
}) })
} }
func (kp *KeypadDimension) ValidateAttributeIndices(attrIndicies []int) bool { func (kp *KeypadDimension) ValidateAttributeIndices(attrIndicies []int) bool {
return all.All[int](attrIndicies, func(i int) bool { return py.All[int](attrIndicies, func(i int) bool {
return i >= 0 && i < kp.TotalAttrs() return i >= 0 && i < kp.TotalAttrs()
}) })
} }

4
internal/entities/user.go
View File

@@ -10,7 +10,7 @@ import (
type User struct { type User struct {
Id models.UserId Id models.UserId
CustomerId models.CustomerID CustomerId models.CustomerId
Email models.UserEmail Email models.UserEmail
EncipheredPasscode models.EncipheredNKode EncipheredPasscode models.EncipheredNKode
Kp KeypadDimension Kp KeypadDimension
@@ -137,7 +137,7 @@ func NewUser(customer Customer, userEmail string, passcodeIdx []int, ui UserInte
CipherKeys: *newKeys, CipherKeys: *newKeys,
Interface: ui, Interface: ui,
Kp: kp, Kp: kp,
CustomerId: customer.ID, CustomerId: customer.Id,
} }
return &newUser, nil return &newUser, nil
} }

10
internal/entities/user_interface.go
View File

@@ -1,10 +1,10 @@
package entities package entities
import ( import (
"github.com/DonovanKelly/sugar-n-spice/set"
"go-nkode/config" "go-nkode/config"
"go-nkode/internal/models" "go-nkode/internal/models"
"go-nkode/internal/security" "go-nkode/internal/security"
"go-nkode/internal/utils"
"log" "log"
) )
@@ -122,15 +122,15 @@ func (u *UserInterface) randomAttributeRotation() error {
return nil return nil
} }
func (u *UserInterface) AttributeAdjacencyGraph() (map[int]set.Set[int], error) { func (u *UserInterface) AttributeAdjacencyGraph() (map[int]utils.Set[int], error) {
interfaceKeypad, err := u.InterfaceMatrix() interfaceKeypad, err := u.InterfaceMatrix()
if err != nil { if err != nil {
return nil, err return nil, err
} }
graph := make(map[int]set.Set[int]) graph := make(map[int]utils.Set[int])
for _, key := range interfaceKeypad { for _, key := range interfaceKeypad {
keySet := set.NewSetFromSlice(key) keySet := utils.NewSetFromSlice(key)
for _, attr := range key { for _, attr := range key {
attrAdjacency := keySet.Copy() attrAdjacency := keySet.Copy()
attrAdjacency.Remove(attr) attrAdjacency.Remove(attr)
@@ -154,7 +154,7 @@ func (u *UserInterface) LoginShuffle() error {
if err != nil { if err != nil {
return err return err
} }
selectedSets := set.NewSetFromSlice[int](setIdxs[:numbOfSelectedSets]) selectedSets := utils.NewSetFromSlice[int](setIdxs[:numbOfSelectedSets])
for keyIdx, key := range keypadSet1 { for keyIdx, key := range keypadSet1 {
for idx := range key { for idx := range key {

40
internal/entities/user_signup_session.go
View File

@@ -1,19 +1,18 @@
package entities package entities
import ( import (
"github.com/DonovanKelly/sugar-n-spice/all"
"github.com/DonovanKelly/sugar-n-spice/set"
"github.com/google/uuid" "github.com/google/uuid"
"go-nkode/config" "go-nkode/config"
"go-nkode/internal/models" "go-nkode/internal/models"
"go-nkode/internal/security" "go-nkode/internal/security"
py "go-nkode/internal/utils"
"log" "log"
"sort" "sort"
) )
type UserSignSession struct { type UserSignSession struct {
Id models.SessionId Id models.SessionId
CustomerId models.CustomerID CustomerId models.CustomerId
LoginUserInterface UserInterface LoginUserInterface UserInterface
Kp KeypadDimension Kp KeypadDimension
SetIdxInterface models.IdxInterface SetIdxInterface models.IdxInterface
@@ -25,31 +24,7 @@ type UserSignSession struct {
Colors []models.RGBColor Colors []models.RGBColor
} }
func NewSignupResetSessionRigged(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerID, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) { func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerId, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) {
loginInterface, err := NewUserInterface(&kp, svgInterface)
if err != nil {
return nil, err
}
setIdxInterface := make(models.IdxInterface, 36)
for idx := range 36 {
setIdxInterface[idx] = idx
}
session := UserSignSession{
Id: models.SessionId(uuid.New()),
CustomerId: customerId,
LoginUserInterface: *loginInterface,
SetIdxInterface: setIdxInterface,
ConfirmIdxInterface: nil,
SetKeySelection: nil,
UserEmail: userEmail,
Kp: kp,
Reset: reset,
Colors: []models.RGBColor{},
}
return &session, nil
}
func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerID, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) {
loginInterface, err := NewUserInterface(&kp, svgInterface) loginInterface, err := NewUserInterface(&kp, svgInterface)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -70,11 +45,12 @@ func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, custo
Reset: reset, Reset: reset,
Colors: colors, Colors: colors,
} }
return &session, nil return &session, nil
} }
func (s *UserSignSession) DeducePasscode(confirmKeyEntry models.KeySelection) ([]int, error) { func (s *UserSignSession) DeducePasscode(confirmKeyEntry models.KeySelection) ([]int, error) {
validEntry := all.All[int](confirmKeyEntry, func(i int) bool { validEntry := py.All[int](confirmKeyEntry, func(i int) bool {
return 0 <= i && i < s.Kp.NumbOfKeys return 0 <= i && i < s.Kp.NumbOfKeys
}) })
@@ -117,8 +93,8 @@ func (s *UserSignSession) DeducePasscode(confirmKeyEntry models.KeySelection) ([
passcode := make([]int, passcodeLen) passcode := make([]int, passcodeLen)
for idx := 0; idx < passcodeLen; idx++ { for idx := 0; idx < passcodeLen; idx++ {
setKey := set.NewSetFromSlice[int](setKeyVals[idx]) setKey := py.NewSetFromSlice[int](setKeyVals[idx])
confirmKey := set.NewSetFromSlice[int](confirmKeyVals[idx]) confirmKey := py.NewSetFromSlice[int](confirmKeyVals[idx])
intersection := setKey.Intersect(confirmKey) intersection := setKey.Intersect(confirmKey)
if intersection.Size() < 1 { if intersection.Size() < 1 {
log.Printf("set and confirm do not intersect at index %d", idx) log.Printf("set and confirm do not intersect at index %d", idx)
@@ -135,7 +111,7 @@ func (s *UserSignSession) DeducePasscode(confirmKeyEntry models.KeySelection) ([
} }
func (s *UserSignSession) SetUserNKode(keySelection models.KeySelection) (models.IdxInterface, error) { func (s *UserSignSession) SetUserNKode(keySelection models.KeySelection) (models.IdxInterface, error) {
validKeySelection := all.All[int](keySelection, func(i int) bool { validKeySelection := py.All[int](keySelection, func(i int) bool {
return 0 <= i && i < s.Kp.NumbOfKeys return 0 <= i && i < s.Kp.NumbOfKeys
}) })
if !validKeySelection { if !validKeySelection {

6
internal/entities/user_test.go
View File

@@ -1,9 +1,9 @@
package entities package entities
import ( import (
"github.com/DonovanKelly/sugar-n-spice/all"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go-nkode/internal/models" "go-nkode/internal/models"
py "go-nkode/internal/utils"
"testing" "testing"
) )
@@ -120,12 +120,12 @@ func TestUserInterface_PartialInterfaceShuffle(t *testing.T) {
shuffleCompare[idx] = val == postShuffle[idx] shuffleCompare[idx] = val == postShuffle[idx]
} }
allTrue := all.All[bool](shuffleCompare, func(n bool) bool { allTrue := py.All[bool](shuffleCompare, func(n bool) bool {
return n == true return n == true
}) })
assert.False(t, allTrue) assert.False(t, allTrue)
allFalse := all.All[bool](shuffleCompare, func(n bool) bool { allFalse := py.All[bool](shuffleCompare, func(n bool) bool {
return n == false return n == false
}) })

12
internal/models/models.go
View File

@@ -90,21 +90,13 @@ type GetLoginInterfaceResp struct {
type KeySelection []int type KeySelection []int
type CustomerID uuid.UUID type CustomerId uuid.UUID
func CustomerIdToString(customerId CustomerID) string { func CustomerIdToString(customerId CustomerId) string {
customerUuid := uuid.UUID(customerId) customerUuid := uuid.UUID(customerId)
return customerUuid.String() return customerUuid.String()
} }
func CustomerIDFromString(customerID string) (CustomerID, error) {
id, err := uuid.Parse(customerID)
if err != nil {
return CustomerID{}, err
}
return CustomerID(id), nil
}
type SessionId uuid.UUID type SessionId uuid.UUID
type UserId uuid.UUID type UserId uuid.UUID

6
internal/security/util.go
View File

@@ -6,7 +6,7 @@ import (
"encoding/binary" "encoding/binary"
"encoding/hex" "encoding/hex"
"errors" "errors"
"github.com/DonovanKelly/sugar-n-spice/set" "go-nkode/internal/utils"
"log" "log"
"math/big" "math/big"
r "math/rand" r "math/rand"
@@ -84,7 +84,7 @@ func GenerateRandomNonRepeatingUint64(listLen int) ([]uint64, error) {
if listLen > int(1)<<32 { if listLen > int(1)<<32 {
return nil, ErrRandNonRepeatingUint64 return nil, ErrRandNonRepeatingUint64
} }
listSet := make(set.Set[uint64]) listSet := make(utils.Set[uint64])
for { for {
if listSet.Size() == listLen { if listSet.Size() == listLen {
break break
@@ -104,7 +104,7 @@ func GenerateRandomNonRepeatingInt(listLen int) ([]int, error) {
if listLen > int(1)<<31 { if listLen > int(1)<<31 {
return nil, ErrRandNonRepeatingInt return nil, ErrRandNonRepeatingInt
} }
listSet := make(set.Set[int]) listSet := make(utils.Set[int])
for { for {
if listSet.Size() == listLen { if listSet.Size() == listLen {
break break

13
internal/sqlc/query.sql.go
View File

@@ -10,19 +10,6 @@ import (
"database/sql" "database/sql"
) )
const addSVGIcon = `-- name: AddSVGIcon :one
INSERT INTO svg_icon (svg)
VALUES (?)
RETURNING id
`
func (q *Queries) AddSVGIcon(ctx context.Context, svg string) (int64, error) {
row := q.db.QueryRowContext(ctx, addSVGIcon, svg)
var id int64
err := row.Scan(&id)
return id, err
}
const createCustomer = `-- name: CreateCustomer :exec const createCustomer = `-- name: CreateCustomer :exec
INSERT INTO customer ( INSERT INTO customer (
id id

101
internal/sqlc/sqlite_queue.go
View File

@@ -1,101 +0,0 @@
package sqlc
import (
"context"
"database/sql"
"errors"
"fmt"
"sync"
)
const writeBufferSize = 100
type GenericQuery func(*Queries, context.Context, any) (any, error)
type WriteTx struct {
ErrChan chan error
ReturnChan chan any
Query GenericQuery
Args any
}
type Queue struct {
Queries *Queries
Db *sql.DB
WriteQueue chan WriteTx
wg sync.WaitGroup
ctx context.Context
cancel context.CancelFunc
}
func NewQueue(ctx context.Context, sqlDb *sql.DB) (*Queue, error) {
ctx, cancel := context.WithCancel(context.Background())
sqldb := &Queue{
Queries: New(sqlDb),
Db: sqlDb,
WriteQueue: make(chan WriteTx, writeBufferSize),
ctx: ctx,
cancel: cancel,
}
return sqldb, nil
}
func (d *Queue) Start() {
d.wg.Add(1)
go func() {
// TODO: I think this might be a naive approach.
defer d.wg.Done()
for {
select {
case <-d.ctx.Done():
return
case writeTx := <-d.WriteQueue:
ret, err := writeTx.Query(d.Queries, d.ctx, writeTx.Args)
writeTx.ErrChan <- err
writeTx.ReturnChan <- ret
close(writeTx.ErrChan)
close(writeTx.ReturnChan)
}
}
}()
}
func (d *Queue) Stop() error {
d.cancel()
d.wg.Wait()
close(d.WriteQueue)
return d.Db.Close()
}
func (d *Queue) EnqueueWriteTx(queryFunc GenericQuery, args any) (any, error) {
select {
case <-d.ctx.Done():
return nil, errors.New("database is shutting down")
default:
}
errChan := make(chan error, 1)
retChan := make(chan any, 1)
writeTx := WriteTx{
Query: queryFunc,
Args: args,
ErrChan: errChan,
ReturnChan: retChan,
}
d.WriteQueue <- writeTx
err := <-errChan
val := <-retChan
return val, err
}
func OpenSqliteDb(dbPath string) (*sql.DB, error) {
sqliteDb, err := sql.Open("sqlite3", dbPath)
if err != nil {
return nil, fmt.Errorf("failed to open database: %w", err)
}
if err := sqliteDb.Ping(); err != nil {
return nil, fmt.Errorf("failed to connect to database: %w", err)
}
return sqliteDb, nil
}

63
internal/utils/hashset.go Normal file
View File

@@ -0,0 +1,63 @@
package utils
type Set[T comparable] map[T]struct{}
func (s *Set[T]) Add(element T) {
(*s)[element] = struct{}{}
}
func (s *Set[T]) Remove(element T) {
delete(*s, element)
}
func (s *Set[T]) Contains(element T) bool {
_, exists := (*s)[element]
return exists
}
func (s *Set[T]) Size() int {
return len(*s)
}
func (s *Set[T]) ToSlice() []T {
list := make([]T, 0, len(*s))
for key := range *s {
list = append(list, key)
}
return list
}
func NewSetFromSlice[T comparable](slice []T) Set[T] {
set := make(Set[T])
for _, val := range slice {
set.Add(val)
}
return set
}
func (s *Set[T]) Copy() Set[T] {
newSet := make(Set[T])
for key, val := range *s {
newSet[key] = val
}
return newSet
}
func (s *Set[T]) IsDisjoint(otherSet Set[T]) bool {
for attr := range *s {
if otherSet.Contains(attr) {
return false
}
}
return true
}
func (s *Set[T]) Intersect(otherSet Set[T]) Set[T] {
intersect := make(Set[T])
for val := range *s {
if otherSet.Contains(val) {
intersect.Add(val)
}
}
return intersect
}

35
internal/utils/hashset_test.go Normal file
View File

@@ -0,0 +1,35 @@
package utils
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestSet(t *testing.T) {
intSet := make(Set[int])
intSet.Add(1)
intSet.Add(2)
assert.EqualValues(t, intSet.Size(), 2)
intSet.Add(3)
intSet.Add(3)
assert.EqualValues(t, intSet.Size(), 3)
intSet.Remove(2)
assert.EqualValues(t, intSet.Size(), 2)
assert.False(t, intSet.Contains(2))
assert.True(t, intSet.Contains(1))
list := intSet.ToSlice()
assert.Contains(t, list, 1)
assert.Contains(t, list, 3)
}
func TestSet_Copy(t *testing.T) {
intSet := NewSetFromSlice[int]([]int{1, 2, 3})
copySet := intSet.Copy()
intSet.Remove(1)
assert.Equal(t, intSet.Size(), 2)
assert.Equal(t, copySet.Size(), 3)
}

11
internal/utils/py-builtin.go Normal file
View File

@@ -0,0 +1,11 @@
package utils
func All[T comparable](slice []T, condition func(T) bool) bool {
for _, v := range slice {
if !condition(v) {
return false
}
}
return true
}

48
scripts/bash/rebuild_db.sh
View File

@@ -1,48 +0,0 @@
#!/bin/bash
sqlite_db="$HOME/databases/demo.db"
db_schema="../../sqlite/schema.sql"
# svg_path="$HOME/svgs/flaticon_colored_svgs"
# svg_path="$HOME/svgs/flaticon_colored_pngs"
#svg_path="$HOME/icons"
svg_path="$HOME/svgs/warfighter_icons"
# remove existing test database
if [ -f "$sqlite_db" ]; then
echo "Removing existing test database at $sqlite_db"
rm "$sqlite_db"
else
echo "No existing test database found at $sqlite_db"
fi
# rebuild database
sqlite3 "$sqlite_db" < "$db_schema"
cli="../../bin/cli"
# build go cli
echo "building cli"
go build -o $cli ../../cmd/cli/main.go
# build db
echo "building db"
$cli build-db -db-path "$sqlite_db" -img-path "$svg_path"
# create customer
echo "creating customer"
customer_id="ed9ed6e0-082c-4b57-8d8c-f00ed6493457"
$cli create-customer -customer-id "$customer_id" -db-path "$sqlite_db"
## create admin user
#user_email="donovan.a.kelly@pm.me"
#keypad_path="$HOME/svgs/my_icons/"
#$nkode_cli add-user \
# -img-path "$keypad_path" \
# -img-type "svg" \
# -customer-id "$customer_id" \
# -user-email "$user_email" \
# -attrs-per-key 9 -numb-of-keys 6 \
# -db-path "$sqlite_db" \
# -role admin \
# -nkode-icons ae-86.svg,arkansas.svg,banana-slug.svg,blockchain.svg
#

7
scripts/bash/scp_db.sh
View File

@@ -1,7 +0,0 @@
#!/bin/bash
set -euo pipefail
./rebuild_db.sh
sqlite_db="$HOME/databases/demo.db"
scp $sqlite_db root@nkode.tech:/var/go-nkode/sqlite/demo.db

6
sqlite/embed.go
View File

@@ -1,6 +0,0 @@
package sqlite
import "embed"
//go:embed schema.sql
var FS embed.FS

5
sqlite/query.sql
View File

@@ -134,8 +134,3 @@ WHERE id = ?;
-- name: GetSvgCount :one -- name: GetSvgCount :one
SELECT COUNT(*) as count FROM svg_icon; SELECT COUNT(*) as count FROM svg_icon;
-- name: AddSVGIcon :one
INSERT INTO svg_icon (svg)
VALUES (?)
RETURNING id;