open-loam 0.1.1 → 0.3.0

data/lib/generators/loam/install/templates/admin/history_controller.rb

@@ -1,38 +0,0 @@
-module Admin
-  # A record's change history (Loam::AuditRecord) with one-click Undo (L-704).
-  # Undo applies the inverse of a change and records ITSELF as an audit, so
-  # undoing an "undo" entry is redo — no separate redo action. Reading needs read
-  # on the record; undoing needs update (the same gate as editing it).
-  class HistoryController < BaseController
-    before_action :set_target
-
-    def index
-      authorize!(policy_for(@record), :read?)
-      @audits = Loam::AuditRecord
-                .where(auditable_type: @record.class.name, auditable_id: @record.id)
-                .order(id: :desc).limit(100)
-    end
-
-    def undo
-      authorize!(policy_for(@record), :update?)
-      audit = Loam::AuditRecord.find(params[:id])
-      Loam::Undo.undo(audit, policy: policy_for(@record))
-      redirect_to admin_history_path(type: @record.class.name, record_id: @record.id), notice: "Change undone."
-    rescue Loam::Undo::NotUndoableError => error
-      redirect_to admin_history_path(type: @record.class.name, record_id: @record.id), alert: error.message
-    end
-
-    private
-
-    # The target record, looked up through its OWN default scope (tenancy holds;
-    # a soft-deleted row is still reachable to restore). The type is whitelisted
-    # to a Loam::TenantRecord — never a bare constantize of a param.
-    def set_target
-      klass = params[:type].to_s.safe_constantize
-      raise Loam::NotAuthorizedError unless klass.is_a?(Class) && klass < Loam::TenantRecord
-
-      scope = klass.respond_to?(:with_deleted) ? klass.with_deleted : klass.all
-      @record = scope.find(params[:record_id])
-    end
-  end
-end

data/lib/generators/loam/install/templates/admin/layout.html.erb

