feat: v0.1.1

.vscode/settings.json

@@ -3,6 +3,8 @@
     "Formik",
     "clsx",
     "fontsource",
+    "notistack",
+    "unmount",
     "vditor"
   ]
 }

codegen.yml

@@ -7,6 +7,6 @@ generates:
       - "typescript"
       - "typescript-operations"
       - "typescript-react-apollo"
-  ./graphql.schema.json:
+  src/generated/graphql.schema.json:
     plugins:
       - "introspection"

package.json

@@ -1,12 +1,15 @@
 {
   "name": "fennec-bs",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": true,
   "dependencies": {
     "@apollo/client": "^3.3.15",
     "@curi/react-dom": "^2.0.4",
     "@curi/router": "^2.1.2",
     "@date-io/date-fns": "^1.3.13",
+    "@fortawesome/fontawesome-svg-core": "^1.2.35",
+    "@fortawesome/free-solid-svg-icons": "^5.15.3",
+    "@fortawesome/react-fontawesome": "^0.1.14",
     "@hickory/browser": "^2.1.0",
     "@material-ui/core": "^4.11.3",
     "@material-ui/icons": "^4.11.2",
@@ -19,12 +22,16 @@
     "@types/node": "^12.20.10",
     "@types/react": "^17.0.3",
     "@types/react-dom": "^17.0.3",
+    "apollo-link-scalars": "^2.1.3",
     "date-fns": "^2.21.1",
     "fontsource-roboto": "^4.0.0",
     "formik": "^2.2.6",
     "formik-material-ui": "^3.0.1",
     "formik-material-ui-pickers": "^0.0.12",
     "graphql": "^15.5.0",
+    "graphql-scalars": "^1.9.3",
+    "material-ui-confirm": "^2.1.2",
+    "notistack": "^1.0.6",
     "ramda": "^0.27.1",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
@@ -66,15 +73,10 @@
     "@graphql-codegen/typescript": "1.21.1",
     "@graphql-codegen/typescript-operations": "1.17.15",
     "@graphql-codegen/typescript-react-apollo": "2.2.3",
-    "@types/autoprefixer": "^10.2.0",
+    "@types/date-fns": "^2.6.0",
-    "@types/graphql": "^14.5.0",
+    "@types/ramda": "^0.27.41",
-    "@types/ramda": "^0.27.40",
-    "@types/sass": "^1.16.0",
-    "@types/tailwindcss": "^2.0.2",
     "@types/yup": "^0.29.11",
     "autoprefixer": "^9.8.6",
-    "postcss": "^7.0.35",
+    "postcss": "^7.0.35"
-    "sass": "^1.32.11",
-    "tailwindcss": "npm:@tailwindcss/postcss7-compat@^2.1.2"
   }
 }

src/commits/commit-list.tsx

@@ -0,0 +1,274 @@
+import { useMutation, useQuery, useSubscription } from "@apollo/client";
+import { Link, useResponse, useRouter } from "@curi/react-dom";
+import { faPlayCircle, faVial } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import {
+  Backdrop,
+  CircularProgress,
+  Collapse,
+  IconButton,
+  LinearProgress,
+  List,
+  ListItem,
+  ListItemIcon,
+  ListItemSecondaryAction,
+  ListItemText,
+  makeStyles,
+  useTheme,
+  withStyles,
+} from "@material-ui/core";
+import {
+  Cancel,
+  CheckCircle,
+  CloudDownload,
+  ShoppingCart,
+  Stop,
+  Timer,
+} from "@material-ui/icons";
+import { format } from "date-fns";
+import { useSnackbar } from "notistack";
+import { complement, equals, find, propEq, takeWhile } from "ramda";
+import {
+  FC,
+  Fragment,
+  MouseEventHandler,
+  ReactNode,
+  useCallback,
+  useMemo,
+  useState,
+} from "react";
+import {
+  Commit,
+  CreatePipelineTaskInput,
+  Pipeline,
+  PipelineTask,
+  TaskStatuses,
+  PipelineUnits,
+} from "../generated/graphql";
+import { CREATE_PIPELINE_TASK, STOP_PIPELINE_TASK } from "./mutations";
+import { COMMITS } from "./queries";
+import { SYNC_COMMITS } from "./subscriptions";
+
+interface Props {
+  pipeline: Pipeline;
+}
+
+const useStyles = makeStyles((theme) => ({
+  root: {
+    flex: "1 1 100%",
+  },
+  nested: {
+    paddingLeft: theme.spacing(4),
+  },
+}));
+
+export const CommitList: FC<Props> = ({ pipeline }) => {
+  const { enqueueSnackbar } = useSnackbar();
+
+  const { data, loading, refetch } = useQuery<{ commits?: Commit[] }>(COMMITS, {
+    variables: {
+      pipelineId: pipeline.id,
+    },
+  });
+
+  const { loading: syncing } = useSubscription<{ syncCommits: boolean }>(
+    SYNC_COMMITS,
+    {
+      variables: {
+        pipelineId: pipeline.id,
+      },
+      onSubscriptionData({ subscriptionData: { data, error } }) {
+        if (error) {
+          enqueueSnackbar(error.message, {
+            variant: "warning",
+          });
+        }
+        if (data?.syncCommits) {
+          refetch({
+            appInstance: data.syncCommits,
+          });
+        }
+      },
+    }
+  );
+
+  const classes = useStyles();
+
+  return (
+    <section className={classes.root}>
+      {(() => {
+        if (loading) {
+          return <LinearProgress color="secondary" />;
+        }
+
+        return (
+          <section>
+            {syncing && <LinearProgress color="secondary" />}
+            <List>
+              {data?.commits?.map((commit) => (
+                <Item key={commit.hash} commit={commit} pipeline={pipeline} />
+              ))}
+            </List>
+          </section>
+        );
+      })()}
+    </section>
+  );
+};
+
+const unitActionPairs: Array<[PipelineUnits, ReactNode, string]> = [
+  [PipelineUnits.Checkout, <ShoppingCart />, "checkout"],
+  [
+    PipelineUnits.InstallDependencies,
+    <CloudDownload />,
+    "install dependencies",
+  ],
+  [PipelineUnits.Test, <FontAwesomeIcon icon={faVial} />, "test"],
+  [PipelineUnits.Deploy, <FontAwesomeIcon icon={faPlayCircle} />, "deploy"],
+];
+
+const Item: FC<{ commit: Commit; pipeline: Pipeline }> = ({
+  commit,
+  pipeline,
+}) => {
+  const [isOpen, setOpen] = useState(() => false);
+
+  const [createTask, { loading }] =
+    useMutation<
+      { createPipelineTask: PipelineTask },
+      { task: CreatePipelineTaskInput }
+    >(CREATE_PIPELINE_TASK);
+
+  const units = useMemo(
+    () => pipeline.workUnitMetadata.units.map((unit) => unit.type),
+    [pipeline]
+  );
+
+  const { navigate, url } = useRouter();
+  const { response } = useResponse();
+
+  const handleCreateTask = useCallback(
+    (unit: PipelineUnits) => {
+      const _units = [...takeWhile(complement(equals(unit)), units), unit];
+      createTask({
+        variables: {
+          task: {
+            units: _units,
+            pipelineId: pipeline.id,
+            commit: commit.hash,
+          },
+        },
+      }).then(({ data }) => {
+        navigate({
+          url: url({
+            name: "pipeline-task-detail",
+            params: { ...response.params, taskId: data?.createPipelineTask.id },
+          }),
+        });
+      });
+    },
+    [commit, createTask, navigate, pipeline, response, units, url]
+  );
+
+  const actions = useMemo(
+    () =>
+      units.map((unit) => {
+        const pair = find(propEq(0, unit), unitActionPairs);
+        return (
+          pair && (
+            <IconButton
+              key={unit}
+              aria-label={pair[2]}
+              disabled={loading}
+              onClick={() => handleCreateTask(unit)}
+            >
+              {pair[1]}
+            </IconButton>
+          )
+        );
+      }),
+    [units, handleCreateTask, loading]
+  );
+  return (
+    <Fragment>
+      <ListItem button onClick={() => setOpen(!isOpen)}>
+        <ListItemText
+          primary={commit.message}
+          secondary={commit.date && format(commit.date, "yyyy-MM-dd HH:mm:ss")}
+        />
+        <ListItemSecondaryAction>{actions}</ListItemSecondaryAction>
+      </ListItem>
+      {loading && <LinearProgress color="secondary" />}
+      <Collapse in={isOpen} timeout="auto" unmountOnExit>
+        <List component="div" disablePadding>
+          {commit.tasks.map((task) => (
+            <Link
+              key={task.id}
+              name="pipeline-task-detail"
+              params={{ ...response.params, taskId: task.id }}
+            >
+              <TaskItem task={task} />
+            </Link>
+          ))}
+        </List>
+      </Collapse>
+    </Fragment>
+  );
+};
+
+const TaskItem: FC<{ task: PipelineTask }> = ({ task }) => {
+  const classes = useStyles();
+  const theme = useTheme();
+  const statusIcon: ReactNode = (() => {
+    switch (task.status) {
+      case TaskStatuses.Pending:
+        return <Timer style={{ color: theme.palette.info.main }} />;
+      case TaskStatuses.Success:
+        return <CheckCircle style={{ color: theme.palette.success.main }} />;
+      case TaskStatuses.Failed:
+        return <Cancel style={{ color: theme.palette.error.main }} />;
+      case TaskStatuses.Working:
+        return (
+          <CircularProgress style={{ color: theme.palette.secondary.main }} />
+        );
+    }
+  })();
+  const [stopTask, { loading: stopTaskWaiting }] = useMutation(
+    STOP_PIPELINE_TASK,
+    {
+      variables: { taskId: task.id },
+    }
+  );
+  const stop: MouseEventHandler = useCallback(
+    (event) => {
+      event.stopPropagation();
+      event.preventDefault();
+      stopTask();
+    },
+    [stopTask]
+  );
+  return (
+    <ListItem button className={classes.nested}>
+      <ListItemIcon>{statusIcon}</ListItemIcon>
+      <ListItemText
+        primary={
+          task.startedAt && format(task.startedAt, "yyyy-MM-dd HH:mm:ss")
+        }
+      />
+      <ListItemSecondaryAction>
+        {task.status === TaskStatuses.Working && (
+          <IconButton edge="end" aria-label="stop" onClick={stop}>
+            <Stop />
+          </IconButton>
+        )}
+      </ListItemSecondaryAction>
+      <LimitedBackdrop open={stopTaskWaiting} />
+    </ListItem>
+  );
+};
+const LimitedBackdrop = withStyles({
+  root: {
+    position: "absolute",
+    zIndex: 1,
+  },
+})(Backdrop);

