danieldaum.net
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 externalLinkTable,
9 githubIntegrationTable,
10 integrationTable,
11 invitationTable,
12 labelTable,
13 notificationTable,
14 projectTable,
15 sessionTable,
16 taskTable,
17 teamMemberTable,
18 teamTable,
19 timeEntryTable,
20 userTable,
21 verificationTable,
22 workflowRuleTable,
23 workspaceTable,
24 workspaceUserTable,
25} from "./schema";
26
27export const userTableRelations = relations(userTable, ({ many }) => ({
28 sessions: many(sessionTable),
29 accounts: many(accountTable),
30 teamMembers: many(teamMemberTable),
31 workspaces: many(workspaceTable),
32 workspaceMemberships: many(workspaceUserTable),
33 assignedTasks: many(taskTable),
34 timeEntries: many(timeEntryTable),
35 activities: many(activityTable),
36 assets: many(assetTable),
37 notifications: many(notificationTable),
38 sentInvitations: many(invitationTable),
39 apikeys: many(apikeyTable),
40}));
41
42export const sessionTableRelations = relations(sessionTable, ({ one }) => ({
43 user: one(userTable, {
44 fields: [sessionTable.userId],
45 references: [userTable.id],
46 }),
47}));
48
49export const accountTableRelations = relations(accountTable, ({ one }) => ({
50 user: one(userTable, {
51 fields: [accountTable.userId],
52 references: [userTable.id],
53 }),
54}));
55
56export const verificationTableRelations = relations(
57 verificationTable,
58 () => ({}),
59);
60
61export const workspaceTableRelations = relations(
62 workspaceTable,
63 ({ many }) => ({
64 teams: many(teamTable),
65 members: many(workspaceUserTable),
66 projects: many(projectTable),
67 assets: many(assetTable),
68 invitations: many(invitationTable),
69 }),
70);
71
72export const workspaceUserTableRelations = relations(
73 workspaceUserTable,
74 ({ one }) => ({
75 workspace: one(workspaceTable, {
76 fields: [workspaceUserTable.workspaceId],
77 references: [workspaceTable.id],
78 }),
79 user: one(userTable, {
80 fields: [workspaceUserTable.userId],
81 references: [userTable.id],
82 }),
83 }),
84);
85
86export const projectTableRelations = relations(
87 projectTable,
88 ({ one, many }) => ({
89 workspace: one(workspaceTable, {
90 fields: [projectTable.workspaceId],
91 references: [workspaceTable.id],
92 }),
93 tasks: many(taskTable),
94 assets: many(assetTable),
95 columns: many(columnTable),
96 workflowRules: many(workflowRuleTable),
97 githubIntegration: many(githubIntegrationTable),
98 integrations: many(integrationTable),
99 }),
100);
101
102export const columnTableRelations = relations(columnTable, ({ one, many }) => ({
103 project: one(projectTable, {
104 fields: [columnTable.projectId],
105 references: [projectTable.id],
106 }),
107 tasks: many(taskTable),
108 workflowRules: many(workflowRuleTable),
109}));
110
111export const workflowRuleTableRelations = relations(
112 workflowRuleTable,
113 ({ one }) => ({
114 project: one(projectTable, {
115 fields: [workflowRuleTable.projectId],
116 references: [projectTable.id],
117 }),
118 column: one(columnTable, {
119 fields: [workflowRuleTable.columnId],
120 references: [columnTable.id],
121 }),
122 }),
123);
124
125export const taskTableRelations = relations(taskTable, ({ one, many }) => ({
126 project: one(projectTable, {
127 fields: [taskTable.projectId],
128 references: [projectTable.id],
129 }),
130 assignee: one(userTable, {
131 fields: [taskTable.userId],
132 references: [userTable.id],
133 }),
134 column: one(columnTable, {
135 fields: [taskTable.columnId],
136 references: [columnTable.id],
137 }),
138 timeEntries: many(timeEntryTable),
139 activities: many(activityTable),
140 assets: many(assetTable),
141 labels: many(labelTable),
142 externalLinks: many(externalLinkTable),
143}));
144
145export const timeEntryTableRelations = relations(timeEntryTable, ({ one }) => ({
146 task: one(taskTable, {
147 fields: [timeEntryTable.taskId],
148 references: [taskTable.id],
149 }),
150 user: one(userTable, {
151 fields: [timeEntryTable.userId],
152 references: [userTable.id],
153 }),
154}));
155
156export const activityTableRelations = relations(activityTable, ({ one }) => ({
157 task: one(taskTable, {
158 fields: [activityTable.taskId],
159 references: [taskTable.id],
160 }),
161 user: one(userTable, {
162 fields: [activityTable.userId],
163 references: [userTable.id],
164 }),
165}));
166
167export const assetTableRelations = relations(assetTable, ({ one }) => ({
168 workspace: one(workspaceTable, {
169 fields: [assetTable.workspaceId],
170 references: [workspaceTable.id],
171 }),
172 project: one(projectTable, {
173 fields: [assetTable.projectId],
174 references: [projectTable.id],
175 }),
176 task: one(taskTable, {
177 fields: [assetTable.taskId],
178 references: [taskTable.id],
179 }),
180 activity: one(activityTable, {
181 fields: [assetTable.activityId],
182 references: [activityTable.id],
183 }),
184 creator: one(userTable, {
185 fields: [assetTable.createdBy],
186 references: [userTable.id],
187 }),
188}));
189
190export const labelTableRelations = relations(labelTable, ({ one }) => ({
191 task: one(taskTable, {
192 fields: [labelTable.taskId],
193 references: [taskTable.id],
194 }),
195}));
196
197export const notificationTableRelations = relations(
198 notificationTable,
199 ({ one }) => ({
200 user: one(userTable, {
201 fields: [notificationTable.userId],
202 references: [userTable.id],
203 }),
204 }),
205);
206
207export const githubIntegrationTableRelations = relations(
208 githubIntegrationTable,
209 ({ one }) => ({
210 project: one(projectTable, {
211 fields: [githubIntegrationTable.projectId],
212 references: [projectTable.id],
213 }),
214 }),
215);
216
217export const teamTableRelations = relations(teamTable, ({ one, many }) => ({
218 workspace: one(workspaceTable, {
219 fields: [teamTable.workspaceId],
220 references: [workspaceTable.id],
221 }),
222 teamMembers: many(teamMemberTable),
223}));
224
225export const teamMemberTableRelations = relations(
226 teamMemberTable,
227 ({ one }) => ({
228 team: one(teamTable, {
229 fields: [teamMemberTable.teamId],
230 references: [teamTable.id],
231 }),
232 user: one(userTable, {
233 fields: [teamMemberTable.userId],
234 references: [userTable.id],
235 }),
236 }),
237);
238
239export const invitationTableRelations = relations(
240 invitationTable,
241 ({ one }) => ({
242 workspace: one(workspaceTable, {
243 fields: [invitationTable.workspaceId],
244 references: [workspaceTable.id],
245 }),
246 inviter: one(userTable, {
247 fields: [invitationTable.inviterId],
248 references: [userTable.id],
249 }),
250 }),
251);
252
253export const apikeyTableRelations = relations(apikeyTable, ({ one }) => ({
254 user: one(userTable, {
255 fields: [apikeyTable.referenceId],
256 references: [userTable.id],
257 }),
258}));
259
260export const integrationTableRelations = relations(
261 integrationTable,
262 ({ one, many }) => ({
263 project: one(projectTable, {
264 fields: [integrationTable.projectId],
265 references: [projectTable.id],
266 }),
267 externalLinks: many(externalLinkTable),
268 }),
269);
270
271export const externalLinkTableRelations = relations(
272 externalLinkTable,
273 ({ one }) => ({
274 task: one(taskTable, {
275 fields: [externalLinkTable.taskId],
276 references: [taskTable.id],
277 }),
278 integration: one(integrationTable, {
279 fields: [externalLinkTable.integrationId],
280 references: [integrationTable.id],
281 }),
282 }),
283);