alecodes/synchronizator-go
Archived
2
0
Fork 0
generated from alecodes/base-template
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

feat: implement platform handler creation

Browse source 
also refactor public and internal api to support transaction between
multiple methods

#2
This commit is contained in:
Alexander Navarro 2024-11-18 16:51:09 -03:00
parent b2d8dadcee
commit 01086d12c9
7 changed files with 423 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

34
pkg/collection.go
View file

@ -1,6 +1,25 @@
package synchronizator
import "fmt"
import (
"fmt"
"strings"
)
type default_collection struct {
platform_name string
}
func (collection *default_collection) ToNode() (string, []byte, error) {
platform_name := strings.ToUpper(collection.platform_name)
return platform_name + "_DEFAULT", nil, nil
}
func (collection *default_collection) FromNode(_class string, name string, metadata []byte) error {
if _class != "DEFAULT" {
return fmt.Errorf("invalid class %s", _class)
}
return nil
}
// Utility struct to represent a collection of nodes, it's a [Node] itself so all
// the node's functionality is available.
@ -35,3 +54,16 @@ func (collection *Collection) AddChild(node *Node) error {
return nil
}
// Allows to retreive the saved information back into the user struct. This
// method will call the [NodeClass.FromNode] of the provided struct.
//
// Example:
//
// data := &Library{}
// if err := node.Unmarshall(data); err != nil {
// println(err)
// }
func (collection *Collection) Unmarshall(dst StandardNode) error {
return dst.FromNode("COLLECTION", collection.name, collection.metadata)
}

47
pkg/node.go
View file

