nquery 0.1.0

data/app/controllers/nquery/embed/charts_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Embed
+    class ChartsController < ActionController::Base
+      include Nquery::Engine.routes.url_helpers
+      layout "nquery/embed"
+
+      def show
+        payload = EmbedTokenService.verify(params[:token])
+        @chart = Chart.find(payload[:resource_id])
+        @result = demo_result
+      rescue EmbedTokenService::Error
+        render plain: "Invalid or expired embed token", status: :forbidden
+      end
+
+      private
+
+      def demo_result
+        { columns: %w[month revenue], rows: [%w[Jan 1200], %w[Feb 1800], %w[Mar 2400]] }
+      end
+    end
+  end
+end

data/app/controllers/nquery/embed/dashboards_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Embed
+    class DashboardsController < ActionController::Base
+      include Nquery::Engine.routes.url_helpers
+      layout "nquery/embed"
+
+      def show
+        payload = EmbedTokenService.verify(params[:token])
+        @dashboard = Dashboard.includes(dashboard_cards: :chart).find(payload[:resource_id])
+      rescue EmbedTokenService::Error
+        render plain: "Invalid or expired embed token", status: :forbidden
+      end
+    end
+  end
+end

data/app/controllers/nquery/home_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nquery
+  class HomeController < ApplicationController
+    include Browsable
+
+    def index
+      charts = Chart.active.includes(:collection, :creator).order(updated_at: :desc).limit(12)
+      dashboards = Dashboard.active.includes(:collection, :creator, :dashboard_cards).order(updated_at: :desc).limit(12)
+
+      @recent_charts = filter_viewable_charts(charts).first(6)
+      @recent_dashboards = filter_viewable_dashboards(dashboards).first(6)
+      @root_collection = Collection.roots.first
+    end
+  end
+end

data/app/controllers/nquery/imports_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Nquery
+  class ImportsController < ApplicationController
+    before_action :authorize_import_access!
+
+    def new
+      @csv_upload = CsvUpload.new
+    end
+
+    def create
+      @csv_upload = CsvImporter.new(
+        file: params[:file],
+        name: params[:name],
+        creator: current_nquery_user,
+        column_mapping: parse_mapping(params[:column_mapping])
+      ).import
+
+      redirect_to root_path, notice: "CSV import started: #{@csv_upload.name}"
+    rescue CsvImporter::Error => e
+      @csv_upload = CsvUpload.new(name: params[:name])
+      flash.now[:alert] = e.message
+      render :new, status: :unprocessable_content
+    end
+
+    private
+
+    def authorize_import_access!
+      root = Collection.roots.first || Collection.shared.first
+      authorize_collection_access!(root, required: :curate)
+    end
+
+    def parse_mapping(raw)
+      return {} if raw.blank?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/app/controllers/nquery/queries_controller.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Nquery
+  class QueriesController < ApplicationController
+    skip_before_action :_authenticate!, only: [] # always auth
+    before_action :set_query, only: %i[show edit update]
+    before_action :authorize_query_collection!, only: %i[show edit update]
+    before_action :set_data_source_for_run, only: %i[run schema]
+    before_action :authorize_run_data_source!, only: %i[run schema]
+
+    def new
+      @query = Query.new(statement: "SELECT 1 AS example")
+      @data_sources = DataSource.active.order(:name)
+      @schema_tables = schema_tables
+    end
+
+    def create
+      @query = Query.new(query_params.merge(creator: current_nquery_user))
+      if @query.save
+        redirect_to edit_query_path(@query), notice: "Query created."
+      else
+        @data_sources = DataSource.active.order(:name)
+        @schema_tables = schema_tables
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def edit
+      @data_sources = DataSource.active.order(:name)
+      @schema_tables = schema_tables
+    end
+
+    def update
+      if @query.update(query_params)
+        respond_to do |format|
+          format.html { redirect_to edit_query_path(@query), notice: "Query saved." }
+          format.json { render json: { ok: true, notice: "Query saved." } }
+        end
+      else
+        @data_sources = DataSource.active.order(:name)
+        @schema_tables = schema_tables
+        respond_to do |format|
+          format.html { render :edit, status: :unprocessable_content }
+          format.json {
+            render json: { error: @query.errors.full_messages.to_sentence.presence || "Query could not be saved." },
+                   status: :unprocessable_content
+          }
+        end
+      end
+    end
+
+    def show
+    end
+
+    def run
+      result = QueryRunner.new(
+        data_source: @data_source,
+        statement: params[:statement],
+        user: current_nquery_user
+      ).run
+
+      render json: result
+    rescue QueryRunner::PermissionError => e
+      render json: { error: e.message }, status: :forbidden
+    rescue QueryRunner::Error => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    def schema
+      render json: { tables: Nquery::SchemaExplorer.tables_for(@data_source) }
+    end
+
+    private
+
+    def set_query
+      @query = Query.find(params[:id])
+    end
+
+    def authorize_query_collection!
+      authorize_collection_access!(@query.collection, required: :view)
+    end
+
+    def set_data_source_for_run
+      @data_source = DataSource.find(params[:data_source_id] || DataSource.first&.id)
+    end
+
+    def authorize_run_data_source!
+      authorize_data_source_access!(@data_source, permission_type: "view_data")
+      authorize_data_source_access!(@data_source, permission_type: "create_queries")
+    end
+
+    def query_params
+      params.require(:query).permit(:name, :statement, :data_source_id, :collection_id)
+    end
+
+    def schema_tables
+      data_source = DataSource.first
+      return [] unless data_source
+
+      DataSources::Adapter.for(data_source).tables
+    rescue StandardError
+      []
+    end
+  end
+end