@@ -1,76 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Admin</title>
-    <%%= csrf_meta_tags %>
-    <%%= stylesheet_link_tag "admin", media: "all" %>
-  </head>
-  <body>
-    <%% flash.each do |type, message| %>
-      <div class="flash flash-<%%= type.to_s == "alert" ? "alert" : "notice" %>"><%%= message %></div>
-    <%% end %>
-    <%% if defined?(current_tenant) && current_tenant %>
-      <div class="context">
-        <%%= t("loam.chrome.tenant") %>: <strong><%%= current_tenant.name %></strong> ·
-        <%%= t("loam.chrome.user") %>: <strong><%%= current_actor&.name %></strong> ·
-        <%%= button_to t("loam.chrome.sign_out"), admin_session_path, method: :delete, form: { style: "display:inline" } %>
-      </div>
-      <nav>
-        <%%= link_to t("loam.nav.dashboard"), admin_root_path %>
-        <%%= link_to admin_notifications_path do %><%%= t("loam.nav.notifications") %> (<span id="loam-notification-count"><%%= unread_notification_count %></span>)<%% end %>
-        <%%= link_to t("loam.nav.api_tokens"), admin_api_tokens_path %>
-        <%%= link_to t("loam.nav.security"), admin_mfa_path %>
-        <%%= link_to "#{t('loam.nav.approvals')} (#{pending_approval_count})", admin_pending_actions_path %>
-        <%%= link_to t("loam.nav.settings"), admin_configs_path %>
-        <%%= link_to t("loam.nav.features"), admin_features_path %>
-        <%%= link_to t("loam.nav.rules"), admin_business_rules_path %>
-        <%%= link_to t("loam.nav.sso"), admin_sso_providers_path %>
-        <%%= link_to t("loam.nav.dictionaries"), admin_dictionaries_path %>
-        <%%= link_to t("loam.nav.tasks"), admin_progress_jobs_path %>
-        <%%= link_to t("loam.nav.schedules"), admin_scheduled_jobs_path %>
-        <%%= link_to t("loam.nav.deliveries"), admin_event_deliveries_path %>
-        <%%= link_to t("loam.nav.inbound"), admin_inbound_webhook_sources_path %>
-        <%%= link_to t("loam.nav.api_docs"), admin_api_docs_path %>
-        <%%= link_to t("loam.nav.overrides"), admin_overrides_path %>
-        <%%= form_with url: admin_search_path, method: :get, class: "search" do %>
-          <%%= text_field_tag :q, params[:q], placeholder: t("loam.chrome.search") %>
-        <%% end %>
-        <%%# Locale switcher (Loam::Translatable): overlays content onto the picked language. %>
-        <%% if Loam.locales.size > 1 %>
-          <span class="locale">
-            <%% Loam.locales.each do |loc| %><%%= link_to loc.upcase, "#{request.path}?locale=#{loc}", style: (loc == current_locale ? "font-weight:bold" : "") %> <%% end %>
-          </span>
-        <%% end %>
-      </nav>
-
-      <%%# Live updates over SSE (Loam::EventStream). Degrades gracefully: if
-          EventSource is unavailable or the stream drops, the per-page-load bell
-          count above still works. %>
-      <script>
-        (function () {
-          if (typeof EventSource === "undefined") return;
-          var source = new EventSource("<%%= admin_events_stream_path %>");
-          source.addEventListener("loam.notification.created", function () {
-            var badge = document.getElementById("loam-notification-count");
-            if (badge) badge.textContent = (parseInt(badge.textContent, 10) || 0) + 1;
-          });
-          // Live task progress (Loam::ProgressJob): move the matching bar. The
-          // frame carries only id/percent/status.
-          source.addEventListener("loam.progress.updated", function (e) {
-            var d = JSON.parse(e.data);
-            var fill = document.getElementById("progress-fill-" + d.id);
-            if (fill) fill.style.width = d.percent + "%";
-            var pct = document.getElementById("progress-percent-" + d.id);
-            if (pct) pct.textContent = d.percent + "%";
-            var st = document.getElementById("progress-status-" + d.id);
-            if (st) st.textContent = d.status;
-          });
-          source.onerror = function () {
-            if (source.readyState === EventSource.CLOSED) source.close();
-          };
-        })();
-      </script>
-    <%% end %>
-    <%%= yield %>
-  </body>
-</html>

data/lib/generators/loam/install/templates/admin/progress_jobs_controller.rb

@@ -1,19 +0,0 @@
-module Admin
-  # Long-running task progress (Loam::ProgressJob) — a tenant-scoped list of
-  # recent jobs with a live bar (the loam.progress.updated SSE event updates it).
-  # Your app starts jobs with Loam::Progress.start in its own background jobs;
-  # a running one can be cancelled cooperatively here.
-  class ProgressJobsController < BaseController
-    def index
-      @jobs = Loam::ProgressJob.recent.limit(20)
-    end
-
-    def cancel
-      job = Loam::ProgressJob.find(params[:id])
-      # Manager-or-owner: a member must not cancel another user's job.
-      raise Loam::NotAuthorizedError unless current_role == :manager || job.actor_id == current_actor&.id
-      job.cancel! if job.running?
-      redirect_to admin_progress_jobs_path, notice: "Job cancelled."
-    end
-  end
-end

data/lib/generators/loam/install/templates/api_base_controller.rb

