GitLab Create Editor Group, 17 Aug 2023

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Web IDE Maintainer Onboarding - Aug 2023 2/4

Description

In this session we start pairing on a Web IDE issue:

- https://gitlab.com/gitlab-org/gitlab-web-ide/-/issues/82
- https://gitlab.com/gitlab-org/gitlab-web-ide/-/merge_requests/228

A

B

A

For hopping on the maintainer onboarding for the web ID project um last time, we talked about uh crash course to all the different moving parts of the project, but now we're going to actually pair up on issues which is probably the best way to become more familiar with what reviewing Mrs and um the different components inside the project itself.

A

uh So I have an issue for us to pick up um before I. Do that? Are there any questions or something before we just start pairing on a specific problem?.

C

um Just one question you mentioned there: there was like this component um I I can't remember the name now, but it's like one of the components you wanted to. You know like very quickly go over, so uh will we have the chance to do this thing.

A

Oh man, oh I, completely forgot what my component that I would want to go over, but it's probably one of the packages I think it was mediator, commands yeah.

C

A

I think we're gonna actually run into it, so um nice, but let's just let it naturally come out. As we pair and stuff hey, shakar I knew you were coming. I was like hey.

D

A

D

I had to go uh yeah fedstone from downstairs, so.

A

Oh, it is no problem at all um all right. um Okay, let me share my screen and I'll introduce the issue that will pair on and then um I'll also Drive, um and we can. We can go from there.

A

uh So there is a bug um in the project and I'm, pretty sure I haven't confirmed this, but I'm pretty sure it also failed on the old web ID. uh So this bug I think, has been around a lot longer than we expect, um but uh we gotta fix either way.

A

The situation is uh if I am viewing the project here and I'm, not on a branch but I'm actually on a commit, let's say I'm like here yeah so um and then maybe if I view the file at a specific, commit and then I go to open a web ID. This will blow up.

A

um Oh, why are you complaining I can't open projects? Oh it's already freaking out come on. What do you do?

A

Wow, that's weird, but either way um I'll say if maybe, if, instead of being in the blob uh I'm here in just the tree at the top here and I, go to edit the in the web, ID all right boom yeah, it blows up because we're looking for a branch, because we have a branch picker and we expect to commit to a branch, all sorts of things like that. So we kind of blow up if the user manages to find themselves opening the web ID with a ref. That is not a branch.

A

So, um what's the desired Behavior would be I think the first the would either we can improve the error message, but I think we can do more than that. I think there's nothing preventing us from bloating everything up other than right. Now we are just looking for branch names, but maybe if something isn't a branch and is still like a ref, we can somehow flag it that we are in a in a ref. That's not a branch yet.

B

So that's the idea.

A

uh Does that kind of make sense kind of what we're hoping to achieve accomplish make it make? This seem seamless how.

D

Do you, how do you pass the draft today to the so because you need to pass the current draft somehow to the web. Ide rate? Is that something that you passes parameters into the iframe so that it knows where it.

A

Is yep yep? That's a really great question, so let me open up. uh Let me open up the web ID project so talking about so clearly. The ref is a URL parameter here that gets consumed by the IDE controller in the rails project, um but the way it gets passed into the web ID project, all of that communication of from rails into this project.

A

um That's in this main entry point in the web ID package when we start the thing and it takes one glorious config file, so this glorious config file, here's um the client only config contains ref yeah.

A

What branch are we trying to open up here? Well, not just a branch. Clearly there is an assumption made here.

C

A

um Yeah yep yeah, so we get this in this config uh and this gets initially handed off into our entry point. And then the config gets serialized into the iframe that we make and then that thing that bootstraps vs code can um take the config and do certain things with it.

D

And then how does that? Finally, the uh so so this then passes it onto the iframe URL or or does it do like a post message to pass it? How does it like it's.

A

A good question so I think right now um we are yeah, we're just we're just hard coding into the iframe itself and then we parse it out.

A

D

So it just goes into the iframe, so the iframe on load has access to that config, um okay and then in within the web, IDE loads up in the iframe, and then it reads that config presumably and then it needs to pass like the ref or whatever to the git provider right. So it needs to go. Tell the git provider hey here's, the ref, that you need to like check out yeah and yeah.

