@contember/engine-server 1.2.0-alpha.1 → 1.2.0-alpha.12

package/src/projectGroup/ProjectGroupContainer.ts

@@ -51,7 +51,7 @@ export class ProjectGroupContainerFactory {
 			.addService('tenantDbCredentials', () =>
 				config.db)
 			.addService('tenantConnection', ({ tenantDbCredentials }): Connection.ConnectionType =>
-				Connection.create(tenantDbCredentials, {}))
+				Connection.create(tenantDbCredentials))
 			.addService('projectSchemaResolver', () =>
 				new ProjectSchemaResolverProxy())
 			.addService('projectInitializer', () =>

package/src/utils/sentry.ts

@@ -28,7 +28,7 @@ export const logSentryError = (error: any, context: SentryErrorContext) => {
 			scope.setTag('project', context.project)
 		}
 		scope.setTag('module', context.module)
-		scope.setLevel(Sentry.Severity.Error)
+		scope.setLevel('error')
 		scope.setUser({
 			id: context.user,
 		})

package/tests/e2e/acl-condition-variable.test.ts

@@ -0,0 +1,74 @@
+import { assert, test } from 'vitest'
+import { createTester, gql } from '../src/tester'
+import { createSchema, SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
+import { addProjectMember, signIn, signUp } from '../src/requests'
+
+namespace ArticleModel {
+	export const readerRole = acl.createRole('reader')
+	export const subscriptionVariable = acl.createConditionVariable('subscription', readerRole)
+
+	@acl.allow(readerRole, {
+		read: true,
+		when: {
+			publishedAt: subscriptionVariable,
+		},
+	})
+	export class Article {
+		publishedAt = def.dateTimeColumn().notNull()
+	}
+}
+
+test('ACL: condition variable', async () => {
+	const tester = await createTester(createSchema(ArticleModel))
+
+	await tester(
+		gql`
+			mutation {
+				articleA: createArticle(data: { publishedAt: "2022-02-01" }) {
+					ok
+				}
+				articleB: createArticle(data: { publishedAt: "2021-12-01" }) {
+					ok
+				}
+			}
+		`,
+	)
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, {
+				articleA: {
+					ok: true,
+				},
+				articleB: {
+					ok: true,
+				},
+			})
+		})
+		.expect(200)
+
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+	await addProjectMember(identityId, tester.projectSlug, { role: 'reader', variables: [{ name: 'subscription', values: [JSON.stringify({ gte: '2022-01-01' })] }] })
+
+	await tester(
+		gql`
+			query {
+				listArticle {
+					publishedAt
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, {
+				listArticle: [
+					{
+						publishedAt: '2022-02-01T00:00:00.000Z',
+					},
+				],
+			})
+		})
+		.expect(200)
+})

package/tests/e2e/assume-identity.test.ts

@@ -0,0 +1,127 @@
+import { test } from 'vitest'
+import { createTester, gql } from '../src/tester'
+import { addProjectMember, signIn, signUp } from '../src/requests'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { AllowAllPermissionFactory } from '@contember/schema-utils'
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+test('Content API: assume identity', async () => {
+	const tester = await createTester(createSchema(TagModel, schema => {
+		return {
+			...schema,
+			acl: {
+				roles: {
+					test: {
+						entities: new AllowAllPermissionFactory().create(schema.model),
+						variables: {},
+						system: {
+							history: true,
+							assumeIdentity: true,
+						},
+					},
+				},
+			},
+		}
+	}))
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+	await addProjectMember(identityId, tester.projectSlug, { role: 'test', variables: [] })
+
+	const assumedIdentityId = '65e049e7-4b22-487a-a93b-528b3127d967'
+	await tester(
+		gql`
+			mutation {
+				createTag(data: {label: "foo bar"}) {
+					ok
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.set('X-Contember-assume-identity', assumedIdentityId)
+		.expect(200)
+
+
+	await tester(
+		gql`
+			query {
+				events {
+					tableName
+					identityId
+				}
+			}
+		`,
+		{ authorizationToken: authKey, path: `/system/${tester.projectSlug}` },
+	)
+		.expect({ data: { events: [{ tableName: 'tag', identityId: assumedIdentityId }] } })
+		.expect(200)
+})
+
+
+test('Content API: assume identity is declined', async () => {
+	const tester = await createTester(createSchema(TagModel, schema => {
+		return {
+			...schema,
+			acl: {
+				roles: {
+					foo: {
+						entities: {},
+						variables: {},
+						system: {
+							assumeIdentity: true,
+						},
+					},
+					test: {
+						entities: new AllowAllPermissionFactory().create(schema.model),
+						variables: {},
+						system: {
+							history: true,
+						},
+					},
+				},
+			},
+		}
+	}))
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+	await addProjectMember(identityId, tester.projectSlug, { role: 'test', variables: [] })
+
+	const assumedIdentityId = '65e049e7-4b22-487a-a93b-528b3127d967'
+	await tester(
+		gql`
+			mutation {
+				createTag(data: {label: "foo bar"}) {
+					ok
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.set('X-Contember-assume-identity', assumedIdentityId)
+		.expect(200)
+
+
+	await tester(
+		gql`
+			query {
+				events {
+					tableName
+					identityId
+				}
+			}
+		`,
+		{ authorizationToken: authKey, path: `/system/${tester.projectSlug}` },
+	)
+		.expect({ data: { events: [{ tableName: 'tag', identityId }] } })
+		.expect(200)
+})

package/tests/e2e/assume-membership.test.ts

@@ -0,0 +1,64 @@
+import { test } from 'vitest'
+import { createTester, gql } from '../src/tester'
+import { addProjectMember, signIn, signUp } from '../src/requests'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+test('Content API: assume membership', async () => {
+	const tester = await createTester(createSchema(TagModel, schema => {
+		return {
+			...schema,
+			acl: {
+				roles: {
+					test: {
+						entities: {},
+						variables: {},
+						content: {
+							assumeMembership: {
+								admin: {},
+							},
+						},
+					},
+				},
+			},
+		}
+	}))
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+	await addProjectMember(identityId, tester.projectSlug, { role: 'test', variables: [] })
+
+	await tester(
+		gql`
+			query {
+				listTag {
+					id
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.expect(400)
+
+
+	await tester(
+		gql`
+			query {
+				listTag {
+					id
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.set('X-Contember-assume-membership', JSON.stringify({ memberships: [{ role: 'admin', variables: [] }] }))
+		.expect({ data: { listTag: [] } })
+		.expect(200)
+})

package/tests/e2e/content-api-basic.test.ts

@@ -0,0 +1,51 @@
+import { assert, test } from 'vitest'
+import { createTester, gql } from '../src/tester'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+test('Content API: create & read tag', async () => {
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
+		gql`
+			mutation {
+				createTag(data: { label: "graphql" }) {
+					ok
+				}
+			}
+		`,
+	)
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, {
+				createTag: {
+					ok: true,
+				},
+			})
+		})
+		.expect(200)
+
+	await tester(
+		gql`
+			query {
+				listTag(filter: { label: { eq: "graphql" } }) {
+					label
+				}
+			}
+		`,
+	)
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, {
+				listTag: [
+					{
+						label: 'graphql',
+					},
+				],
+			})
+		})
+		.expect(200)
+})

package/tests/e2e/content-invalid-schema.test.ts

@@ -0,0 +1,31 @@
+import { assert, test } from 'vitest'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { createTester, gql } from '../src/tester'
+
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+test('Content API: invalid schema error', async () => {
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
+		gql`
+			mutation {
+				createFoo(data: { label: "graphql" }) {
+					ok
+				}
+			}
+		`,
+	)
+		.expect(400)
+		.expect(response => {
+			assert.deepStrictEqual(
+				response.body.errors[0].message,
+				'Cannot query field "createFoo" on type "Mutation". Did you mean "createTag"?',
+			)
+		})
+})

package/tests/e2e/homepage.test.ts

@@ -0,0 +1,10 @@
+import { test } from 'vitest'
+import supertest from 'supertest'
+import { apiUrl } from '../src/tester'
+
+test('show homepage', async () => {
+	await supertest(apiUrl)
+		.get('/')
+		.expect(200)
+		.expect('App is running')
+})

package/tests/e2e/tenant-member-access.test.ts

@@ -0,0 +1,51 @@
+import { assert, test } from 'vitest'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { createTester, gql } from '../src/tester'
+import { addProjectMember, signIn, signUp } from '../src/requests'
+
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+test('Tenant API: sign up, add to a project and check project access', async () => {
+	const tester = await createTester(createSchema(TagModel))
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+
+	await tester(
+		gql`
+			query {
+				listTag {
+					id
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.expect(404)
+		.expect({ errors: [{ message: `Project ${tester.projectSlug} NOT found`, code: 404 }] })
+
+
+	await addProjectMember(identityId, tester.projectSlug)
+
+	await tester(
+		gql`
+			query {
+				listTag {
+					id
+				}
+			}
+		`,
+		{ authorizationToken: authKey },
+	)
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, { listTag: [] })
+		})
+		.expect(200)
+})

package/tests/e2e/x-contember-ref.test.ts

@@ -0,0 +1,71 @@
+import { assert, test } from 'vitest'
+import { createTester, gql } from '../src/tester'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+test('Content API: X-Contember-Ref header', async () => {
+
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
+		gql`
+			mutation {
+				createTag(data: { label: "typescript" }) {
+					ok
+				}
+			}
+		`,
+	).expect(200)
+
+	const response = await tester(
+		gql`
+			query {
+				listTag(filter: { label: { eq: "typescript" } }) {
+					label
+				}
+			}
+		`,
+	)
+		.set('X-Contember-Ref', 'None')
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, {
+				listTag: [
+					{
+						label: 'typescript',
+					},
+				],
+			})
+		})
+		.expect(200)
+	const eventKey = response.get('X-Contember-Ref')
+	await tester(
+		gql`
+			query {
+				listTag {
+					label
+				}
+			}
+		`,
+	)
+		.set('X-Contember-Ref', eventKey)
+		.expect(304)
+
+	// ignored for mutation
+	await tester(
+		gql`
+			mutation {
+				createTag(data: { label: "typescript" }) {
+					ok
+				}
+			}
+		`,
+	)
+		.set('X-Contember-Ref', eventKey)
+		.expect(200)
+})

package/tests/{e2e → src}/requests.ts

@@ -1,5 +1,6 @@
 import { executeGraphql, gql, loginToken } from './tester'
 import { assert } from 'vitest'
+import { Acl } from '@contember/schema'
 
 export const signIn = async (email: string, password = '123456'): Promise<string> => {
 	const response = await executeGraphql(
@@ -50,22 +51,31 @@ export const signUp = async (email: string, password = '123456') => {
 }
 
 
-export const addProjectMember = async (identityId: string, projectSlug: string, role = 'admin') => {
+export const addProjectMember = async (identityId: string, projectSlug: string, membership: Acl.Membership = { role: 'admin', variables: [] }) => {
 	await executeGraphql(
 		'/tenant',
 		gql`
-			mutation ($identity: String!, $projectSlug: String!, $role: String!) {
-				addProjectMember(identityId: $identity, projectSlug: $projectSlug, memberships: [{ role: $role, variables: [] }]) {
+			mutation ($identity: String!, $projectSlug: String!, $membership: MembershipInput!) {
+				addProjectMember(identityId: $identity, projectSlug: $projectSlug, memberships: [$membership]) {
 					ok
+					error {
+						code
+						developerMessage
+						membershipValidation {
+							code
+							role
+							variable
+						}
+					}
 				}
 			}
 		`,
 		{
-			variables: { identity: identityId, projectSlug, role },
+			variables: { identity: identityId, projectSlug, membership },
 		},
 	)
 		.expect(200)
 		.expect(response => {
-			assert.deepStrictEqual(response.body.data, { addProjectMember: { ok: true } })
+			assert.deepStrictEqual(response.body.data, { addProjectMember: { ok: true, error: null } })
 		})
 }

package/dist/tests/e2e/http.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=http.test.d.ts.map

package/dist/tests/e2e/http.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.test.d.ts","sourceRoot":"","sources":["../../../tests/e2e/http.test.ts"],"names":[],"mappings":""}