data/app/controllers/nquery/registrations_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nquery
+  class RegistrationsController < ApplicationController
+    skip_before_action :_authenticate!
+    layout "nquery/auth"
+
+    def new
+      redirect_to root_path if current_nquery_user
+      @user = User.new
+    end
+
+    def create
+      @user = User.new(registration_params)
+      if @user.save
+        @user.ensure_all_users_membership!
+        @user.ensure_personal_collection!
+        session[:nquery_user_id] = @user.id
+        redirect_to root_path, notice: "Welcome to nquery!"
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def registration_params
+      params.require(:user).permit(:email, :first_name, :last_name, :password, :password_confirmation)
+    end
+  end
+end

data/app/controllers/nquery/sessions_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Nquery
+  class SessionsController < ApplicationController
+    skip_before_action :_authenticate!
+    layout "nquery/auth"
+
+    def new
+      redirect_to root_path if current_nquery_user
+    end
+
+    def create
+      user = User.active.find_by(email: params[:email]&.downcase)
+      if user&.authenticate(params[:password])
+        session[:nquery_user_id] = user.id
+        redirect_to root_path, notice: "Signed in successfully."
+      else
+        flash.now[:alert] = "Invalid email or password."
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      session.delete(:nquery_user_id)
+      redirect_to login_path, notice: "Signed out."
+    end
+  end
+end

data/app/helpers/nquery/charts_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nquery
+  module ChartsHelper
+    def chart_dashboard
+      @dashboard
+    end
+
+    def chart_show_path(chart, dashboard: chart_dashboard)
+      dashboard ? dashboard_chart_path(dashboard, chart) : chart_path(chart)
+    end
+
+    def chart_edit_path(chart, dashboard: chart_dashboard)
+      dashboard ? edit_dashboard_chart_path(dashboard, chart) : edit_chart_path(chart)
+    end
+
+    def chart_embed_path(chart, dashboard: chart_dashboard)
+      dashboard ? embed_dashboard_chart_path(dashboard, chart) : embed_chart_path(chart)
+    end
+
+    def chart_archive_path(chart, dashboard: chart_dashboard)
+      dashboard ? archive_dashboard_chart_path(dashboard, chart) : archive_chart_path(chart)
+    end
+
+    def chart_form_path(chart, dashboard: chart_dashboard)
+      dashboard ? dashboard_chart_path(dashboard, chart) : chart_path(chart)
+    end
+
+    def chart_builder_chart_types
+      Chart::CHART_TYPES - %w[table]
+    end
+  end
+end