A

Yep, so let's look at: um let's look at the so the package that bootstrap is such a bad verb for this, but it's the one that's committed into the project, the one that bootstraps vs code and everything that picks up the config and kicks things off. Let's see how it uses utils.

D

And bootstrap are the most overused I know.

A

I know I know um just as long I'm just glad it's not called the vs code, bootstrap manager, manager.

D

Or factory or something I know.

A

um So the um the entry points to the iframe, which is this- we probably should call this Frame or something like this- is this- is the entry point of that whole iframe, that um that gets the config from the Dom and then it starts up. We have two flavors of the web ID that will start up. One flavor is the full web ID, the other is remote development thing and Chicago. You might be able to provide insight into this, but something tells me we can actually get rid of the remote development stuff.

A

That's our old, remote development implementation, because now that we have workspaces uh like.

D

Yeah I suspect so like I, I, gotta.

A

Talk we gotta talk to Eric about it, but like so history is that there were two ways the web ID could start up. One was a fully connected. Vs code was connected to some sort of vs code server that the user entered some parameters to and that's any time you see remote versus client. Only that split that differentiating thing is, but now that we actually have a um more robust remote development offering I, don't think we actually need this, but anyways.

A

That's why we have names like remote and client only existing in the code base, but for all intents and purposes we're really only interested in client only uh and that takes the Glorious config and the way it uses. This is when we set up some of the vs code, workbench options, but then it also uses it for.

A

What does it also use it for? ah Yes? Yes, yes, yes uses it for this thing where we create commands. So this is that really this is that weird package I was wanting to dive into create commands comes from um these vs code, mediator commands so right now we are inside of iframe context and for all of this to work seamlessly, we needed a way for when I'm inside an extension. I want to seamlessly be able to assume authentication from the session context, even though extensions run in this sandbox environment.

A

So the way I stumbled upon um an edge to solving this problem was vs code allows me to create a set of commands when I start out vs code that can be hit from any sandboxed extension.

A

So normally an extension declares its own commands and extensions all run inside a Sandbox environment for security reasons, so that extensions don't bump into each other or steal user, Secrets or whatever, like that.

A

Since we're not connected to the extension Marketplace and our main priority was we want a seamless authentication experience um using commands that run in this iframe context. Naturally, inheriting the cookie session and stuff like that, seemed like a um good first iteration to creating a seamless environment, so these mediator commands are different than normal commands that an extension would declare uh these mediator.

A

Commands are commands that need to inherit the users session context, and so all of our, like API requests, go through these mediator commands and so the extensions, the extension project will ref import these um command IDs.

A

And that's how it'll interface with these mediator commands and then this is where we're declaring all these mediator commands.

A

um So some more history around all this is uh it's a kind of viewed mediator, commands as a necessary evil and hadn't thought a whole lot about it. um I had try to create only when we needed a very specific command, that's when we would have it, and so we have. You know things like start and that is kind of the entry point for starting up pulling the context that we need and all sorts of stuff, and we can see where this thing gets called.

A

But since then um now especially now that we're integrating the workflow gitlab workflow extension, the our main desktop vs code extension to being web ID aware, we don't want to have um mediator, commands that do a lot, and so, instead, uh we've introduced this. This batch from API that takes in a request, object and knows how to execute and return it, and this is kind of in retrospect what I wish the mediator commands only did, but um for some security reasons we were thinking of not doing it this way, but yeah.

A

That's all I'm going to say about from that. um Does anyone have any questions about mediator commands as we're talking about this.

B

I'm curious so for the mediator commands package: are we documenting that API? Is it going to be supported, or is this package only ever used from the web ID only.

A

Ever used for the web ID, this is a good question yeah. This is only ever used internally, uh so let me see if I can find um yeah so here inside this, the vs code extension web ID package um inside of here. uh This is where we're actually calling the um start mediator command so start is coming from I wrapped. All these mediator command calls into nice little piped uh versions of that executed, the generic execute command function.

A

um So it's only this package that really consumes it, with the exception of the mediator, commands that the workflow extension needs, and so that's where the interop package comes in of that's our file of um a shared interface that we've agreed upon for this web ID project and the vs code extension project, but for just the web ID. This is the internal web ID. That extension, that's the engine of everything that creates the file system and the source control and kicks everything off, so it references.

