Class: BetterAuth::Adapters::InternalAdapter

Inherits:
Object
  • Object
show all
Defined in:
lib/better_auth/adapters/internal_adapter.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(adapter, options) ⇒ InternalAdapter

Returns a new instance of InternalAdapter.



12
13
14
15
16
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 12

def initialize(adapter, options)
  @adapter = adapter
  @options = options
  @hooks = DatabaseHooks.new(adapter, options)
end

Instance Attribute Details

#adapter ⇒ Object (readonly)

Returns the value of attribute adapter.



10
11
12
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 10

def adapter
  @adapter
end

#hooks ⇒ Object (readonly)

Returns the value of attribute hooks.



10
11
12
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 10

def hooks
  @hooks
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



10
11
12
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 10

def options
  @options
end

Instance Method Details

#count_total_users(where: nil) ⇒ Object 



57
58
59
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 57

def count_total_users(where: nil)
  adapter.count(model: "user", where: where || [])
end

#create_account(account) ⇒ Object 



32
33
34
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 32

def ()
  hooks.create(timestamps.merge(stringify_keys()), "account")
end

#create_oauth_user(user, account) ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 18

def create_oauth_user(user, )
  adapter.transaction do
    created_user = create_user(user)
     = (stringify_keys().merge("userId" => created_user["id"]))
    {user: created_user, account: }
  end
end

#create_session(user_id, dont_remember_me = false, override = nil, override_all = false, context = nil) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 67

def create_session(user_id, dont_remember_me = false, override = nil, override_all = false, context = nil)
  override = stringify_keys(override || {})
  token = override.delete("token") || SecureRandom.hex(16)
  base = {
    "ipAddress" => "",
    "userAgent" => "",
    "expiresAt" => Time.now + (dont_remember_me ? 86_400 : options.session[:expires_in].to_i),
    "userId" => user_id,
    "token" => token
  }.merge(timestamps)
  data = override_all ? base.merge(override) : override.merge(base)

  custom = secondary_storage && lambda do |session_data|
    actual_session = apply_schema_create("session", session_data)
    store_session(actual_session)
    actual_session
  end
  execute_main = !secondary_storage || options.session[:store_session_in_database]
  created = hooks.create(data, "session", custom: custom, context: context)
  adapter.create(model: "session", data: data, force_allow_id: true) if secondary_storage && execute_main
  created
end

#create_user(user) ⇒ Object 



26
27
28
29
30
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 26

def create_user(user)
  data = timestamps.merge(stringify_keys(user))
  data["email"] = data["email"].to_s.downcase if data["email"]
  hooks.create(data, "user")
end

#create_verification_value(data) ⇒ Object 



228
229
230
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 228

def create_verification_value(data)
  hooks.create(timestamps.merge(stringify_keys(data)), "verification")
end

#delete_account(account_id) ⇒ Object 



158
159
160
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 158

def ()
  hooks.delete([{field: "id", value: }], "account")
end

#delete_accounts(user_id) ⇒ Object 



154
155
156
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 154

def delete_accounts(user_id)
  hooks.delete_many([{field: "userId", value: user_id}], "account")
end

#delete_session(token) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 123

def delete_session(token)
  if secondary_storage
    data = parse_storage(secondary_storage.get(token))
    if data && data["session"]
      user_id = data["session"]["userId"]
      entries = active_session_entries(user_id).reject { |entry| entry["token"] == token }
      write_active_sessions(user_id, entries)
    end
    secondary_storage.delete(token)
    return if !options.session[:store_session_in_database] || options.session[:preserve_session_in_database]
  end

  hooks.delete([{field: "token", value: token}], "session")
end

#delete_sessions(user_id_or_tokens) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 138

def delete_sessions(user_id_or_tokens)
  if secondary_storage
    if user_id_or_tokens.is_a?(Array)
      user_id_or_tokens.each { |token| secondary_storage.delete(token) }
    else
      active_session_entries(user_id_or_tokens).each { |entry| secondary_storage.delete(entry["token"]) }
      secondary_storage.delete(active_key(user_id_or_tokens))
    end
    return if !options.session[:store_session_in_database] || options.session[:preserve_session_in_database]
  end

  field = user_id_or_tokens.is_a?(Array) ? "token" : "userId"
  operator = user_id_or_tokens.is_a?(Array) ? "in" : nil
  hooks.delete_many([{field: field, value: user_id_or_tokens, operator: operator}], "session")
end

#delete_user(user_id) ⇒ Object 



61
62
63
64
65
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 61

def delete_user(user_id)
  delete_sessions(user_id) if !secondary_storage || options.session[:store_session_in_database]
  hooks.delete_many([{field: "userId", value: user_id}], "account")
  hooks.delete([{field: "id", value: user_id}], "user")
end

#delete_verification_by_identifier(identifier) ⇒ Object 



247
248
249
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 247

def delete_verification_by_identifier(identifier)
  hooks.delete([{field: "identifier", value: identifier}], "verification")
end

#delete_verification_value(id) ⇒ Object 



243
244
245
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 243

def delete_verification_value(id)
  hooks.delete([{field: "id", value: id}], "verification")
