permit-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2f70db526a9e0faffa1d423e5d6ebdc7561aecfffb2626e4f5350f351624153
+  data.tar.gz: 2414147d8ac281e8853405ca121d8cc32cddb9410a46f566cb0af5f2d60b62b9
+SHA512:
+  metadata.gz: 504f160a6ecf37c0bc4755a2a58d871832e25f16a36ba1590717bec092e3a49dc63963aa3eb5527a2bf3611ff66d57e6b3d954883b7a6b98bddb23fe9438b2dd
+  data.tar.gz: 4ba505adc4f43973e0c05461bb9bcaa30cd39ceff2f44d648f083d47b92f5671854e2e9fb481f3cf905dd75985fc5d145de5054e020e336244e618e736e4e09a

data/lib/api/api.rb

@@ -0,0 +1,25 @@
+require 'openapi_client'
+require_relative 'users'
+require_relative 'resources'
+require_relative 'utils'
+require_relative 'tenants'
+
+class PermitApiClient
+  attr_accessor :config, :logger, :client, :tenants, :resources, :roles, :users, :elements
+
+  def initialize(config, logger)
+
+    OpenapiClient.configure do |openapi_config|
+      openapi_config.scheme = Utils.get_schema_from_url(config.api_url)
+      openapi_config.host = Utils.get_host_from_url(config.api_url)
+      openapi_config.access_token = config.token
+    end
+    @config = config
+    @logger = logger
+    @users = UsersApi.new(OpenapiClient::UsersApi.new, config, logger)
+    @tenants = TenantsApi.new(OpenapiClient::TenantsApi.new, config, logger)
+    @resources = ResourcesApi.new(OpenapiClient::ResourcesApi.new, config, logger)
+    # @roles = RolesApi.new(OpenapiClient::RolesApi.new, config, logger)
+    # @elements = ElementsApi.new(OpenapiClient::ElementsConfigsApi.new, config, logger)
+  end
+end

data/lib/api/base.rb

@@ -0,0 +1,26 @@
+
+class PermitBaseApi
+  attr_accessor :client, :config, :logger
+
+  def lazy_load_context
+    # If the instance config context is nil, we need to load it from the server
+    OpenapiClient.configure do |openapi_config|
+      openapi_config.scheme = Utils.get_schema_from_url(config.api_url)
+      openapi_config.host = Utils.get_host_from_url(config.api_url)
+      openapi_config.access_token = config.token
+      openapi_config.server_operation_index = {}
+      openapi_config.server_index = nil
+    end
+    client = OpenapiClient::APIKeysApi.new
+    if @config.context.nil?
+      @config.context = client.get_api_key_scope
+    end
+  end
+
+  def initialize(client, config, logger)
+    @logger = logger
+    @config = config
+    @client = client
+  end
+
+end

data/lib/api/resources.rb

@@ -0,0 +1,13 @@
+require_relative 'base'
+
+class ResourcesApi < PermitBaseApi
+  def initialize(client, config, logger)
+    super
+  end
+
+  def get(resource_key)
+
+    data = @client.get_tenant(config.context.project, config.context.project, resource_key)
+    data
+  end
+end

data/lib/api/tenants.rb

@@ -0,0 +1,11 @@
+require_relative 'base'
+class TenantsApi < PermitBaseApi
+  def initialize(client, config, logger)
+    super
+  end
+
+  def get(tenant_key)
+    data = @client.get_tenant(config.context.project, config.context.project, tenant_key)
+    data
+  end
+end

data/lib/api/users.rb