A

This start mediator, command, passing into start uh a possible ref that we're starting with, and so that's kind of where we need to start is in this start mediator command and we can jump into there and see all the things that it's doing we can see from here. We get this thing, which is a start response that includes a whole bunch of goodies like the large list of files. What branch we're on, if we're on a merge requests?

A

What are the user's permissions and and we we make decisions from this extension context based on all of that stuff, but all of this stuff requires user session context. So that's why we have to go through. We had to go through mediator, command students.

D

So the start command um so that that's the media recommend that actually, what bootstraps, the or figures out, what the user's token is and stuff like that to actually make calls or what is it? That's.

A

A great question so start is a bad name for it. This is not a like in retrospect. All of this, probably we would have done it differently and we are going to refactor and do it differently, but start is- um and maybe this is also just inherited from the old web ID. But it's like.

A

um All of those initial API calls, so it's like when all when the only information I have is this all of the initial API calls to get the files to get the user contacts to get the merge request contacts. All of that that's what starts is all of the like initial API calls uh yeah. So let's, let's jump into that, um but before I do that, let me go ahead and start uh I'm.

D

Surprised you didn't have to await that. Like shouldn't, you have to wait. Start I mean you're.

A

Sometimes that's very observant, so yeah so I think one of the things that has changed. You know that has evolved while we're doing this is um it is a it is getting awaited, um but I guess for some reason.

A

um We wanted to do.

A

There were some more initialization that didn't necessarily need to wait for this to be done that we wanted to be available sooner than later, particularly.

D

Yeah much later, I see the awake much later, yeah yeah so.

A

Of that, definitely something that's not obvious and can be improved as well as we're. Looking at this.

D

I'm sure you're optimized to the another extent Paul. Clearly you didn't want. Oh, you can't just wait for something to happen or just do everything else in between so.

A

C

A

I think um I'm, like this whole project too, the like ex there's a lot to be improved with this extensions web ID project um one is like so you can see. We have clear domains that we're interested in like our source, Control Management. So these are all the modules related to that. Then, like hooking things specifically into vs code like we have some vs code specific stuff, uh but one of the things that's not great with this project is initializing stuff.

A

So whenever a thing changes like we've just made a new commit and we're gonna refetch stuff, we just destroy everything and then rebuild it with this initialize function and so like we kind of need a better concept of like and systems that we just initialize and they can manage themselves here and so I have some maintainability issues to refactor um this whole package, so that this this is the the smelliest part of it of like how we just initialize everything and we're not able to so there's clearly going to be a little a little complicated to follow, but the main intent is we get the stuff we need.

A

We create all the stuff. We need and register it with vs code and then we're ready. So that's kind of the whole intent here, but as you'd expect, it gets a little can become a lot, um thankfully we're in typescript land, and so that prevents us from shooting ourselves in the flood too much yeah uh cool. Well, let's hop into the start um command, uh so I'm going to go to where we create the commands. So this is where we're registering the the Handler with the start command ID.

A

So let me go to this module and all right. So a lot of these command factories are functions that return functions, and so we inject into it. The full config that we've received.

A

We're also reject injecting into it our gitlab client, which I think we talked a little bit about last time um since this is crossed out. This is probably our deprecated client. That's using this. We won't worry about that at the moment, but you see this is the main intent is. We are fetching all the stuff we need. This is all about fetching and then return. One glorious non-cohesive object to the extension context to then register everything.

A

um Okay so looks like this is kind of an interesting line of code for our current problem. um Here's a comment: that's helpful about options that we can receive into this start command. uh So there's a ref that comes from the config and then there's a ref that can come from options.

A

Configs, never change, but inside the web. Id I can actually change my branch and other things like that, and so we'll just call initialize re-initialize and that's where options we may provide a ref that the user has specified that will actually load.

A

um Okay, let's see what resolve Branch name is doing uh if we have a ref at all, that's it. Otherwise, if we're in merge requests we're going to just pull it from the merge request.

A

Otherwise we return the project default branch. Okay,.

A

um So the challenge here is ref.

A

Here's the to do ref could be a tag or commit not not always a branch.

D

A

At the recommendation is, this: is.

D

A

