staging router endpoint

packages/backend/src/resolvers.ts

@@ -332,10 +332,6 @@ export const createResolvers = async (service: Service): Promise<any> => {
           return false;
         }
       },
-
-      getVersion(): string {
-        return service.getVersion();
-      },
     },
   };
 };

packages/backend/src/routes/staging.ts

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+
+const router = Router();
+
+router.get('/version', async (req, res) => {
+  return res.send({ version: '0.0.2' });
+});
+
+export default router;

packages/backend/src/schema.gql

@@ -215,5 +215,4 @@ type Mutation {
   updateDomain(domainId: String!, data: UpdateDomainInput!): Boolean!
   authenticateGitHub(code: String!): AuthResult!
   unauthenticateGitHub: Boolean!
-  getVersion: String!
 }

packages/backend/src/server.ts

@@ -17,6 +17,7 @@ import { ServerConfig } from './config';
 import { DEFAULT_GQL_PATH } from './constants';
 import githubRouter from './routes/github';
 import authRouter from './routes/auth';
+import stagingRouter from './routes/staging';
 import { Service } from './service';
 
 const log = debug('snowball:server');
@@ -109,7 +110,7 @@ export const createAndStartServer = async (
   app.set('service', service);
   app.use('/auth', authRouter);
   app.use('/api/github', githubRouter);
-
+  app.use('/staging', stagingRouter);
   httpServer.listen(port, host, () => {
     log(`Server is listening on ${host}:${port}${server.graphqlPath}`);
   });

packages/backend/src/service.ts

@@ -1027,8 +1027,4 @@ export class Service {
   ): Promise<boolean> {
     return this.db.updateUser(user, data);
   }
-
-  getVersion(): string {
-    return '0,0.2';
-  }
 }

packages/frontend/src/pages/AuthPage.tsx

@@ -1,7 +1,35 @@
 import { CloudyFlow } from 'components/CloudyFlow';
 import { SnowballAuth } from './auth/SnowballAuth';
