This commit is contained in:
Anya Tokugawa committed 2026-05-19 21:30:42 +09:00
commit fa6a4c650f
93 files changed
+6555

No files matched your search

+51
View File
@@ -0,0 +1,51 @@
package store
import (
"github.com/google/uuid"
)
func (s *Store) CreateObject(
path string,
) (string, error) {
objectUUID :=
uuid.NewString()
_, err := s.DB.Exec(`
INSERT INTO objects (
uuid,
created_at
)
VALUES (
?,
strftime('%s','now')
)
`,
objectUUID,
)
if err != nil {
return "", err
}
_, err = s.DB.Exec(`
INSERT INTO paths (
path,
object_uuid,
created_at
)
VALUES (
?, ?,
strftime('%s','now')
)
`,
path,
objectUUID,
)
if err != nil {
return "", err
}
return objectUUID, nil
}
+88
View File
@@ -0,0 +1,88 @@
package store
import "strings"
func (s *Store) ListChildPaths(
parent string,
) ([]string, error) {
if parent == "/" {
parent = ""
}
rows, err := s.DB.Query(`
SELECT path
FROM paths
ORDER BY path ASC
`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var path string
err := rows.Scan(
&path,
)
if err != nil {
return nil, err
}
if parent != "" {
if !strings.HasPrefix(
path,
parent+"/",
) {
continue
}
} else {
if !strings.HasPrefix(
path,
"/",
) {
continue
}
}
trimmed :=
strings.TrimPrefix(
path,
parent,
)
trimmed =
strings.TrimPrefix(
trimmed,
"/",
)
if trimmed == "" {
continue
}
if strings.Contains(
trimmed,
"/",
) {
continue
}
out = append(
out,
path,
)
}
return out, nil
}
+51
View File
@@ -0,0 +1,51 @@
package store
import "strings"
type SemanticObject struct {
UUID string
Path string
Kind string
}
func (s *Store) ListSemanticObjects() (
[]SemanticObject,
error,
) {
objects, err := s.ListObjects()
if err != nil {
return nil, err
}
var out []SemanticObject
for _, o := range objects {
if strings.HasPrefix(
o.UUID,
"/system/",
) {
continue
}
if strings.HasPrefix(
o.UUID,
"/o/",
) {
continue
}
out = append(
out,
SemanticObject{
UUID: o.UUID,
Path: o.UUID,
Kind: o.Kind,
},
)
}
return out, nil
}
+46
View File
@@ -0,0 +1,46 @@
package store
type Object struct {
UUID string
Kind string
CreatedAt int64
}
func (s *Store) ListObjects() ([]Object, error) {
rows, err := s.DB.Query(`
SELECT
uuid,
COALESCE(kind, '') AS kind,
created_at
FROM objects
ORDER BY created_at DESC
`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Object
for rows.Next() {
var o Object
err := rows.Scan(
&o.UUID,
&o.Kind,
&o.CreatedAt,
)
if err != nil {
return nil, err
}
out = append(out, o)
}
return out, nil
}
+32
View File
@@ -0,0 +1,32 @@
package store
func (s *Store) RenamePath(
oldPath string,
newPath string,
) error {
_, err := s.DB.Exec(`
UPDATE paths
SET path = ?
WHERE path = ?
`,
newPath,
oldPath,
)
return err
}
func (s *Store) RemovePath(
path string,
) error {
_, err := s.DB.Exec(`
DELETE FROM paths
WHERE path = ?
`,
path,
)
return err
}
+146
View File
@@ -0,0 +1,146 @@
package store
import (
"database/sql"
"time"
)
func (s *Store) BindPath(
path string,
objectUUID string,
) error {
_, err := s.DB.Exec(`
INSERT OR REPLACE INTO paths (
path,
object_uuid,
created_at
) VALUES (?, ?, ?)
`,
path,
objectUUID,
time.Now().Unix(),
)
return err
}
func (s *Store) ResolvePath(
path string,
) (string, error) {
row := s.DB.QueryRow(`
SELECT object_uuid
FROM paths
WHERE path = ?
`, path)
var objectUUID string
err := row.Scan(&objectUUID)
if err != nil {
return "", err
}
return objectUUID, nil
}
func (s *Store) ListChildren(
prefix string,
) ([]string, error) {
rows, err := s.DB.Query(`
SELECT path
FROM paths
WHERE path LIKE ?
ORDER BY path
`,
prefix+"/%",
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var p string
err := rows.Scan(&p)
if err != nil {
return nil, err
}
out = append(out, p)
}
return out, nil
}
func (s *Store) PathExists(
path string,
) bool {
row := s.DB.QueryRow(`
SELECT COUNT(*)
FROM paths
WHERE path = ?
`, path)
var count int
_ = row.Scan(&count)
return count > 0
}
func (s *Store) CreatePageAtPath(
path string,
) (string, error) {
objectUUID, err := s.CreateObject("flow")
if err != nil {
return "", err
}
err = s.BindPath(
path,
objectUUID,
)
if err != nil {
return "", err
}
return objectUUID, nil
}
func (s *Store) GetPathByUUID(
uuid string,
) (string, error) {
row := s.DB.QueryRow(`
SELECT path
FROM paths
WHERE object_uuid = ?
LIMIT 1
`, uuid)
var path string
err := row.Scan(&path)
if err != nil {
return "", err
}
return path, nil
}
func IsNotFound(err error) bool {
return err == sql.ErrNoRows
}
+140
View File
@@ -0,0 +1,140 @@
package store
import (
"crypto/sha256"
"database/sql"
"encoding/hex"
)
type Revision struct {
Hash string
ObjectUUID string
Body string
Message string
CreatedAt int64
}
func revisionHash(
body string,
) string {
sum := sha256.Sum256(
[]byte(body),
)
return hex.EncodeToString(
sum[:],
)
}
func (s *Store) SaveRevision(
objectUUID string,
body string,
message string,
) (string, error) {
hash := revisionHash(body)
_, err := s.DB.Exec(`
INSERT OR IGNORE INTO revisions (
uuid,
object_uuid,
body,
message,
created_at
)
VALUES (
?, ?, ?, ?,
strftime('%s','now')
)
`,
hash,
objectUUID,
body,
message,
)
if err != nil {
return "", err
}
return hash, nil
}
func (s *Store) GetRevision(
hash string,
) (*Revision, error) {
row := s.DB.QueryRow(`
SELECT
uuid,
object_uuid,
body,
message,
created_at
FROM revisions
WHERE uuid = ?
`,
hash,
)
var r Revision
err := row.Scan(
&r.Hash,
&r.ObjectUUID,
&r.Body,
&r.Message,
&r.CreatedAt,
)
if err != nil {
return nil, err
}
return &r, nil
}
func (s *Store) GetLatestRevision(
objectUUID string,
) (*Revision, error) {
row := s.DB.QueryRow(`
SELECT
uuid,
object_uuid,
body,
message,
created_at
FROM revisions
WHERE object_uuid = ?
ORDER BY created_at DESC
LIMIT 1
`,
objectUUID,
)
var r Revision
err := row.Scan(
&r.Hash,
&r.ObjectUUID,
&r.Body,
&r.Message,
&r.CreatedAt,
)
if err != nil {
if err == sql.ErrNoRows {
return &Revision{
ObjectUUID: objectUUID,
}, nil
}
return nil, err
}
return &r, nil
}
+54
View File
@@ -0,0 +1,54 @@
package store
type RevisionListItem struct {
Hash string
ObjectUUID string
Message string
CreatedAt int64
}
func (s *Store) ListRevisions(
objectUUID string,
) ([]RevisionListItem, error) {
rows, err := s.DB.Query(`
SELECT
uuid,
object_uuid,
message,
created_at
FROM revisions
WHERE object_uuid = ?
ORDER BY created_at DESC
`,
objectUUID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []RevisionListItem
for rows.Next() {
var r RevisionListItem
err = rows.Scan(
&r.Hash,
&r.ObjectUUID,
&r.Message,
&r.CreatedAt,
)
if err != nil {
return nil, err
}
out = append(out, r)
}
return out, nil
}
+16
View File
@@ -0,0 +1,16 @@
package store
import "database/sql"
type Store struct {
DB *sql.DB
}
func New(
db *sql.DB,
) *Store {
return &Store{
DB: db,
}
}
+53
View File
@@ -0,0 +1,53 @@
package store
func (s *Store) AddTag(
objectUUID string,
tag string,
) error {
_, err := s.DB.Exec(`
INSERT INTO tags (
object_uuid,
tag
) VALUES (?, ?)
`,
objectUUID,
tag,
)
return err
}
func (s *Store) ListTags(
objectUUID string,
) ([]string, error) {
rows, err := s.DB.Query(`
SELECT tag
FROM tags
WHERE object_uuid = ?
ORDER BY tag
`, objectUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var tag string
err := rows.Scan(&tag)
if err != nil {
return nil, err
}
out = append(out, tag)
}
return out, nil
}
+152
View File
@@ -0,0 +1,152 @@
package store
import (
"sort"
"strings"
)
type TreeNode struct {
Name string
FullPath string
Children map[string]*TreeNode
IsDir bool
ChildCount int
}
type FlatTreeNode struct {
Name string
FullPath string
Depth int
IsDir bool
ChildCount int
}
func (s *Store) BuildPathTree() (*TreeNode, error) {
rows, err := s.DB.Query(`
SELECT path
FROM paths
WHERE path LIKE '/%'
ORDER BY path ASC
`)
if err != nil {
return nil, err
}
defer rows.Close()
root := &TreeNode{
Name: "/",
FullPath: "/",
Children: map[string]*TreeNode{},
IsDir: true,
}
for rows.Next() {
var path string
err := rows.Scan(
&path,
)
if err != nil {
return nil, err
}
parts :=
strings.Split(
strings.TrimPrefix(
path,
"/",
),
"/",
)
current := root
var pathBuilder strings.Builder
for i, part := range parts {
pathBuilder.WriteString("/")
pathBuilder.WriteString(part)
currentPath := pathBuilder.String()
child, ok :=
current.Children[part]
if !ok {
child = &TreeNode{
Name: part,
FullPath: currentPath,
Children: map[string]*TreeNode{},
}
current.Children[part] =
child
}
if i != len(parts)-1 {
child.IsDir = true
}
current = child
}
}
var walk func(*TreeNode)
walk = func(n *TreeNode) {
n.ChildCount =
len(n.Children)
for _, c := range n.Children {
walk(c)
}
}
walk(root)
return root, nil
}
func FlattenTree(
node *TreeNode,
depth int,
out *[]FlatTreeNode,
) {
if node.FullPath != "/" {
*out = append(
*out,
FlatTreeNode{
Name: node.Name,
FullPath: node.FullPath,
Depth: depth,
IsDir: node.IsDir,
ChildCount: node.ChildCount,
},
)
}
keys := make([]string, 0)
for k := range node.Children {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
FlattenTree(
node.Children[k],
depth+1,
out,
)
}
}