Yeah so um I guess somehow we need to be able to tell what it is.

D

um We probably should also rename that method to not just resolve the test result bronze name, but we probably should be resolved, resolve blob.

D

A

I think that's a good idea. um We have.

A

Yeah I think that's a good idea, uh but I'm not entirely sure. Where is the best place to do our logic um like.

A

Like I feel like this is need to return more than a string because um oh yeah yeah, you know what I'm saying like any like there's times when we know no, you need to assume this is a branch and then there's times where okay now I need to actually check. Is this a branch or not?

A

um Maybe so there's? Actually the branch that we return from here um is a lot.

A

Has a lot more of a uh I was the word I'm thinking. The branch that we actually returned from here has a lot more properties to it so like when I create an empty Branch. I have all this information along with it and that's kind of what I'm almost thinking is with this type. I almost need to create a type. That's like we're, not actually a branch yet or something like we're. A pseudo branch.

D

Yeah, it's not a blunt! It's just uh yeah at this point, Giant.

C

A

D

um But that won't work like you, you actually like if it's an empty repo and that's a ref, you don't want to create another branch of that right. That's what you're doing right now and you're like create brunch and then you're, giving the rough name or something well.

A

So this is this: I am um if it's an empty repo.

A

This is a good question. um If it's an empty repo, we I'm returning the name of the default branch, but I think there's probably a place where I check for the like commit ID.

A

uh And like if this is empty,.

D

Well, actually, if, if it's an empty repo, you won't have a commit draft like it's, not a problem that you have to solve anyway, like you won't even have a ref right. So it's not even uh like you, don't even go into that um that, if condition afterwards yeah I won't even come here, because, yes,.

A

Yeah yeah yeah yeah. um Yes, if we're an empty repo, yeah we're super empty and we handle we handle like. Oh, the branch is empty. You need to do a thing, and so that's like comes up when we commit the thing. Let's look at that Behavior real fast um when I'm here and I go to commit and the command is doing the commit. uh So here is where the user will get prompted of like oh, do they need to do a branch selection.

A

And if the project is empty is like, oh, you need to just commit. We kind of.

A

That has a different that has a different Edge to how the problem gets solved. Let's hop in, let's maybe go first to um what we actually returned for the start command response, so this start command response. Thinking of the intent here is get all the things we initially need.

A

And return it to the extension, and so we get things like a list of files. Information on the project user permissions merge, request, contacts Fork info, then gitlab branch is kind of okay, let's figure out. What's actually do we want to return here, because sometimes this isn't actually a branch, so gitlab branch is actually coming from this API client and right now this type is just. This is the API response type of we get a branch, you know what I mean so, what's kind of like the desired return here.

A

Do we want to maybe have like.

A

Like have a different types of a branch that we could return, you know like it's an actual Branch or ref and based on if it's a ref like the type is different. You know what I mean. Do we want to do something like that.

A

Maybe renaming this to ref is a.

C

Good idea, yeah I, was just about to stay the same I think it makes more sense to use ref or I mean like press could be rough as well. So exactly.

A

That's I think that's brilliant Let's, Do, It, um okay, before I just start plowing ahead, uh I, wanna, I wanna get this thing running locally. um Okay, great, oh, wait! One of the lessons I learned last time and I continue to learn is for the moment there's an issue with Firefox um when working on this locally, because it doesn't break cash for some of the service worker stuff. That happens. So it's easier to develop locally on Chrome, so I'm just going to set that up uh and I'm gonna make sure that I have disabled cash.

A

Okay, yeah we gotta, we gotta, implement the cash break and stuff at some point. um Okay, we're just gonna, hit getlab.com sweet all right, so yeah I think I. Think a good place to start is: let's change. This type, we're going to return ref- and here these are API types that we're passing through to the extension. But it looks like our ref is actually going to be different types. So you don't know yeah I, think we'll have something like.

A

Maybe we can even just something like this, where it is a high and if it's a branch, then we have branch that is a gitlab branch or type ref. And then we just have the ref as a string.

A

What do you think.

D

Why not gitlab commit like? Isn't there like a gitlab commit.

A

I, don't I, don't think we have I, don't think we have one. We have like the payload that we send to commit. I, don't think we have like the API response information for it commit.

B

A

