integratedhub/drizzle/relations.ts

import { relations } from "drizzle-orm/relations";
import {
  financialBalances,
  incomes,
  leaseDocuments,
  leases,
  maintenanceRequests,
  messages,
  obligations,
  paymentMethods,
  paymentTransactions,
  properties,
  propertyMedia,
  reminders,
  rentSchedules,
  roles,
  sessionConfigs,
  tenantApplications,
  tenantInvites,
  userPins,
  userRoles,
  users,
  userTokens,
  webTokens,
} from "./schema.ts";

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

export const usersRelations = relations(users, ({ many }) => ({
  financialBalances: many(financialBalances),
  incomes: many(incomes),
  maintenanceRequests: many(maintenanceRequests),
  obligations: many(obligations),
  paymentMethods: many(paymentMethods),
  sessionConfigs: many(sessionConfigs),
  userRoles: many(userRoles),
  userTokens: many(userTokens),
  userPins: many(userPins),
  leases_tenantId: many(leases, {
    relationName: "leases_tenantId_users_id",
  }),
  leases_ownerId: many(leases, {
    relationName: "leases_ownerId_users_id",
  }),
  messages_senderId: many(messages, {
    relationName: "messages_senderId_users_id",
  }),
  messages_recipientId: many(messages, {
    relationName: "messages_recipientId_users_id",
  }),
  properties: many(properties),
  tenantApplications: many(tenantApplications),
  reminders: many(reminders),
  tenantInvites: many(tenantInvites),
  webTokens: many(webTokens),
}));

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

export const leaseDocumentsRelations = relations(leaseDocuments, ({ one }) => ({
  lease: one(leases, {
    fields: [leaseDocuments.leaseId],
    references: [leases.id],
  }),
}));

export const leasesRelations = relations(leases, ({ one, many }) => ({
  leaseDocuments: many(leaseDocuments),
  paymentTransactions: many(paymentTransactions),
  property: one(properties, {
    fields: [leases.propertyId],
    references: [properties.id],
  }),
  user_tenantId: one(users, {
    fields: [leases.tenantId],
    references: [users.id],
    relationName: "leases_tenantId_users_id",
  }),
  user_ownerId: one(users, {
    fields: [leases.ownerId],
    references: [users.id],
    relationName: "leases_ownerId_users_id",
  }),
  rentSchedule: one(rentSchedules, {
    fields: [leases.paymentScheduleId],
    references: [rentSchedules.id],
  }),
  paymentMethod: one(paymentMethods, {
    fields: [leases.defaultPaymentMethodId],
    references: [paymentMethods.id],
  }),
  messages: many(messages),
  reminders: many(reminders),
  tenantInvites: many(tenantInvites),
}));

export const rentSchedulesRelations = relations(
  rentSchedules,
  ({ one, many }) => ({
    property: one(properties, {
      fields: [rentSchedules.propertyId],
      references: [properties.id],
    }),
    leases: many(leases),
  }),
);

export const propertiesRelations = relations(properties, ({ one, many }) => ({
  rentSchedules: many(rentSchedules),
  maintenanceRequests: many(maintenanceRequests),
  propertyMedias: many(propertyMedia),
  leases: many(leases),
  user: one(users, {
    fields: [properties.ownerId],
    references: [users.id],
  }),
  paymentMethod: one(paymentMethods, {
    fields: [properties.defaultPaymentMethodId],
    references: [paymentMethods.id],
  }),
  tenantApplications: many(tenantApplications),
  tenantInvites: many(tenantInvites),
}));

export const maintenanceRequestsRelations = relations(
  maintenanceRequests,
  ({ one }) => ({
    property: one(properties, {
      fields: [maintenanceRequests.propertyId],
      references: [properties.id],
    }),
    user: one(users, {
      fields: [maintenanceRequests.tenantId],
      references: [users.id],
    }),
  }),
);

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

export const paymentMethodsRelations = relations(
  paymentMethods,
  ({ one, many }) => ({
    user: one(users, {
      fields: [paymentMethods.userId],
      references: [users.id],
    }),
    leases: many(leases),
    properties: many(properties),
  }),
);

export const paymentTransactionsRelations = relations(
  paymentTransactions,
  ({ one }) => ({
    lease: one(leases, {
      fields: [paymentTransactions.leaseId],
      references: [leases.id],
    }),
  }),
);

export const propertyMediaRelations = relations(propertyMedia, ({ one }) => ({
  property: one(properties, {
    fields: [propertyMedia.propertyId],
    references: [properties.id],
  }),
}));

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

export const userRolesRelations = relations(userRoles, ({ one }) => ({
  user: one(users, {
    fields: [userRoles.userId],
    references: [users.id],
  }),
  role: one(roles, {
    fields: [userRoles.roleId],
    references: [roles.id],
  }),
}));

export const rolesRelations = relations(roles, ({ many }) => ({
  userRoles: many(userRoles),
}));

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

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

export const messagesRelations = relations(messages, ({ one }) => ({
  lease: one(leases, {
    fields: [messages.leaseId],
    references: [leases.id],
  }),
  user_senderId: one(users, {
    fields: [messages.senderId],
    references: [users.id],
    relationName: "messages_senderId_users_id",
  }),
  user_recipientId: one(users, {
    fields: [messages.recipientId],
    references: [users.id],
    relationName: "messages_recipientId_users_id",
  }),
}));

export const tenantApplicationsRelations = relations(
  tenantApplications,
  ({ one }) => ({
    property: one(properties, {
      fields: [tenantApplications.propertyId],
      references: [properties.id],
    }),
    user: one(users, {
      fields: [tenantApplications.applicantId],
      references: [users.id],
    }),
  }),
);

export const remindersRelations = relations(reminders, ({ one }) => ({
  user: one(users, {
    fields: [reminders.userId],
    references: [users.id],
  }),
  lease: one(leases, {
    fields: [reminders.leaseId],
    references: [leases.id],
  }),
}));

export const tenantInvitesRelations = relations(tenantInvites, ({ one }) => ({
  user: one(users, {
    fields: [tenantInvites.landlordId],
    references: [users.id],
  }),
  property: one(properties, {
    fields: [tenantInvites.propertyId],
    references: [properties.id],
  }),
  lease: one(leases, {
    fields: [tenantInvites.leaseId],
    references: [leases.id],
  }),
}));

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