aurora-data-api 0.1.0

data/lib/aurora-data-api/model.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module AuroraDataApi
+  class Model
+    SCHEMA = {}
+    STRUCTS = {}
+
+    def self.model_name
+      to_s.to_sym
+    end
+
+    def self.literal_id(lit)
+      SCHEMA[model_name] ||= {}
+      SCHEMA[model_name][:literal_id] = lit
+    end
+
+    def self.table_name
+      SCHEMA.dig(model_name, :table_name)
+    end
+
+    def self.table(name)
+      SCHEMA[model_name] ||= {}
+      SCHEMA[model_name][:table_name] = name
+    end
+
+    def self.schema(&block)
+      block.call
+      STRUCTS[model_name] = Struct.new(model_name.to_s, *SCHEMA[model_name][:cols].keys)
+      table("#{name.to_s.downcase}s".to_sym) if table_name.nil?
+    end
+
+    def self.col(name, type, opt = {})
+      SCHEMA[model_name] ||= {}
+      SCHEMA[model_name][:cols] ||= {}
+      if type.is_a? Symbol
+        SCHEMA[model_name][:cols]["#{name}_#{SCHEMA[model_name][:literal_id] || :id}".to_sym] = {type: Integer}
+      end
+      SCHEMA[model_name][:cols][name] = {type: type, opt: opt}
+    end
+
+    def self.timestamp
+      col :created_at, Time, null: false
+      col :updated_at, Time, null: false
+    end
+
+    def self.relationship_by(table_sym)
+      result = Model::SCHEMA[name&.to_sym].select { |_k, v|
+        v.is_a? Hash
+      }.select { |_k, v|
+        v.dig(:opt, :table) == table_sym
+      }
+      result.count > 0 ? [result.keys[0], result.values[0][:type]] : nil
+    end
+
+    def initialize(**params)
+      @struct = STRUCTS[self.class.model_name].new
+      @timestamp = %i[created_at updated_at].all? { |m| members.include?(m) }
+      params.each do |col, val|
+        if col == literal_id
+          @id = val if val.is_a?(Integer)
+        else
+          @struct[col] = val
+        end
+      end
+    end
+
+    attr_reader :id, :timestamp
+
+    def set_timestamp(at:)
+      return false unless @timestamp
+      self.updated_at = Time.now
+      self.created_at = Time.now if at == :create
+      true
+    end
+
+    def members
+      [literal_id] + @struct.members
+    end
+
+    def respond_to_missing?(symbol, include_private)
+      # test-unit calls :encoding in assert_equal
+      !(%i[encoding].include? symbol)
+    end
+
+    def method_missing(method_name, *args, &block)
+      string_name = method_name.to_s
+      if string_name[-1] == "="
+        @struct[string_name.chop] = args[0]
+      elsif string_name[-3, 3] == "_#{literal_id}"
+        @struct[string_name.sub(/_#{literal_id}\z/, "")]&.id || @struct[method_name]
+      elsif method_name == literal_id
+        @id
+      elsif members.include?(method_name)
+        if @struct[method_name].nil?
+          col_id = "#{method_name}_#{literal_id}".to_sym
+          if members.include?(col_id) && @struct[col_id]
+            col_model = SCHEMA[self.class.name&.to_sym][:cols].dig(method_name, :type)
+            return nil unless col_model
+            @struct[method_name] = AuroraDataApi.const_get("#{col_model}Depot".to_sym).select(
+              %(where "#{literal_id}" = :id), id: @struct[col_id]
+            )[0]
+          end
+        else
+          @struct[method_name]
+        end
+      else
+        super
+      end
+    end
+
+    def table_name
+      SCHEMA[self.class.name&.to_sym][:table_name]
+    end
+
+    def literal_id
+      SCHEMA[self.class.model_name][:literal_id] || :id
+    end
+
+    def build_params(include_id: false)
+      {}.tap do |hash|
+        members.each do |member|
+          next if member == literal_id && !include_id
+          next if SCHEMA[self.class.name&.to_sym][:cols][member][:type].is_a? Symbol
+          send(member).then { |v| hash[member] = v }
+        end
+      end
+    end
+
+    def attributes
+      {}.tap do |hash|
+        members.each do |member|
+          next if member.to_s.match?(/_#{literal_id}\z/)
+          send(member).then do |v|
+            hash[member] = v.is_a?(Model) ? v.attributes : v
+          end
+        end
+      end
+    end
+
+    def _set_id(id)
+      @id = id
+    end
+
+    def _destroy
+      @id = nil
+      @struct.members.each do |member|
+        @struct[member] = nil unless member == literal_id
+      end
+      true
+    end
+  end
+end

data/lib/aurora-data-api/version.rb

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

data/lib/aurora-data-api.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "aurora-data-api/version"
+require_relative "aurora-data-api/model"
+require_relative "aurora-data-api/depot"
+require_relative "aurora-data-api/data_service"
+
+module AuroraDataApi
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+class Date
+end

data/sig/aurora-data-api.rbs

@@ -0,0 +1,20 @@
+module AuroraDataApi
+  Error: StandardError
+end
+
+class Date
+end
+
+module Aws
+  def self.config: -> Hash[Symbol, untyped]
+
+  class Credentials
+    def initialize: (String, String) -> untyped
+  end
+
+  module RDSDataService
+    class Client
+      def initialize: (Hash[Symbol, String]) -> void
+    end
+  end
+end

data/sig/data_service.rbs

@@ -0,0 +1,7 @@
+module AuroraDataApi
+  class DataService
+    def initialize: () -> void
+    def execute: (Hash[Symbol, untyped] hash, ?bool without_database) -> untyped
+    def offline_config_update: () -> void
+  end
+end

data/sig/depot.rbs

@@ -0,0 +1,23 @@
+# TypeProf 0.21.2
+
+# Classes
+module AuroraDataApi
+  class Depot
+    @model: untyped
+    @data_service: DataService
+    @table_name: String
+    @literal_id: Symbol
+
+    def self.[]: (singleton(Model) model) -> Depot
+    def initialize: (singleton(Model) model, Proc block) -> void
+    def table_name: -> String
+    def literal_id: -> Symbol
+    def insert: (Model obj) -> untyped
+    def update: (Model obj) -> true
+    def delete: (Model obj) -> true
+    def count: (?String str, **untyped) -> Integer
+    def select: (String str, **untyped) -> untyped
+    def column_data: (untyped meta, untyped col) -> untyped
+    def query: (String str, **untyped) -> untyped
+  end
+end

data/sig/environment.rbs

@@ -0,0 +1,13 @@
+# TypeProf 0.21.2
+
+# Classes
+module AuroraDataApi
+  class Environment
+    def self.offline?: -> bool
+    def self.offline_endpoint: -> String
+    def self.database_name: -> String?
+    def self.region: -> String
+    def self.secret_arn: -> String?
+    def self.resource_arn: -> String?
+  end
+end

data/sig/model.rbs

@@ -0,0 +1,39 @@
+# TypeProf 0.21.2
+
+# Classes
+module AuroraDataApi
+  class Model
+    SCHEMA: Hash[untyped, untyped]
+    STRUCTS: Hash[untyped, untyped]
+    @struct: untyped
+
+    def self.model_name: -> Symbol
+    def self.literal_id: (Symbol lit) -> Symbol
+    def self.table: (Symbol name) -> Symbol
+    def self.table_name: -> Symbol
+    def self.schema: () { () -> void } -> void
+    def self.col: (Symbol name, singleton(String) | singleton(Time) | singleton(Date) | singleton(Integer) | Symbol type, ?Hash[Symbol, Symbol | bool] opt) -> void
+    def self.timestamp: -> void
+    def self.relationship_by: (Symbol table_sym) -> [untyped, untyped]?
+    def initialize: (**Hash[Symbol, untyped]) -> void
+
+    attr_reader id: Integer?
+    attr_reader timestamp: bool
+    attr_accessor created_at: Time
+    attr_accessor updated_at: Time
+
+    def set_timestamp: (at: :update | :create) -> bool
+    def members: -> Array[Symbol]
+    def respond_to_missing?: (untyped symbol, untyped include_private) -> true
+    def method_missing: (untyped method_name, *untyped args) -> nil
+    def table_name: -> Symbol
+    def literal_id: -> Symbol
+    def build_params: (?include_id: bool) -> Hash[Symbol, untyped]
+    def attributes: -> Hash[Symbol, untyped]
+    def _set_id: (Integer? id) -> void
+    def _destroy: -> bool
+  end
+end
+
+class AnonymousStruct_generated_1 < Struct[untyped]
+end

data/sig/version.rbs

@@ -0,0 +1,3 @@
+module AuroraDataApi
+  VERSION: String
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: aurora-data-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HASUMI Hitoshi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-rdsdataservice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.35.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.35.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Assuming you are using AWS Lambda as a backend, Aurora Serverless v1
+  (NOT v2) as a database, and Data API as an adapter
+email:
+- hasumikin@gmail.com
+executables:
+- aurora-data-api
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rake_tasks~"
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- aurora-data-api.gemspec
+- example/.gitignore
+- example/.ruby-version
+- example/Dockerfile
+- example/Gemfile
+- example/Gemfile.lock
+- example/README.md
+- example/Rakefile
+- example/app/depots/comment_depot.rb
+- example/app/depots/entry_depot.rb
+- example/app/depots/user_depot.rb
+- example/app/handlers/main.rb
+- example/app/models/comment.rb
+- example/app/models/entry.rb
+- example/app/models/user.rb
+- example/compose.yml
+- example/db/.gitignore
+- example/db/.keep
+- example/package-lock.json
+- example/package.json
+- example/serverless.yml
+- exe/aurora-data-api
+- lib/aurora-data-api.rb
+- lib/aurora-data-api/data_service.rb
+- lib/aurora-data-api/depot.rb
+- lib/aurora-data-api/environment.rb
+- lib/aurora-data-api/model.rb
+- lib/aurora-data-api/version.rb
+- sig/aurora-data-api.rbs
+- sig/data_service.rbs
+- sig/depot.rbs
+- sig/environment.rbs
+- sig/model.rbs
+- sig/version.rbs
+homepage: https://github.com/hasumikin/aurora-data-api
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/hasumikin/aurora-data-api
+  source_code_uri: https://github.com/hasumikin/aurora-data-api
+  changelog_uri: https://github.com/hasumikin/aurora-data-api/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.14
+signing_key:
+specification_version: 4
+summary: A kind of ORM for Amazon Aurora Serverless v1
+test_files: []