Don't even think we're doing anything with that. Quite yet, so I'm kind of I kind of don't know if we need to even split the knowledge between tags and commits either. Let's just keep it you're in a branch or you're in a non-branch.

C

A

Do you think sounds.

D

Right, yes, the rest of both tags and, let's, let's put a comment there saying it wraps about tags and commits right, yeah.

A

uh Branch is a Bonafide pants that exists on the um in the repo, but rest is uh really.

D

A

A

Cash or a tag back basically a non-branch yeah, hey Chad,.

B

A

A

All right, so then, let's replace this okay! uh Oh wait! Oh, oh! No! Sorry, all right, I realize.

A

I didn't say, project uh huh that doesn't make any sense, um good suggestions, I guess so so, instead of git live Branch, we'll call it gitlab ref. Now, okay, the ref for the current web ID contest, sweet, okay. So now changing this type. What I love is it's going to give me all sorts of things I gotta fix, so we can start fixing the command that now needs to actually return the correct stuff or we can fix how we consume these.

A

This response, uh what do you think should we fix this command first, or should we go to fix, fix the types of the.

D

Let's fix the final State like the consuming of the actual reduction, then we know whether we need to come back and like change other things than before. We like fix yeah.

A

I, like it um so to get to get those failures, um I can run yarn, build typescript I can get a list of the typescript failures here. uh So here in the start, command we're failing.

A

um Did you just all of a sudden, just completely die on me, or are you not? Actually? Why am I I would expect you to fail a little bit more than that. uh Let's see why we're not failing even more so here I'm in the web, ID vs code extension. Let me go to the entry point where I know that we call the start command. Okay, yeah I'd expect I'd, expect typescript to start dying on me here, but I guess it kind of just maybe I need to run clean first or something like that.

A

Oh I bet it's also as yeah I. Wonder if something like that I wonder if we got failures on elsewhere, anyways not important and I know that there's a vs code way for me to find the errors as well, but I I, don't usually find myself doing that. All right we've got.

A

I'm trying to register commands and if I jump into here.

A

Looks like we return, we received something: that's like command's initial data, I'm, not entirely sure what this is. Oh, but this is trying to pick from start command response, only certain properties that we need. Branch isn't one of them now. So this now wraps, okay,.

A

Here, branches and a thing: it's now ref.

A

Okay, gitlab file content provider.

A

D

If it's a bronze, then bronze, otherwise, then bronzer committed ID. Otherwise it's the ref right.

A

Yep yep, um so that sounds like.

A

Sounds like maybe something we can do in line here of like uh let's see yeah see here, we also reference commit ID and stuff too.

A

um It could do something like this. It's not great. We could do something like type equals branch.

A

Ref.Ref that doesn't look good, maybe I should rename it to something. uh Maybe I should rename it to name. What do you think.

E

Yeah yeah I mean that that naming seems like it doesn't match what it actually is and get like a branch or a ref is a ref like a branch or tag is a ref so like calling something a ref that contains a branches a little weird.

B

A

Is it blog type branch.

E

B

E

You have to change a little.

C

A

D

For it, we're gonna call it branch and not brunch, but.

A

Then, if ref.type triple equals, not branch.

E

So one of the things the property would be shock right, like both the ref, both the tag and a branch like resolve to a shot, and that's the thing that you want.

C

E

So take okay to call this ref, but, like it shouldn't contain a branch or a ref like it should just expose once the shot of this of this ref. Regardless of what type of refer it is.

A

D

If it's an interface, if it's an interface, it just has like a method called ref.

D

um So all the needs, all we do need is a actually just a property called ref. uh Sorry Sha.

A

Yeah I think I I, I I. Think I like that. So I almost might do this. Where, if we're here, we have branch, and we can say that we are uh what how do I spell git lab. Why are you so upset.

E

Okay, uh it's like a union type, it could be a tag or a branch. Yes,.

A

And that's what I was trying to do here and one of the things typescript is so good at is like if I do these Union types and I and I give static values to the type it it can at compile time know under what context is the type supposed to be which is great um uh used as a value here? Oh because I'm doing equals? That's why it's not enjoying anything that I'm doing here?

A