data/app/helpers/nquery/collections_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nquery
+  module CollectionsHelper
+    def collection_kind_label(collection)
+      case collection.kind
+      when "root" then "Top-level collection"
+      when "personal" then "Personal collection"
+      else "Collection"
+      end
+    end
+  end
+end

data/app/helpers/nquery/components_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nquery
+  module ComponentsHelper
+    def render_nquery_component(component, &block)
+      component.render_in(self, &block)
+    end
+
+    def nq_flash_cards(flash: self.flash)
+      render_nquery_component(FlashCardsComponent.new(flash: flash))
+    end
+
+    def nq_flash_card(message, type: :notice, **options)
+      render_nquery_component(FlashCardComponent.new(message: message, type: type, **options))
+    end
+
+    def nq_card(title: nil, **options, &block)
+      CardComponent.new(title: title, **options).render_in(self, &block)
+    end
+
+    def nq_card_table(columns:, **options, &block)
+      CardTableComponent.new(columns: columns, **options).render_in(self, &block)
+    end
+
+    def nq_infinite_scroll(url:, **options, &block)
+      InfiniteScrollComponent.new(url: url, **options).render_in(self, &block)
+    end
+  end
+end

data/app/helpers/nquery/home_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nquery
+  module HomeHelper
+    def home_greeting
+      hour = Time.zone.now.hour
+      salutation = if hour < 12
+                     "Good morning"
+                   elsif hour < 18
+                     "Good afternoon"
+                   else
+                     "Good evening"
+                   end
+
+      name = current_nquery_user&.first_name.presence || "there"
+      "#{salutation}, #{name}"
+    end
+
+    def chart_type_label(chart)
+      chart.chart_type.titleize
+    end
+  end
+end

data/app/helpers/nquery/icon_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nquery
+  module IconHelper
+    def nq_icon(name, **options)
+      render "nquery/shared/icon", name: name.to_s, html_options: options
+    end
+  end
+end

data/app/helpers/nquery/navigation_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Nquery
+  module NavigationHelper
+    def nav_link_class(*controller_paths)
+      active = controller_paths.flatten.any? { |path| controller_path == path.to_s }
+      active ? "nq-nav-link active" : "nq-nav-link"
+    end
+  end
+end

data/app/javascript/nquery/controllers/chart_preview_controller.js

