nquery 0.1.0

data/lib/nquery/data_sources/rails_adapter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+module Nquery
+  module DataSources
+    class RailsAdapter < Adapter
+      def tables
+        connection.tables.reject { |t| hidden_table?(t) }
+      end
+
+      def columns(table_name)
+        connection.columns(table_name).map { |c| { name: c.name, type: c.type.to_s } }
+      end
+
+      def execute_readonly(statement, timeout: 15, row_limit: 10_000)
+        rows = []
+        columns = []
+        duration = Benchmark.realtime do
+          connection.transaction do
+            connection.execute("SET TRANSACTION READ ONLY") if postgresql?
+            result = connection.exec_query(sanitize_limit(statement, row_limit))
+            columns = result.columns
+            rows = result.rows
+            raise ActiveRecord::Rollback
+          end
+        end
+        { columns: columns, rows: rows, row_count: rows.size, duration_ms: (duration * 1000).round }
+      end
+
+      private
+
+      def hidden_table?(table_name)
+        return true if table_name.start_with?("ar_") || table_name == "schema_migrations"
+        return false if table_name.start_with?("nquery_sample_")
+
+        table_name.start_with?("nquery_")
+      end
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def postgresql?
+        connection.adapter_name.downcase.include?("postgres")
+      end
+
+      def sanitize_limit(statement, limit)
+        stripped = statement.strip.sub(/;\s*\z/, "")
+        "#{stripped} LIMIT #{limit.to_i}"
+      end
+    end
+  end
+end

data/lib/nquery/data_sources/sqlite_adapter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Nquery
+  module DataSources
+    class SqliteAdapter < PostgresqlAdapter
+    end
+  end
+end

data/lib/nquery/embed_token_service.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module Nquery
+  class EmbedTokenService
+    class Error < StandardError; end
+
+    def self.sign(resource_type:, resource_id:, params: {}, expires_at: 1.hour.from_now, creator: nil)
+      token = generate_token
+      payload = {
+        token: token,
+        resource_type: resource_type,
+        resource_id: resource_id,
+        params: params,
+        exp: expires_at.to_i
+      }
+      data = Base64.urlsafe_encode64(payload.to_json)
+
+      signature = OpenSSL::HMAC.hexdigest("SHA256", signing_key, data)
+      signed = "#{data}.#{signature}"
+
+      EmbedToken.create!(
+        token: token,
+        resource_type: resource_type,
+        resource_id: resource_id,
+        creator: creator,
+        params: params,
+        expires_at: expires_at,
+        active: true
+      )
+
+      { token: token, signed_token: signed, expires_at: expires_at }
+    end
+
+    def self.verify(signed_token)
+      data, signature = signed_token.to_s.split(".", 2)
+      raise Error, "Invalid token format" unless data.present? && signature.present?
+
+      expected_signature = OpenSSL::HMAC.hexdigest("SHA256", signing_key, data)
+      unless ActiveSupport::SecurityUtils.secure_compare(expected_signature, signature)
+        raise Error, "Invalid token signature"
+      end
+
+      payload = JSON.parse(Base64.urlsafe_decode64(data))
+      raise Error, "Token expired" if payload["exp"].to_i <= Time.current.to_i
+
+      record = EmbedToken.active.find_by(token: payload["token"])
+      raise Error, "Token not found" unless record
+      raise Error, "Token expired" if record.expired?
+      raise Error, "Token mismatch" unless record.resource_type == payload["resource_type"] &&
+                                           record.resource_id == payload["resource_id"].to_i
+
+      {
+        resource_type: record.resource_type,
+        resource_id: record.resource_id,
+        params: record.params
+      }
+    end
+
+    def self.signed_token_for(record)
+      payload = {
+        token: record.token,
+        resource_type: record.resource_type,
+        resource_id: record.resource_id,
+        params: record.params || {},
+        exp: record.expires_at.to_i
+      }
+      data = Base64.urlsafe_encode64(payload.to_json)
+      signature = OpenSSL::HMAC.hexdigest("SHA256", signing_key, data)
+      "#{data}.#{signature}"
+    end
+
+    def self.generate_token
+      SecureRandom.urlsafe_base64(24)
+    end
+
+    def self.signing_key
+      Nquery.configuration.embed_signing_key
+    end
+  end
+end

