dynamic-records-meritfront 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db86b391a9dbb87a5499b32931520d39d5dbb1b12eb4680a4721cdb2c897d57b
+  data.tar.gz: a2eed17ce50be8ddc027a64b389a6ba8f69d06b4adda75aab672919c559f6d44
+SHA512:
+  metadata.gz: a0fcec82242810e9e9eec7ae6e46602a6dabfefaf4ded57660b9a0b83d44b4c35d52d8e8a5b50acb64028bb473ee626f3690632cdbe0c146761cffbafa38504e
+  data.tar.gz: 98854c02fd8db676c39d358e33876a389e5da87c68ece01df3d005d9f4189d244271460ccfbac5316c9658a22019b04cfda2974f6beb25f5b209590a40fb30b0

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at lukeclancy@hotmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in dynamic-records-meritfront.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    dynamic-records-meritfront (0.1.4)
+      hashid-rails
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.4)
+      activesupport (= 7.0.4)
+    activerecord (7.0.4)
+      activemodel (= 7.0.4)
+      activesupport (= 7.0.4)
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    concurrent-ruby (1.1.10)
+    hashid-rails (1.4.1)
+      activerecord (>= 4.0)
+      hashids (~> 1.0)
+    hashids (1.0.6)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.16.3)
+    rake (12.3.3)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dynamic-records-meritfront!
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,155 @@
+# Dynamic Records Meritfront
+
+Dyanmic Records Meritfront contains some helpers methods for active record. These methods have the goal of allowing one to
+1. communicate with the frontend quicker and more effectively through Global HashIds
+2. communicate with the backend more effectively with raw sql queries. This becomes especially relevant when you hit the limits of Active Record Relations and the usual way of querying in rails. For instance, if you have a page-long dynamic sql query.
+
+I dont tend to get much feedback, so any given would be appreciated.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_meritfront'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install active_record_meritfront
+
+## Usage
+
+### Hashed Global IDS
+
+hashed global ids look like this: "gid://meritfront/User/K9YI4K". They also have an optional tag so it can also look like "gid://meritfront/User/K9YI4K@user_image". They are based on global ids.
+
+I have been using hgids (Hashed Global IDs) for a while now and they have some unique benefits in front-end back-end communication. This is as they:
+1. hash the id which is good practice
+2. provide a way to have tags, this is good when updating different UI elements dynamically from the backend. For instance updating the @user_image without affecting the @user_name
+3. Carry the class with them, this can allow for more abstract and efficient code, and prevents id collisions between diffrent classes.
+
+#### methods from the hashid-rails gem
+
+See the hashid-rails gem for more (https://github.com/jcypret/hashid-rails). Also note that I aliased .hashid to .hid and .find_by_hashid to .hfind
+
+#### methods from this gem
+
+1. hgid(tag: nil) - get the hgid with optional tag. Aliased to ghid
+2. hgid_as_selector(str, attribute: 'id') - get a css selector for the hgid, good for updating the front-end
+3. self.locate_hgid(hgid_string, with_associations: nil, returns_nil: false) - locates the database record from a hgid. Here are some examples of usage:
+    - ApplicationRecord.locate_hgid(hgid) - <b>DANGEROUS</b> will return any object referenced by the hgid.
+    - User.locate_hgid(hgid) - locates the User record but only if the hgid references a user class. Fires an error if not.
+    - ApplicationRecord.locate_hgid(hgid, with_associations: [:votes]) - locates the record but only if the  record's class has a :votes active record association. So for instance, you can accept only votable objects for upvote functionality. Fires an error if the hgid does not match.
+    - User.locate_hgid(hgid, returns_nil: true) - locates the hgid but only if it is the user class. Returns nil if not.
+4. get_hgid_tag(hgid) - returns the tag attached to the hgid
+5. self.blind_hgid(id, tag) - creates 
+
+### SQL methods
+
+These are methods written for easier sql usage.
+
+#### has_run_migration?(nm)
+
+put in a string name of the migration's class and it will say if it has allready run the migration.
+good during enum migrations as the code to migrate wont run if enumerate is there 
+as it is not yet enumerated (causing an error when it loads the class that will have the
+enumeration in it). This can lead it to being impossible to commit clean code.
+
+<details><summary>example usage</summary>
+only load relationa if it exists in the database
+
+```ruby
+if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
+    class UserImageRelation < ApplicationRecord
+        belongs_to :imageable, polymorphic: true
+        belongs_to :image
+    end
+else
+    class UserImageRelation; end
+end
+
+```
+</details>
+
+#### has_association?(*args)
+
+accepts a list, checks if the model contains those associations
+
+<details><summary>example usage</summary>
+Check if object is a votable class
+
+```ruby
+obj = Comment.first
+obj.has_association?(:votes) #true
+obj = User.first
+obj.has_association?(:votes) #false
+```
+</details>
+
+#### self.headache_sql(name, sql, opts = { })
+with options: 
+- instantiate_class: returns User, Post, etc objects instead of straight sql output.
+    I prefer doing the alterantive
+        ```User.headache_sql(...)```
+        which is also supported
+- prepare: sets whether the db will preprocess the strategy for lookup (defaults true) (have not verified the prepared-ness)
+- name_modifiers: allows one to change the preprocess associated name, useful in cases of dynamic sql.
+- multi_query: allows more than one query (you can seperate an insert and an update with ';' I dont know how else to say it.)
+    this disables other options (except name_modifiers). Not sure how it effects prepared statements.
+- async: does what it says but I haven't used it yet so. Probabably doesn't work
+- other options: considered sql arguments
+
+<details>
+<summary>example usage</summary>
+Delete Friend Requests between two users after they have become friends.
+
+```ruby
+    ApplicationRecord.headache_sql("remove_friend_requests_before_creating_friend", %Q{
+        DELETE FROM friend_requests
+        WHERE (requestie_id = :uid and requester_id = :other_user_id) OR
+            (requester_id = :uid and requestie_id = :other_user_id)
+    }, uid: Current.user.id, other_user_id: other_user.id)
+```
+</details>
+
+<details>
+<summary>advanced example usage</summary>
+Get all users who have made a friend request to a particular user with an optional limit.
+This is an example of why this method is good for dynamic prepared statements.
+
+```ruby
+    return User.headache_sql('get_friend_requests', %Q{
+        SELECT * FROM (
+            SELECT other_user.id, ..., friend_requests.created_at
+            FROM users
+                INNER JOIN friend_requests ON users.id = friend_requests.requestie_id
+                INNER JOIN users other_user ON friend_requests.requester_id = other_user.id
+            WHERE users.id = :uid
+        ) AS all_friend_requests
+        ORDER BY all_friend_requests.created_at DESC
+        #{"LIMIT :limit" if limit > 0}
+    }, uid: u, limit: limit, name_modifiers: [
+        limit > 0 ? 'limited' : nil
+    ])
+```
+</details>
+
+#### self.headache_preload(records, associations)
+Preloads from a list of records, and not from a ActiveRecord_Relation. This will be useful when using the above headache_sql method.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_record_meritfront. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/active_record_meritfront/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveRecordMeritfront project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/active_record_meritfront/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dynamic/records/meritfront"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/update

@@ -0,0 +1,55 @@
+#!/bin/env ruby
+#this is for local development and should not be for actual updates,
+#   I just got annoyed with the number of things you had to do to get the updated
+#   version on your machine. Even after this you have to update the and restart your website...
+#   you can one-line that with './bin/bundle update && ../bin rails s' though. Just
+#   make sure you use ~> in the gemfile and your first 2 version numbers are correct.
+
+#x = File.read('./#{project}.gemspec')
+#x = x.split("\n")
+#puts x.class
+#puts x.length
+#puts x
+
+project = 'dynamic-records-meritfront'			#<---change on a per project basis
+
+puts "_______________________________________________"
+
+require_relative "../lib/#{project}/version"
+
+clz = DynamicRecordsMeritfront				#<---change on a per project basis
+
+old_version = clz::VERSION
+version = old_version.split('.')
+version[-1] = ((version[-1].to_i) + 1).to_s
+version_new = version.join('.')
+
+puts File.dirname(__FILE__)
+puts "old version: #{old_version}"
+
+write_to = "#{File.dirname(__FILE__)}/../lib/#{project}/version.rb"
+
+puts "updating #{write_to} to new version #{version_new}"
+
+
+File.write(write_to, "
+	module #{clz}
+	    VERSION = '#{version_new}'
+	end
+	#this file gets overwritten automatically on minor updates, major ones need to be manually changed
+")
+
+puts "_______________________________________________"
+puts "BUNDLE UPDATE"
+puts `bundle update`
+puts "_______________________________________________"
+puts "GIT ADD"
+puts `git add *`
+puts "_______________________________________________"
+puts "GIT COMMIT"
+puts `git commit -m 'minor changes to version #{version_new}'`
+puts "_______________________________________________"
+puts "INSTALL GEM LOCALLY"
+puts `bundle exec rake install`
+puts "_______________________________________________"
+puts "info: write 'bundle exec rake release' to release the current version to the interwebz"

data/dynamic-records-meritfront.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/dynamic-records-meritfront/version.rb'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dynamic-records-meritfront"
+  spec.version       = DynamicRecordsMeritfront::VERSION
+  spec.authors       = ["Luke Clancy"]
+  spec.email         = ["lukeclancy@hotmail.com"]
+
+  spec.summary       = %q{Helpers for active record that allow for more abstract and fine-grained code.}
+  spec.description   = %q{Adds better functionality for writing raw sql. Adds hashed global id reference string for database records. This can help with the flexibility and speed of handling records.}
+  spec.homepage      = "https://github.com/LukeClancy/dynamic-records-meritfront"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/LukeClancy/dynamic-records-meritfront"
+  spec.metadata["changelog_uri"] = "https://github.com/LukeClancy/dynamic-records-meritfront/blob/main/README.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "hashid-rails"
+end

data/lib/dynamic-records-meritfront/version.rb

@@ -0,0 +1,5 @@
+
+	module DynamicRecordsMeritfront
+	    VERSION = '0.1.4'
+	end
+	#this file gets overwritten automatically on minor updates, major ones need to be manually changed

data/lib/dynamic-records-meritfront.rb

@@ -0,0 +1,328 @@
+require "dynamic-records-meritfront/version"
+
+module DynamicRecordsMeritfront
+    extend ActiveSupport::Concern
+	
+	# include hash id gem
+	include Hashid::Rails
+
+	# the two aliases so I dont go insane
+	module Hashid::Rails
+		alias hid hashid
+	end
+	module Hashid::Rails::ClassMethods
+		alias hfind find_by_hashid
+	end
+
+	def self.has_run_migration?(nm)
+	#put in a string name of the class and it will say if it has allready run the migration.
+	#good during enum migrations as the code to migrate wont run if enumerate is there 
+	#as it is not yet enumerated (causing an error when it loads the class that will have the
+	#enumeration in it). This can lead it to being impossible to commit clean code.
+	#
+	# example usage one: only create the record class if it currently exists in the database
+		# if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
+		# 	class UserImageRelation < ApplicationRecord
+		# 		belongs_to :imageable, polymorphic: true
+		# 		belongs_to :image
+		# 	end
+		# else
+		# 	class UserImageRelation; end
+		# end
+	# example usage two: only load relation if it exists in the database
+		# class UserImageRelation < ApplicationRecord
+		#	if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
+		#	 	belongs_to :imageable, polymorphic: true
+		#	end
+		# end
+	#	
+		#current version of migrations
+		cv = ActiveRecord::Base.connection.migration_context.current_version
+		
+		#find the migration object for the name
+		migration = ActiveRecord::Base.connection.migration_context.migrations.filter!{|a|
+				a.name == nm
+			}.first
+		
+		#if the migration object is nil, it has not yet been created
+		if migration.nil?
+			Rails.logger.info "No migration found for #{nm}. The migration has not yet been created, or is foreign to this database."
+			return false
+		end
+
+		#get the version number for the migration name
+		needed_version = migration.version
+
+		#if current version is above or equal, the migration has allready been run
+		migration_ran = (cv >= needed_version)
+
+		if migration_ran
+			Rails.logger.info "#{nm} migration was run on #{needed_version}. If old and all instances are migrated, consider removing code check."
+		else
+			Rails.logger.info "#{nm} migration has not run yet. This may lead to limited functionality"
+		end
+
+		return migration_ran
+	end
+
+	def self.list_associations
+		#lists associations (see has_association? below)
+		reflect_on_all_associations.map(&:name)
+	end
+
+	def list_associations
+		#lists associations (see class method above)
+		self.class.list_associations
+	end
+
+	def self.has_association?(*args)
+		#checks whether current class has needed association (for example, checks it has comments)
+		#associations can be seen in has_many belongs_to and other similar methods
+
+		#flattens so you can pass self.has_association?(:comments, :baseable_comments) aswell as
+		#		self.has_association?([:comments, :baseable_comments]) without issue
+		#		
+		args = args.flatten.map { |a| a.to_sym }
+		associations = list_associations
+		(args.length == (associations & args).length)
+	end
+
+	def has_association?(*args)
+		#just redirects to the class method for ease of use (see class method above)
+		self.class.has_association?(*args)
+	end
+
+	#should work, probably able to override by redefining in ApplicationRecord class
+
+	PROJECT_NAME = Rails.application.class.to_s.split("::").first.to_s.downcase
+
+	# this method is to get an hgid for a class without actually calling it down from the database.
+	# For example Notification.blind_hgid 1 will give gid://PROJECT_NAME/Notification/69DAB69 etc.
+	def self.blind_hgid(id, tag: nil)
+		unless id.class == String
+			id = self.encode_id id
+		end
+		gid = "gid://#{PROJECT_NAME}/#{self.to_s}/#{id}"
+		if !tag
+			gid
+		else
+			"#{gid}@#{tag}"
+		end
+	end
+
+	# custom hash GlobalID
+	def hgid(tag: nil)
+		gid = "gid://#{PROJECT_NAME}/#{self.class.to_s}/#{self.hid}"
+		if !tag
+			gid
+		else
+			"#{gid}@#{tag}"
+		end
+	end
+	alias ghid hgid #its worth it trust me the amount of times i go 'is it hash global id or global hashid?'
+
+	def hgid_as_selector(tag: nil, attribute: 'id')
+		#https://www.javascripttutorial.net/javascript-dom/javascript-queryselector/
+		gidstr = hgid(tag: tag).to_s
+		return self.class.string_as_selector(gidstr, attribute: attribute)
+	end
+
+	def self.string_as_selector(str, attribute: 'id')
+		#this is needed to allow us to quey various strange characters in the id etc. (see hgids)
+		#also useful for querying various attributes
+		return "*[#{attribute}=\"#{str}\"]"
+	end
+
+	def self.locate_hgid(hgid_string, with_associations: nil, returns_nil: false)
+		if hgid_string == nil or hgid_string.class != String
+			if returns_nil
+				return nil
+			else
+				raise StandardError.new("non-string class passed to ApplicationRecord#locate_hgid as the hgid_string variable")
+			end
+		end
+		if hgid_string.include?('@')
+			hgid_string = hgid_string.split('@')
+			hgid_string.pop
+			hgid_string = hgid_string.join('@') # incase the model was a tag that was tagged. (few months later: Wtf? Guess ill keep it)
+		end
+		#split the thing
+		splitz = hgid_string.split('/')
+		#get the class
+		begin
+			cls = splitz[-2].constantize
+		rescue NameError, NoMethodError => e
+			if returns_nil
+				nil
+			else
+				raise StandardError.new 'Unusual or unavailable string or hgid'
+			end
+		end
+		#get the hash
+		hash = splitz[-1]
+		# if self == ApplicationRecord (for instance), then check that cls is a subclass
+		# if self is not ApplicationRecord, then check cls == this objects class
+		# if with_associations defined, make sure that the class has the associations given (see has_association above)
+		if ((self.abstract_class? and cls < self) or ( (not self.abstract_class?) and cls == self )) and
+			( with_associations == nil or cls.has_association?(with_associations) )
+			#if all is as expected, return the object with its id.
+			if block_given?
+				yield(hash)
+			else
+				cls.hfind(hash)
+			end
+		elsif returns_nil
+			#allows us to handle issues with input
+			nil
+		else
+			#stops execution as default
+			raise StandardError.new 'Not the expected class, or a subclass of ApplicationRecord if called on that.'
+		end
+	end
+
+	def self.get_hgid_tag(hgid_string)
+		if hgid_string.include?('@')
+			return hgid_string.split('@')[-1]
+		else
+			return nil
+		end
+	end
+
+	#thank god for some stack overflow people are pretty awesome https://stackoverflow.com/questions/64894375/executing-a-raw-sql-query-in-rails-with-an-array-parameter-against-postgresql
+	#BigIntArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::BigInteger.new).freeze
+	#IntegerArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::Integer.new).freeze
+
+	#https://api.rubyonrails.org/files/activemodel/lib/active_model/type_rb.html
+	# active_model/type/helpers
+	# active_model/type/value
+	# active_model/type/big_integer
+	# active_model/type/binary
+	# active_model/type/boolean
+	# active_model/type/date
+	# active_model/type/date_time
+	# active_model/type/decimal
+	# active_model/type/float
+	# active_model/type/immutable_string
+	# active_model/type/integer
+	# active_model/type/string
+	# active_model/type/time
+	# active_model
+
+	DB_TYPE_MAPS = {
+		String => ActiveModel::Type::String,
+		Symbol => ActiveModel::Type::String,
+		Integer => ActiveModel::Type::BigInteger,
+		BigDecimal => ActiveRecord::Type::Decimal,
+		TrueClass => ActiveModel::Type::Boolean,
+		FalseClass => ActiveModel::Type::Boolean,
+		Date => ActiveModel::Type::Date,
+		DateTime => ActiveModel::Type::DateTime,
+		Time => ActiveModel::Type::Time,
+		Float => ActiveModel::Type::Float,
+		Array =>  Proc.new{ |first_el_class| ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(DB_TYPE_MAPS[first_el_class].new) }
+	}
+
+
+	#allows us to preload on a list and not a active record relation. So basically from the output of headache_sql
+	def self.headache_preload(records, associations)
+		ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+	end
+
+	#just for ease of use
+	def headache_preload(records, associations)
+		self.class.headache_preload(records, associations)
+	end
+
+	def self.headache_sql(name, sql, opts = { }) #see below for opts
+		# - instantiate_class - returns User, Post, etc objects instead of straight sql output.
+		#		I prefer doing the alterantive
+		#			User.headache_class(...)
+		#		which is also supported
+		# - prepare sets whether the db will preprocess the strategy for lookup (defaults true) (I dont think turning this off works...)
+		# - name_modifiers allows one to change the preprocess associated name, useful in cases of dynamic sql.
+		# - multi_query allows more than one query (you can seperate an insert and an update with ';' I dont know how else to say it.)
+		#		this disables other options (except name_modifiers). Not sure how it effects prepared statements.
+		# - async does what it says but I haven't used it yet so. Probabably doesn't work
+		#
+		# Any other option is assumed to be a sql argument (see other examples in code base)
+
+		#grab options from the opts hash
+		instantiate_class = opts.delete(:instantiate_class)
+		name_modifiers = opts.delete(:name_modifiers)
+		name_modifiers ||= []
+		prepare = opts.delete(:prepare) != false
+		multi_query = opts.delete(:multi_query) == true
+		async = opts.delete(:async) == true
+		params = opts
+
+		#allows dynamic sql prepared statements.
+		for mod in name_modifiers
+			name << "_#{mod.to_s}" unless mod.nil?
+		end
+
+		unless multi_query
+			#https://stackoverflow.com/questions/49947990/can-i-execute-a-raw-sql-query-leverage-prepared-statements-and-not-use-activer/67442353#67442353
+
+			#change the keys to $1, $2 etc. this step is needed for ex. {id: 1, id_user: 2}.
+			#doing the longer ones first prevents id replacing :id_user -> 1_user
+			keys = params.keys.sort{|a,b| b.to_s.length <=> a.to_s.length}
+			vals = []
+			x = 1
+			for key in keys
+				#replace the key with $1, $2 etc
+				if sql.gsub!(":#{key}", "$#{x}") == nil
+					#nothing changed, param not used, delete it
+					x -= 1
+					params.delete key
+				else
+					#yes its dumb I know dont look at me look at rails
+
+					# https://stackoverflow.com/questions/40407700/rails-exec-query-bindings-ignored
+					# binds = [ ActiveRecord::Relation::QueryAttribute.new(
+					# 	"id", 6, ActiveRecord::Type::Integer.new
+					# )]
+					# ApplicationRecord.connection.exec_query(
+					# 	'SELECT * FROM users WHERE id = $1', 'sql', binds
+					# )
+					v = params[key]
+					type = DB_TYPE_MAPS[v.class]
+					if type.nil?
+						raise StandardError.new("#{v}'s class #{v.class} unsupported type right now for ApplicationRecord#headache_sql")
+					elsif type.class == Proc
+						a = v[0]
+						a.nil? ? a = Integer : a = a.class
+						type = type.call(a)
+					else
+						type = type.new
+					end
+					
+					vals << ActiveRecord::Relation::QueryAttribute.new( key, v, type )
+				end
+				x += 1
+			end
+			ret = ActiveRecord::Base.connection.exec_query sql, name, vals, prepare: prepare, async: async
+		else
+			ret = ActiveRecord::Base.connection.execute sql, name
+		end
+
+		#this returns a PG::Result object, which is pretty basic. To make this into User/Post/etc objects we do
+				#the following
+		if instantiate_class or self != ApplicationRecord
+			instantiate_class = self if not instantiate_class
+						#no I am not actually this cool see https://stackoverflow.com/questions/30826015/convert-pgresult-to-an-active-record-model
+						fields = ret.columns
+						vals = ret.rows
+						ret = vals.map { |v|
+								instantiate_class.instantiate(Hash[fields.zip(v)])
+						}
+		end
+		ret
+	end
+	def safe_increment(col, val) #also used in follow, also used in comment#kill
+		self.class.where(id: self.id).update_all("#{col} = #{col} + #{val}")
+	end
+	def self.quick_safe_increment(id, col, val)
+		where(id: id).update_all("#{col} = #{col} + #{val}")
+	end
+
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: dynamic-records-meritfront
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Luke Clancy
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashid-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds better functionality for writing raw sql. Adds hashed global id
+  reference string for database records. This can help with the flexibility and speed
+  of handling records.
+email:
+- lukeclancy@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/update
+- dynamic-records-meritfront.gemspec
+- lib/dynamic-records-meritfront.rb
+- lib/dynamic-records-meritfront/version.rb
+homepage: https://github.com/LukeClancy/dynamic-records-meritfront
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/LukeClancy/dynamic-records-meritfront
+  source_code_uri: https://github.com/LukeClancy/dynamic-records-meritfront
+  changelog_uri: https://github.com/LukeClancy/dynamic-records-meritfront/blob/main/README.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Helpers for active record that allow for more abstract and fine-grained code.
+test_files: []