@@ -0,0 +1,125 @@
+import { Controller } from "@hotwired/stimulus"
+
+function columnIndex(columns, name) {
+  const index = columns.indexOf(name)
+  return index >= 0 ? index : 0
+}
+
+function chartJsType(type) {
+  if (type === "area") return "line"
+  if (type === "scatter") return "scatter"
+  if (type === "pie") return "pie"
+  return type === "line" ? "line" : "bar"
+}
+
+function buildPreviewChartConfig(type, data, xCol, yCol) {
+  const columns = data.columns || []
+  const rows = data.rows || []
+  const xIndex = columnIndex(columns, xCol || columns[0])
+  const yIndex = columnIndex(columns, yCol || columns[1] || columns[0])
+  const labels = rows.map(row => row[xIndex])
+  const values = rows.map(row => Number(row[yIndex]) || 0)
+  const color = "#509ee3"
+  const yLabel = yCol || columns[yIndex] || "Value"
+
+  if (type === "scatter") {
+    return {
+      type: "scatter",
+      data: {
+        datasets: [{
+          label: yLabel,
+          data: rows.map(row => ({ x: Number(row[xIndex]) || 0, y: Number(row[yIndex]) || 0 })),
+          backgroundColor: color
+        }]
+      },
+      options: { responsive: true, maintainAspectRatio: false }
+    }
+  }
+
+  if (type === "pie") {
+    return {
+      type: "pie",
+      data: {
+        labels,
+        datasets: [{ data: values, backgroundColor: [color, "#7db8ea", "#a8d0f0", "#d4e8f8", "#2d7ec1"] }]
+      },
+      options: { responsive: true, maintainAspectRatio: false }
+    }
+  }
+
+  const jsType = chartJsType(type)
+  return {
+    type: jsType,
+    data: {
+      labels,
+      datasets: [{
+        label: yLabel,
+        data: values,
+        backgroundColor: color,
+        borderColor: color,
+        fill: type === "area",
+        tension: type === "line" || type === "area" ? 0.3 : 0
+      }]
+    },
+    options: { responsive: true, maintainAspectRatio: false }
+  }
+}
+
+export default class extends Controller {
+  static targets = ["canvas"]
+  static values = { type: String, data: Object, x: String, y: String }
+
+  connect() {
+    if (typeof Chart === "undefined") return
+
+    const demo = this.hasDataValue ? this.dataValue : {
+      columns: ["month", "revenue"],
+      rows: [["Jan", 1200], ["Feb", 1800], ["Mar", 2400]]
+    }
+    const type = this.typeValue || "bar"
+    const xCol = this.hasXValue ? this.xValue : ""
+    const yCol = this.hasYValue ? this.yValue : ""
+
+    if (type === "number") {
+      const yIndex = columnIndex(demo.columns || [], yCol || demo.columns?.[1] || demo.columns?.[0])
+      const value = demo.rows?.[0]?.[yIndex] ?? "—"
+      this.element.classList.add("is-number")
+      this.element.innerHTML = `<div class="nq-number-display">${value}</div>`
+      return
+    }
+
+    if (type === "table") {
+      const columns = demo.columns || []
+      const rows = (demo.rows || []).slice(0, 8)
+      const table = document.createElement("table")
+      table.className = "nq-data-table"
+      const thead = document.createElement("thead")
+      const headRow = document.createElement("tr")
+      columns.forEach(col => {
+        const th = document.createElement("th")
+        th.textContent = col
+        headRow.appendChild(th)
+      })
+      thead.appendChild(headRow)
+      table.appendChild(thead)
+      const tbody = document.createElement("tbody")
+      rows.forEach(row => {
+        const tr = document.createElement("tr")
+        row.forEach(cell => {
+          const td = document.createElement("td")
+          td.textContent = cell ?? ""
+          tr.appendChild(td)
+        })
+        tbody.appendChild(tr)
+      })
+      table.appendChild(tbody)
+      this.element.innerHTML = ""
+      this.element.appendChild(table)
+      return
+    }
+
+    if (!this.hasCanvasTarget) return
+
+    new Chart(this.canvasTarget, buildPreviewChartConfig(type, demo, xCol, yCol))
+  }
+}

data/app/javascript/nquery/controllers/csv_mapper_controller.js

@@ -0,0 +1,23 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["file", "preview", "mapping"]
+
+  preview() {
+    const file = this.fileTarget.files[0]
+    if (!file) return
+
+    const reader = new FileReader()
+    reader.onload = (e) => {
+      const lines = e.target.result.split("\n").slice(0, 6)
+      const headers = lines[0]?.split(",") || []
+      this.mappingTarget.value = JSON.stringify(
+        headers.map(h => ({ source: h.trim(), target: h.trim().toLowerCase().replace(/\s+/g, "_") }))
+      )
+      this.previewTarget.innerHTML = `<table class="nq-table"><tbody>${lines.map(l =>
+        `<tr>${l.split(",").map(c => `<td>${c.trim()}</td>`).join("")}</tr>`
+      ).join("")}</tbody></table>`
+    }
+    reader.readAsText(file)
+  }
+}

data/app/javascript/nquery/controllers/dashboard_grid_controller.js