Okay, so I have Branch, ref, isn't a great thing, but if I didn't do gitlab are we thinking like commit, ref and I can say, type uh commit and I can have Shaw, and this one could also have Chomp, which is. Maybe all of these refs have just a shop that we're trying to attach to it.

E

Yeah and the third one would be a tag if you ever support tags, yeah.

D

I was saying these would be types concrete types and then you'll just have an interface saying: gitlab show it just has a sharp property, so you can retrieve it everywhere. um Yeah.

A

So then, what I'm thinking is then this could be like this. We could say it's a branch ref or it's a.

C

A

It's a paragraph: do we do we kind of like that.

B

Yeah I think so I think it lines up with like it uh like the get sem book as well so get reference in the book as blobs trees commits tags, essentially.

A

Okay, let's keep, let's keep it like this and I like how we can then, when we initialize all these things, I don't have to dive into knowing I, don't have to I, don't have to break encapsulation and know like how do I get the shot. Well, if it's a branch, it's this thing. If it's tag it's this thing, it just commits this thing: let's just have that be part of the prop the read property here: um cool.

D

Yeah I was I, was thinking, gitlab ref would be any type that has a Shaw like that's what I was thinking yeah.

A

um And I and I I think that makes sense we could make like gitlab based brand bass, ref and then like have all these extend that um but yeah.

D

B

Not super necessary.

A

Like typescript is pretty good at just being able to figure itself out, um okay, so that's great, because then I don't have to do all of this, and I can just do branch.

A

Oh wait! No, it's called ref ER, Ence and then I can go here. I guess we called it commit ID, but no I'm, calling it so uh uh cool all right. So we got some errors here where we're expecting.

A

What do you say that.

C

A

um We'll have to we'll have to maybe first jump into this thing, so it looks like these are the source, control, setup options taken a branch, but let's make it a ref and we'll call it itlab, ref, okay am I exporting, oh good, I am exporting it all right. You don't need that thing anymore.

A

Okay, then we get ref. Let's see how we use Branch, okay and I I'm, just kind of yeah I'm, just I'm, just kind of following following the the trail here.

A

This thing we get we're actually gonna get a ref.

C

A

We'll throw the refs in there create vs code with Source control jump into there. Ref.

C

A

Okay, so this is where um this is one of the situations that we would want to think about how we do it. Based on what kind of ref we have checked out, um we're showing uh commit to a certain thing, but if I'm on a non-branch I can't really commit to that thing. You know what I mean so I think what I'm going to do is I'm, going to create a thing called, get commit button text based on ref, okay, get that ref string and if ref, that type equals branch.

A

Why are you upset? Oh, oh I'm, sorry I'm supposed to do something like this. Okay, um I am really frustrated with.

C

A

Recommending talk to me, yeah.

C

A

Right so if I'm here I will then do ref, Branch name else, I think I'm just going to say commit command text. So we'll just do something like that.

C

D

It's a if it's a tag or a commit, or if it's a tag or just a commit, you don't actually want to show any comment. Button text right. You want to in fact disable the button because they can't they can't really commit into a comment.

A

Right I think um I think it'll have to be like commit to New Branch you're, probably right so I. Your it'll probably have to be like to New Branch.

D

A

Know I think I think that's going to be the the way it'll go um and we'll actually we'll we'll Implement that after we resolve our our type of issues, oops.

A

um Okay, so this this file is good. Let's go back um here, oh yeah, that one's good I just need to use ref here instead of Branch great.

A

um The commit command, yes, the commit command is expecting set of gitlab Branch. This is now git lab raft, oops, I, gotta record. It.

A

um So one of the things too, across the project that would overlooked we can improve upon is you can actually sell typescript to just import types from a thing and it's nice to do that distinction so that typescript knows okay again, this is just a type specific import and I can strip things out on compilation time.

A

Okay, cool we received ref, let's see how this gets used. um Okay, getting the actual Branch selection will pass the ref into there.

A

Okay. Well, let's jump into there get Branch selection options. We've got our ref.

A

C

A

Yeah I don't need this anymore, all right! Oh man, oh Mama's, okay, uh all right! What are we trying to do here.

A

D

Oh, that's pretty cool. We have that error messages as well.

A

B

I think rough name is probably.

A

Okay, ref name.

B

We can push this interesting.

A

A

