GitObjectDb

GitObjectDB simplifie le versioning de gestion de la configuration en le soutenant en git.

Nom	Badge
Gitobjectdb
GitObjectdb.SystemTextjson
Gitobjectdb.yamldotnet
Gitobjectdb.api.odata
Gitobjectdb.api.graphql
Gitobjectdb.api.protobuf
Gitobjectdb.api.protobuf.model

Aperçu

GitObjectDB est conçu pour simplifier le versioning de gestion de la configuration. Il le fait en supprimant le besoin de codage à la main les commandes nécessaires pour interagir avec GIT.

Le référentiel GIT est utilisé comme une base de données pure car les fichiers contenant la copie sérialisée des objets ne sont jamais récupérés dans le système de fichiers. GitObjectDB utilise uniquement le stockage BLOB fourni par Git.

Voici un exemple simple:

1. Définissez votre propre modèle de données de référentiel:

    [ GitFolder ( "Applications" ) ]
   public record Application : Node
   {
       public string Name { get ; init ; }
   
       public string Description { get ; init ; }
   }
   [ GitFolder ( "Pages" ) ]
   public record Table : Node
   {
       public string Name { get ; init ; }
   
       public string Description { get ; init ; }
   
       [ StoreAsSeparateFile ( Extension = "txt" ) ]
       public string ? RichContent { get ; init ; }
   }

2. Manipuler les objets comme suit:

    var existingApplication = connection . Lookup < Application > ( "main" , "applications" , new UniqueId ( id ) ) ;
   var newTable = new Table { .. . } ;
   connection
       . Update ( "main" , c => c . CreateOrUpdate ( newTable , parent : existingApplication ) )
   	. Commit ( new ( "Added new table." , author , committer ) ) ;

Caractéristiques

Stockage de données structuré et non structuré

 var node = new SomeNode
{
    SomeProperty = "Value stored as json" ,
    RichContent = "Value stored as raw text in separate Git blob, next to primary one" ,
} :

... est stocké dans Git comme suit:

• zerzrzrz.json

{
  "$type" : " Sample.SomeNode " ,
  "id" : " zerzrzrz " ,
  "someProperty" : " Value stored as json "
}

• zerzrzrz.richcontent.txt

 Value stored many dynamic resources in separate Git blob, next to primary one

Vous pouvez également stocker des ressources sous forme de fichiers séparés:

 new Resource ( node , "Some/Folder" , "File.txt" , new Resource . Data ( "Value stored in a separate file in <node path>/Resources/Some/Folder/File.txt" ) ) ; 

Ramification

 connection
    . Update ( "main" , c => c . CreateOrUpdate ( table with { Description = newDescription } ) )
    . Commit ( new ( "Some message" , signature , signature ) ) ;
connection . Checkout ( "newBranch" , "main~1" ) ;
connection
    . Update ( "main" , c => c . CreateOrUpdate ( table with { Name = newName } ) )
    . Commit ( new ( "Another message" , signature , signature ) ) ; 

Comparaison des commits

 var comparison = connection . Compare ( "main~5" , "main" ) ;
var nodeChanges = comparison . Modified . OfType < Change . NodeChange > ( ) ; 

Références de nœud

Les références de nœud permet de lier les nœuds existants dans un référentiel:

 public record Order : Node
{
    public Client Client { get ; set ; }
    // ...
}
public record Client : Node
{
    // ...
}
// Nodes get loaded with their references (using a shared )
var cache = new Dictionary < DataPath , ITreeItem > ( ) ;
var order = connection . GetNodes < Order > ( "main" , referenceCache : cache ) . First ( ) ;
Console . WriteLine ( order . Client . Id ) ; 

Fusionner, rebase, cick-cick

 // main:      A---B    A---B
//                 ->     
// newBranch:   C        C---x

connection
    . Update ( "main" , c => c . CreateOrUpdate ( table with { Description = newDescription } ) )
    . Commit ( new ( "B" , signature , signature ) ) ;
connection . Repository . Branches . Add ( "newBranch" , "main~1" ) ;
connection
    . Update ( "newBranch" , c => c . CreateOrUpdate ( table with { Name = newName } ) )
    . Commit ( new ( "C" , signature , signature ) ) ;

sut . Merge ( upstreamCommittish : "main" ) ; 

Gestion de la version du nœud

Imaginez un scénario où vous définissez dans votre code un premier type:

 [ GitFolder ( FolderName = "Items" , UseNodeFolders = false ) ]
[ IsDeprecatedNodeType ( typeof ( SomeNodeV2 ) ) ]
private record SomeNodeV1 : Node
{
    public int Flags { get ; set ; }
}

[ GitFolder ( FolderName = "Items" , UseNodeFolders = false ) ]
private record SomeNodeV2 : Node
{
    public BindingFlags TypedFlags { get ; set ; }
}

Vous souhaitez ensuite introduire un nouveau changement afin que la propriété Flags contienne des informations plus significatives, en s'appuyant sur Enum:

 [ GitFolder ( FolderName = "Items" , UseNodeFolders = false ) ]
private record SomeNodeV2 : Node
{
    public BindingFlags TypedFlags { get ; set ; }
}

Tout ce que vous avez à faire est d'ajouter # 1 ajouter l'attribut [IsDeprecatedNodeType(typeof(SomeNodeV2))] . Cela demandera au désérialiseur de convertir les nœuds en nouvelle version, en utilisant un convertisseur. # 2 Le convertisseur doit être fourni dans le modèle. Vous pouvez utiliser l'automappeur ou d'autres outils à votre convenance.

 [ GitFolder ( FolderName = "Items" , UseNodeFolders = false ) ]
[ IsDeprecatedNodeType ( typeof ( SomeNodeV2 ) ) ]
private record SomeNodeV1 : Node
{
    // ...
}
var model = new ConventionBaseModelBuilder ( )
    . RegisterType < SomeNodeV1 > ( )
    . RegisterType < SomeNodeV2 > ( )
    . AddDeprecatedNodeUpdater ( UpdateDeprecatedNode )
    . Build ( ) ;
Node UpdateDeprecatedNode ( Node old , Type targetType )
{
    var nodeV1 = ( SomeNodeV1 ) old ;
    return new SomeNodeV2
    {
        Id = old . Id ,
        TypedFlags = ( BindingFlags ) nodeV1 . Flags ,
    } ;
}

Documentation

Voir la documentation.

Condition préalable

• .NET Standard 2.0 ou 2.1

Ressources en ligne

• Libgit2sharp (nécessite Nuget 2.7+)

Guide de contribution rapide

• Fourche et clone localement
• Créez une branche spécifique à un sujet. Ajoutez une belle fonctionnalité. N'oubliez pas les tests ;-)
• Envoyez une demande de traction pour répandre le plaisir!

Licence

La licence MIT (reportez-vous au fichier de licence).