9 |
15 | );
16 | }
17 |
--------------------------------------------------------------------------------
/monoid-ui/src/reportWebVitals.ts:
--------------------------------------------------------------------------------
1 | import { ReportHandler } from 'web-vitals';
2 |
3 | const reportWebVitals = (onPerfEntry?: ReportHandler) => {
4 | if (onPerfEntry && onPerfEntry instanceof Function) {
5 | import('web-vitals').then(({
6 | getCLS, getFID, getFCP, getLCP, getTTFB,
7 | }) => {
8 | getCLS(onPerfEntry);
9 | getFID(onPerfEntry);
10 | getFCP(onPerfEntry);
11 | getLCP(onPerfEntry);
12 | getTTFB(onPerfEntry);
13 | });
14 | }
15 | };
16 |
17 | export default reportWebVitals;
18 |
--------------------------------------------------------------------------------
/docusaurus/blog/authors.yml:
--------------------------------------------------------------------------------
1 | endi:
2 | name: Endilie Yacop Sucipto
3 | title: Maintainer of Docusaurus
4 | url: https://github.com/endiliey
5 | image_url: https://github.com/endiliey.png
6 |
7 | yangshun:
8 | name: Yangshun Tay
9 | title: Front End Engineer @ Facebook
10 | url: https://github.com/yangshun
11 | image_url: https://github.com/yangshun.png
12 |
13 | slorber:
14 | name: Sébastien Lorber
15 | title: Docusaurus maintainer
16 | url: https://sebastienlorber.com
17 | image_url: https://github.com/slorber.png
18 |
--------------------------------------------------------------------------------
/monoid-ui/src/pages/Identifiers/IdentifierRoutes.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Route, Routes } from 'react-router-dom';
3 | import NewPrimaryKeyPage from './pages/NewPrimaryKeyPage/NewPrimaryKeyPage';
4 | import UserIdentifiersList from './pages/UserIdentifiersList/UserIdentifiersList';
5 |
6 | export default function IdentifierRoutes() {
7 | return (
8 |
11 |
14 |
8 |
12 | );
13 | }
14 |
15 | PageCenter.defaultProps = {
16 | className: '',
17 | };
18 |
--------------------------------------------------------------------------------
/monoid-api/config-data/data-categories.yaml:
--------------------------------------------------------------------------------
1 | - name: Last Name
2 | id: surname
3 | - name: Phone Number
4 | id: phone
5 | - name: Date of Birth
6 | id: date_of_birth
7 | - name: Postal Code
8 | id: postal_code
9 | - name: Oauth Token
10 | id: oauth_token
11 | - name: User ID
12 | id: user_id
13 | - name: Location
14 | id: location
15 | - name: Email
16 | id: email
17 | - name: IP Address
18 | id: ip
19 | - name: Credit Card
20 | id: credit_card
21 | - name: SSN
22 | id: ssn
23 | - name: Street Address
24 | id: street
25 | - name: MAC Address
26 | id: mac
27 |
--------------------------------------------------------------------------------
/monoid-api/scanner/types.go:
--------------------------------------------------------------------------------
1 | package scanner
2 |
3 | import "github.com/monoid-privacy/monoid/monoidprotocol"
4 |
5 | type RuleMatch struct {
6 | RuleName string
7 | DisplayName string
8 | Confidence string
9 | Identifier string
10 | MatchedData []string
11 | MatchType string
12 | SchemaName string
13 | SchemaGroup *string
14 | LineCount int
15 | }
16 |
17 | type SchemaRecordGroup struct {
18 | Schema monoidprotocol.MonoidSchema
19 | Records []monoidprotocol.MonoidRecord
20 | }
21 |
22 | type ValuePath struct {
23 | Path []string
24 | Type string
25 | }
26 |
--------------------------------------------------------------------------------
/monoid-ui/src/pages/Silos/pages/SiloIndexPage/SiloIndex.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import Button from '../../../../components/Button';
3 | import PageHeader from '../../../../components/PageHeader';
4 | import SiloList from './components/SiloList';
5 |
6 | export default function SiloIndex() {
7 | return (
8 | <>
9 |
9 | {children}
10 |
11 |
12 |
21 | );
22 | }
23 |
24 | BorderedRegion.defaultProps = {
25 | className: '',
26 | };
27 |
--------------------------------------------------------------------------------
/monoid-codescan/app/src/main/kotlin/monoid/codescan/Extension.kt:
--------------------------------------------------------------------------------
1 | package monoid.codescan
2 | import de.fraunhofer.aisec.cpg.TranslationConfiguration
3 | import de.fraunhofer.aisec.cpg.passes.*
4 |
5 | fun TranslationConfiguration.Builder.monoidPasses(): TranslationConfiguration.Builder {
6 | this.registerPass(TypeHierarchyResolver())
7 | this.registerPass(JavaExternalTypeHierarchyResolver())
8 | this.registerPass(ImportResolver())
9 | this.registerPass(VariableUsageResolver())
10 | this.registerPass(CallResolver()) // creates CG
11 | this.registerPass(DFGPass())
12 | this.registerPass(FunctionPointerCallResolver())
13 | // this.registerPass(EvaluationOrderGraphPass()) // creates EOG
14 | this.registerPass(TypeResolver())
15 | this.registerPass(FilenameMapper())
16 | return this
17 | }
--------------------------------------------------------------------------------
/monoid-codescan/app/src/main/kotlin/monoid/codescan/config/CodescanConfig.kt:
--------------------------------------------------------------------------------
1 | package monoid.codescan.config
2 |
3 | import monoid.codescan.generated.enums.CodescanRepoType
4 | import com.fasterxml.jackson.module.kotlin.registerKotlinModule
5 | import com.fasterxml.jackson.module.kotlin.readValue
6 | import com.fasterxml.jackson.dataformat.yaml.YAMLMapper
7 | import java.io.File
8 |
9 | data class CodescanConfig(
10 | val repoId: String,
11 | val repoType: CodescanRepoType
12 | )
13 |
14 | fun readConfig(filepath: File): CodescanConfig {
15 | val mapper = YAMLMapper().registerKotlinModule()
16 | return mapper.readValue
15 | {label}
16 |
17 |
18 | {children}
19 |
20 |
10 |
13 | {
14 | children
15 | && (
16 |
22 | );
23 | }
24 |
--------------------------------------------------------------------------------
/monoid-integrations/monoid-postgres/postgres/helpers.py:
--------------------------------------------------------------------------------
1 | from typing import Any, Mapping, Optional
2 | import psycopg
3 | from monoid_pydev.logger import get_logger
4 |
5 | logger = get_logger("postgres")
6 |
7 |
8 | def get_connection(conf: Mapping[str, Any], db_name: Optional[str] = None) -> psycopg.Connection:
9 | if db_name is None:
10 | db_name = conf["database"]
11 |
12 | connection_str = [
13 | f'host={conf["hostname"]}',
14 | f'port={conf["port"]}',
15 | f'dbname={db_name}',
16 | f'user={conf["username"]}',
17 | f'password={conf["password"]}'
18 | ]
19 |
20 | if conf.get("ssl", False):
21 | connection_str.append("sslmode=prefer")
22 | else:
23 | connection_str.append("sslmode=disable")
24 |
25 | return psycopg.connect(" ".join(connection_str))
26 |
--------------------------------------------------------------------------------
/monoid-api/config-data/resources/images/intercom.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/monoid-api/config-data/resources/images/mixpanel.svg:
--------------------------------------------------------------------------------
1 |
6 |
--------------------------------------------------------------------------------
/monoid-ui/src/components/SVGText.tsx:
--------------------------------------------------------------------------------
1 | import React, { DetailedHTMLProps, useMemo } from 'react';
2 | import { Buffer } from 'buffer';
3 | import { classNames } from '../utils/utils';
4 |
5 | type ImgProps = DetailedHTMLProps
17 | {children}
18 |
19 | )
20 | }
21 | {error.message}
;
31 | }
32 |
33 | return 16 | {children} 17 |
18 | ); 19 | } 20 | 21 | export function H2(props: HeaderProps) { 22 | const { children, className, ...rest } = props; 23 | return ( 24 |31 | {children} 32 |
33 | ); 34 | } 35 | 36 | export default { 37 | H1, 38 | }; 39 | -------------------------------------------------------------------------------- /monoid-api/workflow/validate_ds.go: -------------------------------------------------------------------------------- 1 | package workflow 2 | 3 | import ( 4 | "time" 5 | 6 | "github.com/monoid-privacy/monoid/monoidprotocol" 7 | "github.com/monoid-privacy/monoid/workflow/activity" 8 | "go.temporal.io/sdk/temporal" 9 | "go.temporal.io/sdk/workflow" 10 | ) 11 | 12 | type ValidateDSArgs struct { 13 | SiloSpecID string 14 | Config []byte 15 | } 16 | 17 | func (w *Workflow) ValidateDSWorkflow(ctx workflow.Context, args ValidateDSArgs) (monoidprotocol.MonoidValidateMessage, error) { 18 | options := workflow.ActivityOptions{ 19 | StartToCloseTimeout: time.Minute * 2, 20 | RetryPolicy: &temporal.RetryPolicy{ 21 | MaximumAttempts: 1, 22 | }, 23 | } 24 | 25 | ctx = workflow.WithActivityOptions(ctx, options) 26 | res := monoidprotocol.MonoidValidateMessage{} 27 | 28 | ac := activity.Activity{} 29 | err := workflow.ExecuteActivity(ctx, ac.ValidateDataSiloDef, args).Get(ctx, &res) 30 | 31 | return res, err 32 | } 33 | -------------------------------------------------------------------------------- /docs/monoid-open-source-quick-start/create-user-identifiers.md: -------------------------------------------------------------------------------- 1 | --- 2 | sidebar_position: 2.6 3 | --- 4 | 5 | # Create User Identifiers 6 | 7 | To automate user data requests, Monoid maintains a single source-of-truth for user identifier types that you can map across each of your silos. Whenever a user data request is submitted, you'll indicate the values for all relevant user identifier types, and Monoid will use those values to find the user in each silo. 8 | 9 | To create and manage user identifiers, navigate to `Configuration > Identifiers` on the left sidebar, and click `New Identifier` on the top left corner. 10 | 11 | In the opened form, give your identifier a name (e.g. `Email`) and an ID (e.g. `email`). The ID will be used to programmatically generate user data requests via the Monoid API (so if you were deleting users by email, you'd include `email: ...` in the request). 12 | 13 |  14 | -------------------------------------------------------------------------------- /monoid-api/config-data/resources/images/bigquery.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docusaurus/README.md: -------------------------------------------------------------------------------- 1 | # Website 2 | 3 | This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator. 4 | 5 | ### Installation 6 | 7 | ``` 8 | $ yarn 9 | ``` 10 | 11 | ### Local Development 12 | 13 | ``` 14 | $ yarn start 15 | ``` 16 | 17 | This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server. 18 | 19 | ### Build 20 | 21 | ``` 22 | $ yarn build 23 | ``` 24 | 25 | This command generates static content into the `build` directory and can be served using any static contents hosting service. 26 | 27 | ### Deployment 28 | 29 | Using SSH: 30 | 31 | ``` 32 | $ USE_SSH=true yarn deploy 33 | ``` 34 | 35 | Not using SSH: 36 | 37 | ``` 38 | $ GIT_USER=
21 |
30 | );
31 | }
32 |
33 | EmptyState.defaultProps = {
34 | className: '',
35 | };
36 |
--------------------------------------------------------------------------------
/monoid-api/cmd/analytics/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "net/http"
5 | "os"
6 |
7 | "github.com/gorilla/mux"
8 | "github.com/monoid-privacy/monoid/analytics"
9 | "github.com/monoid-privacy/monoid/analytics/ingestor"
10 | "github.com/rs/zerolog/log"
11 | )
12 |
13 | const defaultPort = "8081"
14 |
15 | func main() {
16 | port := os.Getenv("PORT")
17 | if port == "" {
18 | port = defaultPort
19 | }
20 |
21 | router := mux.NewRouter()
22 |
23 | analyticsHandler := analytics.AnalyticsHandler{
24 | Ingestor: ingestor.NewSegmentIngestor(os.Getenv("SEGMENT_WRITE_KEY"), nil),
25 | }
26 |
27 | defer analyticsHandler.Ingestor.Close()
28 |
29 | router.HandleFunc("/track", analyticsHandler.HandleTrack)
30 | router.HandleFunc("/identify", analyticsHandler.HandleIdentify)
31 |
32 | log.Info().Msgf("starting analytics service on %s", port)
33 | if err := http.ListenAndServe(":"+port, router); err != nil {
34 | log.Err(err).Msg("Error serving")
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/monoid-ui/src/graphql/silo_queries.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable import/prefer-default-export */
2 | import { gql } from '__generated__/gql';
3 |
4 | export const SILO_DATA_SOURCES = gql(`
5 | query SiloDataSources($id: ID!) {
6 | siloDefinition(id: $id) {
7 | id
8 | siloSpecification {
9 | id
10 | manual
11 | }
12 | dataSources {
13 | id
14 | name
15 | group
16 | properties {
17 | id
18 | name
19 | categories {
20 | id
21 | name
22 | }
23 | userPrimaryKey {
24 | id
25 | name
26 | }
27 | }
28 | }
29 | }
30 | }
31 | `);
32 |
33 | export const GET_SILOS = gql(`
34 | query GetSilos($id: ID!) {
35 | workspace(id: $id) {
36 | id
37 | siloDefinitions {
38 | id
39 | name
40 | siloSpecification {
41 | id
42 | name
43 | logo
44 | }
45 | }
46 | }
47 | }
48 | `);
49 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | TEST_SUBDIRS = monoid-api
2 | BUILD_SUBDIRS = monoid-api
3 | INTEGRATIONS_DIR = monoid-integrations
4 | CODESCAN_VERSION = 0.0.1
5 |
6 | TEST_TARGETS = $(foreach fd, $(TEST_SUBDIRS), $(fd)/test)
7 | BUILD_TARGETS = $(foreach fd, $(BUILD_SUBDIRS), $(fd)/build)
8 |
9 | .PHONY: $(TEST_TARGETS)
10 |
11 | $(TEST_TARGETS):
12 | $(MAKE) -C $(@D) test
13 |
14 | $(BUILD_TARGETS):
15 | $(MAKE) -C $(@D) build
16 |
17 | test: $(TEST_TARGETS)
18 | build: $(BUILD_TARGETS)
19 |
20 | docker-build-codescan:
21 | cd monoid-codescan && docker build -t monoidco/monoid-codescan:${CODESCAN_VERSION} .
22 |
23 | docker-push-codescan:
24 | docker push monoidco/monoid-codescan:${CODESCAN_VERSION}
25 |
26 | docker-build:
27 | docker compose -f docker-compose.build.yaml build
28 |
29 | docker-push:
30 | docker compose -f docker-compose.build.yaml push
31 |
32 | build-integrations:
33 | $(MAKE) -C $(INTEGRATIONS_DIR) docker-build
34 |
35 | push-integrations:
36 | $(MAKE) -C $(INTEGRATIONS_DIR) docker-push
37 |
--------------------------------------------------------------------------------
/monoid-api/model/workspace.go:
--------------------------------------------------------------------------------
1 | package model
2 |
3 | import (
4 | "regexp"
5 |
6 | "gorm.io/datatypes"
7 | )
8 |
9 | var emailRegex = regexp.MustCompile("^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")
10 |
11 | type Workspace struct {
12 | ID string
13 | Name string
14 | OnboardingComplete bool `default:"false"`
15 | SiloSpecifications []SiloSpecification
16 | SiloDefinitions []SiloDefinition
17 | Purposes []Purpose
18 | Categories []Category
19 | Requests []Request
20 | UserPrimaryKey []UserPrimaryKey
21 | Settings datatypes.JSON
22 | }
23 |
24 | type WorkspaceSettings struct {
25 | Email string `json:"email"`
26 | SendNews bool `json:"sendNews"`
27 | AnonymizeData bool `json:"anonymizeData"`
28 | }
29 |
30 | func ValidateEmail(email string) bool {
31 | return len(email) > 0 && emailRegex.MatchString(email)
32 | }
33 |
--------------------------------------------------------------------------------
/monoid-api/specimport/tools.go:
--------------------------------------------------------------------------------
1 | package specimport
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/docker/docker/client"
7 | "github.com/monoid-privacy/monoid/monoidprotocol/docker"
8 | )
9 |
10 | // GetFullSpec enriches the manifest entry with the data from the docker image
11 | func GetFullSpec(entry *IntegrationManifestEntry, dockerCli *client.Client) (*IntegrationFullSpecEntry, error) {
12 | ctx := context.Background()
13 |
14 | if entry.Manual {
15 | return &IntegrationFullSpecEntry{
16 | IntegrationManifestEntry: *entry,
17 | }, nil
18 | }
19 |
20 | mp := docker.NewDockerMPWithClient(entry.DockerImage, entry.DockerTag, "", dockerCli, false)
21 | defer mp.Teardown(ctx)
22 |
23 | err := mp.InitConn(ctx)
24 | if err != nil {
25 | return nil, err
26 | }
27 |
28 | spec, err := mp.Spec(ctx)
29 |
30 | if err != nil {
31 | return nil, err
32 | }
33 |
34 | return &IntegrationFullSpecEntry{
35 | IntegrationManifestEntry: *entry,
36 | Spec: spec.Spec,
37 | }, nil
38 | }
39 |
--------------------------------------------------------------------------------
/monoid-api/dataloader/data_sources.go:
--------------------------------------------------------------------------------
1 | package dataloader
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/graph-gophers/dataloader"
7 | "github.com/monoid-privacy/monoid/model"
8 | )
9 |
10 | // DataSource wraps the associated dataloader
11 | func DataSource(ctx context.Context, id string) (*model.DataSource, error) {
12 | loaders := For(ctx)
13 | return getData[*model.DataSource](ctx, id, loaders.DataSourceLoader)
14 | }
15 |
16 | func DataSourceUnscoped(ctx context.Context, id string) (*model.DataSource, error) {
17 | loaders := For(ctx)
18 | return getData[*model.DataSource](ctx, id, loaders.DataSourceLoader)
19 | }
20 |
21 | // dataSources gets all the datasources in keys.
22 | func (c *Reader) dataSources(ctx context.Context, keys dataloader.Keys) []*dataloader.Result {
23 | unscoped, ok := ctx.Value(UnscopedKey).(bool)
24 | if ok && unscoped {
25 | return loadDataUnscoped[*model.DataSource](ctx, c.conf.DB, false, keys)
26 | }
27 |
28 | return loadData[*model.DataSource](ctx, c.conf.DB, false, keys)
29 | }
30 |
--------------------------------------------------------------------------------
/monoid-ui/src/components/Link.tsx:
--------------------------------------------------------------------------------
1 | import React, { HTMLProps } from 'react';
2 | import { Link, LinkProps } from 'react-router-dom';
3 | import { classNames } from '../utils/utils';
4 |
5 | export function BristLink(props: LinkProps) {
6 | const { className, children } = props;
7 |
8 | return (
9 |
19 | {children}
20 |
21 | );
22 | }
23 |
24 | export function BristA(props: HTMLProps{title}
23 |{subtitle}
24 | {action && ( 25 |
26 | {action}
27 |
28 | )}
29 |
16 |
35 | );
36 | }
37 |
38 | Checkbox.defaultProps = {
39 | checkboxLabel: undefined,
40 | };
41 |
42 | export default Checkbox;
43 |
--------------------------------------------------------------------------------
/docs/connector-catalog/overview.md:
--------------------------------------------------------------------------------
1 | ---
2 | sidebar_position: 1
3 | sidebar_label: "Overview"
4 | ---
5 |
6 | # Overview
7 |
8 | Monoid is built around connectors to data silos that contain user data, including both internal (DB's, warehouses, etc.) external (e.g. SaaS apps) data stores. A full Monoid connector is able to automatically scan, query, and delete from a connected silo to fulfill data deletion/export requests and generate compliance reports.
9 |
10 | The maintainers and the community are regularly adding new prebuilt connectors to the Open-Source repo. If Monoid is missing a connector you'd like, you can build your own easily using our [guide](/category/build-a-connector). Alternatively, you can submit an issue on GitHub and we'll get to it as soon as possible, or sign up for a paid plan to get custom connectors on-demand.
11 |
12 | The following page contains guides for setting up each pre-built connector currently in the repo. While we try our best to keep it up-to-date, it is always a work-in-progress and may be missing guides for connectors contributed by the community -- if you can't find a guide, please submit an issue on GitHub and we'll add it ASAP (or feel free to create a PR to add the guide yourself!).
13 |
--------------------------------------------------------------------------------
/docusaurus/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "my-website",
3 | "version": "0.0.0",
4 | "private": true,
5 | "scripts": {
6 | "docusaurus": "docusaurus",
7 | "start": "docusaurus start",
8 | "build": "docusaurus build",
9 | "swizzle": "docusaurus swizzle",
10 | "deploy": "docusaurus deploy",
11 | "clear": "docusaurus clear",
12 | "serve": "docusaurus serve",
13 | "write-translations": "docusaurus write-translations",
14 | "write-heading-ids": "docusaurus write-heading-ids"
15 | },
16 | "dependencies": {
17 | "@docusaurus/core": "2.2.0",
18 | "@docusaurus/preset-classic": "2.2.0",
19 | "@mdx-js/react": "^1.6.22",
20 | "clsx": "^1.2.1",
21 | "prism-react-renderer": "^1.3.5",
22 | "react": "^17.0.2",
23 | "react-dom": "^17.0.2"
24 | },
25 | "devDependencies": {
26 | "@docusaurus/module-type-aliases": "2.2.0"
27 | },
28 | "browserslist": {
29 | "production": [
30 | ">0.5%",
31 | "not dead",
32 | "not op_mini all"
33 | ],
34 | "development": [
35 | "last 1 chrome version",
36 | "last 1 firefox version",
37 | "last 1 safari version"
38 | ]
39 | },
40 | "engines": {
41 | "node": ">=16.14"
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/monoid-ui/src/pages/Silos/pages/SiloPage/components/CategoryBadge.tsx:
--------------------------------------------------------------------------------
1 | import { useQuery } from '@apollo/client';
2 | import React from 'react';
3 | import { gql } from '__generated__/gql';
4 | import AlertRegion from '../../../../../components/AlertRegion';
5 | import Badge, { BadgeColor } from '../../../../../components/Badge';
6 | import Spinner from '../../../../../components/Spinner';
7 |
8 | const GET_CATEGORY = gql(`
9 | query GetCategory($id: ID!) {
10 | category(id: $id) {
11 | id
12 | name
13 | }
14 | }
15 | `);
16 |
17 | export default function CategoryBadge(props: {
18 | categoryID: string,
19 | color?: BadgeColor
20 | }) {
21 | const { categoryID, color } = props;
22 | const { data, loading, error } = useQuery(GET_CATEGORY, {
23 | variables: {
24 | id: categoryID,
25 | },
26 | });
27 |
28 | if (loading) {
29 | return
17 |
28 |
29 |
30 |
33 |
34 |
15 |
19 | );
20 | }
21 |
22 | Card.defaultProps = {
23 | innerClassName: '',
24 | };
25 |
26 | interface CardDividerProps extends React.HTMLProps
16 | {children}
17 |
18 |
33 |
36 |
37 | );
38 | }
39 |
40 | interface CardHeaderProps extends React.HTMLProps{children}
47 | ); 48 | } 49 | -------------------------------------------------------------------------------- /monoid-ui/src/pages/Onboarding/components/RequestStepBody.tsx: -------------------------------------------------------------------------------- 1 | import { useMutation } from '@apollo/client'; 2 | import Card from 'components/Card'; 3 | import PageHeader from 'components/PageHeader'; 4 | import { EXECUTE_REQUEST } from 'graphql/requests_queries'; 5 | import NewRequestForm from 'pages/Requests/pages/NewRequestPage/components/NewRequestForm'; 6 | import Text from 'components/Text'; 7 | import React from 'react'; 8 | 9 | export default function RequestBody(props: { onSuccess: (reqId: string) => void }) { 10 | const [executeReq] = useMutation(EXECUTE_REQUEST); 11 | const { onSuccess } = props; 12 | 13 | return ( 14 | <> 15 |24 | {title} 25 |
26 | ); 27 | break; 28 | case 'top': 29 | default: 30 | header = ( 31 |32 | {title} 33 |
34 | ); 35 | } 36 | 37 | return ( 38 |
39 |
53 | );
54 | }
55 |
56 | PageHeader.defaultProps = {
57 | actionItem: undefined,
58 | subtitle: undefined,
59 | level: 'top',
60 | };
61 |
--------------------------------------------------------------------------------
/monoid-api/filestore/encryptedstore/encryptedstore.go:
--------------------------------------------------------------------------------
1 | package localstore
2 |
3 | import (
4 | "context"
5 | "crypto/rand"
6 | "crypto/sha256"
7 | "io"
8 |
9 | "github.com/minio/sio"
10 | "github.com/monoid-privacy/monoid/filestore"
11 | "golang.org/x/crypto/hkdf"
12 | )
13 |
14 | type encryptedFileStore struct {
15 | filestore filestore.FileStore
16 | key []byte
17 | }
18 |
19 | func NewEncryptedFileStore(filestore filestore.FileStore, key []byte) filestore.FileStore {
20 | return &encryptedFileStore{
21 | filestore: filestore,
22 | key: key,
23 | }
24 | }
25 |
26 | func (fs *encryptedFileStore) NewWriter(
27 | ctx context.Context,
28 | objectName string,
29 | segmentFile bool,
30 | ) (wr io.WriteCloser, fp string, err error) {
31 | writer, filePath, err := fs.filestore.NewWriter(ctx, objectName, segmentFile)
32 | if err != nil {
33 | return nil, "", err
34 | }
35 |
36 | defer func() {
37 | if err != nil {
38 | wr.Close()
39 | fp = ""
40 | wr = nil
41 | }
42 | }()
43 |
44 | var nonce [32]byte
45 | if _, err = io.ReadFull(rand.Reader, nonce[:]); err != nil {
46 | return nil, "", err
47 | }
48 |
49 | var key [32]byte
50 | kdf := hkdf.New(sha256.New, key[:], nonce[:], nil)
51 | if _, err = io.ReadFull(kdf, key[:]); err != nil {
52 | return nil, "", err
53 | }
54 |
55 | writer, err = sio.EncryptWriter(writer, sio.Config{Key: key[:]})
56 | if err != nil {
57 | return nil, "", err
58 | }
59 |
60 | return writer, filePath, nil
61 | }
62 |
63 | func (ls *encryptedFileStore) NewReader(ctx context.Context, objectName string, segmentFile bool) (io.ReadCloser, error) {
64 | return ls.filestore.NewReader(ctx, objectName, segmentFile)
65 | }
66 |
--------------------------------------------------------------------------------
/monoid-api/cmd/tools/discovery/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "os"
7 |
8 | "github.com/docker/docker/client"
9 | "github.com/joho/godotenv"
10 | "github.com/monoid-privacy/monoid/specimport"
11 | "gopkg.in/yaml.v3"
12 | )
13 |
14 | func main() {
15 | _ = godotenv.Load()
16 |
17 | if len(os.Args) != 3 {
18 | fmt.Println("Usage: ./discovery [manifest_file] [out_file]")
19 | return
20 | }
21 |
22 | // Get the manifest spec
23 | fileName := os.Args[1]
24 | f, err := os.Open(fileName)
25 |
26 | if err != nil {
27 | panic(err)
28 | }
29 |
30 | defer f.Close()
31 |
32 | // Get the initial integrations from the spec
33 | integrations := []specimport.IntegrationManifestEntry{}
34 | if err := yaml.NewDecoder(f).Decode(&integrations); err != nil {
35 | panic(err)
36 | }
37 |
38 | dockerCli, err := client.NewClientWithOpts(client.FromEnv)
39 | if err != nil {
40 | panic(err)
41 | }
42 |
43 | dockerCli.NegotiateAPIVersion(context.Background())
44 |
45 | // Run the docker command to get the json schema for the silos
46 | specs := []*specimport.IntegrationFullSpecEntry{}
47 | for _, integration := range integrations {
48 | spec, err := specimport.GetFullSpec(&integration, dockerCli)
49 | if err != nil {
50 | fmt.Printf("Error parsing integration %s: %v\n", integration.Name, err)
51 | continue
52 | }
53 |
54 | specs = append(specs, spec)
55 | }
56 |
57 | // Write the enriched schema back.
58 | outfile, err := os.Create(os.Args[2])
59 | if err != nil {
60 | panic(err)
61 | }
62 |
63 | defer outfile.Close()
64 |
65 | err = yaml.NewEncoder(outfile).Encode(&specs)
66 | if err != nil {
67 | panic(err)
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/monoid-api/dataloader/silo_definitions.go:
--------------------------------------------------------------------------------
1 | package dataloader
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/graph-gophers/dataloader"
8 | "github.com/monoid-privacy/monoid/model"
9 | "github.com/rs/zerolog/log"
10 | )
11 |
12 | // SiloDefinition wraps the associated dataloader
13 | func SiloDefinition(ctx context.Context, id string) (*model.SiloDefinition, error) {
14 | loaders := For(ctx)
15 | thunk := loaders.SiloDefinitionLoader.Load(ctx, dataloader.StringKey(id))
16 | result, err := thunk()
17 | if err != nil {
18 | return nil, err
19 | }
20 | return result.(*model.SiloDefinition), nil
21 | }
22 |
23 | // siloDefinitions gets all the silo definnitions by ids in keys
24 | func (c *Reader) siloDefinitions(ctx context.Context, keys dataloader.Keys) []*dataloader.Result {
25 | // read all requested users in a single query
26 | ids := make([]string, len(keys))
27 | for ix, key := range keys {
28 | ids[ix] = key.String()
29 | }
30 |
31 | silos := []*model.SiloDefinition{}
32 |
33 | if err := c.conf.DB.Where(
34 | "id IN ?",
35 | ids,
36 | ).Find(&silos).Error; err != nil {
37 | log.Err(err).Msg("Error finding silos.")
38 | }
39 |
40 | siloMap := map[string]*model.SiloDefinition{}
41 | for _, c := range silos {
42 | siloMap[c.ID] = c
43 | }
44 |
45 | // return users in the same order requested
46 | output := make([]*dataloader.Result, len(keys))
47 | for index, k := range keys {
48 | res, ok := siloMap[k.String()]
49 | if ok {
50 | output[index] = &dataloader.Result{Data: res, Error: nil}
51 | } else {
52 | output[index] = &dataloader.Result{Data: nil, Error: fmt.Errorf("could not find silo")}
53 | }
54 | }
55 |
56 | return output
57 | }
58 |
--------------------------------------------------------------------------------
/monoid-api/resolver/silo_definition_helpers.go:
--------------------------------------------------------------------------------
1 | package resolver
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/monoid-privacy/monoid/model"
7 | "github.com/monoid-privacy/monoid/monoidprotocol"
8 | "github.com/monoid-privacy/monoid/workflow"
9 | "go.temporal.io/sdk/client"
10 | )
11 |
12 | type validateResult struct {
13 | success bool
14 | message string
15 | }
16 |
17 | func (r *Resolver) validateSiloDef(ctx context.Context, workflowID string, siloDefinition model.SiloDefinition) (*validateResult, error) {
18 | options := client.StartWorkflowOptions{
19 | ID: workflowID,
20 | TaskQueue: workflow.DockerRunnerQueue,
21 | }
22 |
23 | // Start the Workflow
24 | sf := workflow.Workflow{
25 | Conf: r.Conf,
26 | }
27 |
28 | confSecret, err := siloDefinition.Config.ValueBytes()
29 | if err != nil {
30 | return nil, err
31 | }
32 |
33 | we, err := r.Conf.TemporalClient.ExecuteWorkflow(ctx, options, sf.ValidateDSWorkflow, workflow.ValidateDSArgs{
34 | SiloSpecID: siloDefinition.SiloSpecificationID,
35 | Config: confSecret,
36 | })
37 | if err != nil {
38 | return nil, err
39 | }
40 |
41 | // Get the results
42 | var res monoidprotocol.MonoidValidateMessage
43 | err = we.Get(ctx, &res)
44 | if err != nil {
45 | return nil, err
46 | }
47 |
48 | if res.Status == monoidprotocol.MonoidValidateMessageStatusFAILURE {
49 | msg := "An error occurred while validating connection information."
50 |
51 | if res.Message != nil {
52 | msg = *res.Message
53 | }
54 |
55 | return &validateResult{
56 | success: false,
57 | message: msg,
58 | }, nil
59 | }
60 |
61 | return &validateResult{
62 | success: true,
63 | message: "",
64 | }, nil
65 | }
66 |
--------------------------------------------------------------------------------
/monoid-ui/src/components/Toggle.tsx:
--------------------------------------------------------------------------------
1 | import { Switch } from '@headlessui/react';
2 | import React from 'react';
3 | import { classNames } from '../utils/utils';
4 |
5 | export default function Toggle(props: {
6 | className?: string,
7 | checked: boolean,
8 | size?: 'md' | 'lg'
9 | onChange: (c: boolean) => void
10 | }) {
11 | const {
12 | className, checked, onChange, size,
13 | } = props;
14 |
15 | let switchSize = '';
16 | let handleSize = '';
17 | let translate = '';
18 | if (size === 'md') {
19 | switchSize = 'h-6 w-11';
20 | handleSize = 'h-5 w-5';
21 | translate = 'translate-x-5';
22 | } else if (size === 'lg') {
23 | switchSize = 'h-10 w-16';
24 | handleSize = 'h-9 w-9';
25 | translate = 'translate-x-6';
26 | }
27 |
28 | return (
29 |
40 | {header}
41 | {subtitle
42 | && (
43 |
44 | {subtitle}
45 |
46 | )}
47 |
48 |
49 |
50 | {actionItem}
51 |
52 |