feat: kysely project suggestion

taskany-inc · Jul 29, 2024 · b0dc889 · b0dc889
1 parent f1b553a
commit b0dc889
Show file tree

Hide file tree

Showing 6 changed files with 72 additions and 91 deletions.
diff --git a/src/components/GoalParentDropdown/GoalParentDropdown.tsx b/src/components/GoalParentDropdown/GoalParentDropdown.tsx
@@ -76,7 +76,7 @@ export const GoalParentDropdown = ({
         },
     );
 
-    const { data: suggestionsProjects = [] } = trpc.project.suggestions.useQuery(
+    const { data: suggestionsProjects = [] } = trpc.v2.project.suggestions.useQuery(
         {
             query: inputState,
             filter: filterIds,

diff --git a/src/schema/project.ts b/src/schema/project.ts
@@ -10,7 +10,6 @@ export const projectDeepInfoSchema = queryWithFiltersSchema.extend({
 export const projectSuggestionsSchema = z.object({
     query: z.string(),
     take: z.number().optional(),
-    include: z.array(z.string()).optional(),
     filter: z.array(z.string()).optional(),
 });
 

diff --git a/src/utils/filters.ts b/src/utils/filters.ts
@@ -22,31 +22,11 @@ export const filtersPanelSsrInit = async ({ query, ssrHelpers, req }: SSRProps)
         : browserQueryState;
 
     await Promise.all([
-        ssrHelpers.user.suggestions.fetch({
-            take: filtersTakeCount,
-            query: '',
-            include: queryState.owner,
-        }),
-        ssrHelpers.user.suggestions.fetch({
-            take: filtersTakeCount,
-            query: '',
-            include: queryState.participant,
-        }),
-        ssrHelpers.user.suggestions.fetch({
-            take: filtersTakeCount,
-            query: '',
-            include: queryState.issuer,
-        }),
-        ssrHelpers.project.suggestions.fetch({
-            take: filtersTakeCount,
-            query: '',
-            include: queryState.project,
-        }),
-        ssrHelpers.tag.suggestions.fetch({
-            take: filtersTakeCount,
-            query: '',
-            include: queryState.tag,
-        }),
+        ssrHelpers.user.getFilterUsersByIds.fetch(queryState.owner ?? []),
+        ssrHelpers.user.getFilterUsersByIds.fetch(queryState.participant ?? []),
+        ssrHelpers.user.getFilterUsersByIds.fetch(queryState.issuer ?? []),
+        ssrHelpers.project.getByIds.fetch({ ids: queryState.project ?? [] }),
+        ssrHelpers.tag.getByIds.fetch(queryState.tag ?? []),
         ssrHelpers.state.all.fetch(),
     ]);
 

diff --git a/trpc/queries/projectV2.ts b/trpc/queries/projectV2.ts
@@ -553,3 +553,44 @@ export const getWholeGoalCountByProjectIds = (params: GetWholeGoalCountByProject
             ),
         );
 };
+
+interface GetProjectSuggestionsParams {
+    activityId: string;
+    role: Role;
+    query: string;
+    filter?: string[];
+    limit?: number;
+}
+
+export const getProjectSuggestions = ({
+    role,
+    filter = [],
+    query,
+    limit = 5,
+    activityId,
+}: GetProjectSuggestionsParams) => {
+    return db
+        .selectFrom('Project')
+        .selectAll()
+        .where('Project.archived', 'is not', true)
+        .where('Project.title', 'ilike', `%${query}%`)
+        .$if(role === Role.USER, (qb) =>
+            qb.where(({ or, eb, not, exists }) =>
+                or([
+                    eb('Project.activityId', '=', activityId),
+                    eb('Project.id', 'in', ({ selectFrom }) =>
+                        selectFrom('_projectAccess').select('B').where('A', '=', activityId),
+                    ),
+                    not(
+                        exists(({ selectFrom }) =>
+                            selectFrom('_projectAccess').select('B').whereRef('B', '=', 'Project.id'),
+                        ),
+                    ),
+                ]),
+            ),
+        )
+        .$if(filter.length > 0, (qb) => qb.where('Project.id', 'not in', filter))
+        .groupBy('Project.id')
+        .orderBy(sql`CHAR_LENGTH(title)`)
+        .limit(limit);
+};
diff --git a/trpc/router/project.ts b/trpc/router/project.ts
@@ -8,7 +8,6 @@ import {
     projectCreateSchema,
     projectTransferOwnershipSchema,
     projectUpdateSchema,
-    projectSuggestionsSchema,
     projectDeleteSchema,
     participantsToProjectSchema,
     teamsToProjectSchema,
@@ -65,68 +64,6 @@ const getUserItemsWhereSchema = ({ type, activityId }: { type: 'goal' | 'project
 };
 
 export const project = router({
-    suggestions: protectedProcedure
-        .input(projectSuggestionsSchema)
-        .query(async ({ input: { query, take = 5, include, filter }, ctx }) => {
-            const { activityId, role } = ctx.session.user;
-
-            const includeInput = {
-                activity: {
-                    include: {
-                        user: true,
-                    },
-                },
-                flow: {
-                    include: {
-                        states: true,
-                    },
-                },
-            };
-
-            // TODO: should we use getProjectSchema here?
-
-            const accessFilter = getProjectAccessFilter(activityId, role);
-            const requests = [
-                prisma.project.findMany({
-                    take,
-                    where: {
-                        personal: false,
-                        title: {
-                            contains: query,
-                            mode: 'insensitive',
-                        },
-                        ...accessFilter,
-                        ...(include?.length || filter?.length
-                            ? {
-                                  id: {
-                                      notIn: [...(filter || []), ...(include || [])],
-                                  },
-                              }
-                            : {}),
-                        ...nonArchivedPartialQuery,
-                    },
-                    include: includeInput,
-                }),
-            ];
-
-            if (include) {
-                requests.push(
-                    prisma.project.findMany({
-                        where: {
-                            id: {
-                                in: include,
-                            },
-                            personal: false,
-                            ...accessFilter,
-                            ...nonArchivedPartialQuery,
-                        },
-                        include: includeInput,
-                    }),
-                );
-            }
-
-            return Promise.all(requests).then(([suggest, included = []]) => [...included, ...suggest]);
-        }),
     getUserProjectsWithGoals: protectedProcedure
         .input(
             z.object({

diff --git a/trpc/router/projectV2.ts b/trpc/router/projectV2.ts
@@ -3,10 +3,11 @@ import { sql } from 'kysely';
 import { jsonBuildObject } from 'kysely/helpers/postgres';
 
 import { router, protectedProcedure } from '../trpcBackend';
-import { userProjectsSchema } from '../../src/schema/project';
+import { projectSuggestionsSchema, userProjectsSchema } from '../../src/schema/project';
 import {
     getProjectsByIds,
     getStarredProjectsIds,
+    getProjectSuggestions,
     getUserProjectsQuery,
     getUserProjectsWithGoals,
     getWholeGoalCountByProjectIds,
@@ -57,6 +58,29 @@ interface ProjectsWithGoals extends Pick<ProjectResponse, 'id'> {
 }
 
 export const project = router({
+    suggestions: protectedProcedure
+        .input(projectSuggestionsSchema)
+        .query(async ({ input: { query, take = 5, filter }, ctx }) => {
+            const { activityId, role } = ctx.session.user;
+
+            try {
+                const sql = getProjectSuggestions({
+                    role,
+                    query,
+                    filter,
+                    limit: take,
+                    activityId,
+                });
+
+                const res = await sql.execute();
+
+                return res;
+            } catch (error) {
+                console.error(error);
+
+                return Promise.reject(error);
+            }
+        }),
     userProjects: protectedProcedure.input(userProjectsSchema).query(async ({ ctx, input: { take, filter } }) => {
         const { activityId, role } = ctx.session.user;
         try {