data/lib/nquery/engine.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Nquery
+  class Engine < ::Rails::Engine
+    isolate_namespace Nquery
+
+    config.autoload_paths << root.join("app/components")
+    config.eager_load_paths << root.join("app/components")
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer "nquery.assets" do |app|
+      next unless app.config.respond_to?(:assets)
+
+      app.config.assets.paths << root.join("app/assets/builds").to_s
+      app.config.assets.paths << root.join("app/assets/images").to_s
+
+      if app.config.respond_to?(:assets) && defined?(::Sprockets)
+        app.config.assets.precompile += %w[nquery_manifest.js]
+      end
+    end
+
+    initializer "nquery.importmap", before: "importmap" do |app|
+      if app.respond_to?(:importmap)
+        app.config.importmap.paths << root.join("config/importmap.rb")
+        app.config.importmap.cache_sweepers << root.join("app/assets/builds/nquery")
+      end
+    end
+
+    initializer "nquery.migrations" do |app|
+      next if app.root.to_s.start_with?(root.to_s)
+
+      migration_path = root.join("db/migrate").to_s
+      app.config.paths["db/migrate"] << migration_path unless app.config.paths["db/migrate"].include?(migration_path)
+    end
+
+    initializer "nquery.config" do
+      Nquery.configure do |config|
+        config.authentication_mode = ENV.fetch("NQUERY_AUTHENTICATION_MODE", "standalone").to_sym
+      end
+    end
+
+    initializer "nquery.components" do
+      ActiveSupport.on_load(:action_controller) do
+        append_view_path Nquery::Engine.root.join("app/components")
+      end
+    end
+
+    rake_tasks do
+      load root.join("lib/tasks/nquery.rake")
+    end
+  end
+end

data/lib/nquery/permissions/resolver.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Permissions
+    class Resolver
+      COLLECTION_LEVELS = { "no_access" => 0, "view" => 1, "curate" => 2 }.freeze
+      DATA_VIEW_LEVELS = { "blocked" => 0, "can_view" => 1 }.freeze
+      CREATE_QUERY_LEVELS = { "no" => 0, "query_builder" => 1, "native" => 2, "query_builder_and_native" => 3 }.freeze
+      APP_LEVELS = { "no" => 0, "yes" => 1 }.freeze
+
+      def initialize(user)
+        @user = user
+        @groups = user&.groups&.to_a || []
+      end
+
+      def admin?
+        @groups.any? { |g| g.system_group == "administrators" }
+      end
+
+      def collection_access(collection)
+        return :curate if admin?
+
+        levels = @groups.filter_map do |group|
+          perm = Nquery::CollectionPermission.find_by(group: group, collection: collection)
+          perm&.access_level
+        end
+        max_level(levels, COLLECTION_LEVELS)&.to_sym || :no_access
+      end
+
+      def data_access(data_source, resource_path: nil, permission_type: "view_data")
+        return highest_data_level(permission_type) if admin?
+
+        levels = @groups.flat_map do |group|
+          Nquery::DataPermission.where(group: group, data_source: data_source, permission_type: permission_type)
+                              .where("resource_path IS NULL OR resource_path = ?", resource_path)
+                              .pluck(:access_level)
+        end
+        max_data_level(levels, permission_type)
+      end
+
+      def application_access(feature)
+        return :yes if admin?
+
+        levels = @groups.filter_map do |group|
+          Nquery::ApplicationPermission.find_by(group: group, feature: feature)&.access_level
+        end
+        (max_level(levels, APP_LEVELS) || "no").to_sym
+      end
+
+      def all_users_more_permissive?(group, collection: nil, data_source: nil)
+        all_users = Nquery::Group.find_by(system_group: "all_users")
+        return false unless all_users
+
+        if collection
+          all_users_level = Nquery::CollectionPermission.find_by(group: all_users, collection: collection)&.access_level
+          group_level = Nquery::CollectionPermission.find_by(group: group, collection: collection)&.access_level
+          return COLLECTION_LEVELS[all_users_level].to_i > COLLECTION_LEVELS[group_level].to_i
+        end
+
+        false
+      end
+
+      private
+
+      def max_level(levels, map)
+        levels.max_by { |l| map[l] || -1 }
+      end
+
+      def max_data_level(levels, permission_type)
+        map = permission_type == "create_queries" ? CREATE_QUERY_LEVELS : DATA_VIEW_LEVELS
+        (max_level(levels, map) || default_data_level(permission_type)).to_sym
+      end
+
+      def highest_data_level(permission_type)
+        permission_type == "create_queries" ? :query_builder_and_native : :can_view
+      end
+
+      def default_data_level(permission_type)
+        permission_type == "create_queries" ? "no" : "blocked"
+      end
+    end
+  end
+end