@@ -1,90 +0,0 @@
-module Api
-  # Base class for every JSON endpoint. Authentication is a bearer token:
-  #
-  #   curl -H "Authorization: Bearer <token>" http://localhost:3000/api/equipment
-  #
-  # A token identifies one user in one tenant, and `Loam::ApiToken.authenticate`
-  # establishes both in Loam::Current before any action runs. From that point
-  # on this is ordinary tenant-scoped Loam code: every query is filtered, every
-  # write is audited, every policy applies — the API is not a side door.
-  #
-  # Finding a token is the one lookup that cannot start from a tenant (the
-  # token is what reveals the tenant), which is why it lives in the gem rather
-  # than here: host app code must never reach across tenants.
-  class BaseController < ActionController::API
-    before_action :authenticate_api_token!
-
-    rescue_from Loam::NotAuthorizedError do
-      render json: { error: "forbidden" }, status: :forbidden
-    end
-
-    rescue_from ActiveRecord::RecordNotFound do
-      render json: { error: "not_found" }, status: :not_found
-    end
-
-    rescue_from Loam::UnknownCustomFieldError do |error|
-      render json: { error: error.message }, status: :unprocessable_entity
-    end
-
-    private
-
-    def authenticate_api_token!
-      @api_token = Loam::ApiToken.authenticate(bearer_token)
-
-      render json: { error: "unauthorized" }, status: :unauthorized unless @api_token
-    end
-
-    def bearer_token
-      request.headers["Authorization"].to_s[/\ABearer (.+)\z/, 1]
-    end
-
-    def current_tenant = Loam::Current.tenant
-    def current_actor = Loam::Current.actor
-
-    def policy_for(record)
-      Loam::Policy.for(record)
-    end
-
-    def authorize!(policy, action)
-      raise Loam::NotAuthorizedError unless policy.public_send(action)
-    end
-
-    # The JSON shape of an entity: its columns, custom fields included (they
-    # live in the `custom_fields` column that every generated entity carries).
-    #
-    # Encrypted fields (Loam::Encryptable) are returned DECRYPTED — the caller is
-    # authenticated, tenant-scoped and policy-gated, exactly like the admin show
-    # screen — and their blind-index `<field>_hash` column is dropped, so the
-    # equality-leaking hash never goes over the wire. `record.attributes` alone
-    # would emit the raw ciphertext plus the hash.
-    def entity_json(record, enrichments: nil)
-      json = record.attributes
-
-      if record.class.respond_to?(:loam_encrypted_attributes)
-        record.class.loam_encrypted_attributes.each do |name|
-          json[name] = record.public_send(name)
-          json.delete("#{name}_hash")
-        end
-      end
-
-      # Computed cross-module blocks (Loam::Enrichers), under a separate key so
-      # they're never confused with the record's own columns. An index passes the
-      # batched result (avoiding N+1); a single show computes it here.
-      enrichments = Loam::Enrichers.enrich(record) if enrichments.nil?
-      json["enrichments"] = enrichments if enrichments.present?
-      json
-    end
-
-    # Same field-level enforcement as the admin screens: only a definition the
-    # actor's role may write is assigned. Custom fields ride at the top level
-    # of the request body, beside the entity key.
-    def assign_custom_fields!(record, params, policy)
-      submitted = params[:custom_fields]
-      return unless submitted
-
-      submitted.each do |name, value|
-        record.set_custom_field(name, value) if policy.custom_field_writable?(name)
-      end
-    end
-  end
-end

data/lib/generators/loam/install/templates/import_job.rb

@@ -1,25 +0,0 @@
-# Runs a CSV import in the background, advancing a Loam::ProgressJob so the admin
-# watches it live (L-915). Carries tenant + actor explicitly, like every Loam job.
-# The per-row summary (created/updated/failed + error rows) is stored on the
-# ProgressJob's `result` for the summary screen.
-class ImportJob < ApplicationJob
-  queue_as :default
-
-  def perform(entity_type:, csv:, mapping:, match_key:, tenant_id:, actor_id:)
-    tenant = Loam::Tenant.find(tenant_id)
-    actor = User.find_by(id: actor_id)
-    model = Loam::Import.allowed_model(entity_type)
-
-    Loam.as_tenant(tenant, actor: actor) do
-      total = [ CSV.parse(csv).size - 1, 0 ].max
-      progress = Loam::Progress.start(name: "Import #{entity_type}", total: total)
-      begin
-        result = Loam::Import.run(csv, model: model, mapping: mapping, actor: actor, match_key: match_key, progress: progress)
-        progress.update_columns(result: result.to_h)
-        progress.complete!
-      rescue StandardError => error
-        progress.fail!(error.message)
-      end
-    end
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_api_tokens.rb

