users.ts

/*
 * Copyright © 2026 Fells Code, LLC
 * Licensed under the GNU Affero General Public License v3.0
 * See LICENSE file in the project root for full license information
 */

import { Association, DataTypes, Model, Sequelize } from 'sequelize';

import type { Credential } from './credentials.js';
import type { OAuthIdentity } from './oauthIdentities.js';
import type { OrganizationMembership } from './organizationMemberships.js';
import type { TotpCredential } from './totpCredentials.js';

export interface UserAttributes {
  id?: string;
  email: string;
  phone: string | null;
  roles?: string[];
  revoked?: boolean;
  emailVerificationToken?: string | null;
  emailVerificationTokenExpiry?: number | null;
  phoneVerificationToken?: string | null;
  phoneVerificationTokenExpiry?: number | null;
  emailVerified?: boolean;
  phoneVerified?: boolean;
  verified?: boolean;
  challenge?: string | null;
  challengeContext?: Record<string, unknown> | null;
  lastLogin?: Date;
  createdAt?: Date;
  updatedAt?: Date;
  credentials?: Credential[];
  oauthIdentities?: OAuthIdentity[];
  organizationMemberships?: OrganizationMembership[];
  totpCredentials?: TotpCredential[];
}

export class User extends Model<UserAttributes> implements UserAttributes {
  declare id: string;
  declare email: string;
  declare phone: string | null;
  declare revoked: boolean;
  declare emailVerificationToken: string | null;
  declare emailVerificationTokenExpiry: number | null;
  declare phoneVerificationToken: string | null;
  declare phoneVerificationTokenExpiry: number | null;
  declare emailVerified: boolean;
  declare phoneVerified: boolean;
  declare verified: boolean;
  declare challenge: string | null;
  declare challengeContext: Record<string, unknown> | null;
  declare roles?: string[];
  declare lastLogin?: Date;
  declare readonly createdAt: Date;
  declare readonly updatedAt: Date;
  declare readonly credentials?: Credential[];
  declare readonly oauthIdentities?: OAuthIdentity[];
  declare readonly organizationMemberships?: OrganizationMembership[];
  declare readonly totpCredentials?: TotpCredential[];

  public static associations: {
    credentials: Association<User, Credential>;
    oauthIdentities: Association<User, OAuthIdentity>;
    organizationMemberships: Association<User, OrganizationMembership>;
    totpCredentials: Association<User, TotpCredential>;
  };

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  static associate(models: any) {
    User.hasMany(models.Credential, {
      foreignKey: 'userId',
      onDelete: 'CASCADE',
      as: 'credentials',
    });
    User.hasMany(models.OAuthIdentity, {
      foreignKey: 'userId',
      onDelete: 'CASCADE',
      as: 'oauthIdentities',
    });
    User.hasMany(models.TotpCredential, {
      foreignKey: 'userId',
      onDelete: 'CASCADE',
      as: 'totpCredentials',
    });
    User.hasMany(models.OrganizationMembership, {
      foreignKey: 'userId',
      onDelete: 'CASCADE',
      as: 'organizationMemberships',
    });
  }
}

const initializeUserModel = (sequelize: Sequelize) => {
  User.init(
    {
      id: {
        type: DataTypes.UUID,
        primaryKey: true,
        defaultValue: DataTypes.UUIDV4,
        allowNull: false,
      },
      email: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true,
      },
      phone: {
        type: DataTypes.STRING,
        allowNull: true,
        unique: true,
      },
      roles: {
        type: DataTypes.ARRAY(DataTypes.STRING),
        allowNull: false,
        defaultValue: [],
      },
      emailVerificationToken: {
        type: DataTypes.STRING,
        allowNull: true,
      },
      emailVerificationTokenExpiry: {
        type: DataTypes.BIGINT,
        allowNull: true,
      },
      phoneVerificationToken: {
        type: DataTypes.STRING,
        allowNull: true,
      },
      phoneVerificationTokenExpiry: {
        type: DataTypes.BIGINT,
        allowNull: true,
      },
      revoked: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      verified: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      emailVerified: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      phoneVerified: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      challenge: {
        type: DataTypes.STRING,
        allowNull: true,
      },
      challengeContext: {
        type: DataTypes.JSON,
        allowNull: true,
      },
      lastLogin: {
        type: DataTypes.DATE,
        allowNull: true,
      },
    },
    {
      sequelize,
      modelName: 'User',
      tableName: 'users',
      underscored: true,
    },
  );

  return User;
};

export default initializeUserModel;