Add project management

README.md

@@ -12,7 +12,7 @@
 - [x] Web interface (Next.js) with proxy log viewer.
 - [ ] Add scope support to the proxy.
 - [ ] Full text search (with regex) in proxy log viewer.
-- [ ] Project management.
+- [x] Project management.
 - [ ] Sender module for sending manual HTTP requests, either from scratch or based
       off requests from the proxy log.
 - [ ] Attacker module for automated sending of HTTP requests. Leverage the concurrency
@@ -56,12 +56,7 @@ Alternatively, you can run Hetty via Docker. See: [`dstotijn/hetty`](https://hub
 on Docker Hub.
 
 ```
-$ docker run \
+$ docker run -v $HOME/.hetty:/root/.hetty -p 127.0.0.1:8080:8080 dstotijn/hetty
--v $HOME/.hetty/hetty_key.pem:/root/.hetty/hetty_key.pem \
--v $HOME/.hetty/hetty_cert.pem:/root/.hetty/hetty_cert.pem \
--v $HOME/.hetty/hetty.db:/root/.hetty/hetty.db \
--p 127.0.0.1:8080:8080 \
-dstotijn/hetty
 ```
 
 ## Usage
@@ -80,15 +75,15 @@ Usage of ./hetty:
         File path to admin build
   -cert string
         CA certificate filepath. Creates a new CA certificate is file doesn't exist (default "~/.hetty/hetty_cert.pem")
-  -db string
-        Database file path (default "~/.hetty/hetty.db")
   -key string
         CA private key filepath. Creates a new CA private key if file doesn't exist (default "~/.hetty/hetty_key.pem")
+  -projects string
+        Projects directory path (default "~/.hetty/projects")
 ```
 
 ## Certificate Setup and Installation
 
-In order for Hetty to proxy requests going to HTTPS endpoints, a root CA certificate for 
+In order for Hetty to proxy requests going to HTTPS endpoints, a root CA certificate for
 Hetty will need to be set up. Furthermore, the CA certificate may need to be
 installed to the host for them to be trusted by your browser. The following steps
 will cover how you can generate your certificate, provide them to hetty, and how
@@ -115,7 +110,7 @@ certificate with hetty, simply run the command with no arguments
 hetty
 ```
 
-You should now have a key and certificate located at  `~/.hetty/hetty_key.pem` and
+You should now have a key and certificate located at `~/.hetty/hetty_key.pem` and
 `~/.hetty/hetty_cert.pem` respectively.
 
 #### Generating CA certificates with OpenSSL

admin/src/components/Layout.tsx

@@ -21,12 +21,15 @@ import MenuIcon from "@material-ui/icons/Menu";
 import HomeIcon from "@material-ui/icons/Home";
 import SettingsEthernetIcon from "@material-ui/icons/SettingsEthernet";
 import SendIcon from "@material-ui/icons/Send";
+import FolderIcon from "@material-ui/icons/Folder";
 import ChevronLeftIcon from "@material-ui/icons/ChevronLeft";
 import ChevronRightIcon from "@material-ui/icons/ChevronRight";
 import clsx from "clsx";
 
 export enum Page {
   Home,
+  GetStarted,
+  Projects,
   ProxySetup,
   ProxyLogs,
   Sender,
@@ -233,6 +236,22 @@ export function Layout({ title, page, children }: Props): JSX.Element {
               <ListItemText primary="Sender" />
             </ListItem>
           </Link>
+          <Link href="/projects" passHref>
+            <ListItem
+              button
+              component="a"
+              key="projects"
+              selected={page === Page.Projects}
+              className={classes.listItem}
+            >
+              <Tooltip title="Projects">
+                <ListItemIcon className={classes.listItemIcon}>
+                  <FolderIcon />
+                </ListItemIcon>
+              </Tooltip>
+              <ListItemText primary="Projects" />
+            </ListItem>
+          </Link>
         </List>
       </Drawer>
       <main className={classes.content}>

admin/src/components/projects/NewProject.tsx

@@ -0,0 +1,122 @@
+import { gql, useMutation } from "@apollo/client";
+import {
+  Box,
+  Button,
+  CircularProgress,
+  createStyles,
+  makeStyles,
+  TextField,
+  Theme,
+  Typography,
+} from "@material-ui/core";
+import AddIcon from "@material-ui/icons/Add";
+import React, { useState } from "react";
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    projectName: {
+      marginTop: -6,
+      marginRight: theme.spacing(2),
+    },
+    button: {
+      marginRight: theme.spacing(2),
+    },
+  })
+);
+
+const OPEN_PROJECT = gql`
+  mutation OpenProject($name: String!) {
+    openProject(name: $name) {
+      name
+      isActive
+    }
+  }
+`;
+
+function NewProject(): JSX.Element {
+  const classes = useStyles();
+  const [input, setInput] = useState(null);
+
+  const [openProject, { error, loading }] = useMutation(OPEN_PROJECT, {
+    onError: () => {},
+    onCompleted() {
+      input.value = "";
+    },
+    update(cache, { data: { openProject } }) {
+      cache.modify({
+        fields: {
+          activeProject() {
+            const activeProjRef = cache.writeFragment({
+              id: openProject.name,
+              data: openProject,
+              fragment: gql`
+                fragment ActiveProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return activeProjRef;
+          },
+          projects(_, { DELETE }) {
+            cache.writeFragment({
+              id: openProject.name,
+              data: openProject,
+              fragment: gql`
+                fragment OpenProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return DELETE;
+          },
+        },
+      });
+    },
+  });
+
+  const handleNewProjectForm = (e: React.SyntheticEvent) => {
+    e.preventDefault();
+    openProject({ variables: { name: input.value } });
+  };
+
+  return (
+    <div>
+      <Box mb={3}>
+        <Typography variant="h6">New project</Typography>
+      </Box>
+      <form onSubmit={handleNewProjectForm} autoComplete="off">
+        <TextField
+          className={classes.projectName}
+          color="secondary"
+          inputProps={{
+            id: "projectName",
+            ref: (node) => {
+              setInput(node);
+            },
+          }}
+          label="Project name"
+          placeholder="Project name…"
+          error={Boolean(error)}
+          helperText={error && error.message}
+        />
+        <Button
+          className={classes.button}
+          type="submit"
+          variant="contained"
+          color="secondary"
+          size="large"
+          disabled={loading}
+          startIcon={loading ? <CircularProgress size={22} /> : <AddIcon />}
+        >
+          Create & open project
+        </Button>
+      </form>
+    </div>
+  );
+}
+
+export default NewProject;

admin/src/components/projects/ProjectList.tsx

@@ -0,0 +1,311 @@
+import { gql, useMutation, useQuery } from "@apollo/client";
+import {
+  Avatar,
+  Box,
+  Button,
+  CircularProgress,
+  createStyles,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogContentText,
+  DialogTitle,
+  IconButton,
+  List,
+  ListItem,
+  ListItemAvatar,
+  ListItemSecondaryAction,
+  ListItemText,
+  makeStyles,
+  Snackbar,
+  Theme,
+  Tooltip,
+  Typography,
+} from "@material-ui/core";
+import CloseIcon from "@material-ui/icons/Close";
+import DescriptionIcon from "@material-ui/icons/Description";
+import DeleteIcon from "@material-ui/icons/Delete";
+import LaunchIcon from "@material-ui/icons/Launch";
+import { Alert } from "@material-ui/lab";
+
+import React, { useState } from "react";
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    projectsList: {
+      backgroundColor: theme.palette.background.paper,
+    },
+    activeProject: {
+      color: theme.palette.getContrastText(theme.palette.secondary.main),
+      backgroundColor: theme.palette.secondary.main,
+    },
+    deleteProjectButton: {
+      color: theme.palette.error.main,
+    },
+  })
+);
+
+const PROJECTS = gql`
+  query Projects {
+    projects {
+      name
+      isActive
+    }
+  }
+`;
+
+const OPEN_PROJECT = gql`
+  mutation OpenProject($name: String!) {
+    openProject(name: $name) {
+      name
+      isActive
+    }
+  }
+`;
+
+const CLOSE_PROJECT = gql`
+  mutation CloseProject {
+    closeProject {
+      success
+    }
+  }
+`;
+
+const DELETE_PROJECT = gql`
+  mutation DeleteProject($name: String!) {
+    deleteProject(name: $name) {
+      success
+    }
+  }
+`;
+
+function ProjectList(): JSX.Element {
+  const classes = useStyles();
+  const { loading: projLoading, error: projErr, data: projData } = useQuery(
+    PROJECTS
+  );
+  const [
+    openProject,
+    { error: openProjErr, loading: openProjLoading },
+  ] = useMutation(OPEN_PROJECT, {
+    errorPolicy: "all",
+    onError: () => {},
+    update(cache, { data: { openProject } }) {
+      cache.modify({
+        fields: {
+          activeProject() {
+            const activeProjRef = cache.writeFragment({
+              data: openProject,
+              fragment: gql`
+                fragment ActiveProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return activeProjRef;
+          },
+          projects(_, { DELETE }) {
+            cache.writeFragment({
+              id: openProject.name,
+              data: openProject,
+              fragment: gql`
+                fragment OpenProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return DELETE;
+          },
+        },
+      });
+    },
+  });
+  const [closeProject, { error: closeProjErr }] = useMutation(CLOSE_PROJECT, {
+    errorPolicy: "all",
+    onError: () => {},
+    update(cache) {
+      cache.modify({
+        fields: {
+          activeProject() {
+            return null;
+          },
+          projects(_, { DELETE }) {
+            return DELETE;
+          },
+        },
+      });
+    },
+  });
+  const [
+    deleteProject,
+    { loading: deleteProjLoading, error: deleteProjErr },
+  ] = useMutation(DELETE_PROJECT, {
+    errorPolicy: "all",
+    onError: () => {},
+    update(cache) {
+      cache.modify({
+        fields: {
+          projects(_, { DELETE }) {
+            return DELETE;
+          },
+        },
+      });
+      setDeleteDiagOpen(false);
+      setDeleteNotifOpen(true);
+    },
+  });
+
+  const [deleteProjName, setDeleteProjName] = useState(null);
+  const [deleteDiagOpen, setDeleteDiagOpen] = useState(false);
+  const handleDeleteButtonClick = (name: string) => {
+    setDeleteProjName(name);
+    setDeleteDiagOpen(true);
+  };
+  const handleDeleteConfirm = () => {
+    deleteProject({ variables: { name: deleteProjName } });
+  };
+  const handleDeleteCancel = () => {
+    setDeleteDiagOpen(false);
+  };
+
+  const [deleteNotifOpen, setDeleteNotifOpen] = useState(false);
+  const handleCloseDeleteNotif = (_, reason?: string) => {
+    if (reason === "clickaway") {
+      return;
+    }
+    setDeleteNotifOpen(false);
+  };
+
+  return (
+    <div>
+      <Dialog open={deleteDiagOpen} onClose={handleDeleteCancel}>
+        <DialogTitle>
+          Delete project “<strong>{deleteProjName}</strong>”?
+        </DialogTitle>
+        <DialogContent>
+          <DialogContentText>
+            Deleting a project permanently removes its database file from disk.
+            This action is irreversible.
+          </DialogContentText>
+          {deleteProjErr && (
+            <Alert severity="error">
+              Error closing project: {deleteProjErr.message}
+            </Alert>
+          )}
+        </DialogContent>
+        <DialogActions>
+          <Button onClick={handleDeleteCancel} autoFocus>
+            Cancel
+          </Button>
+          <Button
+            className={classes.deleteProjectButton}
+            onClick={handleDeleteConfirm}
+            disabled={deleteProjLoading}
+          >
+            Delete
+          </Button>
+        </DialogActions>
+      </Dialog>
+
+      <Snackbar
+        open={deleteNotifOpen}
+        autoHideDuration={3000}
+        onClose={handleCloseDeleteNotif}
+      >
+        <Alert onClose={handleCloseDeleteNotif} severity="info">
+          Project <strong>{deleteProjName}</strong> was deleted.
+        </Alert>
+      </Snackbar>
+
+      <Box mb={3}>
+        <Typography variant="h6">Manage projects</Typography>
+      </Box>
+
+      <Box mb={4}>
+        {projLoading && <CircularProgress />}
+        {projErr && (
+          <Alert severity="error">
+            Error fetching projects: {projErr.message}
+          </Alert>
+        )}
+        {openProjErr && (
+          <Alert severity="error">
+            Error opening project: {openProjErr.message}
+          </Alert>
+        )}
+        {closeProjErr && (
+          <Alert severity="error">
+            Error closing project: {closeProjErr.message}
+          </Alert>
+        )}
+      </Box>
+
+      {projData?.projects.length > 0 && (
+        <List className={classes.projectsList}>
+          {projData.projects.map((project) => (
+            <ListItem key={project.name}>
+              <ListItemAvatar>
+                <Avatar
+                  className={
+                    project.isActive ? classes.activeProject : undefined
+                  }
+                >
+                  <DescriptionIcon />
+                </Avatar>
+              </ListItemAvatar>
+              <ListItemText>
+                {project.name} {project.isActive && <em>(Active)</em>}
+              </ListItemText>
+              <ListItemSecondaryAction>
+                {project.isActive && (
+                  <Tooltip title="Close project">
+                    <IconButton onClick={() => closeProject()}>
+                      <CloseIcon />
+                    </IconButton>
+                  </Tooltip>
+                )}
+                {!project.isActive && (
+                  <Tooltip title="Open project">
+                    <span>
+                      <IconButton
+                        disabled={openProjLoading || projLoading}
+                        onClick={() =>
+                          openProject({
+                            variables: { name: project.name },
+                          })
+                        }
+                      >
+                        <LaunchIcon />
+                      </IconButton>
+                    </span>
+                  </Tooltip>
+                )}
+                <Tooltip title="Delete project">
+                  <span>
+                    <IconButton
+                      onClick={() => handleDeleteButtonClick(project.name)}
+                      disabled={project.isActive}
+                    >
+                      <DeleteIcon />
+                    </IconButton>
+                  </span>
+                </Tooltip>
+              </ListItemSecondaryAction>
+            </ListItem>
+          ))}
+        </List>
+      )}
+      {projData?.projects.length === 0 && (
+        <Alert severity="info">
+          There are no projects. Create one to get started.
+        </Alert>
+      )}
+    </div>
+  );
+}
+
+export default ProjectList;

admin/src/components/reqlog/LogsOverview.tsx

@@ -1,7 +1,12 @@
 import { useRouter } from "next/router";
 import { gql, useQuery } from "@apollo/client";
-import { useState } from "react";
+import Link from "next/link";
-import { Box, Typography, CircularProgress } from "@material-ui/core";
+import {
+  Box,
+  Typography,
+  CircularProgress,
+  Link as MaterialLink,
+} from "@material-ui/core";
 import Alert from "@material-ui/lab/Alert";
 
 import RequestList from "./RequestList";
@@ -42,6 +47,17 @@ function LogsOverview(): JSX.Element {
     return <CircularProgress />;
   }
   if (error) {
+    if (error.graphQLErrors[0]?.extensions?.code === "no_active_project") {
+      return (
+        <Alert severity="info">
+          There is no project active.{" "}
+          <Link href="/projects" passHref>
+            <MaterialLink color="secondary">Create or open</MaterialLink>
+          </Link>{" "}
+          one first.
+        </Alert>
+      );
+    }
     return <Alert severity="error">Error fetching logs: {error.message}</Alert>;
   }
 

admin/src/lib/graphql.ts

@@ -1,6 +1,5 @@
 import { useMemo } from "react";
 import { ApolloClient, HttpLink, InMemoryCache } from "@apollo/client";
-import { concatPagination } from "@apollo/client/utilities";
 
 let apolloClient;
 
@@ -12,10 +11,8 @@ function createApolloClient() {
     }),
     cache: new InMemoryCache({
       typePolicies: {
-        Query: {
+        Project: {
-          fields: {
+          keyFields: ["name"],
-            allPosts: concatPagination(),
-          },
         },
       },
     }),

admin/src/lib/theme.ts

@@ -11,6 +11,12 @@ const theme = createMuiTheme({
     secondary: {
       main: teal["A400"],
     },
+    info: {
+      main: teal["A400"],
+    },
+    success: {
+      main: teal["A400"],
+    },
   },
   typography: {
     h2: {

admin/src/pages/get-started/index.tsx

@@ -0,0 +1,36 @@
+import { Box, Link as MaterialLink, Typography } from "@material-ui/core";
+import Link from "next/link";
+
+import React from "react";
+
+import Layout, { Page } from "../../components/Layout";
+
+function Index(): JSX.Element {
+  return (
+    <Layout page={Page.GetStarted} title="Get started">
+      <Box p={4}>
+        <Box mb={3}>
+          <Typography variant="h4">Get started</Typography>
+        </Box>
+        <Typography paragraph>
+          You’ve loaded a (new) project. What’s next? You can now use the MITM
+          proxy and review HTTP requests and responses via the{" "}
+          <Link href="/proxy/logs" passHref>
+            <MaterialLink color="secondary">Proxy logs</MaterialLink>
+          </Link>
+          . Stuck? Ask for help on the{" "}
+          <MaterialLink
+            href="https://github.com/dstotijn/hetty/discussions"
+            color="secondary"
+            target="_blank"
+          >
+            Discussions forum
+          </MaterialLink>
+          .
+        </Typography>
+      </Box>
+    </Layout>
+  );
+}
+
+export default Index;

admin/src/pages/index.tsx

@@ -1,17 +1,30 @@
 import {
+  Avatar,
   Box,
   Button,
+  CircularProgress,
   createStyles,
-  IconButton,
+  List,
+  ListItem,
+  ListItemAvatar,
+  ListItemText,
   makeStyles,
+  TextField,
   Theme,
   Typography,
 } from "@material-ui/core";
-import SettingsEthernetIcon from "@material-ui/icons/SettingsEthernet";
+import AddIcon from "@material-ui/icons/Add";
-import SendIcon from "@material-ui/icons/Send";
+import FolderIcon from "@material-ui/icons/Folder";
+import DescriptionIcon from "@material-ui/icons/Description";
+import PlayArrowIcon from "@material-ui/icons/PlayArrow";
 import Link from "next/link";
 
+import { useState } from "react";
+import { gql, useMutation, useQuery } from "@apollo/client";
+import { useRouter } from "next/router";
+
 import Layout, { Page } from "../components/Layout";
+import { Alert } from "@material-ui/lab";
 
 const useStyles = makeStyles((theme: Theme) =>
   createStyles({
@@ -24,14 +37,108 @@ const useStyles = makeStyles((theme: Theme) =>
       lineHeight: 2,
       marginBottom: theme.spacing(5),
     },
+    projectName: {
+      marginTop: -6,
+      marginRight: theme.spacing(2),
+    },
     button: {
       marginRight: theme.spacing(2),
     },
+    activeProject: {
+      color: theme.palette.getContrastText(theme.palette.secondary.main),
+      backgroundColor: theme.palette.secondary.main,
+    },
   })
 );
 
+const ACTIVE_PROJECT = gql`
+  query ActiveProject {
+    activeProject {
+      name
+    }
+  }
+`;
+
+const OPEN_PROJECT = gql`
+  mutation OpenProject($name: String!) {
+    openProject(name: $name) {
+      name
+      isActive
+    }
+  }
+`;
+
 function Index(): JSX.Element {
   const classes = useStyles();
+  const router = useRouter();
+  const [input, setInput] = useState(null);
+  const { error: activeProjErr, data: activeProjData } = useQuery(
+    ACTIVE_PROJECT,
+    {
+      pollInterval: 1000,
+    }
+  );
+  const [
+    openProject,
+    { error: openProjErr, data: openProjData, loading: openProjLoading },
+  ] = useMutation(OPEN_PROJECT, {
+    onError: () => {},
+    onCompleted({ openProject }) {
+      if (openProject) {
+        router.push("/get-started");
+      }
+    },
+    update(cache, { data: { openProject } }) {
+      cache.modify({
+        fields: {
+          activeProject() {
+            const activeProjRef = cache.writeFragment({
+              id: openProject.name,
+              data: openProject,
+              fragment: gql`
+                fragment ActiveProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return activeProjRef;
+          },
+          projects(_, { DELETE }) {
+            cache.writeFragment({
+              id: openProject.name,
+              data: openProject,
+              fragment: gql`
+                fragment OpenProject on Project {
+                  name
+                  isActive
+                  type
+                }
+              `,
+            });
+            return DELETE;
+          },
+        },
+      });
+    },
+  });
+
+  const handleForm = (e: React.SyntheticEvent) => {
+    e.preventDefault();
+    openProject({ variables: { name: input.value } });
+  };
+
+  if (activeProjErr) {
+    return (
+      <Layout page={Page.Home} title="">
+        <Alert severity="error">
+          Error fetching active project: {activeProjErr.message}
+        </Alert>
+      </Layout>
+    );
+  }
+
   return (
     <Layout page={Page.Home} title="">
       <Box p={4}>
@@ -42,38 +149,105 @@ function Index(): JSX.Element {
             The simple HTTP toolkit for security research.
           </Typography>
         </Box>
+
         <Typography className={classes.subtitle} paragraph>
           What if security testing was intuitive, powerful, and good looking?
           What if it was <strong>free</strong>, instead of $400 per year?{" "}
           <span className={classes.titleHighlight}>Hetty</span> is listening on{" "}
           <code>:8080</code>…
         </Typography>
-        <Box>
+
-          <Link href="/proxy" passHref>
+        {activeProjData?.activeProject?.name ? (
+          <div>
+            <Box mb={1}>
+              <Typography variant="h6">Active project:</Typography>
+            </Box>
+            <Box ml={-2} mb={2}>
+              <List>
+                <ListItem>
+                  <ListItemAvatar>
+                    <Avatar className={classes.activeProject}>
+                      <DescriptionIcon />
+                    </Avatar>
+                  </ListItemAvatar>
+                  <ListItemText primary={activeProjData.activeProject.name} />
+                </ListItem>
+              </List>
+            </Box>
+            <div>
+              <Link href="/get-started" passHref>
+                <Button
+                  className={classes.button}
+                  variant="outlined"
+                  component="a"
+                  color="secondary"
+                  size="large"
+                  startIcon={<PlayArrowIcon />}
+                >
+                  Get started
+                </Button>
+              </Link>
+              <Link href="/projects" passHref>
+                <Button
+                  className={classes.button}
+                  variant="outlined"
+                  component="a"
+                  size="large"
+                  startIcon={<FolderIcon />}
+                >
+                  Manage projects
+                </Button>
+              </Link>
+            </div>
+          </div>
+        ) : (
+          <form onSubmit={handleForm} autoComplete="off">
+            <TextField
+              className={classes.projectName}
+              color="secondary"
+              inputProps={{
+                id: "projectName",
+                ref: (node) => {
+                  setInput(node);
+                },
+              }}
+              label="Project name"
+              placeholder="Project name…"
+              error={Boolean(openProjErr)}
+              helperText={openProjErr && openProjErr.message}
+            />
             <Button
               className={classes.button}
+              type="submit"
               variant="contained"
               color="secondary"
-              component="a"
               size="large"
-              startIcon={<SettingsEthernetIcon />}
+              disabled={
+                openProjLoading || Boolean(openProjData?.openProject?.name)
+              }
+              startIcon={
+                openProjLoading || openProjData?.openProject ? (
+                  <CircularProgress size={22} />
+                ) : (
+                  <AddIcon />
+                )
+              }
             >
-              Setup proxy
+              Create project
             </Button>
-          </Link>
+            <Link href="/projects" passHref>
-          <Link href="/proxy" passHref>
+              <Button
-            <Button
+                className={classes.button}
-              className={classes.button}
+                variant="outlined"
-              variant="contained"
+                component="a"
-              color="primary"
+                size="large"
-              component="a"
+                startIcon={<FolderIcon />}
-              size="large"
+              >
-              startIcon={<SendIcon />}
+                Open project…
-            >
+              </Button>
-              Send HTTP requests
+            </Link>
-            </Button>
+          </form>
-          </Link>
+        )}
-        </Box>
       </Box>
     </Layout>
   );

admin/src/pages/projects/index.tsx

@@ -0,0 +1,33 @@
+import { Box, Divider, Grid, Typography } from "@material-ui/core";
+import Layout, { Page } from "../../components/Layout";
+import NewProject from "../../components/projects/NewProject";
+import ProjectList from "../../components/projects/ProjectList";
+
+function Index(): JSX.Element {
+  return (
+    <Layout page={Page.Projects} title="Projects">
+      <Box p={4}>
+        <Box mb={3}>
+          <Typography variant="h4">Projects</Typography>
+        </Box>
+        <Typography paragraph>
+          Projects contain settings and data generated/processed by Hetty. They
+          are stored as SQLite database files on disk.
+        </Typography>
+        <Box my={4}>
+          <Divider />
+        </Box>
+        <Box mb={8}>
+          <NewProject />
+        </Box>
+        <Grid container>
+          <Grid item xs={12} sm={8} md={6} lg={6}>
+            <ProjectList />
+          </Grid>
+        </Grid>
+      </Box>
+    </Layout>
+  );
+}
+
+export default Index;

cmd/hetty/main.go

@@ -11,10 +11,9 @@ import (
 
 	rice "github.com/GeertJohan/go.rice"
 	"github.com/dstotijn/hetty/pkg/api"
-	"github.com/dstotijn/hetty/pkg/db/sqlite"
+	"github.com/dstotijn/hetty/pkg/proj"
 	"github.com/dstotijn/hetty/pkg/proxy"
 	"github.com/dstotijn/hetty/pkg/reqlog"
-	"github.com/dstotijn/hetty/pkg/scope"
 
 	"github.com/99designs/gqlgen/graphql/handler"
 	"github.com/99designs/gqlgen/graphql/playground"
@@ -25,7 +24,7 @@ import (
 var (
 	caCertFile string
 	caKeyFile  string
-	dbFile     string
+	projPath   string
 	addr       string
 	adminPath  string
 )
@@ -33,7 +32,7 @@ var (
 func main() {
 	flag.StringVar(&caCertFile, "cert", "~/.hetty/hetty_cert.pem", "CA certificate filepath. Creates a new CA certificate is file doesn't exist")
 	flag.StringVar(&caKeyFile, "key", "~/.hetty/hetty_key.pem", "CA private key filepath. Creates a new CA private key if file doesn't exist")
-	flag.StringVar(&dbFile, "db", "~/.hetty/hetty.db", "Database file path")
+	flag.StringVar(&projPath, "projects", "~/.hetty/projects", "Projects directory path")
 	flag.StringVar(&addr, "addr", ":8080", "TCP address to listen on, in the form \"host:port\"")
 	flag.StringVar(&adminPath, "adminPath", "", "File path to admin build")
 	flag.Parse()
@@ -47,9 +46,9 @@ func main() {
 	if err != nil {
 		log.Fatalf("[FATAL] Could not parse CA private key filepath: %v", err)
 	}
-	dbFile, err := homedir.Expand(dbFile)
+	projPath, err := homedir.Expand(projPath)
 	if err != nil {
-		log.Fatalf("[FATAL] Could not parse CA private key filepath: %v", err)
+		log.Fatalf("[FATAL] Could not parse projects filepath: %v", err)
 	}
 
 	// Load existing CA certificate and key from disk, or generate and write
@@ -59,16 +58,15 @@ func main() {
 		log.Fatalf("[FATAL] Could not create/load CA key pair: %v", err)
 	}
 
-	db, err := sqlite.New(dbFile)
+	projService, err := proj.NewService(projPath)
 	if err != nil {
-		log.Fatalf("[FATAL] Could not initialize database: %v", err)
+		log.Fatalf("[FATAL] Could not create new project service: %v", err)
 	}
-	defer db.Close()
+	defer projService.Close()
 
-	scope := scope.New(nil)
 	reqLogService := reqlog.NewService(reqlog.Config{
-		Scope:      scope,
+		Scope:      projService.Scope,
-		Repository: db,
+		Repository: projService.Database(),
 	})
 
 	p, err := proxy.NewProxy(caCert, caKey)
@@ -103,6 +101,7 @@ func main() {
 	adminRouter.Path("/api/playground/").Handler(playground.Handler("GraphQL Playground", "/api/graphql/"))
 	adminRouter.Path("/api/graphql/").Handler(handler.NewDefaultServer(api.NewExecutableSchema(api.Config{Resolvers: &api.Resolver{
 		RequestLogService: reqLogService,
+		ProjectService:    projService,
 	}})))
 
 	// Admin interface.

go.mod

@@ -3,16 +3,15 @@ module github.com/dstotijn/hetty
 go 1.15
 
 require (
-	github.com/99designs/gqlgen v0.11.3
+	github.com/99designs/gqlgen v0.13.0
 	github.com/GeertJohan/go.rice v1.0.0
 	github.com/Masterminds/squirrel v1.4.0
 	github.com/gorilla/mux v1.7.4
-	github.com/gorilla/websocket v1.4.0 // indirect
 	github.com/hashicorp/golang-lru v0.5.1 // indirect
 	github.com/jmoiron/sqlx v1.2.0
 	github.com/mattn/go-sqlite3 v1.14.4
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mitchellh/mapstructure v1.1.2 // indirect
-	github.com/vektah/gqlparser/v2 v2.0.1
+	github.com/vektah/gqlparser/v2 v2.1.0
 	google.golang.org/appengine v1.6.6 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
 github.com/99designs/gqlgen v0.11.3 h1:oFSxl1DFS9X///uHV3y6CEfpcXWrDUxVblR4Xib2bs4=
 github.com/99designs/gqlgen v0.11.3/go.mod h1:RgX5GRRdDWNkh4pBrdzNpNPFVsdoUFY2+adM6nb1N+4=
+github.com/99designs/gqlgen v0.13.0 h1:haLTcUp3Vwp80xMVEg5KRNwzfUrgFdRmtBY8fuB8scA=
+github.com/99designs/gqlgen v0.13.0/go.mod h1:NV130r6f4tpRWuAI+zsrSdooO/eWUv+Gyyoi3rEfXIk=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/GeertJohan/go.incremental v1.0.0 h1:7AH+pY1XUgQE4Y1HcXYaMqAI0m9yrFqo/jt0CW30vsg=
 github.com/GeertJohan/go.incremental v1.0.0/go.mod h1:6fAjUhbVuX1KcMD3c8TEgVUqmo4seqhv0i0kdATSkM0=
@@ -39,6 +41,8 @@ github.com/gorilla/websocket v1.2.0 h1:VJtLvh6VQym50czpZzx07z/kw9EgAxI3x1ZB8taTM
 github.com/gorilla/websocket v1.2.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
@@ -105,6 +109,8 @@ github.com/vektah/dataloaden v0.2.1-0.20190515034641-a19b9a6e7c9e h1:+w0Zm/9gaWp
 github.com/vektah/dataloaden v0.2.1-0.20190515034641-a19b9a6e7c9e/go.mod h1:/HUdMve7rvxZma+2ZELQeNh88+003LL7Pf/CZ089j8U=
 github.com/vektah/gqlparser/v2 v2.0.1 h1:xgl5abVnsd4hkN9rk65OJID9bfcLSMuTaTcZj777q1o=
 github.com/vektah/gqlparser/v2 v2.0.1/go.mod h1:SyUiHgLATUR8BiYURfTirrTcGpcE+4XkV2se04Px1Ms=
+github.com/vektah/gqlparser/v2 v2.1.0 h1:uiKJ+T5HMGGQM2kRKQ8Pxw8+Zq9qhhZhz/lieYvCMns=
+github.com/vektah/gqlparser/v2 v2.1.0/go.mod h1:SyUiHgLATUR8BiYURfTirrTcGpcE+4XkV2se04Px1Ms=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

pkg/api/models_gen.go

@@ -9,6 +9,14 @@ import (
 	"time"
 )
 
+type CloseProjectResult struct {
+	Success bool `json:"success"`
+}
+
+type DeleteProjectResult struct {
+	Success bool `json:"success"`
+}
+
 type HTTPHeader struct {
 	Key   string `json:"key"`
 	Value string `json:"value"`
@@ -34,6 +42,11 @@ type HTTPResponseLog struct {
 	Headers      []HTTPHeader `json:"headers"`
 }
 
+type Project struct {
+	Name     string `json:"name"`
+	IsActive bool   `json:"isActive"`
+}
+
 type HTTPMethod string
 
 const (

pkg/api/resolvers.go

@@ -7,20 +7,35 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/dstotijn/hetty/pkg/proj"
 	"github.com/dstotijn/hetty/pkg/reqlog"
+	"github.com/vektah/gqlparser/v2/gqlerror"
 )
 
 type Resolver struct {
 	RequestLogService *reqlog.Service
+	ProjectService    *proj.Service
 }
 
 type queryResolver struct{ *Resolver }
+type mutationResolver struct{ *Resolver }
 
-func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
+func (r *Resolver) Query() QueryResolver       { return &queryResolver{r} }
+func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
 
 func (r *queryResolver) HTTPRequestLogs(ctx context.Context) ([]HTTPRequestLog, error) {
 	opts := reqlog.FindRequestsOptions{OmitOutOfScope: false}
 	reqs, err := r.RequestLogService.FindRequests(ctx, opts)
+	if err == reqlog.ErrNoProject {
+		return nil, &gqlerror.Error{
+			Path:    graphql.GetPath(ctx),
+			Message: "No active project.",
+			Extensions: map[string]interface{}{
+				"code": "no_active_project",
+			},
+		}
+	}
 	if err != nil {
 		return nil, fmt.Errorf("could not query repository for requests: %v", err)
 	}
@@ -116,3 +131,65 @@ func parseRequestLog(req reqlog.Request) (HTTPRequestLog, error) {
 
 	return log, nil
 }
+
+func (r *mutationResolver) OpenProject(ctx context.Context, name string) (*Project, error) {
+	p, err := r.ProjectService.Open(name)
+	if err == proj.ErrInvalidName {
+		return nil, gqlerror.Errorf("Project name must only contain alphanumeric or space chars.")
+	}
+	if err != nil {
+		return nil, fmt.Errorf("could not open project: %v", err)
+	}
+	return &Project{
+		Name:     p.Name,
+		IsActive: p.IsActive,
+	}, nil
+}
+
+func (r *queryResolver) ActiveProject(ctx context.Context) (*Project, error) {
+	p, err := r.ProjectService.ActiveProject()
+	if err == proj.ErrNoProject {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("could not open project: %v", err)
+	}
+
+	return &Project{
+		Name:     p.Name,
+		IsActive: p.IsActive,
+	}, nil
+}
+
+func (r *queryResolver) Projects(ctx context.Context) ([]Project, error) {
+	p, err := r.ProjectService.Projects()
+	if err != nil {
+		return nil, fmt.Errorf("could not get projects: %v", err)
+	}
+
+	projects := make([]Project, len(p))
+	for i, proj := range p {
+		projects[i] = Project{
+			Name:     proj.Name,
+			IsActive: proj.IsActive,
+		}
+	}
+
+	return projects, nil
+}
+
+func (r *mutationResolver) CloseProject(ctx context.Context) (*CloseProjectResult, error) {
+	if err := r.ProjectService.Close(); err != nil {
+		return nil, fmt.Errorf("could not close project: %v", err)
+	}
+	return &CloseProjectResult{true}, nil
+}
+
+func (r *mutationResolver) DeleteProject(ctx context.Context, name string) (*DeleteProjectResult, error) {
+	if err := r.ProjectService.Delete(name); err != nil {
+		return nil, fmt.Errorf("could not delete project: %v", err)
+	}
+	return &DeleteProjectResult{
+		Success: true,
+	}, nil
+}

pkg/api/schema.graphql

@@ -23,9 +23,30 @@ type HttpHeader {
   value: String!
 }
 
+type Project {
+  name: String!
+  isActive: Boolean!
+}
+
+type CloseProjectResult {
+  success: Boolean!
+}
+
+type DeleteProjectResult {
+  success: Boolean!
+}
+
 type Query {
   httpRequestLog(id: ID!): HttpRequestLog
   httpRequestLogs: [HttpRequestLog!]!
+  activeProject: Project
+  projects: [Project!]!
+}
+
+type Mutation {
+  openProject(name: String!): Project
+  closeProject: CloseProjectResult!
+  deleteProject(name: String!): DeleteProjectResult!
 }
 
 enum HttpMethod {

pkg/db/sqlite/sqlite.go

@@ -3,11 +3,10 @@ package sqlite
 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
-	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/dstotijn/hetty/pkg/reqlog"
@@ -33,13 +32,10 @@ type httpRequestLogsQuery struct {
 	joinResponse       bool
 }
 
-// New returns a new Client.
+// Open opens a database.
-func New(filename string) (*Client, error) {
+func (c *Client) Open(filename string) error {
-	// Create directory for DB if it doesn't exist yet.
+	if c.db != nil {
-	if dbDir, _ := filepath.Split(filename); dbDir != "" {
+		return errors.New("sqlite: database already open")
-		if _, err := os.Stat(dbDir); os.IsNotExist(err) {
-			os.Mkdir(dbDir, 0755)
-		}
 	}
 
 	opts := make(url.Values)
@@ -48,24 +44,24 @@ func New(filename string) (*Client, error) {
 	dsn := fmt.Sprintf("file:%v?%v", filename, opts.Encode())
 	db, err := sqlx.Open("sqlite3", dsn)
 	if err != nil {
-		return nil, err
+		return fmt.Errorf("sqlite: could not open database: %v", err)
 	}
 
 	if err := db.Ping(); err != nil {
-		return nil, fmt.Errorf("sqlite: could not ping database: %v", err)
+		return fmt.Errorf("sqlite: could not ping database: %v", err)
 	}
 
-	c := &Client{db: db}
+	if err := prepareSchema(db); err != nil {
-
+		return fmt.Errorf("sqlite: could not prepare schema: %v", err)
-	if err := c.prepareSchema(); err != nil {
-		return nil, fmt.Errorf("sqlite: could not prepare schema: %v", err)
 	}
 
-	return &Client{db: db}, nil
+	c.db = db
+
+	return nil
 }
 
-func (c Client) prepareSchema() error {
+func prepareSchema(db *sqlx.DB) error {
-	_, err := c.db.Exec(`CREATE TABLE IF NOT EXISTS http_requests (
+	_, err := db.Exec(`CREATE TABLE IF NOT EXISTS http_requests (
 		id INTEGER PRIMARY KEY,
 		proto TEXT,
 		url TEXT,
@@ -77,7 +73,7 @@ func (c Client) prepareSchema() error {
 		return fmt.Errorf("could not create http_requests table: %v", err)
 	}
 
-	_, err = c.db.Exec(`CREATE TABLE IF NOT EXISTS http_responses (
+	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS http_responses (
 		id INTEGER PRIMARY KEY,
 		req_id INTEGER REFERENCES http_requests(id) ON DELETE CASCADE,
 		proto TEXT,
@@ -90,7 +86,7 @@ func (c Client) prepareSchema() error {
 		return fmt.Errorf("could not create http_responses table: %v", err)
 	}
 
-	_, err = c.db.Exec(`CREATE TABLE IF NOT EXISTS http_headers (
+	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS http_headers (
 		id INTEGER PRIMARY KEY,
 		req_id INTEGER REFERENCES http_requests(id) ON DELETE CASCADE,
 		res_id INTEGER REFERENCES http_responses(id) ON DELETE CASCADE,
@@ -104,9 +100,16 @@ func (c Client) prepareSchema() error {
 	return nil
 }
 
-// Close uses the underlying database.
+// Close uses the underlying database if it's open.
 func (c *Client) Close() error {
-	return c.db.Close()
+	if c.db == nil {
+		return nil
+	}
+	if err := c.db.Close(); err != nil {
+		return fmt.Errorf("sqlite: could not close database: %v", err)
+	}
+	c.db = nil
+	return nil
 }
 
 var reqFieldToColumnMap = map[string]string{
@@ -136,6 +139,10 @@ func (c *Client) FindRequestLogs(
 	opts reqlog.FindRequestsOptions,
 	scope *scope.Scope,
 ) (reqLogs []reqlog.Request, err error) {
+	if c.db == nil {
+		return nil, reqlog.ErrNoProject
+	}
+
 	httpReqLogsQuery := parseHTTPRequestLogsQuery(ctx)
 
 	reqQuery := sq.
@@ -178,6 +185,9 @@ func (c *Client) FindRequestLogs(
 }
 
 func (c *Client) FindRequestLogByID(ctx context.Context, id int64) (reqlog.Request, error) {
+	if c.db == nil {
+		return reqlog.Request{}, reqlog.ErrNoProject
+	}
 	httpReqLogsQuery := parseHTTPRequestLogsQuery(ctx)
 
 	reqQuery := sq.
@@ -218,6 +228,9 @@ func (c *Client) AddRequestLog(
 	body []byte,
 	timestamp time.Time,
 ) (*reqlog.Request, error) {
+	if c.db == nil {
+		return nil, reqlog.ErrNoProject
+	}
 
 	reqLog := &reqlog.Request{
 		Request:   req,
@@ -289,6 +302,10 @@ func (c *Client) AddResponseLog(
 	body []byte,
 	timestamp time.Time,
 ) (*reqlog.Response, error) {
+	if c.db == nil {
+		return nil, reqlog.ErrNoProject
+	}
+
 	resLog := &reqlog.Response{
 		RequestID: reqID,
 		Response:  res,
@@ -495,3 +512,7 @@ func (c *Client) queryHeaders(
 
 	return nil
 }
+
+func (c *Client) IsOpen() bool {
+	return c.db != nil
+}

pkg/proj/proj.go

@@ -0,0 +1,135 @@
+package proj
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/dstotijn/hetty/pkg/db/sqlite"
+	"github.com/dstotijn/hetty/pkg/scope"
+)
+
+// Service is used for managing projects.
+type Service struct {
+	dbPath string
+	db     *sqlite.Client
+	name   string
+
+	Scope *scope.Scope
+}
+
+type Project struct {
+	Name     string
+	IsActive bool
+}
+
+var (
+	ErrNoProject   = errors.New("proj: no open project")
+	ErrInvalidName = errors.New("proj: invalid name, must be alphanumeric or whitespace chars")
+)
+
+var nameRegexp = regexp.MustCompile(`^[\w\d\s]+$`)
+
+// NewService returns a new Service.
+func NewService(dbPath string) (*Service, error) {
+	// Create directory for DBs if it doesn't exist yet.
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+		if err := os.MkdirAll(dbPath, 0755); err != nil {
+			return nil, fmt.Errorf("proj: could not create project directory: %v", err)
+		}
+	}
+
+	return &Service{
+		dbPath: dbPath,
+		db:     &sqlite.Client{},
+		Scope:  scope.New(nil),
+	}, nil
+}
+
+// Close closes the currently open project database (if there is one).
+func (svc *Service) Close() error {
+	if err := svc.db.Close(); err != nil {
+		return fmt.Errorf("proj: could not close project: %v", err)
+	}
+	svc.name = ""
+	return nil
+}
+
+// Delete removes a project database file from disk (if there is one).
+func (svc *Service) Delete(name string) error {
+	if name == "" {
+		return errors.New("proj: name cannot be empty")
+	}
+	if svc.name == name {
+		return fmt.Errorf("proj: project (%v) is active", name)
+	}
+
+	if err := os.Remove(filepath.Join(svc.dbPath, name+".db")); err != nil {
+		return fmt.Errorf("proj: could not remove database file: %v", err)
+	}
+
+	return nil
+}
+
+// Database returns the currently open database. If no database is open, it will
+// return `nil`.
+func (svc *Service) Database() *sqlite.Client {
+	return svc.db
+}
+
+// Open opens a database identified with `name`. If a database with this
+// identifier doesn't exist yet, it will be automatically created.
+func (svc *Service) Open(name string) (Project, error) {
+	if !nameRegexp.MatchString(name) {
+		return Project{}, ErrInvalidName
+	}
+	if err := svc.db.Close(); err != nil {
+		return Project{}, fmt.Errorf("proj: could not close previously open database: %v", err)
+	}
+
+	dbPath := filepath.Join(svc.dbPath, name+".db")
+
+	err := svc.db.Open(dbPath)
+	if err != nil {
+		return Project{}, fmt.Errorf("proj: could not open database: %v", err)
+	}
+
+	svc.name = name
+
+	return Project{
+		Name:     name,
+		IsActive: true,
+	}, nil
+}
+
+func (svc *Service) ActiveProject() (Project, error) {
+	if !svc.db.IsOpen() {
+		return Project{}, ErrNoProject
+	}
+
+	return Project{
+		Name: svc.name,
+	}, nil
+}
+
+func (svc *Service) Projects() ([]Project, error) {
+	files, err := ioutil.ReadDir(svc.dbPath)
+	if err != nil {
+		return nil, fmt.Errorf("proj: could not read projects directory: %v", err)
+	}
+
+	projects := make([]Project, len(files))
+	for i, file := range files {
+		projName := strings.TrimSuffix(file.Name(), ".db")
+		projects[i] = Project{
+			Name:     projName,
+			IsActive: svc.name == projName,
+		}
+	}
+
+	return projects, nil
+}

pkg/proxy/cert.go

@@ -83,13 +83,13 @@ func LoadOrCreateCA(caKeyFile, caCertFile string) (*x509.Certificate, *rsa.Priva
 	keyDir, _ := filepath.Split(caKeyFile)
 	if keyDir != "" {
 		if _, err := os.Stat(keyDir); os.IsNotExist(err) {
-			os.Mkdir(keyDir, 0755)
+			os.MkdirAll(keyDir, 0755)
 		}
 	}
 	keyDir, _ = filepath.Split(caCertFile)
 	if keyDir != "" {
 		if _, err := os.Stat("keyDir"); os.IsNotExist(err) {
-			os.Mkdir(keyDir, 0755)
+			os.MkdirAll(keyDir, 0755)
 		}
 	}
 

pkg/reqlog/repo.go

@@ -8,6 +8,10 @@ import (
 	"github.com/dstotijn/hetty/pkg/scope"
 )
 
+type RepositoryProvider interface {
+	Repository() Repository
+}
+
 type Repository interface {
 	FindRequestLogs(ctx context.Context, opts FindRequestsOptions, scope *scope.Scope) ([]Request, error)
 	FindRequestLogByID(ctx context.Context, id int64) (Request, error)

pkg/reqlog/reqlog.go

@@ -19,7 +19,10 @@ type contextKey int
 
 const LogBypassedKey contextKey = 0
 
-var ErrRequestNotFound = errors.New("reqlog: request not found")
+var (
+	ErrRequestNotFound = errors.New("reqlog: request not found")
+	ErrNoProject       = errors.New("reqlog: no project")
+)
 
 type Request struct {
 	ID        int64
@@ -133,6 +136,11 @@ func (svc *Service) RequestModifier(next proxy.RequestModifyFunc) proxy.RequestM
 		}
 
 		reqLog, err := svc.addRequest(req.Context(), *clone, body, now)
+		if err == ErrNoProject {
+			ctx := context.WithValue(req.Context(), LogBypassedKey, true)
+			*req = *req.WithContext(ctx)
+			return
+		}
 		if err != nil {
 			log.Printf("[ERROR] Could not store request log: %v", err)
 			return