TΓΌrkehren.', + } + await expect( + mutate({ + mutation: createPostMutation, + variables, + }), + ).resolves.toMatchObject({ + data: { + CreatePost: { + language: 'de', + }, + }, + }) + }) +}) diff --git a/backend/src/middleware/permissionsMiddleware.js b/backend/src/middleware/permissionsMiddleware.js index 734931df2..af70ca2fd 100644 --- a/backend/src/middleware/permissionsMiddleware.js +++ b/backend/src/middleware/permissionsMiddleware.js @@ -29,15 +29,25 @@ const onlyYourself = rule({ const isMyOwn = rule({ cache: 'no_cache', -})(async (parent, args, context, info) => { - return context.user.id === parent.id +})(async (parent, args, { user }, info) => { + return user && user.id === parent.id }) const isMySocialMedia = rule({ cache: 'no_cache', })(async (_, args, { user }) => { + // We need a User + if (!user) { + return false + } let socialMedia = await neode.find('SocialMedia', args.id) - socialMedia = await socialMedia.toJson() + // Did we find a social media node? + if (!socialMedia) { + return false + } + socialMedia = await socialMedia.toJson() // whats this for? + + // Is it my social media entry? return socialMedia.ownedBy.node.id === user.id }) @@ -86,7 +96,10 @@ export default shield( '*': deny, findPosts: allow, findUsers: allow, - findResources: allow, + searchResults: allow, + searchPosts: allow, + searchUsers: allow, + searchHashtags: allow, embed: allow, Category: allow, Tag: allow, @@ -106,6 +119,9 @@ export default shield( notifications: isAuthenticated, Donations: isAuthenticated, userData: isAuthenticated, + MyInviteCodes: isAuthenticated, + isValidInviteCode: allow, + queryLocations: isAuthenticated, }, Mutation: { '*': deny, @@ -149,6 +165,7 @@ export default shield( pinPost: isAdmin, unpinPost: isAdmin, UpdateDonations: isAdmin, + GenerateInviteCode: isAuthenticated, switchUserRole: isAdmin, }, User: { diff --git a/backend/src/middleware/sentryMiddleware.js b/backend/src/middleware/sentryMiddleware.js index da8ef32d0..8891b8677 100644 --- a/backend/src/middleware/sentryMiddleware.js +++ b/backend/src/middleware/sentryMiddleware.js @@ -1,16 +1,16 @@ import { sentry } from 'graphql-middleware-sentry' -import { sentryConfigs } from '../config' +import CONFIG from '../config' let sentryMiddleware = (resolve, root, args, context, resolveInfo) => resolve(root, args, context, resolveInfo) -if (sentryConfigs.SENTRY_DSN_BACKEND) { +if (CONFIG.SENTRY_DSN_BACKEND) { sentryMiddleware = sentry({ forwardErrors: true, config: { - dsn: sentryConfigs.SENTRY_DSN_BACKEND, - release: sentryConfigs.COMMIT, - environment: process.env.NODE_ENV, + dsn: CONFIG.SENTRY_DSN_BACKEND, + release: CONFIG.COMMIT, + environment: CONFIG.NODE_ENV, }, withScope: (scope, error, context) => { scope.setUser({ @@ -23,7 +23,7 @@ if (sentryConfigs.SENTRY_DSN_BACKEND) { }) } else { // eslint-disable-next-line no-console - if (process.env.NODE_ENV !== 'test') console.log('Warning: Sentry middleware inactive.') + if (!CONFIG.TEST) console.log('Warning: Sentry middleware inactive.') } export default sentryMiddleware diff --git a/backend/src/middleware/slugify/uniqueSlug.js b/backend/src/middleware/slugify/uniqueSlug.js index ca37cd562..7cfb89c19 100644 --- a/backend/src/middleware/slugify/uniqueSlug.js +++ b/backend/src/middleware/slugify/uniqueSlug.js @@ -2,6 +2,7 @@ import slugify from 'slug' export default async function uniqueSlug(string, isUnique) { const slug = slugify(string || 'anonymous', { lower: true, + multicharmap: { Γ: 'AE', Γ€: 'ae', Γ: 'OE', ΓΆ: 'oe', Γ: 'UE', ΓΌ: 'ue', Γ: 'ss' }, }) if (await isUnique(slug)) return slug diff --git a/backend/src/middleware/slugify/uniqueSlug.spec.js b/backend/src/middleware/slugify/uniqueSlug.spec.js index ff14a56ef..d002eae03 100644 --- a/backend/src/middleware/slugify/uniqueSlug.spec.js +++ b/backend/src/middleware/slugify/uniqueSlug.spec.js @@ -18,4 +18,16 @@ describe('uniqueSlug', () => { const isUnique = jest.fn().mockResolvedValue(true) expect(uniqueSlug(string, isUnique)).resolves.toEqual('anonymous') }) + + it('Converts umlaut to a two letter equivalent', async () => { + const umlaut = 'ΓΓΓÀâüΓ' + const isUnique = jest.fn().mockResolvedValue(true) + await expect(uniqueSlug(umlaut, isUnique)).resolves.toEqual('aeoeueaeoeuess') + }) + + it('Removes Spanish enya and diacritics', async () => { + const diacritics = 'Ñà éèΓìóòúùñçΓΓΓΓΓΓΓΓΓΓΓΓ' + const isUnique = jest.fn().mockResolvedValue(true) + await expect(uniqueSlug(diacritics, isUnique)).resolves.toEqual('aaeeiioouuncaaeeiioouunc') + }) }) diff --git a/backend/src/middleware/validation/validationMiddleware.js b/backend/src/middleware/validation/validationMiddleware.js index d36e64846..20933a777 100644 --- a/backend/src/middleware/validation/validationMiddleware.js +++ b/backend/src/middleware/validation/validationMiddleware.js @@ -2,8 +2,6 @@ import { UserInputError } from 'apollo-server' const COMMENT_MIN_LENGTH = 1 const NO_POST_ERR_MESSAGE = 'Comment cannot be created without a post!' -const NO_CATEGORIES_ERR_MESSAGE = - 'You cannot save a post without at least one category or more than three' const USERNAME_MIN_LENGTH = 3 const validateCreateComment = async (resolve, root, args, context, info) => { const content = args.content.replace(/<(?:.|\n)*?>/gm, '').trim() @@ -46,20 +44,6 @@ const validateUpdateComment = async (resolve, root, args, context, info) => { return resolve(root, args, context, info) } -const validatePost = async (resolve, root, args, context, info) => { - const { categoryIds } = args - if (!Array.isArray(categoryIds) || !categoryIds.length || categoryIds.length > 3) { - throw new UserInputError(NO_CATEGORIES_ERR_MESSAGE) - } - return resolve(root, args, context, info) -} - -const validateUpdatePost = async (resolve, root, args, context, info) => { - const { categoryIds } = args - if (typeof categoryIds === 'undefined') return resolve(root, args, context, info) - return validatePost(resolve, root, args, context, info) -} - const validateReport = async (resolve, root, args, context, info) => { const { resourceId } = args const { user } = context @@ -138,8 +122,6 @@ export default { Mutation: { CreateComment: validateCreateComment, UpdateComment: validateUpdateComment, - CreatePost: validatePost, - UpdatePost: validateUpdatePost, UpdateUser: validateUpdateUser, fileReport: validateReport, review: validateReview, diff --git a/backend/src/middleware/validation/validationMiddleware.spec.js b/backend/src/middleware/validation/validationMiddleware.spec.js index 74a343eeb..c3d518256 100644 --- a/backend/src/middleware/validation/validationMiddleware.spec.js +++ b/backend/src/middleware/validation/validationMiddleware.spec.js @@ -30,27 +30,7 @@ const updateCommentMutation = gql` } } ` -const createPostMutation = gql` - mutation($id: ID, $title: String!, $content: String!, $language: String, $categoryIds: [ID]) { - CreatePost( - id: $id - title: $title - content: $content - language: $language - categoryIds: $categoryIds - ) { - id - } - } -` -const updatePostMutation = gql` - mutation($id: ID!, $title: String!, $content: String!, $categoryIds: [ID]) { - UpdatePost(id: $id, title: $title, content: $content, categoryIds: $categoryIds) { - id - } - } -` const reportMutation = gql` mutation($resourceId: ID!, $reasonCategory: ReasonCategory!, $reasonDescription: String!) { fileReport( @@ -227,104 +207,6 @@ describe('validateCreateComment', () => { }) }) }) - - describe('validatePost', () => { - let createPostVariables - beforeEach(async () => { - createPostVariables = { - title: 'I am a title', - content: 'Some content', - } - authenticatedUser = await commentingUser.toJson() - }) - - describe('categories', () => { - describe('null', () => { - it('throws UserInputError', async () => { - createPostVariables = { ...createPostVariables, categoryIds: null } - await expect( - mutate({ mutation: createPostMutation, variables: createPostVariables }), - ).resolves.toMatchObject({ - data: { CreatePost: null }, - errors: [ - { - message: 'You cannot save a post without at least one category or more than three', - }, - ], - }) - }) - }) - - describe('empty', () => { - it('throws UserInputError', async () => { - createPostVariables = { ...createPostVariables, categoryIds: [] } - await expect( - mutate({ mutation: createPostMutation, variables: createPostVariables }), - ).resolves.toMatchObject({ - data: { CreatePost: null }, - errors: [ - { - message: 'You cannot save a post without at least one category or more than three', - }, - ], - }) - }) - }) - - describe('more than 3 categoryIds', () => { - it('throws UserInputError', async () => { - createPostVariables = { - ...createPostVariables, - categoryIds: ['cat9', 'cat27', 'cat15', 'cat4'], - } - await expect( - mutate({ mutation: createPostMutation, variables: createPostVariables }), - ).resolves.toMatchObject({ - data: { CreatePost: null }, - errors: [ - { - message: 'You cannot save a post without at least one category or more than three', - }, - ], - }) - }) - }) - }) - }) - - describe('validateUpdatePost', () => { - describe('post created without categories somehow', () => { - let owner, updatePostVariables - beforeEach(async () => { - const postSomehowCreated = await neode.create('Post', { - id: 'how-was-this-created', - }) - owner = await neode.create('User', { - id: 'author-of-post-without-category', - slug: 'hacker', - }) - await postSomehowCreated.relateTo(owner, 'author') - authenticatedUser = await owner.toJson() - updatePostVariables = { - id: 'how-was-this-created', - title: 'I am a title', - content: 'Some content', - categoryIds: [], - } - }) - - it('requires at least one category for successful update', async () => { - await expect( - mutate({ mutation: updatePostMutation, variables: updatePostVariables }), - ).resolves.toMatchObject({ - data: { UpdatePost: null }, - errors: [ - { message: 'You cannot save a post without at least one category or more than three' }, - ], - }) - }) - }) - }) }) describe('validateReport', () => { diff --git a/backend/src/models/Image.js b/backend/src/models/Image.js index 19824b493..b46342c18 100644 --- a/backend/src/models/Image.js +++ b/backend/src/models/Image.js @@ -3,5 +3,6 @@ export default { alt: { type: 'string' }, sensitive: { type: 'boolean', default: false }, aspectRatio: { type: 'float', default: 1.0 }, + type: { type: 'string' }, createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() }, } diff --git a/backend/src/models/InvitationCode.js b/backend/src/models/InviteCode.js similarity index 54% rename from backend/src/models/InvitationCode.js rename to backend/src/models/InviteCode.js index 138289faf..7204f1b38 100644 --- a/backend/src/models/InvitationCode.js +++ b/backend/src/models/InviteCode.js @@ -1,16 +1,17 @@ export default { + code: { type: 'string', primary: true }, createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() }, - token: { type: 'string', primary: true, token: true }, - generatedBy: { + expiresAt: { type: 'string', isoDate: true, default: null }, + generated: { type: 'relationship', relationship: 'GENERATED', target: 'User', direction: 'in', }, - activated: { + redeemed: { type: 'relationship', - relationship: 'ACTIVATED', - target: 'EmailAddress', - direction: 'out', + relationship: 'REDEEMED', + target: 'User', + direction: 'in', }, } diff --git a/backend/src/models/User.js b/backend/src/models/User.js index ae7e1ae8c..6cfd22268 100644 --- a/backend/src/models/User.js +++ b/backend/src/models/User.js @@ -100,6 +100,18 @@ export default { target: 'User', direction: 'in', }, + inviteCodes: { + type: 'relationship', + relationship: 'GENERATED', + target: 'InviteCode', + direction: 'out', + }, + redeemedInviteCode: { + type: 'relationship', + relationship: 'REDEEMED', + target: 'InviteCode', + direction: 'out', + }, termsAndConditionsAgreedVersion: { type: 'string', allow: [null], diff --git a/backend/src/models/index.js b/backend/src/models/index.js index c53ef89ab..8d6a021ab 100644 --- a/backend/src/models/index.js +++ b/backend/src/models/index.js @@ -15,4 +15,5 @@ export default { Donations: require('./Donations.js').default, Report: require('./Report.js').default, Migration: require('./Migration.js').default, + InviteCode: require('./InviteCode.js').default, } diff --git a/backend/src/schema/resolvers/helpers/generateInviteCode.js b/backend/src/schema/resolvers/helpers/generateInviteCode.js new file mode 100644 index 000000000..70e122d26 --- /dev/null +++ b/backend/src/schema/resolvers/helpers/generateInviteCode.js @@ -0,0 +1,8 @@ +export default function generateInviteCode() { + // 6 random numbers in [ 0, 35 ] are 36 possible numbers (10 [0-9] + 26 [A-Z]) + return Array.from({ length: 6 }, (n = Math.floor(Math.random() * 36)) => { + // n > 9: it is a letter (ASCII 65 is A) -> 10 + 55 = 65 + // else: it is a number (ASCII 48 is 0) -> 0 + 48 = 48 + return String.fromCharCode(n > 9 ? n + 55 : n + 48) + }).join('') +} diff --git a/backend/src/schema/resolvers/images.js b/backend/src/schema/resolvers/images.js index 8b3f4a3e8..111f84888 100644 --- a/backend/src/schema/resolvers/images.js +++ b/backend/src/schema/resolvers/images.js @@ -2,7 +2,7 @@ import Resolver from './helpers/Resolver' export default { Image: { ...Resolver('Image', { - undefinedToNull: ['sensitive', 'alt', 'aspectRatio'], + undefinedToNull: ['sensitive', 'alt', 'aspectRatio', 'type'], }), }, } diff --git a/backend/src/schema/resolvers/images/images.js b/backend/src/schema/resolvers/images/images.js index 18a3569b6..656ae114a 100644 --- a/backend/src/schema/resolvers/images/images.js +++ b/backend/src/schema/resolvers/images/images.js @@ -5,10 +5,10 @@ import slug from 'slug' import { existsSync, unlinkSync, createWriteStream } from 'fs' import { UserInputError } from 'apollo-server' import { getDriver } from '../../../db/neo4j' -import { s3Configs } from '../../../config' +import CONFIG from '../../../config' // const widths = [34, 160, 320, 640, 1024] -const { AWS_ENDPOINT: endpoint, AWS_REGION: region, AWS_BUCKET: Bucket, S3_CONFIGURED } = s3Configs +const { AWS_ENDPOINT: endpoint, AWS_REGION: region, AWS_BUCKET: Bucket, S3_CONFIGURED } = CONFIG export async function deleteImage(resource, relationshipType, opts = {}) { sanitizeRelationshipType(relationshipType) @@ -53,8 +53,8 @@ export async function mergeImage(resource, relationshipType, imageInput, opts = if (!(existingImage || upload)) throw new UserInputError('Cannot find image for given resource') if (existingImage && upload) deleteImageFile(existingImage, deleteCallback) const url = await uploadImageFile(upload, uploadCallback) - const { alt, sensitive, aspectRatio } = imageInput - const image = { alt, sensitive, aspectRatio, url } + const { alt, sensitive, aspectRatio, type } = imageInput + const image = { alt, sensitive, aspectRatio, url, type } txResult = await transaction.run( ` MATCH (resource {id: $resource.id}) diff --git a/backend/src/schema/resolvers/inviteCodes.js b/backend/src/schema/resolvers/inviteCodes.js new file mode 100644 index 000000000..91148a08d --- /dev/null +++ b/backend/src/schema/resolvers/inviteCodes.js @@ -0,0 +1,109 @@ +import generateInviteCode from './helpers/generateInviteCode' +import Resolver from './helpers/Resolver' + +const uniqueInviteCode = async (session, code) => { + return session.readTransaction(async (txc) => { + const result = await txc.run(`MATCH (ic:InviteCode { id: $code }) RETURN count(ic) AS count`, { + code, + }) + return parseInt(String(result.records[0].get('count'))) === 0 + }) +} + +export default { + Query: { + MyInviteCodes: async (_parent, args, context, _resolveInfo) => { + const { + user: { id: userId }, + } = context + const session = context.driver.session() + const readTxResultPromise = session.readTransaction(async (txc) => { + const result = await txc.run( + `MATCH (user:User {id: $userId})-[:GENERATED]->(ic:InviteCode) + RETURN properties(ic) AS inviteCodes`, + { + userId, + }, + ) + return result.records.map((record) => record.get('inviteCodes')) + }) + try { + const txResult = await readTxResultPromise + return txResult + } finally { + session.close() + } + }, + isValidInviteCode: async (_parent, args, context, _resolveInfo) => { + const { code } = args + if (!code) return false + const session = context.driver.session() + const readTxResultPromise = session.readTransaction(async (txc) => { + const result = await txc.run( + `MATCH (ic:InviteCode { code: toUpper($code) }) + RETURN + CASE + WHEN ic.expiresAt IS NULL THEN true + WHEN datetime(ic.expiresAt) >= datetime() THEN true + ELSE false END AS result`, + { + code, + }, + ) + return result.records.map((record) => record.get('result')) + }) + try { + const txResult = await readTxResultPromise + return !!txResult[0] + } finally { + session.close() + } + }, + }, + Mutation: { + GenerateInviteCode: async (_parent, args, context, _resolveInfo) => { + const { + user: { id: userId }, + } = context + const session = context.driver.session() + let code = generateInviteCode() + while (!(await uniqueInviteCode(session, code))) { + code = generateInviteCode() + } + const writeTxResultPromise = session.writeTransaction(async (txc) => { + const result = await txc.run( + `MATCH (user:User {id: $userId}) + MERGE (user)-[:GENERATED]->(ic:InviteCode { code: $code }) + ON CREATE SET + ic.createdAt = toString(datetime()), + ic.expiresAt = $expiresAt + RETURN ic AS inviteCode`, + { + userId, + code, + expiresAt: args.expiresAt, + }, + ) + return result.records.map((record) => record.get('inviteCode').properties) + }) + try { + const txResult = await writeTxResultPromise + return txResult[0] + } finally { + session.close() + } + }, + }, + InviteCode: { + ...Resolver('InviteCode', { + idAttribute: 'code', + undefinedToNull: ['expiresAt'], + hasOne: { + generatedBy: '<-[:GENERATED]-(related:User)', + }, + hasMany: { + redeemedBy: '<-[:REDEEMED]-(related:User)', + }, + }), + }, +} diff --git a/backend/src/schema/resolvers/inviteCodes.spec.js b/backend/src/schema/resolvers/inviteCodes.spec.js new file mode 100644 index 000000000..19f021437 --- /dev/null +++ b/backend/src/schema/resolvers/inviteCodes.spec.js @@ -0,0 +1,200 @@ +import Factory, { cleanDatabase } from '../../db/factories' +import { getDriver } from '../../db/neo4j' +import { gql } from '../../helpers/jest' +import createServer from '../../server' +import { createTestClient } from 'apollo-server-testing' + +let user +let query +let mutate + +const driver = getDriver() + +const generateInviteCodeMutation = gql` + mutation($expiresAt: String = null) { + GenerateInviteCode(expiresAt: $expiresAt) { + code + createdAt + expiresAt + } + } +` + +const myInviteCodesQuery = gql` + query { + MyInviteCodes { + code + createdAt + expiresAt + } + } +` + +const isValidInviteCodeQuery = gql` + query($code: ID!) { + isValidInviteCode(code: $code) + } +` + +beforeAll(async () => { + await cleanDatabase() + const { server } = createServer({ + context: () => { + return { + driver, + user, + } + }, + }) + query = createTestClient(server).query + mutate = createTestClient(server).mutate +}) + +afterAll(async () => { + await cleanDatabase() +}) + +describe('inviteCodes', () => { + describe('as unauthenticated user', () => { + it('cannot generate invite codes', async () => { + await expect(mutate({ mutation: generateInviteCodeMutation })).resolves.toEqual( + expect.objectContaining({ + errors: expect.arrayContaining([ + expect.objectContaining({ + extensions: { code: 'INTERNAL_SERVER_ERROR' }, + }), + ]), + data: { + GenerateInviteCode: null, + }, + }), + ) + }) + + it('cannot query invite codes', async () => { + await expect(query({ query: myInviteCodesQuery })).resolves.toEqual( + expect.objectContaining({ + errors: expect.arrayContaining([ + expect.objectContaining({ + extensions: { code: 'INTERNAL_SERVER_ERROR' }, + }), + ]), + data: { + MyInviteCodes: null, + }, + }), + ) + }) + }) + + describe('as authenticated user', () => { + beforeAll(async () => { + const authenticatedUser = await Factory.build( + 'user', + { + role: 'user', + }, + { + email: 'user@example.org', + password: '1234', + }, + ) + user = await authenticatedUser.toJson() + }) + + it('generates an invite code without expiresAt', async () => { + await expect(mutate({ mutation: generateInviteCodeMutation })).resolves.toEqual( + expect.objectContaining({ + errors: undefined, + data: { + GenerateInviteCode: { + code: expect.stringMatching(/^[0-9A-Z]{6,6}$/), + expiresAt: null, + createdAt: expect.any(String), + }, + }, + }), + ) + }) + + it('generates an invite code with expiresAt', async () => { + const nextWeek = new Date() + nextWeek.setDate(nextWeek.getDate() + 7) + await expect( + mutate({ + mutation: generateInviteCodeMutation, + variables: { expiresAt: nextWeek.toISOString() }, + }), + ).resolves.toEqual( + expect.objectContaining({ + errors: undefined, + data: { + GenerateInviteCode: { + code: expect.stringMatching(/^[0-9A-Z]{6,6}$/), + expiresAt: nextWeek.toISOString(), + createdAt: expect.any(String), + }, + }, + }), + ) + }) + + let inviteCodes + + it('returns the created invite codes when queried', async () => { + const response = await query({ query: myInviteCodesQuery }) + inviteCodes = response.data.MyInviteCodes + expect(inviteCodes).toHaveLength(2) + }) + + it('does not return the created invite codes of other users when queried', async () => { + await Factory.build('inviteCode') + const response = await query({ query: myInviteCodesQuery }) + inviteCodes = response.data.MyInviteCodes + expect(inviteCodes).toHaveLength(2) + }) + + it('validates an invite code without expiresAt', async () => { + const unExpiringInviteCode = inviteCodes.filter((ic) => ic.expiresAt === null)[0].code + const result = await query({ + query: isValidInviteCodeQuery, + variables: { code: unExpiringInviteCode }, + }) + expect(result.data.isValidInviteCode).toBeTruthy() + }) + + it('validates an invite code in lower case', async () => { + const unExpiringInviteCode = inviteCodes.filter((ic) => ic.expiresAt === null)[0].code + const result = await query({ + query: isValidInviteCodeQuery, + variables: { code: unExpiringInviteCode.toLowerCase() }, + }) + expect(result.data.isValidInviteCode).toBeTruthy() + }) + + it('validates an invite code with expiresAt in the future', async () => { + const expiringInviteCode = inviteCodes.filter((ic) => ic.expiresAt !== null)[0].code + const result = await query({ + query: isValidInviteCodeQuery, + variables: { code: expiringInviteCode }, + }) + expect(result.data.isValidInviteCode).toBeTruthy() + }) + + it('does not validate an invite code which expired in the past', async () => { + const lastWeek = new Date() + lastWeek.setDate(lastWeek.getDate() - 7) + const inviteCode = await Factory.build('inviteCode', { + expiresAt: lastWeek.toISOString(), + }) + const code = inviteCode.get('code') + const result = await query({ query: isValidInviteCodeQuery, variables: { code } }) + expect(result.data.isValidInviteCode).toBeFalsy() + }) + + it('does not validate an invite code which does not exits', async () => { + const result = await query({ query: isValidInviteCodeQuery, variables: { code: 'AAA' } }) + expect(result.data.isValidInviteCode).toBeFalsy() + }) + }) +}) diff --git a/backend/src/schema/resolvers/locations.js b/backend/src/schema/resolvers/locations.js index be72001f7..fa0feafa1 100644 --- a/backend/src/schema/resolvers/locations.js +++ b/backend/src/schema/resolvers/locations.js @@ -1,4 +1,6 @@ +import { UserInputError } from 'apollo-server' import Resolver from './helpers/Resolver' +import { queryLocations } from './users/location' export default { Location: { @@ -16,4 +18,13 @@ export default { ], }), }, + Query: { + queryLocations: async (object, args, context, resolveInfo) => { + try { + return queryLocations(args) + } catch (e) { + throw new UserInputError(e.message) + } + }, + }, } diff --git a/backend/src/schema/resolvers/posts.js b/backend/src/schema/resolvers/posts.js index f209158fe..14e645730 100644 --- a/backend/src/schema/resolvers/posts.js +++ b/backend/src/schema/resolvers/posts.js @@ -76,7 +76,6 @@ export default { }, Mutation: { CreatePost: async (_parent, params, context, _resolveInfo) => { - const { categoryIds } = params const { image: imageInput } = params delete params.categoryIds delete params.image @@ -92,13 +91,9 @@ export default { WITH post MATCH (author:User {id: $userId}) MERGE (post)<-[:WROTE]-(author) - WITH post - UNWIND $categoryIds AS categoryId - MATCH (category:Category {id: categoryId}) - MERGE (post)-[:CATEGORIZED]->(category) RETURN post {.*} `, - { userId: context.user.id, categoryIds, params }, + { userId: context.user.id, params }, ) const [post] = createPostTransactionResponse.records.map((record) => record.get('post')) if (imageInput) { diff --git a/backend/src/schema/resolvers/posts.spec.js b/backend/src/schema/resolvers/posts.spec.js index b24383fba..f0c57b8fb 100644 --- a/backend/src/schema/resolvers/posts.spec.js +++ b/backend/src/schema/resolvers/posts.spec.js @@ -317,19 +317,6 @@ describe('CreatePost', () => { expected, ) }) - - describe('language', () => { - beforeEach(() => { - variables = { ...variables, language: 'es' } - }) - - it('allows a user to set the language of the post', async () => { - const expected = { data: { CreatePost: { language: 'es' } } } - await expect(mutate({ mutation: createPostMutation, variables })).resolves.toMatchObject( - expected, - ) - }) - }) }) }) diff --git a/backend/src/schema/resolvers/searches.js b/backend/src/schema/resolvers/searches.js index 58fa63f8d..7b157fc65 100644 --- a/backend/src/schema/resolvers/searches.js +++ b/backend/src/schema/resolvers/searches.js @@ -3,90 +3,200 @@ import { queryString } from './searches/queryString' // see http://lucene.apache.org/core/8_3_1/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#package.description +const cypherTemplate = (setup) => ` + CALL db.index.fulltext.queryNodes('${setup.fulltextIndex}', $query) + YIELD node AS resource, score + ${setup.match} + ${setup.whereClause} + ${setup.withClause} + RETURN + ${setup.returnClause} + AS result + SKIP $skip + ${setup.limit} +` + +const simpleWhereClause = + 'WHERE score >= 0.0 AND NOT (resource.deleted = true OR resource.disabled = true)' + +const postWhereClause = `WHERE score >= 0.0 + AND NOT ( + author.deleted = true OR author.disabled = true + OR resource.deleted = true OR resource.disabled = true + OR (:User {id: $userId})-[:MUTED]->(author) + )` + +const searchPostsSetup = { + fulltextIndex: 'post_fulltext_search', + match: 'MATCH (resource:Post)<-[:WROTE]-(author:User)', + whereClause: postWhereClause, + withClause: `WITH resource, author, + [(resource)<-[:COMMENTS]-(comment:Comment) | comment] AS comments, + [(resource)<-[:SHOUTED]-(user:User) | user] AS shouter`, + returnClause: `resource { + .*, + __typename: labels(resource)[0], + author: properties(author), + commentsCount: toString(size(comments)), + shoutedCount: toString(size(shouter)) + }`, + limit: 'LIMIT $limit', +} + +const searchUsersSetup = { + fulltextIndex: 'user_fulltext_search', + match: 'MATCH (resource:User)', + whereClause: simpleWhereClause, + withClause: '', + returnClause: 'resource {.*, __typename: labels(resource)[0]}', + limit: 'LIMIT $limit', +} + +const searchHashtagsSetup = { + fulltextIndex: 'tag_fulltext_search', + match: 'MATCH (resource:Tag)', + whereClause: simpleWhereClause, + withClause: '', + returnClause: 'resource {.*, __typename: labels(resource)[0]}', + limit: 'LIMIT $limit', +} + +const countSetup = { + returnClause: 'toString(size(collect(resource)))', + limit: '', +} + +const countUsersSetup = { + ...searchUsersSetup, + ...countSetup, +} +const countPostsSetup = { + ...searchPostsSetup, + ...countSetup, +} +const countHashtagsSetup = { + ...searchHashtagsSetup, + ...countSetup, +} + +const searchResultPromise = async (session, setup, params) => { + return session.readTransaction(async (transaction) => { + return transaction.run(cypherTemplate(setup), params) + }) +} + +const searchResultCallback = (result) => { + return result.records.map((r) => r.get('result')) +} + +const countResultCallback = (result) => { + return result.records[0].get('result') +} + +const getSearchResults = async (context, setup, params, resultCallback = searchResultCallback) => { + const session = context.driver.session() + try { + const results = await searchResultPromise(session, setup, params) + log(results) + return resultCallback(results) + } finally { + session.close() + } +} + +const multiSearchMap = [ + { symbol: '!', setup: searchPostsSetup, resultName: 'posts' }, + { symbol: '@', setup: searchUsersSetup, resultName: 'users' }, + { symbol: '#', setup: searchHashtagsSetup, resultName: 'hashtags' }, +] + export default { Query: { - findResources: async (_parent, args, context, _resolveInfo) => { + searchPosts: async (_parent, args, context, _resolveInfo) => { + const { query, postsOffset, firstPosts } = args + const { id: userId } = context.user + + return { + postCount: getSearchResults( + context, + countPostsSetup, + { + query: queryString(query), + skip: 0, + userId, + }, + countResultCallback, + ), + posts: getSearchResults(context, searchPostsSetup, { + query: queryString(query), + skip: postsOffset, + limit: firstPosts, + userId, + }), + } + }, + searchUsers: async (_parent, args, context, _resolveInfo) => { + const { query, usersOffset, firstUsers } = args + return { + userCount: getSearchResults( + context, + countUsersSetup, + { + query: queryString(query), + skip: 0, + }, + countResultCallback, + ), + users: getSearchResults(context, searchUsersSetup, { + query: queryString(query), + skip: usersOffset, + limit: firstUsers, + }), + } + }, + searchHashtags: async (_parent, args, context, _resolveInfo) => { + const { query, hashtagsOffset, firstHashtags } = args + return { + hashtagCount: getSearchResults( + context, + countHashtagsSetup, + { + query: queryString(query), + skip: 0, + }, + countResultCallback, + ), + hashtags: getSearchResults(context, searchHashtagsSetup, { + query: queryString(query), + skip: hashtagsOffset, + limit: firstHashtags, + }), + } + }, + searchResults: async (_parent, args, context, _resolveInfo) => { const { query, limit } = args - const { id: thisUserId } = context.user + const { id: userId } = context.user - const postCypher = ` - CALL db.index.fulltext.queryNodes('post_fulltext_search', $query) - YIELD node as resource, score - MATCH (resource)<-[:WROTE]-(author:User) - WHERE score >= 0.0 - AND NOT ( - author.deleted = true OR author.disabled = true - OR resource.deleted = true OR resource.disabled = true - OR (:User {id: $thisUserId})-[:MUTED]->(author) - ) - WITH resource, author, - [(resource)<-[:COMMENTS]-(comment:Comment) | comment] as comments, - [(resource)<-[:SHOUTED]-(user:User) | user] as shouter - RETURN resource { - .*, - __typename: labels(resource)[0], - author: properties(author), - commentsCount: toString(size(comments)), - shoutedCount: toString(size(shouter)) + const searchType = query.replace(/^([!@#]?).*$/, '$1') + const searchString = query.replace(/^([!@#])/, '') + + const params = { + query: queryString(searchString), + skip: 0, + limit, + userId, } - LIMIT $limit - ` - const userCypher = ` - CALL db.index.fulltext.queryNodes('user_fulltext_search', $query) - YIELD node as resource, score - MATCH (resource) - WHERE score >= 0.0 - AND NOT (resource.deleted = true OR resource.disabled = true) - RETURN resource {.*, __typename: labels(resource)[0]} - LIMIT $limit - ` - const tagCypher = ` - CALL db.index.fulltext.queryNodes('tag_fulltext_search', $query) - YIELD node as resource, score - MATCH (resource) - WHERE score >= 0.0 - AND NOT (resource.deleted = true OR resource.disabled = true) - RETURN resource {.*, __typename: labels(resource)[0]} - LIMIT $limit - ` + if (searchType === '') + return [ + ...(await getSearchResults(context, searchPostsSetup, params)), + ...(await getSearchResults(context, searchUsersSetup, params)), + ...(await getSearchResults(context, searchHashtagsSetup, params)), + ] - const myQuery = queryString(query) - - const session = context.driver.session() - const searchResultPromise = session.readTransaction(async (transaction) => { - const postTransactionResponse = transaction.run(postCypher, { - query: myQuery, - limit, - thisUserId, - }) - const userTransactionResponse = transaction.run(userCypher, { - query: myQuery, - limit, - thisUserId, - }) - const tagTransactionResponse = transaction.run(tagCypher, { - query: myQuery, - limit, - }) - return Promise.all([ - postTransactionResponse, - userTransactionResponse, - tagTransactionResponse, - ]) - }) - - try { - const [postResults, userResults, tagResults] = await searchResultPromise - log(postResults) - log(userResults) - log(tagResults) - return [...postResults.records, ...userResults.records, ...tagResults.records].map((r) => - r.get('resource'), - ) - } finally { - session.close() - } + params.limit = 15 + const type = multiSearchMap.find((obj) => obj.symbol === searchType) + return getSearchResults(context, type.setup, params) }, }, } diff --git a/backend/src/schema/resolvers/searches.spec.js b/backend/src/schema/resolvers/searches.spec.js index 3d7bd039d..a859bf296 100644 --- a/backend/src/schema/resolvers/searches.spec.js +++ b/backend/src/schema/resolvers/searches.spec.js @@ -29,7 +29,7 @@ afterAll(async () => { const searchQuery = gql` query($query: String!) { - findResources(query: $query, limit: 5) { + searchResults(query: $query, limit: 5) { __typename ... on Post { id @@ -47,6 +47,21 @@ const searchQuery = gql` } } ` + +const searchPostQuery = gql` + query($query: String!, $firstPosts: Int, $postsOffset: Int) { + searchPosts(query: $query, firstPosts: $firstPosts, postsOffset: $postsOffset) { + postCount + posts { + __typename + id + title + content + } + } + } +` + describe('resolvers/searches', () => { let variables @@ -65,7 +80,7 @@ describe('resolvers/searches', () => { variables = { query: 'John' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { id: 'a-user', name: 'John Doe', @@ -95,7 +110,7 @@ describe('resolvers/searches', () => { variables = { query: 'beitrag' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'a-post', @@ -114,7 +129,7 @@ describe('resolvers/searches', () => { variables = { query: 'BEITRAG' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'a-post', @@ -132,7 +147,7 @@ describe('resolvers/searches', () => { it('returns empty search results', async () => { await expect( query({ query: searchQuery, variables: { query: 'Unfug' } }), - ).resolves.toMatchObject({ data: { findResources: [] } }) + ).resolves.toMatchObject({ data: { searchResults: [] } }) }) }) @@ -189,7 +204,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: 'beitrag' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: expect.arrayContaining([ + searchResults: expect.arrayContaining([ { __typename: 'Post', id: 'a-post', @@ -216,7 +231,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: 'tee-ei' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'g-post', @@ -235,7 +250,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: 'βteeeiβ' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'g-post', @@ -256,7 +271,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: '(a - b)Β²' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'c-post', @@ -277,7 +292,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: '(a-b)Β²' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'c-post', @@ -298,7 +313,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: '+ bΒ² 2.' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'c-post', @@ -321,7 +336,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: 'der panther' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: [ + searchResults: [ { __typename: 'Post', id: 'd-post', @@ -349,7 +364,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: 'VorΓΌ Subs' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: expect.arrayContaining([ + searchResults: expect.arrayContaining([ { __typename: 'Post', id: 'd-post', @@ -395,7 +410,7 @@ und hinter tausend StΓ€ben keine Welt.`, variables = { query: '-maria-' } await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ data: { - findResources: expect.arrayContaining([ + searchResults: expect.arrayContaining([ { __typename: 'User', id: 'c-user', @@ -416,6 +431,128 @@ und hinter tausend StΓ€ben keine Welt.`, }) }) + describe('adding a user and a hashtag with a name that is content of a post', () => { + beforeAll(async () => { + await Promise.all([ + Factory.build('user', { + id: 'f-user', + name: 'Peter Panther', + slug: 'peter-panther', + }), + await Factory.build('tag', { id: 'Panther' }), + ]) + }) + + describe('query the word that contains the post, the hashtag and the name of the user', () => { + it('finds the user, the post and the hashtag', async () => { + variables = { query: 'panther' } + await expect(query({ query: searchQuery, variables })).resolves.toMatchObject({ + data: { + searchResults: expect.arrayContaining([ + { + __typename: 'User', + id: 'f-user', + name: 'Peter Panther', + slug: 'peter-panther', + }, + { + __typename: 'Post', + id: 'd-post', + title: 'Der Panther', + content: `Sein Blick ist vom VorΓΌbergehn der StΓ€be