kaneo (minimalist kanban) fork to experiment adding a tangled integration
github.com/usekaneo/kaneo
1import { relations } from "drizzle-orm";
2import {
3 accountTable,
4 activityTable,
5 apikeyTable,
6 assetTable,
7 columnTable,
8 commentTable,
9 externalLinkTable,
10 githubIntegrationTable,
11 integrationTable,
12 invitationTable,
13 labelTable,
14 notificationTable,
15 projectTable,
16 sessionTable,
17 taskRelationTable,
18 taskReminderSentTable,
19 taskTable,
20 teamMemberTable,
21 teamTable,
22 timeEntryTable,
23 userNotificationPreferenceTable,
24 userNotificationWorkspaceProjectTable,
25 userNotificationWorkspaceRuleTable,
26 userTable,
27 verificationTable,
28 workflowRuleTable,
29 workspaceTable,
30 workspaceUserTable,
31} from "./schema";
32
33export const userTableRelations = relations(userTable, ({ many, one }) => ({
34 sessions: many(sessionTable),
35 accounts: many(accountTable),
36 teamMembers: many(teamMemberTable),
37 workspaces: many(workspaceTable),
38 workspaceMemberships: many(workspaceUserTable),
39 assignedTasks: many(taskTable),
40 timeEntries: many(timeEntryTable),
41 activities: many(activityTable),
42 comments: many(commentTable),
43 assets: many(assetTable),
44 notifications: many(notificationTable),
45 notificationPreference: one(userNotificationPreferenceTable),
46 notificationWorkspaceRules: many(userNotificationWorkspaceRuleTable),
47 sentInvitations: many(invitationTable),
48 apikeys: many(apikeyTable),
49}));
50
51export const sessionTableRelations = relations(sessionTable, ({ one }) => ({
52 user: one(userTable, {
53 fields: [sessionTable.userId],
54 references: [userTable.id],
55 }),
56}));
57
58export const accountTableRelations = relations(accountTable, ({ one }) => ({
59 user: one(userTable, {
60 fields: [accountTable.userId],
61 references: [userTable.id],
62 }),
63}));
64
65export const verificationTableRelations = relations(
66 verificationTable,
67 () => ({}),
68);
69
70export const workspaceTableRelations = relations(
71 workspaceTable,
72 ({ many }) => ({
73 teams: many(teamTable),
74 members: many(workspaceUserTable),
75 projects: many(projectTable),
76 assets: many(assetTable),
77 invitations: many(invitationTable),
78 notificationWorkspaceRules: many(userNotificationWorkspaceRuleTable),
79 }),
80);
81
82export const workspaceUserTableRelations = relations(
83 workspaceUserTable,
84 ({ one }) => ({
85 workspace: one(workspaceTable, {
86 fields: [workspaceUserTable.workspaceId],
87 references: [workspaceTable.id],
88 }),
89 user: one(userTable, {
90 fields: [workspaceUserTable.userId],
91 references: [userTable.id],
92 }),
93 }),
94);
95
96export const projectTableRelations = relations(
97 projectTable,
98 ({ one, many }) => ({
99 workspace: one(workspaceTable, {
100 fields: [projectTable.workspaceId],
101 references: [workspaceTable.id],
102 }),
103 tasks: many(taskTable),
104 assets: many(assetTable),
105 columns: many(columnTable),
106 workflowRules: many(workflowRuleTable),
107 githubIntegration: many(githubIntegrationTable),
108 integrations: many(integrationTable),
109 notificationWorkspaceProjects: many(userNotificationWorkspaceProjectTable),
110 }),
111);
112
113export const columnTableRelations = relations(columnTable, ({ one, many }) => ({
114 project: one(projectTable, {
115 fields: [columnTable.projectId],
116 references: [projectTable.id],
117 }),
118 tasks: many(taskTable),
119 workflowRules: many(workflowRuleTable),
120}));
121
122export const workflowRuleTableRelations = relations(
123 workflowRuleTable,
124 ({ one }) => ({
125 project: one(projectTable, {
126 fields: [workflowRuleTable.projectId],
127 references: [projectTable.id],
128 }),
129 column: one(columnTable, {
130 fields: [workflowRuleTable.columnId],
131 references: [columnTable.id],
132 }),
133 }),
134);
135
136export const taskTableRelations = relations(taskTable, ({ one, many }) => ({
137 project: one(projectTable, {
138 fields: [taskTable.projectId],
139 references: [projectTable.id],
140 }),
141 assignee: one(userTable, {
142 fields: [taskTable.userId],
143 references: [userTable.id],
144 }),
145 column: one(columnTable, {
146 fields: [taskTable.columnId],
147 references: [columnTable.id],
148 }),
149 timeEntries: many(timeEntryTable),
150 activities: many(activityTable),
151 comments: many(commentTable),
152 assets: many(assetTable),
153 labels: many(labelTable),
154 externalLinks: many(externalLinkTable),
155 sourceRelations: many(taskRelationTable, { relationName: "sourceTask" }),
156 targetRelations: many(taskRelationTable, { relationName: "targetTask" }),
157 remindersSent: many(taskReminderSentTable),
158}));
159
160export const timeEntryTableRelations = relations(timeEntryTable, ({ one }) => ({
161 task: one(taskTable, {
162 fields: [timeEntryTable.taskId],
163 references: [taskTable.id],
164 }),
165 user: one(userTable, {
166 fields: [timeEntryTable.userId],
167 references: [userTable.id],
168 }),
169}));
170
171export const activityTableRelations = relations(activityTable, ({ one }) => ({
172 task: one(taskTable, {
173 fields: [activityTable.taskId],
174 references: [taskTable.id],
175 }),
176 user: one(userTable, {
177 fields: [activityTable.userId],
178 references: [userTable.id],
179 }),
180}));
181
182export const assetTableRelations = relations(assetTable, ({ one }) => ({
183 workspace: one(workspaceTable, {
184 fields: [assetTable.workspaceId],
185 references: [workspaceTable.id],
186 }),
187 project: one(projectTable, {
188 fields: [assetTable.projectId],
189 references: [projectTable.id],
190 }),
191 task: one(taskTable, {
192 fields: [assetTable.taskId],
193 references: [taskTable.id],
194 }),
195 activity: one(activityTable, {
196 fields: [assetTable.activityId],
197 references: [activityTable.id],
198 }),
199 creator: one(userTable, {
200 fields: [assetTable.createdBy],
201 references: [userTable.id],
202 }),
203}));
204
205export const labelTableRelations = relations(labelTable, ({ one }) => ({
206 task: one(taskTable, {
207 fields: [labelTable.taskId],
208 references: [taskTable.id],
209 }),
210}));
211
212export const notificationTableRelations = relations(
213 notificationTable,
214 ({ one }) => ({
215 user: one(userTable, {
216 fields: [notificationTable.userId],
217 references: [userTable.id],
218 }),
219 }),
220);
221
222export const userNotificationPreferenceTableRelations = relations(
223 userNotificationPreferenceTable,
224 ({ one }) => ({
225 user: one(userTable, {
226 fields: [userNotificationPreferenceTable.userId],
227 references: [userTable.id],
228 }),
229 }),
230);
231
232export const userNotificationWorkspaceRuleTableRelations = relations(
233 userNotificationWorkspaceRuleTable,
234 ({ one, many }) => ({
235 user: one(userTable, {
236 fields: [userNotificationWorkspaceRuleTable.userId],
237 references: [userTable.id],
238 }),
239 workspace: one(workspaceTable, {
240 fields: [userNotificationWorkspaceRuleTable.workspaceId],
241 references: [workspaceTable.id],
242 }),
243 selectedProjects: many(userNotificationWorkspaceProjectTable),
244 }),
245);
246
247export const userNotificationWorkspaceProjectTableRelations = relations(
248 userNotificationWorkspaceProjectTable,
249 ({ one }) => ({
250 workspaceRule: one(userNotificationWorkspaceRuleTable, {
251 fields: [
252 userNotificationWorkspaceProjectTable.workspaceId,
253 userNotificationWorkspaceProjectTable.workspaceRuleId,
254 ],
255 references: [
256 userNotificationWorkspaceRuleTable.workspaceId,
257 userNotificationWorkspaceRuleTable.id,
258 ],
259 }),
260 project: one(projectTable, {
261 fields: [
262 userNotificationWorkspaceProjectTable.workspaceId,
263 userNotificationWorkspaceProjectTable.projectId,
264 ],
265 references: [projectTable.workspaceId, projectTable.id],
266 }),
267 }),
268);
269
270export const githubIntegrationTableRelations = relations(
271 githubIntegrationTable,
272 ({ one }) => ({
273 project: one(projectTable, {
274 fields: [githubIntegrationTable.projectId],
275 references: [projectTable.id],
276 }),
277 }),
278);
279
280export const teamTableRelations = relations(teamTable, ({ one, many }) => ({
281 workspace: one(workspaceTable, {
282 fields: [teamTable.workspaceId],
283 references: [workspaceTable.id],
284 }),
285 teamMembers: many(teamMemberTable),
286}));
287
288export const teamMemberTableRelations = relations(
289 teamMemberTable,
290 ({ one }) => ({
291 team: one(teamTable, {
292 fields: [teamMemberTable.teamId],
293 references: [teamTable.id],
294 }),
295 user: one(userTable, {
296 fields: [teamMemberTable.userId],
297 references: [userTable.id],
298 }),
299 }),
300);
301
302export const invitationTableRelations = relations(
303 invitationTable,
304 ({ one }) => ({
305 workspace: one(workspaceTable, {
306 fields: [invitationTable.workspaceId],
307 references: [workspaceTable.id],
308 }),
309 inviter: one(userTable, {
310 fields: [invitationTable.inviterId],
311 references: [userTable.id],
312 }),
313 }),
314);
315
316export const apikeyTableRelations = relations(apikeyTable, ({ one }) => ({
317 user: one(userTable, {
318 fields: [apikeyTable.referenceId],
319 references: [userTable.id],
320 }),
321}));
322
323export const integrationTableRelations = relations(
324 integrationTable,
325 ({ one, many }) => ({
326 project: one(projectTable, {
327 fields: [integrationTable.projectId],
328 references: [projectTable.id],
329 }),
330 externalLinks: many(externalLinkTable),
331 }),
332);
333
334export const taskRelationTableRelations = relations(
335 taskRelationTable,
336 ({ one }) => ({
337 sourceTask: one(taskTable, {
338 fields: [taskRelationTable.sourceTaskId],
339 references: [taskTable.id],
340 relationName: "sourceTask",
341 }),
342 targetTask: one(taskTable, {
343 fields: [taskRelationTable.targetTaskId],
344 references: [taskTable.id],
345 relationName: "targetTask",
346 }),
347 }),
348);
349
350export const externalLinkTableRelations = relations(
351 externalLinkTable,
352 ({ one }) => ({
353 task: one(taskTable, {
354 fields: [externalLinkTable.taskId],
355 references: [taskTable.id],
356 }),
357 integration: one(integrationTable, {
358 fields: [externalLinkTable.integrationId],
359 references: [integrationTable.id],
360 }),
361 }),
362);
363
364export const taskReminderSentTableRelations = relations(
365 taskReminderSentTable,
366 ({ one }) => ({
367 task: one(taskTable, {
368 fields: [taskReminderSentTable.taskId],
369 references: [taskTable.id],
370 }),
371 }),
372);
373
374export const commentTableRelations = relations(commentTable, ({ one }) => ({
375 task: one(taskTable, {
376 fields: [commentTable.taskId],
377 references: [taskTable.id],
378 }),
379 user: one(userTable, {
380 fields: [commentTable.userId],
381 references: [userTable.id],
382 }),
383}));