Submatter/packages/database/src/schema/relations.ts

import {
  pgTable,
  uuid,
  varchar,
  timestamp,
  index,
  uniqueIndex,
} from "drizzle-orm/pg-core";
import { relations } from "drizzle-orm";
import { objects, objectAssignees, workspaceMembers } from "./objects";
import { users, accounts, sessions, userEmailIdentities } from "./users";
import { propertyDefinitions } from "./properties";
import { propertyValues } from "./values";
import { views } from "./views";
import { templates } from "./templates";
import { objectTypeDefs } from "./types";
import { markdownBacklogItems } from "./markdown_backlog";
import { cursorSyncMappings } from "./cursor_sync";
import { workspaces, workspaceInvites } from "./workspaces";
import { auditLog } from "./audit";
import { agentRuns } from "./agent_runs";
import { modelProviders } from "./model_providers";
import { roleModelRoutes } from "./role_model_routes";
import { connectedRepos } from "./connected_repos";
import { convoyEvents } from "./convoy_events";

export const objectRelations = pgTable(
  "object_relations",
  {
    id: uuid("id").primaryKey().defaultRandom(),
    sourceId: uuid("source_id")
      .notNull()
      .references(() => objects.id, { onDelete: "cascade" }),
    targetId: uuid("target_id")
      .notNull()
      .references(() => objects.id, { onDelete: "cascade" }),
    relationType: varchar("relation_type", { length: 50 }).notNull(),
    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
  },
  (table) => ({
    sourceIdIdx: index("object_relations_source_id_idx").on(table.sourceId),
    targetIdIdx: index("object_relations_target_id_idx").on(table.targetId),
    relationTypeIdx: index("object_relations_relation_type_idx").on(table.relationType),
    sourceTargetTypeUnique: uniqueIndex("object_relations_source_target_type_unique").on(
      table.sourceId,
      table.targetId,
      table.relationType,
    ),
  }),
);

// --- Drizzle ORM relations ---

export const usersRelations = relations(users, ({ many }) => ({
  objectsCreated: many(objects),
  workspaceMemberships: many(workspaceMembers),
  ownedWorkspaces: many(workspaces),
  objectAssignees: many(objectAssignees),
  accounts: many(accounts),
  sessions: many(sessions),
  emailIdentities: many(userEmailIdentities),
}));

export const userEmailIdentitiesRelations = relations(
  userEmailIdentities,
  ({ one }) => ({
    user: one(users, {
      fields: [userEmailIdentities.userId],
      references: [users.id],
    }),
  }),
);

export const workspaceInvitesRelations = relations(workspaceInvites, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [workspaceInvites.workspaceId],
    references: [workspaces.id],
  }),
  invitedBy: one(users, {
    fields: [workspaceInvites.invitedByUserId],
    references: [users.id],
  }),
}));

export const auditLogRelations = relations(auditLog, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [auditLog.workspaceId],
    references: [workspaces.id],
  }),
  actor: one(users, {
    fields: [auditLog.actorUserId],
    references: [users.id],
  }),
}));

export const agentRunsRelations = relations(agentRuns, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [agentRuns.workspaceId],
    references: [workspaces.id],
  }),
  backlogItem: one(markdownBacklogItems, {
    fields: [agentRuns.backlogItemId],
    references: [markdownBacklogItems.id],
  }),
  actor: one(users, {
    fields: [agentRuns.actorUserId],
    references: [users.id],
  }),
}));

export const workspacesRelations = relations(workspaces, ({ one, many }) => ({
  owner: one(users, {
    fields: [workspaces.ownerUserId],
    references: [users.id],
  }),
  members: many(workspaceMembers),
  invites: many(workspaceInvites),
  objects: many(objects),
  templates: many(templates),
  objectTypeDefs: many(objectTypeDefs),
  propertyDefinitions: many(propertyDefinitions),
  markdownBacklogItems: many(markdownBacklogItems),
  modelProviders: many(modelProviders),
  roleModelRoutes: many(roleModelRoutes),
  connectedRepos: many(connectedRepos),
  convoyEvents: many(convoyEvents),
}));

export const objectsRelations = relations(objects, ({ one, many }) => ({
  parent: one(objects, {
    fields: [objects.parentId],
    references: [objects.id],
    relationName: "objectHierarchy",
  }),
  children: many(objects, { relationName: "objectHierarchy" }),
  workspace: one(workspaces, {
    fields: [objects.workspaceId],
    references: [workspaces.id],
  }),
  template: one(templates, {
    fields: [objects.templateId],
    references: [templates.id],
  }),
  creator: one(users, {
    fields: [objects.createdBy],
    references: [users.id],
  }),
  propertyValues: many(propertyValues),
  views: many(views),
  assignees: many(objectAssignees),
  outgoingRelations: many(objectRelations, { relationName: "relationSource" }),
  incomingRelations: many(objectRelations, { relationName: "relationTarget" }),
}));