@@ -1,15 +0,0 @@
-class CreateLoamApiTokens < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_api_tokens<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.references :user, null: false, foreign_key: true<%= loam_type_option %>
-      t.string :token, null: false
-      t.string :label
-      t.datetime :last_used_at
-      t.timestamps
-    end
-    # Tokens are looked up before a tenant is known, so the uniqueness that
-    # matters is global.
-    add_index :loam_api_tokens, :token, unique: true
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_audit_records.rb

@@ -1,14 +0,0 @@
-class CreateLoamAuditRecords < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_audit_records<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :auditable_type, null: false
-      t.<%= loam_key_column_type %> :auditable_id<%= loam_key_limit_option %>, null: false
-      t.string :action, null: false
-      t.<%= loam_key_column_type %> :actor_id<%= loam_key_limit_option %>
-      t.text :changeset
-      t.timestamps
-    end
-    add_index :loam_audit_records, %i[tenant_id auditable_type auditable_id]
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_comments.rb

@@ -1,13 +0,0 @@
-class CreateLoamComments < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_comments<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :commentable_type, null: false
-      t.<%= loam_key_column_type %> :commentable_id<%= loam_key_limit_option %>, null: false
-      t.references :author, null: false, foreign_key: { to_table: :users }<%= loam_type_option %>
-      t.text :body, null: false
-      t.timestamps
-    end
-    add_index :loam_comments, %i[tenant_id commentable_type commentable_id]
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_custom_field_values.rb

@@ -1,19 +0,0 @@
-class CreateLoamCustomFieldValues < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_custom_field_values<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :indexable_type, null: false
-      t.<%= loam_key_column_type %> :indexable_id<%= loam_key_limit_option %>, null: false
-      t.string :field_key, null: false
-      t.text :value_text                # canonical string form (contains/present/eq)
-      t.decimal :value_number           # integer/decimal fields (range queries)
-      t.boolean :value_boolean          # boolean fields
-      t.datetime :value_datetime        # date/datetime fields
-      t.timestamps
-    end
-    add_index :loam_custom_field_values, %i[indexable_type indexable_id field_key],
-              unique: true, name: "index_loam_cfv_unique"
-    add_index :loam_custom_field_values, %i[tenant_id indexable_type field_key value_text], name: "index_loam_cfv_text"
-    add_index :loam_custom_field_values, %i[tenant_id indexable_type field_key value_number], name: "index_loam_cfv_number"
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_dashboard_widgets.rb

@@ -1,12 +0,0 @@
-class CreateLoamDashboardWidgets < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_dashboard_widgets<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :widget_key, null: false   # a registered Loam::Widgets key
-      t.integer :position, null: false, default: 0
-      t.boolean :active, null: false, default: true
-      t.timestamps
-    end
-    add_index :loam_dashboard_widgets, %i[tenant_id widget_key], unique: true
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_dictionaries.rb

@@ -1,11 +0,0 @@
-class CreateLoamDictionaries < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_dictionaries<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :key, null: false   # the code the field def / API references (e.g. "damage_severity")
-      t.string :name, null: false  # human label for the list
-      t.timestamps
-    end
-    add_index :loam_dictionaries, %i[tenant_id key], unique: true
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_memberships.rb

@@ -1,11 +0,0 @@
-class CreateLoamMemberships < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_memberships<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.references :user, null: false, foreign_key: true<%= loam_type_option %>
-      t.string :role, null: false
-      t.timestamps
-    end
-    add_index :loam_memberships, %i[tenant_id user_id], unique: true
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_notifications.rb

