lure
/
lure
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 13 Activity

Add GetPkg endpoint to API
ci/woodpecker/push/woodpecker Pipeline was successful Details

This commit is contained in:
Elara 2022-12-17 23:10:34 -08:00
parent 6cd0802f64
commit fe477ba6d1
5 changed files with 521 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
cmd/lure-api/api.go
View File

@ -122,28 +122,40 @@ func (l lureWebAPI) Search(ctx context.Context, req *api.SearchRequest) (*api.Se
if err != nil {
return err
}
out.Packages = append(out.Packages, &api.Package{
Name: pkg.Name,
Repository: pkg.Repository,
Version: pkg.Version,
Release: int64(pkg.Release),
Epoch: ptr(int64(pkg.Epoch)),
Description: &pkg.Description,
Homepage: &pkg.Homepage,
Maintainer: &pkg.Maintainer,
Architectures: pkg.Architectures,
Licenses: pkg.Licenses,
Provides: pkg.Provides,
Conflicts: pkg.Conflicts,
Replaces: pkg.Replaces,
Depends: dbMapToAPI(pkg.Depends),
BuildDepends: dbMapToAPI(pkg.BuildDepends),
})
out.Packages = append(out.Packages, dbPkgToAPI(pkg))
return nil
})
return out, err
}
func (l lureWebAPI) GetPkg(ctx context.Context, req *api.GetPackageRequest) (*api.Package, error) {
pkg, err := db.GetPkg(l.db, "name = ? AND repository = ?", req.Name, req.Repository)
if err != nil {
return nil, err
}
return dbPkgToAPI(pkg), nil
}
func dbPkgToAPI(pkg *db.Package) *api.Package {
return &api.Package{
Name: pkg.Name,
Repository: pkg.Repository,
Version: pkg.Version,
Release: int64(pkg.Release),
Epoch: ptr(int64(pkg.Epoch)),
Description: &pkg.Description,
Homepage: &pkg.Homepage,
Maintainer: &pkg.Maintainer,
Architectures: pkg.Architectures,
Licenses: pkg.Licenses,
Provides: pkg.Provides,
Conflicts: pkg.Conflicts,
Replaces: pkg.Replaces,
Depends: dbMapToAPI(pkg.Depends),
BuildDepends: dbMapToAPI(pkg.BuildDepends),
}
}
func ptr[T any](v T) *T {
return &v
}

172
cmd/lure-api/internal/api/lure.pb.go
View File

