has_helpers 5.0.2

data/docs/Elasticsearch.md

@@ -0,0 +1,23 @@
+# Elasticsearch
+
+## Setup
+
+* Install Elasticsearch `brew install elasticsearch`.
+* Use `brew info elasticsearch` for instructions on starting.
+* Run `rake search:views` to create the views used for indexing.
+
+## Indexing
+
+* Make sure sidekiq is running, and `rake search:views` has been run.
+* Run `rake search:reindex` to reindex all classes. Note that this rake task
+  can only be run in the development environment. Indexes should always be
+  run individually in production.
+* To index one class, run `index_class.reindex`.
+* To reindex one record, run `record.reindex`. This may fail in development
+  if the index class has not yet been loaded.
+
+## Common Resolutions to Issues
+
+* If seeing errors about a view not existing, run `rake search:views`.
+* If seeing errors from elasticsearch about field types, run `rake search:clean`,
+  then `rake search:reindex`.

data/docs/Search_API.md

@@ -0,0 +1,126 @@
+# Search API
+
+## Set up
+
+* Application resources
+
+Queries must be made against a resource or set of resources. Each `HasHelpers::Application` has a set of
+`HasHelpers::Resource` records. These are used to determine whether the current user can search the specified resource(
+s), so you should define them appropriately.
+
+* Mount the SearchAPI Rack Application
+
+Just add a new line to your routes file to mount `HasHelpers::SearchAPI`. You can just copy and paste this if you want:
+
+```ruby
+mount ::HasHelpers::SearchAPI => "/search" # You can customize the URL.
+```
+
+* Search Providers
+
+Framework ships with search providers (currently the two options are SQL and Sphinx) and defaults to SQL searches. SQL
+searches can be customized and Sphinx will need some further setup. Read about how to do those things and more about
+providers in the [Search Providers](#search-provider) section below.
+
+## Requests
+
+Requests should be made to the path which was specified when mounting the SearchAPI Rack application.
+
+### Request Format
+
+Currently only JSON requests are accepted.
+
+### Responses
+
+All responses will return a JSON body.
+
+A successful response will return a payload with the results and pagination information. These will be wrapped in a
+top-level object which will have the following keys: `"resources"`, `"current_page"`, `"per_page"`, and
+`"total_entries"`.
+
+#### Errors
+
+If an error response was received with a status in the 4xx-5xx range then the response body will included a top level
+object with an "errors" key and follows the [JSONAPI standard](http://jsonapi.org/format/).
+
+```json
+{
+  "errors": [
+    {
+      "title": "Something went wrong."
+    }
+  ]
+}
+```
+
+### Query Parameters
+
+| Parameter             | Description                                                                                                                                                                                                                                                                                                                                       |
+|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `query`               | What you want to search for. I'm pretty sure you already understood this.                                                                                                                                                                                                                                                                         |
+| `resource` (optional) | A comma-separated list of resource types. Resources must be from the set which configured for the current application. E.g. `Advisor` or `Client,Firm`. Omitting this parameter will cause the query to search all resources. _Currently SQL searches do not support multiple resources and will only use the first resource which is specified._ |
+| `with` (optional)     | A common-separated list of key value pairs where each key and value are separated by a colon (`:`), e.g. `firm_id:123,carrier_id:456`. _Currently "with" options only have an effect for Sphinx searches._                                                                                                                                        |
+
+An example search URL might look something like this:
+`http://example.com/search?resource=Advisor,Client&query=Fredo&with=firm_id`
+
+## Search Providers
+
+HasHelpers ships with search providers out of the box. Currently those are SQL (`HasHelpers::Query::SQL`) and Sphinx (
+`HasHelpers::Query::Sphinx`). SQL search is the default.
+
+### SQL Search
+
+Out of the box you should be able to use SQL searches as long as your resource tables each have a `name` column. You may
+specify your own method to perform SQL searches by defining class-level method named `sql_search` to your resource
+model. Note that custom SQL searches are responsible for querying and paginating records.
+
+Here is a very simple example of a custom sql_search method:
+
+```ruby
+# MyResource
+def self.sql_search(query, options)
+  where(options)
+    .where(name: query)
+    .page(options[:page] || 1)
+    .per_page(options[:per_page] || 15)
+end
+```
+
+### Sphinx Search
+
+You will need to add `sphinx` and the `thinking-sphinx` gems to your application if you want to use Sphinx searches.
+
+### Accessing and Setting the Search Provider
+
+The current search provider is accessible and may be set at the application level through `HasHelpers::Query` methods.
+
+Accessing the current provider:
+
+```ruby
+HasHelpers::Query.provider # => HasHelpers::Query::Sphinx
+```
+
+Setting the current provider:
+
+```ruby
+HasHelpers::Query.provider = HasHelpers::Query::SQL
+```
+
+You can also set the provider to a proc to provide a dynamic way of getting a provider.
+
+```ruby
+HasHelpers::Query.provider = -> {
+  HasHelpers::Application.current_application.search_provider # Look up the search provider dynamically
+}
+```
+
+### Adding a Custom Search Provider
+
+The recommended way is to create a class which includes `HasHelpers::Query::Provider`. Then override the `exec_query`
+instance method.
+
+Bare bones way: Create a provider class which has a `search` method that accepts `:query`, `:resource`, and `:options`
+keyword arguments. You are on your own after that!
+
+Take a look at the stock provider classes if you need some guidance.

data/docs/cards_role_proxy.md

@@ -0,0 +1,107 @@
+# Cards Role Proxy
+
+Cards can resolve role visibility through `HasHelpers::Cards::Roles` instead of reading `HasHelpers::Role` directly. This lets admin apps keep the authoritative `roles` table while consumer apps render cards against remote role data.
+
+The proxy is built on top of `HasHelpers::ServiceTrust`, so both apps must configure ServiceTrust before configuring Cards. `issuer` and `audience` in `Cards.config` must match the values used in ServiceTrust on each side.
+
+## ServiceTrust configuration
+
+Admin/server app — trusts the consumer to call `roles:read`:
+
+```ruby
+::HasHelpers::ServiceTrust.configure do |config|
+  config.issuer = "hqadmin"
+  config.environment = Rails.env
+  config.trusted_issuers do |_env, register|
+    register.call("hqadmin", url: ENV.fetch("AGENCIESHQ_URL"), allowed_capabilities: "roles:read")
+  end
+end
+```
+
+Consumer/client app — points at the admin's JWKS:
+
+```ruby
+::HasHelpers::ServiceTrust.configure do |config|
+  config.issuer = "agencieshq"
+  config.environment = Rails.env
+  config.trusted_issuers do |_env, register|
+    register.call("hqadmin", url: ENV.fetch("HQADMIN_URL"))
+  end
+end
+```
+
+Each app generates and persists its own signing keypair (`HasHelpers::ServiceTrust::KeyManager.current_signing_key`) on first boot; the keypair is encrypted at rest via the Rails master key.
+
+## Cards configuration
+
+Admin/server app:
+
+```ruby
+HasHelpers::Cards.configure do |config|
+  config.mode = :server
+  config.issuer = "hqadmin"
+end
+```
+
+Consumer/client app:
+
+```ruby
+HasHelpers::Cards.configure do |config|
+  config.mode = :client
+  config.issuer = "agencieshq"
+  config.audience = "hqadmin"
+  config.base_url = ENV.fetch("HQADMIN_URL")
+  config.redis = RedisConf.current
+end
+```
+
+Client mode requires Redis.
+
+## Admin GraphQL
+
+Mount the internal role fields in the admin app's service-trust-gated internal schema and put it behind `VerifyMiddleware`:
+
+```ruby
+class InternalQuery < GraphQL::Schema::Object
+  HasHelpers::Resolvers::Internal::Roles.mount(self)
+end
+
+class InternalSchema < GraphQL::Schema
+  query InternalQuery
+end
+
+# config/routes.rb (admin app)
+mount HasHelpers::ServiceTrust::VerifyMiddleware.new(
+  ->(env) { InternalSchema.execute(...).to_h.then { |r| [200, {}, [r.to_json]] } },
+  paths: %r{\A/internal_graphql\z}
+), at: "/internal_graphql"
+```
+
+The resolver enforces the `roles:read` ServiceTrust capability declared via `Authorizable`.
+
+## Consumer API
+
+Use the facade:
+
+```ruby
+HasHelpers::Cards::Roles.find(role_id)
+HasHelpers::Cards::Roles.all
+HasHelpers::Cards::Roles.where(ids: role_ids)
+```
+
+`RoleResourceCard#role` also routes through the facade.
+
+## Orphan Sweeper
+
+Register the sweeper in the consumer app's GoodJob cron configuration:
+
+```ruby
+config.good_job.cron = {
+  cards_orphan_card_sweeper: {
+    cron: "0 3 * * *",
+    class: "HasHelpers::Cards::OrphanCardSweeper"
+  }
+}
+```
+
+The sweeper runs only in `:client` mode and soft-disables orphaned role cards by setting `disabled_at`.

data/docs/factory_api.md

@@ -0,0 +1,135 @@
+# Factory API (test-only)
+
+This API is meant for e2e/tests only and is disabled in production. It lives under the HasHelpers engine mount (e.g., `/has_helpers`).
+
+All requests must include:
+
+- `X-Factory-Api-Key`: must equal `TEST_FACTORY_API_KEY`.
+
+The API is enabled when `Rails.env.test?` and `TEST_FACTORY_API_ENABLED=true`.
+
+## Endpoints
+
+### POST /test/factory/create
+
+Create & persist via FactoryBot.
+
+- Params: `resource` (required), `traits` [array], `payload` [hash], `include` (see Includes).
+- Response: `201` with `{ id, attributes: { … } }`.
+
+Example:
+
+```bash
+curl -X POST /has_helpers/test/factory/create \
+  -H "Content-Type: application/json" \
+  -H "X-Factory-Api-Key: $TEST_FACTORY_API_KEY" \
+  -d '{"resource":"user","traits":["with_org"],"payload":{"username":"api_user@example.com"},"include":["organization"]}'
+```
+
+### POST /test/factory/build
+
+Build (not persisted).
+
+- Params: same as `create`.
+- Response: `200` with `{ id, attributes: { … }, persisted: false }`.
+
+Example:
+
+```bash
+curl -X POST /has_helpers/test/factory/build \
+  -H "Content-Type: application/json" \
+  -H "X-Factory-Api-Key: $TEST_FACTORY_API_KEY" \
+  -d '{"resource":"user","include":["organization"]}'
+```
+
+### POST /test/factory/seed
+
+Bulk create.
+
+- Params: same as `create` plus `count` (required, >0).
+- Response: `201` with an array of serialized records.
+
+Example:
+
+```bash
+curl -X POST /has_helpers/test/factory/seed \
+  -H "Content-Type: application/json" \
+  -H "X-Factory-Api-Key: $TEST_FACTORY_API_KEY" \
+  -d '{"resource":"user","count":3,"traits":["with_org"]}'
+```
+
+### GET /test/factory/:resource/:id
+
+Fetch a persisted record.
+
+- Query params: `include` supported.
+- Response: `200` with serialized record; `404` if missing; `400` if factory unknown.
+
+Example:
+
+```bash
+curl -G /has_helpers/test/factory/advisor/123 \
+  -H "X-Factory-Api-Key: $TEST_FACTORY_API_KEY" \
+  --data-urlencode 'include=["organization"]'
+```
+
+## Includes (embedding associations)
+
+Works on all endpoints; passed directly to `as_json(include: ...)`.
+
+Accepted forms (JSON or native objects):
+
+- Flat: `"include": ["organization","demographic"]`
+- Nested: `"include": [{"organization":["firm"]},"demographic"]`
+- Deep: `"include": [{"organization":{"firm":{"region":{}}}}]`
+- Single: `"include": "organization"`
+
+Meaning: each key is an association; nested values describe further includes for that association.
+
+Examples:
+
+```bash
+# advisor -> organization
+--data-urlencode 'include=["organization"]'
+
+# advisor -> organization -> firm, plus demographic
+--data-urlencode 'include=[{"organization":["firm"]},"demographic"]'
+
+# advisor -> organization -> firm -> region
+--data-urlencode 'include=[{"organization":{"firm":{"region":{}}}}]'
+
+## POST /test/factory/scenario
+Run a predefined FactoryScenario (Ruby DSL) with optional overrides/additions.
+
+- Params:
+  - `scenario` (required): scenario name, e.g., `commissions/scenario_1`.
+  - `objects` (hash): keyed by alias. For aliases defined in the scenario, entries act as overrides; for unknown aliases, entries are created as new factories.
+    - `traits`: array of traits
+    - `attributes`: hash of overrides; supports references like `@alias` or `@alias.id`.
+    - `factory`: only needed for aliases not defined in the scenario (extras).
+  - `activate`: array of aliases to force-load if they aren't referenced elsewhere (optional).
+  - `include`: per-object only; provide a hash keyed by alias, where each value is an include spec.
+  - `response`: array of aliases to include in the response body. If omitted, only the aliases built during execution are returned.
+- Response: `200` with a hash keyed by alias.
+
+Example:
+
+```bash
+curl -X POST /has_helpers/test/factory/scenario \
+  -H "Content-Type: application/json" \
+  -H "X-Factory-Api-Key: $TEST_FACTORY_API_KEY" \
+  -d '{
+        "scenario": "commissions/scenario_1",
+        "objects": {
+          "policy": { "traits": ["with_number"], "attributes": { "face_amount": 500000 } },
+          "advisor_3": { "traits": ["with_org"], "attributes": { "name": "Override Name" } },
+          "extra_schedule": {
+            "factory": "commission_schedule",
+            "traits": ["for_percent_of_premium"],
+            "attributes": { "organization": "@organization", "rate_percent": 77 }
+          }
+        },
+        "include": ["organization", {"policy": ["product","carrier"]}]
+      }'
+```
+```

data/has-helpers-pr-289-pipeline.yaml

@@ -0,0 +1,16 @@
+USER-SUPPLIED VALUES:
+gem-delivery:
+  rbac:
+  - role: edit
+    subjects:
+    - kind: Group
+      name: hq-product
+git:
+  organization: OneHQ
+  ref: refs/pull/289/head
+  repository: has_helpers
+  sha: 09b2b7caa1e381e37a595753d47e27e523e5e53c
+global:
+  taskAnnotations:
+    vault.security.banzaicloud.io/vault-role: has-helpers-pr-289-pipeline
+publish: false

data/has-helpers-pr-298-pipeline.yaml

@@ -0,0 +1,15 @@
+USER-SUPPLIED VALUES:
+git:
+  organization: OneHQ
+  ref: refs/pull/289/head
+  repository: has_helpers
+  sha: 04a21aedd9d9e8d60e1672957c54d16b32732764
+global:
+  taskAnnotations:
+    vault.security.banzaicloud.io/vault-role: has-helpers-pr-289-pipeline
+publish: false
+rbac:
+- role: edit
+  subjects:
+  - kind: Group
+    name: hq-product

data/has_helpers.gemspec

@@ -0,0 +1,68 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+$:.push File.expand_path("../lib", __FILE__)
+require "has_helpers/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "has_helpers"
+  s.version               = HasHelpers::VERSION
+  s.required_ruby_version = ">= 3.4.0", "< 4.0.0"
+  s.summary               = "HelpersHQ"
+  s.description           = "Ruby helpers."
+  s.authors               = ["Kyle J. Ginavan"]
+  s.email                 = ["kyle@onehq.com"]
+  s.homepage              = "https://github.com/OneHQ/has_helpers"
+  s.licenses              = ["HQ"]
+  s.files                 = `git ls-files`.split("\n")
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables           = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths         = ["lib"]
+
+  s.add_dependency "aws-sdk-s3",                              "~> 1.46"
+  s.add_dependency "aws-sdk-sqs",                             "~> 1.22"
+  s.add_dependency "barby",                                   "~> 0.6.8" # barcode generation
+  s.add_dependency "cancancan",                               "~> 3.0" # authorization (UserRestrictions is a CanCan::Ability)
+  s.add_dependency "chronic",                                 "0.10.2"
+  s.add_dependency "chunky_png",                              "~> 1.3" # barcode generation to png
+  s.add_dependency "flipper",                                 "~> 0.16"
+  s.add_dependency "flipper-redis",                           "~> 0.16"
+  s.add_dependency "flipper-ui",                              "~> 0.16"
+  s.add_dependency "holidays",                                "~> 8.4"
+  s.add_dependency "humanize",                                "~> 2.0"
+  s.add_dependency "jwt",                                     "~> 2.7"
+  s.add_dependency "marginalia",                              "~> 1.8" # Insert comments into ActiveRecord queries. Useful for disabling pgpool.
+  # This is a workaround to avoid date format issues with Searchkick.indexer. TODO: Remove this multi_json version limit when elasticsearch-rails is updated to 8.x.
+  s.add_dependency "csv",                                     "~> 3.3"
+  s.add_dependency "multi_json",                              ">= 1.11", "<= 1.17"
+  s.add_dependency "mustache",                                "~> 1.0"
+  s.add_dependency "observer",                                "~> 0.1"
+  s.add_dependency "opentelemetry-exporter-otlp",             "~> 0.24"
+  s.add_dependency "opentelemetry-instrumentation-all",       "~> 0.27"
+  s.add_dependency "opentelemetry-sdk",                       "~> 1.5"
+  s.add_dependency "rails",                                   ">= 6.0", "< 7.2.4"
+  s.add_dependency "redcarpet",                               "~> 3.0"
+  s.add_dependency "searchkick",                              "~> 4.1"
+  s.add_dependency "sidekiq",                                 "~> 6.0"
+  s.add_dependency "sidekiq-ent",                             "~> 2.0"
+  s.add_dependency "sidekiq-pro",                             "~> 5.0"
+  s.add_dependency "slack-ruby-client",                       "~> 1.0"
+  s.add_dependency "sorbet-runtime",                          "~> 0.0"
+  s.add_dependency "spreadsheet_architect",                   "~> 4.1"
+  s.add_dependency "strong_migrations",                       "~> 2.5" # helps ensure bad things don't happen in migrations
+  s.add_dependency "wicked_pdf",                              "~> 1.4"
+  s.add_dependency "will_paginate",                           "~> 3.1"
+
+  s.add_development_dependency "kt-paperclip",                "~> 7.2"
+  s.add_development_dependency "sorbet",                      "~> 0.6"
+  s.add_development_dependency "sprockets",                   "~> 3.0"
+
+  # hq
+  s.add_dependency "has_owner",                               "~> 5.0.0"
+  s.add_dependency "has_utils",                               "~> 5.0.0"
+  s.add_dependency "has_validated_attributes",                "~> 5.0.0"
+  s.add_dependency "hq-graphql",                              "~> 5.0.0"
+  s.add_dependency "psql_hq",                                 "~> 5.0.0"
+
+  s.add_development_dependency "testhq",                      "~> 5.0.0"
+end

data/lib/active_record/migration/active_migration_patch.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# If you would like to use these methods in a Rails migration, make sure you
+# add this require line at the top of your migration file:
+#   require "active_migration_patch"
+class ActiveRecord::Migration
+  def conditionally_add_index(table, columns, opts = {})
+    add_index(table, columns, opts) unless index_exists?(table, columns, opts)
+  end
+
+  # Adds a foreign key based on the arguments passed in. If organization_id is
+  # not already part of the from_columns, it adds it to both the from_columns
+  # and to_columns. The default foreign key name will use the same format we
+  # used in our data migrations to initially update all foreign keys to include
+  # organization_id.
+  #   from_table: name of the table the fk constraint is on (symbol or string)
+  #   to_table: name of the table the fk references (symbol or string)
+  #   from_columns (optional): name of the fk column(s) in from_table; defaults
+  #     to using the standard foreign key name for the to_table - e.g.,
+  #     "client_id" if the to_table is "clients" (symbol, string, or array of
+  #     symbols and/or strings)
+  #   to_columns (optional): name of the referenced column(s) in to_table;
+  #     defaults to "id" (symbol, string, or array of symbols and/or strings)
+  #   name (optional): name for the foreign key constraint
+  # If you pass in from_columns and to_columns, the columns should be ordered
+  # so the first references the first, the second references the second etc.
+  #
+  # EXAMPLES:
+  #   add_org_scoped_foreign_key(from_table: :trustees, to_table: :clients)
+  #   add_org_scoped_foreign_key(
+  #     from_table: :advisors,
+  #     to_table: :users,
+  #     from_columns: :created_by_id
+  #   )
+  #   add_org_scoped_foreign_key(
+  #     from_table: :toys,
+  #     to_table: "factories",
+  #     from_columns: [:factory_id, "toy_category_id"]
+  #     to_columns: ["id", :toy_category_id]
+  #   )
+  def add_org_scoped_foreign_key(from_table:, to_table:, from_columns: nil, to_columns: nil, name: nil, validate: true)
+    from_columns, to_columns = foreign_key_columns(to_table: to_table, from_columns: from_columns, to_columns: to_columns)
+    add_compound_foreign_key(
+      from_table: from_table,
+      to_table: to_table,
+      from_columns: from_columns,
+      to_columns: to_columns,
+      name: name,
+      validate: validate
+    )
+  end
+
+  def validate_org_scoped_foreign_key(from_table:, to_table:, from_columns: nil, to_columns: nil, name: nil)
+    from_columns, to_columns = foreign_key_columns(to_table: to_table, from_columns: from_columns, to_columns: to_columns)
+    name ||= compound_foreign_key_name(
+      from_table: from_table,
+      to_table: to_table,
+      from_columns: from_columns,
+      to_columns: to_columns
+    )
+
+    ActiveRecord::Base.connection_pool.with_connection do |conn|
+      conn.execute <<-END_OF_SQL
+        ALTER TABLE #{from_table}
+        VALIDATE CONSTRAINT #{name};
+      END_OF_SQL
+    end
+  end
+
+  # Adds a compound foreign key based on the arguments passed in.
+  #   from_table: name of the table the fk constraint is on (symbol or string)
+  #   to_table: name of the table the fk references (symbol or string)
+  #   from_columns (optional): name of the fk column(s) in from_table; defaults
+  #     to using the standard foreign key name for the to_table - e.g.,
+  #     "client_id" if the to_table is "clients" (symbol, string, or array of
+  #     symbols and/or strings)
+  #   to_columns (optional): name of the referenced column(s) in to_table;
+  #     defaults to "id" (symbol, string, or array of symbols and/or strings)
+  #   name (optional): name for the foreign key constraint
+  # If you pass in from_columns and to_columns, the columns should be ordered
+  # so the first references the first, the second references the second etc.
+  def add_compound_foreign_key(from_table:, to_table:, from_columns:, to_columns:, name: nil, validate: true)
+    name ||= compound_foreign_key_name(
+      from_table: from_table,
+      to_table: to_table,
+      from_columns: from_columns,
+      to_columns: to_columns
+    )
+
+    ActiveRecord::Base.connection_pool.with_connection do |conn|
+      conn.execute <<-END_OF_SQL
+        ALTER TABLE #{from_table}
+            ADD CONSTRAINT #{name}
+            FOREIGN KEY (#{from_columns.join(",")})
+            REFERENCES #{to_table} (#{to_columns.join(",")})
+            #{"NOT VALID" unless validate}
+            DEFERRABLE INITIALLY DEFERRED;
+      END_OF_SQL
+    end
+  end
+
+  # Returns a name for the foreign key constraint. If the from_columns include
+  # organization_id, the name begins with "org_id_fk_"; otherwise, it starts with "compound_fk_".
+  def compound_foreign_key_name(from_table:, to_table:, from_columns:, to_columns:)
+    from_columns = from_columns.map(&:to_s)
+    to_columns = to_columns.map(&:to_s)
+    prefix = from_columns.include?("organization_id") ? "org_id" : "compound"
+
+    "#{prefix}_fk_#{::Digest::MD5.hexdigest([from_table.to_s, from_columns, to_table.to_s, to_columns].flatten.join("."))}"
+  end
+
+  def foreign_key_columns(to_table:, from_columns: nil, to_columns: nil)
+    from_columns = from_columns.blank? ? [to_table.to_s.singularize.foreign_key] : Array(from_columns)
+    to_columns = to_columns.blank? ? ["id"] : Array(to_columns)
+
+    unless from_columns.map(&:to_s).include?("organization_id")
+      from_columns << "organization_id"
+      to_columns << "organization_id"
+    end
+
+    return from_columns, to_columns
+  end
+end

data/lib/generators/has_helpers/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Installs necessary files for using HasHelpers.
+
+Example:
+    rails generate has_helpers:install
+
+    This will create (or modify):
+        db/migrate/?_has_helpers_initial_setup.rb

data/lib/generators/has_helpers/install/install_generator.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+class HasHelpers::InstallGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path("../templates", __FILE__)
+  class_option :skip_migrations, type: :boolean, default: false, description: "Copies migration files for HasHelpers models."
+
+  def self.next_migration_number(path)
+    ActiveRecord::Generators::Base.next_migration_number(path)
+  end
+
+  def copy_migrations
+    return if options.skip_migrations?
+    Dir["#{File.expand_path('../templates', __FILE__)}/migrate/*.rb"].each do |migration|
+      migration_template "migrate/#{File.basename(migration)}", "db/migrate/#{File.basename(migration)}"
+    end
+  end
+end

data/lib/generators/has_helpers/install/templates/migrate/has_helpers_initial_setup.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+class HasHelpersInitialSetup < ActiveRecord::Migration
+  def change
+    #################
+    #### Options ####
+    #################
+    create_table :options do |t|
+      t.string    :type,          limit: 63, null: false
+      t.string    :name,          limit: 127, null: false
+      t.timestamps                null: false
+    end
+    add_index :options, [:type, :name], unique: true
+    add_index :options, :name
+
+    ####################
+    #### Time Zones ####
+    ####################
+    create_table :time_zones do |t|
+      t.string    :name,                       limit: 127, null: false
+      t.string    :pg_timezone_name,           limit: 127, null: false
+      t.timestamps                             null: false
+    end
+  end
+end