+import { useEffect, useState } from 'react';
+
+const baseUrl = import.meta.env.VITE_SERVER_URL;
+const IS_STAGING = import.meta.env.VITE_IS_STAGING;
 
 const AuthPage = () => {
+  const [version, setVersion] = useState('');
+
+  async function getVersion() {
+    const res = await fetch(`${baseUrl}/staging/version`);
+
+    if (res.status == 200) {
+      const queriedVersion = (await res.json()).version;
+      console.log('v: ', queriedVersion);
+      if (queriedVersion) {
+        setVersion(queriedVersion);
+      }
+    } else if (res.status === 204) {
+      return null;
+    } else {
+      throw new Error(
+        `Unexpected response from staging version endpoint: ${res.status}: ${await res.text()}`,
+      );
+    }
+  }
+
+  useEffect(() => {
+    getVersion();
+  }, []);
+
   return (
     <CloudyFlow className="flex flex-col min-h-screen">
       <div className="py-8 relative z-10">
@@ -21,6 +49,11 @@ const AuthPage = () => {
           <SnowballAuth />
         </div>
       </div>
+      {IS_STAGING == 'YES' && (
+        <div className="p-4 text-center">
+          <span>Version: {version}</span>
+        </div>
+      )}
     </CloudyFlow>
   );
 };

packages/gql-client/dist/index.mjs

@@ -20,7 +20,10 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/client.ts
-import { ApolloClient, InMemoryCache } from "@apollo/client";
+import {
+  ApolloClient,
+  InMemoryCache
+} from "@apollo/client";
 
 // src/queries.ts
 import { gql } from "@apollo/client";

packages/gql-client/src/client.ts

@@ -1,8 +1,13 @@
-import { ApolloClient, DefaultOptions, InMemoryCache, NormalizedCacheObject } from '@apollo/client';
+import {
+  ApolloClient,
+  DefaultOptions,
+  InMemoryCache,
+  NormalizedCacheObject,
+} from "@apollo/client";
 
-import * as queries from './queries';
+import * as queries from "./queries";
-import * as types from './types';
+import * as types from "./types";
-import * as mutations from './mutations';
+import * as mutations from "./mutations";
 
 export interface GraphQLConfig {
   gqlEndpoint: string;
@@ -11,13 +16,13 @@ export interface GraphQLConfig {
 // TODO: check options
 const defaultOptions: DefaultOptions = {
   watchQuery: {
-    fetchPolicy: 'no-cache',
+    fetchPolicy: "no-cache",
-    errorPolicy: 'ignore'
+    errorPolicy: "ignore",
   },
   query: {
-    fetchPolicy: 'no-cache',
+    fetchPolicy: "no-cache",
-    errorPolicy: 'all'
+    errorPolicy: "all",
-  }
+  },
 };
 
 export class GQLClient {
@@ -28,13 +33,13 @@ export class GQLClient {
       uri: config.gqlEndpoint,
       cache: new InMemoryCache(),
       defaultOptions,
-      credentials: 'include'
+      credentials: "include",
     });
   }
 
   async getUser(): Promise<types.GetUserResponse> {
     const { data } = await this.client.query({
-      query: queries.getUser
+      query: queries.getUser,
     });
 
     return data;
@@ -44,19 +49,21 @@ export class GQLClient {
     const { data } = await this.client.query({
       query: queries.getProject,
       variables: {
-        projectId
+        projectId,
-      }
+      },
     });
 
     return data;
   }
 
-  async getProjectsInOrganization (organizationSlug: string) : Promise<types.GetProjectsInOrganizationResponse> {
+  async getProjectsInOrganization(
+    organizationSlug: string
+  ): Promise<types.GetProjectsInOrganizationResponse> {
     const { data } = await this.client.query({
       query: queries.getProjectsInOrganization,
       variables: {
-        organizationSlug
+        organizationSlug,
-      }
+      },
     });
 
     return data;
@@ -64,179 +71,216 @@ export class GQLClient {
 
   async getOrganizations(): Promise<types.GetOrganizationsResponse> {
     const { data } = await this.client.query({
-      query: queries.getOrganizations
+      query: queries.getOrganizations,
     });
 
     return data;
   }
 
-  async getDeployments (projectId: string) : Promise<types.GetDeploymentsResponse> {
+  async getDeployments(
+    projectId: string
+  ): Promise<types.GetDeploymentsResponse> {
     const { data } = await this.client.query({
       query: queries.getDeployments,
       variables: {
-        projectId
+        projectId,
-      }
+      },
     });
 
     return data;
   }
 
-  async getEnvironmentVariables (projectId: string) : Promise<types.GetEnvironmentVariablesResponse> {
+  async getEnvironmentVariables(
+    projectId: string
+  ): Promise<types.GetEnvironmentVariablesResponse> {
     const { data } = await this.client.query({
       query: queries.getEnvironmentVariables,
       variables: {
-        projectId
+        projectId,
-      }
+      },
     });
 
     return data;
   }
 
-  async getProjectMembers (projectId: string) : Promise<types.GetProjectMembersResponse> {
+  async getProjectMembers(
+    projectId: string
+  ): Promise<types.GetProjectMembersResponse> {
     const result = await this.client.query({
       query: queries.getProjectMembers,
       variables: {
-        projectId
+        projectId,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async addProjectMember (projectId: string, data: types.AddProjectMemberInput) : Promise<types.AddProjectMemberResponse> {
+  async addProjectMember(
+    projectId: string,
+    data: types.AddProjectMemberInput
+  ): Promise<types.AddProjectMemberResponse> {
     const result = await this.client.mutate({
       mutation: mutations.addProjectMember,
       variables: {
         projectId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async updateProjectMember (projectMemberId: string, data: types.UpdateProjectMemberInput): Promise<types.UpdateProjectMemberResponse> {
+  async updateProjectMember(
+    projectMemberId: string,
+    data: types.UpdateProjectMemberInput
+  ): Promise<types.UpdateProjectMemberResponse> {
     const result = await this.client.mutate({
       mutation: mutations.updateProjectMember,
       variables: {
         projectMemberId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async removeProjectMember (projectMemberId: string): Promise<types.RemoveProjectMemberResponse> {
+  async removeProjectMember(
+    projectMemberId: string
+  ): Promise<types.RemoveProjectMemberResponse> {
     const result = await this.client.mutate({
       mutation: mutations.removeProjectMember,
       variables: {
-        projectMemberId
+        projectMemberId,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async searchProjects (searchText: string) : Promise<types.SearchProjectsResponse> {
+  async searchProjects(
+    searchText: string
+  ): Promise<types.SearchProjectsResponse> {
     const { data } = await this.client.query({
       query: queries.searchProjects,
       variables: {
-        searchText
+        searchText,
-      }
+      },
     });
 
     return data;
   }
 
-  async addEnvironmentVariables (projectId: string, data: types.AddEnvironmentVariableInput[]): Promise<types.AddEnvironmentVariablesResponse> {
+  async addEnvironmentVariables(
+    projectId: string,
+    data: types.AddEnvironmentVariableInput[]
+  ): Promise<types.AddEnvironmentVariablesResponse> {
     const result = await this.client.mutate({
       mutation: mutations.addEnvironmentVariables,
       variables: {
         projectId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async updateEnvironmentVariable (environmentVariableId: string, data: types.UpdateEnvironmentVariableInput): Promise<types.UpdateEnvironmentVariableResponse> {
+  async updateEnvironmentVariable(
+    environmentVariableId: string,
+    data: types.UpdateEnvironmentVariableInput
+  ): Promise<types.UpdateEnvironmentVariableResponse> {
     const result = await this.client.mutate({
       mutation: mutations.updateEnvironmentVariable,
       variables: {
         environmentVariableId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async removeEnvironmentVariable (environmentVariableId: string): Promise<types.RemoveEnvironmentVariableResponse> {
+  async removeEnvironmentVariable(
+    environmentVariableId: string
+  ): Promise<types.RemoveEnvironmentVariableResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.removeEnvironmentVariable,
       variables: {
-        environmentVariableId
+        environmentVariableId,
-      }
+      },
     });
 
     return data;
   }
 
-  async updateDeploymentToProd (deploymentId: string): Promise<types.UpdateDeploymentToProdResponse> {
+  async updateDeploymentToProd(
+    deploymentId: string
+  ): Promise<types.UpdateDeploymentToProdResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.updateDeploymentToProd,
       variables: {
-        deploymentId
+        deploymentId,
-      }
+      },
     });
 
     return data;
   }
 
-  async addProject (organizationSlug: string, data: types.AddProjectInput): Promise<types.AddProjectResponse> {
+  async addProject(
+    organizationSlug: string,
+    data: types.AddProjectInput
+  ): Promise<types.AddProjectResponse> {
     const result = await this.client.mutate({
       mutation: mutations.addProject,
       variables: {
         organizationSlug,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async updateProject (projectId: string, data: types.UpdateProjectInput): Promise<types.UpdateProjectResponse> {
+  async updateProject(
+    projectId: string,
+    data: types.UpdateProjectInput
+  ): Promise<types.UpdateProjectResponse> {
     const result = await this.client.mutate({
       mutation: mutations.updateProjectMutation,
       variables: {
         projectId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async updateDomain (domainId: string, data: types.UpdateDomainInput): Promise<types.UpdateDomainResponse> {
+  async updateDomain(
+    domainId: string,
+    data: types.UpdateDomainInput
+  ): Promise<types.UpdateDomainResponse> {
     const result = await this.client.mutate({
       mutation: mutations.updateDomainMutation,
       variables: {
         domainId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async redeployToProd (deploymentId: string): Promise<types.RedeployToProdResponse> {
+  async redeployToProd(
+    deploymentId: string
+  ): Promise<types.RedeployToProdResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.redeployToProd,
       variables: {
-        deploymentId
+        deploymentId,
-      }
+      },
     });
 
     return data;
@@ -246,8 +290,8 @@ export class GQLClient {
     const { data } = await this.client.mutate({
       mutation: mutations.deleteProject,
       variables: {
-        projectId
+        projectId,
-      }
+      },
     });
 
     return data;
@@ -257,66 +301,79 @@ export class GQLClient {
     const { data } = await this.client.mutate({
       mutation: mutations.deleteDomain,
       variables: {
-        domainId
+        domainId,
-      }
+      },
     });
 
     return data;
   }
 
-  async rollbackDeployment (projectId: string, deploymentId: string): Promise<types.RollbackDeploymentResponse> {
+  async rollbackDeployment(
+    projectId: string,
+    deploymentId: string
+  ): Promise<types.RollbackDeploymentResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.rollbackDeployment,
       variables: {
         projectId,
-        deploymentId
+        deploymentId,
-      }
+      },
     });
 
     return data;
   }
 
-  async deleteDeployment (deploymentId: string): Promise<types.DeleteDeploymentResponse> {
+  async deleteDeployment(
+    deploymentId: string
+  ): Promise<types.DeleteDeploymentResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.deleteDeployment,
       variables: {
-        deploymentId
+        deploymentId,
-      }
+      },
     });
 
     return data;
   }
 
-  async addDomain (projectId: string, data: types.AddDomainInput): Promise<types.AddDomainResponse> {
+  async addDomain(
+    projectId: string,
+    data: types.AddDomainInput
+  ): Promise<types.AddDomainResponse> {
     const result = await this.client.mutate({
       mutation: mutations.addDomain,
       variables: {
         projectId,
-        data
+        data,
-      }
+      },
     });
 
     return result.data;
   }
 
-  async getDomains (projectId: string, filter?: types.FilterDomainInput): Promise<types.GetDomainsResponse> {
+  async getDomains(
+    projectId: string,
+    filter?: types.FilterDomainInput
+  ): Promise<types.GetDomainsResponse> {
     const { data } = await this.client.query({
       query: queries.getDomains,
       variables: {
         projectId,
-        filter
+        filter,
-      }
+      },
     });
 
     return data;
   }
 
-  async authenticateGitHub (code: string): Promise<types.AuthenticateGitHubResponse> {
+  async authenticateGitHub(
+    code: string
+  ): Promise<types.AuthenticateGitHubResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.authenticateGitHub,
       variables: {
-        code
+        code,
-      }
+      },
     });
 
     return data;
@@ -324,7 +381,7 @@ export class GQLClient {
 
   async unauthenticateGithub(): Promise<types.UnauthenticateGitHubResponse> {
     const { data } = await this.client.mutate({
-      mutation: mutations.unauthenticateGitHub
+      mutation: mutations.unauthenticateGitHub,
     });
 
     return data;