data/lib/nquery/query_runner.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Nquery
+  class QueryRunner
+    class Error < StandardError; end
+    class PermissionError < Error; end
+
+    FORBIDDEN_KEYWORDS = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|TRUNCATE|GRANT|REVOKE|INTO)\b/i
+
+    def initialize(data_source:, statement:, user: nil, query: nil)
+      @data_source = data_source
+      @statement = statement.to_s.strip
+      @user = user
+      @query = query
+    end
+
+    def run
+      validate_statement!
+      check_permissions!
+
+      adapter = DataSources::Adapter.for(@data_source)
+      result = adapter.execute_readonly(
+        @statement,
+        timeout: Nquery.configuration.query_timeout,
+        row_limit: Nquery.configuration.query_row_limit
+      )
+
+      record_audit!(result, "success")
+      result
+    rescue PermissionError
+      raise
+    rescue StandardError => e
+      record_audit!({}, "error", e.message)
+      raise Error, e.message
+    end
+
+    private
+
+    def validate_statement!
+      raise Error, "Query cannot be blank" if @statement.blank?
+      raise Error, "Multi-statement queries are not allowed" if @statement.include?(";")
+      raise Error, "Query must start with SELECT or WITH" unless @statement.match?(/\A\s*(SELECT|WITH)\b/i)
+      raise Error, "Only SELECT queries are allowed" if @statement.match?(FORBIDDEN_KEYWORDS)
+    end
+
+    def check_permissions!
+      return unless @user
+
+      resolver = Permissions::Resolver.new(@user)
+      access = resolver.data_access(@data_source, permission_type: "view_data")
+      raise PermissionError, "You do not have permission to view this data" if access == :blocked
+
+      create_access = resolver.data_access(@data_source, permission_type: "create_queries")
+      raise PermissionError, "You do not have permission to run SQL queries" if create_access == :no
+    end
+
+    def record_audit!(result, status, error_message = nil)
+      Audit.create!(
+        user: @user,
+        query: @query,
+        statement: @statement,
+        status: status,
+        row_count: result[:row_count],
+        duration_ms: result[:duration_ms],
+        error_message: error_message
+      )
+    end
+  end
+end

