From 072dbf6e6696d3f9b0a53c0993392f7c275834f7 Mon Sep 17 00:00:00 2001 From: Haim Kortovich Date: Thu, 5 Mar 2026 11:35:01 -0500 Subject: [PATCH] WIP --- .envrc | 1 + .formatter.exs | 5 + .gitignore | 27 +++++ AGENTS.md | 111 ++++++++++++++++++ README.md | 18 +++ config/config.exs | 48 ++++++++ config/dev.exs | 73 ++++++++++++ config/prod.exs | 17 +++ config/runtime.exs | 102 ++++++++++++++++ config/test.exs | 31 +++++ docker-compose.yml | 23 ++++ flake.lock | 60 ++++++++++ flake.nix | 25 ++++ lib/customer_service.ex | 9 ++ lib/customer_service/aggregates/customer.ex | 44 +++++++ lib/customer_service/application.ex | 36 ++++++ lib/customer_service/commanded_app.ex | 15 +++ lib/customer_service/commands.ex | 11 ++ lib/customer_service/event_store.ex | 3 + lib/customer_service/events.ex | 12 ++ lib/customer_service/projections/customer.ex | 28 +++++ lib/customer_service/projectors/customer.ex | 31 +++++ lib/customer_service/repo.ex | 13 ++ lib/customer_service_web.ex | 63 ++++++++++ lib/customer_service_web/api_spec.ex | 24 ++++ .../controllers/customer.ex | 84 +++++++++++++ .../controllers/error_json.ex | 21 ++++ lib/customer_service_web/endpoint.ex | 49 ++++++++ lib/customer_service_web/router.ex | 15 +++ lib/customer_service_web/schemas/customer.ex | 38 ++++++ lib/customer_service_web/telemetry.ex | 93 +++++++++++++++ mix.exs | 75 ++++++++++++ mix.lock | 34 ++++++ priv/repo/migrations/.formatter.exs | 4 + .../20260224165602_add_customer_table.exs | 19 +++ ...60224175717_create_projection_versions.exs | 12 ++ priv/repo/seeds.exs | 11 ++ priv/static/favicon.ico | Bin 0 -> 152 bytes priv/static/robots.txt | 5 + .../controllers/error_json_test.exs | 12 ++ test/support/conn_case.ex | 38 ++++++ test/support/data_case.ex | 58 +++++++++ test/test_helper.exs | 2 + 43 files changed, 1400 insertions(+) create mode 100644 .envrc create mode 100644 .formatter.exs create mode 100644 .gitignore create mode 100644 AGENTS.md create mode 100644 README.md create mode 100644 config/config.exs create mode 100644 config/dev.exs create mode 100644 config/prod.exs create mode 100644 config/runtime.exs create mode 100644 config/test.exs create mode 100644 docker-compose.yml create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 lib/customer_service.ex create mode 100644 lib/customer_service/aggregates/customer.ex create mode 100644 lib/customer_service/application.ex create mode 100644 lib/customer_service/commanded_app.ex create mode 100644 lib/customer_service/commands.ex create mode 100644 lib/customer_service/event_store.ex create mode 100644 lib/customer_service/events.ex create mode 100644 lib/customer_service/projections/customer.ex create mode 100644 lib/customer_service/projectors/customer.ex create mode 100644 lib/customer_service/repo.ex create mode 100644 lib/customer_service_web.ex create mode 100644 lib/customer_service_web/api_spec.ex create mode 100644 lib/customer_service_web/controllers/customer.ex create mode 100644 lib/customer_service_web/controllers/error_json.ex create mode 100644 lib/customer_service_web/endpoint.ex create mode 100644 lib/customer_service_web/router.ex create mode 100644 lib/customer_service_web/schemas/customer.ex create mode 100644 lib/customer_service_web/telemetry.ex create mode 100644 mix.exs create mode 100644 mix.lock create mode 100644 priv/repo/migrations/.formatter.exs create mode 100644 priv/repo/migrations/20260224165602_add_customer_table.exs create mode 100644 priv/repo/migrations/20260224175717_create_projection_versions.exs create mode 100644 priv/repo/seeds.exs create mode 100644 priv/static/favicon.ico create mode 100644 priv/static/robots.txt create mode 100644 test/customer_service_web/controllers/error_json_test.exs create mode 100644 test/support/conn_case.ex create mode 100644 test/support/data_case.ex create mode 100644 test/test_helper.exs diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.formatter.exs b/.formatter.exs new file mode 100644 index 0000000..429bacc --- /dev/null +++ b/.formatter.exs @@ -0,0 +1,5 @@ +[ + import_deps: [:ecto, :ecto_sql, :phoenix, :open_api_spex], + subdirectories: ["priv/*/migrations"], + inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}", "priv/*/seeds.exs"] +] diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ad0ff01 --- /dev/null +++ b/.gitignore @@ -0,0 +1,27 @@ +# The directory Mix will write compiled artifacts to. +/_build/ + +# If you run "mix test --cover", coverage assets end up here. +/cover/ + +# The directory Mix downloads your dependencies sources to. +/deps/ + +# Where 3rd-party dependencies like ExDoc output generated docs. +/doc/ + +# Ignore .fetch files in case you like to edit your project deps locally. +/.fetch + +# If the VM crashes, it generates a dump, let's ignore it too. +erl_crash.dump + +# Also ignore archive artifacts (built via "mix archive.build"). +*.ez + +# Temporary files, for example, from tests. +/tmp/ + +# Ignore package tarball (built via "mix hex.build"). +customer_service-*.tar + diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..a51acdd --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,111 @@ +This is a web application written using the Phoenix web framework. + +## Project guidelines + +- Use `mix precommit` alias when you are done with all changes and fix any pending issues +- Use the already included and available `:req` (`Req`) library for HTTP requests, **avoid** `:httpoison`, `:tesla`, and `:httpc`. Req is included by default and is the preferred HTTP client for Phoenix apps + +### Phoenix v1.8 guidelines + +- **Always** begin your LiveView templates with `` which wraps all inner content +- The `MyAppWeb.Layouts` module is aliased in the `my_app_web.ex` file, so you can use it without needing to alias it again +- Anytime you run into errors with no `current_scope` assign: + - You failed to follow the Authenticated Routes guidelines, or you failed to pass `current_scope` to `` + - **Always** fix the `current_scope` error by moving your routes to the proper `live_session` and ensure you pass `current_scope` as needed +- Phoenix v1.8 moved the `<.flash_group>` component to the `Layouts` module. You are **forbidden** from calling `<.flash_group>` outside of the `layouts.ex` module +- Out of the box, `core_components.ex` imports an `<.icon name="hero-x-mark" class="w-5 h-5"/>` component for for hero icons. **Always** use the `<.icon>` component for icons, **never** use `Heroicons` modules or similar +- **Always** use the imported `<.input>` component for form inputs from `core_components.ex` when available. `<.input>` is imported and using it will save steps and prevent errors +- If you override the default input classes (`<.input class="myclass px-2 py-1 rounded-lg">)`) class with your own values, no default classes are inherited, so your +custom classes must fully style the input + + + + + +## Elixir guidelines + +- Elixir lists **do not support index based access via the access syntax** + + **Never do this (invalid)**: + + i = 0 + mylist = ["blue", "green"] + mylist[i] + + Instead, **always** use `Enum.at`, pattern matching, or `List` for index based list access, ie: + + i = 0 + mylist = ["blue", "green"] + Enum.at(mylist, i) + +- Elixir variables are immutable, but can be rebound, so for block expressions like `if`, `case`, `cond`, etc + you *must* bind the result of the expression to a variable if you want to use it and you CANNOT rebind the result inside the expression, ie: + + # INVALID: we are rebinding inside the `if` and the result never gets assigned + if connected?(socket) do + socket = assign(socket, :val, val) + end + + # VALID: we rebind the result of the `if` to a new variable + socket = + if connected?(socket) do + assign(socket, :val, val) + end + +- **Never** nest multiple modules in the same file as it can cause cyclic dependencies and compilation errors +- **Never** use map access syntax (`changeset[:field]`) on structs as they do not implement the Access behaviour by default. For regular structs, you **must** access the fields directly, such as `my_struct.field` or use higher level APIs that are available on the struct if they exist, `Ecto.Changeset.get_field/2` for changesets +- Elixir's standard library has everything necessary for date and time manipulation. Familiarize yourself with the common `Time`, `Date`, `DateTime`, and `Calendar` interfaces by accessing their documentation as necessary. **Never** install additional dependencies unless asked or for date/time parsing (which you can use the `date_time_parser` package) +- Don't use `String.to_atom/1` on user input (memory leak risk) +- Predicate function names should not start with `is_` and should end in a question mark. Names like `is_thing` should be reserved for guards +- Elixir's builtin OTP primitives like `DynamicSupervisor` and `Registry`, require names in the child spec, such as `{DynamicSupervisor, name: MyApp.MyDynamicSup}`, then you can use `DynamicSupervisor.start_child(MyApp.MyDynamicSup, child_spec)` +- Use `Task.async_stream(collection, callback, options)` for concurrent enumeration with back-pressure. The majority of times you will want to pass `timeout: :infinity` as option + +## Mix guidelines + +- Read the docs and options before using tasks (by using `mix help task_name`) +- To debug test failures, run tests in a specific file with `mix test test/my_test.exs` or run all previously failed tests with `mix test --failed` +- `mix deps.clean --all` is **almost never needed**. **Avoid** using it unless you have good reason + +## Test guidelines + +- **Always use `start_supervised!/1`** to start processes in tests as it guarantees cleanup between tests +- **Avoid** `Process.sleep/1` and `Process.alive?/1` in tests + - Instead of sleeping to wait for a process to finish, **always** use `Process.monitor/1` and assert on the DOWN message: + + ref = Process.monitor(pid) + assert_receive {:DOWN, ^ref, :process, ^pid, :normal} + + - Instead of sleeping to synchronize before the next call, **always** use `_ = :sys.get_state/1` to ensure the process has handled prior messages + + + +## Phoenix guidelines + +- Remember Phoenix router `scope` blocks include an optional alias which is prefixed for all routes within the scope. **Always** be mindful of this when creating routes within a scope to avoid duplicate module prefixes. + +- You **never** need to create your own `alias` for route definitions! The `scope` provides the alias, ie: + + scope "/admin", AppWeb.Admin do + pipe_through :browser + + live "/users", UserLive, :index + end + + the UserLive route would point to the `AppWeb.Admin.UserLive` module + +- `Phoenix.View` no longer is needed or included with Phoenix, don't use it + + + +## Ecto Guidelines + +- **Always** preload Ecto associations in queries when they'll be accessed in templates, ie a message that needs to reference the `message.user.email` +- Remember `import Ecto.Query` and other supporting modules when you write `seeds.exs` +- `Ecto.Schema` fields always use the `:string` type, even for `:text`, columns, ie: `field :name, :string` +- `Ecto.Changeset.validate_number/2` **DOES NOT SUPPORT the `:allow_nil` option**. By default, Ecto validations only run if a change for the given field exists and the change value is not nil, so such as option is never needed +- You **must** use `Ecto.Changeset.get_field(changeset, :field)` to access changeset fields +- Fields which are set programatically, such as `user_id`, must not be listed in `cast` calls or similar for security purposes. Instead they must be explicitly set when creating the struct +- **Always** invoke `mix ecto.gen.migration migration_name_using_underscores` when generating migration files, so the correct timestamp and conventions are applied + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..349431a --- /dev/null +++ b/README.md @@ -0,0 +1,18 @@ +# CustomerService + +To start your Phoenix server: + +* Run `mix setup` to install and setup dependencies +* Start Phoenix endpoint with `mix phx.server` or inside IEx with `iex -S mix phx.server` + +Now you can visit [`localhost:4000`](http://localhost:4000) from your browser. + +Ready to run in production? Please [check our deployment guides](https://hexdocs.pm/phoenix/deployment.html). + +## Learn more + +* Official website: https://www.phoenixframework.org/ +* Guides: https://hexdocs.pm/phoenix/overview.html +* Docs: https://hexdocs.pm/phoenix +* Forum: https://elixirforum.com/c/phoenix-forum +* Source: https://github.com/phoenixframework/phoenix diff --git a/config/config.exs b/config/config.exs new file mode 100644 index 0000000..01811b2 --- /dev/null +++ b/config/config.exs @@ -0,0 +1,48 @@ +# This file is responsible for configuring your application +# and its dependencies with the aid of the Config module. +# +# This configuration file is loaded before any dependency and +# is restricted to this project. + +# General application configuration +import Config + +config :customer_service, + ecto_repos: [CustomerService.Repo], + event_stores: [CustomerService.EventStore] + +config :customer_service, CustomerServiceWeb.Endpoint, + url: [host: "localhost"], + adapter: Bandit.PhoenixAdapter, + render_errors: [ + formats: [json: CustomerServiceWeb.ErrorJSON], + layout: false + ], + pubsub_server: CustomerService.PubSub, + live_view: [signing_salt: "zPStCmh9"] + +# Configure Elixir's Logger +config :logger, :default_formatter, + format: "$time $metadata[$level] $message\n", + metadata: [:request_id] + +# Use Jason for JSON parsing in Phoenix +config :phoenix, :json_library, Jason + +config :customer_service, CustomerService.CommandedApp, + event_store: [ + adapter: Commanded.EventStore.Adapters.EventStore, + event_store: CustomerService.EventStore + ], + pub_sub: :local, + registry: :local + +config :commanded, + event_store_adapter: Commanded.EventStore.Adapters.EventStore + +config :commanded_ecto_projections, + repo: CustomerService.Repo + +# Import environment specific config. This must remain at the bottom +# of this file so it overrides the configuration defined above. +import_config "#{config_env()}.exs" diff --git a/config/dev.exs b/config/dev.exs new file mode 100644 index 0000000..df19cf2 --- /dev/null +++ b/config/dev.exs @@ -0,0 +1,73 @@ +import Config + +config :customer_service, CustomerService.EventStore, + serializer: Commanded.Serialization.JsonSerializer, + username: "postgres", + password: "postgres", + database: "customer_service_eventstore_dev", + hostname: "localhost", + pool_size: 10 + +# Configure your database +config :customer_service, CustomerService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "customer_service_dev", + stacktrace: true, + show_sensitive_data_on_connection_error: true, + pool_size: 10 + +# For development, we disable any cache and enable +# debugging and code reloading. +# +# The watchers configuration can be used to run external +# watchers to your application. For example, we can use it +# to bundle .js and .css sources. +config :customer_service, CustomerServiceWeb.Endpoint, + # Binding to loopback ipv4 address prevents access from other machines. + # Change to `ip: {0, 0, 0, 0}` to allow access from other machines. + http: [ip: {127, 0, 0, 1}], + check_origin: false, + code_reloader: true, + debug_errors: true, + secret_key_base: "rSPVNB6DCC2RMMlmk9QkCVGAzasUD6AWh5ussctvNuUxgZL9DRnFXTo6jcIz6JpB", + watchers: [] + +# ## SSL Support +# +# In order to use HTTPS in development, a self-signed +# certificate can be generated by running the following +# Mix task: +# +# mix phx.gen.cert +# +# Run `mix help phx.gen.cert` for more information. +# +# The `http:` config above can be replaced with: +# +# https: [ +# port: 4001, +# cipher_suite: :strong, +# keyfile: "priv/cert/selfsigned_key.pem", +# certfile: "priv/cert/selfsigned.pem" +# ], +# +# If desired, both `http:` and `https:` keys can be +# configured to run both http and https servers on +# different ports. + +# Enable dev routes for dashboard and mailbox +config :customer_service, dev_routes: true + +# Do not include metadata nor timestamps in development logs +config :logger, :default_formatter, format: "[$level] $message\n" + +# Set a higher stacktrace during development. Avoid configuring such +# in production as building large stacktraces may be expensive. +config :phoenix, :stacktrace_depth, 20 + +# Initialize plugs at runtime for faster development compilation +config :phoenix, :plug_init_mode, :runtime + +config :open_api_spex, :cache_adapter, OpenApiSpex.Plug.NoneCache diff --git a/config/prod.exs b/config/prod.exs new file mode 100644 index 0000000..ccf568a --- /dev/null +++ b/config/prod.exs @@ -0,0 +1,17 @@ +import Config + +# Force using SSL in production. This also sets the "strict-security-transport" header, +# known as HSTS. If you have a health check endpoint, you may want to exclude it below. +# Note `:force_ssl` is required to be set at compile-time. +config :customer_service, CustomerServiceWeb.Endpoint, + force_ssl: [rewrite_on: [:x_forwarded_proto]], + exclude: [ + # paths: ["/health"], + hosts: ["localhost", "127.0.0.1"] + ] + +# Do not print debug messages in production +config :logger, level: :info + +# Runtime production configuration, including reading +# of environment variables, is done on config/runtime.exs. diff --git a/config/runtime.exs b/config/runtime.exs new file mode 100644 index 0000000..9a089ed --- /dev/null +++ b/config/runtime.exs @@ -0,0 +1,102 @@ +import Config + +# config/runtime.exs is executed for all environments, including +# during releases. It is executed after compilation and before the +# system starts, so it is typically used to load production configuration +# and secrets from environment variables or elsewhere. Do not define +# any compile-time configuration in here, as it won't be applied. +# The block below contains prod specific runtime configuration. + +# ## Using releases +# +# If you use `mix release`, you need to explicitly enable the server +# by passing the PHX_SERVER=true when you start it: +# +# PHX_SERVER=true bin/customer_service start +# +# Alternatively, you can use `mix phx.gen.release` to generate a `bin/server` +# script that automatically sets the env var above. +if System.get_env("PHX_SERVER") do + config :customer_service, CustomerServiceWeb.Endpoint, server: true +end + +config :customer_service, CustomerServiceWeb.Endpoint, + http: [port: String.to_integer(System.get_env("PORT", "4000"))] + +if config_env() == :prod do + database_url = + System.get_env("DATABASE_URL") || + raise """ + environment variable DATABASE_URL is missing. + For example: ecto://USER:PASS@HOST/DATABASE + """ + + maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: [] + + config :customer_service, CustomerService.Repo, + # ssl: true, + url: database_url, + pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10"), + # For machines with several cores, consider starting multiple pools of `pool_size` + # pool_count: 4, + socket_options: maybe_ipv6 + + # The secret key base is used to sign/encrypt cookies and other secrets. + # A default value is used in config/dev.exs and config/test.exs but you + # want to use a different value for prod and you most likely don't want + # to check this value into version control, so we use an environment + # variable instead. + secret_key_base = + System.get_env("SECRET_KEY_BASE") || + raise """ + environment variable SECRET_KEY_BASE is missing. + You can generate one by calling: mix phx.gen.secret + """ + + host = System.get_env("PHX_HOST") || "example.com" + + config :customer_service, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY") + + config :customer_service, CustomerServiceWeb.Endpoint, + url: [host: host, port: 443, scheme: "https"], + http: [ + # Enable IPv6 and bind on all interfaces. + # Set it to {0, 0, 0, 0, 0, 0, 0, 1} for local network only access. + # See the documentation on https://hexdocs.pm/bandit/Bandit.html#t:options/0 + # for details about using IPv6 vs IPv4 and loopback vs public addresses. + ip: {0, 0, 0, 0, 0, 0, 0, 0} + ], + secret_key_base: secret_key_base + + # ## SSL Support + # + # To get SSL working, you will need to add the `https` key + # to your endpoint configuration: + # + # config :customer_service, CustomerServiceWeb.Endpoint, + # https: [ + # ..., + # port: 443, + # cipher_suite: :strong, + # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"), + # certfile: System.get_env("SOME_APP_SSL_CERT_PATH") + # ] + # + # The `cipher_suite` is set to `:strong` to support only the + # latest and more secure SSL ciphers. This means old browsers + # and clients may not be supported. You can set it to + # `:compatible` for wider support. + # + # `:keyfile` and `:certfile` expect an absolute path to the key + # and cert in disk or a relative path inside priv, for example + # "priv/ssl/server.key". For all supported SSL configuration + # options, see https://hexdocs.pm/plug/Plug.SSL.html#configure/1 + # + # We also recommend setting `force_ssl` in your config/prod.exs, + # ensuring no data is ever sent via http, always redirecting to https: + # + # config :customer_service, CustomerServiceWeb.Endpoint, + # force_ssl: [hsts: true] + # + # Check `Plug.SSL` for all available options in `force_ssl`. +end diff --git a/config/test.exs b/config/test.exs new file mode 100644 index 0000000..41dc029 --- /dev/null +++ b/config/test.exs @@ -0,0 +1,31 @@ +import Config + +# Configure your database +# +# The MIX_TEST_PARTITION environment variable can be used +# to provide built-in test partitioning in CI environment. +# Run `mix help test` for more information. +config :customer_service, CustomerService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "customer_service_test#{System.get_env("MIX_TEST_PARTITION")}", + pool: Ecto.Adapters.SQL.Sandbox, + pool_size: System.schedulers_online() * 2 + +# We don't run a server during test. If one is required, +# you can enable the server option below. +config :customer_service, CustomerServiceWeb.Endpoint, + http: [ip: {127, 0, 0, 1}, port: 4002], + secret_key_base: "5XFY5h177fHai1B8WyArxreTVj0T8OX5WgpRoQVlTSmdM5dINx1rQMkDRqn1Hniy", + server: false + +# Print only warnings and errors during test +config :logger, level: :warning + +# Initialize plugs at runtime for faster test compilation +config :phoenix, :plug_init_mode, :runtime + +# Sort query params output of verified routes for robust url comparisons +config :phoenix, + sort_verified_routes_query_params: true diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..aade169 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,23 @@ +version: "3.9" + +services: + postgres: + image: postgres:16-alpine + container_name: customer_postgres + restart: unless-stopped + environment: + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + POSTGRES_DB: customer_service_dev + ports: + - "5432:5432" + volumes: + - customer_pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U postgres"] + interval: 5s + timeout: 5s + retries: 5 + +volumes: + customer_pg_data: diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..91efd4f --- /dev/null +++ b/flake.lock @@ -0,0 +1,60 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1771950615, + "narHash": "sha256-Iqc6kksbvnjrg/9WYWGlOFw9J3o6/W5kBki4PvJp7X0=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "f6f08216301df30f2acab89c39506c296ac10c21", + "type": "github" + }, + "original": { + "owner": "nixos", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..1f49a87 --- /dev/null +++ b/flake.nix @@ -0,0 +1,25 @@ +{ + description = "test"; + + inputs = { + nixpkgs.url = "github:nixos/nixpkgs"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, nixpkgs, flake-utils, ... }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + + in { + devShell = + pkgs.mkShell { + buildInputs = with pkgs; + [ + elixir + elixir-ls + git + ]; + }; + }); +} diff --git a/lib/customer_service.ex b/lib/customer_service.ex new file mode 100644 index 0000000..d66446a --- /dev/null +++ b/lib/customer_service.ex @@ -0,0 +1,9 @@ +defmodule CustomerService do + @moduledoc """ + CustomerService keeps the contexts that define your domain + and business logic. + + Contexts are also responsible for managing your data, regardless + if it comes from the database, an external API or others. + """ +end diff --git a/lib/customer_service/aggregates/customer.ex b/lib/customer_service/aggregates/customer.ex new file mode 100644 index 0000000..8b3ff4f --- /dev/null +++ b/lib/customer_service/aggregates/customer.ex @@ -0,0 +1,44 @@ +defmodule CustomerService.Aggregates.Customer do + defstruct [ + :id, + :first_name, + :last_name, + :birth_date, + :gender, + :email, + :phone + ] + + alias __MODULE__ + alias Commanded.Aggregates.Aggregate + alias CustomerService.Commands + alias CustomerService.Events + + @behaviour Aggregate + @impl Aggregate + def execute(%Customer{id: nil}, %Commands.CreateCustomer{} = cmd) do + %Events.CustomerCreated{ + id: cmd.id, + first_name: cmd.first_name, + last_name: cmd.last_name, + birth_date: cmd.birth_date, + gender: cmd.gender, + email: cmd.email, + phone: cmd.phone + } + end + + @impl Aggregate + def apply(%Customer{} = c, %Events.CustomerCreated{} = e) do + %Customer{ + c + | id: e.id, + first_name: e.first_name, + last_name: e.last_name, + birth_date: e.birth_date, + gender: e.gender, + email: e.email, + phone: e.phone + } + end +end diff --git a/lib/customer_service/application.ex b/lib/customer_service/application.ex new file mode 100644 index 0000000..83dd94c --- /dev/null +++ b/lib/customer_service/application.ex @@ -0,0 +1,36 @@ +defmodule CustomerService.Application do + # See https://hexdocs.pm/elixir/Application.html + # for more information on OTP Applications + @moduledoc false + + use Application + + @impl true + def start(_type, _args) do + children = [ + CustomerService.CommandedApp, + CustomerService.Repo, + CustomerService.Projectors.Customer, + CustomerServiceWeb.Telemetry, + {DNSCluster, query: Application.get_env(:customer_service, :dns_cluster_query) || :ignore}, + {Phoenix.PubSub, name: CustomerService.PubSub}, + # Start a worker by calling: CustomerService.Worker.start_link(arg) + # {CustomerService.Worker, arg}, + # Start to serve requests, typically the last entry + CustomerServiceWeb.Endpoint + ] + + # See https://hexdocs.pm/elixir/Supervisor.html + # for other strategies and supported options + opts = [strategy: :one_for_one, name: CustomerService.Supervisor] + Supervisor.start_link(children, opts) + end + + # Tell Phoenix to update the endpoint configuration + # whenever the application is updated. + @impl true + def config_change(changed, _new, removed) do + CustomerServiceWeb.Endpoint.config_change(changed, removed) + :ok + end +end diff --git a/lib/customer_service/commanded_app.ex b/lib/customer_service/commanded_app.ex new file mode 100644 index 0000000..37d3510 --- /dev/null +++ b/lib/customer_service/commanded_app.ex @@ -0,0 +1,15 @@ +defmodule CustomerService.Router do + use Commanded.Commands.Router + alias CustomerService.Commands + alias CustomerService.Aggregates + + identify(Aggregates.Customer, by: :id) + dispatch([Commands.CreateCustomer], to: Aggregates.Customer) +end + +defmodule CustomerService.CommandedApp do + use Commanded.Application, + otp_app: :customer_service + + router(CustomerService.Router) +end diff --git a/lib/customer_service/commands.ex b/lib/customer_service/commands.ex new file mode 100644 index 0000000..93c8a04 --- /dev/null +++ b/lib/customer_service/commands.ex @@ -0,0 +1,11 @@ +defmodule CustomerService.Commands.CreateCustomer do + defstruct [ + :id, + :first_name, + :last_name, + :birth_date, + :gender, + :email, + :phone + ] +end diff --git a/lib/customer_service/event_store.ex b/lib/customer_service/event_store.ex new file mode 100644 index 0000000..94ad94d --- /dev/null +++ b/lib/customer_service/event_store.ex @@ -0,0 +1,3 @@ +defmodule CustomerService.EventStore do + use EventStore, otp_app: :customer_service +end diff --git a/lib/customer_service/events.ex b/lib/customer_service/events.ex new file mode 100644 index 0000000..69ddc59 --- /dev/null +++ b/lib/customer_service/events.ex @@ -0,0 +1,12 @@ +defmodule CustomerService.Events.CustomerCreated do + @derive Jason.Encoder + defstruct [ + :id, + :first_name, + :last_name, + :birth_date, + :gender, + :email, + :phone + ] +end diff --git a/lib/customer_service/projections/customer.ex b/lib/customer_service/projections/customer.ex new file mode 100644 index 0000000..d81e075 --- /dev/null +++ b/lib/customer_service/projections/customer.ex @@ -0,0 +1,28 @@ +defmodule CustomerService.Projections.Customer do + use Ecto.Schema + + @derive {Jason.Encoder, + only: [ + :id, + :first_name, + :last_name, + :birth_date, + :gender, + :email, + :phone, + :inserted_at, + :updated_at + ]} + @primary_key {:id, :binary_id, autogenerate: false} + @timestamps_opts [type: :utc_datetime_usec] + schema "customers" do + field :first_name, :string + field :last_name, :string + field :birth_date, :date + field :gender, :string + field :email, :string + field :phone, :string + + timestamps() + end +end diff --git a/lib/customer_service/projectors/customer.ex b/lib/customer_service/projectors/customer.ex new file mode 100644 index 0000000..bf2d67e --- /dev/null +++ b/lib/customer_service/projectors/customer.ex @@ -0,0 +1,31 @@ +defmodule CustomerService.Projectors.Customer do + use Commanded.Projections.Ecto, + application: CustomerService.CommandedApp, + repo: CustomerService.Repo, + name: "CustomerService.Projetors.Customer", + consistency: :strong + + alias CustomerService.Events + alias CustomerService.Projections.Customer + + project(%Events.CustomerCreated{} = event, fn multi -> + Ecto.Multi.insert(multi, :customer, %Customer{ + id: event.id, + first_name: event.first_name, + last_name: event.last_name, + birth_date: event.birth_date, + gender: event.gender, + email: event.email, + phone: event.phone + }) + end) + + # project %Events.CustomerDeactivated{} = event, _metadata do + # Ecto.Multi.update_all( + # multi, + # :deactivate_customer, + # from(c in Customer, where: c.customer_id == ^event.customer_id), + # set: [active: false] + # ) + # end +end diff --git a/lib/customer_service/repo.ex b/lib/customer_service/repo.ex new file mode 100644 index 0000000..b00d5c7 --- /dev/null +++ b/lib/customer_service/repo.ex @@ -0,0 +1,13 @@ +defmodule CustomerService.Repo do + use Ecto.Repo, + otp_app: :customer_service, + adapter: Ecto.Adapters.Postgres + + @doc """ + Dynamically loads the repository url from the + DATABASE_URL environment variable. + """ + def init(_, opts) do + {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))} + end +end diff --git a/lib/customer_service_web.ex b/lib/customer_service_web.ex new file mode 100644 index 0000000..132891b --- /dev/null +++ b/lib/customer_service_web.ex @@ -0,0 +1,63 @@ +defmodule CustomerServiceWeb do + @moduledoc """ + The entrypoint for defining your web interface, such + as controllers, components, channels, and so on. + + This can be used in your application as: + + use CustomerServiceWeb, :controller + use CustomerServiceWeb, :html + + The definitions below will be executed for every controller, + component, etc, so keep them short and clean, focused + on imports, uses and aliases. + + Do NOT define functions inside the quoted expressions + below. Instead, define additional modules and import + those modules here. + """ + + def static_paths, do: ~w(assets fonts images favicon.ico robots.txt) + + def router do + quote do + use Phoenix.Router, helpers: false + + # Import common connection and controller functions to use in pipelines + import Plug.Conn + import Phoenix.Controller + end + end + + def channel do + quote do + use Phoenix.Channel + end + end + + def controller do + quote do + use Phoenix.Controller, formats: [:html, :json] + + import Plug.Conn + + unquote(verified_routes()) + end + end + + def verified_routes do + quote do + use Phoenix.VerifiedRoutes, + endpoint: CustomerServiceWeb.Endpoint, + router: CustomerServiceWeb.Router, + statics: CustomerServiceWeb.static_paths() + end + end + + @doc """ + When used, dispatch to the appropriate controller/live_view/etc. + """ + defmacro __using__(which) when is_atom(which) do + apply(__MODULE__, which, []) + end +end diff --git a/lib/customer_service_web/api_spec.ex b/lib/customer_service_web/api_spec.ex new file mode 100644 index 0000000..625f3c3 --- /dev/null +++ b/lib/customer_service_web/api_spec.ex @@ -0,0 +1,24 @@ +defmodule CustomerServiceWeb.ApiSpec do + alias OpenApiSpex.{OpenApi, Info, Server} + alias OpenApiSpex.{Info, OpenApi, Paths, Server} + alias CustomerServiceWeb.{Endpoint, Router} + @behaviour OpenApi + + @impl OpenApi + def spec do + %OpenApi{ + servers: [ + # Populate the Server info from a phoenix endpoint + Server.from_endpoint(Endpoint) + ], + info: %Info{ + title: "Customer Service", + version: "1.0" + }, + # Populate the paths from a phoenix router + paths: Paths.from_router(Router) + } + # Discover request/response schemas from path specs + |> OpenApiSpex.resolve_schema_modules() + end +end diff --git a/lib/customer_service_web/controllers/customer.ex b/lib/customer_service_web/controllers/customer.ex new file mode 100644 index 0000000..ed31589 --- /dev/null +++ b/lib/customer_service_web/controllers/customer.ex @@ -0,0 +1,84 @@ +defmodule CustomerServiceWeb.Customer do + use CustomerServiceWeb, :controller + + alias CustomerServiceWeb.Schemas.CreateCustomerRequest + alias CustomerServiceWeb.Schemas.CustomerResponse + alias CustomerService.Commands.CreateCustomer + alias CustomerService.CommandedApp + use OpenApiSpex.ControllerSpecs + + tags ["Customers"] + + operation :create, + summary: "Create customer", + request_body: {"Customer data", "application/json", CreateCustomerRequest}, + responses: [ + ok: {"Customer created", "application/json", CustomerResponse} + ] + + def create(conn, params) do + customer_id = Ecto.UUID.generate() + + command = + %CreateCustomer{ + id: customer_id, + first_name: params["first_name"], + last_name: params["last_name"], + birth_date: Date.from_iso8601!(params["birth_date"]), + gender: params["gender"], + email: params["email"], + phone: params["phone"] + } + + case CommandedApp.dispatch(command, consistency: :strong) do + :ok -> + json(conn, %{id: customer_id}) + + {:error, reason} -> + conn + |> put_status(:unprocessable_entity) + |> json(%{error: inspect(reason)}) + end + end + + operation :show, + summary: "Get customer", + parameters: [ + id: [in: :path, type: :string, description: "Customer ID"] + ], + responses: [ + ok: {"Customer", "application/json", CustomerResponse}, + not_found: {"Not found", "application/json", nil} + ] + + def show(conn, %{"id" => id}) do + case CustomerService.Repo.get(CustomerService.Projections.Customer, id) do + nil -> + send_resp(conn, 404, "") + + customer -> + json(conn, customer) + end + end + + operation :index, + summary: "List customers", + responses: [ + ok: + {"Customer list", "application/json", + %OpenApiSpex.Schema{ + type: :array, + items: CustomerResponse + }} + ] + + def index(conn, _) do + case CustomerService.Repo.all(CustomerService.Projections.Customer) do + nil -> + send_resp(conn, 404, "") + + customer -> + json(conn, customer) + end + end +end diff --git a/lib/customer_service_web/controllers/error_json.ex b/lib/customer_service_web/controllers/error_json.ex new file mode 100644 index 0000000..c3b1d42 --- /dev/null +++ b/lib/customer_service_web/controllers/error_json.ex @@ -0,0 +1,21 @@ +defmodule CustomerServiceWeb.ErrorJSON do + @moduledoc """ + This module is invoked by your endpoint in case of errors on JSON requests. + + See config/config.exs. + """ + + # If you want to customize a particular status code, + # you may add your own clauses, such as: + # + # def render("500.json", _assigns) do + # %{errors: %{detail: "Internal Server Error"}} + # end + + # By default, Phoenix returns the status message from + # the template name. For example, "404.json" becomes + # "Not Found". + def render(template, _assigns) do + %{errors: %{detail: Phoenix.Controller.status_message_from_template(template)}} + end +end diff --git a/lib/customer_service_web/endpoint.ex b/lib/customer_service_web/endpoint.ex new file mode 100644 index 0000000..fbecc79 --- /dev/null +++ b/lib/customer_service_web/endpoint.ex @@ -0,0 +1,49 @@ +defmodule CustomerServiceWeb.Endpoint do + use Phoenix.Endpoint, otp_app: :customer_service + + # The session will be stored in the cookie and signed, + # this means its contents can be read but not tampered with. + # Set :encryption_salt if you would also like to encrypt it. + @session_options [ + store: :cookie, + key: "_customer_service_key", + signing_salt: "2Ese9Ehj", + same_site: "Lax" + ] + + # socket "/live", Phoenix.LiveView.Socket, + # websocket: [connect_info: [session: @session_options]], + # longpoll: [connect_info: [session: @session_options]] + + # Serve at "/" the static files from "priv/static" directory. + # + # When code reloading is disabled (e.g., in production), + # the `gzip` option is enabled to serve compressed + # static files generated by running `phx.digest`. + plug Plug.Static, + at: "/", + from: :customer_service, + gzip: not code_reloading?, + only: CustomerServiceWeb.static_paths(), + raise_on_missing_only: code_reloading? + + # Code reloading can be explicitly enabled under the + # :code_reloader configuration of your endpoint. + if code_reloading? do + plug Phoenix.CodeReloader + plug Phoenix.Ecto.CheckRepoStatus, otp_app: :customer_service + end + + plug Plug.RequestId + plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint] + + plug Plug.Parsers, + parsers: [:urlencoded, :multipart, :json], + pass: ["*/*"], + json_decoder: Phoenix.json_library() + + plug Plug.MethodOverride + plug Plug.Head + plug Plug.Session, @session_options + plug CustomerServiceWeb.Router +end diff --git a/lib/customer_service_web/router.ex b/lib/customer_service_web/router.ex new file mode 100644 index 0000000..0d7ff27 --- /dev/null +++ b/lib/customer_service_web/router.ex @@ -0,0 +1,15 @@ +defmodule CustomerServiceWeb.Router do + use CustomerServiceWeb, :router + + pipeline :api do + plug CORSPlug, origin: "*" + plug OpenApiSpex.Plug.PutApiSpec, module: CustomerServiceWeb.ApiSpec + end + + scope "/api" do + pipe_through :api + + resources "/customers", CustomerServiceWeb.Customer, only: [:create, :index, :show] + get "/openapi", OpenApiSpex.Plug.RenderSpec, [] + end +end diff --git a/lib/customer_service_web/schemas/customer.ex b/lib/customer_service_web/schemas/customer.ex new file mode 100644 index 0000000..4f6c8f5 --- /dev/null +++ b/lib/customer_service_web/schemas/customer.ex @@ -0,0 +1,38 @@ +defmodule CustomerServiceWeb.Schemas do + defmodule CustomerResponse do + require OpenApiSpex + alias OpenApiSpex.Schema + + OpenApiSpex.schema(%{ + title: "Customer", + type: :object, + properties: %{ + id: %Schema{type: :string, format: :uuid}, + first_name: %Schema{type: :string}, + last_name: %Schema{type: :string}, + birth_date: %Schema{type: :string, format: :date}, + gender: %Schema{type: :string}, + email: %Schema{type: :string, format: :email}, + phone: %Schema{type: :string} + } + }) + end + + defmodule CreateCustomerRequest do + require OpenApiSpex + alias OpenApiSpex.Schema + + OpenApiSpex.schema(%{ + title: "CreateCustomer", + type: :object, + properties: %{ + first_name: %Schema{type: :string}, + last_name: %Schema{type: :string}, + birth_date: %Schema{type: :string, format: :date}, + gender: %Schema{type: :string}, + email: %Schema{type: :string, format: :email}, + phone: %Schema{type: :string} + } + }) + end +end diff --git a/lib/customer_service_web/telemetry.ex b/lib/customer_service_web/telemetry.ex new file mode 100644 index 0000000..5010013 --- /dev/null +++ b/lib/customer_service_web/telemetry.ex @@ -0,0 +1,93 @@ +defmodule CustomerServiceWeb.Telemetry do + use Supervisor + import Telemetry.Metrics + + def start_link(arg) do + Supervisor.start_link(__MODULE__, arg, name: __MODULE__) + end + + @impl true + def init(_arg) do + children = [ + # Telemetry poller will execute the given period measurements + # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics + {:telemetry_poller, measurements: periodic_measurements(), period: 10_000} + # Add reporters as children of your supervision tree. + # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()} + ] + + Supervisor.init(children, strategy: :one_for_one) + end + + def metrics do + [ + # Phoenix Metrics + summary("phoenix.endpoint.start.system_time", + unit: {:native, :millisecond} + ), + summary("phoenix.endpoint.stop.duration", + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.start.system_time", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.exception.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.stop.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.socket_connected.duration", + unit: {:native, :millisecond} + ), + sum("phoenix.socket_drain.count"), + summary("phoenix.channel_joined.duration", + unit: {:native, :millisecond} + ), + summary("phoenix.channel_handled_in.duration", + tags: [:event], + unit: {:native, :millisecond} + ), + + # Database Metrics + summary("customer_service.repo.query.total_time", + unit: {:native, :millisecond}, + description: "The sum of the other measurements" + ), + summary("customer_service.repo.query.decode_time", + unit: {:native, :millisecond}, + description: "The time spent decoding the data received from the database" + ), + summary("customer_service.repo.query.query_time", + unit: {:native, :millisecond}, + description: "The time spent executing the query" + ), + summary("customer_service.repo.query.queue_time", + unit: {:native, :millisecond}, + description: "The time spent waiting for a database connection" + ), + summary("customer_service.repo.query.idle_time", + unit: {:native, :millisecond}, + description: + "The time the connection spent waiting before being checked out for the query" + ), + + # VM Metrics + summary("vm.memory.total", unit: {:byte, :kilobyte}), + summary("vm.total_run_queue_lengths.total"), + summary("vm.total_run_queue_lengths.cpu"), + summary("vm.total_run_queue_lengths.io") + ] + end + + defp periodic_measurements do + [ + # A module, function and arguments to be invoked periodically. + # This function must call :telemetry.execute/3 and a metric must be added above. + # {CustomerServiceWeb, :count_users, []} + ] + end +end diff --git a/mix.exs b/mix.exs new file mode 100644 index 0000000..3cf44e6 --- /dev/null +++ b/mix.exs @@ -0,0 +1,75 @@ +defmodule CustomerService.MixProject do + use Mix.Project + + def project do + [ + app: :customer_service, + version: "0.1.0", + elixir: "~> 1.15", + elixirc_paths: elixirc_paths(Mix.env()), + start_permanent: Mix.env() == :prod, + aliases: aliases(), + deps: deps(), + listeners: [Phoenix.CodeReloader] + ] + end + + # Configuration for the OTP application. + # + # Type `mix help compile.app` for more information. + def application do + [ + mod: {CustomerService.Application, []}, + extra_applications: [:logger, :runtime_tools, :eventstore] + ] + end + + def cli do + [ + preferred_envs: [precommit: :test] + ] + end + + # Specifies which paths to compile per environment. + defp elixirc_paths(:test), do: ["lib", "test/support"] + defp elixirc_paths(_), do: ["lib"] + + # Specifies your project dependencies. + # + # Type `mix help deps` for examples and options. + defp deps do + [ + {:phoenix, "~> 1.8.3"}, + {:phoenix_ecto, "~> 4.5"}, + {:ecto_sql, "~> 3.13"}, + {:postgrex, ">= 0.0.0"}, + {:telemetry_metrics, "~> 1.0"}, + {:telemetry_poller, "~> 1.0"}, + {:jason, "~> 1.2"}, + {:dns_cluster, "~> 0.2.0"}, + {:bandit, "~> 1.5"}, + {:commanded_ecto_projections, "~> 1.4"}, + {:commanded, "~> 1.4"}, + {:eventstore, "~> 1.4"}, + {:open_api_spex, "~> 3.20"}, + {:commanded_eventstore_adapter, "~> 1.4"}, + {:cors_plug, "~> 3.0"} + ] + end + + # Aliases are shortcuts or tasks specific to the current project. + # For example, to install project dependencies and perform other setup tasks, run: + # + # $ mix setup + # + # See the documentation for `Mix` for more info on aliases. + defp aliases do + [ + setup: ["deps.get", "ecto.setup"], + "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"], + "ecto.reset": ["ecto.drop", "ecto.setup"], + test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"], + precommit: ["compile --warnings-as-errors", "deps.unlock --unused", "format", "test"] + ] + end +end diff --git a/mix.lock b/mix.lock new file mode 100644 index 0000000..44c3729 --- /dev/null +++ b/mix.lock @@ -0,0 +1,34 @@ +%{ + "backoff": {:hex, :backoff, "1.1.6", "83b72ed2108ba1ee8f7d1c22e0b4a00cfe3593a67dbc792799e8cce9f42f796b", [:rebar3], [], "hexpm", "cf0cfff8995fb20562f822e5cc47d8ccf664c5ecdc26a684cbe85c225f9d7c39"}, + "bandit": {:hex, :bandit, "1.10.3", "1e5d168fa79ec8de2860d1b4d878d97d4fbbe2fdbe7b0a7d9315a4359d1d4bb9", [:mix], [{:hpax, "~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "99a52d909c48db65ca598e1962797659e3c0f1d06e825a50c3d75b74a5e2db18"}, + "commanded": {:hex, :commanded, "1.4.9", "289bc371943cf082f1161b1560563f5451ca176c967670cccd63fc3988fcd225", [:mix], [{:backoff, "~> 1.1", [hex: :backoff, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_registry, "~> 0.2", [hex: :telemetry_registry, repo: "hexpm", optional: false]}], "hexpm", "a4f49c23041a23687aa10e99f3db7ee3b8ae470bb615b73b9f887b86437263e7"}, + "commanded_ecto_projections": {:hex, :commanded_ecto_projections, "1.4.0", "a1b220577577d5e0aee4c92b2d9bc6de221f9c1ac2ab36932cba15881761332f", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.11", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "8919a6173cd8f30fe2f948c2967f9289c7f5fe4eeca7abc67966bfca31f4aa9f"}, + "commanded_eventstore_adapter": {:hex, :commanded_eventstore_adapter, "1.4.2", "4f2d9d9bd8ef7807a5a4c278b4344adddbbbb4d9c86c693872bc85b944be1fe8", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:eventstore, "~> 1.4", [hex: :eventstore, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "26eaa68515e3e73834d769b73bddfea76c3fdcaff085d735c22b82a66ba19b10"}, + "cors_plug": {:hex, :cors_plug, "3.0.3", "7c3ac52b39624bc616db2e937c282f3f623f25f8d550068b6710e58d04a0e330", [:mix], [{:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3f2d759e8c272ed3835fab2ef11b46bddab8c1ab9528167bd463b6452edf830d"}, + "db_connection": {:hex, :db_connection, "2.9.0", "a6a97c5c958a2d7091a58a9be40caf41ab496b0701d21e1d1abff3fa27a7f371", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "17d502eacaf61829db98facf6f20808ed33da6ccf495354a41e64fe42f9c509c"}, + "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"}, + "dns_cluster": {:hex, :dns_cluster, "0.2.0", "aa8eb46e3bd0326bd67b84790c561733b25c5ba2fe3c7e36f28e88f384ebcb33", [:mix], [], "hexpm", "ba6f1893411c69c01b9e8e8f772062535a4cf70f3f35bcc964a324078d8c8240"}, + "ecto": {:hex, :ecto, "3.13.5", "9d4a69700183f33bf97208294768e561f5c7f1ecf417e0fa1006e4a91713a834", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "df9efebf70cf94142739ba357499661ef5dbb559ef902b68ea1f3c1fabce36de"}, + "ecto_sql": {:hex, :ecto_sql, "3.13.4", "b6e9d07557ddba62508a9ce4a484989a5bb5e9a048ae0e695f6d93f095c25d60", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2b38cf0749ca4d1c5a8bcbff79bbe15446861ca12a61f9fba604486cb6b62a14"}, + "eventstore": {:hex, :eventstore, "1.4.8", "26778c991cfb078f3906a4267060efc7bb5e5943f69ddb8ae6fb60f07042a66e", [:mix], [{:fsm, "~> 0.3", [hex: :fsm, repo: "hexpm", optional: false]}, {:gen_stage, "~> 1.2", [hex: :gen_stage, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.17", [hex: :postgrex, repo: "hexpm", optional: false]}], "hexpm", "30c914602fdea8db5992a90ecb1f84068531e764cf0c066be71ff0eec4e3bcb9"}, + "fsm": {:hex, :fsm, "0.3.1", "087aa9b02779a84320dc7a2d8464452b5308e29877921b2bde81cdba32a12390", [:mix], [], "hexpm", "fbf0d53f89e9082b326b0b5828b94b4c549ff9d1452bbfd00b4d1ac082208e96"}, + "gen_stage": {:hex, :gen_stage, "1.3.2", "7c77e5d1e97de2c6c2f78f306f463bca64bf2f4c3cdd606affc0100b89743b7b", [:mix], [], "hexpm", "0ffae547fa777b3ed889a6b9e1e64566217413d018cabd825f786e843ffe63e7"}, + "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"}, + "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, + "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"}, + "open_api_spex": {:hex, :open_api_spex, "3.22.2", "0b3c4f572ee69cb6c936abf426b9d84d8eebd34960871fd77aead746f0d69cb0", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0 or ~> 6.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "0a4fc08472d75e9cfe96e0748c6b1565b3b4398f97bf43fcce41b41b6fd3fb33"}, + "phoenix": {:hex, :phoenix, "1.8.4", "0387f84f00071cba8d71d930b9121b2fb3645197a9206c31b908d2e7902a4851", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "c988b1cd3b084eebb13e6676d572597d387fa607dab258526637b4e6c4c08543"}, + "phoenix_ecto": {:hex, :phoenix_ecto, "4.7.0", "75c4b9dfb3efdc42aec2bd5f8bccd978aca0651dbcbc7a3f362ea5d9d43153c6", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "1d75011e4254cb4ddf823e81823a9629559a1be93b4321a6a5f11a5306fbf4cc"}, + "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"}, + "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"}, + "plug": {:hex, :plug, "1.19.1", "09bac17ae7a001a68ae393658aa23c7e38782be5c5c00c80be82901262c394c0", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "560a0017a8f6d5d30146916862aaf9300b7280063651dd7e532b8be168511e62"}, + "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"}, + "postgrex": {:hex, :postgrex, "0.22.0", "fb027b58b6eab1f6de5396a2abcdaaeb168f9ed4eccbb594e6ac393b02078cbd", [:mix], [{:db_connection, "~> 2.9", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "a68c4261e299597909e03e6f8ff5a13876f5caadaddd0d23af0d0a61afcc5d84"}, + "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, + "telemetry_metrics": {:hex, :telemetry_metrics, "1.1.0", "5bd5f3b5637e0abea0426b947e3ce5dd304f8b3bc6617039e2b5a008adc02f8f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7b79e8ddfde70adb6db8a6623d1778ec66401f366e9a8f5dd0955c56bc8ce67"}, + "telemetry_poller": {:hex, :telemetry_poller, "1.3.0", "d5c46420126b5ac2d72bc6580fb4f537d35e851cc0f8dbd571acf6d6e10f5ec7", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "51f18bed7128544a50f75897db9974436ea9bfba560420b646af27a9a9b35211"}, + "telemetry_registry": {:hex, :telemetry_registry, "0.3.2", "701576890320be6428189bff963e865e8f23e0ff3615eade8f78662be0fc003c", [:mix, :rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7ed191eb1d115a3034af8e1e35e4e63d5348851d556646d46ca3d1b4e16bab9"}, + "thousand_island": {:hex, :thousand_island, "1.4.3", "2158209580f633be38d43ec4e3ce0a01079592b9657afff9080d5d8ca149a3af", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6e4ce09b0fd761a58594d02814d40f77daff460c48a7354a15ab353bb998ea0b"}, + "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"}, + "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"}, +} diff --git a/priv/repo/migrations/.formatter.exs b/priv/repo/migrations/.formatter.exs new file mode 100644 index 0000000..49f9151 --- /dev/null +++ b/priv/repo/migrations/.formatter.exs @@ -0,0 +1,4 @@ +[ + import_deps: [:ecto_sql], + inputs: ["*.exs"] +] diff --git a/priv/repo/migrations/20260224165602_add_customer_table.exs b/priv/repo/migrations/20260224165602_add_customer_table.exs new file mode 100644 index 0000000..26d8178 --- /dev/null +++ b/priv/repo/migrations/20260224165602_add_customer_table.exs @@ -0,0 +1,19 @@ +defmodule CustomerService.Repo.Migrations.AddCustomerTable do + use Ecto.Migration + + def change do + create table(:customers, primary_key: false) do + add :id, :uuid, primary_key: true + add :first_name, :string + add :last_name, :string + add :birth_date, :date + add :gender, :string + add :email, :string + add :phone, :string + + timestamps() + end + + create index(:customers, [:email]) + end +end diff --git a/priv/repo/migrations/20260224175717_create_projection_versions.exs b/priv/repo/migrations/20260224175717_create_projection_versions.exs new file mode 100644 index 0000000..93861a0 --- /dev/null +++ b/priv/repo/migrations/20260224175717_create_projection_versions.exs @@ -0,0 +1,12 @@ +defmodule CreateProjectionVersions do + use Ecto.Migration + + def change do + create table(:projection_versions, primary_key: false) do + add(:projection_name, :text, primary_key: true) + add(:last_seen_event_number, :bigint) + + timestamps(type: :naive_datetime_usec) + end + end +end diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs new file mode 100644 index 0000000..c08ecba --- /dev/null +++ b/priv/repo/seeds.exs @@ -0,0 +1,11 @@ +# Script for populating the database. You can run it as: +# +# mix run priv/repo/seeds.exs +# +# Inside the script, you can read and write to any of your +# repositories directly: +# +# CustomerService.Repo.insert!(%CustomerService.SomeSchema{}) +# +# We recommend using the bang functions (`insert!`, `update!` +# and so on) as they will fail if something goes wrong. diff --git a/priv/static/favicon.ico b/priv/static/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..7f372bfc21cdd8cb47585339d5fa4d9dd424402f GIT binary patch literal 152 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=@t!V@Ar*{oFEH`~d50E!_s``s q?{G*w(7?#d#v@^nKnY_HKaYb01EZMZjMqTJ89ZJ6T-G@yGywoKK_h|y literal 0 HcmV?d00001 diff --git a/priv/static/robots.txt b/priv/static/robots.txt new file mode 100644 index 0000000..26e06b5 --- /dev/null +++ b/priv/static/robots.txt @@ -0,0 +1,5 @@ +# See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file +# +# To ban all spiders from the entire site uncomment the next two lines: +# User-agent: * +# Disallow: / diff --git a/test/customer_service_web/controllers/error_json_test.exs b/test/customer_service_web/controllers/error_json_test.exs new file mode 100644 index 0000000..c12cd4d --- /dev/null +++ b/test/customer_service_web/controllers/error_json_test.exs @@ -0,0 +1,12 @@ +defmodule CustomerServiceWeb.ErrorJSONTest do + use CustomerServiceWeb.ConnCase, async: true + + test "renders 404" do + assert CustomerServiceWeb.ErrorJSON.render("404.json", %{}) == %{errors: %{detail: "Not Found"}} + end + + test "renders 500" do + assert CustomerServiceWeb.ErrorJSON.render("500.json", %{}) == + %{errors: %{detail: "Internal Server Error"}} + end +end diff --git a/test/support/conn_case.ex b/test/support/conn_case.ex new file mode 100644 index 0000000..d851f7f --- /dev/null +++ b/test/support/conn_case.ex @@ -0,0 +1,38 @@ +defmodule CustomerServiceWeb.ConnCase do + @moduledoc """ + This module defines the test case to be used by + tests that require setting up a connection. + + Such tests rely on `Phoenix.ConnTest` and also + import other functionality to make it easier + to build common data structures and query the data layer. + + Finally, if the test case interacts with the database, + we enable the SQL sandbox, so changes done to the database + are reverted at the end of every test. If you are using + PostgreSQL, you can even run database tests asynchronously + by setting `use CustomerServiceWeb.ConnCase, async: true`, although + this option is not recommended for other databases. + """ + + use ExUnit.CaseTemplate + + using do + quote do + # The default endpoint for testing + @endpoint CustomerServiceWeb.Endpoint + + use CustomerServiceWeb, :verified_routes + + # Import conveniences for testing with connections + import Plug.Conn + import Phoenix.ConnTest + import CustomerServiceWeb.ConnCase + end + end + + setup tags do + CustomerService.DataCase.setup_sandbox(tags) + {:ok, conn: Phoenix.ConnTest.build_conn()} + end +end diff --git a/test/support/data_case.ex b/test/support/data_case.ex new file mode 100644 index 0000000..9768b4d --- /dev/null +++ b/test/support/data_case.ex @@ -0,0 +1,58 @@ +defmodule CustomerService.DataCase do + @moduledoc """ + This module defines the setup for tests requiring + access to the application's data layer. + + You may define functions here to be used as helpers in + your tests. + + Finally, if the test case interacts with the database, + we enable the SQL sandbox, so changes done to the database + are reverted at the end of every test. If you are using + PostgreSQL, you can even run database tests asynchronously + by setting `use CustomerService.DataCase, async: true`, although + this option is not recommended for other databases. + """ + + use ExUnit.CaseTemplate + + using do + quote do + alias CustomerService.Repo + + import Ecto + import Ecto.Changeset + import Ecto.Query + import CustomerService.DataCase + end + end + + setup tags do + CustomerService.DataCase.setup_sandbox(tags) + :ok + end + + @doc """ + Sets up the sandbox based on the test tags. + """ + def setup_sandbox(tags) do + pid = Ecto.Adapters.SQL.Sandbox.start_owner!(CustomerService.Repo, shared: not tags[:async]) + on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end) + end + + @doc """ + A helper that transforms changeset errors into a map of messages. + + assert {:error, changeset} = Accounts.create_user(%{password: "short"}) + assert "password is too short" in errors_on(changeset).password + assert %{password: ["password is too short"]} = errors_on(changeset) + + """ + def errors_on(changeset) do + Ecto.Changeset.traverse_errors(changeset, fn {message, opts} -> + Regex.replace(~r"%{(\w+)}", message, fn _, key -> + opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string() + end) + end) + end +end diff --git a/test/test_helper.exs b/test/test_helper.exs new file mode 100644 index 0000000..df3f452 --- /dev/null +++ b/test/test_helper.exs @@ -0,0 +1,2 @@ +ExUnit.start() +Ecto.Adapters.SQL.Sandbox.mode(CustomerService.Repo, :manual)