@ -4,46 +4,22 @@ package synchronizator
// to provide the ability to parse the database node into a user defined
// struct that fulfills it's requirements.
//
// Example usage:
//
// type Library struct {
// Name string `json:"name"`
// Category string `json:"category"`
// Metadata map[string]interface{} `json:"metadata"`
// }
//
// func (library *Library) ToNode() (string, string, []byte, error) {
// metadata, err := json.Marshal(library.Metadata)
// if err != nil {
// return "", "", nil, err
// }
// return "LIBRARY", library.Name, metadata, nil
// }
//
// func (library *Library) FromNode(_class string, name string, metadata []byte) error {
// if _class != "LIBRARY" {
// return fmt.Errorf("invalid class %s", _class)
// }
// if err := json.Unmarshal(metadata, &library.Metadata); err != nil {
// return err
// }
// library.Name = name
// return nil
// }
type NodeClass interface {
// This interface is compatible with the [NodeClass] interface but it doesn't
// handle the class parameter as it's a static value provided by the
// StandardNode
type StandardNode interface {
// How to transform the struct into a node. It needs to return the class,
// name and a []byte representation of the metadata.
//
// - class: Is used for classification and query pourposes. It's recomended to provide a constante string to increase consistency.
// - name: A user friendly name
// - metadata: Arbitrary data. This will be stored as a jsonb in the database
//
ToNode() (string, string, []byte, error)
ToNode() (string, []byte, error)
// How to transform a node into the struct. This method should modify the
// struct directly as it receives a pointer.
//
// - class: Is used for classification and query pourposes.
// - class: The class of the node, should not be modified to avoid inconsistencies.
// - name: A user friendly name
// - metadata: Arbitrary data. This is stored as a jsonb in the database
FromNode(string, string, []byte) error
@ -60,11 +36,11 @@ type Node struct {
metadata []byte // Arbitrary data. This is stored as a jsonb in the database
}
// Creates a new relation of type RelationshipClass to the node with the
// Creates a new relation of type StandardRelationship to the node with the
// provided id. An error is returned if the relation already exists.
//
// This method is a wrapper around the AddRelation method of the connection.
func (node *Node) AddRelation(relation RelationshipClass, to int64) (*Relationship, error) {
func (node *Node) AddRelation(relation StandardRelationship, to int64) (*Relationship, error) {
return node._conn.AddRelation(node.Id, relation, to)
}
@ -145,6 +121,11 @@ func (node *Node) Delete() error {
// if err := node.Unmarshall(data); err != nil {
// println(err)
// }
func (node *Node) Unmarshall(dst NodeClass) error {
func (node *Node) Unmarshall(dst StandardNode) error {
return dst.FromNode(node._class, node.name, node.metadata)
}
// Returns the class of the node
func (relationship *Relationship) GetClass() string {
return relationship._class
}

25
pkg/platform.go Normal file
View file

@ -0,0 +1,25 @@
package synchronizator
type PlatformClass interface {
// How to transform the struct into a node. It needs to return the class,
// name and a []byte representation of the metadata.
//
// - name: A user friendly name
// - metadata: Arbitrary data. This will be stored as a jsonb in the database
//
ToNode() (string, []byte, error)
// How to transform a node into the struct. This method should modify the
// struct directly as it receives a pointer.
//
// - name: A user friendly name
// - metadata: Arbitrary data. This is stored as a jsonb in the database
FromNode(string, []byte) error
}
// Utility struct to represent a collection of nodes, it's a [Node] itself so all
// the node's functionality is available.
type Platform struct {
Node // Underlaying node info
collections []*Collection // Child nodes
}

6
pkg/relationship.go
View file

@ -18,7 +18,7 @@ package synchronizator
// }
// return nil
// }
type RelationshipClass interface {
type StandardRelationship interface {
// How to transform the struct into a collection. It needs to return the class,
// and a []byte representation of the metadata.
//
@ -44,7 +44,3 @@ type Relationship struct {
To int64 // To what node this relation goes to
Metadata []byte // Arbitrary data. This is stored as a jsonb in the database
}
func (relationship *Relationship) GetClass() string {
return relationship._class
}

148
pkg/synchronizator.go
View file

@ -4,6 +4,10 @@
// It does so implementing a graph database representing the relation of the
// different entities of data called "nodes", helping you find, create or
// delete the "equivalent" entities in the different sources.
//
// In this library we use the following nomemclature:
// - [struct_name]: The representation of the element in the database
// - [struct_name]Class: An interface so the users can create a custom representation of the element that make's sence in their application. The interface needs to provide a way to transform the struct into a node and viceversa.
package synchronizator
import (
@ -133,6 +137,21 @@ func (conn *DB) bootstrap() error {
return nil
}
// Allows you to run the underliying query in a transaction.
func (conn *DB) withTx(fn func(*sql.Tx) error) error {
tx, err := conn.Connection.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if err := fn(tx); err != nil {
return err
}
return tx.Commit()
}
func (conn *DB) Query(sql string, args ...any) (*sql.Rows, error) {
conn.log(DEBUG, "Executing query:", sql, args)
@ -144,13 +163,68 @@ func (conn *DB) Query(sql string, args ...any) (*sql.Rows, error) {
return rows, nil
}
// Creates a new Platform with the provided data.
//
// A collection is only a Node wrapper with some extended functionality to
// manage multiple nodes. For more information see [DB.NewNode] method and the
// [Platform] struct.
func (conn *DB) NewPlatform(data StandardNode) (*Platform, error) {
var platform *Platform
err := conn.withTx(func(tx *sql.Tx) error {
node, err := conn.newNodewithTx(tx, "PLATFORM", data)
if err != nil {
return err
}
collection, err := conn.newCollectionwithTx(
tx,
&default_collection{platform_name: node.name},
)
if err != nil {
return err
}
platform := &Platform{
Node: *node,
collections: []*Collection{collection},
}
_, err = conn.addRelationwithTx(tx, platform.Id, &collection_relation{}, collection.Id)
if err != nil {
return err
}
return nil
})
return platform, err
}
// Creates a new Collection with the provided data.
//
// A collection is only a Node wrapper with some extended functionality to
// manage multiple nodes. For more information see [DB.NewNode] method and the
// [Collection] struct.
func (conn *DB) NewCollection(data NodeClass) (*Collection, error) {
node, err := conn.NewNode(data)
//
// The operation is ran in a database transaction.
func (conn *DB) NewCollection(data StandardNode) (*Collection, error) {
var collection *Collection
err := conn.withTx(func(tx *sql.Tx) error {
var err error
collection, err = conn.newCollectionwithTx(tx, data)
return err
})
return collection, err
}
// Creates a new Collection with the provided data.
//
// A collection is only a Node wrapper with some extended functionality to
// manage multiple nodes. For more information see [DB.NewNode] method and the
// [Collection] struct.
func (conn *DB) newCollectionwithTx(tx *sql.Tx, data StandardNode) (*Collection, error) {
node, err := conn.newNodewithTx(tx, "COLLECTION", data)
if err != nil {
return nil, err
}
@ -160,12 +234,27 @@ func (conn *DB) NewCollection(data NodeClass) (*Collection, error) {
childs: make([]*Node, 0),
}
return collection, nil
return collection, err
}
// Creates a new node.
//
// The operation is ran in a database transaction.
func (conn *DB) NewNode(class string, data StandardNode) (*Node, error) {
var node *Node
err := conn.withTx(func(tx *sql.Tx) error {
var err error
node, err = conn.newNodewithTx(tx, class, data)
return err
})
return node, err
}
// Creates a new node
func (conn *DB) NewNode(data NodeClass) (*Node, error) {
class, name, metadata, err := data.ToNode()
func (conn *DB) newNodewithTx(tx *sql.Tx, class string, data StandardNode) (*Node, error) {
name, metadata, err := data.ToNode()
if err != nil {
return nil, err
}
@ -178,13 +267,6 @@ func (conn *DB) NewNode(data NodeClass) (*Node, error) {
Id: -1,
}
tx, err := conn.Connection.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
conn.log(DEBUG, "Creating node:", node)
sql := "INSERT INTO nodes (_class, name, metadata) VALUES ($1, $2, $3) RETURNING id;"
@ -194,22 +276,18 @@ func (conn *DB) NewNode(data NodeClass) (*Node, error) {
return nil, err
}
if err := tx.Commit(); err != nil {
return nil, err
}
return &node, nil
}
// Updates a node with the provided id and data
func (conn *DB) UpdateNode(id int64, data NodeClass) (*Node, error) {
class, name, metadata, err := data.ToNode()
func (conn *DB) UpdateNode(id int64, data StandardNode) (*Node, error) {
name, metadata, err := data.ToNode()
if err != nil {
return nil, err
}
node := Node{
_conn: conn,
_class: class,
name: name,
metadata: metadata,
Id: id,
@ -275,12 +353,32 @@ func (conn *DB) DeleteNode(id int64) error {
return nil
}
// Creates a new node.
//
// The operation is ran in a database transaction.
func (conn *DB) AddRelation(
from int64,
data StandardRelationship,
to int64,
) (*Relationship, error) {
var relationship *Relationship
err := conn.withTx(func(tx *sql.Tx) error {
var err error
relationship, err = conn.addRelationwithTx(tx, from, data, to)
return err
})
return relationship, err
}
// Creates a new relationship between two nodes.
//
// It returns the created relationship representation.
func (conn *DB) AddRelation(
func (conn *DB) addRelationwithTx(
tx *sql.Tx,
from int64,
data RelationshipClass,
data StandardRelationship,
to int64,
) (*Relationship, error) {
class, metadata, err := data.ToRelationship()
@ -296,13 +394,6 @@ func (conn *DB) AddRelation(
To: to,
}
tx, err := conn.Connection.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
conn.log(DEBUG, "Creating relationship:", from, relationship, to)
sql := "INSERT INTO relationships (_class, node_from, node_to, metadata) VALUES ($1, $2, $3, $4) RETURNING node_from, node_to;"
@ -312,9 +403,6 @@ func (conn *DB) AddRelation(
return nil, err
}
if err := tx.Commit(); err != nil {
return nil, err
}
return &relationship, nil
}