src/commits/mutations.ts

@@ -0,0 +1,17 @@
+import { gql } from '@apollo/client';
+
+export const CREATE_PIPELINE_TASK = gql`
+  mutation CreatePipelineTask($task: CreatePipelineTaskInput!) {
+    createPipelineTask(task: $task) {
+      id
+      status
+      startedAt
+      endedAt
+    }
+  }
+`;
+export const STOP_PIPELINE_TASK = gql`
+  mutation StopPipelineTask($taskId: String!) {
+    stopPipelineTask(id: $taskId)
+  }
+`;

src/commits/queries.ts

@@ -0,0 +1,20 @@
+import { gql } from '@apollo/client';
+
+export const COMMITS = gql`
+  query Commits($pipelineId: String!) {
+    commits(pipelineId: $pipelineId) {
+      message
+      hash
+      date
+      body
+      author_name
+      tasks {
+        id
+        units
+        status
+        startedAt
+        endedAt
+      }
+    }
+  }
+`;

src/commits/subscriptions.ts

@@ -0,0 +1,6 @@
+import { gql } from "@apollo/client";
+export const SYNC_COMMITS = gql`
+  subscription SyncCommits($pipelineId: String!) {
+    syncCommits(pipelineId: $pipelineId)
+  }
+`;

src/commons/fallbacks/error-page.tsx

@@ -0,0 +1,11 @@
+import { Typography } from '@material-ui/core';
+import React, { FC } from 'react';
+
+export const ErrorPage: FC = ({children}) => {
+  return (
+    <section>
+      <Typography component="h2">Something is wrong :(</Typography>
+      <Typography variant="body1" component="div">{children}</Typography>
+    </section>
+  );
+}

src/commons/graphql/client.ts

@@ -1,6 +0,0 @@
-import { ApolloClient, InMemoryCache } from "@apollo/client";
-
-export const client = new ApolloClient({
-  uri: "/api/graphql",
-  cache: new InMemoryCache(),
-});

src/commons/graphql/client.tsx

@@ -0,0 +1,113 @@
+import {
+  ApolloClient,
+  ApolloLink,
+  HttpLink,
+  InMemoryCache,
+  split,
+  ApolloProvider,
+} from "@apollo/client";
+import { withScalars } from "apollo-link-scalars";
+import { buildClientSchema, IntrospectionQuery } from "graphql";
+import { DateTimeResolver } from "graphql-scalars";
+import { FC } from "react";
+import introspectionResult from "../../generated/graphql.schema.json";
+import { onError } from "@apollo/client/link/error";
+import { WebSocketLink } from "@apollo/client/link/ws";
+import { getMainDefinition } from "@apollo/client/utilities";
+import { useSnackbar } from "notistack";
+import { deepOmit } from "../../utils/deep-omit";
+
+const schema = buildClientSchema(
+  introspectionResult as unknown as IntrospectionQuery
+);
+
+const typesMap = {
+  DateTime: DateTimeResolver,
+};
+
+const cleanTypeName = new ApolloLink((operation, forward) => {
+  if (operation.variables) {
+    operation.variables = deepOmit(["__typename"], operation.variables);
+  }
+  const rt = forward(operation);
+  return (
+    rt.map?.((data) => {
+      return data;
+    }) ?? rt
+  );
+});
+
+export const FennecApolloClientProvider: FC = ({ children }) => {
+  const { enqueueSnackbar } = useSnackbar();
+  const errorLink = onError(({ graphQLErrors, networkError }) => {
+    if (graphQLErrors) {
+      graphQLErrors.forEach((error) => {
+        enqueueSnackbar(error.message, {
+          variant: "error",
+        });
+      });
+      graphQLErrors.forEach(({ message, locations, path }) => {
+        console.error(
+          `[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`
+        );
+      });
+    }
+    if (networkError) {
+      console.log(`[Network error]: ${networkError}`);
+      enqueueSnackbar(networkError.message, {
+        variant: "error",
+      });
+    }
+  });
+  const wsLink = new WebSocketLink({
+    uri: `${window.location.protocol.replace("http", "ws")}//${
+      window.location.hostname
+    }:${window.location.port}/api/graphql`,
+    options: {
+      reconnect: true,
+    },
+  });
+  const httpLink = new HttpLink({
+    uri: "/api/graphql",
+  });
+  const splitLink = split(
+    ({ query }) => {
+      const definition = getMainDefinition(query);
+      return (
+        definition.kind === "OperationDefinition" &&
+        definition.operation === "subscription"
+      );
+    },
+    wsLink,
+    httpLink
+  );
+  const link = ApolloLink.from([
+    errorLink,
+    withScalars({ schema, typesMap }) as unknown as ApolloLink,
+    cleanTypeName,
+    splitLink,
+  ]);
+  const client = new ApolloClient({
+    connectToDevTools: true,
+    ssrMode: typeof window === "undefined",
+    link,
+    cache: new InMemoryCache({
+      typePolicies: {
+        // PipelineTaskLogs: {
+        //   keyFields: ["unit"],
+        // },
+        // PipelineTask: {
+        //   fields: {
+        //     logs: {
+        //       merge(existing = [], incoming: any[]) {
+        //         return [...existing, ...incoming];
+        //       },
+        //     },
+        //   },
+        // },
+      },
+    }),
+  });
+
+  return <ApolloProvider client={client}>{children}</ApolloProvider>;
+};

src/commons/graphql/queries.ts

@@ -0,0 +1,26 @@
+import { gql } from '@apollo/client';
+
+export const COMMIT_LIST_QUERY = gql`
+  query CommitListQuery($projectId: String!, $pipelineId: String!) {
+    project(id: $projectId) {
+      id
+      name
+      comment
+      webUrl
+      sshUrl
+      webHookSecret
+    }
+    pipeline(id: $pipelineId) {
+      id
+      name
+      branch
+      workUnitMetadata {
+        version
+        units {
+          type
+          scripts
+        }
+      }
+    }
+  }
+`;

src/commons/route/active-link.tsx

@@ -0,0 +1,20 @@
+import { ActiveHookProps, Link, LinkProps, useActive } from '@curi/react-dom';
+import React, { FC, ReactNode } from 'react';
+
+export type ActiveLinkProps = ActiveHookProps &
+  LinkProps & {
+    className?: string;
+    children: ReactNode;
+  };
+
+export const ActiveLink:FC<ActiveLinkProps> = ({ name, params, partial, className = "", ...rest }) => {
+  const active = useActive({ name, params, partial });
+  return (
+    <Link
+      name={name}
+      params={params}
+      {...rest}
+      className={active ? `${className} active` : className}
+    />
+  );
+};

src/commons/route/router.tsx

@@ -0,0 +1,31 @@
+import { useApolloClient } from "@apollo/client";
+import { createRouterComponent } from "@curi/react-dom";
+import { createRouter, announce } from "@curi/router";
+import { browser } from "@hickory/browser";
+import { FC, ReactNode, useEffect, useMemo, useState } from "react";
+import routes from "../../routes";
+import { LinearProgress } from "@material-ui/core";
+
+const Component: FC = ({ children }) => {
+  const client = useApolloClient();
+  const [body, setBody] = useState<any>(null);
+
+  useEffect(() => {
+    const router = createRouter(browser, routes, {
+      sideEffects: [
+        announce(({ response }) => {
+          return `Navigated to ${response.location.pathname}`;
+        }),
+      ],
+      external: { client },
+    });
+    const Router = createRouterComponent(router);
+    router.once(() => {
+      setBody(<Router>{children}</Router>);
+    });
+  }, [setBody, client, children]);
+
+  return body ?? <LinearProgress />;
+};
+
+export default Component;

src/generated/graphql.schema.json

@@ -10,6 +10,163 @@
       "name": "Subscription"
     },
     "types": [
+      {
+        "kind": "OBJECT",
+        "name": "Commit",
+        "description": null,
+        "fields": [
+          {
+            "name": "hash",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "date",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "DateTime",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "message",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "refs",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "body",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "author_name",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "author_email",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "tasks",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "OBJECT",
+                    "name": "PipelineTask",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "String",
+        "description": "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
       {
         "kind": "INPUT_OBJECT",
         "name": "CreatePipelineInput",
@@ -85,16 +242,6 @@
         "enumValues": null,
         "possibleTypes": null
       },
-      {
-        "kind": "SCALAR",
-        "name": "String",
-        "description": "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
-        "fields": null,
-        "inputFields": null,
-        "interfaces": null,
-        "enumValues": null,
-        "possibleTypes": null
-      },
       {
         "kind": "INPUT_OBJECT",
         "name": "CreatePipelineTaskInput",
@@ -429,83 +576,6 @@
         "enumValues": null,
         "possibleTypes": null
       },
-      {
-        "kind": "OBJECT",
-        "name": "LogList",
-        "description": null,
-        "fields": [
-          {
-            "name": "all",
-            "description": null,
-            "args": [],
-            "type": {
-              "kind": "NON_NULL",
-              "name": null,
-              "ofType": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "OBJECT",
-                    "name": "LogFields",
-                    "ofType": null
-                  }
-                }
-              }
-            },
-            "isDeprecated": false,
-            "deprecationReason": null
-          },
-          {
-            "name": "total",
-            "description": null,
-            "args": [],
-            "type": {
-              "kind": "NON_NULL",
-              "name": null,
-              "ofType": {
-                "kind": "SCALAR",
-                "name": "Float",
-                "ofType": null
-              }
-            },
-            "isDeprecated": false,
-            "deprecationReason": null
-          },
-          {
-            "name": "latest",
-            "description": null,
-            "args": [],
-            "type": {
-              "kind": "NON_NULL",
-              "name": null,
-              "ofType": {
-                "kind": "OBJECT",
-                "name": "LogFields",
-                "ofType": null
-              }
-            },
-            "isDeprecated": false,
-            "deprecationReason": null
-          }
-        ],
-        "inputFields": null,
-        "interfaces": [],
-        "enumValues": null,
-        "possibleTypes": null
-      },
-      {
-        "kind": "SCALAR",
-        "name": "Float",
-        "description": "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).",
-        "fields": null,
-        "inputFields": null,
-        "interfaces": null,
-        "enumValues": null,
-        "possibleTypes": null
-      },
       {
         "kind": "OBJECT",
         "name": "Mutation",
@@ -644,11 +714,11 @@
             "deprecationReason": null
           },
           {
-            "name": "modifyPipeline",
+            "name": "updatePipeline",
             "description": null,
             "args": [
               {
-                "name": "Pipeline",
+                "name": "pipeline",
                 "description": null,
                 "type": {
                   "kind": "NON_NULL",
@@ -662,22 +732,6 @@
                 "defaultValue": null,
                 "isDeprecated": false,
                 "deprecationReason": null
-              },
-              {
-                "name": "id",
-                "description": null,
-                "type": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "SCALAR",
-                    "name": "String",
-                    "ofType": null
-                  }
-                },
-                "defaultValue": null,
-                "isDeprecated": false,
-                "deprecationReason": null
               }
             ],
             "type": {
@@ -757,6 +811,39 @@
             },
             "isDeprecated": false,
             "deprecationReason": null
+          },
+          {
+            "name": "stopPipelineTask",
+            "description": null,
+            "args": [
+              {
+                "name": "id",
+                "description": null,
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "SCALAR",
+                    "name": "String",
+                    "ofType": null
+                  }
+                },
+                "defaultValue": null,
+                "isDeprecated": false,
+                "deprecationReason": null
+              }
+            ],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "Boolean",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
           }
         ],
         "inputFields": null,