@@ -0,0 +1,25 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["card"]
+
+  connect() {
+    this.cardTargets.forEach(card => {
+      card.addEventListener("dragstart", this.dragStart.bind(this))
+      card.addEventListener("dragover", e => e.preventDefault())
+      card.addEventListener("drop", this.drop.bind(this))
+    })
+  }
+
+  dragStart(event) {
+    this.dragged = event.currentTarget
+    event.dataTransfer.effectAllowed = "move"
+  }
+
+  drop(event) {
+    event.preventDefault()
+    if (this.dragged && event.currentTarget !== this.dragged) {
+      event.currentTarget.parentNode.insertBefore(this.dragged, event.currentTarget)
+    }
+  }
+}

data/app/javascript/nquery/controllers/query_editor_controller.js

@@ -0,0 +1,41 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["statement", "results", "dataSource", "schema"]
+
+  insertTable(event) {
+    const table = event.currentTarget.dataset.table
+    const textarea = this.statementTarget
+    const insert = `SELECT * FROM ${table} LIMIT 100`
+    textarea.value = insert
+  }
+
+  async run() {
+    const statement = this.statementTarget.value
+    const dataSourceId = this.dataSourceTarget?.value
+    const csrf = document.querySelector('meta[name="csrf-token"]')?.content
+
+    try {
+      const response = await fetch("/queries/run", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-CSRF-Token": csrf },
+        body: JSON.stringify({ statement, data_source_id: dataSourceId })
+      })
+      const data = await response.json()
+      this.resultsTarget.textContent = JSON.stringify(data, null, 2)
+    } catch (e) {
+      this.resultsTarget.textContent = e.message
+    }
+  }
+
+  async loadSchema() {
+    if (!this.hasSchemaTarget) return
+    const dataSourceId = this.dataSourceTarget.value
+    const response = await fetch(`/queries/schema?data_source_id=${dataSourceId}`)
+    const data = await response.json()
+    this.schemaTarget.innerHTML = data.tables.map(t => {
+      const name = typeof t === "string" ? t : t.name
+      return `<li class="nq-tree-item" data-action="click->query-editor#insertTable" data-table="${name}">${name}</li>`
+    }).join("")
+  }
+}

data/app/models/nquery/application_permission.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nquery
+  class ApplicationPermission < ApplicationRecord
+    FEATURES = %w[settings monitoring subscriptions].freeze
+
+    belongs_to :group, class_name: "Nquery::Group"
+
+    validates :feature, inclusion: { in: FEATURES }
+    validates :access_level, inclusion: { in: %w[yes no] }
+  end
+end

data/app/models/nquery/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nquery
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/nquery/audit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nquery
+  class Audit < ApplicationRecord
+    belongs_to :user, class_name: "Nquery::User", optional: true
+    belongs_to :query, class_name: "Nquery::Query", optional: true
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    scope :for_user, lambda { |term|
+      pattern = "%#{sanitize_sql_like(term.downcase)}%"
+      full_name_sql = if connection.adapter_name.downcase.include?("mysql")
+        "CONCAT(nquery_users.first_name, ' ', nquery_users.last_name)"
+      else
+        "nquery_users.first_name || ' ' || nquery_users.last_name"
+      end
+
+      joins(:user).where(
+        "LOWER(nquery_users.email) LIKE :q OR LOWER(#{full_name_sql}) LIKE :q",
+        q: pattern
+      )
+    }
+
+    scope :for_collection, ->(collection_id) {
+      joins(query: :collection).where(nquery_collections: { id: collection_id })
+    }
+
+    scope :for_dashboard, lambda { |dashboard_id|
+      dashboard_audit_ids = joins(query: { chart: { dashboard_cards: :dashboard } })
+        .where(nquery_dashboards: { id: dashboard_id })
+        .select(:id)
+      where(id: dashboard_audit_ids)
+    }
+
+    scope :since, ->(date) { where(created_at: Date.parse(date).beginning_of_day..) }
+    scope :until_date, ->(date) { where(created_at: ..Date.parse(date).end_of_day) }
+  end
+end