So at this point we have two things that happen: uh we either prompt for a branch name and that's a pre-existing thing because, like if you're pointing to the main branch we'll be like hey, are you really sure you want to push to the main branch and we'll do that? Behavior.

D

Maybe we should set that to true, actually so, if it's not uh like, where does it get set so I think we should set it to true if it's anything but a branch I.

A

Think you're, right and I think that might be all we need to do so. I'm almost going to do something like this. um We could do something. I agree that yeah, it's probably better. If we can, if I does not equal Branch or.

A

I did too many. That is that too many equals.

A

It was too many equals yeah.

A

um So we'll just pass ref to here, but then.

A

Otherwise, I can assume that ref is a branch and all these are going to be okay. Does that make sense and we're going to test all this out? We're just resolving type issues at the moment.

C

A

Prompt Branch name so, instead of something like this.

B

I think rough, then that's probably Fair there yeah we'll do you think we need the context of the whole.

A

That's a really great question: um do you want to just make yeah we can maybe just call it ref name. You want to just try that out or we can just call it. Ref um rough name makes sense, because we've been calling wrath as as a larger type, the rest of the project. Okay, please, please stop suggesting stuff. Does anyone know how to turn it off I hate doing that, but I'm gonna have to.

A

Is there a little?

A

Is there a way to turn off the suggestions? I gotta figure that out sometime all right.

A

A

Okay, yeah we'll try that out. That should be cool. Let's, let's see what happens there uh so then here they get the actual name of it. It's not going to be the shaw, um but let's just do that for right now and I'll. Add it to you of the Shah is not the name.

A

um Okay, so going back up the stock here will pass in ref boom, we're good here and then we'll pass in ref oom we're good here. All right, I think we got just one more um init, so I'll change this to ref Branch status bar item, where let's go ahead and and get the whole Wrath of gitlab ref. Here.

B

Blah blah blah.

C

A

So I am I. Am sensing like a need to somehow pull the name, the visible name from based on what the ref is? We can either make that, like a shared property that all the different types have to do, or we can create a helper. That knows how to find the name based on the types.

D

Yeah, exactly I think we can create a helper okay, just pull out the name based on the type.

A

Let's maybe just create, let's, let's create a little, um let's create a little thing, maybe within this project. Oh look at this helpful director, utils yeah, I love. It get rap name.

A

Utils export cons, get ref.

A

Oh, no, no you're, not right you're, not right.

A

Okay, if ref DOT type equals branch return, ref.branch.name.

A

uh If ref, that type equals tag, return, ref, .name.

A

Else return right to that shell.

D

I'll just say new uh because you need to know or just New Branch new. You know what I mean like, but after child is just a lot of text for them to delete, but what anyway I mean they'll have to delete all of the text right and actually put in a real name. So I was just wondering whether you just give an empty string.

A

But this is also used for like down here, like what branch you've you've actually checked out, and so, if I'm, just on the shot and I have no other.

C

Oh I see about.

A

It it's like, maybe that's just where we're at you.

D

Know I see, okay, makes sense.

E

A

So then, I think here I'm going to do something like name equals, get uh ref name graph boom.

A

But yeah we go, we should go back to here where we were um prompting for the branch name generating the branch name.

A

D

A

We should call it uh get.

D

A

Rough name equals get ref name.

C

A

All right um so I think we've resolved strike errors in this package that consumes all of it. I think, then we have the hype, errors in the other package and then and the mediator commands, which is actually creating the.

D

But where's, the actual, like the um I, mean you need to make the API calls to that's the mediatric ones right to check out the actual, like grass bucket box.

A

Yep yep um yeah, so here.

A

So here we're at something interesting.

A

All right we've got, we here, I, think we've resolved the branch name and that's okay, so we're pulling what is the actual ref we're trying to use, and that could be a branch name or it could be a ref. Maybe we need to rename this to resolve refname.

A

C

A

A good idea, all right name.

A

We're going to call you ref name and then, if we're in an empty repo, we're just going to assume you're using this empty Branch thing. Does that sound all right? So when we create an empty branch, we'll call this a good lab RAV, but it's going to be something like hype.

A

C

B

A

Why are you so upset? What am I missing? Oh I'm missing a curly brace yeah. It's not gonna be happy. If I do that. Okay.