@@ -764,6 +851,26 @@
         "enumValues": null,
         "possibleTypes": null
       },
+      {
+        "kind": "SCALAR",
+        "name": "Float",
+        "description": "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Boolean",
+        "description": "The `Boolean` scalar type represents `true` or `false`.",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
       {
         "kind": "OBJECT",
         "name": "Pipeline",
@@ -1037,6 +1144,22 @@
             },
             "isDeprecated": false,
             "deprecationReason": null
+          },
+          {
+            "name": "runOn",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
           }
         ],
         "inputFields": null,
@@ -1046,9 +1169,57 @@
       },
       {
         "kind": "OBJECT",
-        "name": "PipelineTaskLogMessage",
+        "name": "PipelineTaskEvent",
         "description": null,
         "fields": [
+          {
+            "name": "taskId",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "pipelineId",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "projectId",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
           {
             "name": "unit",
             "description": null,
@@ -1062,7 +1233,7 @@
             "deprecationReason": null
           },
           {
-            "name": "time",
+            "name": "emittedAt",
             "description": null,
             "args": [],
             "type": {
@@ -1094,7 +1265,7 @@
             "deprecationReason": null
           },
           {
-            "name": "isError",
+            "name": "messageType",
             "description": null,
             "args": [],
             "type": {
@@ -1102,7 +1273,23 @@
               "name": null,
               "ofType": {
                 "kind": "SCALAR",
-                "name": "Boolean",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "status",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "ENUM",
+                "name": "TaskStatuses",
                 "ofType": null
               }
             },
@@ -1115,16 +1302,6 @@
         "enumValues": null,
         "possibleTypes": null
       },
-      {
-        "kind": "SCALAR",
-        "name": "Boolean",
-        "description": "The `Boolean` scalar type represents `true` or `false`.",
-        "fields": null,
-        "inputFields": null,
-        "interfaces": null,
-        "enumValues": null,
-        "possibleTypes": null
-      },
       {
         "kind": "OBJECT",
         "name": "PipelineTaskLogs",
@@ -1427,7 +1604,7 @@
             "deprecationReason": null
           },
           {
-            "name": "listPipelines",
+            "name": "pipelines",
             "description": null,
             "args": [
               {
@@ -1464,7 +1641,7 @@
             "deprecationReason": null
           },
           {
-            "name": "findPipeline",
+            "name": "pipeline",
             "description": null,
             "args": [
               {
@@ -1496,6 +1673,43 @@
             "isDeprecated": false,
             "deprecationReason": null
           },
+          {
+            "name": "commits",
+            "description": null,
+            "args": [
+              {
+                "name": "pipelineId",
+                "description": null,
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "SCALAR",
+                    "name": "String",
+                    "ofType": null
+                  }
+                },
+                "defaultValue": null,
+                "isDeprecated": false,
+                "deprecationReason": null
+              }
+            ],
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "OBJECT",
+                  "name": "Commit",
+                  "ofType": null
+                }
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
           {
             "name": "listPipelineTaskByPipelineId",
             "description": null,
@@ -1538,7 +1752,7 @@
             "deprecationReason": null
           },
           {
-            "name": "findPipelineTask",
+            "name": "pipelineTask",
             "description": null,
             "args": [
               {
@@ -1582,11 +1796,23 @@
         "description": null,
         "fields": [
           {
-            "name": "listLogsForPipeline",
+            "name": "syncCommits",
             "description": null,
             "args": [
               {
-                "name": "id",
+                "name": "appInstance",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
+                },
+                "defaultValue": null,
+                "isDeprecated": false,
+                "deprecationReason": null
+              },
+              {
+                "name": "pipelineId",
                 "description": null,
                 "type": {
                   "kind": "NON_NULL",
@@ -1603,19 +1829,15 @@
               }
             ],
             "type": {
-              "kind": "NON_NULL",
+              "kind": "SCALAR",
-              "name": null,
+              "name": "String",
-              "ofType": {
-                "kind": "OBJECT",
-                "name": "LogList",
               "ofType": null
-              }
             },
             "isDeprecated": false,
             "deprecationReason": null
           },
           {
-            "name": "pipelineTaskLog",
+            "name": "pipelineTaskEvent",
             "description": null,
             "args": [
               {
@@ -1640,7 +1862,7 @@
               "name": null,
               "ofType": {
                 "kind": "OBJECT",
-                "name": "PipelineTaskLogMessage",
+                "name": "PipelineTaskEvent",
                 "ofType": null
               }
             },
@@ -1790,6 +2012,22 @@
             "defaultValue": null,
             "isDeprecated": false,
             "deprecationReason": null
+          },
+          {
+            "name": "id",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "defaultValue": null,
+            "isDeprecated": false,
+            "deprecationReason": null
           }
         ],
         "interfaces": null,
@@ -2011,7 +2249,7 @@
               "name": null,
               "ofType": {
                 "kind": "SCALAR",
-                "name": "Float",
+                "name": "Int",
                 "ofType": null
               }
             },
@@ -2048,6 +2286,16 @@
         "enumValues": null,
         "possibleTypes": null
       },
+      {
+        "kind": "SCALAR",
+        "name": "Int",
+        "description": "The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
       {
         "kind": "INPUT_OBJECT",
         "name": "WorkUnitMetadataInput",
@@ -2059,7 +2307,7 @@
             "description": null,
             "type": {
               "kind": "SCALAR",
-              "name": "Float",
+              "name": "Int",
               "ofType": null
             },
             "defaultValue": "1",

src/generated/graphql.tsx

@@ -14,6 +14,18 @@ export type Scalars = {
   DateTime: any;
 };
 
+export type Commit = {
+  __typename?: 'Commit';
+  hash: Scalars['String'];
+  date: Scalars['DateTime'];
+  message: Scalars['String'];
+  refs: Scalars['String'];
+  body: Scalars['String'];
+  author_name: Scalars['String'];
+  author_email: Scalars['String'];
+  tasks: Array<PipelineTask>;
+};
+
 export type CreatePipelineInput = {
   projectId: Scalars['String'];
   branch: Scalars['String'];
@@ -53,22 +65,16 @@ export type LogFields = {
   tasks: Array<PipelineTask>;
 };
 
-export type LogList = {
-  __typename?: 'LogList';
-  all: Array<LogFields>;
-  total: Scalars['Float'];
-  latest: LogFields;
-};
-
 export type Mutation = {
   __typename?: 'Mutation';
   createProject: Project;
   updateProject: Project;
   removeProject: Scalars['Float'];
   createPipeline: Pipeline;
-  modifyPipeline: Pipeline;
+  updatePipeline: Pipeline;
   deletePipeline: Scalars['Float'];
   createPipelineTask: PipelineTask;
+  stopPipelineTask: Scalars['Boolean'];
 };
 
 
@@ -92,9 +98,8 @@ export type MutationCreatePipelineArgs = {
 };
 
 
-export type MutationModifyPipelineArgs = {
+export type MutationUpdatePipelineArgs = {
-  Pipeline: UpdatePipelineInput;
+  pipeline: UpdatePipelineInput;
-  id: Scalars['String'];
 };
 
 
@@ -107,6 +112,11 @@ export type MutationCreatePipelineTaskArgs = {
   task: CreatePipelineTaskInput;
 };
 
+
+export type MutationStopPipelineTaskArgs = {
+  id: Scalars['String'];
+};
+
 export type Pipeline = {
   __typename?: 'Pipeline';
   id: Scalars['ID'];
@@ -128,14 +138,19 @@ export type PipelineTask = {
   status: TaskStatuses;
   startedAt?: Maybe<Scalars['DateTime']>;
   endedAt?: Maybe<Scalars['DateTime']>;
+  runOn: Scalars['String'];
 };
 
-export type PipelineTaskLogMessage = {
+export type PipelineTaskEvent = {
-  __typename?: 'PipelineTaskLogMessage';
+  __typename?: 'PipelineTaskEvent';
+  taskId: Scalars['String'];
+  pipelineId: Scalars['String'];
+  projectId: Scalars['String'];
   unit?: Maybe<PipelineUnits>;
-  time: Scalars['DateTime'];
+  emittedAt: Scalars['DateTime'];
   message: Scalars['String'];
-  isError: Scalars['Boolean'];
+  messageType: Scalars['String'];
+  status: TaskStatuses;
 };
 
 export type PipelineTaskLogs = {
@@ -171,10 +186,11 @@ export type Query = {
   hello: Hello;
   projects: Array<Project>;
   project: Project;
-  listPipelines: Array<Pipeline>;
+  pipelines: Array<Pipeline>;
-  findPipeline: Pipeline;
+  pipeline: Pipeline;
+  commits?: Maybe<Array<Commit>>;
   listPipelineTaskByPipelineId: Array<PipelineTask>;
-  findPipelineTask: PipelineTask;
+  pipelineTask: PipelineTask;
 };
 
 
@@ -183,39 +199,45 @@ export type QueryProjectArgs = {
 };
 
 
-export type QueryListPipelinesArgs = {
+export type QueryPipelinesArgs = {
   projectId?: Maybe<Scalars['String']>;
 };
 
 
-export type QueryFindPipelineArgs = {
+export type QueryPipelineArgs = {
   id: Scalars['String'];
 };
 
 
+export type QueryCommitsArgs = {
+  pipelineId: Scalars['String'];
+};
+
+
 export type QueryListPipelineTaskByPipelineIdArgs = {
   pipelineId: Scalars['String'];
 };
 
 
-export type QueryFindPipelineTaskArgs = {
+export type QueryPipelineTaskArgs = {
   id: Scalars['String'];
 };
 
 export type Subscription = {
   __typename?: 'Subscription';
-  listLogsForPipeline: LogList;
+  syncCommits?: Maybe<Scalars['String']>;
-  pipelineTaskLog: PipelineTaskLogMessage;
+  pipelineTaskEvent: PipelineTaskEvent;
   pipelineTaskChanged: PipelineTask;
 };
 
 
-export type SubscriptionListLogsForPipelineArgs = {
+export type SubscriptionSyncCommitsArgs = {
-  id: Scalars['String'];
+  appInstance?: Maybe<Scalars['String']>;
+  pipelineId: Scalars['String'];
 };
 
 
-export type SubscriptionPipelineTaskLogArgs = {
+export type SubscriptionPipelineTaskEventArgs = {
   taskId: Scalars['String'];
 };
 
@@ -237,6 +259,7 @@ export type UpdatePipelineInput = {
   branch: Scalars['String'];
   name: Scalars['String'];
   workUnitMetadata: WorkUnitMetadataInput;
+  id: Scalars['String'];
 };
 
 export type UpdateProjectInput = {
@@ -261,11 +284,11 @@ export type WorkUnitInput = {
 
 export type WorkUnitMetadata = {
   __typename?: 'WorkUnitMetadata';
-  version: Scalars['Float'];
+  version: Scalars['Int'];
   units: Array<WorkUnit>;
 };
 
 export type WorkUnitMetadataInput = {
-  version?: Maybe<Scalars['Float']>;
+  version?: Maybe<Scalars['Int']>;
   units: Array<WorkUnitInput>;
 };

src/index.tsx

@@ -4,40 +4,30 @@ import "./index.css";
 import "fontsource-roboto";
 import App from "./App";
 import reportWebVitals from "./reportWebVitals";
-import { client } from "./commons/graphql/client";
+import { FennecApolloClientProvider } from "./commons/graphql/client";
-import { ApolloProvider } from "@apollo/client";
 import { MuiPickersUtilsProvider } from "@material-ui/pickers";
 import DateFnsUtils from "@date-io/date-fns";
 import zhLocale from "date-fns/locale/zh-CN";
-import { createRouterComponent } from "@curi/react-dom";
+import { ConfirmProvider } from "material-ui-confirm";
-import { createRouter, announce } from "@curi/router";
+import { SnackbarProvider } from "notistack";
-import { browser } from "@hickory/browser";
+import Router from './commons/route/router';
-import routes from "./routes";
 
-const router = createRouter(browser, routes, {
-  sideEffects: [
-    announce(({ response }) => {
-      return `Navigated to ${response.location.pathname}`;
-    }),
-  ],
-  external: { client }
-});
-const Router = createRouterComponent(router);
-
-router.once(() => {
   ReactDOM.render(
     <React.StrictMode>
-      <ApolloProvider client={client}>
+      <ConfirmProvider>
+        <SnackbarProvider maxSnack={5}>
+          <FennecApolloClientProvider>
             <MuiPickersUtilsProvider utils={DateFnsUtils} locale={zhLocale}>
               <Router>
                 <App />
               </Router>
             </MuiPickersUtilsProvider>
-      </ApolloProvider>
+          </FennecApolloClientProvider>
+        </SnackbarProvider>
+      </ConfirmProvider>
     </React.StrictMode>,
     document.getElementById("root")
   );
-});
 
 // If you want to start measuring performance in your app, pass a function
 // to log results (for example: reportWebVitals(console.log))

src/layouts/default.tsx

@@ -1,4 +1,4 @@
-import React, { FC } from "react";
+import React, { FC, useCallback, useRef, useState } from "react";
 import clsx from "clsx";
 import {
   createStyles,
@@ -16,13 +16,15 @@ import IconButton from "@material-ui/core/IconButton";
 import MenuIcon from "@material-ui/icons/Menu";
 import ChevronLeftIcon from "@material-ui/icons/ChevronLeft";
 import ChevronRightIcon from "@material-ui/icons/ChevronRight";
-import { ProjectPanel } from '../projects/project-panel';
+import { ProjectPanel } from "../projects/project-panel";
+import { HeaderContainerProvider } from "./header-container";
 const drawerWidth = 240;
 
 const useStyles = makeStyles((theme: Theme) =>
   createStyles({
     root: {
       display: "flex",
+      overflow: "hidden",
     },
     appBar: {
       zIndex: theme.zIndex.drawer + 1,
@@ -70,17 +72,24 @@ const useStyles = makeStyles((theme: Theme) =>
       alignItems: "center",
       justifyContent: "flex-end",
       padding: theme.spacing(0, 1),
+      flex: "none",
       // necessary for content to be below app bar
       ...theme.mixins.toolbar,
     },
+    headerContaner: {
+      flex: "auto",
+    },
     content: {
       flexGrow: 1,
-      padding: theme.spacing(3),
+      height: "100vh",
+      display: "flex",
+      flexFlow: "column",
+      padding: theme.spacing(0),
     },
   })
 );
 
-export const DefaultLayout: FC = ({children}) => {
+export const DefaultLayout: FC = ({ children }) => {
   const classes = useStyles();
   const theme = useTheme();
   const [open, setOpen] = React.useState(true);
@@ -93,6 +102,14 @@ export const DefaultLayout: FC = ({children}) => {
     setOpen(false);
   };
 
+  const [headerContainer, setHeaderContainer] = useState(undefined);
+  const onRefChange = useCallback(
+    (node) => {
+      setHeaderContainer(node);
+    },
+    [setHeaderContainer]
+  );
+
   return (
     <div className={classes.root}>
       <CssBaseline />
@@ -114,9 +131,7 @@ export const DefaultLayout: FC = ({children}) => {
           >
             <MenuIcon />
           </IconButton>
-            <Typography variant="h6" noWrap>
+          <div className={classes.headerContaner} ref={onRefChange}></div>
-              Mini variant drawer
-            </Typography>
         </Toolbar>
       </AppBar>
       <Drawer
@@ -147,8 +162,11 @@ export const DefaultLayout: FC = ({children}) => {
       </Drawer>
       <main className={classes.content}>
         <div className={classes.toolbar} />
-          { children }
+
+        <HeaderContainerProvider value={headerContainer}>
+          {children}
+        </HeaderContainerProvider>
       </main>
     </div>
   );
-}
+};

src/layouts/header-container.tsx

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'react';
+
+const Context = createContext<HTMLElement| undefined>(undefined);
+
+export const HeaderContainerProvider = Context.Provider;
+
+export const useHeaderContainer = () => useContext(Context);

src/layouts/index.tsx

@@ -1 +1,2 @@
 export * from './default';
+export * from './header-container';

src/pipeline-tasks/pipeline-task-detail.tsx

@@ -0,0 +1,189 @@
+import { gql, useQuery, useSubscription } from "@apollo/client";
+import { LinearProgress, makeStyles, Typography } from "@material-ui/core";
+import { format } from "date-fns";
+import { FC, useState } from "react";
+import { ErrorPage } from "../commons/fallbacks/error-page";
+import {
+  PipelineTask,
+  PipelineTaskEvent,
+  PipelineTaskLogs,
+  TaskStatuses,
+} from "../generated/graphql";
+import { PIPELINE_TASK_EVENT } from "./subscriptions";
+import { clone, find, propEq } from "ramda";
+
+interface Props {
+  taskId: string;
+}
+
+const PIPELINE_TASK = gql`
+  query FindPipelineTask($taskId: String!) {
+    pipelineTask(id: $taskId) {
+      id
+      units
+      commit
+      status
+      startedAt
+      endedAt
+      logs {
+        unit
+        logs
+        status
+        startedAt
+        endedAt
+      }
+    }
+  }
+`;
+
+const useStyles = makeStyles((theme) => ({
+  root: {},
+  groupTitle: {
+    backgroundColor: "white",
+    fontWeight: 500,
+    borderTop: "1px solid #eee",
+    fontSize: "16px",
+    padding: "12px",
+    marginLeft: "1px",
+  },
+  logText: {
+    fontFamily: 'Menlo, Monaco, "Courier New", monospace',
+    whiteSpace: "pre-wrap",
+    border: "none",
+    margin: "6px 12px",
+    display: "block",
+  },
+}));
+
+export const PipelineTaskDetail: FC<Props> = ({ taskId }) => {
+  const [taskEvents, setTaskEvents] = useState(
+    () => new Array<PipelineTaskEvent>()
+  );
+  const { data, loading, error, client } = useQuery<{
+    pipelineTask: PipelineTask;
+  }>(PIPELINE_TASK, {
+    variables: { taskId },
+  });
+  const task = data?.pipelineTask;
+  useSubscription<{ pipelineTaskEvent: PipelineTaskEvent }>(
+    PIPELINE_TASK_EVENT,
+    {
+      variables: { taskId },
+      onSubscriptionData({ subscriptionData: { data } }) {
+        const event = data?.pipelineTaskEvent;
+        console.log(event);
+        if (event && task) {
+          setTaskEvents((prev) => [...prev, event]);
+          if (event.unit) {
+            // event of running scripts
+            client.cache.modify({
+              id: client.cache.identify(task!),
+              fields: {
+                logs(before: PipelineTaskLogs[]) {
+                  before = clone(before);
+                  let l = find(propEq("unit", event.unit), before);
+                  if (l) {
+                    l.logs += event.message;
+                  } else {
+                    l = {
+                      unit: event.unit!,
+                      logs: event.message,
+                      status: event.status,
+                      startedAt: event.emittedAt,
+                      endedAt: null,
+                      __typename: "PipelineTaskLogs",
+                    };
+                    before.push(l);
+                  }
+                  if (event.status === TaskStatuses.Working) {
+                    l.startedAt || (l.startedAt = event.emittedAt);
+                  }
+                  if (
+                    [TaskStatuses.Failed, TaskStatuses.Success].includes(
+                      event.status
+                    )
+                  ) {
+                    l.startedAt && (l.startedAt = event.emittedAt);
+                    l.endedAt = event.emittedAt;
+                  }
+                  l.status = event.status;
+                  return before;
+                },
+              },
+            });
+          } else {
+            // event of task status change
+            client.cache.modify({
+              id: client.cache.identify(task!),
+              fields: {
+                status() {
+                  return event.status;
+                },
+                startedAt(before) {
+                  if (event.status === TaskStatuses.Working) {
+                    return event.emittedAt;
+                  } else {
+                    return before;
+                  }
+                },
+                endedAt(before) {
+                  if (
+                    [TaskStatuses.Success, TaskStatuses.Failed].includes(
+                      event.status
+                    )
+                  ) {
+                    return event.emittedAt;
+                  } else {
+                    return before;
+                  }
+                },
+              },
+            });
+          }
+        }
+      },
+    }
+  );
+  const classes = useStyles();
+
+  if (error) {
+    return <ErrorPage>{error.message}</ErrorPage>;
+  }
+
+  if (loading) {
+    return <LinearProgress color="secondary" />;
+  }
+
+  return (
+    <div className={classes.root}>
+      <Typography variant="h4" component="h2">
+        {taskId} detail
+      </Typography>
+      <Typography variant="h5" component="h3">
+        {task?.status}
+      </Typography>
+      <Typography variant="h5" component="h3">
+        {task?.startedAt && format(task?.startedAt, "yyyy-MM-dd HH:mm:ss.SSS")}-
+        {task?.endedAt && format(task?.endedAt, "yyyy-MM-dd HH:mm:ss.SSS")}
+      </Typography>
+
+      {task?.logs.map((logs) => (
+        <LogGroup key={logs.unit} logs={logs} />
+      ))}
+    </div>
+  );
+};
+
+const LogGroup: FC<{ logs: PipelineTaskLogs }> = ({ logs }) => {
+  const classes = useStyles();
+  return (
+    <div>
+      <div className={classes.groupTitle}>
+        {logs.unit}{" "}
+        {logs.startedAt && format(logs.startedAt, "yyyy-MM-dd HH:mm:ss")}{" "}
+        {logs.endedAt && format(logs.endedAt, "yyyy-MM-dd HH:mm:ss")} {logs.status}
+      </div>
+      <code className={classes.logText}>{logs.logs}</code>
+    </div>
+  );
+};

src/pipeline-tasks/subscriptions.ts

@@ -0,0 +1,16 @@
+import { gql } from "@apollo/client";
+
+export const PIPELINE_TASK_EVENT = gql`
+  subscription PipelineTaskEvent($taskId: String!) {
+    pipelineTaskEvent(taskId: $taskId) {
+      taskId
+      pipelineId
+      projectId
+      unit
+      emittedAt
+      message
+      messageType
+      status
+    }
+  }
+`;

src/pipelines/index.ts

@@ -0,0 +1,3 @@
+export * from './pipeline-detail';
+export * from './pipeline-list';
+export * from './queries';

src/pipelines/mutations.ts

@@ -0,0 +1,43 @@
+import { gql } from "@apollo/client";
+
+export const CREATE_PIPELINE = gql`
+  mutation CreatePipeline($pipeline: CreatePipelineInput!) {
+    createPipeline(pipeline: $pipeline) {
+      id
+      projectId
+      branch
+      name
+      workUnitMetadata {
+        version
+        units {
+          type
+          scripts
+        }
+      }
+    }
+  }
+`;
+
+export const UPDATE_PIPELINE = gql`
+  mutation UpdatePipeline($pipeline: UpdatePipelineInput!) {
+    updatePipeline(pipeline: $pipeline) {
+      id
+      projectId
+      branch
+      name
+      workUnitMetadata {
+        version
+        units {
+          type
+          scripts
+        }
+      }
+    }
+  }
+`;
+
+export const DELETE_PIPELINE = gql`
+  mutation DeletePipeline($id: String!) {
+    deletePipeline(id: $id)
+  }
+`;

src/pipelines/pipeline-detail.tsx

@@ -0,0 +1,11 @@
+import { FC } from 'react';
+import { Pipeline } from '../generated/graphql';
+
+interface Props {
+  pipeline: Pipeline;
+}
+
+export const PipelineDetail: FC<Props> = ({pipeline}) => {
+
+  return <div>PipelineDetail</div>
+}

src/pipelines/pipeline-editor.tsx

@@ -0,0 +1,285 @@
+import { gql, Reference, useMutation, useQuery } from "@apollo/client";
+import { useRouter } from "@curi/react-dom";
+import {
+  Button,
+  Grid,
+  IconButton,
+  LinearProgress,
+  makeStyles,
+  Paper,
+  Portal,
+  Typography,
+} from "@material-ui/core";
+import { Delete } from "@material-ui/icons";
+import { FormikHelpers, Formik, Form, Field } from "formik";
+import { TextField, TextFieldProps } from "formik-material-ui";
+import { TextField as MuiTextField } from "@material-ui/core";
+import { useConfirm } from "material-ui-confirm";
+import { useSnackbar } from "notistack";
+import { not, omit } from "ramda";
+import { ChangeEvent, FC } from "react";
+import {
+  Pipeline,
+  WorkUnitMetadata,
+  PipelineUnits,
+} from "../generated/graphql";
+import { useHeaderContainer } from "../layouts";
+import { CREATE_PIPELINE, DELETE_PIPELINE, UPDATE_PIPELINE } from "./mutations";
+import { PIPELINE } from "./queries";
+import * as Yup from "yup";
+import { useField } from "formik";
+
+type Values = Partial<Pipeline>;
+
+interface Props {
+  pipeline: Values;
+}
+
+const useStyles = makeStyles((theme) => ({
+  root: {
+    flex: "1 1 100%",
+  },
+  nested: {
+    paddingLeft: theme.spacing(4),
+  },
+  form: {
+    margin: 16,
+  },
+  metadataList: {
+    padding: 0,
+  },
+  metadataItem: {
+    listStyle: "none",
+  },
+  metadataContainer: {
+    padding: "10px 30px",
+    margin: "10px 0",
+  },
+}));
+
+export const PipelineEditor: FC<Props> = ({ pipeline }) => {
+  const { enqueueSnackbar } = useSnackbar();
+
+  const isCreate = not("id" in pipeline);
+
+  const [createPipeline] = useMutation<{ createPipeline: Pipeline }>(
+    CREATE_PIPELINE,
+    {
+      update(cache, { data }) {
+        cache.modify({
+          fields: {
+            pipelines(exiting = []) {
+              const pipelineRef = cache.writeFragment({
+                data: data!.createPipeline,
+                fragment: gql`
+                  fragment newPipeline on Pipeline {
+                    id
+                    projectId
+                    branch
+                    name
+                    workUnitMetadata {
+                      version
+                      units {
+                        type
+                        scripts
+                      }
+                    }
+                  }
+                `,
+              });
+              return [pipelineRef, ...exiting];
+            },
+          },
+        });
+      },
+    }
+  );
+  const [updatePipeline] = useMutation(UPDATE_PIPELINE);
+
+  const router = useRouter();
+
+  const submitForm = async (
+    values: Values,
+    formikHelpers: FormikHelpers<Values>
+  ) => {
+    try {
+      let pipelineId = pipeline.id;
+      let projectId = pipeline.projectId;
+      if (isCreate) {
+        await createPipeline({
+          variables: {
+            input: values,
+          },
+        }).then(({ data }) => {
+          pipelineId = data!.createPipeline.id;
+          projectId = data!.createPipeline.projectId;
+        });
+      } else {
+        await updatePipeline({
+          variables: {
+            pipeline: omit(["projectId"], values),
+          },
+        });
+      }
+      enqueueSnackbar("Saved successfully", {
+        variant: "success",
+      });
+      router.navigate({
+        url: router.url({
+          name: "pipeline-commits",
+          params: {
+            pipelineId,
+            projectId,
+          },
+        }),
+        method: "replace",
+      });
+    } finally {
+      formikHelpers.setSubmitting(false);
+    }
+  };
+
+  const [deletePipeline, { loading: deleting }] = useMutation(DELETE_PIPELINE, {
+    variables: { id: pipeline.id },
+    update(cache) {
+      cache.modify({
+        fields: {
+          projects(exiting: Reference[] = [], { readField }) {
+            return exiting.filter(
+              (ref) => pipeline.id !== readField("id", ref)
+            );
+          },
+        },
+      });
+    },
+  });
+
+  const confirm = useConfirm();
+  const handleDelete = async () => {
+    try {
+      await confirm({ description: `This will delete ${pipeline.name}.` });
+      await deletePipeline();
+      enqueueSnackbar("Deleted successfully", {
+        variant: "success",
+      });
+      router.navigate({
+        url: router.url({
+          name: "dashboard",
+        }),
+      });
+    } catch {}
+  };
+
+  const headerContainer = useHeaderContainer();
+
+  const units = [
+    PipelineUnits.Checkout,
+    PipelineUnits.InstallDependencies,
+    PipelineUnits.Test,
+    PipelineUnits.Deploy,
+    PipelineUnits.CleanUp,
+  ];
+  const classes = useStyles();
+  return (
+    <Paper className={classes.root}>
+      <Portal container={headerContainer}>
+        <Grid container justify="space-between" alignItems="center">
+          <Typography variant="h6" component="h1">
+            {isCreate ? "Create" : "Edit"} Pipeline
+          </Typography>
+          {isCreate ? null : (
+            <IconButton
+              color="inherit"
+              onClick={handleDelete}
+              disabled={deleting}
+            >
+              <Delete />
+            </IconButton>
+          )}
+        </Grid>
+      </Portal>
+      <Formik
+        initialValues={pipeline}
+        validationSchema={Yup.object({
+          name: Yup.string()
+            .max(32, "Must be 32 characters or less")
+            .required("Required"),
+          branch: Yup.string()
+            .max(32, "Must be 32 characters or less")
+            .required("Required"),
+        })}
+        onSubmit={submitForm}
+      >
+        {({ submitForm, isSubmitting, values }) => {
+          return (
+            <Form className={classes.form}>
+              <Field component={TextField} name="name" label="Name" fullWidth />
+              <Field
+                component={TextField}
+                name="branch"
+                label="Branch"
+                fullWidth
+                margin="normal"
+              />
+              <Paper className={classes.metadataContainer}>
+                <Field
+                  component={TextField}
+                  name="workUnitMetadata.version"
+                  label="Version"
+                  fullWidth
+                  readonly
+                  margin="normal"
+                />
+                <ol className={classes.metadataList}>
+                  {units.map((unit, index) => {
+                    return (
+                      <li key={unit} className={classes.metadataItem}>
+                        <Field
+                          name={`workUnitMetadata.units[${index}].scripts]`}
+                          component={ScriptsField}
+                          label={`${unit} Scripts`}
+                          fullWidth
+                          multiline
+                          margin="normal"
+                        />
+                      </li>
+                    );
+                  })}
+                </ol>
+              </Paper>
+              {isSubmitting && <LinearProgress />}
+              <Button
+                variant="contained"
+                color="primary"
+                disabled={isSubmitting}
+                onClick={submitForm}
+                fullWidth
+              >
+                Submit
+              </Button>
+            </Form>
+          );
+        }}
+      </Formik>
+    </Paper>
+  );
+};
+
+const ScriptsField: FC<TextFieldProps> = ({ field, form, meta, ...props }) => {
+  return (
+    <TextField
+      {...props}
+      form={form}
+      meta={meta}
+      field={{
+        ...field,
+        value: field.value?.join("\n") ?? "",
+        onChange: (ev: ChangeEvent<HTMLInputElement>) =>
+          form.setFieldValue(
+            field.name,
+            ev.target.value?.split("\n").map((it) => it.trim()) ?? []
+          ),
+      }}
+    />
+  );
+};

src/pipelines/pipeline-list.tsx

@@ -0,0 +1,91 @@
+import { gql, useQuery } from "@apollo/client";
+import { Link, useRouter } from "@curi/react-dom";
+import {
+  List,
+  ListItem,
+  Typography,
+  ListItemText,
+  ListItemSecondaryAction,
+  IconButton,
+} from "@material-ui/core";
+import { FC, MouseEventHandler, useMemo } from "react";
+import { Pipeline, Project } from "../generated/graphql";
+import { CallMerge, Edit } from "@material-ui/icons";
+import { clone } from "ramda";
+import { useEffect } from "react";
+
+interface Props {
+  projectId: string;
+}
+
+const PIPELINES = gql`
+  query Pipelines($projectId: String!) {
+    pipelines(projectId: $projectId) {
+      id
+      name
+      branch
+    }
+    project(id: $projectId) {
+      id
+    }
+  }
+`;
+
+export const PipelineList: FC<Props> = ({ projectId }) => {
+  const { data, loading } = useQuery<
+    { pipelines: Pipeline[]; project: Project },
+    { projectId: string }
+  >(PIPELINES, {
+    variables: { projectId },
+  });
+  const pipelines = useMemo(() => {
+    return data?.pipelines?.map((pipeline) => ({
+      ...pipeline,
+      project: data?.project,
+    }));
+  }, [data]);
+  return (
+    <List>
+      {pipelines?.map((pipeline) => (
+        <Link
+          name="pipeline-commits"
+          params={{ pipelineId: pipeline.id, projectId: projectId }}
+          key={pipeline.id}
+        >
+          <Item pipeline={pipeline} />
+        </Link>
+      ))}
+    </List>
+  );
+};
+
+const Item = ({ pipeline }: { pipeline: Pipeline }) => {
+  const { navigate, url } = useRouter();
+  const modify: MouseEventHandler = (ev) => {
+    ev.preventDefault();
+    navigate({
+      url: url({
+        name: "edit-pipeline",
+        params: { pipelineId: pipeline.id, projectId: pipeline.project.id },
+      }),
+    });
+  };
+  return (
+    <ListItem button>
+      <ListItemText
+        primary={pipeline.name}
+        secondary={
+          <Typography component="span" variant="body2" color="textSecondary">
+            <CallMerge fontSize="small" />
+            {pipeline.branch}
+          </Typography>
+        }
+      />
+      <ListItemSecondaryAction>
+        <IconButton edge="end" aria-label="edit" onClick={modify}>
+          <Edit />
+        </IconButton>
+      </ListItemSecondaryAction>
+    </ListItem>
+  );
+};

src/pipelines/queries.ts

@@ -0,0 +1,19 @@
+import { gql } from '@apollo/client';
+
+export const PIPELINE = gql`
+  query Pipeline($id: String!) {
+    pipeline(id: $id) {
+      id
+      name
+      projectId
+      branch
+      workUnitMetadata {
+        version
+        units {
+          type
+          scripts
+        }
+      }
+    }
+  }
+`;

src/projects/index.ts

@@ -0,0 +1,4 @@
+export * from './project-detail';
+export * from './project-panel';
+export * from './project-editor';
+export * from './queries';

src/projects/project-detail.tsx

@@ -0,0 +1,79 @@
+import { Project } from "../generated/graphql";
+import React, { FC, Fragment } from "react";
+import { IconButton, Grid, makeStyles, Paper, Portal, Typography } from "@material-ui/core";
+import { useHeaderContainer } from "../layouts";
+import { PipelineList } from "../pipelines/pipeline-list";
+import { Edit } from '@material-ui/icons';
+import { Link } from '@curi/react-dom';
+
+interface Props {
+  project: Project;
+}
+
+const useStyles = makeStyles(() => ({
+  root: {
+    height: "100%",
+    flex: "auto",
+    overflow: "hidden"
+  },
+  pipelineListContainer: {
+    height: "100%",
+    width: "100%",
+    overflow: "auto"
+  },
+}));
+
+export const ProjectDetail: FC<Props> = ({ project, children }) => {
+  const headerContainer = useHeaderContainer();
+
+  const classes = useStyles();
+
+  return (
+    <Fragment>
+      <Portal container={headerContainer}>
+        <Grid
+          container
+          spacing={3}
+          direction="row"
+          justify="space-between"
+          alignItems="center"
+        >
+          <Grid item>
+            <Typography component="h1" variant="h6" noWrap>
+              {project.name}
+            </Typography>
+            <Typography variant="subtitle2" gutterBottom noWrap>
+              {project.comment}
+            </Typography>
+          </Grid>
+          <Grid item>
+            <Link name="edit-project" params={{ projectId: project.id }}>
+              <IconButton color="inherit">{<Edit />}</IconButton>
+            </Link>
+          </Grid>
+        </Grid>
+      </Portal>
+      <Grid
+        container
+        spacing={0}
+        direction="row"
+        alignItems="stretch"
+        className={classes.root}
+      >
+        <Grid item xs={3} lg={2} style={{ height: "100%", display: "flex" }}>
+          <Paper className={classes.pipelineListContainer}>
+            <PipelineList projectId={project.id} />
+          </Paper>
+        </Grid>
+        <Grid
+          item
+          xs={9}
+          lg={10}
+          style={{ height: "100%", display: "flex", overflowY: "auto" }}
+        >
+          {children}
+        </Grid>
+      </Grid>
+    </Fragment>
+  );
+};

src/projects/project-editor.tsx

@@ -1,16 +1,25 @@
-import { gql, useMutation } from "@apollo/client";
+import { gql, Reference, useMutation } from "@apollo/client";
-import { Button, LinearProgress, makeStyles, Paper } from "@material-ui/core";
+import {
+  Button,
+  LinearProgress,
+  makeStyles,
+  Paper,
+  Portal,
+  Typography,
+  Grid,
+  IconButton,
+} from "@material-ui/core";
 import { Form, Formik, Field, FormikHelpers } from "formik";
 import { TextField } from "formik-material-ui";
 import { not } from "ramda";
-import React, { FC } from "react";
+import { FC } from "react";
-import {
+import { Project } from "../generated/graphql";
-  CreateProjectInput,
-  UpdateProjectInput,
-  Project,
-} from "../generated/graphql";
 import * as Yup from "yup";
 import { useRouter } from "@curi/react-dom";
+import { useHeaderContainer } from "../layouts";
+import DeleteIcon from "@material-ui/icons/Delete";
+import { useConfirm } from "material-ui-confirm";
+import { useSnackbar } from "notistack";
 
 type Values = Partial<Project>;
 
@@ -53,6 +62,12 @@ const UPDATE_PROJECT = gql`
   }
 `;
 
+const REMOVE_PROJECT = gql`
+  mutation RemoveProject($id: String!) {
+    removeProject(id: $id)
+  }
+`;
+
 export const ProjectEditor: FC<Props> = ({ project }) => {
   const isCreate = not("id" in project);
 
@@ -62,7 +77,7 @@ export const ProjectEditor: FC<Props> = ({ project }) => {
       update(cache, { data }) {
         cache.modify({
           fields: {
-            findProjects(exitingProjects = []) {
+            projects(exitingProjects = []) {
               const newProjectRef = cache.writeFragment({
                 data: data!.createProject,
                 fragment: gql`
@@ -86,6 +101,9 @@ export const ProjectEditor: FC<Props> = ({ project }) => {
   const [updateProject] = useMutation(UPDATE_PROJECT);
 
   const router = useRouter();
+
+  const { enqueueSnackbar } = useSnackbar();
+
   const submitForm = async (
     values: Values,
     formikHelpers: FormikHelpers<Values>
@@ -106,6 +124,9 @@ export const ProjectEditor: FC<Props> = ({ project }) => {
           },
         });
       }
+      enqueueSnackbar("Saved successfully", {
+        variant: "success",
+      });
       router.navigate({
         url: router.url({
           name: "project-detail",
@@ -120,9 +141,58 @@ export const ProjectEditor: FC<Props> = ({ project }) => {
     }
   };
 
+  const [removeProject, { loading: deleting }] = useMutation(REMOVE_PROJECT, {
+    variables: { id: project.id },
+    update(cache) {
+      cache.modify({
+        fields: {
+          projects(exitingProjects: Reference[] = [], { readField }) {
+            return exitingProjects.filter(
+              (ref) => project.id !== readField("id", ref)
+            );
+          },
+        },
+      });
+    },
+  });
+
+  const confirm = useConfirm();
+  const handleDelete = async () => {
+    try {
+      await confirm({ description: `This will delete ${project.name}.` });
+      await removeProject();
+      enqueueSnackbar("Deleted successfully", {
+        variant: "success",
+      });
+      router.navigate({
+        url: router.url({
+          name: "dashboard",
+        }),
+      });
+    } catch {}
+  };
+
+  const headerContainer = useHeaderContainer();
+
   const classes = useStyles();
   return (
     <Paper className={classes.root}>
+      <Portal container={headerContainer}>
+        <Grid container justify="space-between" alignItems="center">
+          <Typography variant="h6" component="h1">
+            {isCreate ? "Create" : "Edit"} Project
+          </Typography>
+          {isCreate ? null : (
+            <IconButton
+              color="inherit"
+              onClick={handleDelete}
+              disabled={deleting}
+            >
+              <DeleteIcon />
+            </IconButton>
+          )}
+        </Grid>
+      </Portal>
       <Formik
         initialValues={project}
         validationSchema={Yup.object({

src/projects/project-panel.tsx

@@ -1,13 +1,12 @@
-import { gql, useQuery } from '@apollo/client';
+import { gql, useQuery } from "@apollo/client";
-import { Link, useRouter } from '@curi/react-dom';
+import { Link } from "@curi/react-dom";
-import { Box, List, ListItem } from '@material-ui/core';
+import { Box, List, ListItem, makeStyles, Theme } from "@material-ui/core";
-import { makeStyles, Theme, createStyles } from '@material-ui/core';
+import { FC } from "react";
-import { find, propEq } from 'ramda';
+import { Project } from "../generated/graphql";
-import React, { useState, FC, useEffect } from 'react';
+import { ListItemText } from "@material-ui/core";
-import { Project } from '../generated/graphql';
+import { Button } from "@material-ui/core";
-import { ListItemText } from '@material-ui/core';
+import { AddBox } from "@material-ui/icons";
-import { Button } from '@material-ui/core';
+import { ActiveLink } from "../commons/route/active-link";
-import { AddBox } from '@material-ui/icons';
 
 const PROJECTS = gql`
   query Projects {
@@ -22,19 +21,31 @@ const PROJECTS = gql`
   }
 `;
 
-const useStyles = makeStyles((theme: Theme) =>
+const useStyles = makeStyles((theme: Theme) => ({
-  createStyles({
+  item: {
-    
+    position: "relative",
-  })
+    ".active &": {
-);
+      backgroundColor: theme.palette.background.default,
+    },
+    ".active &::before": {
+      position: "absolute",
+      top: 0,
+      bottom: 0,
+      left: 0,
+      content: '""',
+      display: "block",
+      borderLeftColor: theme.palette.secondary.main,
+      borderLeftWidth: 4,
+      borderLeftStyle: "solid",
+    },
+  },
+}));
 
 export function ProjectPanel() {
   return (
     <section>
       <Box m={2}>
-        <Link
+        <Link name="create-project">
-          name="create-project"
-        >
           <Button
             variant="contained"
             color="primary"
@@ -51,32 +62,23 @@ export function ProjectPanel() {
 }
 
 const ProjectList: FC<{}> = () => {
-  const { data, refetch } = useQuery<{
+  const { data } = useQuery<{
     projects: Project[];
   }>(PROJECTS);
   const projects = data?.projects;
-  const [currentProject, setCurrentProject] = useState<Project | undefined>(
-    undefined
-  );
-  const { current } = useRouter();
 
-  useEffect(() => {
+  const classes = useStyles();
-    const currId = current()?.response?.params.projectId;
-    console.log(currId);
-    setCurrentProject(find(propEq("id", currId), projects ?? []));
-  }, [current, projects]);
 
   const items = projects?.map((item) => (
-    <Link
+    <ActiveLink
-      name="edit-project"
+      name="project-detail"
       params={{ projectId: item.id }}
       key={item.id}
-      onNav={() => setCurrentProject(item)}
     >
-      <ListItem button>
+      <ListItem button className={classes.item}>
         <ListItemText primary={item.name} secondary={item.comment} />
       </ListItem>
-    </Link>
+    </ActiveLink>
   ));
   return <List>{items}</List>;
 };

src/routes.tsx

@@ -1,9 +1,19 @@
 import { ApolloClient, InMemoryCache } from "@apollo/client";
 import { prepareRoutes } from "@curi/router";
 import { omit } from 'ramda';
-import { CreateProjectInput, Project } from './generated/graphql';
+import React from "react";
-import { ProjectEditor } from './projects/project-editor';
+import { ProjectDetail, ProjectEditor, PROJECT } from "./projects";
-import { PROJECT } from './projects/queries';
+import { COMMIT_LIST_QUERY } from './commons/graphql/queries';
+import { CommitList } from './commits/commit-list';
+import { PipelineTaskDetail } from './pipeline-tasks/pipeline-task-detail';
+import { PipelineEditor } from "./pipelines/pipeline-editor";
+import {
+  CreatePipelineInput,
+  CreateProjectInput,
+  Pipeline,
+  Project,
+} from "./generated/graphql";
+import { PIPELINE } from "./pipelines";
 
 export default prepareRoutes([
   {
@@ -12,7 +22,7 @@ export default prepareRoutes([
     respond() {
       return { body: () => <div>DashBoard</div> };
     },
-  },
+  }, // dashboard
   {
     name: "create-project",
     path: "projects/create",
@@ -26,11 +36,14 @@ export default prepareRoutes([
       };
       return { body: () => <ProjectEditor project={input} /> };
     },
-  },
+  }, // create-project
   {
     name: "edit-project",
     path: "projects/:projectId/edit",
-    async resolve(matched, { client }: { client: ApolloClient<InMemoryCache> }) {
+    async resolve(
+      matched,
+      { client }: { client: ApolloClient<InMemoryCache> }
+    ) {
       const { data } = await client.query<{ project: Project }>({
         query: PROJECT,
         variables: { id: matched?.params.projectId },
@@ -44,18 +57,129 @@ export default prepareRoutes([
     respond({ resolved }) {
       return resolved;
     },
+  }, // edit-project
+  {
+    name: "create-pipeline",
+    path: "projects/:projectId/pipelines/create",
+    async resolve(
+      matched,
+      { client }: { client: ApolloClient<InMemoryCache> }
+    ) {
+      const input: CreatePipelineInput = {
+        name: "",
+        branch: "",
+        projectId: matched!.params.projectId,
+        workUnitMetadata: {
+          version: 1,
+          units: [],
         },
+      };
+      return {
+        body: () => <PipelineEditor pipeline={input as any} />,
+      };
+    },
+    respond({ resolved }) {
+      return resolved;
+    },
+  }, // create-pipeline
+  {
+    name: "edit-pipeline",
+    path: "projects/:projectId/pipelines/:pipelineId/edit",
+    async resolve(
+      matched,
+      { client }: { client: ApolloClient<InMemoryCache> }
+    ) {
+      const { data } = await client.query<{ pipeline: Pipeline }>({
+        query: PIPELINE,
+        variables: { id: matched?.params.pipelineId },
+      });
+      return {
+        body: () => <PipelineEditor pipeline={data.pipeline} />,
+      };
+    },
+    respond({ resolved }) {
+      return resolved;
+    },
+  }, // edit-pipeline
   {
     name: "project-detail",
     path: "projects/:projectId",
-    resolve() {
+    async resolve(
-      const body = import(
+      matched,
-        /* webpackChunkName: "article-editor" */ "./projects/project-panel"
+      { client }: { client: ApolloClient<InMemoryCache> }
-      ).then((m) => m.ProjectPanel);
+    ) {
-      return body;
+      const { data } = await client.query<{ project: Project }>({
+        query: PROJECT,
+        variables: { id: matched?.params.projectId },
+      });
+      return {
+        body: () => (
+          <ProjectDetail project={omit(["__typename"], data.project)} />
+        ),
+      };
     },
     respond({ resolved }) {
-      return { body: resolved };
+      return resolved;
     },
+    children: [
+      {
+        name: "pipeline-commits",
+        path: "pipelines/:pipelineId/commits",
+        async resolve(
+          matched,
+          { client }: { client: ApolloClient<InMemoryCache> }
+        ) {
+          const { data } = await client.query<{
+            pipeline: Pipeline;
+            project: Project;
+          }>({
+            query: COMMIT_LIST_QUERY,
+            variables: {
+              projectId: matched?.params.projectId,
+              pipelineId: matched?.params.pipelineId,
             },
+          });
+          return {
+            body: () => (
+              <ProjectDetail project={omit(["__typename"], data.project)}>
+                <CommitList pipeline={omit(["__typename"], data.pipeline)} />
+              </ProjectDetail>
+            ),
+          };
+        },
+        respond({ resolved, error }) {
+          return resolved || <div>Failed</div>;
+        },
+      }, // pipeline-commits
+      {
+        name: "pipeline-task-detail",
+        path: "pipelines/:pipelineId/tasks/:taskId",
+        async resolve(
+          matched,
+          { client }: { client: ApolloClient<InMemoryCache> }
+        ) {
+          const { data } = await client.query<{
+            pipeline: Pipeline;
+            project: Project;
+          }>({
+            query: COMMIT_LIST_QUERY,
+            variables: {
+              projectId: matched?.params.projectId,
+              pipelineId: matched?.params.pipelineId,
+            },
+          });
+          return {
+            body: () => (
+              <ProjectDetail project={omit(["__typename"], data.project)}>
+                <PipelineTaskDetail taskId={matched?.params.taskId} />
+              </ProjectDetail>
+            ),
+          };
+        },
+        respond({ resolved, error }) {
+          return resolved || <div>Failed</div>;
+        },
+      }, // pipeline-task-detail
+    ],
+  }, // project-detail
 ]);

src/utils/deep-omit.ts

@@ -0,0 +1,22 @@
+import { fromPairs, map, omit, pipe, toPairs, type } from "ramda";
+
+export const deepOmit = <T = any, K = any>(
+  names: readonly string[],
+  value: K
+): T => {
+  switch (type(value)) {
+    case "Array":
+      return (value as unknown as Array<any>).map((item: any) =>
+        deepOmit(names, item)
+      ) as unknown as T;
+    case "Object":
+      return pipe(
+        omit(names),
+        toPairs,
+        map(([key, val]) => [key, deepOmit(names, val)] as any),
+        fromPairs
+      )(value) as unknown as T;
+    default:
+      return value as unknown as T;
+  }
+};