export const objectAssigneesRelations = relations(objectAssignees, ({ one }) => ({
  object: one(objects, {
    fields: [objectAssignees.objectId],
    references: [objects.id],
  }),
  user: one(users, {
    fields: [objectAssignees.userId],
    references: [users.id],
  }),
}));

export const workspaceMembersRelations = relations(workspaceMembers, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [workspaceMembers.workspaceId],
    references: [workspaces.id],
  }),
  user: one(users, {
    fields: [workspaceMembers.userId],
    references: [users.id],
  }),
}));

export const propertyDefinitionsRelations = relations(propertyDefinitions, ({ one, many }) => ({
  workspace: one(workspaces, {
    fields: [propertyDefinitions.workspaceId],
    references: [workspaces.id],
  }),
  values: many(propertyValues),
}));

export const propertyValuesRelations = relations(propertyValues, ({ one }) => ({
  object: one(objects, {
    fields: [propertyValues.objectId],
    references: [objects.id],
  }),
  propertyDefinition: one(propertyDefinitions, {
    fields: [propertyValues.propertyDefId],
    references: [propertyDefinitions.id],
  }),
}));

export const viewsRelations = relations(views, ({ one }) => ({
  object: one(objects, {
    fields: [views.objectId],
    references: [objects.id],
  }),
}));

export const templatesRelations = relations(templates, ({ one, many }) => ({
  workspace: one(workspaces, {
    fields: [templates.workspaceId],
    references: [workspaces.id],
  }),
  objects: many(objects),
}));

export const objectTypeDefsRelations = relations(objectTypeDefs, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [objectTypeDefs.workspaceId],
    references: [workspaces.id],
  }),
}));

export const accountsRelations = relations(accounts, ({ one }) => ({
  user: one(users, {
    fields: [accounts.userId],
    references: [users.id],
  }),
}));

export const sessionsRelations = relations(sessions, ({ one }) => ({
  user: one(users, {
    fields: [sessions.userId],
    references: [users.id],
  }),
}));

export const objectRelationsRelations = relations(objectRelations, ({ one }) => ({
  source: one(objects, {
    fields: [objectRelations.sourceId],
    references: [objects.id],
    relationName: "relationSource",
  }),
  target: one(objects, {
    fields: [objectRelations.targetId],
    references: [objects.id],
    relationName: "relationTarget",
  }),
}));

export const markdownBacklogItemsRelations = relations(
  markdownBacklogItems,
  ({ one, many }) => ({
    workspace: one(workspaces, {
      fields: [markdownBacklogItems.workspaceId],
      references: [workspaces.id],
    }),
    parent: one(markdownBacklogItems, {
      fields: [markdownBacklogItems.parentId],
      references: [markdownBacklogItems.id],
      relationName: "backlogHierarchy",
    }),
    children: many(markdownBacklogItems, { relationName: "backlogHierarchy" }),
    cursorMapping: one(cursorSyncMappings, {
      fields: [markdownBacklogItems.id],
      references: [cursorSyncMappings.backlogItemId],
    }),
  }),
);

export const cursorSyncMappingsRelations = relations(cursorSyncMappings, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [cursorSyncMappings.workspaceId],
    references: [workspaces.id],
  }),
  backlogItem: one(markdownBacklogItems, {
    fields: [cursorSyncMappings.backlogItemId],
    references: [markdownBacklogItems.id],
  }),
}));

export const modelProvidersRelations = relations(modelProviders, ({ one, many }) => ({
  workspace: one(workspaces, {
    fields: [modelProviders.workspaceId],
    references: [workspaces.id],
  }),
  roleRoutes: many(roleModelRoutes),
}));

export const convoyEventsRelations = relations(convoyEvents, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [convoyEvents.workspaceId],
    references: [workspaces.id],
  }),
  convoy: one(objects, {
    fields: [convoyEvents.convoyId],
    references: [objects.id],
    relationName: "convoyEventConvoy",
  }),
  brief: one(objects, {
    fields: [convoyEvents.briefId],
    references: [objects.id],
    relationName: "convoyEventBrief",
  }),
}));

export const connectedReposRelations = relations(connectedRepos, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [connectedRepos.workspaceId],
    references: [workspaces.id],
  }),
}));

export const roleModelRoutesRelations = relations(roleModelRoutes, ({ one }) => ({
  workspace: one(workspaces, {
    fields: [roleModelRoutes.workspaceId],
    references: [workspaces.id],
  }),
  provider: one(modelProviders, {
    fields: [roleModelRoutes.providerAliasId],
    references: [modelProviders.id],
  }),
}));