Feature/projects & envs

src/api-gateway/api-gateway.graphql

@@ -4,8 +4,8 @@
 # -----------------------------------------------
 
 type ApiTokens {
-  _id: String!
-  launchRoomToken: String!
+  _id: String
+  launchRoomToken: String
 }
 
 type Clause {
@@ -27,10 +27,21 @@ type ClientSideAvailability {
   usingMobileKey: Boolean!
 }
 
+# The javascript `Date` as string. Type represents date and time as the ISO Date string.
+scalar DateTime
+
 type Empty {
   ok: Boolean!
 }
 
+type Environment {
+  _id: ID!
+  apiToken: ID!
+  deletedAt: DateTime
+  name: String!
+  project: ID!
+}
+
 type Fallthrough {
   rollout: VariationsObject
   variation: Int
@@ -47,6 +58,7 @@ type FlagDetails {
   clientSideAvailability: ClientSideAvailability!
   deleted: Boolean!
   description: String!
+  environment: ID!
   fallthrough: Fallthrough!
   key: String!
   name: String!
@@ -77,16 +89,27 @@ scalar JSON @specifiedBy(url: "http://www.ecma-international.org/publications/fi
 type Mutation {
   subscribeToNewsletter(email: String!, firstName: String, lastName: String): Empty!
   upsertApiTokens(_id: String!, launchRoomToken: String!): ApiTokens
-  upsertFlag(archived: Boolean, description: String, fallthrough: FallthroughInput, key: ID!, name: String, offVariation: Int, on: Boolean, rules: [RuleInput!], variationsBoolean: [Boolean!], variationsJson: [String!], variationsNumber: [Int!], variationsString: [String!], workspaceId: ID!): Boolean!
+  upsertEnvironment(_id: ID, deletedAt: DateTime, launchRoomToken: String, name: String!, project: ID): Environment
+  upsertFlag(archived: Boolean, description: String, environment: ID!, fallthrough: FallthroughInput, key: ID!, name: String, offVariation: Int, on: Boolean, rules: [RuleInput!], variationsBoolean: [Boolean!], variationsJson: [String!], variationsNumber: [Int!], variationsString: [String!], workspaceId: ID!): Boolean!
+  upsertProject(_id: ID, deletedAt: DateTime, name: String!, workspace: ID!): Project
 }
 
 type Prerequisite {
   key: String!
   variation: Int!
 }
 
+type Project {
+  _id: ID!
+  deletedAt: DateTime
+  name: String!
+  workspace: ID!
+}
+
 type Query {
-  apiTokens: ApiTokens!
+  fetchApiTokens(_id: ID!): ApiTokens!
+  fetchEnvironments(workspace: ID!): [Environment!]!
+  fetchProjects(workspace: ID!): [Project!]!
   flagDetails(key: ID!, workspaceId: ID!): FlagDetails
   flagsStatus(archived: Boolean!, limit: Int!, skip: Int!, workspaceId: ID!): FlagsStatus!
 

src/api-gateway/api-gateway.ts

@@ -8,6 +8,8 @@ import { OnefxAuth } from "onefx-auth";
 import { NonEmptyArray } from "type-graphql/dist/interfaces/NonEmptyArray";
 import { NewsletterResolver } from "@/shared/newsletter/newsletter-resolver";
 import { FlagResolver } from "@/api-gateway/resolvers/flag-resolver";
+import { ProjectsResolver } from "@/api-gateway/resolvers/project-resolver";
+import { EnvironmentsResolver } from "@/api-gateway/resolvers/environment-resolver";
 import { MyServer } from "@/server/start-server";
 import { customAuthChecker } from "@/api-gateway/auth-checker";
 import { ApiTokensResolver } from "@/shared/api-tokens/api-tokens-resolver";
@@ -29,6 +31,8 @@ export async function setApiGateway(server: MyServer): Promise<void> {
     NewsletterResolver,
     FlagResolver,
     ApiTokensResolver,
+    ProjectsResolver,
+    EnvironmentsResolver,
   ];
   server.resolvers = resolvers;
 

src/api-gateway/resolvers/environment-resolver.ts

@@ -0,0 +1,125 @@
+import {
+  Args,
+  ID,
+  ArgsType,
+  Authorized,
+  Ctx,
+  Field,
+  Mutation,
+  ObjectType,
+  Query,
+  Resolver,
+} from "type-graphql";
+import { IContext } from "@/api-gateway/api-gateway";
+import { Environment as EnvironmentDoc } from "@/model/environment-model";
+
+@ObjectType()
+class Environment {
+  @Field(() => ID)
+  _id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => ID)
+  project: string;
+
+  @Field(() => ID)
+  apiToken: string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt: Date;
+}
+
+@ArgsType()
+class UpsertEnvironmentRequest {
+  @Field(() => ID, { nullable: true })
+  _id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => ID, { nullable: true })
+  project?: string;
+
+  @Field(() => String, { nullable: true })
+  launchRoomToken?: string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date;
+}
+
+@ArgsType()
+class RequestByWorkspaceId {
+  @Field(() => ID)
+  workspace: string;
+}
+
+@Resolver()
+export class EnvironmentsResolver {
+  @Authorized()
+  @Query(() => [Environment])
+  public async fetchEnvironments(
+    @Args() { workspace }: RequestByWorkspaceId,
+    @Ctx() { model: { environmentModel, projectModel } }: IContext
+  ): Promise<EnvironmentDoc[]> {
+    const projects = await projectModel.find({ workspace, deletedAt: null });
+    const environments = await Promise.all(
+      projects.map(
+        async (project): Promise<EnvironmentDoc[]> =>
+          environmentModel.find({
+            project: project._id,
+            deletedAt: null,
+          })
+      )
+    );
+    return environments.flat();
+  }
+
+  @Authorized()
+  @Mutation(() => Environment, { nullable: true })
+  async upsertEnvironment(
+    @Args() { _id, name, project, deletedAt }: UpsertEnvironmentRequest,
+    @Ctx()
+    {
+      model: { environmentModel, projectModel, apiTokens, flagModel },
+    }: IContext
+  ): Promise<EnvironmentDoc | null> {
+    if (_id) {
+      return environmentModel.findOneAndUpdate(
+        { _id },
+        { name, project, deletedAt }
+      );
+    }
+    const currentProject = await projectModel.findOne({ _id: project });
+    const apiToken = await apiTokens.create({
+      workspace: currentProject?.workspace,
+    });
+    const environment = await environmentModel.create({
+      name,
+      project,
+      apiToken,
+    });
+
+    const prevEnvironment = await environmentModel.findOne({
+      project,
+      deletedAt: null,
+    });
+    if (prevEnvironment) {
+      const flags = await flagModel
+        .find({
+          workspace: currentProject?.workspace,
+          environment: prevEnvironment._id,
+        })
+        .lean();
+
+      await Promise.all(
+        flags.map(async (flag) => {
+          delete flag._id;
+          await flagModel.create({ ...flag, environment: environment._id });
+        })
+      );
+    }
+    return environment;
+  }
+}

src/api-gateway/resolvers/flag-resolver.ts

@@ -188,6 +188,9 @@ class FlagDetails {
   @Field(() => ClientSideAvailability)
   clientSideAvailability: ClientSideAvailability;
 
+  @Field(() => ID)
+  environment: boolean;
+
   @Field(() => Boolean)
   archived: boolean;
 }
@@ -281,6 +284,9 @@ class UpFlagDetailsArgs {
   @Field(() => FallthroughInput, { nullable: true })
   fallthrough: FallthroughInput;
 
+  @Field(() => ID)
+  environment: string;
+
   @Field(() => Boolean, { nullable: true })
   archived: boolean;
 }
@@ -341,7 +347,8 @@ export class FlagResolver {
   @Mutation(() => Boolean)
   async upsertFlag(
     @Args() detail: UpFlagDetailsArgs,
-    @Ctx() { model: { flagModel, userWorkspace }, userId }: IContext
+    @Ctx()
+    { model: { flagModel, userWorkspace, environmentModel }, userId }: IContext
   ): Promise<boolean> {
     const {
       key,
@@ -351,11 +358,15 @@ export class FlagResolver {
       offVariation,
       fallthrough,
       archived,
+      environment,
     } = detail;
-
     await assertWorkspace(userWorkspace, userId, workspaceId);
 
-    const flag = await flagModel.findOne({ key, workspace: workspaceId });
+    const flag = await flagModel.findOne({
+      key,
+      workspace: workspaceId,
+      environment,
+    });
     if (flag) {
       const updated = {} as Record<string, unknown>;
 
@@ -381,11 +392,13 @@ export class FlagResolver {
       if (archived !== undefined) {
         updated.archived = archived;
       }
+      updated.environment = environment;
 
       await flagModel.findOneAndUpdate(
         {
           key,
           workspace: workspaceId,
+          environment,
         },
         updated
       );
@@ -401,20 +414,29 @@ export class FlagResolver {
         variationsJson?.map((value) => JSON.parse(value)) ||
         variationsNumber ||
         variationsString;
-
-      await flagModel.create({
-        workspace: workspaceId,
-        clientSideAvailability: {
-          usingMobileKey: true,
-          usingEnvironmentId: true,
-        },
-        isOn: true,
-        salt: "",
-        sel: "",
-        targets: [],
-        variations,
-        ...detail,
+      const currentEnvironment = await environmentModel.findById(environment);
+      const environments = await environmentModel.find({
+        project: currentEnvironment?.project,
+        deletedAt: null,
       });
+      await Promise.all(
+        environments.map(async (value) =>
+          flagModel.create({
+            workspace: workspaceId,
+            clientSideAvailability: {
+              usingMobileKey: true,
+              usingEnvironmentId: true,
+            },
+            isOn: true,
+            salt: "",
+            sel: "",
+            targets: [],
+            variations,
+            ...detail,
+            environment: value._id,
+          })
+        )
+      );
     }
 
     return true;

src/api-gateway/resolvers/project-resolver.ts

@@ -0,0 +1,77 @@
+import {
+  Args,
+  ID,
+  ArgsType,
+  Authorized,
+  Ctx,
+  Field,
+  Mutation,
+  ObjectType,
+  Query,
+  Resolver,
+} from "type-graphql";
+import { IContext } from "@/api-gateway/api-gateway";
+import { Project as ProjectDoc } from "@/model/project-model";
+
+@ObjectType()
+class Project {
+  @Field(() => ID)
+  _id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => ID)
+  workspace: string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt: Date;
+}
+
+@ArgsType()
+class UpsertProjectRequest {
+  @Field(() => ID, { nullable: true })
+  _id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => ID)
+  workspace: string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date;
+}
+
+@ArgsType()
+class RequestByWorkspaceId {
+  @Field(() => ID)
+  workspace: string;
+}
+
+@Resolver()
+export class ProjectsResolver {
+  @Authorized()
+  @Query(() => [Project])
+  public async fetchProjects(
+    @Args() { workspace }: RequestByWorkspaceId,
+    @Ctx() { model: { projectModel } }: IContext
+  ): Promise<ProjectDoc[]> {
+    return projectModel.find({ workspace, deletedAt: null });
+  }
+
+  @Authorized()
+  @Mutation(() => Project, { nullable: true })
+  async upsertProject(
+    @Args() { _id, name, workspace, deletedAt }: UpsertProjectRequest,
+    @Ctx() { model: { projectModel } }: IContext
+  ): Promise<ProjectDoc | null> {
+    if (_id) {
+      return projectModel.findOneAndUpdate(
+        { _id },
+        { name, workspace, deletedAt }
+      );
+    }
+    return projectModel.create({ name, workspace });
+  }
+}