@@ -0,0 +1,50 @@
+require_relative 'base'
+
+class UsersApi < PermitBaseApi
+  def initialize(client, config, logger)
+    super
+  end
+
+  def get(user_key)
+    lazy_load_context
+    data = @client.get_user(config.context.project_id, config.context.environment_id, user_key)
+    data
+  end
+
+
+  def sync_user(user)
+    lazy_load_context
+    raise KeyError.new("Required UserCreate or hash object") if user.is_a?(String)
+    user_key = user.is_a?(Hash) ? user.delete(:key) : user.key
+    raise KeyError.new("required 'key' in input dictionary") if user_key.nil?
+
+    # check if the user key already exists
+    logger.info("checking if user '#{user_key}' already exists")
+    begin
+      user_to_update = @client.get_user(config.context.project_id, config.context.environment_id, user_key)
+    rescue OpenapiClient::ApiError => e
+      if e.code == 404
+        # if the user does not exist, create it
+        logger.info("user does not exist, creating it...")
+        user_create = user.is_a?(Hash) ? OpenapiClient::UserCreate.new(user.merge("key" => user_key)) : user
+        created_user = @client.create_user(config.context.project_id, config.context.environment_id, user_create)
+        return created_user
+      else
+        raise e
+      end
+    end
+    if user_to_update
+      # if the user exists update it
+      logger.info("user exists, updating it...")
+      unless user.is_a?(Hash)
+        user = user.instance_variables.map { |var| [var.to_s.delete("@"), user.instance_variable_get(var)] }.to_h.except("key")
+      end
+      if user.empty?
+        raise "empty user object, nothing to update"
+      end
+      user_update =  OpenapiClient::UserUpdate.new(user)
+      updated_user = @client.update_user(config.context.project_id, config.context.environment_id, user_key, user_update)
+      return updated_user
+    end
+  end
+end

data/lib/api/utils.rb

@@ -0,0 +1,9 @@
+class Utils
+  def self.get_schema_from_url(url)
+    url.split(':')[0]
+  end
+
+  def self.get_host_from_url(url)
+    url.split(':')[1].split('/')[2]
+  end
+end

data/lib/config.rb

@@ -0,0 +1,23 @@
+class PermitConfig
+  #
+  # This class is used to configure the Permit SDK. It is used to set the base url of the PDP and the api key.
+  #
+  # Example:
+  #
+  # ```ruby
+  # permit = Permit::Permit.new
+  # permit.config.base_url = 'https://pdp.permit.io'
+  # permit.config
+  # ```
+  attr_accessor :api_url, :token, :pdp_url, :context, :debug, :logger
+
+  def initialize( token, api_url = DEFAULT_API_URL, pdp_url = DEFAULT_PDP_URL,context = nil, debug = false, logger = nil)
+    @api_url = api_url
+    @pdp_url = pdp_url
+    @context = context
+    @token = token
+    @debug = debug
+    @logger = logger
+  end
+
+end

data/lib/main.rb

@@ -0,0 +1,49 @@
+require 'webrick'
+require_relative 'permit'
+
+permit = Permit.new( "TOKEN")
+
+server = WEBrick::HTTPServer.new(Port: 3000)
+
+server.mount_proc '/' do |_, res|
+  res['Content-Type'] = 'application/json'
+  user = { id: "daniel@permit.io", first_name: nil, last_name: nil, email: "daniel@permit.io" }
+
+  permitted = permit.check("daniel@permit.io", "create", "Blog_Post")
+  if permitted
+    res.status = 200
+    res.body = { result: "#{user[:first_name]} #{user[:last_name]} is PERMITTED to create Blog_Post!" }.to_json
+    next
+  end
+  res.status = 403
+  res.body = { result: "#{user[:first_name]} #{user[:last_name]} is NOT PERMITTED to create Blog_Post!" }.to_json
+end
+
+trap 'INT' do server.shutdown end
+
+server.start
+
+
+# require_relative 'permit'
+# require_relative 'openapi_client/models/user_create'
+# permit = Permit.new('token')
+# a = permit.api.users.get("asdf12")
+# # allow = permit.check('daniel@permit.io', 'create', 'Blog_Post:123')
+# # if allow
+# #   puts "Allow"
+# # else
+# #   puts "Deny"
+# # end
+# #
+# # allow = permit.check({"key": "daniel@permit.io"}, 'create', {"type":"Blog_Post","tenant":"default", "key":"123"})
+# # if allow
+# #   puts "Allow"
+# # else
+# #   puts "Deny"
+# # end
+# user = OpenapiClient::UserCreate.new(key: "asdf1234", email: "raz@maiol.com", first_name: "Raz", last_name: "Ma")
+# a = permit.sync_user(user)
+# puts a
+#
+# a = permit.sync_user({ key: "asdf12345", email: "raz@maiol.com", first_name: "Raz", last_name: "Ma" })
+# puts a