data/lib/nquery/sample_data/ecommerce.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Nquery
+  module SampleData
+    class Ecommerce
+      TABLES = {
+        categories: "nquery_sample_categories",
+        products: "nquery_sample_products",
+        customers: "nquery_sample_customers",
+        orders: "nquery_sample_orders",
+        order_items: "nquery_sample_order_items"
+      }.freeze
+
+      REQUIRED_TABLES = TABLES.values.freeze
+
+      def self.run!
+        new.run!
+      end
+
+      def run!
+        connection = ActiveRecord::Base.connection
+        create_tables!(connection)
+        return if seeded?(connection)
+
+        seed!(connection)
+      end
+
+      private
+
+      def create_tables!(connection)
+        create_table_if_missing(connection, TABLES[:categories]) do |t|
+          t.string :name, null: false
+          t.timestamps
+        end
+
+        create_table_if_missing(connection, TABLES[:products]) do |t|
+          t.references :category, null: false, foreign_key: { to_table: TABLES[:categories] }
+          t.string :name, null: false
+          t.decimal :price, precision: 10, scale: 2, null: false
+          t.timestamps
+        end
+
+        create_table_if_missing(connection, TABLES[:customers]) do |t|
+          t.string :email, null: false
+          t.string :first_name, null: false
+          t.string :last_name, null: false
+          t.timestamps
+        end
+        connection.add_index TABLES[:customers], :email, unique: true unless connection.index_exists?(TABLES[:customers], :email)
+
+        create_table_if_missing(connection, TABLES[:orders]) do |t|
+          t.references :customer, null: false, foreign_key: { to_table: TABLES[:customers] }
+          t.string :status, null: false, default: "completed"
+          t.datetime :ordered_at, null: false
+          t.timestamps
+        end
+
+        create_table_if_missing(connection, TABLES[:order_items]) do |t|
+          t.references :order, null: false, foreign_key: { to_table: TABLES[:orders] }
+          t.references :product, null: false, foreign_key: { to_table: TABLES[:products] }
+          t.integer :quantity, null: false, default: 1
+          t.decimal :unit_price, precision: 10, scale: 2, null: false
+          t.timestamps
+        end
+      end
+
+      def create_table_if_missing(connection, table_name, &block)
+        return if connection.table_exists?(table_name)
+
+        connection.create_table(table_name, &block)
+      end
+
+      def seeded?(connection)
+        connection.select_value(
+          "SELECT COUNT(*) FROM #{connection.quote_table_name(TABLES[:orders])}"
+        ).to_i.positive?
+      end
+
+      def seed!(connection)
+        now = Time.current
+        categories = {
+          electronics: insert_row(connection, TABLES[:categories], name: "Electronics", created_at: now, updated_at: now),
+          apparel: insert_row(connection, TABLES[:categories], name: "Apparel", created_at: now, updated_at: now),
+          home: insert_row(connection, TABLES[:categories], name: "Home", created_at: now, updated_at: now)
+        }
+
+        products = {
+          headphones: insert_row(connection, TABLES[:products], category_id: categories[:electronics], name: "Wireless Headphones", price: 79.99, created_at: now, updated_at: now),
+          keyboard: insert_row(connection, TABLES[:products], category_id: categories[:electronics], name: "Mechanical Keyboard", price: 129.99, created_at: now, updated_at: now),
+          mouse: insert_row(connection, TABLES[:products], category_id: categories[:electronics], name: "Ergonomic Mouse", price: 49.99, created_at: now, updated_at: now),
+          hoodie: insert_row(connection, TABLES[:products], category_id: categories[:apparel], name: "Cotton Hoodie", price: 59.99, created_at: now, updated_at: now),
+          tshirt: insert_row(connection, TABLES[:products], category_id: categories[:apparel], name: "Logo T-Shirt", price: 24.99, created_at: now, updated_at: now),
+          mug: insert_row(connection, TABLES[:products], category_id: categories[:home], name: "Ceramic Mug", price: 14.99, created_at: now, updated_at: now),
+          lamp: insert_row(connection, TABLES[:products], category_id: categories[:home], name: "Desk Lamp", price: 39.99, created_at: now, updated_at: now)
+        }
+
+        customers = [
+          insert_row(connection, TABLES[:customers], email: "alice@example.com", first_name: "Alice", last_name: "Nguyen", created_at: now, updated_at: now),
+          insert_row(connection, TABLES[:customers], email: "bob@example.com", first_name: "Bob", last_name: "Martinez", created_at: now, updated_at: now),
+          insert_row(connection, TABLES[:customers], email: "carol@example.com", first_name: "Carol", last_name: "Patel", created_at: now, updated_at: now),
+          insert_row(connection, TABLES[:customers], email: "dan@example.com", first_name: "Dan", last_name: "Kim", created_at: now, updated_at: now),
+          insert_row(connection, TABLES[:customers], email: "eva@example.com", first_name: "Eva", last_name: "Silva", created_at: now, updated_at: now)
+        ]
+
+        order_specs = [
+          { customer: customers[0], ordered_at: Time.zone.parse("2026-01-05 10:00"), items: [[:headphones, 1], [:mug, 2]] },
+          { customer: customers[1], ordered_at: Time.zone.parse("2026-01-12 14:30"), items: [[:keyboard, 1], [:mouse, 1]] },
+          { customer: customers[2], ordered_at: Time.zone.parse("2026-01-20 09:15"), items: [[:hoodie, 2], [:tshirt, 1]] },
+          { customer: customers[3], ordered_at: Time.zone.parse("2026-02-03 11:00"), items: [[:lamp, 1], [:mug, 1]] },
+          { customer: customers[4], ordered_at: Time.zone.parse("2026-02-14 16:45"), items: [[:headphones, 1], [:tshirt, 2]] },
+          { customer: customers[0], ordered_at: Time.zone.parse("2026-02-22 08:20"), items: [[:mouse, 2]] },
+          { customer: customers[1], ordered_at: Time.zone.parse("2026-03-01 13:10"), items: [[:keyboard, 1], [:hoodie, 1]] },
+          { customer: customers[2], ordered_at: Time.zone.parse("2026-03-08 17:30"), items: [[:lamp, 2], [:mug, 3]] },
+          { customer: customers[3], ordered_at: Time.zone.parse("2026-03-15 10:50"), items: [[:headphones, 2], [:keyboard, 1]] },
+          { customer: customers[4], ordered_at: Time.zone.parse("2026-03-21 19:00"), items: [[:tshirt, 3], [:mouse, 1]] }
+        ]
+
+        order_specs.each do |spec|
+          order_id = insert_row(
+            connection,
+            TABLES[:orders],
+            customer_id: spec[:customer],
+            status: "completed",
+            ordered_at: spec[:ordered_at],
+            created_at: now,
+            updated_at: now
+          )
+
+          spec[:items].each do |product_key, quantity|
+            product_id = products[product_key]
+            unit_price = connection.select_value(
+              "SELECT price FROM #{connection.quote_table_name(TABLES[:products])} WHERE id = #{connection.quote(product_id)}"
+            )
+            insert_row(
+              connection,
+              TABLES[:order_items],
+              order_id: order_id,
+              product_id: product_id,
+              quantity: quantity,
+              unit_price: unit_price,
+              created_at: now,
+              updated_at: now
+            )
+          end
+        end
+      end
+
+      def insert_row(connection, table, attrs)
+        columns = attrs.keys
+        values = attrs.values.map { |value| connection.quote(value) }
+        connection.insert(
+          "INSERT INTO #{connection.quote_table_name(table)} (#{columns.map { |c| connection.quote_column_name(c) }.join(', ')}) VALUES (#{values.join(', ')})"
+        )
+      end
+    end
+  end
+end