@ -801,6 +801,61 @@ func (x *Package) GetBuildDepends() map[string]*StringList {
return nil
}
type GetPackageRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Repository string `protobuf:"bytes,2,opt,name=repository,proto3" json:"repository,omitempty"`
}
func (x *GetPackageRequest) Reset() {
*x = GetPackageRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_lure_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetPackageRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetPackageRequest) ProtoMessage() {}
func (x *GetPackageRequest) ProtoReflect() protoreflect.Message {
mi := &file_lure_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetPackageRequest.ProtoReflect.Descriptor instead.
func (*GetPackageRequest) Descriptor() ([]byte, []int) {
return file_lure_proto_rawDescGZIP(), []int{10}
}
func (x *GetPackageRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *GetPackageRequest) GetRepository() string {
if x != nil {
return x.Repository
}
return ""
}
// SearchResponse contains returned packages
type SearchResponse struct {
state protoimpl.MessageState
@ -813,7 +868,7 @@ type SearchResponse struct {
func (x *SearchResponse) Reset() {
*x = SearchResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_lure_proto_msgTypes[10]
mi := &file_lure_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@ -826,7 +881,7 @@ func (x *SearchResponse) String() string {
func (*SearchResponse) ProtoMessage() {}
func (x *SearchResponse) ProtoReflect() protoreflect.Message {
mi := &file_lure_proto_msgTypes[10]
mi := &file_lure_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@ -839,7 +894,7 @@ func (x *SearchResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use SearchResponse.ProtoReflect.Descriptor instead.
func (*SearchResponse) Descriptor() ([]byte, []int) {
return file_lure_proto_rawDescGZIP(), []int{10}
return file_lure_proto_rawDescGZIP(), []int{11}
}
func (x *SearchResponse) GetPackages() []*Package {
@ -951,37 +1006,45 @@ var file_lure_proto_rawDesc = []byte{
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x68, 0x6f, 0x6d, 0x65, 0x70, 0x61, 0x67, 0x65, 0x42, 0x0d, 0x0a,
0x0b, 0x5f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3b, 0x0a, 0x0e,
0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29,
0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x0d, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x52,
0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2a, 0x3e, 0x0a, 0x07, 0x53, 0x4f, 0x52,
0x54, 0x5f, 0x42, 0x59, 0x12, 0x0c, 0x0a, 0x08, 0x55, 0x4e, 0x53, 0x4f, 0x52, 0x54, 0x45, 0x44,
0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a,
0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x59, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07,
0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x10, 0x03, 0x2a, 0x42, 0x0a, 0x0b, 0x46, 0x49, 0x4c,
0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, 0x5f, 0x46,
0x49, 0x4c, 0x54, 0x45, 0x52, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x5f, 0x52, 0x45,
0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x59, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x53, 0x55,
0x50, 0x50, 0x4f, 0x52, 0x54, 0x53, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x10, 0x02, 0x32, 0x86, 0x02,
0x0a, 0x03, 0x41, 0x50, 0x49, 0x12, 0x48, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43,
0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x43, 0x72,
0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x3c, 0x0a, 0x0b, 0x45, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x18,
0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e,
0x45, 0x6d, 0x70, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a,
0x0b, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x2e, 0x6c,
0x75, 0x72, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x47, 0x65,
0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x33, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x13, 0x2e, 0x6c, 0x75,
0x72, 0x65, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x14, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x0f, 0x5a, 0x0d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x2f, 0x61, 0x70, 0x69, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
0x0b, 0x5f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x47, 0x0a, 0x11,
0x47, 0x65, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74,
0x6f, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x73,
0x69, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x3b, 0x0a, 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61,
0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x75, 0x72, 0x65,
0x2e, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x52, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
0x65, 0x73, 0x2a, 0x3e, 0x0a, 0x07, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x12, 0x0c, 0x0a,
0x08, 0x55, 0x4e, 0x53, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4e,
0x41, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54,
0x4f, 0x52, 0x59, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e,
0x10, 0x03, 0x2a, 0x42, 0x0a, 0x0b, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50,
0x45, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, 0x5f, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x10, 0x00,
0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52,
0x59, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x53, 0x5f,
0x41, 0x52, 0x43, 0x48, 0x10, 0x02, 0x32, 0xb8, 0x02, 0x0a, 0x03, 0x41, 0x50, 0x49, 0x12, 0x48,
0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12,
0x1a, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d,
0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x75,
0x72, 0x65, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x0b, 0x45, 0x64, 0x69, 0x74,
0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x45,
0x64, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d,
0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x47, 0x65, 0x74,
0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x19, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x53, 0x65,
0x61, 0x72, 0x63, 0x68, 0x12, 0x13, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x61, 0x72,
0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x6c, 0x75, 0x72, 0x65,
0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x30, 0x0a, 0x06, 0x47, 0x65, 0x74, 0x50, 0x6b, 0x67, 0x12, 0x17, 0x2e, 0x6c, 0x75, 0x72, 0x65,
0x2e, 0x47, 0x65, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x0d, 0x2e, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67,
0x65, 0x42, 0x0f, 0x5a, 0x0d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x61,
0x70, 0x69, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
@ -997,7 +1060,7 @@ func file_lure_proto_rawDescGZIP() []byte {
}
var file_lure_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_lure_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_lure_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_lure_proto_goTypes = []interface{}{
(SORT_BY)(0), // 0: lure.SORT_BY
(FILTER_TYPE)(0), // 1: lure.FILTER_TYPE
@ -1011,16 +1074,17 @@ var file_lure_proto_goTypes = []interface{}{
(*SearchRequest)(nil), // 9: lure.SearchRequest
(*StringList)(nil), // 10: lure.StringList
(*Package)(nil), // 11: lure.Package
(*SearchResponse)(nil), // 12: lure.SearchResponse
nil, // 13: lure.Package.DependsEntry
nil, // 14: lure.Package.BuildDependsEntry
(*GetPackageRequest)(nil), // 12: lure.GetPackageRequest
(*SearchResponse)(nil), // 13: lure.SearchResponse
nil, // 14: lure.Package.DependsEntry
nil, // 15: lure.Package.BuildDependsEntry
}
var file_lure_proto_depIdxs = []int32{
3, // 0: lure.GetCommentsResponse.comments:type_name -> lure.Comment
0, // 1: lure.SearchRequest.sort_by:type_name -> lure.SORT_BY
1, // 2: lure.SearchRequest.filter_type:type_name -> lure.FILTER_TYPE
13, // 3: lure.Package.depends:type_name -> lure.Package.DependsEntry
14, // 4: lure.Package.build_depends:type_name -> lure.Package.BuildDependsEntry
14, // 3: lure.Package.depends:type_name -> lure.Package.DependsEntry
15, // 4: lure.Package.build_depends:type_name -> lure.Package.BuildDependsEntry
11, // 5: lure.SearchResponse.packages:type_name -> lure.Package
10, // 6: lure.Package.DependsEntry.value:type_name -> lure.StringList
10, // 7: lure.Package.BuildDependsEntry.value:type_name -> lure.StringList
@ -1028,12 +1092,14 @@ var file_lure_proto_depIdxs = []int32{
6, // 9: lure.API.EditComment:input_type -> lure.EditCommentRequest
7, // 10: lure.API.GetComments:input_type -> lure.GetCommentsRequest
9, // 11: lure.API.Search:input_type -> lure.SearchRequest
5, // 12: lure.API.CreateComment:output_type -> lure.CreateCommentResponse
2, // 13: lure.API.EditComment:output_type -> lure.EmptyResponse
8, // 14: lure.API.GetComments:output_type -> lure.GetCommentsResponse
12, // 15: lure.API.Search:output_type -> lure.SearchResponse
12, // [12:16] is the sub-list for method output_type
8, // [8:12] is the sub-list for method input_type
12, // 12: lure.API.GetPkg:input_type -> lure.GetPackageRequest
5, // 13: lure.API.CreateComment:output_type -> lure.CreateCommentResponse
2, // 14: lure.API.EditComment:output_type -> lure.EmptyResponse
8, // 15: lure.API.GetComments:output_type -> lure.GetCommentsResponse
13, // 16: lure.API.Search:output_type -> lure.SearchResponse
11, // 17: lure.API.GetPkg:output_type -> lure.Package
13, // [13:18] is the sub-list for method output_type
8, // [8:13] is the sub-list for method input_type
8, // [8:8] is the sub-list for extension type_name
8, // [8:8] is the sub-list for extension extendee
0, // [0:8] is the sub-list for field type_name
@ -1166,6 +1232,18 @@ func file_lure_proto_init() {
}
}
file_lure_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetPackageRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_lure_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SearchResponse); i {
case 0:
return &v.state
@ -1186,7 +1264,7 @@ func file_lure_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_lure_proto_rawDesc,
NumEnums: 2,
NumMessages: 13,
NumMessages: 14,
NumExtensions: 0,
NumServices: 1,
},

412
cmd/lure-api/internal/api/lure.twirp.go
View File

@ -44,6 +44,9 @@ type API interface {
// Search searches through LURE packages in the database
Search(context.Context, *SearchRequest) (*SearchResponse, error)
// GetPkg gets a single LURE package from the database
GetPkg(context.Context, *GetPackageRequest) (*Package, error)
}
// ===================
@ -52,7 +55,7 @@ type API interface {
type aPIProtobufClient struct {
client HTTPClient
urls [4]string
urls [5]string
interceptor twirp.Interceptor
opts twirp.ClientOptions
}
@ -80,11 +83,12 @@ func NewAPIProtobufClient(baseURL string, client HTTPClient, opts ...twirp.Clien
// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
serviceURL := sanitizeBaseURL(baseURL)
serviceURL += baseServicePath(pathPrefix, "lure", "API")
urls := [4]string{
urls := [5]string{
serviceURL + "CreateComment",
serviceURL + "EditComment",
serviceURL + "GetComments",
serviceURL + "Search",
serviceURL + "GetPkg",
}
return &aPIProtobufClient{
@ -279,13 +283,59 @@ func (c *aPIProtobufClient) callSearch(ctx context.Context, in *SearchRequest) (
return out, nil
}
func (c *aPIProtobufClient) GetPkg(ctx context.Context, in *GetPackageRequest) (*Package, error) {
ctx = ctxsetters.WithPackageName(ctx, "lure")
ctx = ctxsetters.WithServiceName(ctx, "API")
ctx = ctxsetters.WithMethodName(ctx, "GetPkg")
caller := c.callGetPkg
if c.interceptor != nil {
caller = func(ctx context.Context, req *GetPackageRequest) (*Package, error) {
resp, err := c.interceptor(
func(ctx context.Context, req interface{}) (interface{}, error) {
typedReq, ok := req.(*GetPackageRequest)
if !ok {
return nil, twirp.InternalError("failed type assertion req.(*GetPackageRequest) when calling interceptor")
}
return c.callGetPkg(ctx, typedReq)
},
)(ctx, req)
if resp != nil {
typedResp, ok := resp.(*Package)
if !ok {
return nil, twirp.InternalError("failed type assertion resp.(*Package) when calling interceptor")
}
return typedResp, err
}
return nil, err
}
}
return caller(ctx, in)
}
func (c *aPIProtobufClient) callGetPkg(ctx context.Context, in *GetPackageRequest) (*Package, error) {
out := new(Package)
ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
if err != nil {
twerr, ok := err.(twirp.Error)
if !ok {
twerr = twirp.InternalErrorWith(err)
}
callClientError(ctx, c.opts.Hooks, twerr)
return nil, err
}
callClientResponseReceived(ctx, c.opts.Hooks)
return out, nil
}
// ===============
// API JSON Client
// ===============
type aPIJSONClient struct {
client HTTPClient
urls [4]string
urls [5]string
interceptor twirp.Interceptor
opts twirp.ClientOptions
}
@ -313,11 +363,12 @@ func NewAPIJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOpt
// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
serviceURL := sanitizeBaseURL(baseURL)
serviceURL += baseServicePath(pathPrefix, "lure", "API")
urls := [4]string{
urls := [5]string{
serviceURL + "CreateComment",
serviceURL + "EditComment",
serviceURL + "GetComments",
serviceURL + "Search",
serviceURL + "GetPkg",
}
return &aPIJSONClient{
@ -512,6 +563,52 @@ func (c *aPIJSONClient) callSearch(ctx context.Context, in *SearchRequest) (*Sea
return out, nil
}
func (c *aPIJSONClient) GetPkg(ctx context.Context, in *GetPackageRequest) (*Package, error) {
ctx = ctxsetters.WithPackageName(ctx, "lure")
ctx = ctxsetters.WithServiceName(ctx, "API")
ctx = ctxsetters.WithMethodName(ctx, "GetPkg")
caller := c.callGetPkg
if c.interceptor != nil {
caller = func(ctx context.Context, req *GetPackageRequest) (*Package, error) {
resp, err := c.interceptor(
func(ctx context.Context, req interface{}) (interface{}, error) {
typedReq, ok := req.(*GetPackageRequest)
if !ok {
return nil, twirp.InternalError("failed type assertion req.(*GetPackageRequest) when calling interceptor")
}
return c.callGetPkg(ctx, typedReq)
},
)(ctx, req)
if resp != nil {
typedResp, ok := resp.(*Package)
if !ok {
return nil, twirp.InternalError("failed type assertion resp.(*Package) when calling interceptor")
}
return typedResp, err
}
return nil, err
}
}
return caller(ctx, in)
}
func (c *aPIJSONClient) callGetPkg(ctx context.Context, in *GetPackageRequest) (*Package, error) {
out := new(Package)
ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
if err != nil {
twerr, ok := err.(twirp.Error)
if !ok {
twerr = twirp.InternalErrorWith(err)
}
callClientError(ctx, c.opts.Hooks, twerr)
return nil, err
}
callClientResponseReceived(ctx, c.opts.Hooks)
return out, nil
}
// ==================
// API Server Handler
// ==================
@ -621,6 +718,9 @@ func (s *aPIServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
case "Search":
s.serveSearch(ctx, resp, req)
return
case "GetPkg":
s.serveGetPkg(ctx, resp, req)
return
default:
msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
@ -1348,6 +1448,186 @@ func (s *aPIServer) serveSearchProtobuf(ctx context.Context, resp http.ResponseW
callResponseSent(ctx, s.hooks)
}
func (s *aPIServer) serveGetPkg(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
header := req.Header.Get("Content-Type")
i := strings.Index(header, ";")
if i == -1 {
i = len(header)
}
switch strings.TrimSpace(strings.ToLower(header[:i])) {
case "application/json":
s.serveGetPkgJSON(ctx, resp, req)
case "application/protobuf":
s.serveGetPkgProtobuf(ctx, resp, req)
default:
msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
twerr := badRouteError(msg, req.Method, req.URL.Path)
s.writeError(ctx, resp, twerr)
}
}
func (s *aPIServer) serveGetPkgJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
var err error
ctx = ctxsetters.WithMethodName(ctx, "GetPkg")
ctx, err = callRequestRouted(ctx, s.hooks)
if err != nil {
s.writeError(ctx, resp, err)
return
}
d := json.NewDecoder(req.Body)
rawReqBody := json.RawMessage{}
if err := d.Decode(&rawReqBody); err != nil {
s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
return
}
reqContent := new(GetPackageRequest)
unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
return
}
handler := s.API.GetPkg
if s.interceptor != nil {
handler = func(ctx context.Context, req *GetPackageRequest) (*Package, error) {
resp, err := s.interceptor(
func(ctx context.Context, req interface{}) (interface{}, error) {
typedReq, ok := req.(*GetPackageRequest)
if !ok {
return nil, twirp.InternalError("failed type assertion req.(*GetPackageRequest) when calling interceptor")
}
return s.API.GetPkg(ctx, typedReq)
},
)(ctx, req)
if resp != nil {
typedResp, ok := resp.(*Package)
if !ok {
return nil, twirp.InternalError("failed type assertion resp.(*Package) when calling interceptor")
}
return typedResp, err
}
return nil, err
}
}
// Call service method
var respContent *Package
func() {
defer ensurePanicResponses(ctx, resp, s.hooks)
respContent, err = handler(ctx, reqContent)
}()
if err != nil {
s.writeError(ctx, resp, err)
return
}
if respContent == nil {
s.writeError(ctx, resp, twirp.InternalError("received a nil *Package and nil error while calling GetPkg. nil responses are not supported"))
return
}
ctx = callResponsePrepared(ctx, s.hooks)
marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
respBytes, err := marshaler.Marshal(respContent)
if err != nil {
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
return
}
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
resp.Header().Set("Content-Type", "application/json")
resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
resp.WriteHeader(http.StatusOK)
if n, err := resp.Write(respBytes); err != nil {
msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
twerr := twirp.NewError(twirp.Unknown, msg)
ctx = callError(ctx, s.hooks, twerr)
}
callResponseSent(ctx, s.hooks)
}
func (s *aPIServer) serveGetPkgProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
var err error
ctx = ctxsetters.WithMethodName(ctx, "GetPkg")
ctx, err = callRequestRouted(ctx, s.hooks)
if err != nil {
s.writeError(ctx, resp, err)
return
}
buf, err := io.ReadAll(req.Body)
if err != nil {
s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
return
}
reqContent := new(GetPackageRequest)
if err = proto.Unmarshal(buf, reqContent); err != nil {
s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
return
}
handler := s.API.GetPkg
if s.interceptor != nil {
handler = func(ctx context.Context, req *GetPackageRequest) (*Package, error) {
resp, err := s.interceptor(
func(ctx context.Context, req interface{}) (interface{}, error) {
typedReq, ok := req.(*GetPackageRequest)
if !ok {
return nil, twirp.InternalError("failed type assertion req.(*GetPackageRequest) when calling interceptor")
}
return s.API.GetPkg(ctx, typedReq)
},
)(ctx, req)
if resp != nil {
typedResp, ok := resp.(*Package)
if !ok {
return nil, twirp.InternalError("failed type assertion resp.(*Package) when calling interceptor")
}
return typedResp, err
}
return nil, err
}
}
// Call service method
var respContent *Package
func() {
defer ensurePanicResponses(ctx, resp, s.hooks)
respContent, err = handler(ctx, reqContent)
}()
if err != nil {
s.writeError(ctx, resp, err)
return
}
if respContent == nil {
s.writeError(ctx, resp, twirp.InternalError("received a nil *Package and nil error while calling GetPkg. nil responses are not supported"))
return
}
ctx = callResponsePrepared(ctx, s.hooks)
respBytes, err := proto.Marshal(respContent)
if err != nil {
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
return
}
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
resp.Header().Set("Content-Type", "application/protobuf")
resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
resp.WriteHeader(http.StatusOK)
if n, err := resp.Write(respBytes); err != nil {
msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
twerr := twirp.NewError(twirp.Unknown, msg)
ctx = callError(ctx, s.hooks, twerr)
}
callResponseSent(ctx, s.hooks)
}
func (s *aPIServer) ServiceDescriptor() ([]byte, int) {
return twirpFileDescriptor0, 0
}
@ -1929,65 +2209,67 @@ func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error)
}
var twirpFileDescriptor0 = []byte{
// 949 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0xae, 0x93, 0x26, 0x4e, 0x8e, 0xe3, 0x34, 0x3b, 0x5b, 0x24, 0x37, 0xfc, 0x6c, 0xc9, 0x42,
0x55, 0xf6, 0xa2, 0x2b, 0x65, 0x11, 0x42, 0x80, 0x10, 0x75, 0x1b, 0x68, 0xa4, 0x92, 0x84, 0x49,
0xb6, 0x52, 0xb9, 0xb1, 0x5c, 0xe7, 0x6c, 0x3a, 0xaa, 0xff, 0xd6, 0x33, 0xe9, 0x2a, 0x2f, 0x80,
0x56, 0x3c, 0x1d, 0x0f, 0xc1, 0x83, 0xa0, 0x99, 0xb1, 0x53, 0xa7, 0xad, 0xd8, 0x0b, 0xb8, 0xf3,
0xf9, 0xbe, 0xef, 0xcc, 0x99, 0xf3, 0x33, 0x33, 0x06, 0x08, 0x97, 0x19, 0x1e, 0xa5, 0x59, 0x22,
0x12, 0xb2, 0x2d, 0xbf, 0x7b, 0x3b, 0x60, 0x0f, 0xa2, 0x54, 0xac, 0x28, 0xf2, 0x34, 0x89, 0x39,
0xf6, 0x16, 0x60, 0x9e, 0x24, 0x51, 0x84, 0xb1, 0x20, 0x9f, 0x02, 0x04, 0xfa, 0xd3, 0x63, 0x73,
0xc7, 0xd8, 0x37, 0x0e, 0xab, 0xb4, 0x99, 0x23, 0xc3, 0x39, 0xf9, 0x1c, 0x5a, 0x82, 0x45, 0xe8,
0x05, 0x19, 0xfa, 0x02, 0xe7, 0x4e, 0x45, 0x09, 0x2c, 0x89, 0x9d, 0x68, 0x88, 0x74, 0xa1, 0x11,
0x24, 0xb1, 0xc0, 0x58, 0x70, 0xa7, 0xba, 0x6f, 0x1c, 0x36, 0xe9, 0xda, 0xee, 0x45, 0xb0, 0xab,
0x65, 0x79, 0x38, 0x8a, 0x6f, 0x97, 0xc8, 0x05, 0xf9, 0x0c, 0x20, 0xc3, 0x34, 0xe1, 0x4c, 0x24,
0xd9, 0x4a, 0x45, 0x6d, 0xd2, 0x12, 0x42, 0xf6, 0xa0, 0x91, 0xde, 0x2c, 0xbc, 0xd8, 0x8f, 0x50,
0x85, 0x6c, 0x52, 0x33, 0xbd, 0x59, 0x8c, 0xfc, 0x08, 0xff, 0x35, 0xdc, 0x37, 0xf0, 0xd1, 0xbd,
0x70, 0x3a, 0xe1, 0x0f, 0x64, 0xd9, 0xbb, 0x00, 0x32, 0x98, 0x33, 0x71, 0x6f, 0x93, 0x1f, 0x2e,
0x4d, 0x8c, 0xef, 0xbc, 0xf5, 0x66, 0xf4, 0x3e, 0xad, 0x18, 0xdf, 0x9d, 0x14, 0xfb, 0xf9, 0xd3,
0x00, 0xf2, 0x0b, 0x16, 0xeb, 0xf2, 0xff, 0x21, 0xfb, 0xe7, 0x60, 0xe7, 0xad, 0xf0, 0x38, 0x8b,
0x03, 0x54, 0x25, 0xa8, 0xd2, 0x56, 0x0e, 0x4e, 0x25, 0x46, 0x76, 0xa1, 0x16, 0xb2, 0x88, 0x09,
0x67, 0x5b, 0x91, 0xda, 0xe8, 0xfd, 0x04, 0x4f, 0x37, 0xf6, 0x92, 0x97, 0xe6, 0x2b, 0x59, 0x4f,
0x8d, 0x39, 0xc6, 0x7e, 0xf5, 0xd0, 0xea, 0xdb, 0x47, 0x6a, 0x82, 0x8a, 0x6a, 0xac, 0xe9, 0xde,
0x5f, 0x06, 0xd8, 0x53, 0xf4, 0xb3, 0xe0, 0xba, 0xc8, 0x64, 0x17, 0x6a, 0x6f, 0x97, 0xb8, 0x4e,
0x42, 0x1b, 0x77, 0xf1, 0x2b, 0xa5, 0xf8, 0xe4, 0x00, 0x4c, 0x9e, 0x64, 0xc2, 0xbb, 0x5a, 0xa9,
0x4d, 0xb7, 0x8b, 0x38, 0xd3, 0x31, 0x9d, 0x79, 0xee, 0x25, 0xad, 0x4b, 0xd6, 0x5d, 0x91, 0x3e,
0x58, 0x6f, 0x58, 0x28, 0x30, 0xf3, 0xc4, 0x2a, 0x45, 0x95, 0x43, 0xbb, 0xff, 0x44, 0x6b, 0x7f,
0x1e, 0x9e, 0xcf, 0x06, 0xd4, 0x9b, 0x5d, 0x4e, 0x06, 0x14, 0xb4, 0x6a, 0xb6, 0x4a, 0x91, 0x1c,
0x40, 0x2b, 0xf7, 0xb9, 0xf5, 0xc3, 0x25, 0x3a, 0x35, 0xb9, 0x9d, 0xb3, 0x2d, 0x9a, 0xaf, 0x74,
0x21, 0xc1, 0xf7, 0x86, 0xe1, 0xee, 0x80, 0xed, 0x95, 0x85, 0xbd, 0x03, 0x80, 0xa9, 0xc8, 0x58,
0xbc, 0x38, 0x67, 0x5c, 0x10, 0x07, 0x4c, 0x8c, 0x45, 0xc6, 0x50, 0x97, 0xa2, 0x49, 0x0b, 0xb3,
0xf7, 0x77, 0x0d, 0xcc, 0x89, 0x1f, 0xdc, 0xf8, 0x0b, 0x24, 0x04, 0xb6, 0x55, 0x6b, 0x74, 0xce,
0xea, 0xfb, 0x5e, 0x4b, 0x2b, 0x0f, 0x5a, 0xea, 0x80, 0x79, 0x8b, 0x19, 0x67, 0x49, 0x9c, 0x0f,
0x6d, 0x61, 0x4a, 0x26, 0xc3, 0x10, 0x7d, 0x8e, 0x79, 0xbb, 0x0a, 0x93, 0xec, 0x41, 0x0d, 0xd3,
0x24, 0xb8, 0x56, 0xd9, 0x54, 0xcf, 0xb6, 0xa8, 0x36, 0xdf, 0x1b, 0x06, 0xf9, 0x12, 0xac, 0x39,
0xf2, 0x20, 0x63, 0xa9, 0x90, 0x4b, 0xd6, 0x55, 0xba, 0x06, 0x2d, 0x83, 0x52, 0xf6, 0x0c, 0x1a,
0xd7, 0x49, 0x84, 0xa9, 0xbf, 0x40, 0xc7, 0x54, 0x9a, 0x0a, 0x5d, 0x23, 0x52, 0xf0, 0x1c, 0x20,
0xf2, 0x59, 0x2c, 0x7c, 0x16, 0x63, 0xe6, 0x34, 0x94, 0xa4, 0x4a, 0x4b, 0x98, 0x14, 0x7d, 0x01,
0xb6, 0xec, 0x39, 0x13, 0x18, 0x88, 0x65, 0x86, 0xdc, 0x69, 0xaa, 0xda, 0x6c, 0x82, 0xf2, 0x5c,
0x86, 0x2c, 0xc0, 0x98, 0x23, 0x77, 0x40, 0x09, 0xd6, 0xb6, 0xe4, 0xd2, 0x2c, 0xb9, 0x65, 0x73,
0xe4, 0x8e, 0xa5, 0xb9, 0xc2, 0x26, 0x9f, 0x40, 0x33, 0x48, 0xe2, 0x37, 0x21, 0x0b, 0x04, 0x77,
0x5a, 0x8a, 0xbc, 0x03, 0xa4, 0x67, 0x86, 0x69, 0xe8, 0x07, 0xc8, 0x1d, 0x5b, 0x7b, 0x16, 0x36,
0xf9, 0x1a, 0xcc, 0x39, 0xa6, 0x18, 0xcf, 0xb9, 0xd3, 0x56, 0x83, 0xdb, 0xd5, 0x43, 0x92, 0xf7,
0xe9, 0xe8, 0x54, 0x93, 0x83, 0x58, 0x64, 0x2b, 0x5a, 0x48, 0xc9, 0x29, 0xd8, 0x57, 0x4b, 0x16,
0xce, 0xbd, 0xc2, 0x77, 0x47, 0xf9, 0x3e, 0xdb, 0xf4, 0x75, 0xa5, 0x64, 0x63, 0x81, 0xd6, 0x55,
0x09, 0xea, 0x9e, 0x43, 0xab, 0xcc, 0x92, 0x0e, 0x54, 0x6f, 0xb0, 0x38, 0x06, 0xf2, 0x93, 0x1c,
0x40, 0x4d, 0xcf, 0xa2, 0x1c, 0x06, 0xab, 0xdf, 0xc9, 0x87, 0x7d, 0x3d, 0x6c, 0x54, 0xd3, 0xdf,
0x55, 0xbe, 0x35, 0xba, 0xbf, 0xc1, 0x93, 0x07, 0x01, 0xff, 0xdb, 0x92, 0x6e, 0x03, 0xea, 0x9e,
0x1a, 0x17, 0xb7, 0x0d, 0x2d, 0xaf, 0x34, 0x17, 0xae, 0x05, 0x4d, 0xaf, 0x98, 0x01, 0xd7, 0x06,
0xcb, 0xbb, 0xeb, 0x76, 0xef, 0x7b, 0x68, 0x17, 0x07, 0xfc, 0xee, 0x7a, 0x48, 0x75, 0x4d, 0xee,
0x5d, 0x0f, 0x79, 0xa5, 0xe8, 0x9a, 0x7e, 0xf1, 0x23, 0x98, 0xf9, 0x59, 0x26, 0x2d, 0x68, 0xbc,
0x1e, 0x49, 0x63, 0x70, 0xda, 0xd9, 0x22, 0x0d, 0xd8, 0x1e, 0x1d, 0xff, 0x3a, 0xe8, 0x18, 0xa4,
0x0d, 0x40, 0x07, 0x93, 0xf1, 0x74, 0x38, 0x1b, 0xd3, 0xcb, 0x4e, 0x85, 0x58, 0x60, 0x5e, 0x0c,
0xe8, 0x74, 0x38, 0x1e, 0x75, 0xaa, 0x2f, 0x5c, 0xb0, 0x4a, 0xe7, 0x9b, 0xd8, 0xd0, 0x1c, 0x8d,
0x3d, 0x8d, 0x74, 0xb6, 0xc8, 0x13, 0xb0, 0x87, 0x23, 0xaf, 0xe4, 0x6d, 0x48, 0x68, 0xfa, 0x7a,
0x32, 0x19, 0xd3, 0xd9, 0xd4, 0x3b, 0xa6, 0x27, 0x67, 0x9d, 0x4a, 0xff, 0x8f, 0x0a, 0x54, 0x8f,
0x27, 0x43, 0x72, 0x06, 0xf6, 0xc6, 0x4b, 0x40, 0xf2, 0xd9, 0x78, 0xec, 0x35, 0xea, 0x7e, 0xfc,
0x28, 0x97, 0x17, 0xe0, 0x07, 0xb0, 0x4a, 0x6f, 0x03, 0x71, 0xb4, 0xf6, 0xe1, 0x73, 0xd1, 0x7d,
0x9a, 0x33, 0xe5, 0x97, 0x96, 0xb8, 0x60, 0x95, 0x2e, 0xdd, 0xc2, 0xfb, 0xe1, 0x9b, 0xd0, 0xdd,
0x7b, 0x84, 0xc9, 0xd7, 0x78, 0x05, 0x75, 0xdd, 0x14, 0x92, 0x87, 0xd8, 0xb8, 0x83, 0xbb, 0xbb,
0x9b, 0xa0, 0x76, 0x72, 0x77, 0x7e, 0xb7, 0x5f, 0xb2, 0x58, 0x60, 0x16, 0xfb, 0xe1, 0x4b, 0x3f,
0x65, 0x57, 0x75, 0xf5, 0x47, 0xf0, 0xea, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x30, 0x56, 0x9a,
0xc2, 0x1f, 0x08, 0x00, 0x00,
// 978 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xef, 0x6e, 0xe3, 0x44,
0x10, 0xaf, 0x93, 0x26, 0x4e, 0xc6, 0x71, 0x9a, 0xee, 0x15, 0xe1, 0x86, 0x3f, 0x57, 0x7c, 0x50,
0x95, 0xfb, 0xd0, 0x43, 0x3d, 0x84, 0x10, 0x20, 0x44, 0xdd, 0x86, 0x36, 0x52, 0x49, 0xc2, 0x26,
0x57, 0xa9, 0x7c, 0xb1, 0x5c, 0x67, 0x2e, 0x5d, 0xc5, 0xff, 0xce, 0xde, 0xf4, 0x94, 0x37, 0x38,
0xf1, 0x44, 0x3c, 0x06, 0x0f, 0xc1, 0x83, 0xa0, 0xdd, 0xb5, 0x53, 0xa7, 0xad, 0x38, 0x09, 0xf8,
0xb6, 0xf3, 0x9b, 0x7f, 0x3b, 0x33, 0x3f, 0xcf, 0x1a, 0x20, 0x58, 0xa4, 0x78, 0x98, 0xa4, 0x31,
0x8f, 0xc9, 0xa6, 0x38, 0xdb, 0x5b, 0x60, 0xf6, 0xc2, 0x84, 0x2f, 0x29, 0x66, 0x49, 0x1c, 0x65,
0x68, 0xcf, 0x40, 0x3f, 0x89, 0xc3, 0x10, 0x23, 0x4e, 0x3e, 0x01, 0xf0, 0xd5, 0xd1, 0x65, 0x53,
0x4b, 0xdb, 0xd3, 0x0e, 0xaa, 0xb4, 0x99, 0x23, 0xfd, 0x29, 0xf9, 0x0c, 0x5a, 0x9c, 0x85, 0xe8,
0xfa, 0x29, 0x7a, 0x1c, 0xa7, 0x56, 0x45, 0x1a, 0x18, 0x02, 0x3b, 0x51, 0x10, 0xe9, 0x42, 0xc3,
0x8f, 0x23, 0x8e, 0x11, 0xcf, 0xac, 0xea, 0x9e, 0x76, 0xd0, 0xa4, 0x2b, 0xd9, 0x0e, 0x61, 0x47,
0x99, 0xe5, 0xe9, 0x28, 0xbe, 0x59, 0x60, 0xc6, 0xc9, 0xa7, 0x00, 0x29, 0x26, 0x71, 0xc6, 0x78,
0x9c, 0x2e, 0x65, 0xd6, 0x26, 0x2d, 0x21, 0x64, 0x17, 0x1a, 0xc9, 0x7c, 0xe6, 0x46, 0x5e, 0x88,
0x32, 0x65, 0x93, 0xea, 0xc9, 0x7c, 0x36, 0xf0, 0x42, 0xfc, 0xc7, 0x74, 0xdf, 0xc0, 0x07, 0xf7,
0xd2, 0xa9, 0x82, 0xdf, 0x53, 0xa5, 0x7d, 0x09, 0xa4, 0x37, 0x65, 0xfc, 0xde, 0x25, 0xdf, 0xdf,
0x9a, 0x08, 0xdf, 0xba, 0xab, 0xcb, 0xa8, 0x7b, 0x1a, 0x11, 0xbe, 0x3d, 0x29, 0xee, 0xf3, 0xbb,
0x06, 0xe4, 0x0c, 0x8b, 0xb8, 0xd9, 0xff, 0x50, 0xfd, 0x33, 0x30, 0xf3, 0x51, 0xb8, 0x19, 0x8b,
0x7c, 0x94, 0x2d, 0xa8, 0xd2, 0x56, 0x0e, 0x8e, 0x05, 0x46, 0x76, 0xa0, 0x16, 0xb0, 0x90, 0x71,
0x6b, 0x53, 0x2a, 0x95, 0x60, 0xff, 0x04, 0x4f, 0xd6, 0xee, 0x92, 0xb7, 0xe6, 0x4b, 0xd1, 0x4f,
0x85, 0x59, 0xda, 0x5e, 0xf5, 0xc0, 0x38, 0x32, 0x0f, 0x25, 0x83, 0x8a, 0x6e, 0xac, 0xd4, 0xf6,
0x9f, 0x1a, 0x98, 0x63, 0xf4, 0x52, 0xff, 0xa6, 0xa8, 0x64, 0x07, 0x6a, 0x6f, 0x16, 0xb8, 0x2a,
0x42, 0x09, 0x77, 0xf9, 0x2b, 0xa5, 0xfc, 0x64, 0x1f, 0xf4, 0x2c, 0x4e, 0xb9, 0x7b, 0xbd, 0x94,
0x97, 0x6e, 0x17, 0x79, 0xc6, 0x43, 0x3a, 0x71, 0x9d, 0x2b, 0x5a, 0x17, 0x5a, 0x67, 0x49, 0x8e,
0xc0, 0x78, 0xcd, 0x02, 0x8e, 0xa9, 0xcb, 0x97, 0x09, 0xca, 0x1a, 0xda, 0x47, 0xdb, 0xca, 0xf6,
0xe7, 0xfe, 0xc5, 0xa4, 0x47, 0xdd, 0xc9, 0xd5, 0xa8, 0x47, 0x41, 0x59, 0x4d, 0x96, 0x09, 0x92,
0x7d, 0x68, 0xe5, 0x3e, 0xb7, 0x5e, 0xb0, 0x40, 0xab, 0x26, 0xae, 0x73, 0xbe, 0x41, 0xf3, 0x48,
0x97, 0x02, 0x7c, 0xa7, 0x69, 0xce, 0x16, 0x98, 0x6e, 0xd9, 0xd0, 0xde, 0x07, 0x18, 0xf3, 0x94,
0x45, 0xb3, 0x0b, 0x96, 0x71, 0x62, 0x81, 0x8e, 0x11, 0x4f, 0x19, 0xaa, 0x56, 0x34, 0x69, 0x21,
0xda, 0x7f, 0xd5, 0x40, 0x1f, 0x79, 0xfe, 0xdc, 0x9b, 0x21, 0x21, 0xb0, 0x29, 0x47, 0xa3, 0x6a,
0x96, 0xe7, 0x7b, 0x23, 0xad, 0x3c, 0x18, 0xa9, 0x05, 0xfa, 0x2d, 0xa6, 0x19, 0x8b, 0xa3, 0x9c,
0xb4, 0x85, 0x28, 0x34, 0x29, 0x06, 0xe8, 0x65, 0x98, 0x8f, 0xab, 0x10, 0xc9, 0x2e, 0xd4, 0x30,
0x89, 0xfd, 0x1b, 0x59, 0x4d, 0xf5, 0x7c, 0x83, 0x2a, 0xf1, 0x9d, 0xa6, 0x91, 0x2f, 0xc0, 0x98,
0x62, 0xe6, 0xa7, 0x2c, 0xe1, 0x22, 0x64, 0x5d, 0x96, 0xab, 0xd1, 0x32, 0x28, 0xcc, 0x9e, 0x42,
0xe3, 0x26, 0x0e, 0x31, 0xf1, 0x66, 0x68, 0xe9, 0xd2, 0xa6, 0x42, 0x57, 0x88, 0x30, 0x78, 0x06,
0x10, 0x7a, 0x2c, 0xe2, 0x1e, 0x8b, 0x30, 0xb5, 0x1a, 0xd2, 0xa4, 0x4a, 0x4b, 0x98, 0x30, 0xfa,
0x1c, 0x4c, 0x31, 0x73, 0xc6, 0xd1, 0xe7, 0x8b, 0x14, 0x33, 0xab, 0x29, 0x7b, 0xb3, 0x0e, 0x8a,
0xef, 0x32, 0x60, 0x3e, 0x46, 0x19, 0x66, 0x16, 0x48, 0x83, 0x95, 0x2c, 0x74, 0x49, 0x1a, 0xdf,
0xb2, 0x29, 0x66, 0x96, 0xa1, 0x74, 0x85, 0x4c, 0x3e, 0x86, 0xa6, 0x1f, 0x47, 0xaf, 0x03, 0xe6,
0xf3, 0xcc, 0x6a, 0x49, 0xe5, 0x1d, 0x20, 0x3c, 0x53, 0x4c, 0x02, 0xcf, 0xc7, 0xcc, 0x32, 0x95,
0x67, 0x21, 0x93, 0xaf, 0x41, 0x9f, 0x62, 0x82, 0xd1, 0x34, 0xb3, 0xda, 0x92, 0xb8, 0x5d, 0x45,
0x92, 0x7c, 0x4e, 0x87, 0xa7, 0x4a, 0xd9, 0x8b, 0x78, 0xba, 0xa4, 0x85, 0x29, 0x39, 0x05, 0xf3,
0x7a, 0xc1, 0x82, 0xa9, 0x5b, 0xf8, 0x6e, 0x49, 0xdf, 0xa7, 0xeb, 0xbe, 0x8e, 0x30, 0x59, 0x0b,
0xd0, 0xba, 0x2e, 0x41, 0xdd, 0x0b, 0x68, 0x95, 0xb5, 0xa4, 0x03, 0xd5, 0x39, 0x16, 0x9f, 0x81,
0x38, 0x92, 0x7d, 0xa8, 0x29, 0x2e, 0x0a, 0x32, 0x18, 0x47, 0x9d, 0x9c, 0xec, 0x2b, 0xb2, 0x51,
0xa5, 0xfe, 0xae, 0xf2, 0xad, 0xd6, 0xfd, 0x15, 0xb6, 0x1f, 0x24, 0xfc, 0x6f, 0x21, 0x9d, 0x06,
0xd4, 0x5d, 0x49, 0x17, 0xa7, 0x0d, 0x2d, 0xb7, 0xc4, 0x0b, 0xc7, 0x80, 0xa6, 0x5b, 0x70, 0xc0,
0x31, 0xc1, 0x70, 0xef, 0xa6, 0x6d, 0x9f, 0xc1, 0xf6, 0x19, 0xf2, 0xbc, 0x09, 0xc5, 0x47, 0xfe,
0x2f, 0xf8, 0x6e, 0x7f, 0x0f, 0xed, 0x62, 0x53, 0xdc, 0xed, 0x99, 0x44, 0xc5, 0xbd, 0xb7, 0x67,
0x8a, 0x6c, 0x2b, 0xf5, 0xf3, 0x1f, 0x41, 0xcf, 0x97, 0x02, 0x69, 0x41, 0xe3, 0xd5, 0x40, 0x08,
0xbd, 0xd3, 0xce, 0x06, 0x69, 0xc0, 0xe6, 0xe0, 0xf8, 0x97, 0x5e, 0x47, 0x23, 0x6d, 0x00, 0xda,
0x1b, 0x0d, 0xc7, 0xfd, 0xc9, 0x90, 0x5e, 0x75, 0x2a, 0xc4, 0x00, 0xfd, 0xb2, 0x47, 0xc7, 0xfd,
0xe1, 0xa0, 0x53, 0x7d, 0xee, 0x80, 0x51, 0x5a, 0x14, 0xc4, 0x84, 0xe6, 0x60, 0xe8, 0x2a, 0xa4,
0xb3, 0x41, 0xb6, 0xc1, 0xec, 0x0f, 0xdc, 0x92, 0xb7, 0x26, 0xa0, 0xf1, 0xab, 0xd1, 0x68, 0x48,
0x27, 0x63, 0xf7, 0x98, 0x9e, 0x9c, 0x77, 0x2a, 0x47, 0x7f, 0x54, 0xa0, 0x7a, 0x3c, 0xea, 0x93,
0x73, 0x30, 0xd7, 0x9e, 0x14, 0x92, 0x93, 0xec, 0xb1, 0x67, 0xad, 0xfb, 0xd1, 0xa3, 0xba, 0xbc,
0x01, 0x3f, 0x80, 0x51, 0x7a, 0x64, 0x88, 0xa5, 0x6c, 0x1f, 0xbe, 0x3b, 0xdd, 0x27, 0xb9, 0xa6,
0xfc, 0x64, 0x13, 0x07, 0x8c, 0xd2, 0xf6, 0x2e, 0xbc, 0x1f, 0x3e, 0x2e, 0xdd, 0xdd, 0x47, 0x34,
0x79, 0x8c, 0x97, 0x50, 0x57, 0x43, 0x21, 0x79, 0x8a, 0xb5, 0x65, 0xde, 0xdd, 0x59, 0x07, 0x73,
0xa7, 0xaf, 0xa0, 0x2e, 0x28, 0x31, 0x9f, 0x91, 0x0f, 0x57, 0x91, 0xd7, 0x09, 0xd2, 0x5d, 0x1f,
0xa4, 0xb3, 0xf5, 0x9b, 0xf9, 0x82, 0x45, 0x1c, 0xd3, 0xc8, 0x0b, 0x5e, 0x78, 0x09, 0xbb, 0xae,
0xcb, 0x9f, 0x91, 0x97, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xec, 0xa6, 0x81, 0xb1, 0x9a, 0x08,
0x00, 0x00,
}

7
cmd/lure-api/lure.proto
View File

@ -90,6 +90,11 @@ message Package {
map<string, StringList> build_depends = 15;
}
message GetPackageRequest {
string name = 1;
string repository = 2;
}
// SearchResponse contains returned packages
message SearchResponse {
repeated Package packages = 1;
@ -106,4 +111,6 @@ service API {
// Search searches through LURE packages in the database
rpc Search(SearchRequest) returns (SearchResponse);
// GetPkg gets a single LURE package from the database
rpc GetPkg(GetPackageRequest) returns (Package);
}

13
internal/db/db.go
View File

@ -2,6 +2,7 @@ package db
import (
"github.com/genjidb/genji"
"github.com/genjidb/genji/document"
"github.com/genjidb/genji/types"
)
@ -81,6 +82,18 @@ func GetPkgs(db *genji.DB, where string, args ...any) (*genji.Result, error) {
return stream, nil
}
// GetPkg returns a single package that match the where conditions
func GetPkg(db *genji.DB, where string, args ...any) (*Package, error) {
doc, err := db.QueryDocument("SELECT * FROM pkgs WHERE "+where+"LIMIT 1", args...)
if err != nil {
return nil, err
}
out := &Package{}
err = document.ScanDocument(doc, out)
return out, err
}
// DeletePkgs deletes all packages matching the where conditions
func DeletePkgs(db *genji.DB, where string, args ...any) error {
return db.Exec("DELETE FROM pkgs WHERE "+where, args...)