markus/next-ory
1
0
Fork 0
mirror of https://codeberg.org/MarkusThielker/next-ory.git synced 2025-04-16 13:49:28 +00:00
Code Releases Packages Activity

NORY-59: fix database relations file

Browse source
This commit is contained in:
Markus Thielker 2025-04-01 14:42:50 +02:00
parent 1602dcaa0b
commit b2ce32a076
1 changed files with 159 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

318
dashboard/drizzle/relations.ts
View file

@ -1,334 +1,334 @@
import { relations } from 'drizzle-orm/relations'; import { relations } from 'drizzle-orm/relations';
import { import {
continuityContainers, continuity_containers,
courierMessageDispatches, courier_message_dispatches,
courierMessages, courier_messages,
identities, identities,
identityCredentialIdentifiers, identity_credential_identifiers,
identityCredentials, identity_credential_types,
identityCredentialTypes, identity_credentials,
identityLoginCodes, identity_login_codes,
identityRecoveryAddresses, identity_recovery_addresses,
identityRecoveryCodes, identity_recovery_codes,
identityRecoveryTokens, identity_recovery_tokens,
identityRegistrationCodes, identity_registration_codes,
identityVerifiableAddresses, identity_verifiable_addresses,
identityVerificationCodes, identity_verification_codes,
identityVerificationTokens, identity_verification_tokens,
networks, networks,
selfserviceErrors, selfservice_errors,
selfserviceLoginFlows, selfservice_login_flows,
selfserviceRecoveryFlows, selfservice_recovery_flows,
selfserviceRegistrationFlows, selfservice_registration_flows,
selfserviceSettingsFlows, selfservice_settings_flows,
selfserviceVerificationFlows, selfservice_verification_flows,
sessionDevices, session_devices,
sessions, sessions,
} from './schema'; } from './schema';
export const identityCredentialsRelations = relations(identityCredentials, ({ one, many }) => ({ export const identityCredentialsRelations = relations(identity_credentials, ({ one, many }) => ({
identity: one(identities, { identity: one(identities, {
fields: [identityCredentials.identityId], fields: [identity_credentials.identity_id],
references: [identities.id], references: [identities.id],
}), }),
identityCredentialType: one(identityCredentialTypes, { identityCredentialType: one(identity_credential_types, {
fields: [identityCredentials.identityCredentialTypeId], fields: [identity_credentials.identity_credential_type_id],
references: [identityCredentialTypes.id], references: [identity_credential_types.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityCredentials.nid], fields: [identity_credentials.nid],
references: [networks.id], references: [networks.id],
}), }),
identityCredentialIdentifiers: many(identityCredentialIdentifiers), identityCredentialIdentifiers: many(identity_credential_identifiers),
})); }));
export const identitiesRelations = relations(identities, ({ one, many }) => ({ export const identitiesRelations = relations(identities, ({ one, many }) => ({
identityCredentials: many(identityCredentials), identityCredentials: many(identity_credentials),
network: one(networks, { network: one(networks, {
fields: [identities.nid], fields: [identities.nid],
references: [networks.id], references: [networks.id],
}), }),
identityVerifiableAddresses: many(identityVerifiableAddresses), identityVerifiableAddresses: many(identity_verifiable_addresses),
selfserviceSettingsFlows: many(selfserviceSettingsFlows), selfserviceSettingsFlows: many(selfservice_settings_flows),
continuityContainers: many(continuityContainers), continuityContainers: many(continuity_containers),
sessions: many(sessions), sessions: many(sessions),
identityRecoveryAddresses: many(identityRecoveryAddresses), identityRecoveryAddresses: many(identity_recovery_addresses),
selfserviceRecoveryFlows: many(selfserviceRecoveryFlows), selfserviceRecoveryFlows: many(selfservice_recovery_flows),
identityRecoveryTokens: many(identityRecoveryTokens), identityRecoveryTokens: many(identity_recovery_tokens),
identityRecoveryCodes: many(identityRecoveryCodes), identityRecoveryCodes: many(identity_recovery_codes),
identityLoginCodes: many(identityLoginCodes), identityLoginCodes: many(identity_login_codes),
})); }));
export const identityCredentialTypesRelations = relations(identityCredentialTypes, ({ many }) => ({ export const identityCredentialTypesRelations = relations(identity_credential_types, ({ many }) => ({
identityCredentials: many(identityCredentials), identityCredentials: many(identity_credentials),
identityCredentialIdentifiers: many(identityCredentialIdentifiers), identityCredentialIdentifiers: many(identity_credential_identifiers),
})); }));
export const networksRelations = relations(networks, ({ many }) => ({ export const networksRelations = relations(networks, ({ many }) => ({
identityCredentials: many(identityCredentials), identityCredentials: many(identity_credentials),
selfserviceLoginFlows: many(selfserviceLoginFlows), selfserviceLoginFlows: many(selfservice_login_flows),
selfserviceRegistrationFlows: many(selfserviceRegistrationFlows), selfserviceRegistrationFlows: many(selfservice_registration_flows),
identities: many(identities), identities: many(identities),
identityCredentialIdentifiers: many(identityCredentialIdentifiers), identityCredentialIdentifiers: many(identity_credential_identifiers),
identityVerifiableAddresses: many(identityVerifiableAddresses), identityVerifiableAddresses: many(identity_verifiable_addresses),
courierMessages: many(courierMessages), courierMessages: many(courier_messages),
selfserviceErrors: many(selfserviceErrors), selfserviceErrors: many(selfservice_errors),
selfserviceVerificationFlows: many(selfserviceVerificationFlows), selfserviceVerificationFlows: many(selfservice_verification_flows),
selfserviceSettingsFlows: many(selfserviceSettingsFlows), selfserviceSettingsFlows: many(selfservice_settings_flows),
continuityContainers: many(continuityContainers), continuityContainers: many(continuity_containers),
sessions: many(sessions), sessions: many(sessions),
identityRecoveryAddresses: many(identityRecoveryAddresses), identityRecoveryAddresses: many(identity_recovery_addresses),
identityVerificationTokens: many(identityVerificationTokens), identityVerificationTokens: many(identity_verification_tokens),
selfserviceRecoveryFlows: many(selfserviceRecoveryFlows), selfserviceRecoveryFlows: many(selfservice_recovery_flows),
identityRecoveryTokens: many(identityRecoveryTokens), identityRecoveryTokens: many(identity_recovery_tokens),
identityRecoveryCodes: many(identityRecoveryCodes), identityRecoveryCodes: many(identity_recovery_codes),
sessionDevices: many(sessionDevices), sessionDevices: many(session_devices),
identityVerificationCodes: many(identityVerificationCodes), identityVerificationCodes: many(identity_verification_codes),
courierMessageDispatches: many(courierMessageDispatches), courierMessageDispatches: many(courier_message_dispatches),
identityLoginCodes: many(identityLoginCodes), identityLoginCodes: many(identity_login_codes),
identityRegistrationCodes: many(identityRegistrationCodes), identityRegistrationCodes: many(identity_registration_codes),
})); }));
export const selfserviceLoginFlowsRelations = relations(selfserviceLoginFlows, ({ one, many }) => ({ export const selfserviceLoginFlowsRelations = relations(selfservice_login_flows, ({ one, many }) => ({
network: one(networks, { network: one(networks, {
fields: [selfserviceLoginFlows.nid], fields: [selfservice_login_flows.nid],
references: [networks.id], references: [networks.id],
}), }),
identityLoginCodes: many(identityLoginCodes), identityLoginCodes: many(identity_login_codes),
})); }));
export const selfserviceRegistrationFlowsRelations = relations(selfserviceRegistrationFlows, ({ one, many }) => ({ export const selfserviceRegistrationFlowsRelations = relations(selfservice_registration_flows, ({ one, many }) => ({
network: one(networks, { network: one(networks, {
fields: [selfserviceRegistrationFlows.nid], fields: [selfservice_registration_flows.nid],
references: [networks.id], references: [networks.id],
}), }),
identityRegistrationCodes: many(identityRegistrationCodes), identityRegistrationCodes: many(identity_registration_codes),
})); }));
export const identityCredentialIdentifiersRelations = relations(identityCredentialIdentifiers, ({ one }) => ({ export const identityCredentialIdentifiersRelations = relations(identity_credential_identifiers, ({ one }) => ({
identityCredential: one(identityCredentials, { identityCredential: one(identity_credentials, {
fields: [identityCredentialIdentifiers.identityCredentialId], fields: [identity_credential_identifiers.identity_credential_id],
references: [identityCredentials.id], references: [identity_credentials.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityCredentialIdentifiers.nid], fields: [identity_credential_identifiers.nid],
references: [networks.id], references: [networks.id],
}), }),
identityCredentialType: one(identityCredentialTypes, { identityCredentialType: one(identity_credential_types, {
fields: [identityCredentialIdentifiers.identityCredentialTypeId], fields: [identity_credential_identifiers.identity_credential_type_id],
references: [identityCredentialTypes.id], references: [identity_credential_types.id],
}), }),
})); }));
export const identityVerifiableAddressesRelations = relations(identityVerifiableAddresses, ({ one, many }) => ({ export const identityVerifiableAddressesRelations = relations(identity_verifiable_addresses, ({ one, many }) => ({
identity: one(identities, { identity: one(identities, {
fields: [identityVerifiableAddresses.identityId], fields: [identity_verifiable_addresses.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityVerifiableAddresses.nid], fields: [identity_verifiable_addresses.nid],
references: [networks.id], references: [networks.id],
}), }),
identityVerificationTokens: many(identityVerificationTokens), identityVerificationTokens: many(identity_verification_tokens),
identityVerificationCodes: many(identityVerificationCodes), identityVerificationCodes: many(identity_verification_codes),
})); }));
export const courierMessagesRelations = relations(courierMessages, ({ one, many }) => ({ export const courierMessagesRelations = relations(courier_messages, ({ one, many }) => ({
network: one(networks, { network: one(networks, {
fields: [courierMessages.nid], fields: [courier_messages.nid],
references: [networks.id], references: [networks.id],
}), }),
courierMessageDispatches: many(courierMessageDispatches), courierMessageDispatches: many(courier_message_dispatches),
})); }));
export const selfserviceErrorsRelations = relations(selfserviceErrors, ({ one }) => ({ export const selfserviceErrorsRelations = relations(selfservice_errors, ({ one }) => ({
network: one(networks, { network: one(networks, {
fields: [selfserviceErrors.nid], fields: [selfservice_errors.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const selfserviceVerificationFlowsRelations = relations(selfserviceVerificationFlows, ({ one, many }) => ({ export const selfserviceVerificationFlowsRelations = relations(selfservice_verification_flows, ({ one, many }) => ({
network: one(networks, { network: one(networks, {
fields: [selfserviceVerificationFlows.nid], fields: [selfservice_verification_flows.nid],
references: [networks.id], references: [networks.id],
}), }),
identityVerificationTokens: many(identityVerificationTokens), identityVerificationTokens: many(identity_verification_tokens),
identityVerificationCodes: many(identityVerificationCodes), identityVerificationCodes: many(identity_verification_codes),
})); }));
export const selfserviceSettingsFlowsRelations = relations(selfserviceSettingsFlows, ({ one }) => ({ export const selfserviceSettingsFlowsRelations = relations(selfservice_settings_flows, ({ one }) => ({
identity: one(identities, { identity: one(identities, {
fields: [selfserviceSettingsFlows.identityId], fields: [selfservice_settings_flows.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [selfserviceSettingsFlows.nid], fields: [selfservice_settings_flows.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const continuityContainersRelations = relations(continuityContainers, ({ one }) => ({ export const continuityContainersRelations = relations(continuity_containers, ({ one }) => ({
identity: one(identities, { identity: one(identities, {
fields: [continuityContainers.identityId], fields: [continuity_containers.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [continuityContainers.nid], fields: [continuity_containers.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const sessionsRelations = relations(sessions, ({ one, many }) => ({ export const sessionsRelations = relations(sessions, ({ one, many }) => ({
identity: one(identities, { identity: one(identities, {
fields: [sessions.identityId], fields: [sessions.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [sessions.nid], fields: [sessions.nid],
references: [networks.id], references: [networks.id],
}), }),
sessionDevices: many(sessionDevices), sessionDevices: many(session_devices),
})); }));
export const identityRecoveryAddressesRelations = relations(identityRecoveryAddresses, ({ one, many }) => ({ export const identityRecoveryAddressesRelations = relations(identity_recovery_addresses, ({ one, many }) => ({
identity: one(identities, { identity: one(identities, {
fields: [identityRecoveryAddresses.identityId], fields: [identity_recovery_addresses.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityRecoveryAddresses.nid], fields: [identity_recovery_addresses.nid],
references: [networks.id], references: [networks.id],
}), }),
identityRecoveryTokens: many(identityRecoveryTokens), identityRecoveryTokens: many(identity_recovery_tokens),
identityRecoveryCodes: many(identityRecoveryCodes), identityRecoveryCodes: many(identity_recovery_codes),
})); }));
export const identityVerificationTokensRelations = relations(identityVerificationTokens, ({ one }) => ({ export const identityVerificationTokensRelations = relations(identity_verification_tokens, ({ one }) => ({
identityVerifiableAddress: one(identityVerifiableAddresses, { identityVerifiableAddress: one(identity_verifiable_addresses, {
fields: [identityVerificationTokens.identityVerifiableAddressId], fields: [identity_verification_tokens.identity_verifiable_address_id],
references: [identityVerifiableAddresses.id], references: [identity_verifiable_addresses.id],
}), }),
selfserviceVerificationFlow: one(selfserviceVerificationFlows, { selfserviceVerificationFlow: one(selfservice_verification_flows, {
fields: [identityVerificationTokens.selfserviceVerificationFlowId], fields: [identity_verification_tokens.selfservice_verification_flow_id],
references: [selfserviceVerificationFlows.id], references: [selfservice_verification_flows.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityVerificationTokens.nid], fields: [identity_verification_tokens.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const selfserviceRecoveryFlowsRelations = relations(selfserviceRecoveryFlows, ({ one, many }) => ({ export const selfserviceRecoveryFlowsRelations = relations(selfservice_recovery_flows, ({ one, many }) => ({
identity: one(identities, { identity: one(identities, {
fields: [selfserviceRecoveryFlows.recoveredIdentityId], fields: [selfservice_recovery_flows.recovered_identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [selfserviceRecoveryFlows.nid], fields: [selfservice_recovery_flows.nid],
references: [networks.id], references: [networks.id],
}), }),
identityRecoveryTokens: many(identityRecoveryTokens), identityRecoveryTokens: many(identity_recovery_tokens),
identityRecoveryCodes: many(identityRecoveryCodes), identityRecoveryCodes: many(identity_recovery_codes),
})); }));
export const identityRecoveryTokensRelations = relations(identityRecoveryTokens, ({ one }) => ({ export const identityRecoveryTokensRelations = relations(identity_recovery_tokens, ({ one }) => ({
selfserviceRecoveryFlow: one(selfserviceRecoveryFlows, { selfserviceRecoveryFlow: one(selfservice_recovery_flows, {
fields: [identityRecoveryTokens.selfserviceRecoveryFlowId], fields: [identity_recovery_tokens.selfservice_recovery_flow_id],
references: [selfserviceRecoveryFlows.id], references: [selfservice_recovery_flows.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityRecoveryTokens.nid], fields: [identity_recovery_tokens.nid],
references: [networks.id], references: [networks.id],
}), }),
identityRecoveryAddress: one(identityRecoveryAddresses, { identityRecoveryAddress: one(identity_recovery_addresses, {
fields: [identityRecoveryTokens.identityRecoveryAddressId], fields: [identity_recovery_tokens.identity_recovery_address_id],
references: [identityRecoveryAddresses.id], references: [identity_recovery_addresses.id],
}), }),
identity: one(identities, { identity: one(identities, {
fields: [identityRecoveryTokens.identityId], fields: [identity_recovery_tokens.identity_id],
references: [identities.id], references: [identities.id],
}), }),
})); }));
export const identityRecoveryCodesRelations = relations(identityRecoveryCodes, ({ one }) => ({ export const identityRecoveryCodesRelations = relations(identity_recovery_codes, ({ one }) => ({
identityRecoveryAddress: one(identityRecoveryAddresses, { identityRecoveryAddress: one(identity_recovery_addresses, {
fields: [identityRecoveryCodes.identityRecoveryAddressId], fields: [identity_recovery_codes.identity_recovery_address_id],
references: [identityRecoveryAddresses.id], references: [identity_recovery_addresses.id],
}), }),
selfserviceRecoveryFlow: one(selfserviceRecoveryFlows, { selfserviceRecoveryFlow: one(selfservice_recovery_flows, {
fields: [identityRecoveryCodes.selfserviceRecoveryFlowId], fields: [identity_recovery_codes.selfservice_recovery_flow_id],
references: [selfserviceRecoveryFlows.id], references: [selfservice_recovery_flows.id],
}), }),
identity: one(identities, { identity: one(identities, {
fields: [identityRecoveryCodes.identityId], fields: [identity_recovery_codes.identity_id],
references: [identities.id], references: [identities.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityRecoveryCodes.nid], fields: [identity_recovery_codes.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const sessionDevicesRelations = relations(sessionDevices, ({ one }) => ({ export const sessionDevicesRelations = relations(session_devices, ({ one }) => ({
session: one(sessions, { session: one(sessions, {
fields: [sessionDevices.sessionId], fields: [session_devices.session_id],
references: [sessions.id], references: [sessions.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [sessionDevices.nid], fields: [session_devices.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const identityVerificationCodesRelations = relations(identityVerificationCodes, ({ one }) => ({ export const identityVerificationCodesRelations = relations(identity_verification_codes, ({ one }) => ({
identityVerifiableAddress: one(identityVerifiableAddresses, { identityVerifiableAddress: one(identity_verifiable_addresses, {
fields: [identityVerificationCodes.identityVerifiableAddressId], fields: [identity_verification_codes.identity_verifiable_address_id],
references: [identityVerifiableAddresses.id], references: [identity_verifiable_addresses.id],
}), }),
selfserviceVerificationFlow: one(selfserviceVerificationFlows, { selfserviceVerificationFlow: one(selfservice_verification_flows, {
fields: [identityVerificationCodes.selfserviceVerificationFlowId], fields: [identity_verification_codes.selfservice_verification_flow_id],
references: [selfserviceVerificationFlows.id], references: [selfservice_verification_flows.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityVerificationCodes.nid], fields: [identity_verification_codes.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const courierMessageDispatchesRelations = relations(courierMessageDispatches, ({ one }) => ({ export const courierMessageDispatchesRelations = relations(courier_message_dispatches, ({ one }) => ({
courierMessage: one(courierMessages, { courierMessage: one(courier_messages, {
fields: [courierMessageDispatches.messageId], fields: [courier_message_dispatches.message_id],
references: [courierMessages.id], references: [courier_messages.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [courierMessageDispatches.nid], fields: [courier_message_dispatches.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));
export const identityLoginCodesRelations = relations(identityLoginCodes, ({ one }) => ({ export const identityLoginCodesRelations = relations(identity_login_codes, ({ one }) => ({
selfserviceLoginFlow: one(selfserviceLoginFlows, { selfserviceLoginFlow: one(selfservice_login_flows, {
fields: [identityLoginCodes.selfserviceLoginFlowId], fields: [identity_login_codes.selfservice_login_flow_id],
references: [selfserviceLoginFlows.id], references: [selfservice_login_flows.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityLoginCodes.nid], fields: [identity_login_codes.nid],
references: [networks.id], references: [networks.id],
}), }),
identity: one(identities, { identity: one(identities, {
fields: [identityLoginCodes.identityId], fields: [identity_login_codes.identity_id],
references: [identities.id], references: [identities.id],
}), }),
})); }));
export const identityRegistrationCodesRelations = relations(identityRegistrationCodes, ({ one }) => ({ export const identityRegistrationCodesRelations = relations(identity_registration_codes, ({ one }) => ({
selfserviceRegistrationFlow: one(selfserviceRegistrationFlows, { selfserviceRegistrationFlow: one(selfservice_registration_flows, {
fields: [identityRegistrationCodes.selfserviceRegistrationFlowId], fields: [identity_registration_codes.selfservice_registration_flow_id],
references: [selfserviceRegistrationFlows.id], references: [selfservice_registration_flows.id],
}), }),
network: one(networks, { network: one(networks, {
fields: [identityRegistrationCodes.nid], fields: [identity_registration_codes.nid],
references: [networks.id], references: [networks.id],
}), }),
})); }));