Add schema proposal composition background job

deployment/index.ts

@@ -136,17 +136,6 @@ const tokens = deployTokens({
   observability,
 });
 
-deployWorkflows({
-  image: docker.factory.getImageId('workflows', imagesTag),
-  docker,
-  environment,
-  postgres,
-  postmarkSecret,
-  observability,
-  sentry,
-  heartbeat: heartbeatsConfig.get('webhooks'),
-});
-
 const commerce = deployCommerce({
   image: docker.factory.getImageId('commerce', imagesTag),
   docker,
@@ -201,6 +190,18 @@ const schemaPolicy = deploySchemaPolicy({
   observability,
 });
 
+deployWorkflows({
+  image: docker.factory.getImageId('workflows', imagesTag),
+  docker,
+  environment,
+  postgres,
+  postmarkSecret,
+  observability,
+  sentry,
+  heartbeat: heartbeatsConfig.get('webhooks'),
+  schema,
+});
+
 const supertokens = deploySuperTokens(postgres, { dependencies: [dbMigrations] }, environment);
 const zendesk = configureZendesk({ environment });
 const githubApp = configureGithubApp();

deployment/services/workflows.ts

@@ -1,10 +1,12 @@
 import * as pulumi from '@pulumi/pulumi';
+import { serviceLocalEndpoint } from '../utils/local-endpoint';
 import { ServiceSecret } from '../utils/secrets';
 import { ServiceDeployment } from '../utils/service-deployment';
 import { Docker } from './docker';
 import { Environment } from './environment';
 import { Observability } from './observability';
 import { Postgres } from './postgres';
+import { Schema } from './schema';
 import { Sentry } from './sentry';
 
 export class PostmarkSecret extends ServiceSecret<{
@@ -22,6 +24,7 @@ export function deployWorkflows({
   postgres,
   observability,
   postmarkSecret,
+  schema,
 }: {
   postgres: Postgres;
   observability: Observability;
@@ -31,6 +34,7 @@ export function deployWorkflows({
   heartbeat?: string;
   sentry: Sentry;
   postmarkSecret: PostmarkSecret;
+  schema: Schema;
 }) {
   return (
     new ServiceDeployment(
@@ -47,6 +51,7 @@ export function deployWorkflows({
               ? observability.tracingEndpoint
               : '',
           LOG_JSON: '1',
+          SCHEMA_ENDPOINT: serviceLocalEndpoint(schema.service),
         },
         readinessProbe: '/_readiness',
         livenessProbe: '/_health',

docker/docker-compose.community.yml

@@ -322,6 +322,10 @@ services:
       SENTRY_DSN: '${SENTRY_DSN:-}'
       PROMETHEUS_METRICS: '${PROMETHEUS_METRICS:-}'
       LOG_JSON: '1'
+      SCHEMA_ENDPOINT: http://schema:3002
+      REDIS_HOST: redis
+      REDIS_PORT: 6379
+      REDIS_PASSWORD: '${REDIS_PASSWORD}'
 
   usage:
     image: '${DOCKER_REGISTRY}usage${DOCKER_TAG}'

integration-tests/docker-compose.integration.yaml

@@ -239,6 +239,7 @@ services:
   workflows:
     environment:
       EMAIL_PROVIDER: '${EMAIL_PROVIDER}'
+      SCHEMA_ENDPOINT: http://schema:3002
       LOG_LEVEL: debug
     ports:
       - '3014:3014'

integration-tests/package.json

@@ -34,6 +34,7 @@
     "dockerode": "4.0.8",
     "dotenv": "16.4.7",
     "graphql": "16.9.0",
+    "graphql-sse": "2.6.0",
     "human-id": "4.1.1",
     "ioredis": "5.8.2",
     "slonik": "30.4.4",

integration-tests/testkit/graphql.ts

@@ -1,4 +1,5 @@
 import { ExecutionResult, parse, print } from 'graphql';
+import { createClient } from 'graphql-sse';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
 import { sortSDL } from '@theguild/federation-composition';
 import { getServiceHost } from './utils';
@@ -87,3 +88,42 @@ export async function execute<TResult, TVariables>(
     },
   };
 }
+
+export async function subscribe<TResult, TVariables>(
+  params: {
+    document: TypedDocumentNode<TResult, TVariables>;
+    operationName?: string;
+    authToken?: string;
+    token?: string;
+    legacyAuthorizationMode?: boolean;
+  } & (TVariables extends Record<string, never>
+    ? { variables?: never }
+    : { variables: TVariables }),
+) {
+  const registryAddress = await getServiceHost('server', 8082);
+  const client = createClient({
+    url: `http://${registryAddress}/graphql`,
+    headers: {
+      ...(params.authToken
+        ? {
+            authorization: `Bearer ${params.authToken}`,
+          }
+        : {}),
+      ...(params.token
+        ? params.legacyAuthorizationMode
+          ? {
+              'x-api-token': params.token,
+            }
+          : {
+              authorization: `Bearer ${params.token}`,
+            }
+        : {}),
+    },
+  });
+
+  return client.iterate({
+    operationName: params.operationName,
+    query: print(params.document),
+    variables: params.variables ?? {},
+  });
+}

integration-tests/testkit/seed.ts

@@ -766,13 +766,15 @@ export function initSeed() {
                         commit: string;
                       },
                       contextId?: string,
+                      schemaProposalId?: string,
                     ) {
                       return await checkSchema(
                         {
                           sdl,
                           service,
                           meta,
                           contextId,
+                          schemaProposalId,
                         },
                         secret,
                       );

integration-tests/tests/api/proposals/create.spec.ts

@@ -0,0 +1,83 @@
+import { graphql } from 'testkit/gql';
+import { ProjectType, ResourceAssignmentModeType } from 'testkit/gql/graphql';
+import { execute } from 'testkit/graphql';
+import { initSeed } from 'testkit/seed';
+
+const CreateProposalMutation = graphql(`
+  mutation CreateProposalMutation($input: CreateSchemaProposalInput!) {
+    createSchemaProposal(input: $input) {
+      ok {
+        schemaProposal {
+          id
+        }
+      }
+      error {
+        message
+      }
+    }
+  }
+`);
+
+describe('Schema Proposals', () => {
+  test.concurrent(
+    'cannot be proposed without "schemaProposal:modify" permission',
+    async ({ expect }) => {
+      const { createOrg, ownerToken } = await initSeed().createOwner();
+      const { createProject, createOrganizationAccessToken, setFeatureFlag } = await createOrg();
+      await setFeatureFlag('schemaProposals', true);
+      const { target } = await createProject(ProjectType.Federation);
+      const { privateAccessKey: accessKey } = await createOrganizationAccessToken(
+        {
+          resources: {
+            mode: ResourceAssignmentModeType.All,
+          },
+          permissions: ['schemaProposal:describe'],
+        },
+        ownerToken,
+      );
+
+      const result = await execute({
+        document: CreateProposalMutation,
+        variables: {
+          input: {
+            target: { byId: target.id },
+            author: 'Jeff',
+            title: 'Proposed changes to the schema...',
+          },
+        },
+        authToken: accessKey,
+      }).then(r => r.expectGraphQLErrors());
+    },
+  );
+
+  test.concurrent(
+    'can be proposed successfully with "schemaProposal:modify" permission',
+    async ({ expect }) => {
+      const { createOrg, ownerToken } = await initSeed().createOwner();
+      const { createProject, createOrganizationAccessToken, setFeatureFlag } = await createOrg();
+      await setFeatureFlag('schemaProposals', true);
+      const { target } = await createProject(ProjectType.Federation);
+
+      const { privateAccessKey: accessKey } = await createOrganizationAccessToken({
+        resources: {
+          mode: ResourceAssignmentModeType.All,
+        },
+        permissions: ['schemaProposal:modify'],
+      });
+
+      const result = await execute({
+        document: CreateProposalMutation,
+        variables: {
+          input: {
+            target: { byId: target.id },
+            author: 'Jeff',
+            title: 'Proposed changes to the schema...',
+          },
+        },
+        authToken: accessKey,
+      }).then(r => r.expectNoGraphQLErrors());
+
+      expect(result.createSchemaProposal.ok?.schemaProposal).toHaveProperty('id');
+    },
+  );
+});

integration-tests/tests/api/proposals/read.spec.ts

@@ -0,0 +1,115 @@
+import { graphql } from 'testkit/gql';
+import { ProjectType, ResourceAssignmentModeType } from 'testkit/gql/graphql';
+import { execute } from 'testkit/graphql';
+import { initSeed } from 'testkit/seed';
+
+const CreateProposalMutation = graphql(`
+  mutation CreateProposalMutation($input: CreateSchemaProposalInput!) {
+    createSchemaProposal(input: $input) {
+      ok {
+        schemaProposal {
+          id
+        }
+      }
+      error {
+        message
+      }
+    }
+  }
+`);
+
+const ReadProposalQuery = graphql(`
+  query ReadProposalQuery($input: SchemaProposalInput!) {
+    schemaProposal(input: $input) {
+      title
+      description
+      checks(input: { latestPerService: true }) {
+        edges {
+          node {
+            id
+          }
+        }
+      }
+    }
+  }
+`);
+
+/**
+ * Creates a proposal and returns a token with specified permissions
+ **/
+async function setup(input: {
+  tokenPermissions: string[];
+}): Promise<{ accessKey: string; proposalId: string }> {
+  const { createOrg, ownerToken } = await initSeed().createOwner();
+  const { createProject, createOrganizationAccessToken, setFeatureFlag } = await createOrg();
+  await setFeatureFlag('schemaProposals', true);
+  const { target } = await createProject(ProjectType.Federation);
+
+  // create as owner
+  const result = await execute({
+    document: CreateProposalMutation,
+    variables: {
+      input: {
+        target: { byId: target.id },
+        author: 'Jeff',
+        title: 'Proposed changes to the schema...',
+      },
+    },
+    token: ownerToken,
+  }).then(r => r.expectNoGraphQLErrors());
+
+  const { privateAccessKey: accessKey } = await createOrganizationAccessToken(
+    {
+      resources: {
+        mode: ResourceAssignmentModeType.All,
+      },
+      permissions: input.tokenPermissions,
+    },
+    ownerToken,
+  );
+  const proposalId = result.createSchemaProposal.ok?.schemaProposal.id!;
+  return { accessKey, proposalId };
+}
+
+describe('Schema Proposals', () => {
+  test.concurrent(
+    'can read proposal with "schemaProposal:describe" permission',
+    async ({ expect }) => {
+      const { accessKey, proposalId } = await setup({
+        tokenPermissions: ['schemaProposal:describe'],
+      });
+
+      {
+        const proposal = await execute({
+          document: ReadProposalQuery,
+          variables: {
+            input: {
+              id: proposalId,
+            },
+          },
+          token: accessKey,
+        }).then(r => r.expectNoGraphQLErrors());
+
+        expect(proposal.schemaProposal?.title).toMatchInlineSnapshot(
+          `Proposed changes to the schema...`,
+        );
+      }
+    },
+  );
+
+  test.concurrent('cannot read proposal without "schemaProposal:describe" permission', async () => {
+    const { accessKey, proposalId } = await setup({ tokenPermissions: [] });
+
+    {
+      await execute({
+        document: ReadProposalQuery,
+        variables: {
+          input: {
+            id: proposalId,
+          },
+        },
+        token: accessKey,
+      }).then(r => r.expectGraphQLErrors());
+    }
+  });
+});