@@ -1,15 +0,0 @@
-class CreateLoamNotifications < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_notifications<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.references :user, null: false, foreign_key: true<%= loam_type_option %>
-      t.string :title, null: false
-      t.text :body
-      t.datetime :read_at
-      t.string :source_type
-      t.<%= loam_key_column_type %> :source_id<%= loam_key_limit_option %>
-      t.timestamps
-    end
-    add_index :loam_notifications, %i[tenant_id user_id read_at]
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_record_locks.rb

@@ -1,16 +0,0 @@
-class CreateLoamRecordLocks < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_record_locks<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :lockable_type, null: false
-      t.<%= loam_key_column_type %> :lockable_id<%= loam_key_limit_option %>, null: false
-      t.references :locked_by, null: false, foreign_key: { to_table: :users }<%= loam_type_option %>
-      t.string :token, null: false
-      t.datetime :expires_at, null: false   # TTL; an expired lock is treated as free
-      t.timestamps                          # updated_at is the heartbeat
-    end
-    # One advisory lock per record.
-    add_index :loam_record_locks, %i[tenant_id lockable_type lockable_id], unique: true,
-              name: "index_loam_record_locks_on_lockable"
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_search_tokens.rb

@@ -1,18 +0,0 @@
-class CreateLoamSearchTokens < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_search_tokens<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :searchable_type, null: false  # the entity class name (e.g. "Gadget")
-      t.<%= loam_key_column_type %> :searchable_id<%= loam_key_limit_option %>, null: false     # the record it indexes
-      t.string :token, null: false             # one normalized word
-    end
-    # The match subquery filters by (tenant, type, token); index maintenance
-    # deletes by (tenant, type, record). One index each — no timestamps: these
-    # are plumbing rows written with insert_all/delete_all.
-    #
-    # Shipped even though the default LikeDriver never uses it, so switching to
-    # Loam::Search::TokenDriver is a one-line initializer change, not a migration.
-    add_index :loam_search_tokens, %i[tenant_id searchable_type token]
-    add_index :loam_search_tokens, %i[tenant_id searchable_type searchable_id]
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_tenants.rb

@@ -1,9 +0,0 @@
-class CreateLoamTenants < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_tenants<%= loam_id_option %> do |t|
-      t.string :name, null: false
-      t.string :slug, null: false, index: { unique: true }
-      t.timestamps
-    end
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_translations.rb

@@ -1,15 +0,0 @@
-class CreateLoamTranslations < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_translations<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :translatable_type, null: false
-      t.<%= loam_key_column_type %> :translatable_id<%= loam_key_limit_option %>, null: false
-      t.string :locale, null: false            # "en", "de", "pl"
-      t.string :field, null: false             # the translated attribute
-      t.text :value                            # the per-locale content
-      t.timestamps
-    end
-    add_index :loam_translations, %i[translatable_type translatable_id locale field],
-              unique: true, name: "index_loam_translations_unique"
-  end
-end

data/lib/generators/loam/install/templates/migrations/create_loam_webhook_endpoints.rb

@@ -1,13 +0,0 @@
-class CreateLoamWebhookEndpoints < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table :loam_webhook_endpoints<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.string :url, null: false
-      t.string :event_pattern, null: false
-      t.string :secret, null: false
-      t.boolean :active, null: false, default: true
-      t.timestamps
-    end
-    add_index :loam_webhook_endpoints, %i[tenant_id active]
-  end
-end

data/lib/loam/engine.rb