data/lib/nquery/schema_explorer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Nquery
+  class SchemaExplorer
+    def self.tables_for(data_source)
+      new(data_source).tables
+    end
+
+    def initialize(data_source)
+      @data_source = data_source
+    end
+
+    def tables
+      return [] unless @data_source
+
+      adapter = DataSources::Adapter.for(@data_source)
+      adapter.tables.map do |table|
+        {
+          name: table,
+          columns: adapter.columns(table)
+        }
+      end
+    rescue StandardError => e
+      Rails.logger.error("[Nquery::SchemaExplorer] #{e.class}: #{e.message}\n#{e.backtrace&.first(8)&.join("\n")}")
+      []
+    end
+  end
+end

data/lib/nquery/seeder.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Nquery
+  class Seeder
+    def self.run!
+      new.run!
+    end
+
+    def run!
+      seed_sample_data!
+
+      admin_group = ensure_group!("Administrators", "administrators")
+      all_users_group = ensure_group!("All Users", "all_users")
+      engineering = ensure_group!("Engineering", "custom", "Engineering team")
+
+      admin = ensure_user!("admin@nquery.dev", "Admin", "User", "password123")
+      analyst = ensure_user!("analyst@nquery.dev", "Data", "Analyst", "password123")
+
+      [admin, analyst].each(&:ensure_all_users_membership!)
+      admin_group.group_memberships.find_or_create_by!(user: admin)
+      engineering.group_memberships.find_or_create_by!(user: analyst)
+
+      data_source = DataSource.find_or_create_by!(name: "Main Database") do |ds|
+        ds.adapter = "rails"
+        ds.connection_config = {}.to_json
+      end
+
+      root_collection = Collection.find_or_create_by!(name: "Our analytics", kind: "root")
+      admin.ensure_personal_collection!
+
+      seed_permissions!(admin_group, all_users_group, engineering, root_collection, data_source)
+
+      sample_tables = SampleData::Ecommerce::TABLES
+      query = Query.find_or_initialize_by(name: "Monthly revenue")
+      query.assign_attributes(
+        statement: <<~SQL.squish,
+          SELECT strftime('%Y-%m', #{sample_tables[:orders]}.ordered_at) AS month,
+                 ROUND(SUM(#{sample_tables[:order_items]}.quantity * #{sample_tables[:order_items]}.unit_price), 2) AS revenue
+          FROM #{sample_tables[:orders]}
+          INNER JOIN #{sample_tables[:order_items]} ON #{sample_tables[:order_items]}.order_id = #{sample_tables[:orders]}.id
+          GROUP BY strftime('%Y-%m', #{sample_tables[:orders]}.ordered_at)
+          ORDER BY month
+        SQL
+        data_source: data_source,
+        creator: admin,
+        collection: root_collection
+      )
+      query.save!
+
+      chart = Chart.find_or_create_by!(name: "Revenue by month") do |c|
+        c.query = query
+        c.collection = root_collection
+        c.creator = admin
+        c.visualization = { "type" => "bar", "x" => "month", "y" => "revenue" }
+      end
+
+      dashboard = Dashboard.find_or_create_by!(name: "Executive overview") do |d|
+        d.description = "Key metrics at a glance"
+        d.collection = root_collection
+        d.creator = admin
+      end
+
+      DashboardCard.find_or_create_by!(dashboard: dashboard, chart: chart) do |card|
+        card.pos_x = 0
+        card.pos_y = 0
+        card.width = 6
+        card.height = 4
+      end
+
+      EmbedTokenService.sign(
+        resource_type: "Nquery::Chart",
+        resource_id: chart.id,
+        creator: admin,
+        expires_at: 1.year.from_now
+      ) unless EmbedToken.exists?(resource_type: "Nquery::Chart", resource_id: chart.id)
+
+      ApplicationPermission::FEATURES.each do |feature|
+        ApplicationPermission.find_or_create_by!(group: admin_group, feature: feature) do |p|
+          p.access_level = "yes"
+        end
+      end
+    end
+
+    private
+
+    def seed_sample_data!
+      return unless Rails.env.local?
+
+      SampleData::Ecommerce.run!
+    end
+
+    def ensure_group!(name, system_group, description = nil)
+      Group.find_or_create_by!(system_group: system_group) do |g|
+        g.name = name
+        g.description = description
+      end
+    end
+
+    def ensure_user!(email, first_name, last_name, password)
+      User.find_or_create_by!(email: email) do |u|
+        u.first_name = first_name
+        u.last_name = last_name
+        u.password = password
+      end
+    end
+
+    def seed_permissions!(admin_group, all_users_group, engineering, root_collection, data_source)
+      CollectionPermission.find_or_create_by!(group: admin_group, collection: root_collection) do |p|
+        p.access_level = "curate"
+      end
+      CollectionPermission.find_or_create_by!(group: all_users_group, collection: root_collection) do |p|
+        p.access_level = "view"
+      end
+      CollectionPermission.find_or_create_by!(group: engineering, collection: root_collection) do |p|
+        p.access_level = "view"
+      end
+
+      [admin_group, all_users_group, engineering].each do |group|
+        level = group.system_group == "administrators" ? "can_view" : (group.system_group == "all_users" ? "can_view" : "blocked")
+        create_level = group.system_group == "administrators" ? "query_builder_and_native" : "no"
+
+        DataPermission.find_or_create_by!(group: group, data_source: data_source, permission_type: "view_data", resource_path: nil) do |p|
+          p.access_level = level
+        end
+        DataPermission.find_or_create_by!(group: group, data_source: data_source, permission_type: "create_queries", resource_path: nil) do |p|
+          p.access_level = create_level
+        end
+      end
+    end
+  end
+end

data/lib/nquery/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Nquery
+  VERSION = "0.1.0"
+end