E

Oh yeah, okay,.

A

So we're creating an empty branch of our new ref type, which wraps so this is all like gitlab API type stuff, but we have we're just treating it like a a branch um here is like we're, not an empty project, so we need to actually figure this out, and this is the line that's blowing up and everything dies. So we need to.

A

I think because tag names can be anything I feel like we have to almost like check tags first right.

A

Like we have to check if this is attack,.

D

Yeah so I think we need uh I I mean we need an API call to check whether it's a branch or a tag or a just a commit right and I.

E

Think we need that earlier right.

D

I mean I think we can even classify it even before it gets here, because when we are actually when are we asserting that into a ref type um or we don't actually have the studies yeah so yeah, maybe in the then.

E

um Under the covers, these are just rough specs, which is like the refs heads whatever and I, don't know just stepping back. Maybe that would be a better way to have the raw representation of it, and then you can just have methods which look at that and tell what type it is. That would work more like get itself, but I don't know if that would be too abstract for what what you're trying to do here.

E

If you should make this match more, like the the porcelain UI, where you're actually only working with tags and branches.

B

Yeah whatever's.

E

More compatible with vs code, probably when.

A

A

Can you say that, can you say that again, that's um but.

E

Like if there I was, while y'all were doing, that, I was like looking at the I'll drop. Another link here like under the covers a ref, is just like this path. You know plus reps ads whatever and a tag or Branch, or you know, there's two types of tags or if your head is just pointing to a detached head. Those are all just like pointers to this ref spec, which is this string.

C

A

Yes, I see what you're saying.

E

What what Xiao one does this point to, which is a three which I.

A

See what you're saying.

E

A

Yeah, and so that's where like ref, might not be the best name for this thing, but we do need to somehow distinguish between this input parameter that we get from the route. What kind of thing have you given me, because we want to know, are you on a branch that's going to have different UI Behavior than like? Are we not on a branch.

E

Yeah and like git knows that based off of like this internal metadata, but you can also like you know if it's refs tags or refs something else.

A

Right right, I, don't think we have backend API endpoints for this, but.

D

To get three things that Aaron just pasted really.

C

D

uh Yeah, the graphql API would.

C

B

So what I want.

C

To add and did is I.

B

Just went to the graphql.

A

B

A

Yes, um but this doesn't give me information.

E

A

E

A

B

I don't know of any metadata, but I'm just clicking through I've, literally just told that query so I'm sure there's additional fields to use here.

A

Yeah um and I've I've I'm familiar with this um I'm familiar with this graphql resolver and like so across the application we will.

A

Yeah I mean that's, and this is interesting. You're right, I see yeah, we could use based on the ref and, like the last commit information we can get ideas from that because if it's like.

D

But we don't even need that I'm pretty sure we can get in the tree object. There should be something that tells us what what is the type right.

E

Yeah there is a ref type, that's that's a property of tree, so.

D

Let's, let's try to get that out and see.

A

Get um a ref type, all right, I know we're at time, um so we can uh I, think I. Think the oh yeah there is okay, okay, what no, what I got to look it up.

D

Yeah, there's got heads, heads and tags and Lisa tells you a lot.

A

Yeah this seems like an enum um that must be referenced somewhere else.

A

um Yeah I bet the graphql API might might there might be something that where I can just give it a generic ref, and it will tell me what the type is that would be lovely exactly not the fallback that we've kind of thought about was: let's see if it's a tag, let's see, if it's a branch, then you must be a commit, like that's kind of, was.

D

The fall yeah yeah exactly there's.

A

Always that fallback but I might um we might spend some time I'm gonna review what we did with the APAC folk and then we'll push it forward. The um the APAC folk and I will push it forward and see uh if there's a helpful endpoint for this.

E

A

You all have any other ideas feel free to drop on that issue, um the the on, even just the onboarding issue of like oh, we could use, maybe use as an endpoint for checking it out I'm, going to push up what we did so far and a work in progress Mr um but yeah. This is super helpful thanks for hopping on and I feel like it's lovely typescript, you just make the core change and then just follow the threads, and it's pretty.

A

Just one little thread at a time: yeah, it's like it's like it's like knitting, all right, I'll catch, you all later all right. Thank.

B