end

#find_account(account_id) ⇒ Object 



212
213
214
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 212

def ()
  adapter.find_one(model: "account", where: [{field: "accountId", value: }])
end

#find_account_by_provider_id(account_id, provider_id) ⇒ Object 



216
217
218
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 216

def (, provider_id)
  adapter.find_one(model: "account", where: [{field: "accountId", value: }, {field: "providerId", value: provider_id}])
end

#find_account_by_user_id(user_id) ⇒ Object 



220
221
222
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 220

def (user_id)
  find_accounts(user_id)
end

#find_accounts(user_id) ⇒ Object 



208
209
210
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 208

def find_accounts(user_id)
  adapter.find_many(model: "account", where: [{field: "userId", value: user_id}])
end

#find_oauth_user(email, account_id, provider_id) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 162

def find_oauth_user(email, , provider_id)
   = (, provider_id)
  if 
    user = ["user"] || adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
    return nil unless user

    linked = .dup
    linked.delete("user")
    return {user: user, linked_account: linked, accounts: [linked]}
  end

  found_user = adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
  return nil unless found_user

  {user: found_user, linked_account: nil, accounts: find_accounts(found_user["id"])}
end

#find_session(token) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 90

def find_session(token)
  if secondary_storage
    data = parse_storage(secondary_storage.get(token))
    return nil unless data

    return {
      session: normalize_session_dates(data["session"]),
      user: normalize_user_dates(data["user"])
    }
  end

  found = find_session_with_user(token)
  return nil unless found && found["user"]

  user = found.delete("user")
  {session: found, user: user}
end

#find_sessions(tokens) ⇒ Object 



108
109
110
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 108

def find_sessions(tokens)
  tokens.filter_map { |token| find_session(token) }
end

#find_user_by_email(email, include_accounts: false) ⇒ Object 



179
180
181
182
183
184
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 179

def find_user_by_email(email, include_accounts: false)
  user = adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
  return nil unless user

  {user: user, accounts: include_accounts ? find_accounts(user["id"]) : []}
end

#find_user_by_id(user_id) ⇒ Object 



186
187
188
189
190
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 186

def find_user_by_id(user_id)
  return nil if user_id.to_s.empty?

  adapter.find_one(model: "user", where: [{field: "id", value: user_id}])
end

#find_verification_value(identifier) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 232

def find_verification_value(identifier)
  values = adapter.find_many(
    model: "verification",
    where: [{field: "identifier", value: identifier}],
    sort_by: {field: "createdAt", direction: "desc"},
    limit: 1
  )
  hooks.delete_many([{field: "expiresAt", value: Time.now, operator: "lt"}], "verification") unless options.verification[:disable_cleanup]
  values.first
end

#link_account(account) ⇒ Object 



36
37
38
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 36

def ()
  ()
end

#list_sessions(user_id) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 40

def list_sessions(user_id)
  if secondary_storage
    active_session_entries(user_id).filter_map do |entry|
      data = parse_storage(secondary_storage.get(entry.fetch("token")))
      next unless data && data["session"]

      normalize_session_dates(data["session"])
    end
  else
    adapter.find_many(model: "session", where: [{field: "userId", value: user_id}])
  end
end

#list_users(limit: nil, offset: nil, sort_by: nil, where: nil) ⇒ Object 



53
54
55
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 53

def list_users(limit: nil, offset: nil, sort_by: nil, where: nil)
  adapter.find_many(model: "user", where: where || [], limit: limit, offset: offset, sort_by: sort_by)
end

#update_account(id, data) ⇒ Object 



224
225
226
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 224

def (id, data)
  hooks.update(stringify_keys(data), [{field: "id", value: id}], "account")
end

#update_password(user_id, password) ⇒ Object 



204
205
206
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 204

def update_password(user_id, password)
  hooks.update_many({password: password}, [{field: "userId", value: user_id}, {field: "providerId", value: "credential"}], "account")
end

#update_session(token, session) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 112

def update_session(token, session)
  data = stringify_keys(session)
  if secondary_storage
    return hooks.update(data, [{field: "token", value: token}], "session", custom: lambda { |actual_data|
      update_stored_session(token, actual_data)
    })
  end

  hooks.update(data, [{field: "token", value: token}], "session")
end

#update_user(user_id, data) ⇒ Object 



192
193
194
195
196
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 192

def update_user(user_id, data)
  user = hooks.update(stringify_keys(data), [{field: "id", value: user_id}], "user")
  refresh_user_sessions(user) if user
  user
end

#update_user_by_email(email, data) ⇒ Object 



198
199
200
201
202
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 198

def update_user_by_email(email, data)
  user = hooks.update(stringify_keys(data), [{field: "email", value: email.to_s.downcase}], "user")
  refresh_user_sessions(user) if user
  user
end

#update_verification_value(id, data) ⇒ Object 



251
252
253
 
# File 'lib/better_auth/adapters/internal_adapter.rb', line 251

def update_verification_value(id, data)
  hooks.update(stringify_keys(data), [{field: "id", value: id}], "verification")
end