@@ -1,57 +0,0 @@
-module Loam
-  class Engine < ::Rails::Engine
-    # Not isolated on purpose: Loam models live under the Loam:: namespace but
-    # share the host app's routes/helpers, keeping the prototype surface small.
-
-    # Webhook dispatch listens to every Loam event. Wired after initialization
-    # so the models it queries are loadable, and guarded against subscribing
-    # twice (see Loam::Webhooks.subscribe!).
-    config.after_initialize do
-      Loam::Webhooks.subscribe!
-      Loam::DurableEvents.subscribe!    # persist + retry durable subscribers (L-706)
-      Loam::BusinessRules.subscribe!
-      Loam::Widgets.register_builtins!  # the default dashboard widgets
-      Loam::Overrides.check!            # warn about any stale disable/replace overrides
-
-      # The durability sweep runs per-tenant on a schedule (materialized into
-      # each tenant by Loam::Scheduler.sync_tenant). interval:300 = every 5 min.
-      Loam::Scheduler.register(
-        key: Loam::DurableEvents::SWEEP_KEY, name: "Event redelivery sweep",
-        job_class: "Loam::EventRedeliverySweepJob", schedule: "interval:300", scope: "tenant"
-      )
-    end
-
-    # Loam's Active Record layer — TenantRecord, Auditable, Eventful and the
-    # rest — is defined inside ActiveSupport.on_load(:active_record) in
-    # lib/loam.rb, so those constants exist only once something has referenced
-    # ActiveRecord::Base.
-    #
-    # Zeitwerk eager-loads app/models alphabetically. A host model that inherits
-    # from Loam::TenantRecord and sorts ahead of application_record.rb reaches
-    # the constant before anything has touched Base, and eager load dies with
-    # "uninitialized constant Loam::TenantRecord". Whether an app hits it
-    # depends on its model names, so it shows up on a rename rather than on the
-    # change that caused it.
-    #
-    # Referencing Base here fires the hook while load order is still the
-    # engine's to decide instead of each host app's. :eager_load! is late enough
-    # that every active_record.* initializer has applied its configuration, and
-    # it runs in every environment (in development it is a no-op that still
-    # executes), so lazily-loaded apps are settled by the same line.
-    initializer "loam.active_record_layer", before: :eager_load! do
-      ActiveRecord::Base
-    end
-
-    # Loam's own UI strings ship under lib/ (the gemspec packages lib/**/*), so
-    # register them on the app's I18n load path explicitly rather than relying on
-    # the default config/locales path (which the gem does not ship). An app
-    # overrides any key with its own config/locales/loam.<locale>.yml.
-    initializer "loam.i18n" do |app|
-      app.config.i18n.load_path += Dir[File.expand_path("locales/*.yml", __dir__)]
-    end
-
-    # lib/tasks/loam.rake (bin/rails loam:sync) is picked up by Rails::Engine's
-    # own lib/tasks loading. Loading it again from a `rake_tasks` block here
-    # would define the task twice and run its body twice.
-  end
-end

data/lib/loam/sso/http_client.rb

@@ -1,42 +0,0 @@
-require "net/http"
-require "json"
-
-module Loam
-  module Sso
-    # The one place SSO talks to the network — kept tiny and isolated so the rest
-    # of the flow is pure. Only Loam::Sso::OidcProvider uses it, and the test
-    # suite injects a FakeProvider instead, so this is never exercised offline.
-    module HttpClient
-      module_function
-
-      def get_json(url, bearer: nil)
-        uri = URI(url)
-        request = Net::HTTP::Get.new(uri)
-        request["Authorization"] = "Bearer #{bearer}" if bearer
-        parse(perform(uri, request))
-      end
-
-      def post_form(url, params)
-        uri = URI(url)
-        request = Net::HTTP::Post.new(uri)
-        request.set_form_data(params)
-        request["Accept"] = "application/json"
-        parse(perform(uri, request))
-      end
-
-      def perform(uri, request)
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-          http.request(request)
-        end
-      end
-
-      def parse(response)
-        unless response.is_a?(Net::HTTPSuccess)
-          raise Loam::Sso::Error, "identity provider returned #{response.code}"
-        end
-
-        JSON.parse(response.body)
-      end
-    end
-  end
-end

data/lib/loam/version.rb

@@ -1,3 +0,0 @@
-module Loam
-  VERSION = "0.1.1"
-end