bas 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f5359b994975192b92fe8582bd37c23e9ce212bbe7d90bd9b93566421f88cd2
-  data.tar.gz: 3d8a0d0f9a8ea9529f3538600a471d32506fa865d45c8e1621d1d3851b6a5682
+  metadata.gz: b15ef30bfbc91578e5b2ef5bf19861f9bda796d0296faa65ae80cd2244521655
+  data.tar.gz: 34775b96d78ee72c66a1d7501020d810030bbf6fc0396ec12e0aa39ed58d3735
 SHA512:
-  metadata.gz: d88b0b00ca6da83a2168051a685d60bea43766ec677285e129ced8e48dc55660203b8c7994e347f3e043e898838ed6e3910f9e5271f78e22e219a035929f85f9
-  data.tar.gz: 0a01df01e758f0b97931debeedc150045c1ba5f0978fe475ae775139fed7ed1d622cf66f17740f098ddfabf1d29a48511b83cffb67a97316b0dfeea51b2e5694
+  metadata.gz: 7f74a4e1963f29cd2f7cc5d5847d4215cd403281394711570d6c612771ed7036ada74941cd449f1c8c1faf82b7d6f33bb0941ce81b4c39884a240404637e6d6d
+  data.tar.gz: 82c7867b2b3af0a16f3ca4780c796bff3ed3ae3e27d5b6e31d91731d2dea7bc367ebd4ac9ad39e54b98c56ef3f686e9bdf5411e54c8dd7fe6359356ca7809e48

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+# 1.0.0 (17.05.2024)
+- [Refactor Project Architecture](https://github.com/kommitters/bas/issues/35)
+- [Refactor PTO today Use Case](https://github.com/kommitters/bas/issues/29)
+- [Refactor PTO next week Use Case](https://github.com/kommitters/bas/issues/30)
+- [Refactor Birthday today Use Case](https://github.com/kommitters/bas/issues/31)
+- [Refactor Birthday next week Use Case](https://github.com/kommitters/bas/issues/32)
+- [Refactor WIP limit Use Case](https://github.com/kommitters/bas/issues/33)
+- [Refactor support email Use Case](https://github.com/kommitters/bas/issues/34)
+- [Add a garbage collector](https://github.com/kommitters/bas/issues/42)
+- [Update read Postgres component](https://github.com/kommitters/bas/issues/45)
+- [Update new table structure](https://github.com/kommitters/bas/issues/46)
+
 # 0.4.0 (19.04.2024)
 - [[BAS] Add process for OpenAI](https://github.com/kommitters/bas/issues/25)
 

data/README.md

@@ -1,8 +1,8 @@
 # BAS - Business Automation System
 
-Many organizations and individuals rely on automation across various contexts in their daily operations. With BAS, we aim to provide an open-source platform that empowers users to create customized automation systems tailored to their unique requirements. BAS consists of a series of abstract components designed to facilitate the creation of diverse use cases, regardless of context.
+Many organizations and individuals rely on automation across various contexts in their daily operations. With BAS, we aim to provide an open-source platform that empowers users to create customized automation systems tailored to their unique requirements. BAS consists of a series of abstract components designed to facilitate the creation of diverse bots, regardless of context.
 
-The underlying idea is to develop generic components that can serve a wide range of needs, this approach ensures that all members of the community can leverage the platform's evolving suite of components and use cases to their advantage.
+The underlying idea is to develop generic components that can serve a wide range of needs, this approach ensures that all members of the community can leverage the platform's evolving suite of components and bots to their advantage.
 
 ![Gem Version](https://img.shields.io/gem/v/bas?style=for-the-badge)
 ![Gem Total Downloads](https://img.shields.io/gem/dt/bas?style=for-the-badge)
@@ -26,59 +26,38 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 * Ruby 2.6.0 or higher
 
-## Building my own use case
+## BOT
+A bot is a tool in charge of executing a specific automation task. The pipeline of a bot consists of reading from a data source, processing a specific task, and then writing a result in storage.
 
-The gem provides with basic interfaces, types, and methods to shape your own use cases in an easy way.
+## Use case
+A use case is an automation problem greater than the one managed by a single bot. A use case comprises a set of bots that are agnostic between them and each one solves a specific task (parts of the automation problem). To connect the bots, a shared storage should be used. This shared storage could be a PostgresDB database, an S3 bucket, or any kind of storage where the bots will read and write data so another bot can use it to execute their tasks.
 
-There are 7 currently implemented use cases:
-* Birthday notifications - from Notion to Discord
-* Next Week Birthday notifications - from Notion to Discord
-* PTO notifications - from Notion to Discord
-* Next Week PTO notifications - from Notion to Discord
-* PTO notifications - from Postgres to Slack
-* WIP limit exceeded - from Notion to Discord
-* Support email notification - from IMAP to Discord
+For example, a system to notify birthdays in a company (automation problem) can be solved with three bots: one to fetch the data from an external data source, one to format the birthday message, and the last one to notify somewhere.
 
-For this example we'll analyze the birthday notification use case, bringing data from a notion database, and sending the
-notifications to a Discord channel.
+## Building my own BOT
 
-A *Use Case* object, consists on 5 main components, having it's own responsibility:
+The gem provides with basic interfaces, types, and methods to shape your own bot in an easy way. Since the process of reading and writing in a shared storage is separated from the main task, two base classes were defined to deal with this executions, leaving the logic of the specific task in the bot file.
 
-### 1. Read - Obtaining the data
+### 1. Read - Obtaining the data from the Shared Storage
 
-Specifically, a reader is an object in charged of bringing data from a data source. The gem already provides the base interface
-for building your own reader for your specific data source, or rely on already built classes if they match your purpose.
+Specifically, a reader is an object in charged of bringing data from a shared storage. The gem already provides the base interface
+for building your own reader for your specific shared storage, or rely on already built classes if they match your purpose.
 
-The base interface for a reader can be found under the `bas/read/base.rb` class. Since this is a implementation of the `Read::Base`
-for bringing data from a Notion database, it was created on a new namespace for that data source, it can be found under
-`/bas/read/notion/use_case/birthday_today.rb`. It implements specific logic for reading the data and validating the response.
+The base interface for a reader can be found under the `bas/read/base.rb` class.
 
-### 2. Serialize - Shaping it
+### 2. Write - Apply changes in a shared storage
+The **Write** is in charge of creating or updating information in a shared storage. This is the last step for every BOT. These changes can be a transaction in a database, adding files in a cloud storage, or simply creating logs.
 
-The **Serializer** responsibility, is to shape the data using custom types from the app domain, bringing it into a
-common structure understandable for other components, specifically the **Formatter**.
+The base interface for a writer can be found under the `bas/write/base.rb` class.
 
-Because of the use case, the Serializer implementation for it, relies on specific types for representing a Birthday it self. It can be found
-under `/bas/serialize/notion/birthday_today.rb`
+### 3. Bot - Solve a specific automation task
+The bot execute the logic to solve an specific task. For this, it can use the data from the read step, and then returns a processed response to be wrote by the write component. Every bot reads from a shared storage and writes in a shared storage.
 
-### 3. Formatter - Preparing the message
-
-The **Formatter**, is in charge of preparing the message to be sent in our notification, and give it the right format with the right data.
-The template or 'format' to be used should be included in the use case configurations, which we'll review in a further step. It's
-implementation can be found under `/bas/formatter/birthday.rb`.
-
-### 4. Process - Optional Data Process
-
-Finally, the **Process** basically, allow required data process depending on the use case like sending formatted messages into a destination. In this case, since the use case was implemented for
-Discord, it implements specific logic to communicate with a Discord channel using a webhook. The webhook configuration and name for the 'Sender'
-in the channel should be provided with the initial use case configurations. It can be found under `/bas/process/discord/implementation.rb`
-
-### 5. Write - Apply changes in a destination
-Finally, the **Write** is in charge of creating or updating information in a destination. This is the last step in the pipeline, and it aims to allow the users to apply changes in a destination depending on the use case. These changes can be a transaction in a database, adding files in a cloud storage, or simply creating logs. For the Birthday use case, after the Process sends the notification, the Write creates a Log in the `$stdout`. It can be found under `lib/bas/write/logs/use_case/console_log.rb`
+The base interface for a bot can be found under the `bas/bot/base.rb` class.
 
 ## Examples
 
-In this example, we demonstrate how to instantiate a birthday notification use case and execute it in a basic Ruby project. We'll also cover its deployment in a serverless configuration, specifically using a simple Lambda deployment.
+In this example, we demonstrate how to instantiate a birthday notification bot and execute it in a basic Ruby project. We'll also cover its deployment in a serverless configuration, specifically using a simple Lambda deployment.
 
 ### Preparing the configurations
 
@@ -94,74 +73,37 @@ With the following formula for the **BD_this_year** column: `dateAdd(prop("BD"),
 
 * A Notion secret, which can be obtained, by creating an integration here: `https://developers.notion.com/`, browsing on the **View my integrations** option, and selecting the **New Integration** or **Create new integration** buttons.
 
-* A webhook key, which can be generated directly on discord on the desired channel, following this instructions: `https://support.discord.com/hc/en-us/articles/228383668-Intro-to-Webhooks`
-
-* A filter, to determine which data to bring from the database, for this specific case, the filter we used is:
-
-```
-#### file.rb ####
-today = Date.now
-{
-    "filter": {
-      "or": [
-        {
-          "property": "BD_this_year",
-          "date": {
-            "equals": today
-          }
-        }
-      ]
-    },
-    "sorts": []
-}
-```
-
-* A template for the formatter to be used for formatting the payload to be send to Discord. For this specific case, the format of the messages should be:
-
-`"NAME, Wishing you a very happy birthday! Enjoy your special day! :birthday: :gift:"`
-
-### Instantiating the Use Case
+### Instantiating the FetchBirthdayFromNotion Bot
 
-To instantiate the use case, the `UseCases` module should provide a method for this purpose, for this specific case, the `notify_birthday_from_notion_to_discord`
-is the desired one.
+The specific bot can be found in the `bas/bot/fetch_birthdays_from_notion.rb` file.
 
 **Normal ruby code**
 ```
-filter = {
-    "filter": {
-      "or": [
-        {
-          "property": "BD_this_year",
-          "date": {
-            "equals": today
-          }
-        }
-      ]
-    },
-    "sorts": []
-}
-
 options = {
-    read_options: {
-      base_url: "https://api.notion.com",
-      database_id: NOTION_DATABASE_ID,
-      secret: NOTION_API_INTEGRATION_SECRET,
-      filter: filter
+  process_options: {
+    database_id: "notion database id",
+    secret: "notion secret"
+  },
+  write_options: {
+    connection: {
+      host: "host",
+      port: 5432,
+      dbname: "bas",
+      user: "postgres",
+      password: "postgres"
     },
-    process_options: {
-      webhook: "https://discord.com/api/webhooks/1199213527672565760/KmpoIzBet9xYG16oFh8W1RWHbpIqT7UtTBRrhfLcvWZdNiVZCTM-gpil2Qoy4eYEgpdf",
-      name: "Birthday Bot"
-    }
+    db_table: "use_cases",
+    bot_name: "FetchBirthdaysFromNotion"
+  }
 }
 
-use_case = UseCases.notify_birthday_from_notion_to_discord(options)
-
-use_case.perform
+bot = Bot::FetchBirthdaysFromNotion.new(options)
+bot.execute
 
 ```
 
 ### Serverless
-We'll explain how to configure and deploy a use case with serverless, this example will cover the PTO's notifications use case.
+We'll explain how to configure and deploy a bot with serverless.
 
 #### Configuring environment variables
 Create the environment variables configuration file.
@@ -173,15 +115,11 @@ cp env.yml.example env.yml
 And put the following env variables
 ```
 dev:
-  NOTION_DATABASE_ID: NOTION_DATABASE_ID
-  NOTION_SECRET: NOTION_SECRET
-  DISCORD_WEBHOOK: DISCORD_WEBHOOK
-  DISCORD_BOT_NAME: DISCORD_BOT_NAME
+  BIRTHDAY_NOTION_DATABASE_ID: "BIRTHDAY_NOTION_DATABASE_ID"
+  BIRTHDAY_NOTION_SECRET: "BIRTHDAY_NOTION_SECRET"
 prod:
-  NOTION_DATABASE_ID: NOTION_DATABASE_ID
-  NOTION_SECRET: NOTION_SECRET
-  DISCORD_WEBHOOK: DISCORD_WEBHOOK
-  DISCORD_BOT_NAME: DISCORD_BOT_NAME
+  BIRTHDAY_NOTION_DATABASE_ID: "BIRTHDAY_NOTION_DATABASE_ID"
+  BIRTHDAY_NOTION_SECRET: "BIRTHDAY_NOTION_SECRET"
 
 ```
 
@@ -225,60 +163,45 @@ On your serverless configuration, create your lambda function, on your serverles
 ```ruby
 # frozen_string_literal: true
 
-require 'bas'
+require 'bas/bot/fetch_birthdays_from_notion'
 
 # Initialize the environment variables
-NOTION_BASE_URL = 'https://api.notion.com'
-NOTION_DATABASE_ID = ENV.fetch('PTO_NOTION_DATABASE_ID')
-NOTION_SECRET = ENV.fetch('PTO_NOTION_SECRET')
-DISCORD_WEBHOOK = ENV.fetch('PTO_DISCORD_WEBHOOK')
-DISCORD_BOT_NAME = ENV.fetch('PTO_DISCORD_BOT_NAME')
+NOTION_DATABASE_ID = ENV.fetch('NOTION_DATABASE_ID')
+NOTION_SECRET = ENV.fetch('NOTION_SECRET')
 
 module Notifier
   # Service description
   class UseCaseName
     def self.notify(*)
-      options = { read_options:, process_options: }
+      options = { process_options: , write_options: }
 
       begin
-        use_case = UseCases.use_case_build_function(options)
+        use_case = Bot::FetchBirthdaysFromNotion.new(options)
 
-        use_case.perform
+        use_case.execute
       rescue StandardError => e
         { body: { message: e.message } }
       end
     end
 
-    def self.read_options
-      {
-        base_url: NOTION_BASE_URL,
-        database_id: NOTION_DATABASE_ID,
-        secret: NOTION_SECRET,
-        filter: {
-          filter: { "and": read_filter }
-        }
-      }
-    end
-
-    def self.read_filter
-      today = Common::TimeZone.set_colombia_time_zone.strftime('%F').to_s
-
-      [
-        { property: 'Desde?', date: { on_or_before: today } },
-        { property: 'Hasta?', date: { on_or_after: today } }
-      ]
-    end
-
     def self.process_options
       {
-        webhook: DISCORD_WEBHOOK,
-        name: DISCORD_BOT_NAME
+        database_id: NOTION_DATABASE_ID,
+        secret: NOTION_SECRET
       }
     end
 
-    def self.format_options
+    def self.write_options
       {
-        template: ':beach: individual_name is on PTO'
+        connection: {
+          host: "host",
+          port: 5432,
+          dbname: "bas",
+          user: "postgres",
+          password: "postgres"
+        },
+        db_table: "use_cases",
+        bot_name: "FetchBirthdaysFromNotion"
       }
     end
   end
@@ -290,18 +213,16 @@ In the `serverless.yml` file, add a new instance in the `functions` block with t
 
 ```bash
 functions:
-  ptoNotification:
-    handler: src/lambdas/pto_notification.Notifier::PTO.notify
+  fetchBirthdayFromNotion:
+    handler: src/lambdas/birthday_fetch.Bot::Birthday.fetch
     environment:
-      PTO_NOTION_DATABASE_ID: ${file(./env.yml):${env:STAGE}.PTO_NOTION_DATABASE_ID}
-      PTO_NOTION_SECRET: ${file(./env.yml):${env:STAGE}.PTO_NOTION_SECRET}
-      PTO_DISCORD_WEBHOOK: ${file(./env.yml):${env:STAGE}.PTO_DISCORD_WEBHOOK}
-      PTO_DISCORD_BOT_NAME: ${file(./env.yml):${env:STAGE}.DISCORD_BOT_NAME}
+      BIRTHDAY_NOTION_DATABASE_ID: ${file(./env.yml):${env:STAGE}.BIRTHDAY_NOTION_DATABASE_ID}
+      BIRTHDAY_NOTION_SECRET: ${file(./env.yml):${env:STAGE}.BIRTHDAY_NOTION_SECRET}
     events:
       - schedule:
-          name: pto-daily-notification
-          description: "Notify every 24 hours at 8:30 a.m (UTC-5) from monday to friday"
-          rate: cron(${file(./env.yml):${env:STAGE}.PTO_SCHEDULER})
+          name: birthday-fetch
+          description: "Fetch every 24 hours at 8:30 a.m (UTC-5) from monday to friday"
+          rate: cron(${file(./env.yml):${env:STAGE}.BIRTHDAY_FETCH_SCHEDULER})
           enabled: true
 ```
 

data/lib/bas/bot/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../utils/exceptions/function_not_implemented"
+require_relative "../utils/exceptions/invalid_process_response"
+require_relative "../write/postgres_update"
+
+module Bot
+  ##
+  # The Bot::Base class serves as the foundation for implementing specific bots. Operating
+  # as an interface, this class defines essential attributes and methods, providing a blueprint
+  # for creating custom bots formed by a Read, Process, and Write components.
+  #
+  class Base
+    attr_reader :read_options, :process_options, :write_options
+    attr_accessor :read_response, :process_response, :write_response
+
+    def initialize(config)
+      @read_options = config[:read_options] || {}
+      @process_options = config[:process_options] || {}
+      @write_options = config[:write_options] || {}
+    end
+
+    def execute
+      @read_response = read
+
+      write_read_response_in_process
+
+      @process_response = process
+      raise Utils::Exceptions::InvalidProcessResponse unless process_response.is_a?(Hash)
+
+      write_read_response_processed
+
+      @write_response = write
+    end
+
+    protected
+
+    def read
+      raise Utils::Exceptions::FunctionNotImplemented
+    end
+
+    def process
+      raise Utils::Exceptions::FunctionNotImplemented
+    end
+
+    def write
+      raise Utils::Exceptions::FunctionNotImplemented
+    end
+
+    def unprocessable_response
+      read_data = read_response.data
+
+      read_data.nil? || read_data == {} || read_data.any? { |_key, value| [[], ""].include?(value) }
+    end
+
+    private
+
+    def write_read_response_in_process
+      return if read_options[:avoid_process].eql?(true) || read_response.id.nil?
+
+      options = { params: { stage: "in process" }, conditions: "id=#{read_response.id}" }
+
+      Write::PostgresUpdate.new(read_options.merge(options)).execute
+    end
+
+    def write_read_response_processed
+      return if read_options[:avoid_process].eql?(true) || read_response.id.nil?
+
+      options = { params: { stage: "processed" }, conditions: "id=#{read_response.id}" }
+
+      Write::PostgresUpdate.new(read_options.merge(options)).execute
+    end
+  end
+end

data/lib/bas/bot/compare_wip_limit_count.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::CompareWipLimitCount class serves as a bot implementation to read domains wip limits and
+  # counts from a PostgresDB database, compare the values to find exceeded counts, and write them on
+  # a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FetchDomainsWipLimitFromNotion"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "CompareWipLimitCount"
+  #     }
+  #   }
+  #
+  #   bot = Bot::CompareWipLimitCount.new(options)
+  #   bot.execute
+  #
+  class CompareWipLimitCount < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to compare the domains wip counts and limits
+    #
+    def process
+      return { success: { exceeded_domain_count: {} } } if unprocessable_response
+
+      domains_limits = read_response.data["domains_limits"]
+      domain_wip_count = read_response.data["domain_wip_count"]
+
+      exceeded_domain_count = exceedded_counts(domains_limits, domain_wip_count)
+
+      { success: { exceeded_domain_count: } }
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def exceedded_counts(limits, counts)
+      counts.to_a.map do |domain_wip_count|
+        domain, count = domain_wip_count
+        domain_limit = limits[domain]
+
+        { domain:, exceeded: count - domain_limit } if count > domain_limit
+      end.compact
+    end
+  end
+end

data/lib/bas/bot/fetch_birthdays_from_notion.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchBirthdaysFromNotion class serves as a bot implementation to read birthdays from a
+  # notion database and write them on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     process_options: {
+  #       database_id: "notion database id",
+  #       secret: "notion secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FetchBirthdaysFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchBirthdaysFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchBirthdaysFromNotion < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to execute the Notion utility to fetch birthdays from a notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        birthdays_list = normalize_response(response.parsed_response["results"])
+
+        { success: { birthdays: birthdays_list } }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # Write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 ORDER BY inserted_at DESC",
+        params: [false, read_options[:tag]]
+      }
+    end
+
+    def params
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      today = Time.now.utc.strftime("%F").to_s
+
+      {
+        filter: {
+          and: [{ property: "BD_this_year", date: { equals: today } }] + last_edited_condition
+        }
+      }
+    end
+
+    def last_edited_condition
+      return [] if read_response.inserted_at.nil?
+
+      [
+        {
+          timestamp: "last_edited_time",
+          last_edited_time: { on_or_after: read_response.inserted_at }
+        }
+      ]
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |value|
+        birthday_fields = value["properties"]
+
+        {
+          "name" => extract_rich_text_field_value(birthday_fields["Complete Name"]),
+          "birthday_date" => extract_date_field_value(birthday_fields["BD_this_year"])
+        }
+      end
+    end
+
+    def extract_rich_text_field_value(data)
+      data["rich_text"][0]["plain_text"]
+    end
+
+    def extract_date_field_value(data)
+      data["formula"]["date"]["start"]
+    end
+  end
+end