data/lib/openapi_client/api/api_keys_api.rb

@@ -0,0 +1,413 @@
+=begin
+#Permit.io API
+
+# Authorization as a service 
+
+The version of the OpenAPI document: 2.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 6.2.1
+
+=end
+
+require 'cgi'
+
+module OpenapiClient
+  class APIKeysApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Create Api Key
+    # Creates a new api_key under the active organization.
+    # @param api_key_create [APIKeyCreate] 
+    # @param [Hash] opts the optional parameters
+    # @return [APIKeyRead]
+    def create_api_key(api_key_create, opts = {})
+      data, _status_code, _headers = create_api_key_with_http_info(api_key_create, opts)
+      data
+    end
+
+    # Create Api Key
+    # Creates a new api_key under the active organization.
+    # @param api_key_create [APIKeyCreate] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(APIKeyRead, Integer, Hash)>] APIKeyRead data, response status code and response headers
+    def create_api_key_with_http_info(api_key_create, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.create_api_key ...'
+      end
+      # verify the required parameter 'api_key_create' is set
+      if @api_client.config.client_side_validation && api_key_create.nil?
+        fail ArgumentError, "Missing the required parameter 'api_key_create' when calling APIKeysApi.create_api_key"
+      end
+      # resource path
+      local_var_path = '/v2/api-key'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(api_key_create)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'APIKeyRead'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.create_api_key",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#create_api_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Delete Api Key
+    # Deletes the api_key and all its related data.
+    # @param api_key_id [String] The unique id of the API key
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def delete_api_key(api_key_id, opts = {})
+      delete_api_key_with_http_info(api_key_id, opts)
+      nil
+    end
+
+    # Delete Api Key
+    # Deletes the api_key and all its related data.
+    # @param api_key_id [String] The unique id of the API key
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def delete_api_key_with_http_info(api_key_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.delete_api_key ...'
+      end
+      # verify the required parameter 'api_key_id' is set
+      if @api_client.config.client_side_validation && api_key_id.nil?
+        fail ArgumentError, "Missing the required parameter 'api_key_id' when calling APIKeysApi.delete_api_key"
+      end
+      # resource path
+      local_var_path = '/v2/api-key/{api_key_id}'.sub('{' + 'api_key_id' + '}', CGI.escape(api_key_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type]
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.delete_api_key",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#delete_api_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get Api Key
+    # Gets a single api_key matching the given api_key_id, if such api_key exists.
+    # @param api_key_id [String] The unique id of the API key
+    # @param [Hash] opts the optional parameters
+    # @return [APIKeyRead]
+    def get_api_key(api_key_id, opts = {})
+      data, _status_code, _headers = get_api_key_with_http_info(api_key_id, opts)
+      data
+    end
+
+    # Get Api Key
+    # Gets a single api_key matching the given api_key_id, if such api_key exists.
+    # @param api_key_id [String] The unique id of the API key
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(APIKeyRead, Integer, Hash)>] APIKeyRead data, response status code and response headers
+    def get_api_key_with_http_info(api_key_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.get_api_key ...'
+      end
+      # verify the required parameter 'api_key_id' is set
+      if @api_client.config.client_side_validation && api_key_id.nil?
+        fail ArgumentError, "Missing the required parameter 'api_key_id' when calling APIKeysApi.get_api_key"
+      end
+      # resource path
+      local_var_path = '/v2/api-key/{api_key_id}'.sub('{' + 'api_key_id' + '}', CGI.escape(api_key_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'APIKeyRead'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.get_api_key",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#get_api_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get Api Key Scope
+    # @param [Hash] opts the optional parameters
+    # @return [APIKeyScopeRead]
+    def get_api_key_scope(opts = {})
+      data, _status_code, _headers = get_api_key_scope_with_http_info(opts)
+      data
+    end
+
+    # Get Api Key Scope
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(APIKeyScopeRead, Integer, Hash)>] APIKeyScopeRead data, response status code and response headers
+    def get_api_key_scope_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.get_api_key_scope ...'
+      end
+      # resource path
+      local_var_path = '/v2/api-key/scope'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'APIKeyScopeRead'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.get_api_key_scope",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#get_api_key_scope\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get Environment Api Key
+    # @param proj_id [String] Either the unique id of the project, or the URL-friendly key of the project (i.e: the \&quot;slug\&quot;).
+    # @param env_id [String] Either the unique id of the environment, or the URL-friendly key of the environment (i.e: the \&quot;slug\&quot;).
+    # @param [Hash] opts the optional parameters
+    # @return [APIKeyRead]
+    def get_environment_api_key(proj_id, env_id, opts = {})
+      data, _status_code, _headers = get_environment_api_key_with_http_info(proj_id, env_id, opts)
+      data
+    end
+
+    # Get Environment Api Key
+    # @param proj_id [String] Either the unique id of the project, or the URL-friendly key of the project (i.e: the \&quot;slug\&quot;).
+    # @param env_id [String] Either the unique id of the environment, or the URL-friendly key of the environment (i.e: the \&quot;slug\&quot;).
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(APIKeyRead, Integer, Hash)>] APIKeyRead data, response status code and response headers
+    def get_environment_api_key_with_http_info(proj_id, env_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.get_environment_api_key ...'
+      end
+      # verify the required parameter 'proj_id' is set
+      if @api_client.config.client_side_validation && proj_id.nil?
+        fail ArgumentError, "Missing the required parameter 'proj_id' when calling APIKeysApi.get_environment_api_key"
+      end
+      # verify the required parameter 'env_id' is set
+      if @api_client.config.client_side_validation && env_id.nil?
+        fail ArgumentError, "Missing the required parameter 'env_id' when calling APIKeysApi.get_environment_api_key"
+      end
+      # resource path
+      local_var_path = '/v2/api-key/{proj_id}/{env_id}'.sub('{' + 'proj_id' + '}', CGI.escape(proj_id.to_s)).sub('{' + 'env_id' + '}', CGI.escape(env_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'APIKeyRead'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.get_environment_api_key",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#get_environment_api_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # List Api Keys
+    # Lists all the api_keys under the active organization.
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :page Page number of the results to fetch, starting at 1. (default to 1)
+    # @option opts [Integer] :per_page The number of results per page (max 100). (default to 30)
+    # @return [PaginatedResultAPIKeyRead]
+    def list_api_keys(opts = {})
+      data, _status_code, _headers = list_api_keys_with_http_info(opts)
+      data
+    end
+
+    # List Api Keys
+    # Lists all the api_keys under the active organization.
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :page Page number of the results to fetch, starting at 1. (default to 1)
+    # @option opts [Integer] :per_page The number of results per page (max 100). (default to 30)
+    # @return [Array<(PaginatedResultAPIKeyRead, Integer, Hash)>] PaginatedResultAPIKeyRead data, response status code and response headers
+    def list_api_keys_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: APIKeysApi.list_api_keys ...'
+      end
+      if @api_client.config.client_side_validation && !opts[:'page'].nil? && opts[:'page'] < 1
+        fail ArgumentError, 'invalid value for "opts[:"page"]" when calling APIKeysApi.list_api_keys, must be greater than or equal to 1.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'per_page'].nil? && opts[:'per_page'] > 100
+        fail ArgumentError, 'invalid value for "opts[:"per_page"]" when calling APIKeysApi.list_api_keys, must be smaller than or equal to 100.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'per_page'].nil? && opts[:'per_page'] < 1
+        fail ArgumentError, 'invalid value for "opts[:"per_page"]" when calling APIKeysApi.list_api_keys, must be greater than or equal to 1.'
+      end
+
+      # resource path
+      local_var_path = '/v2/api-key'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
+      query_params[:'per_page'] = opts[:'per_page'] if !opts[:'per_page'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PaginatedResultAPIKeyRead'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"APIKeysApi.list_api_keys",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: APIKeysApi#list_api_keys\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end